kcenon::pacs::storage::prefetch_repository Class Reference

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

#include <prefetch_repository.h>

Collaboration diagram for kcenon::pacs::storage::prefetch_repository:

Public Member Functions
	prefetch_repository (sqlite3 *db)
	~prefetch_repository ()
	prefetch_repository (const prefetch_repository &)=delete
auto	operator= (const prefetch_repository &) -> prefetch_repository &=delete
	prefetch_repository (prefetch_repository &&) noexcept
auto	operator= (prefetch_repository &&) noexcept -> prefetch_repository &
auto	save_rule (const client::prefetch_rule &rule) -> VoidResult
auto	find_rule_by_id (std::string_view rule_id) const -> std::optional< client::prefetch_rule >
auto	find_rule_by_pk (int64_t pk) const -> std::optional< client::prefetch_rule >
auto	find_rules (const prefetch_rule_query_options &options={}) const -> std::vector< client::prefetch_rule >
auto	find_enabled_rules () const -> std::vector< client::prefetch_rule >
auto	remove_rule (std::string_view rule_id) -> VoidResult
auto	rule_exists (std::string_view rule_id) const -> bool
auto	increment_triggered (std::string_view rule_id) -> VoidResult
auto	increment_studies_prefetched (std::string_view rule_id, size_t count=1) -> VoidResult
auto	enable_rule (std::string_view rule_id) -> VoidResult
auto	disable_rule (std::string_view rule_id) -> VoidResult
auto	save_history (const client::prefetch_history &history) -> VoidResult
auto	find_history (const prefetch_history_query_options &options={}) const -> std::vector< client::prefetch_history >
auto	is_study_prefetched (std::string_view study_uid) const -> bool
auto	count_completed_today () const -> size_t
auto	count_failed_today () const -> size_t
auto	update_history_status (std::string_view study_uid, std::string_view status) -> VoidResult
auto	cleanup_old_history (std::chrono::hours max_age) -> Result< size_t >
auto	rule_count () const -> size_t
auto	enabled_rule_count () const -> size_t
auto	history_count () const -> size_t
auto	is_valid () const noexcept -> bool
auto	initialize_tables () -> VoidResult

Private Member Functions
auto	parse_rule_row (void *stmt) const -> client::prefetch_rule
auto	parse_history_row (void *stmt) const -> client::prefetch_history

Static Private Member Functions
static auto	serialize_modalities (const std::vector< std::string > &modalities) -> std::string
static auto	deserialize_modalities (std::string_view json) -> std::vector< std::string >
static auto	serialize_node_ids (const std::vector< std::string > &node_ids) -> std::string
static auto	deserialize_node_ids (std::string_view json) -> std::vector< std::string >

Private Attributes
sqlite3 *	db_ {nullptr}

Detailed Description

Repository for prefetch persistence (legacy SQLite interface)

Definition at line 414 of file prefetch_repository.h.

Constructor & Destructor Documentation

prefetch_repository() [1/3]

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

explicit

Definition at line 1034 of file prefetch_repository.cpp.

: db_(db) {}

~prefetch_repository()

kcenon::pacs::storage::prefetch_repository::~prefetch_repository ( )

default

prefetch_repository() [2/3]

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

delete

prefetch_repository() [3/3]

kcenon::pacs::storage::prefetch_repository::prefetch_repository ( prefetch_repository && )

defaultnoexcept

Member Function Documentation

cleanup_old_history()

Result< size_t > kcenon::pacs::storage::prefetch_repository::cleanup_old_history ( std::chrono::hours max_age ) -> Result<size_t>

nodiscard

Definition at line 1707 of file prefetch_repository.cpp.

                           {
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to update status: " + std::string(sqlite3_errmsg(db_)),
            "prefetch_repository"});
    }
 
    return kcenon::common::ok();
}
 
