kcenon::pacs::storage::node_repository Class Reference

Repository for remote node persistence (legacy SQLite interface) More...

#include <node_repository.h>

Collaboration diagram for kcenon::pacs::storage::node_repository:

Public Member Functions
	node_repository (sqlite3 *db)
	~node_repository ()
	node_repository (const node_repository &)=delete
auto	operator= (const node_repository &) -> node_repository &=delete
	node_repository (node_repository &&) noexcept
auto	operator= (node_repository &&) noexcept -> node_repository &
auto	upsert (const client::remote_node &node) -> Result< int64_t >
auto	find_by_id (std::string_view node_id) const -> std::optional< client::remote_node >
auto	find_by_pk (int64_t pk) const -> std::optional< client::remote_node >
auto	find_all () const -> std::vector< client::remote_node >
auto	find_by_status (client::node_status status) const -> std::vector< client::remote_node >
auto	remove (std::string_view node_id) -> VoidResult
auto	exists (std::string_view node_id) const -> bool
auto	count () const -> size_t
auto	update_status (std::string_view node_id, client::node_status status, std::string_view error_message="") -> VoidResult
auto	update_last_verified (std::string_view node_id) -> VoidResult
auto	is_valid () const noexcept -> bool

Private Member Functions
auto	parse_row (void *stmt) const -> client::remote_node

Private Attributes
sqlite3 *	db_ {nullptr}

Detailed Description

Repository for remote node persistence (legacy SQLite interface)

This is the legacy interface maintained for builds without database_system. New code should use the base_repository version when PACS_WITH_DATABASE_SYSTEM is defined.

Definition at line 177 of file node_repository.h.

Constructor & Destructor Documentation

node_repository() [1/3]

kcenon::pacs::storage::node_repository::node_repository ( sqlite3 * db )

explicit

Definition at line 449 of file node_repository.cpp.

: db_(db) {}

~node_repository()

kcenon::pacs::storage::node_repository::~node_repository ( )

default

node_repository() [2/3]

kcenon::pacs::storage::node_repository::node_repository ( const node_repository & )

delete

node_repository() [3/3]

kcenon::pacs::storage::node_repository::node_repository ( node_repository && )

defaultnoexcept

Member Function Documentation

count()

size_t kcenon::pacs::storage::node_repository::count ( ) const -> size_t

nodiscard

Definition at line 703 of file node_repository.cpp.

                                    {
    if (!db_) return 0;
 
    static constexpr const char* sql = "SELECT COUNT(*) FROM remote_nodes";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return 0;
    }
 
    size_t result = 0;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        result = static_cast<size_t>(sqlite3_column_int64(stmt, 0));
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_.

exists()

bool kcenon::pacs::storage::node_repository::exists ( std::string_view node_id ) const -> bool

nodiscard

Definition at line 686 of file node_repository.cpp.

                                                         {
    if (!db_) return false;
 
    static constexpr const char* sql = "SELECT 1 FROM remote_nodes WHERE node_id = ?";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return false;
    }
 
    sqlite3_bind_text(stmt, 1, node_id.data(), static_cast<int>(node_id.size()), SQLITE_TRANSIENT);
 
    bool found = (sqlite3_step(stmt) == SQLITE_ROW);
    sqlite3_finalize(stmt);
    return found;
}

References db_.

find_all()

std::vector< client::remote_node > kcenon::pacs::storage::node_repository::find_all ( ) const -> std::vector<client::remote_node>

nodiscard

Definition at line 602 of file node_repository.cpp.

                                                             {
    std::vector<client::remote_node> result;
    if (!db_) return result;
 
    static constexpr const char* sql = R"(
        SELECT pk, node_id, name, ae_title, host, port,
               supports_find, supports_move, supports_get, supports_store, supports_worklist,
               connection_timeout_sec, dimse_timeout_sec, max_associations,
               status, last_verified, last_error, last_error_message,
               created_at, updated_at
        FROM remote_nodes ORDER BY name
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return result;
    }
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        result.push_back(parse_row(stmt));
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_row().

Here is the call graph for this function:

find_by_id()

std::optional< client::remote_node > kcenon::pacs::storage::node_repository::find_by_id ( std::string_view node_id ) const -> std::optional<client::remote_node>

nodiscard

