kcenon::pacs::storage::key_image_repository Class Reference

Repository for key image persistence (legacy SQLite interface) More...

#include <key_image_repository.h>

Collaboration diagram for kcenon::pacs::storage::key_image_repository:

Public Member Functions
	key_image_repository (sqlite3 *db)
	~key_image_repository ()
	key_image_repository (const key_image_repository &)=delete
auto	operator= (const key_image_repository &) -> key_image_repository &=delete
	key_image_repository (key_image_repository &&) noexcept
auto	operator= (key_image_repository &&) noexcept -> key_image_repository &
auto	save (const key_image_record &record) -> VoidResult
auto	find_by_id (std::string_view key_image_id) const -> std::optional< key_image_record >
auto	find_by_pk (int64_t pk) const -> std::optional< key_image_record >
auto	find_by_study (std::string_view study_uid) const -> std::vector< key_image_record >
auto	search (const key_image_query &query) const -> std::vector< key_image_record >
auto	remove (std::string_view key_image_id) -> VoidResult
auto	exists (std::string_view key_image_id) const -> bool
auto	count () const -> size_t
auto	count_by_study (std::string_view study_uid) const -> size_t
auto	is_valid () const noexcept -> bool

Private Member Functions
auto	parse_row (void *stmt) const -> key_image_record

Private Attributes
sqlite3 *	db_ {nullptr}

Detailed Description

Repository for key image 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 162 of file key_image_repository.h.

Constructor & Destructor Documentation

key_image_repository() [1/3]

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

explicit

Definition at line 358 of file key_image_repository.cpp.

: db_(db) {}

~key_image_repository()

kcenon::pacs::storage::key_image_repository::~key_image_repository ( )

default

key_image_repository() [2/3]

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

delete

key_image_repository() [3/3]

kcenon::pacs::storage::key_image_repository::key_image_repository ( key_image_repository && )

defaultnoexcept

Member Function Documentation

count()

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

nodiscard

Definition at line 584 of file key_image_repository.cpp.

                                         {
    if (!db_) return 0;
 
    static constexpr const char* sql = "SELECT COUNT(*) FROM key_images";
 
    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));
    }

count_by_study()

size_t kcenon::pacs::storage::key_image_repository::count_by_study ( std::string_view study_uid ) const -> size_t

nodiscard

Definition at line 603 of file key_image_repository.cpp.

                                                                          {
    if (!db_) return 0;
 
    static constexpr const char* sql =
        "SELECT COUNT(*) FROM key_images WHERE study_uid = ?";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return 0;
    }
 
    sqlite3_bind_text(stmt, 1, study_uid.data(),
                      static_cast<int>(study_uid.size()), SQLITE_TRANSIENT);
 
    size_t result = 0;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        result = static_cast<size_t>(sqlite3_column_int64(stmt, 0));
    }

exists()

bool kcenon::pacs::storage::key_image_repository::exists ( std::string_view key_image_id ) const -> bool

nodiscard

Definition at line 565 of file key_image_repository.cpp.

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

Referenced by kcenon::pacs::web::endpoints::register_key_image_endpoints_impl().

Here is the caller graph for this function:

find_by_id()

std::optional< key_image_record > kcenon::pacs::storage::key_image_repository::find_by_id ( std::string_view key_image_id ) const -> std::optional<key_image_record>

nodiscard

Definition at line 421 of file key_image_repository.cpp.

                                       {
    if (!db_) return std::nullopt;
 
    static constexpr const char* sql = R"(
        SELECT pk, key_image_id, study_uid, sop_instance_uid, frame_number,
               user_id, reason, document_title, created_at
        FROM key_images WHERE key_image_id = ?
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_text(stmt, 1, key_image_id.data(),
                      static_cast<int>(key_image_id.size()), SQLITE_TRANSIENT);
 
    std::optional<key_image_record> 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< key_image_record > kcenon::pacs::storage::key_image_repository::find_by_pk ( int64_t pk ) const -> std::optional<key_image_record>

nodiscard

Definition at line 448 of file key_image_repository.cpp.

                      {
    if (!db_) return std::nullopt;
 
    static constexpr const char* sql = R"(
        SELECT pk, key_image_id, study_uid, sop_instance_uid, frame_number,
               user_id, reason, document_title, created_at
        FROM key_images 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<key_image_record> 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_study()

std::vector< key_image_record > kcenon::pacs::storage::key_image_repository::find_by_study ( std::string_view study_uid ) const -> std::vector<key_image_record>

nodiscard

Definition at line 474 of file key_image_repository.cpp.

                                    {
    key_image_query query;
    query.study_uid = std::string(study_uid);
    return search(query);
}

References search().

Referenced by kcenon::pacs::web::endpoints::register_key_image_endpoints_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

is_valid()

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

nodiscardnoexcept

Definition at line 626 of file key_image_repository.cpp.

operator=() [1/2]

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

delete

operator=() [2/2]

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

defaultnoexcept

parse_row()

key_image_record kcenon::pacs::storage::key_image_repository::parse_row ( void * stmt ) const -> key_image_record

nodiscardprivate

Definition at line 628 of file key_image_repository.cpp.

                                                   { return db_ != nullptr; }
 
key_image_record key_image_repository::parse_row(void* stmt_ptr) const {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    key_image_record record;
 
    int col = 0;
    record.pk = get_int64_column(stmt, col++);
    record.key_image_id = get_text_column(stmt, col++);
    record.study_uid = get_text_column(stmt, col++);
    record.sop_instance_uid = get_text_column(stmt, col++);
    record.frame_number = get_optional_int(stmt, col++);
    record.user_id = get_text_column(stmt, col++);
    record.reason = get_text_column(stmt, col++);
    record.document_title = get_text_column(stmt, col++);
 
    auto created_str = get_text_column(stmt, col++);

Referenced by find_by_id(), find_by_pk(), and search().

Here is the caller graph for this function:

remove()

VoidResult kcenon::pacs::storage::key_image_repository::remove ( std::string_view key_image_id ) -> VoidResult

nodiscard

Definition at line 532 of file key_image_repository.cpp.

                                                                   {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "key_image_repository"});
    }
 
    static constexpr const char* sql =
        "DELETE FROM key_images WHERE key_image_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_)),
            "key_image_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, key_image_id.data(),
                      static_cast<int>(key_image_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 key image: " + std::string(sqlite3_errmsg(db_)),
            "key_image_repository"});