Result<size_t> prefetch_repository::cleanup_old_history(std::chrono::hours max_age) {
    if (!db_) {
        return Result<size_t>(kcenon::common::error_info{
            -1, "Database not initialized", "prefetch_repository"});
    }
 
    // Calculate cutoff timestamp
    auto cutoff = std::chrono::system_clock::now() - max_age;
    auto cutoff_str = to_timestamp_string(cutoff);
 
    static constexpr const char* sql = R"(
        DELETE FROM prefetch_history WHERE prefetched_at < ?
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return Result<size_t>(kcenon::common::error_info{
            -1, "Failed to prepare statement: " + std::string(sqlite3_errmsg(db_)),
            "prefetch_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, cutoff_str.c_str(), -1, SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);

References db_.

count_completed_today()

size_t kcenon::pacs::storage::prefetch_repository::count_completed_today ( ) const -> size_t

nodiscard

Definition at line 1627 of file prefetch_repository.cpp.

                                                        {
    if (!db_) return 0;
 
    static constexpr const char* sql = R"(
        SELECT COUNT(*) FROM prefetch_history
        WHERE status = 'completed'
        AND date(prefetched_at) = date('now')
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return 0;

count_failed_today()

size_t kcenon::pacs::storage::prefetch_repository::count_failed_today ( ) const -> size_t

nodiscard

Definition at line 1650 of file prefetch_repository.cpp.

                                          {
        result = static_cast<size_t>(sqlite3_column_int64(stmt, 0));
    }
 
    sqlite3_finalize(stmt);
    return result;
}
 
size_t prefetch_repository::count_failed_today() const {
    if (!db_) return 0;
 
    static constexpr const char* sql = R"(
        SELECT COUNT(*) FROM prefetch_history
        WHERE status = 'failed'
        AND date(prefetched_at) = date('now')
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return 0;

deserialize_modalities()

std::vector< std::string > kcenon::pacs::storage::prefetch_repository::deserialize_modalities ( std::string_view json ) -> std::vector<std::string>

staticnodiscardprivate

Definition at line 1002 of file prefetch_repository.cpp.

                         {
    std::vector<std::string> result;
    if (json.empty() || json == "[]") return result;
 
    size_t pos = 0;
    while (pos < json.size()) {
        auto [value, next_pos] = extract_json_string(json, pos);
        if (next_pos == std::string_view::npos) break;
        if (!value.empty()) {
            result.push_back(value);
        }
        pos = next_pos;
    }
 
    return result;
}

Referenced by deserialize_node_ids().

Here is the caller graph for this function:

deserialize_node_ids()

std::vector< std::string > kcenon::pacs::storage::prefetch_repository::deserialize_node_ids ( std::string_view json ) -> std::vector<std::string>

staticnodiscardprivate

Definition at line 1025 of file prefetch_repository.cpp.

                         {
    return deserialize_modalities(json);  // Same format
}

References deserialize_modalities().

Here is the call graph for this function:

disable_rule()

VoidResult kcenon::pacs::storage::prefetch_repository::disable_rule ( std::string_view rule_id ) -> VoidResult

nodiscard

Definition at line 1481 of file prefetch_repository.cpp.

                                      : " + std::string(sqlite3_errmsg(db_)),
            "prefetch_repository"});
    }
 
    return kcenon::common::ok();
}
 
VoidResult prefetch_repository::disable_rule(std::string_view rule_id) {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "prefetch_repository"});
    }
 
    static constexpr const char* sql = R"(
        UPDATE prefetch_rules SET
            enabled = 0,
            updated_at = CURRENT_TIMESTAMP
        WHERE rule_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_)),
            "prefetch_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, rule_id.data(), static_cast<int>(rule_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {

enable_rule()

VoidResult kcenon::pacs::storage::prefetch_repository::enable_rule ( std::string_view rule_id ) -> VoidResult

nodiscard

Definition at line 1447 of file prefetch_repository.cpp.

                                                       : " + std::string(sqlite3_errmsg(db_)),
            "prefetch_repository"});
    }
 
    return kcenon::common::ok();
}
 
VoidResult prefetch_repository::enable_rule(std::string_view rule_id) {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "prefetch_repository"});
    }
 
    static constexpr const char* sql = R"(
        UPDATE prefetch_rules SET
            enabled = 1,
            updated_at = CURRENT_TIMESTAMP
        WHERE rule_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_)),
            "prefetch_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, rule_id.data(), static_cast<int>(rule_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {

enabled_rule_count()

size_t kcenon::pacs::storage::prefetch_repository::enabled_rule_count ( ) const -> size_t

nodiscard