Definition at line 546 of file node_repository.cpp.

                                                                                       {
    if (!db_) return std::nullopt;
 
    static constexpr const char* sql = R"(
        SELECT pk, node_id, name, ae_title, host, port,
               supports_find, supports_move, supports_get, supports_store, supports_worklist,
               connection_timeout_sec, dimse_timeout_sec, max_associations,
               status, last_verified, last_error, last_error_message,
               created_at, updated_at
        FROM remote_nodes WHERE node_id = ?
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_text(stmt, 1, node_id.data(), static_cast<int>(node_id.size()), SQLITE_TRANSIENT);
 
    std::optional<client::remote_node> result;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        result = parse_row(stmt);
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_row().

Here is the call graph for this function:

find_by_pk()

std::optional< client::remote_node > kcenon::pacs::storage::node_repository::find_by_pk ( int64_t pk ) const -> std::optional<client::remote_node>

nodiscard

Definition at line 574 of file node_repository.cpp.

                                                                           {
    if (!db_) return std::nullopt;
 
    static constexpr const char* sql = R"(
        SELECT pk, node_id, name, ae_title, host, port,
               supports_find, supports_move, supports_get, supports_store, supports_worklist,
               connection_timeout_sec, dimse_timeout_sec, max_associations,
               status, last_verified, last_error, last_error_message,
               created_at, updated_at
        FROM remote_nodes WHERE pk = ?
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_int64(stmt, 1, pk);
 
    std::optional<client::remote_node> result;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        result = parse_row(stmt);
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_row().

Here is the call graph for this function:

find_by_status()

std::vector< client::remote_node > kcenon::pacs::storage::node_repository::find_by_status ( client::node_status status ) const -> std::vector<client::remote_node>

nodiscard

Definition at line 628 of file node_repository.cpp.

                                    {
    std::vector<client::remote_node> result;
    if (!db_) return result;
 
    static constexpr const char* sql = R"(
        SELECT pk, node_id, name, ae_title, host, port,
               supports_find, supports_move, supports_get, supports_store, supports_worklist,
               connection_timeout_sec, dimse_timeout_sec, max_associations,
               status, last_verified, last_error, last_error_message,
               created_at, updated_at
        FROM remote_nodes WHERE status = ? ORDER BY name
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return result;
    }
 
    auto status_str = std::string(client::to_string(status));
    sqlite3_bind_text(stmt, 1, status_str.c_str(), -1, SQLITE_TRANSIENT);
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        result.push_back(parse_row(stmt));
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, parse_row(), and kcenon::pacs::client::to_string().

Here is the call graph for this function:

is_valid()

bool kcenon::pacs::storage::node_repository::is_valid ( ) const -> bool

nodiscardnoexcept

Definition at line 821 of file node_repository.cpp.

                                              {
    return db_ != nullptr;
}

References db_.

operator=() [1/2]

auto kcenon::pacs::storage::node_repository::operator= ( const node_repository & ) -> node_repository &=delete

delete

operator=() [2/2]

auto kcenon::pacs::storage::node_repository::operator= ( node_repository && ) -> node_repository &

defaultnoexcept

parse_row()

client::remote_node kcenon::pacs::storage::node_repository::parse_row ( void * stmt ) const -> client::remote_node

nodiscardprivate

Definition at line 829 of file node_repository.cpp.

                                                                 {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    client::remote_node node;
 
    int col = 0;
    node.pk = get_int64_column(stmt, col++);
    node.node_id = get_text_column(stmt, col++);
    node.name = get_text_column(stmt, col++);
    node.ae_title = get_text_column(stmt, col++);
    node.host = get_text_column(stmt, col++);
    node.port = static_cast<uint16_t>(get_int_column(stmt, col++, 104));
 
    node.supports_find = get_int_column(stmt, col++) != 0;
    node.supports_move = get_int_column(stmt, col++) != 0;
    node.supports_get = get_int_column(stmt, col++) != 0;
    node.supports_store = get_int_column(stmt, col++) != 0;
    node.supports_worklist = get_int_column(stmt, col++) != 0;
 
    node.connection_timeout = std::chrono::seconds(get_int_column(stmt, col++, 30));
    node.dimse_timeout = std::chrono::seconds(get_int_column(stmt, col++, 60));
    node.max_associations = static_cast<size_t>(get_int_column(stmt, col++, 4));
 
    auto status_str = get_text_column(stmt, col++);
    node.status = client::node_status_from_string(status_str);
 
    auto last_verified_str = get_text_column(stmt, col++);
    node.last_verified = from_timestamp_string(last_verified_str.c_str());
 
    auto last_error_str = get_text_column(stmt, col++);
    node.last_error = from_timestamp_string(last_error_str.c_str());
 
    node.last_error_message = get_text_column(stmt, col++);
 
    auto created_at_str = get_text_column(stmt, col++);
    node.created_at = from_timestamp_string(created_at_str.c_str());
 
    auto updated_at_str = get_text_column(stmt, col++);
    node.updated_at = from_timestamp_string(updated_at_str.c_str());
 
    return node;
}

References kcenon::pacs::client::remote_node::ae_title, kcenon::pacs::client::remote_node::connection_timeout, kcenon::pacs::client::remote_node::created_at, kcenon::pacs::client::remote_node::dimse_timeout, kcenon::pacs::client::remote_node::host, kcenon::pacs::client::remote_node::last_error, kcenon::pacs::client::remote_node::last_error_message, kcenon::pacs::client::remote_node::last_verified, kcenon::pacs::client::remote_node::max_associations, kcenon::pacs::client::remote_node::name, kcenon::pacs::client::remote_node::node_id, kcenon::pacs::client::node_status_from_string(), kcenon::pacs::client::remote_node::pk, kcenon::pacs::client::remote_node::port, kcenon::pacs::client::remote_node::status, kcenon::pacs::client::remote_node::supports_find, kcenon::pacs::client::remote_node::supports_get, kcenon::pacs::client::remote_node::supports_move, kcenon::pacs::client::remote_node::supports_store, kcenon::pacs::client::remote_node::supports_worklist, and kcenon::pacs::client::remote_node::updated_at.

Referenced by find_all(), find_by_id(), find_by_pk(), and find_by_status().

Here is the call graph for this function:

Here is the caller graph for this function:

remove()

VoidResult kcenon::pacs::storage::node_repository::remove ( std::string_view node_id ) -> VoidResult

nodiscard

Definition at line 658 of file node_repository.cpp.

                                                         {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{-1, "Database not initialized", "node_repository"});
    }
 
    static constexpr const char* sql = "DELETE FROM remote_nodes WHERE node_id = ?";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to prepare statement: " + std::string(sqlite3_errmsg(db_)),
            "node_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, node_id.data(), static_cast<int>(node_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to delete: " + std::string(sqlite3_errmsg(db_)),
            "node_repository"});
    }
 
    return kcenon::common::ok();
}

