kcenon::pacs::storage::measurement_repository Class Reference

Repository for measurement persistence (legacy SQLite interface) More...

#include <measurement_repository.h>

Collaboration diagram for kcenon::pacs::storage::measurement_repository:

Public Member Functions
	measurement_repository (sqlite3 *db)
	~measurement_repository ()
	measurement_repository (const measurement_repository &)=delete
auto	operator= (const measurement_repository &) -> measurement_repository &=delete
	measurement_repository (measurement_repository &&) noexcept
auto	operator= (measurement_repository &&) noexcept -> measurement_repository &
auto	save (const measurement_record &record) -> VoidResult
auto	find_by_id (std::string_view measurement_id) const -> std::optional< measurement_record >
auto	find_by_pk (int64_t pk) const -> std::optional< measurement_record >
auto	find_by_instance (std::string_view sop_instance_uid) const -> std::vector< measurement_record >
auto	search (const measurement_query &query) const -> std::vector< measurement_record >
auto	remove (std::string_view measurement_id) -> VoidResult
auto	exists (std::string_view measurement_id) const -> bool
auto	count () const -> size_t
auto	count (const measurement_query &query) const -> size_t
auto	is_valid () const noexcept -> bool

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

Private Attributes
sqlite3 *	db_ {nullptr}

Detailed Description

Repository for measurement 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 166 of file measurement_repository.h.

Constructor & Destructor Documentation

measurement_repository() [1/3]

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

explicit

Definition at line 420 of file measurement_repository.cpp.

: db_(db) {}

~measurement_repository()

kcenon::pacs::storage::measurement_repository::~measurement_repository ( )

default

measurement_repository() [2/3]

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

delete

measurement_repository() [3/3]

kcenon::pacs::storage::measurement_repository::measurement_repository ( measurement_repository && )

defaultnoexcept

Member Function Documentation

count() [1/2]

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

nodiscard

Definition at line 650 of file measurement_repository.cpp.

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

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

Here is the caller graph for this function:

count() [2/2]

size_t kcenon::pacs::storage::measurement_repository::count ( const measurement_query & query ) const -> size_t

nodiscard