Referenced by kcenon::pacs::web::endpoints::register_key_image_endpoints_impl().

Here is the caller graph for this function:

save()

VoidResult kcenon::pacs::storage::key_image_repository::save ( const key_image_record & record ) -> VoidResult

nodiscard

Definition at line 368 of file key_image_repository.cpp.

                                                                    {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "key_image_repository"});
    }
 
    static constexpr const char* sql = R"(
        INSERT INTO key_images (
            key_image_id, study_uid, sop_instance_uid, frame_number,
            user_id, reason, document_title, created_at
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(key_image_id) DO UPDATE SET
            reason = excluded.reason,
            document_title = excluded.document_title
    )";
 
    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_)),
            "key_image_repository"});
    }
 
    auto now_str = to_timestamp_string(std::chrono::system_clock::now());
 
    int idx = 1;
    sqlite3_bind_text(stmt, idx++, record.key_image_id.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, record.study_uid.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, record.sop_instance_uid.c_str(), -1,
                      SQLITE_TRANSIENT);
    bind_optional_int(stmt, idx++, record.frame_number);
    sqlite3_bind_text(stmt, idx++, record.user_id.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, record.reason.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, record.document_title.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, now_str.c_str(), -1, SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return VoidResult(kcenon::common::error_info{
            -1,
            "Failed to save key image: " + std::string(sqlite3_errmsg(db_)),
            "key_image_repository"});
    }
 
    return kcenon::common::ok();
}

Referenced by kcenon::pacs::web::endpoints::register_key_image_endpoints_impl().

Here is the caller graph for this function:

search()

std::vector< key_image_record > kcenon::pacs::storage::key_image_repository::search ( const key_image_query & query ) const -> std::vector<key_image_record>

nodiscard

Definition at line 481 of file key_image_repository.cpp.

                                        {
    std::vector<key_image_record> result;
    if (!db_) return result;
 
    std::ostringstream sql;
    sql << R"(
        SELECT pk, key_image_id, study_uid, sop_instance_uid, frame_number,
               user_id, reason, document_title, created_at
        FROM key_images WHERE 1=1
    )";
 
    std::vector<std::pair<int, std::string>> bindings;
    int param_idx = 1;
 
    if (query.study_uid.has_value()) {
        sql << " AND study_uid = ?";
        bindings.emplace_back(param_idx++, query.study_uid.value());
    }
 
    if (query.sop_instance_uid.has_value()) {
        sql << " AND sop_instance_uid = ?";
        bindings.emplace_back(param_idx++, query.sop_instance_uid.value());
    }
 
    if (query.user_id.has_value()) {
        sql << " AND user_id = ?";
        bindings.emplace_back(param_idx++, query.user_id.value());
    }
 
    sql << " ORDER BY created_at DESC";
 
    if (query.limit > 0) {
        sql << " LIMIT " << query.limit << " OFFSET " << query.offset;
    }
 
    sqlite3_stmt* stmt = nullptr;
    auto sql_str = sql.str();
    if (sqlite3_prepare_v2(db_, sql_str.c_str(), -1, &stmt, nullptr) !=
        SQLITE_OK) {
        return result;
    }
 
    for (const auto& [idx, value] : bindings) {
        sqlite3_bind_text(stmt, idx, value.c_str(), -1, SQLITE_TRANSIENT);
    }
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        result.push_back(parse_row(stmt));
    }

References db_, and parse_row().

Referenced by find_by_study().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

db_

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

private

Definition at line 192 of file key_image_repository.h.

{nullptr};

Referenced by find_by_id(), find_by_pk(), and search().

---

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

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