kcenon::pacs::storage::instance_repository Class Reference

Repository for instance metadata persistence (legacy SQLite interface) More...

#include <instance_repository.h>

Collaboration diagram for kcenon::pacs::storage::instance_repository:

Public Member Functions
	instance_repository (sqlite3 *db)
	Construct an instance repository with a raw SQLite database handle.
	~instance_repository ()
	instance_repository (const instance_repository &)=delete
auto	operator= (const instance_repository &) -> instance_repository &=delete
	instance_repository (instance_repository &&) noexcept
auto	operator= (instance_repository &&) noexcept -> instance_repository &
auto	upsert_instance (int64_t series_pk, std::string_view sop_uid, std::string_view sop_class_uid, std::string_view file_path, int64_t file_size, std::string_view transfer_syntax="", std::optional< int > instance_number=std::nullopt) -> Result< int64_t >
	Insert or update an instance record by individual fields.
auto	upsert_instance (const instance_record &record) -> Result< int64_t >
	Insert or update an instance record from an existing record struct.
auto	find_instance (std::string_view sop_uid) const -> std::optional< instance_record >
	Find an instance record by its SOP Instance UID.
auto	find_instance_by_pk (int64_t pk) const -> std::optional< instance_record >
	Find an instance record by its database primary key.
auto	list_instances (std::string_view series_uid) const -> Result< std::vector< instance_record > >
	List all instance records belonging to a given series.
auto	search_instances (const instance_query &query) const -> Result< std::vector< instance_record > >
	Search for instance records matching the given query criteria.
auto	delete_instance (std::string_view sop_uid) -> VoidResult
	Delete an instance record by its SOP Instance UID.
auto	instance_count () const -> Result< size_t >
	Get the total number of instance records in the repository.
auto	instance_count (std::string_view series_uid) const -> Result< size_t >
	Get the number of instance records belonging to a given series.
auto	get_file_path (std::string_view sop_instance_uid) const -> Result< std::optional< std::string > >
	Retrieve the file system path for a stored instance.
auto	get_study_files (std::string_view study_instance_uid) const -> Result< std::vector< std::string > >
	Retrieve all file paths for instances belonging to a study.
auto	get_series_files (std::string_view series_instance_uid) const -> Result< std::vector< std::string > >
	Retrieve all file paths for instances belonging to a series.

Private Member Functions
auto	parse_instance_row (void *stmt) const -> instance_record

Static Private Member Functions
static auto	parse_timestamp (const std::string &str) -> std::chrono::system_clock::time_point

Private Attributes
sqlite3 *	db_ {nullptr}

Detailed Description

Repository for instance metadata persistence (legacy SQLite interface)

Definition at line 194 of file instance_repository.h.

Constructor & Destructor Documentation

instance_repository() [1/3]

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

explicit

Construct an instance repository with a raw SQLite database handle.

Parameters

db	Pointer to the SQLite database connection

Definition at line 719 of file instance_repository.cpp.

: db_(db) {}

~instance_repository()

kcenon::pacs::storage::instance_repository::~instance_repository ( )

default

instance_repository() [2/3]

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

delete

instance_repository() [3/3]

kcenon::pacs::storage::instance_repository::instance_repository ( instance_repository && )

defaultnoexcept

Member Function Documentation

delete_instance()

auto kcenon::pacs::storage::instance_repository::delete_instance ( std::string_view sop_uid ) -> VoidResult

nodiscard

Delete an instance record by its SOP Instance UID.

Parameters

sop_uid

SOP Instance UID of the instance to delete

Returns

VoidResult indicating success or an error