Definition at line 1765 of file prefetch_repository.cpp.

                                          {
        result = static_cast<size_t>(sqlite3_column_int64(stmt, 0));
    }
 
    sqlite3_finalize(stmt);
    return result;
}
 
size_t prefetch_repository::enabled_rule_count() const {
    if (!db_) return 0;
 
    static constexpr const char* sql = "SELECT COUNT(*) FROM prefetch_rules WHERE enabled = 1";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return 0;

find_enabled_rules()

std::vector< client::prefetch_rule > kcenon::pacs::storage::prefetch_repository::find_enabled_rules ( ) const -> std::vector<client::prefetch_rule>

nodiscard

Definition at line 1322 of file prefetch_repository.cpp.

find_history()

std::vector< client::prefetch_history > kcenon::pacs::storage::prefetch_repository::find_history ( const prefetch_history_query_options & options = {} ) const -> std::vector<client::prefetch_history>

nodiscard

Definition at line 1570 of file prefetch_repository.cpp.

                                       : " + std::string(sqlite3_errmsg(db_)),
            "prefetch_repository"});
    }
 
    return kcenon::common::ok();
}
 
std::vector<client::prefetch_history> prefetch_repository::find_history(
    const prefetch_history_query_options& options) const {
    std::vector<client::prefetch_history> result;
    if (!db_) return result;
 
    std::ostringstream sql;
    sql << R"(
        SELECT pk, patient_id, study_uid, rule_id, source_node_id, job_id, status, prefetched_at
        FROM prefetch_history WHERE 1=1
    )";
 
    if (options.patient_id.has_value()) {
        sql << " AND patient_id = '" << options.patient_id.value() << "'";
    }
 
    if (options.rule_id.has_value()) {
        sql << " AND rule_id = '" << options.rule_id.value() << "'";
    }
 
    if (options.status.has_value()) {
        sql << " AND status = '" << options.status.value() << "'";
    }
 
    sql << " ORDER BY prefetched_at DESC";
    sql << " LIMIT " << options.limit << " OFFSET " << options.offset;
 
    sqlite3_stmt* stmt = nullptr;
    auto sql_str = sql.str();
    if (sqlite3_prepare_v2(db_, sql_str.c_str(), -1, &stmt, nullptr) != SQLITE_OK) {

find_rule_by_id()

std::optional< client::prefetch_rule > kcenon::pacs::storage::prefetch_repository::find_rule_by_id ( std::string_view rule_id ) const -> std::optional<client::prefetch_rule>

nodiscard

Definition at line 1232 of file prefetch_repository.cpp.

                                  {
    if (!db_) return std::nullopt;
 
    static constexpr const char* sql = R"(
        SELECT pk, rule_id, name, enabled, trigger_type,
               modality_filter, body_part_filter, station_ae_filter,
               prior_lookback_hours, max_prior_studies, prior_modalities_json,
               source_node_ids_json, schedule_cron, advance_time_minutes,
               triggered_count, studies_prefetched, last_triggered
        FROM prefetch_rules WHERE rule_id = ?
    )";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return std::nullopt;
    }
 
    sqlite3_bind_text(stmt, 1, rule_id.data(), static_cast<int>(rule_id.size()), SQLITE_TRANSIENT);
 
    std::optional<client::prefetch_rule> result;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        result = parse_rule_row(stmt);
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_rule_row().

Here is the call graph for this function:

find_rule_by_pk()

std::optional< client::prefetch_rule > kcenon::pacs::storage::prefetch_repository::find_rule_by_pk ( int64_t pk ) const -> std::optional<client::prefetch_rule>

nodiscard

Definition at line 1261 of file prefetch_repository.cpp.

                                                                                      {
    if (!db_) return std::nullopt;
 
    static constexpr const char* sql = R"(
        SELECT pk, rule_id, name, enabled, trigger_type,
               modality_filter, body_part_filter, station_ae_filter,
               prior_lookback_hours, max_prior_studies, prior_modalities_json,
               source_node_ids_json, schedule_cron, advance_time_minutes,
               triggered_count, studies_prefetched, last_triggered
        FROM prefetch_rules 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<client::prefetch_rule> result;
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        result = parse_rule_row(stmt);
    }
 
    sqlite3_finalize(stmt);
    return result;
}