References db_.

update_last_verified()

VoidResult kcenon::pacs::storage::node_repository::update_last_verified ( std::string_view node_id ) -> VoidResult

nodiscard

Definition at line 784 of file node_repository.cpp.

                                                                       {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{-1, "Database not initialized", "node_repository"});
    }
 
    static constexpr const char* sql = R"(
        UPDATE remote_nodes SET
            last_verified = CURRENT_TIMESTAMP,
            updated_at = CURRENT_TIMESTAMP
        WHERE node_id = ?
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to prepare statement: " + std::string(sqlite3_errmsg(db_)),
            "node_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, node_id.data(), static_cast<int>(node_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to update last_verified: " + std::string(sqlite3_errmsg(db_)),
            "node_repository"});
    }
 
    return kcenon::common::ok();
}

References db_.

update_status()

VoidResult kcenon::pacs::storage::node_repository::update_status ( std::string_view node_id, client::node_status status, std::string_view error_message = "" ) -> VoidResult

nodiscard

Definition at line 726 of file node_repository.cpp.

                                  {
 
    if (!db_) {
        return VoidResult(kcenon::common::error_info{-1, "Database not initialized", "node_repository"});
    }
 
    const char* sql = nullptr;
    if (status == client::node_status::error || status == client::node_status::offline) {
        sql = R"(
            UPDATE remote_nodes SET
                status = ?,
                last_error = CURRENT_TIMESTAMP,
                last_error_message = ?,
                updated_at = CURRENT_TIMESTAMP
            WHERE node_id = ?
        )";
    } else {
        sql = R"(
            UPDATE remote_nodes SET
                status = ?,
                updated_at = CURRENT_TIMESTAMP
            WHERE node_id = ?
        )";
    }
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to prepare statement: " + std::string(sqlite3_errmsg(db_)),
            "node_repository"});
    }
 
    auto status_str = std::string(client::to_string(status));
    int idx = 1;
    sqlite3_bind_text(stmt, idx++, status_str.c_str(), -1, SQLITE_TRANSIENT);
 
    if (status == client::node_status::error || status == client::node_status::offline) {
        sqlite3_bind_text(stmt, idx++, error_message.data(),
                          static_cast<int>(error_message.size()), SQLITE_TRANSIENT);
    }
 
    sqlite3_bind_text(stmt, idx++, node_id.data(), static_cast<int>(node_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to update status: " + std::string(sqlite3_errmsg(db_)),
            "node_repository"});
    }
 
    return kcenon::common::ok();
}