Definition at line 1090 of file instance_repository.cpp.

                  {
    const char* sql = "DELETE FROM instances WHERE sop_uid = ?;";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::monostate>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare delete: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, sop_uid.data(),
                      static_cast<int>(sop_uid.size()), SQLITE_TRANSIENT);
 
    rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        return make_error<std::monostate>(
            rc,
            kcenon::pacs::compat::format("Failed to delete instance: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    return ok();
}

find_instance()

auto kcenon::pacs::storage::instance_repository::find_instance ( std::string_view sop_uid ) const -> std::optional<instance_record>

nodiscard

Find an instance record by its SOP Instance UID.

Parameters

sop_uid

SOP Instance UID to search for

Returns

The matching instance record, or std::nullopt if not found

Definition at line 910 of file instance_repository.cpp.

                                    {
    const char* sql = R"(
        SELECT instance_pk, series_pk, sop_uid, sop_class_uid, instance_number,
               transfer_syntax, content_date, content_time,
               rows, columns, bits_allocated, number_of_frames,
               file_path, file_size, file_hash, created_at
        FROM instances
        WHERE sop_uid = ?;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_text(stmt, 1, sop_uid.data(),
                      static_cast<int>(sop_uid.size()), SQLITE_TRANSIENT);
 
    rc = sqlite3_step(stmt);
    if (rc != SQLITE_ROW) {
        sqlite3_finalize(stmt);
        return std::nullopt;
    }
 
    auto record = parse_instance_row(stmt);
    sqlite3_finalize(stmt);
    return record;
}

find_instance_by_pk()

auto kcenon::pacs::storage::instance_repository::find_instance_by_pk ( int64_t pk ) const -> std::optional<instance_record>

nodiscard

Find an instance record by its database primary key.

Parameters

pk	Primary key of the instance record

Returns

The matching instance record, or std::nullopt if not found

Definition at line 941 of file instance_repository.cpp.

                                    {
    const char* sql = R"(
        SELECT instance_pk, series_pk, sop_uid, sop_class_uid, instance_number,
               transfer_syntax, content_date, content_time,
               rows, columns, bits_allocated, number_of_frames,
               file_path, file_size, file_hash, created_at
        FROM instances
        WHERE instance_pk = ?;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_int64(stmt, 1, pk);
 
    rc = sqlite3_step(stmt);
    if (rc != SQLITE_ROW) {
        sqlite3_finalize(stmt);
        return std::nullopt;
    }
 
    auto record = parse_instance_row(stmt);
    sqlite3_finalize(stmt);
    return record;
}

get_file_path()

auto kcenon::pacs::storage::instance_repository::get_file_path ( std::string_view sop_instance_uid ) const -> Result<std::optional<std::string>>

nodiscard

Retrieve the file system path for a stored instance.

Parameters

sop_instance_uid

SOP Instance UID to look up

Returns

Result containing the file path if found, std::nullopt if the instance exists but has no file, or an error

Definition at line 1173 of file instance_repository.cpp.

                                      {
    const char* sql = "SELECT file_path FROM instances WHERE sop_uid = ?;";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::optional<std::string>>(
            database_query_error,
            kcenon::pacs::compat::format("Failed to prepare query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, sop_instance_uid.data(),
                      static_cast<int>(sop_instance_uid.size()),
                      SQLITE_TRANSIENT);
 
    rc = sqlite3_step(stmt);
    if (rc != SQLITE_ROW) {
        sqlite3_finalize(stmt);
        return ok(std::optional<std::string>(std::nullopt));
    }
 
    auto path = get_text(stmt, 0);
    sqlite3_finalize(stmt);
    return ok(std::optional<std::string>(path));
}

References kcenon::pacs::error_codes::database_query_error.

get_series_files()

auto kcenon::pacs::storage::instance_repository::get_series_files ( std::string_view series_instance_uid ) const -> Result<std::vector<std::string>>

nodiscard

Retrieve all file paths for instances belonging to a series.

Parameters

series_instance_uid

Series Instance UID to look up

Returns

Result containing a vector of file paths, or an error

Definition at line 1237 of file instance_repository.cpp.

                                    {
    std::vector<std::string> results;
 
    const char* sql = R"(
        SELECT i.file_path
        FROM instances i
        JOIN series se ON i.series_pk = se.series_pk
        WHERE se.series_uid = ?
        ORDER BY i.instance_number;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::vector<std::string>>(
            database_query_error,
            kcenon::pacs::compat::format("Failed to prepare query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, series_instance_uid.data(),
                      static_cast<int>(series_instance_uid.size()),
                      SQLITE_TRANSIENT);
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        results.push_back(get_text(stmt, 0));
    }
 
    sqlite3_finalize(stmt);
    return ok(std::move(results));
}

References kcenon::pacs::error_codes::database_query_error.

get_study_files()

auto kcenon::pacs::storage::instance_repository::get_study_files ( std::string_view study_instance_uid ) const -> Result<std::vector<std::string>>

nodiscard

Retrieve all file paths for instances belonging to a study.

Parameters

study_instance_uid

Study Instance UID to look up

Returns

Result containing a vector of file paths, or an error

Definition at line 1202 of file instance_repository.cpp.

                                    {
    std::vector<std::string> results;
 
    const char* sql = R"(
        SELECT i.file_path
        FROM instances i
        JOIN series se ON i.series_pk = se.series_pk
        JOIN studies st ON se.study_pk = st.study_pk
        WHERE st.study_uid = ?
        ORDER BY se.series_number, i.instance_number;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::vector<std::string>>(
            database_query_error,
            kcenon::pacs::compat::format("Failed to prepare query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, study_instance_uid.data(),
                      static_cast<int>(study_instance_uid.size()),
                      SQLITE_TRANSIENT);
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        results.push_back(get_text(stmt, 0));
    }
 
    sqlite3_finalize(stmt);
    return ok(std::move(results));
}

References kcenon::pacs::error_codes::database_query_error.

instance_count() [1/2]

auto kcenon::pacs::storage::instance_repository::instance_count ( ) const -> Result<size_t>

nodiscard

Get the total number of instance records in the repository.

Returns

Result containing the total instance count, or an error

Definition at line 1121 of file instance_repository.cpp.

                                                                 {
    const char* sql = "SELECT COUNT(*) FROM instances;";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<size_t>(
            database_query_error,
            kcenon::pacs::compat::format("Failed to prepare query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    size_t count = 0;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        count = static_cast<size_t>(sqlite3_column_int64(stmt, 0));
    }
 
    sqlite3_finalize(stmt);
    return ok(count);
}

References kcenon::pacs::error_codes::database_query_error, and db_.

instance_count() [2/2]

auto kcenon::pacs::storage::instance_repository::instance_count ( std::string_view series_uid ) const -> Result<size_t>

nodiscard

Get the number of instance records belonging to a given series.

Parameters

series_uid

Series Instance UID to count instances for

Returns

Result containing the instance count for the series, or an error

Definition at line 1143 of file instance_repository.cpp.

                      {
    const char* sql = R"(
        SELECT COUNT(*) FROM instances i
        JOIN series s ON i.series_pk = s.series_pk
        WHERE s.series_uid = ?;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<size_t>(
            database_query_error,
            kcenon::pacs::compat::format("Failed to prepare query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, series_uid.data(),
                      static_cast<int>(series_uid.size()), SQLITE_TRANSIENT);
 
    size_t count = 0;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        count = static_cast<size_t>(sqlite3_column_int64(stmt, 0));
    }
 
    sqlite3_finalize(stmt);
    return ok(count);
}

References kcenon::pacs::error_codes::database_query_error.

list_instances()

auto kcenon::pacs::storage::instance_repository::list_instances ( std::string_view series_uid ) const -> Result<std::vector<instance_record>>

nodiscard

List all instance records belonging to a given series.

Parameters

series_uid

Series Instance UID to filter by

Returns

Result containing a vector of matching instance records, or an error

Definition at line 971 of file instance_repository.cpp.

                                          {
    std::vector<instance_record> results;
 
    const char* sql = R"(
        SELECT i.instance_pk, i.series_pk, i.sop_uid, i.sop_class_uid,
               i.instance_number, i.transfer_syntax, i.content_date,
               i.content_time, i.rows, i.columns, i.bits_allocated,
               i.number_of_frames, i.file_path, i.file_size, i.file_hash,
               i.created_at
        FROM instances i
        JOIN series s ON i.series_pk = s.series_pk
        WHERE s.series_uid = ?
        ORDER BY i.instance_number ASC, i.sop_uid ASC;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::vector<instance_record>>(
            database_query_error,
            kcenon::pacs::compat::format("Failed to prepare query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, series_uid.data(),
                      static_cast<int>(series_uid.size()), SQLITE_TRANSIENT);
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        results.push_back(parse_instance_row(stmt));
    }
 
    sqlite3_finalize(stmt);
    return ok(std::move(results));
}

References kcenon::pacs::error_codes::database_query_error.

operator=() [1/2]

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

delete

operator=() [2/2]

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

defaultnoexcept

parse_instance_row()

auto kcenon::pacs::storage::instance_repository::parse_instance_row ( void * stmt ) const -> instance_record

nodiscardprivate

Definition at line 733 of file instance_repository.cpp.

                       {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    instance_record record;
 
    record.pk = sqlite3_column_int64(stmt, 0);
    record.series_pk = sqlite3_column_int64(stmt, 1);
    record.sop_uid = get_text(stmt, 2);
    record.sop_class_uid = get_text(stmt, 3);
 
    if (sqlite3_column_type(stmt, 4) != SQLITE_NULL) {
        record.instance_number = sqlite3_column_int(stmt, 4);
    }
 
    record.transfer_syntax = get_text(stmt, 5);
    record.content_date = get_text(stmt, 6);
    record.content_time = get_text(stmt, 7);
 
    if (sqlite3_column_type(stmt, 8) != SQLITE_NULL) {
        record.rows = sqlite3_column_int(stmt, 8);
    }
    if (sqlite3_column_type(stmt, 9) != SQLITE_NULL) {
        record.columns = sqlite3_column_int(stmt, 9);
    }
    if (sqlite3_column_type(stmt, 10) != SQLITE_NULL) {
        record.bits_allocated = sqlite3_column_int(stmt, 10);
    }
    if (sqlite3_column_type(stmt, 11) != SQLITE_NULL) {
        record.number_of_frames = sqlite3_column_int(stmt, 11);
    }
 
    record.file_path = get_text(stmt, 12);
    record.file_size = sqlite3_column_int64(stmt, 13);
    record.file_hash = get_text(stmt, 14);
    record.created_at = parse_datetime(get_text(stmt, 15).c_str());
 
    return record;
}

parse_timestamp()

auto kcenon::pacs::storage::instance_repository::parse_timestamp ( const std::string & str ) -> std::chrono::system_clock::time_point

staticnodiscardprivate

Definition at line 728 of file instance_repository.cpp.

                                       {
    return parse_datetime(str.c_str());
}

search_instances()

auto kcenon::pacs::storage::instance_repository::search_instances ( const instance_query & query ) const -> Result<std::vector<instance_record>>

nodiscard

Search for instance records matching the given query criteria.

Parameters

query

Query parameters including optional filters and pagination

Returns

Result containing a vector of matching instance records, or an error

Definition at line 1008 of file instance_repository.cpp.

                                          {
    std::vector<instance_record> results;
 
    std::string sql = R"(
        SELECT i.instance_pk, i.series_pk, i.sop_uid, i.sop_class_uid,
               i.instance_number, i.transfer_syntax, i.content_date,
               i.content_time, i.rows, i.columns, i.bits_allocated,
               i.number_of_frames, i.file_path, i.file_size, i.file_hash,
               i.created_at
        FROM instances i
        JOIN series s ON i.series_pk = s.series_pk
        WHERE 1=1
    )";
 
    std::vector<std::string> params;
 
    if (query.series_uid.has_value()) {
        sql += " AND s.series_uid = ?";
        params.push_back(*query.series_uid);
    }
    if (query.sop_uid.has_value()) {
        sql += " AND i.sop_uid = ?";
        params.push_back(*query.sop_uid);
    }
    if (query.sop_class_uid.has_value()) {
        sql += " AND i.sop_class_uid = ?";
        params.push_back(*query.sop_class_uid);
    }
    if (query.content_date.has_value()) {
        sql += " AND i.content_date = ?";
        params.push_back(*query.content_date);
    }
    if (query.content_date_from.has_value()) {
        sql += " AND i.content_date >= ?";
        params.push_back(*query.content_date_from);
    }
    if (query.content_date_to.has_value()) {
        sql += " AND i.content_date <= ?";
        params.push_back(*query.content_date_to);
    }
 
    sql += " ORDER BY i.instance_number ASC, i.sop_uid ASC";
 
    if (query.limit > 0) {
        sql += kcenon::pacs::compat::format(" LIMIT {}", query.limit);
    }
    if (query.offset > 0) {
        sql += kcenon::pacs::compat::format(" OFFSET {}", query.offset);
    }
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql.c_str(), -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::vector<instance_record>>(
            database_query_error,
            kcenon::pacs::compat::format("Failed to prepare query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    int bind_index = 1;
    for (const auto& param : params) {
        sqlite3_bind_text(stmt, bind_index++, param.c_str(), -1,
                          SQLITE_TRANSIENT);
    }
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        auto record = parse_instance_row(stmt);
        if (query.instance_number.has_value()) {
            if (!record.instance_number.has_value() ||
                *record.instance_number != *query.instance_number) {
                continue;
            }
        }
        results.push_back(std::move(record));
    }
 
    sqlite3_finalize(stmt);
    return ok(std::move(results));
}

References kcenon::pacs::error_codes::database_query_error.

upsert_instance() [1/2]

auto kcenon::pacs::storage::instance_repository::upsert_instance ( const instance_record & record ) -> Result<int64_t>

nodiscard

Insert or update an instance record from an existing record struct.

Parameters

record

The instance record to upsert

Returns

Result containing the primary key of the upserted record, or an error

Definition at line 791 of file instance_repository.cpp.

                       {
    if (record.sop_uid.empty()) {
        return make_error<int64_t>(-1, "SOP Instance UID is required",
                                   "storage");
    }
 
    if (record.sop_uid.length() > 64) {
        return make_error<int64_t>(
            -1, "SOP Instance UID exceeds maximum length of 64 characters",
            "storage");
    }
 
    if (record.series_pk <= 0) {
        return make_error<int64_t>(-1, "Valid series_pk is required",
                                   "storage");
    }
 
    if (record.file_path.empty()) {
        return make_error<int64_t>(-1, "File path is required", "storage");
    }
 
    if (record.file_size < 0) {
        return make_error<int64_t>(-1, "File size must be non-negative",
                                   "storage");
    }
 
    const char* sql = R"(
        INSERT INTO instances (
            series_pk, sop_uid, sop_class_uid, instance_number,
            transfer_syntax, content_date, content_time,
            rows, columns, bits_allocated, number_of_frames,
            file_path, file_size, file_hash
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(sop_uid) DO UPDATE SET
            series_pk = excluded.series_pk,
            sop_class_uid = excluded.sop_class_uid,
            instance_number = excluded.instance_number,
            transfer_syntax = excluded.transfer_syntax,
            content_date = excluded.content_date,
            content_time = excluded.content_time,
            rows = excluded.rows,
            columns = excluded.columns,
            bits_allocated = excluded.bits_allocated,
            number_of_frames = excluded.number_of_frames,
            file_path = excluded.file_path,
            file_size = excluded.file_size,
            file_hash = excluded.file_hash
        RETURNING instance_pk;
    )";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<int64_t>(
            rc,
            kcenon::pacs::compat::format("Failed to prepare statement: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_int64(stmt, 1, record.series_pk);
    sqlite3_bind_text(stmt, 2, record.sop_uid.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 3, record.sop_class_uid.c_str(), -1,
                      SQLITE_TRANSIENT);
 
    if (record.instance_number.has_value()) {
        sqlite3_bind_int(stmt, 4, *record.instance_number);
    } else {
        sqlite3_bind_null(stmt, 4);
    }
 
    sqlite3_bind_text(stmt, 5, record.transfer_syntax.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 6, record.content_date.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 7, record.content_time.c_str(), -1,
                      SQLITE_TRANSIENT);
 
    if (record.rows.has_value()) {
        sqlite3_bind_int(stmt, 8, *record.rows);
    } else {
        sqlite3_bind_null(stmt, 8);
    }
    if (record.columns.has_value()) {
        sqlite3_bind_int(stmt, 9, *record.columns);
    } else {
        sqlite3_bind_null(stmt, 9);
    }
    if (record.bits_allocated.has_value()) {
        sqlite3_bind_int(stmt, 10, *record.bits_allocated);
    } else {
        sqlite3_bind_null(stmt, 10);
    }
    if (record.number_of_frames.has_value()) {
        sqlite3_bind_int(stmt, 11, *record.number_of_frames);
    } else {
        sqlite3_bind_null(stmt, 11);
    }
 
    sqlite3_bind_text(stmt, 12, record.file_path.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_int64(stmt, 13, record.file_size);
    sqlite3_bind_text(stmt, 14, record.file_hash.c_str(), -1, SQLITE_TRANSIENT);
 
    rc = sqlite3_step(stmt);
    if (rc != SQLITE_ROW) {
        auto error_msg = sqlite3_errmsg(db_);
        sqlite3_finalize(stmt);
        return make_error<int64_t>(
            rc,
            kcenon::pacs::compat::format("Failed to upsert instance: {}", error_msg),
            "storage");
    }
 
    auto pk = sqlite3_column_int64(stmt, 0);
    sqlite3_finalize(stmt);
    return pk;
}

upsert_instance() [2/2]

auto kcenon::pacs::storage::instance_repository::upsert_instance ( int64_t series_pk, std::string_view sop_uid, std::string_view sop_class_uid, std::string_view file_path, int64_t file_size, std::string_view transfer_syntax = "", std::optional< int > instance_number = std::nullopt ) -> Result<int64_t>

nodiscard

Insert or update an instance record by individual fields.

Parameters

series_pk	Primary key of the parent series
sop_uid	SOP Instance UID (DICOM tag 0008,0018)
sop_class_uid	SOP Class UID (DICOM tag 0008,0016)
file_path	File system path where the instance is stored
file_size	Size of the stored file in bytes
transfer_syntax	Transfer Syntax UID (DICOM tag 0002,0010), empty if unknown
instance_number	Instance Number (DICOM tag 0020,0013), nullopt if absent

Returns

Result containing the primary key of the upserted record, or an error

Definition at line 772 of file instance_repository.cpp.

                       {
    instance_record record;
    record.series_pk = series_pk;
    record.sop_uid = std::string(sop_uid);
    record.sop_class_uid = std::string(sop_class_uid);
    record.file_path = std::string(file_path);
    record.file_size = file_size;
    record.transfer_syntax = std::string(transfer_syntax);
    record.instance_number = instance_number;
    return upsert_instance(record);
}

Member Data Documentation

db_

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

private

Definition at line 320 of file instance_repository.h.

{nullptr};

Referenced by instance_count().

---

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

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