References db_, and parse_rule_row().

Here is the call graph for this function:

find_rules()

std::vector< client::prefetch_rule > kcenon::pacs::storage::prefetch_repository::find_rules ( const prefetch_rule_query_options & options = {} ) const -> std::vector<client::prefetch_rule>

nodiscard

Definition at line 1289 of file prefetch_repository.cpp.

                                                      {
    std::vector<client::prefetch_rule> result;
    if (!db_) return result;
 
    std::ostringstream sql;
    sql << R"(
        SELECT pk, rule_id, name, enabled, trigger_type,
               modality_filter, body_part_filter, station_ae_filter,
               prior_lookback_hours, max_prior_studies, prior_modalities_json,
               source_node_ids_json, schedule_cron, advance_time_minutes,
               triggered_count, studies_prefetched, last_triggered
        FROM prefetch_rules WHERE 1=1
    )";
 
    if (options.enabled_only.has_value()) {
        sql << " AND enabled = " << (options.enabled_only.value() ? "1" : "0");
    }
 
    if (options.trigger.has_value()) {
        sql << " AND trigger_type = '" << client::to_string(options.trigger.value()) << "'";
    }
 
    sql << " ORDER BY created_at DESC";
    sql << " LIMIT " << options.limit << " OFFSET " << options.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;
    }
 

References db_, and kcenon::pacs::client::to_string().

Referenced by remove_rule().

Here is the call graph for this function:

Here is the caller graph for this function:

history_count()

size_t kcenon::pacs::storage::prefetch_repository::history_count ( ) const -> size_t

nodiscard

Definition at line 1784 of file prefetch_repository.cpp.

                                          {
        result = static_cast<size_t>(sqlite3_column_int64(stmt, 0));
    }
 
    sqlite3_finalize(stmt);
    return result;
}
 
size_t prefetch_repository::history_count() const {
    if (!db_) return 0;
 
    static constexpr const char* sql = "SELECT COUNT(*) FROM prefetch_history";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return 0;

increment_studies_prefetched()

VoidResult kcenon::pacs::storage::prefetch_repository::increment_studies_prefetched ( std::string_view rule_id, size_t count = 1 ) -> VoidResult

nodiscard

Definition at line 1412 of file prefetch_repository.cpp.

                                              : " + std::string(sqlite3_errmsg(db_)),
            "prefetch_repository"});
    }
 
    return kcenon::common::ok();
}
 
VoidResult prefetch_repository::increment_studies_prefetched(
    std::string_view rule_id, size_t count) {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "prefetch_repository"});
    }
 
    static constexpr const char* sql = R"(
        UPDATE prefetch_rules SET
            studies_prefetched = studies_prefetched + ?
        WHERE rule_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_)),
            "prefetch_repository"});
    }
 
    sqlite3_bind_int64(stmt, 1, static_cast<int64_t>(count));
    sqlite3_bind_text(stmt, 2, rule_id.data(), static_cast<int>(rule_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {

increment_triggered()

VoidResult kcenon::pacs::storage::prefetch_repository::increment_triggered ( std::string_view rule_id ) -> VoidResult

nodiscard

Definition at line 1378 of file prefetch_repository.cpp.

                                                                          {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "prefetch_repository"});
    }
 
    static constexpr const char* sql = R"(
        UPDATE prefetch_rules SET
            triggered_count = triggered_count + 1,
            last_triggered = CURRENT_TIMESTAMP
        WHERE rule_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_)),
            "prefetch_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, rule_id.data(), static_cast<int>(rule_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {

initialize_tables()

VoidResult kcenon::pacs::storage::prefetch_repository::initialize_tables ( ) -> VoidResult

nodiscard