Definition at line 669 of file measurement_repository.cpp.

                                                                         {
    if (!db_) return 0;
 
    std::ostringstream sql;
    sql << "SELECT COUNT(*) FROM measurements WHERE 1=1";
 
    std::vector<std::pair<int, std::string>> bindings;
    int param_idx = 1;
 
    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());
    }
 
    if (query.type.has_value()) {
        sql << " AND measurement_type = ?";
        bindings.emplace_back(param_idx++, to_string(query.type.value()));
    }
 
    sqlite3_stmt* stmt = nullptr;
    auto sql_str = sql.str();
    if (sqlite3_prepare_v2(db_, sql_str.c_str(), -1, &stmt, nullptr) !=
        SQLITE_OK) {
        return 0;
    }
 
    for (const auto& [idx, value] : bindings) {
        sqlite3_bind_text(stmt, idx, value.c_str(), -1, 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::measurement_repository::exists ( std::string_view measurement_id ) const -> bool

nodiscard

Definition at line 631 of file measurement_repository.cpp.

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

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

Here is the caller graph for this function:

find_by_id()

std::optional< measurement_record > kcenon::pacs::storage::measurement_repository::find_by_id ( std::string_view measurement_id ) const -> std::optional<measurement_record>

nodiscard

Definition at line 487 of file measurement_repository.cpp.

                                         {
    if (!db_) return std::nullopt;
 
    static constexpr const char* sql = R"(
        SELECT pk, measurement_id, sop_instance_uid, frame_number, user_id,
               measurement_type, geometry_json, value, unit, label, created_at
        FROM measurements WHERE measurement_id = ?
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_text(stmt, 1, measurement_id.data(),
                      static_cast<int>(measurement_id.size()), SQLITE_TRANSIENT);
 
    std::optional<measurement_record> result;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        result = parse_row(stmt);
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_row().

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

Here is the call graph for this function:

Here is the caller graph for this function:

find_by_instance()

std::vector< measurement_record > kcenon::pacs::storage::measurement_repository::find_by_instance ( std::string_view sop_instance_uid ) const -> std::vector<measurement_record>

nodiscard

Definition at line 540 of file measurement_repository.cpp.

                                           {
    measurement_query query;
    query.sop_instance_uid = std::string(sop_instance_uid);
    return search(query);
}

References search().

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

Here is the call graph for this function:

Here is the caller graph for this function:

find_by_pk()

std::optional< measurement_record > kcenon::pacs::storage::measurement_repository::find_by_pk ( int64_t pk ) const -> std::optional<measurement_record>

nodiscard

Definition at line 514 of file measurement_repository.cpp.

                      {
    if (!db_) return std::nullopt;
 
    static constexpr const char* sql = R"(
        SELECT pk, measurement_id, sop_instance_uid, frame_number, user_id,
               measurement_type, geometry_json, value, unit, label, created_at
        FROM measurements 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<measurement_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:

is_valid()

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

nodiscardnoexcept

Definition at line 713 of file measurement_repository.cpp.

operator=() [1/2]

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

delete

operator=() [2/2]

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

defaultnoexcept

parse_row()

measurement_record kcenon::pacs::storage::measurement_repository::parse_row ( void * stmt ) const -> measurement_record

nodiscardprivate

Definition at line 717 of file measurement_repository.cpp.

                                                     {
    return db_ != nullptr;
}
 
measurement_record measurement_repository::parse_row(void* stmt_ptr) const {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    measurement_record record;
 
    int col = 0;
    record.pk = get_int64_column(stmt, col++);
    record.measurement_id = 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++);
 
    auto type_str = get_text_column(stmt, col++);
    record.type =
        measurement_type_from_string(type_str).value_or(measurement_type::length);
 
    record.geometry_json = get_text_column(stmt, col++);
    record.value = get_double_column(stmt, col++);
    record.unit = get_text_column(stmt, col++);
    record.label = get_text_column(stmt, col++);
 
    auto created_str = get_text_column(stmt, col++);

References db_.

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

Here is the caller graph for this function:

remove()

VoidResult kcenon::pacs::storage::measurement_repository::remove ( std::string_view measurement_id ) -> VoidResult

nodiscard

Definition at line 598 of file measurement_repository.cpp.

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

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

Here is the caller graph for this function:

save()

VoidResult kcenon::pacs::storage::measurement_repository::save ( const measurement_record & record ) -> VoidResult

nodiscard

Definition at line 430 of file measurement_repository.cpp.

                                                                        {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "measurement_repository"});
    }
 
    static constexpr const char* sql = R"(
        INSERT INTO measurements (
            measurement_id, sop_instance_uid, frame_number, user_id,
            measurement_type, geometry_json, value, unit, label, created_at
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(measurement_id) DO UPDATE SET
            geometry_json = excluded.geometry_json,
            value = excluded.value,
            unit = excluded.unit,
            label = excluded.label
    )";
 
    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_)),
            "measurement_repository"});
    }
 
    auto now_str = to_timestamp_string(std::chrono::system_clock::now());
 
    int idx = 1;
    sqlite3_bind_text(stmt, idx++, record.measurement_id.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++, to_string(record.type).c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, record.geometry_json.c_str(), -1,
                      SQLITE_TRANSIENT);
    sqlite3_bind_double(stmt, idx++, record.value);
    sqlite3_bind_text(stmt, idx++, record.unit.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, record.label.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 measurement: " + std::string(sqlite3_errmsg(db_)),
            "measurement_repository"});
    }
 
    return kcenon::common::ok();
}

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

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

Here is the call graph for this function:

Here is the caller graph for this function:

search()

std::vector< measurement_record > kcenon::pacs::storage::measurement_repository::search ( const measurement_query & query ) const -> std::vector<measurement_record>

nodiscard

Definition at line 547 of file measurement_repository.cpp.

                                          {
    std::vector<measurement_record> result;
    if (!db_) return result;
 
    std::ostringstream sql;
    sql << R"(
        SELECT pk, measurement_id, sop_instance_uid, frame_number, user_id,
               measurement_type, geometry_json, value, unit, label, created_at
        FROM measurements WHERE 1=1
    )";
 
    std::vector<std::pair<int, std::string>> bindings;
    int param_idx = 1;
 
    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());
    }
 
    if (query.type.has_value()) {
        sql << " AND measurement_type = ?";
        bindings.emplace_back(param_idx++, to_string(query.type.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_, parse_row(), and kcenon::pacs::storage::to_string().

Referenced by find_by_instance(), and kcenon::pacs::web::endpoints::register_measurement_endpoints_impl().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

db_

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

private

Definition at line 196 of file measurement_repository.h.

{nullptr};

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

---

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

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