kcenon::pacs::storage::series_repository Class Reference

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

#include <series_repository.h>

Collaboration diagram for kcenon::pacs::storage::series_repository:

Public Member Functions
	series_repository (sqlite3 *db)
	~series_repository ()
	series_repository (const series_repository &)=delete
auto	operator= (const series_repository &) -> series_repository &=delete
	series_repository (series_repository &&) noexcept
auto	operator= (series_repository &&) noexcept -> series_repository &
auto	upsert_series (int64_t study_pk, std::string_view series_uid, std::string_view modality="", std::optional< int > series_number=std::nullopt, std::string_view series_description="", std::string_view body_part_examined="", std::string_view station_name="") -> Result< int64_t >
auto	upsert_series (const series_record &record) -> Result< int64_t >
auto	find_series (std::string_view series_uid) const -> std::optional< series_record >
auto	find_series_by_pk (int64_t pk) const -> std::optional< series_record >
auto	list_series (std::string_view study_uid) const -> Result< std::vector< series_record > >
auto	search_series (const series_query &query) const -> Result< std::vector< series_record > >
auto	delete_series (std::string_view series_uid) -> VoidResult
auto	series_count () const -> Result< size_t >
auto	series_count (std::string_view study_uid) const -> Result< size_t >

Private Member Functions
auto	parse_series_row (void *stmt) const -> series_record

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

Private Attributes
sqlite3 *	db_ {nullptr}

Detailed Description

Repository for series metadata persistence (legacy SQLite interface)

Definition at line 109 of file series_repository.h.

Constructor & Destructor Documentation

series_repository() [1/3]

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

explicit

Definition at line 575 of file series_repository.cpp.

: db_(db) {}

~series_repository()

kcenon::pacs::storage::series_repository::~series_repository ( )

default

series_repository() [2/3]

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

delete

series_repository() [3/3]

kcenon::pacs::storage::series_repository::series_repository ( series_repository && )

defaultnoexcept

Member Function Documentation

delete_series()

auto kcenon::pacs::storage::series_repository::delete_series ( std::string_view series_uid ) -> VoidResult

nodiscard

Definition at line 897 of file series_repository.cpp.

                  {
    const char* sql = "DELETE FROM series WHERE series_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, series_uid.data(),
                      static_cast<int>(series_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 series: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    return ok();
}

find_series()

auto kcenon::pacs::storage::series_repository::find_series ( std::string_view series_uid ) const -> std::optional<series_record>

nodiscard

Definition at line 727 of file series_repository.cpp.

                                  {
    const char* sql = R"(
        SELECT series_pk, study_pk, series_uid, modality, series_number,
               series_description, body_part_examined, station_name,
               num_instances, created_at, updated_at
        FROM series
        WHERE series_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, series_uid.data(),
                      static_cast<int>(series_uid.size()), SQLITE_TRANSIENT);
 
    rc = sqlite3_step(stmt);
    if (rc != SQLITE_ROW) {
        sqlite3_finalize(stmt);
        return std::nullopt;
    }
 
    auto record = parse_series_row(stmt);
    sqlite3_finalize(stmt);
    return record;
}

find_series_by_pk()

auto kcenon::pacs::storage::series_repository::find_series_by_pk ( int64_t pk ) const -> std::optional<series_record>

nodiscard

Definition at line 757 of file series_repository.cpp.

                                  {
    const char* sql = R"(
        SELECT series_pk, study_pk, series_uid, modality, series_number,
               series_description, body_part_examined, station_name,
               num_instances, created_at, updated_at
        FROM series
        WHERE series_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_series_row(stmt);
    sqlite3_finalize(stmt);
    return record;
}

list_series()

auto kcenon::pacs::storage::series_repository::list_series ( std::string_view study_uid ) const -> Result<std::vector<series_record>>

nodiscard