Definition at line 1046 of file prefetch_repository.cpp.

                                                  {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "prefetch_repository"});
    }
 
    // Create prefetch_rules table
    static constexpr const char* create_rules_sql = R"(
        CREATE TABLE IF NOT EXISTS prefetch_rules (
            pk INTEGER PRIMARY KEY AUTOINCREMENT,
            rule_id TEXT UNIQUE NOT NULL,
            name TEXT NOT NULL,
            enabled INTEGER DEFAULT 1,
            trigger_type TEXT NOT NULL,
            modality_filter TEXT,
            body_part_filter TEXT,
            station_ae_filter TEXT,
            prior_lookback_hours INTEGER DEFAULT 8760,
            max_prior_studies INTEGER DEFAULT 3,
            prior_modalities_json TEXT,
            source_node_ids_json TEXT NOT NULL,
            schedule_cron TEXT,
            advance_time_minutes INTEGER DEFAULT 60,
            triggered_count INTEGER DEFAULT 0,
            studies_prefetched INTEGER DEFAULT 0,
            last_triggered TIMESTAMP,
            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
            updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    )";
 
    char* err_msg = nullptr;
    int rc = sqlite3_exec(db_, create_rules_sql, nullptr, nullptr, &err_msg);
    if (rc != SQLITE_OK) {
        std::string error = err_msg ? err_msg : "Unknown error";
        sqlite3_free(err_msg);
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to create prefetch_rules table: " + error,
            "prefetch_repository"});
    }
 
    // Create prefetch_history table
    static constexpr const char* create_history_sql = R"(
        CREATE TABLE IF NOT EXISTS prefetch_history (
            pk INTEGER PRIMARY KEY AUTOINCREMENT,
            patient_id TEXT NOT NULL,
            study_uid TEXT NOT NULL,
            rule_id TEXT,
            source_node_id TEXT NOT NULL,
            job_id TEXT,
            status TEXT NOT NULL,
            prefetched_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
        )
    )";
 
    rc = sqlite3_exec(db_, create_history_sql, nullptr, nullptr, &err_msg);
    if (rc != SQLITE_OK) {
        std::string error = err_msg ? err_msg : "Unknown error";
        sqlite3_free(err_msg);
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to create prefetch_history table: " + error,
            "prefetch_repository"});
    }
 
    // Create indexes
    static constexpr const char* create_indexes_sql = R"(
        CREATE INDEX IF NOT EXISTS idx_prefetch_history_patient ON prefetch_history(patient_id);
        CREATE INDEX IF NOT EXISTS idx_prefetch_history_study ON prefetch_history(study_uid);
        CREATE INDEX IF NOT EXISTS idx_prefetch_history_status ON prefetch_history(status);
    )";
 
    rc = sqlite3_exec(db_, create_indexes_sql, nullptr, nullptr, &err_msg);
    if (rc != SQLITE_OK) {
        std::string error = err_msg ? err_msg : "Unknown error";
        sqlite3_free(err_msg);
        return VoidResult(kcenon::common::error_info{
            -1, "Failed to create indexes: " + error,
            "prefetch_repository"});
    }
 
    return kcenon::common::ok();
}

References kcenon::pacs::storage::error.

is_study_prefetched()

bool kcenon::pacs::storage::prefetch_repository::is_study_prefetched ( std::string_view study_uid ) const -> bool

nodiscard

Definition at line 1607 of file prefetch_repository.cpp.

                                             {
        result.push_back(parse_history_row(stmt));
    }
 
    sqlite3_finalize(stmt);
    return result;
}
 
bool prefetch_repository::is_study_prefetched(std::string_view study_uid) const {
    if (!db_) return false;
 
    static constexpr const char* sql = R"(
        SELECT 1 FROM prefetch_history
        WHERE study_uid = ? AND status IN ('completed', 'pending')
    )";
 
    sqlite3_stmt* stmt = nullptr;

is_valid()

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

nodiscardnoexcept

Definition at line 1807 of file prefetch_repository.cpp.

operator=() [1/2]

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

delete

operator=() [2/2]

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

defaultnoexcept

parse_history_row()

client::prefetch_history kcenon::pacs::storage::prefetch_repository::parse_history_row ( void * stmt ) const -> client::prefetch_history

nodiscardprivate

