kcenon::pacs::storage::annotation_repository Class Reference

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

#include <annotation_repository.h>

Collaboration diagram for kcenon::pacs::storage::annotation_repository:

Public Member Functions
	annotation_repository (sqlite3 *db)
	~annotation_repository ()
	annotation_repository (const annotation_repository &)=delete
auto	operator= (const annotation_repository &) -> annotation_repository &=delete
	annotation_repository (annotation_repository &&) noexcept
auto	operator= (annotation_repository &&) noexcept -> annotation_repository &
auto	save (const annotation_record &record) -> VoidResult
auto	find_by_id (std::string_view annotation_id) const -> std::optional< annotation_record >
auto	find_by_pk (int64_t pk) const -> std::optional< annotation_record >
auto	find_by_instance (std::string_view sop_instance_uid) const -> std::vector< annotation_record >
auto	find_by_study (std::string_view study_uid) const -> std::vector< annotation_record >
auto	search (const annotation_query &query) const -> std::vector< annotation_record >
auto	update (const annotation_record &record) -> VoidResult
auto	remove (std::string_view annotation_id) -> VoidResult
auto	exists (std::string_view annotation_id) const -> bool
auto	count () const -> size_t
auto	count (const annotation_query &query) const -> size_t
auto	is_valid () const noexcept -> bool

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

Static Private Member Functions
static auto	serialize_style (const annotation_style &style) -> std::string
static auto	deserialize_style (std::string_view json) -> annotation_style

Private Attributes
sqlite3 *	db_ {nullptr}

Detailed Description

Repository for annotation 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 187 of file annotation_repository.h.

Constructor & Destructor Documentation

annotation_repository() [1/3]

annotation_repository::annotation_repository ( sqlite3 * db )

explicit

Definition at line 625 of file annotation_repository.cpp.

: db_(db) {}

~annotation_repository()

annotation_repository::~annotation_repository ( )

default

annotation_repository() [2/3]

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

delete

annotation_repository() [3/3]

annotation_repository::annotation_repository ( annotation_repository && )

defaultnoexcept

Member Function Documentation

count() [1/2]

auto kcenon::pacs::storage::annotation_repository::count ( ) const -> size_t

nodiscard

count() [2/2]

auto kcenon::pacs::storage::annotation_repository::count ( const annotation_query & query ) const -> size_t

nodiscard

deserialize_style()

annotation_style kcenon::pacs::storage::annotation_repository::deserialize_style ( std::string_view json ) -> annotation_style

staticnodiscardprivate

Definition at line 577 of file annotation_repository.cpp.

References search(), and style.

Here is the call graph for this function:

exists()

bool annotation_repository::exists ( std::string_view annotation_id ) const -> bool

nodiscard

Definition at line 892 of file annotation_repository.cpp.

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

find_by_id()

std::optional< annotation_record > annotation_repository::find_by_id ( std::string_view annotation_id ) const -> std::optional<annotation_record>

nodiscard