References db_, kcenon::pacs::client::error, kcenon::pacs::client::offline, and kcenon::pacs::client::to_string().

Here is the call graph for this function:

upsert()

Result< int64_t > kcenon::pacs::storage::node_repository::upsert ( const client::remote_node & node ) -> Result<int64_t>

nodiscard

Definition at line 461 of file node_repository.cpp.

                                                                     {
    if (!db_) {
        return kcenon::common::make_error<int64_t>(
            -1, "Database not initialized", "node_repository");
    }
 
    static constexpr const char* sql = R"(
        INSERT INTO remote_nodes (
            node_id, name, ae_title, host, port,
            supports_find, supports_move, supports_get, supports_store, supports_worklist,
            connection_timeout_sec, dimse_timeout_sec, max_associations,
            status, last_verified, last_error, last_error_message,
            created_at, updated_at
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)
        ON CONFLICT(node_id) DO UPDATE SET
            name = excluded.name,
            ae_title = excluded.ae_title,
            host = excluded.host,
            port = excluded.port,
            supports_find = excluded.supports_find,
            supports_move = excluded.supports_move,
            supports_get = excluded.supports_get,
            supports_store = excluded.supports_store,
            supports_worklist = excluded.supports_worklist,
            connection_timeout_sec = excluded.connection_timeout_sec,
            dimse_timeout_sec = excluded.dimse_timeout_sec,
            max_associations = excluded.max_associations,
            updated_at = CURRENT_TIMESTAMP
        RETURNING pk
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return kcenon::common::make_error<int64_t>(
            -1, "Failed to prepare statement: " + std::string(sqlite3_errmsg(db_)),
            "node_repository");
    }
 
    int idx = 1;
    sqlite3_bind_text(stmt, idx++, node.node_id.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, node.name.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, node.ae_title.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, node.host.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_int(stmt, idx++, node.port);
    sqlite3_bind_int(stmt, idx++, node.supports_find ? 1 : 0);
    sqlite3_bind_int(stmt, idx++, node.supports_move ? 1 : 0);
    sqlite3_bind_int(stmt, idx++, node.supports_get ? 1 : 0);
    sqlite3_bind_int(stmt, idx++, node.supports_store ? 1 : 0);
    sqlite3_bind_int(stmt, idx++, node.supports_worklist ? 1 : 0);
    sqlite3_bind_int(stmt, idx++, static_cast<int>(node.connection_timeout.count()));
    sqlite3_bind_int(stmt, idx++, static_cast<int>(node.dimse_timeout.count()));
    sqlite3_bind_int(stmt, idx++, static_cast<int>(node.max_associations));
 
    auto status_str = std::string(client::to_string(node.status));
    sqlite3_bind_text(stmt, idx++, status_str.c_str(), -1, SQLITE_TRANSIENT);
 
    auto last_verified_str = to_timestamp_string(node.last_verified);
    if (last_verified_str.empty()) {
        sqlite3_bind_null(stmt, idx++);
    } else {
        sqlite3_bind_text(stmt, idx++, last_verified_str.c_str(), -1, SQLITE_TRANSIENT);
    }
 
    auto last_error_str = to_timestamp_string(node.last_error);
    if (last_error_str.empty()) {
        sqlite3_bind_null(stmt, idx++);
    } else {
        sqlite3_bind_text(stmt, idx++, last_error_str.c_str(), -1, SQLITE_TRANSIENT);
    }
 
    sqlite3_bind_text(stmt, idx++, node.last_error_message.c_str(), -1, SQLITE_TRANSIENT);
 
    int64_t pk = 0;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        pk = sqlite3_column_int64(stmt, 0);
    } else {
        auto err = std::string(sqlite3_errmsg(db_));
        sqlite3_finalize(stmt);
        return kcenon::common::make_error<int64_t>(-1, "Failed to upsert: " + err, "node_repository");
    }
 
    sqlite3_finalize(stmt);
    return kcenon::common::ok(pk);
}

References kcenon::pacs::client::to_string().

Here is the call graph for this function:

Member Data Documentation

db_

sqlite3* kcenon::pacs::storage::node_repository::db_ {nullptr}

private

Definition at line 211 of file node_repository.h.

{nullptr};

Referenced by count(), exists(), find_all(), find_by_id(), find_by_pk(), find_by_status(), is_valid(), remove(), update_last_verified(), and update_status().

---

The documentation for this class was generated from the following files:

• include/kcenon/pacs/storage/node_repository.h
• src/storage/node_repository.cpp