Definition at line 1851 of file prefetch_repository.cpp.

                                                                                  {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    client::prefetch_history history;
 
    int col = 0;
    history.pk = get_int64_column(stmt, col++);
    history.patient_id = get_text_column(stmt, col++);
    history.study_uid = get_text_column(stmt, col++);

parse_rule_row()

client::prefetch_rule kcenon::pacs::storage::prefetch_repository::parse_rule_row ( void * stmt ) const -> client::prefetch_rule

nodiscardprivate

Definition at line 1815 of file prefetch_repository.cpp.

                                                  {
    return db_ != nullptr;
}
 
// =============================================================================
// Private Implementation
// =============================================================================
 
client::prefetch_rule prefetch_repository::parse_rule_row(void* stmt_ptr) const {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    client::prefetch_rule rule;
 
    int col = 0;
    rule.pk = get_int64_column(stmt, col++);
    rule.rule_id = get_text_column(stmt, col++);
    rule.name = get_text_column(stmt, col++);
    rule.enabled = (get_int_column(stmt, col++) != 0);
    rule.trigger = client::prefetch_trigger_from_string(get_text_column(stmt, col++));
 
    rule.modality_filter = get_text_column(stmt, col++);
    rule.body_part_filter = get_text_column(stmt, col++);
    rule.station_ae_filter = get_text_column(stmt, col++);
 
    rule.prior_lookback = std::chrono::hours{get_int64_column(stmt, col++)};
    rule.max_prior_studies = static_cast<size_t>(get_int64_column(stmt, col++));
 
    auto modalities_json = get_text_column(stmt, col++);
    rule.prior_modalities = deserialize_modalities(modalities_json);
 
    auto node_ids_json = get_text_column(stmt, col++);
    rule.source_node_ids = deserialize_node_ids(node_ids_json);
 
    rule.schedule_cron = get_text_column(stmt, col++);

References db_.

Referenced by find_rule_by_id(), and find_rule_by_pk().

Here is the caller graph for this function:

remove_rule()

VoidResult kcenon::pacs::storage::prefetch_repository::remove_rule ( std::string_view rule_id ) -> VoidResult

nodiscard

Definition at line 1328 of file prefetch_repository.cpp.

                                                                             {
    prefetch_rule_query_options options;
    options.enabled_only = true;
    return find_rules(options);
}
 
VoidResult prefetch_repository::remove_rule(std::string_view rule_id) {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "prefetch_repository"});
    }
 
    static constexpr const char* sql = "DELETE FROM prefetch_rules WHERE rule_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_)),
            "prefetch_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, rule_id.data(), static_cast<int>(rule_id.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {

References kcenon::pacs::storage::prefetch_rule_query_options::enabled_only, and find_rules().

Here is the call graph for this function:

rule_count()

size_t kcenon::pacs::storage::prefetch_repository::rule_count ( ) const -> size_t

nodiscard

Definition at line 1746 of file prefetch_repository.cpp.

                                             {
    if (!db_) return 0;
 
    static constexpr const char* sql = "SELECT COUNT(*) FROM prefetch_rules";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return 0;

rule_exists()

bool kcenon::pacs::storage::prefetch_repository::rule_exists ( std::string_view rule_id ) const -> bool

nodiscard

Definition at line 1357 of file prefetch_repository.cpp.

                                      : " + std::string(sqlite3_errmsg(db_)),
            "prefetch_repository"});
    }
 
    return kcenon::common::ok();
}
 