Definition at line 786 of file series_repository.cpp.

                                        {
    std::vector<series_record> results;
 
    const char* sql = R"(
        SELECT se.series_pk, se.study_pk, se.series_uid, se.modality,
               se.series_number, se.series_description, se.body_part_examined,
               se.station_name, se.num_instances, se.created_at, se.updated_at
        FROM series se
        JOIN studies st ON se.study_pk = st.study_pk
        WHERE st.study_uid = ?
        ORDER BY se.series_number ASC, se.series_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<series_record>>(
            database_query_error,
            kcenon::pacs::compat::format("Failed to prepare query: {}",
                                 sqlite3_errmsg(db_)),
            "storage");
    }
 
    sqlite3_bind_text(stmt, 1, study_uid.data(),
                      static_cast<int>(study_uid.size()), SQLITE_TRANSIENT);
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        results.push_back(parse_series_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::series_repository::operator= ( const series_repository & ) -> series_repository &=delete

delete

operator=() [2/2]

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

defaultnoexcept

parse_series_row()

auto kcenon::pacs::storage::series_repository::parse_series_row ( void * stmt ) const -> series_record

nodiscardprivate

Definition at line 610 of file series_repository.cpp.

                                                                              {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    series_record record;
 
    record.pk = sqlite3_column_int64(stmt, 0);
    record.study_pk = sqlite3_column_int64(stmt, 1);
    record.series_uid = get_text(stmt, 2);
    record.modality = get_text(stmt, 3);
 
    if (sqlite3_column_type(stmt, 4) != SQLITE_NULL) {
        record.series_number = sqlite3_column_int(stmt, 4);
    }
 
    record.series_description = get_text(stmt, 5);
    record.body_part_examined = get_text(stmt, 6);
    record.station_name = get_text(stmt, 7);
    record.num_instances = sqlite3_column_int(stmt, 8);
    record.created_at = parse_datetime(get_text(stmt, 9).c_str());
    record.updated_at = parse_datetime(get_text(stmt, 10).c_str());
 
    return record;
}

parse_timestamp()

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

staticnodiscardprivate

Definition at line 605 of file series_repository.cpp.

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

search_series()

auto kcenon::pacs::storage::series_repository::search_series ( const series_query & query ) const -> Result<std::vector<series_record>>

nodiscard

Definition at line 821 of file series_repository.cpp.

                                        {
    std::vector<series_record> results;
 
    std::string sql = R"(
        SELECT se.series_pk, se.study_pk, se.series_uid, se.modality,
               se.series_number, se.series_description, se.body_part_examined,
               se.station_name, se.num_instances, se.created_at, se.updated_at
        FROM series se
        JOIN studies st ON se.study_pk = st.study_pk
        WHERE 1=1
    )";
 
    std::vector<std::string> params;
 
    if (query.study_uid.has_value()) {
        sql += " AND st.study_uid = ?";
        params.push_back(*query.study_uid);
    }
    if (query.series_uid.has_value()) {
        sql += " AND se.series_uid = ?";
        params.push_back(*query.series_uid);
    }
    if (query.modality.has_value()) {
        sql += " AND se.modality = ?";
        params.push_back(*query.modality);
    }
    if (query.series_description.has_value()) {
        sql += " AND se.series_description LIKE ?";
        params.push_back(to_like_pattern(*query.series_description));
    }
    if (query.body_part_examined.has_value()) {
        sql += " AND se.body_part_examined = ?";
        params.push_back(*query.body_part_examined);
    }
 
    sql += " ORDER BY se.series_number ASC, se.series_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<series_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_series_row(stmt);
        if (query.series_number.has_value()) {
            if (!record.series_number.has_value() ||
                *record.series_number != *query.series_number) {
                continue;
            }
        }
        results.push_back(std::move(record));
    }
 
    sqlite3_finalize(stmt);
    return ok(std::move(results));
}

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

series_count() [1/2]

auto kcenon::pacs::storage::series_repository::series_count ( ) const -> Result<size_t>