Definition at line 690 of file annotation_repository.cpp.

                                        {
    if (!db_) return std::nullopt;
 
    static constexpr const char* sql = R"(
        SELECT pk, annotation_id, study_uid, series_uid, sop_instance_uid, frame_number,
               user_id, annotation_type, geometry_json, text, style_json,
               created_at, updated_at
        FROM annotations WHERE annotation_id = ?
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_text(stmt, 1, annotation_id.data(),
                      static_cast<int>(annotation_id.size()), SQLITE_TRANSIENT);
 
    std::optional<annotation_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_instance()

std::vector< annotation_record > annotation_repository::find_by_instance ( std::string_view sop_instance_uid ) const -> std::vector<annotation_record>

nodiscard

Definition at line 744 of file annotation_repository.cpp.

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

References search().

Here is the call graph for this function:

find_by_pk()

std::optional< annotation_record > annotation_repository::find_by_pk ( int64_t pk ) const -> std::optional<annotation_record>

nodiscard

Definition at line 718 of file annotation_repository.cpp.

                                                                                 {
    if (!db_) return std::nullopt;
 
    static constexpr const char* sql = R"(
        SELECT pk, annotation_id, study_uid, series_uid, sop_instance_uid, frame_number,
               user_id, annotation_type, geometry_json, text, style_json,
               created_at, updated_at
        FROM annotations 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<annotation_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< annotation_record > annotation_repository::find_by_study ( std::string_view study_uid ) const -> std::vector<annotation_record>

nodiscard

Definition at line 751 of file annotation_repository.cpp.

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

References search().

Here is the call graph for this function:

is_valid()

bool annotation_repository::is_valid ( ) const -> bool

nodiscardnoexcept

Definition at line 983 of file annotation_repository.cpp.

operator=() [1/2]

auto annotation_repository::operator= ( annotation_repository && ) -> annotation_repository &

defaultnoexcept

operator=() [2/2]

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

delete

parse_row()

annotation_record annotation_repository::parse_row ( void * stmt ) const -> annotation_record

nodiscardprivate

Definition at line 987 of file annotation_repository.cpp.

                                                    {
    return db_ != nullptr;
}
 
annotation_record annotation_repository::parse_row(void* stmt_ptr) const {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    annotation_record record;
 
    int col = 0;
    record.pk = get_int64_column(stmt, col++);
    record.annotation_id = get_text_column(stmt, col++);
    record.study_uid = get_text_column(stmt, col++);
    record.series_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++);
 
    auto type_str = get_text_column(stmt, col++);
    record.type = annotation_type_from_string(type_str).value_or(annotation_type::text);
 
    record.geometry_json = get_text_column(stmt, col++);
    record.text = get_text_column(stmt, col++);
 
    auto style_json = get_text_column(stmt, col++);
    record.style = deserialize_style(style_json);
 
    auto created_str = get_text_column(stmt, col++);
    record.created_at = from_timestamp_string(created_str.c_str());
 

References db_.

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

Here is the caller graph for this function:

remove()

VoidResult annotation_repository::remove ( std::string_view annotation_id ) -> VoidResult

nodiscard

Definition at line 862 of file annotation_repository.cpp.

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

save()

VoidResult annotation_repository::save ( const annotation_record & record ) -> VoidResult

nodiscard

Definition at line 634 of file annotation_repository.cpp.

                                                                      {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "annotation_repository"});
    }
 
    static constexpr const char* sql = R"(
        INSERT INTO annotations (
            annotation_id, study_uid, series_uid, sop_instance_uid, frame_number,
            user_id, annotation_type, geometry_json, text, style_json,
            created_at, updated_at
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(annotation_id) DO UPDATE SET
            geometry_json = excluded.geometry_json,
            text = excluded.text,
            style_json = excluded.style_json,
            updated_at = excluded.updated_at
    )";
 
    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_)),
            "annotation_repository"});
    }
 
    auto now = std::chrono::system_clock::now();
    auto now_str = to_timestamp_string(now);
    auto style_json = serialize_style(record.style);
 
    int idx = 1;
    sqlite3_bind_text(stmt, idx++, record.annotation_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.series_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++, to_string(record.type).c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, record.geometry_json.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, record.text.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, style_json.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, now_str.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 annotation: " + std::string(sqlite3_errmsg(db_)),
            "annotation_repository"});
    }
 
    return kcenon::common::ok();
}

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

Here is the call graph for this function:

search()

std::vector< annotation_record > annotation_repository::search ( const annotation_query & query ) const -> std::vector<annotation_record>

nodiscard

Definition at line 758 of file annotation_repository.cpp.

                                         {
    std::vector<annotation_record> result;
    if (!db_) return result;
 
    std::ostringstream sql;
    sql << R"(
        SELECT pk, annotation_id, study_uid, series_uid, sop_instance_uid, frame_number,
               user_id, annotation_type, geometry_json, text, style_json,
               created_at, updated_at
        FROM annotations 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.series_uid.has_value()) {
        sql << " AND series_uid = ?";
        bindings.emplace_back(param_idx++, query.series_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());
    }
 
    if (query.type.has_value()) {
        sql << " AND annotation_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 deserialize_style(), find_by_instance(), and find_by_study().

Here is the call graph for this function:

Here is the caller graph for this function:

serialize_style()

std::string kcenon::pacs::storage::annotation_repository::serialize_style ( const annotation_style & style ) -> std::string

staticnodiscardprivate

Definition at line 564 of file annotation_repository.cpp.

                                                                              {
    std::ostringstream oss;
    oss << "{"
        << R"("color":")" << json_escape(style.color) << "\","
        << R"("line_width":)" << style.line_width << ","
        << R"("fill_color":")" << json_escape(style.fill_color) << "\","
        << R"("fill_opacity":)" << style.fill_opacity << ","
        << R"("font_family":")" << json_escape(style.font_family) << "\","
        << R"("font_size":)" << style.font_size
        << "}";
    return oss.str();
}

References style.

update()

VoidResult annotation_repository::update ( const annotation_record & record ) -> VoidResult

nodiscard

Definition at line 818 of file annotation_repository.cpp.

                                                                        {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "annotation_repository"});
    }
 
    static constexpr const char* sql = R"(
        UPDATE annotations SET
            geometry_json = ?,
            text = ?,
            style_json = ?,
            updated_at = ?
        WHERE annotation_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_)),
            "annotation_repository"});
    }
 
    auto now_str = to_timestamp_string(std::chrono::system_clock::now());
    auto style_json = serialize_style(record.style);
 
    int idx = 1;
    sqlite3_bind_text(stmt, idx++, record.geometry_json.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, record.text.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, style_json.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, now_str.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, record.annotation_id.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 update annotation: " + std::string(sqlite3_errmsg(db_)),

Member Data Documentation

db_

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

private

Definition at line 221 of file annotation_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/annotation_repository.h
• src/storage/annotation_repository.cpp