bool prefetch_repository::rule_exists(std::string_view rule_id) const {
    if (!db_) return false;
 
    static constexpr const char* sql = "SELECT 1 FROM prefetch_rules WHERE rule_id = ?";
 
    sqlite3_stmt* stmt = nullptr;
    if (sqlite3_prepare_v2(db_, sql, -1, &stmt, nullptr) != SQLITE_OK) {
        return false;
    }

save_history()

VoidResult kcenon::pacs::storage::prefetch_repository::save_history ( const client::prefetch_history & history ) -> VoidResult

nodiscard

Definition at line 1519 of file prefetch_repository.cpp.

                                                                                  {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "prefetch_repository"});
    }
 
    static constexpr const char* sql = R"(
        INSERT INTO prefetch_history (
            patient_id, study_uid, rule_id, source_node_id, job_id, status
        ) VALUES (?, ?, ?, ?, ?, ?)
    )";
 
    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_)),
            "prefetch_repository"});
    }
 
    int idx = 1;
    sqlite3_bind_text(stmt, idx++, history.patient_id.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, history.study_uid.c_str(), -1, SQLITE_TRANSIENT);
 
    if (history.rule_id.empty()) {
        sqlite3_bind_null(stmt, idx++);
    } else {
        sqlite3_bind_text(stmt, idx++, history.rule_id.c_str(), -1, SQLITE_TRANSIENT);
    }
 
    sqlite3_bind_text(stmt, idx++, history.source_node_id.c_str(), -1, SQLITE_TRANSIENT);
 
    if (history.job_id.empty()) {
        sqlite3_bind_null(stmt, idx++);
    } else {
        sqlite3_bind_text(stmt, idx++, history.job_id.c_str(), -1, SQLITE_TRANSIENT);
    }
 
    sqlite3_bind_text(stmt, idx++, history.status.c_str(), -1, SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {

save_rule()

VoidResult kcenon::pacs::storage::prefetch_repository::save_rule ( const client::prefetch_rule & rule ) -> VoidResult

nodiscard

Definition at line 1133 of file prefetch_repository.cpp.

                                                                         {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "prefetch_repository"});
    }
 
    static constexpr const char* sql = R"(
        INSERT INTO prefetch_rules (
            rule_id, name, enabled, trigger_type,
            modality_filter, body_part_filter, station_ae_filter,
            prior_lookback_hours, max_prior_studies, prior_modalities_json,
            source_node_ids_json, schedule_cron, advance_time_minutes,
            triggered_count, studies_prefetched, last_triggered
        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
        ON CONFLICT(rule_id) DO UPDATE SET
            name = excluded.name,
            enabled = excluded.enabled,
            trigger_type = excluded.trigger_type,
            modality_filter = excluded.modality_filter,
            body_part_filter = excluded.body_part_filter,
            station_ae_filter = excluded.station_ae_filter,
            prior_lookback_hours = excluded.prior_lookback_hours,
            max_prior_studies = excluded.max_prior_studies,
            prior_modalities_json = excluded.prior_modalities_json,
            source_node_ids_json = excluded.source_node_ids_json,
            schedule_cron = excluded.schedule_cron,
            advance_time_minutes = excluded.advance_time_minutes,
            updated_at = CURRENT_TIMESTAMP
    )";
 
    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_)),
            "prefetch_repository"});
    }
 
    int idx = 1;
    sqlite3_bind_text(stmt, idx++, rule.rule_id.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, idx++, rule.name.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_int(stmt, idx++, rule.enabled ? 1 : 0);
    sqlite3_bind_text(stmt, idx++, client::to_string(rule.trigger), -1, SQLITE_STATIC);
 
    if (rule.modality_filter.empty()) {
        sqlite3_bind_null(stmt, idx++);
    } else {
        sqlite3_bind_text(stmt, idx++, rule.modality_filter.c_str(), -1, SQLITE_TRANSIENT);
    }
 
    if (rule.body_part_filter.empty()) {
        sqlite3_bind_null(stmt, idx++);
    } else {
        sqlite3_bind_text(stmt, idx++, rule.body_part_filter.c_str(), -1, SQLITE_TRANSIENT);
    }
 
    if (rule.station_ae_filter.empty()) {
        sqlite3_bind_null(stmt, idx++);
    } else {
        sqlite3_bind_text(stmt, idx++, rule.station_ae_filter.c_str(), -1, SQLITE_TRANSIENT);
    }
 
    sqlite3_bind_int64(stmt, idx++, rule.prior_lookback.count());
    sqlite3_bind_int64(stmt, idx++, static_cast<int64_t>(rule.max_prior_studies));
 
    auto modalities_json = serialize_modalities(rule.prior_modalities);
    sqlite3_bind_text(stmt, idx++, modalities_json.c_str(), -1, SQLITE_TRANSIENT);
 
    auto node_ids_json = serialize_node_ids(rule.source_node_ids);
    sqlite3_bind_text(stmt, idx++, node_ids_json.c_str(), -1, SQLITE_TRANSIENT);
 
    if (rule.schedule_cron.empty()) {
        sqlite3_bind_null(stmt, idx++);
    } else {
        sqlite3_bind_text(stmt, idx++, rule.schedule_cron.c_str(), -1, SQLITE_TRANSIENT);
    }
 
    sqlite3_bind_int64(stmt, idx++, rule.advance_time.count());
    sqlite3_bind_int64(stmt, idx++, static_cast<int64_t>(rule.triggered_count));
    sqlite3_bind_int64(stmt, idx++, static_cast<int64_t>(rule.studies_prefetched));
 
    auto last_triggered_str = to_timestamp_string(rule.last_triggered);
    if (last_triggered_str.empty()) {
        sqlite3_bind_null(stmt, idx++);
    } else {
        sqlite3_bind_text(stmt, idx++, last_triggered_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 rule: " + std::string(sqlite3_errmsg(db_)),
            "prefetch_repository"});
    }
 
    return kcenon::common::ok();
}