nodiscard

Definition at line 928 of file series_repository.cpp.

                                                             {
    const char* sql = "SELECT COUNT(*) FROM series;";
 
    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_.

series_count() [2/2]

auto kcenon::pacs::storage::series_repository::series_count ( std::string_view study_uid ) const -> Result<size_t>

nodiscard

Definition at line 950 of file series_repository.cpp.

                      {
    const char* sql = R"(
        SELECT COUNT(*) FROM series se
        JOIN studies st ON se.study_pk = st.study_pk
        WHERE st.study_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, study_uid.data(),
                      static_cast<int>(study_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.

to_like_pattern()

auto kcenon::pacs::storage::series_repository::to_like_pattern ( std::string_view pattern ) -> std::string

staticnodiscardprivate

Definition at line 584 of file series_repository.cpp.

                 {
    std::string result;
    result.reserve(pattern.size());
 
    for (char c : pattern) {
        if (c == '*') {
            result += '%';
        } else if (c == '?') {
            result += '_';
        } else if (c == '%' || c == '_') {
            result += '\\';
            result += c;
        } else {
            result += c;
        }
    }
 
    return result;
}

upsert_series() [1/2]

auto kcenon::pacs::storage::series_repository::upsert_series ( const series_record & record ) -> Result<int64_t>

nodiscard

Definition at line 652 of file series_repository.cpp.

                       {
    if (record.series_uid.empty()) {
        return make_error<int64_t>(-1, "Series Instance UID is required",
                                   "storage");
    }
 
    if (record.series_uid.length() > 64) {
        return make_error<int64_t>(
            -1, "Series Instance UID exceeds maximum length of 64 characters",
            "storage");
    }
 
    if (record.study_pk <= 0) {
        return make_error<int64_t>(-1, "Valid study_pk is required", "storage");
    }
 
    const char* sql = R"(
        INSERT INTO series (
            study_pk, series_uid, modality, series_number,
            series_description, body_part_examined, station_name,
            updated_at
        ) VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'))
        ON CONFLICT(series_uid) DO UPDATE SET
            study_pk = excluded.study_pk,
            modality = excluded.modality,
            series_number = excluded.series_number,
            series_description = excluded.series_description,
            body_part_examined = excluded.body_part_examined,
            station_name = excluded.station_name,
            updated_at = datetime('now')
        RETURNING series_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.study_pk);
    sqlite3_bind_text(stmt, 2, record.series_uid.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 3, record.modality.c_str(), -1, SQLITE_TRANSIENT);
 
    if (record.series_number.has_value()) {
        sqlite3_bind_int(stmt, 4, *record.series_number);
    } else {
        sqlite3_bind_null(stmt, 4);
    }
 
    sqlite3_bind_text(stmt, 5, record.series_description.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 6, record.body_part_examined.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 7, record.station_name.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 series: {}", error_msg),
            "storage");
    }
 
    auto pk = sqlite3_column_int64(stmt, 0);
    sqlite3_finalize(stmt);
    return pk;
}

upsert_series() [2/2]

auto kcenon::pacs::storage::series_repository::upsert_series ( int64_t study_pk, std::string_view series_uid, std::string_view modality = "", std::optional< int > series_number = std::nullopt, std::string_view series_description = "", std::string_view body_part_examined = "", std::string_view station_name = "" ) -> Result<int64_t>

nodiscard

Definition at line 633 of file series_repository.cpp.

                       {
    series_record record;
    record.study_pk = study_pk;
    record.series_uid = std::string(series_uid);
    record.modality = std::string(modality);
    record.series_number = series_number;
    record.series_description = std::string(series_description);
    record.body_part_examined = std::string(body_part_examined);
    record.station_name = std::string(station_name);
    return upsert_series(record);
}

Member Data Documentation

db_

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

private

Definition at line 150 of file series_repository.h.

{nullptr};

Referenced by series_count().

---

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

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