References kcenon::pacs::client::prefetch_rule::advance_time, kcenon::pacs::client::prefetch_rule::body_part_filter, db_, kcenon::pacs::client::prefetch_rule::enabled, kcenon::pacs::client::prefetch_rule::last_triggered, kcenon::pacs::client::prefetch_rule::max_prior_studies, kcenon::pacs::client::prefetch_rule::modality_filter, kcenon::pacs::client::prefetch_rule::name, kcenon::pacs::client::prefetch_rule::prior_lookback, kcenon::pacs::client::prefetch_rule::prior_modalities, kcenon::pacs::client::prefetch_rule::rule_id, kcenon::pacs::client::prefetch_rule::schedule_cron, serialize_modalities(), serialize_node_ids(), kcenon::pacs::client::prefetch_rule::source_node_ids, kcenon::pacs::client::prefetch_rule::station_ae_filter, kcenon::pacs::client::prefetch_rule::studies_prefetched, kcenon::pacs::client::to_string(), kcenon::pacs::client::prefetch_rule::trigger, and kcenon::pacs::client::prefetch_rule::triggered_count.

Here is the call graph for this function:

serialize_modalities()

std::string kcenon::pacs::storage::prefetch_repository::serialize_modalities ( const std::vector< std::string > & modalities ) -> std::string

staticnodiscardprivate

Definition at line 988 of file prefetch_repository.cpp.

                                            {
    if (modalities.empty()) return "[]";
 
    std::ostringstream oss;
    oss << "[";
    for (size_t i = 0; i < modalities.size(); ++i) {
        if (i > 0) oss << ",";
        oss << "\"" << escape_json_string(modalities[i]) << "\"";
    }
    oss << "]";
    return oss.str();
}

Referenced by save_rule(), and serialize_node_ids().

Here is the caller graph for this function:

serialize_node_ids()

std::string kcenon::pacs::storage::prefetch_repository::serialize_node_ids ( const std::vector< std::string > & node_ids ) -> std::string

staticnodiscardprivate

Definition at line 1020 of file prefetch_repository.cpp.

                                          {
    return serialize_modalities(node_ids);  // Same format
}

References serialize_modalities().

Referenced by save_rule().

Here is the call graph for this function:

Here is the caller graph for this function:

update_history_status()

VoidResult kcenon::pacs::storage::prefetch_repository::update_history_status ( std::string_view study_uid, std::string_view status ) -> VoidResult

nodiscard

Definition at line 1673 of file prefetch_repository.cpp.

                                          {
        result = static_cast<size_t>(sqlite3_column_int64(stmt, 0));
    }
 
    sqlite3_finalize(stmt);
    return result;
}
 
VoidResult prefetch_repository::update_history_status(
    std::string_view study_uid,
    std::string_view status) {
    if (!db_) {
        return VoidResult(kcenon::common::error_info{
            -1, "Database not initialized", "prefetch_repository"});
    }
 
    static constexpr const char* sql = R"(
        UPDATE prefetch_history SET status = ? WHERE study_uid = ?
    )";
 
    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_)),
            "prefetch_repository"});
    }
 
    sqlite3_bind_text(stmt, 1, status.data(), static_cast<int>(status.size()), SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 2, study_uid.data(), static_cast<int>(study_uid.size()), SQLITE_TRANSIENT);
 
    auto rc = sqlite3_step(stmt);

Member Data Documentation

db_

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

private

Definition at line 477 of file prefetch_repository.h.

{nullptr};

Referenced by cleanup_old_history(), find_rule_by_id(), find_rule_by_pk(), find_rules(), parse_rule_row(), and save_rule().

---

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

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