kcenon::pacs::storage::patient_repository Class Reference

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

#include <patient_repository.h>

Collaboration diagram for kcenon::pacs::storage::patient_repository:

Public Member Functions
	patient_repository (sqlite3 *db)
	~patient_repository ()
	patient_repository (const patient_repository &)=delete
auto	operator= (const patient_repository &) -> patient_repository &=delete
	patient_repository (patient_repository &&) noexcept
auto	operator= (patient_repository &&) noexcept -> patient_repository &
auto	upsert_patient (std::string_view patient_id, std::string_view patient_name="", std::string_view birth_date="", std::string_view sex="") -> Result< int64_t >
auto	upsert_patient (const patient_record &record) -> Result< int64_t >
auto	find_patient (std::string_view patient_id) const -> std::optional< patient_record >
auto	find_patient_by_pk (int64_t pk) const -> std::optional< patient_record >
auto	search_patients (const patient_query &query) const -> Result< std::vector< patient_record > >
auto	delete_patient (std::string_view patient_id) -> VoidResult
auto	patient_count () const -> Result< size_t >

Private Member Functions
auto	parse_patient_row (void *stmt) const -> patient_record

Static Private Member Functions
static auto	to_like_pattern (std::string_view pattern) -> std::string

Private Attributes
sqlite3 *	db_ {nullptr}

Detailed Description

Repository for patient metadata persistence (legacy SQLite interface)

Definition at line 179 of file patient_repository.h.

Constructor & Destructor Documentation

patient_repository() [1/3]

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

explicit

Definition at line 524 of file patient_repository.cpp.

: db_(db) {}

~patient_repository()

kcenon::pacs::storage::patient_repository::~patient_repository ( )

default

patient_repository() [2/3]

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

delete

patient_repository() [3/3]

kcenon::pacs::storage::patient_repository::patient_repository ( patient_repository && )

defaultnoexcept

Member Function Documentation

delete_patient()

auto kcenon::pacs::storage::patient_repository::delete_patient ( std::string_view patient_id ) -> VoidResult

nodiscard

Definition at line 790 of file patient_repository.cpp.

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

find_patient()

auto kcenon::pacs::storage::patient_repository::find_patient ( std::string_view patient_id ) const -> std::optional<patient_record>

nodiscard

Definition at line 656 of file patient_repository.cpp.

                                   {
    const char* sql = R"(
        SELECT patient_pk, patient_id, patient_name, birth_date, sex,
               other_ids, ethnic_group, comments, created_at, updated_at
        FROM patients
        WHERE patient_id = ?;
    )";
 
    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, patient_id.data(),
                      static_cast<int>(patient_id.size()), SQLITE_TRANSIENT);
 
    rc = sqlite3_step(stmt);
    if (rc != SQLITE_ROW) {
        sqlite3_finalize(stmt);
        return std::nullopt;
    }
 
    auto record = parse_patient_row(stmt);
    sqlite3_finalize(stmt);
 
    return record;
}

find_patient_by_pk()

auto kcenon::pacs::storage::patient_repository::find_patient_by_pk ( int64_t pk ) const -> std::optional<patient_record>

nodiscard

Definition at line 686 of file patient_repository.cpp.

                                   {
    const char* sql = R"(
        SELECT patient_pk, patient_id, patient_name, birth_date, sex,
               other_ids, ethnic_group, comments, created_at, updated_at
        FROM patients
        WHERE patient_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_patient_row(stmt);
    sqlite3_finalize(stmt);
 
    return record;
}

operator=() [1/2]

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

delete

operator=() [2/2]

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

defaultnoexcept

parse_patient_row()

auto kcenon::pacs::storage::patient_repository::parse_patient_row ( void * stmt ) const -> patient_record

nodiscardprivate

Definition at line 554 of file patient_repository.cpp.

                      {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    patient_record record;
 
    record.pk = sqlite3_column_int64(stmt, 0);
    record.patient_id = get_text(stmt, 1);
    record.patient_name = get_text(stmt, 2);
    record.birth_date = get_text(stmt, 3);
    record.sex = get_text(stmt, 4);
    record.other_ids = get_text(stmt, 5);
    record.ethnic_group = get_text(stmt, 6);
    record.comments = get_text(stmt, 7);
 
    auto created_str = get_text(stmt, 8);
    record.created_at = parse_datetime(created_str.c_str());
 
    auto updated_str = get_text(stmt, 9);
    record.updated_at = parse_datetime(updated_str.c_str());
 
    return record;
}

patient_count()

auto kcenon::pacs::storage::patient_repository::patient_count ( ) const -> Result<size_t>

nodiscard

Definition at line 818 of file patient_repository.cpp.

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

search_patients()

auto kcenon::pacs::storage::patient_repository::search_patients ( const patient_query & query ) const -> Result<std::vector<patient_record>>

nodiscard

Definition at line 715 of file patient_repository.cpp.

                                         {
    std::vector<patient_record> results;
 
    std::string sql = R"(
        SELECT patient_pk, patient_id, patient_name, birth_date, sex,
               other_ids, ethnic_group, comments, created_at, updated_at
        FROM patients
        WHERE 1=1
    )";
 
    std::vector<std::string> params;
 
    if (query.patient_id.has_value()) {
        sql += " AND patient_id LIKE ?";
        params.push_back(to_like_pattern(*query.patient_id));
    }
 
    if (query.patient_name.has_value()) {
        sql += " AND patient_name LIKE ?";
        params.push_back(to_like_pattern(*query.patient_name));
    }
 
    if (query.birth_date.has_value()) {
        sql += " AND birth_date = ?";
        params.push_back(*query.birth_date);
    }
 
    if (query.birth_date_from.has_value()) {
        sql += " AND birth_date >= ?";
        params.push_back(*query.birth_date_from);
    }
 
    if (query.birth_date_to.has_value()) {
        sql += " AND birth_date <= ?";
        params.push_back(*query.birth_date_to);
    }
 
    if (query.sex.has_value()) {
        sql += " AND sex = ?";
        params.push_back(*query.sex);
    }
 
    sql += " ORDER BY patient_name, patient_id";
 
    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<patient_record>>(
            database_query_error,
            kcenon::pacs::compat::format("Failed to prepare query: {}", sqlite3_errmsg(db_)),
            "storage");
    }
 
    for (size_t i = 0; i < params.size(); ++i) {
        sqlite3_bind_text(stmt, static_cast<int>(i + 1), params[i].c_str(), -1,
                          SQLITE_TRANSIENT);
    }
 
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        results.push_back(parse_patient_row(stmt));
    }
 
    sqlite3_finalize(stmt);
    return ok(std::move(results));
}

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

to_like_pattern()

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

staticnodiscardprivate

Definition at line 533 of file patient_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_patient() [1/2]

auto kcenon::pacs::storage::patient_repository::upsert_patient ( const patient_record & record ) -> Result<int64_t>

nodiscard

Definition at line 590 of file patient_repository.cpp.

                       {
    if (record.patient_id.empty()) {
        return make_error<int64_t>(-1, "Patient ID is required", "storage");
    }
 
    if (record.patient_id.length() > 64) {
        return make_error<int64_t>(
            -1, "Patient ID exceeds maximum length of 64 characters",
            "storage");
    }
 
    if (!record.sex.empty() && record.sex != "M" && record.sex != "F" &&
        record.sex != "O") {
        return make_error<int64_t>(
            -1, "Invalid sex value. Must be M, F, or O", "storage");
    }
 
    const char* sql = R"(
        INSERT INTO patients (
            patient_id, patient_name, birth_date, sex,
            other_ids, ethnic_group, comments, updated_at
        ) VALUES (?, ?, ?, ?, ?, ?, ?, datetime('now'))
        ON CONFLICT(patient_id) DO UPDATE SET
            patient_name = excluded.patient_name,
            birth_date = excluded.birth_date,
            sex = excluded.sex,
            other_ids = excluded.other_ids,
            ethnic_group = excluded.ethnic_group,
            comments = excluded.comments,
            updated_at = datetime('now')
        RETURNING patient_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_text(stmt, 1, record.patient_id.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 2, record.patient_name.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 3, record.birth_date.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 4, record.sex.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 5, record.other_ids.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 6, record.ethnic_group.c_str(), -1, SQLITE_TRANSIENT);
    sqlite3_bind_text(stmt, 7, record.comments.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 patient: {}", error_msg),
            "storage");
    }
 
    auto pk = sqlite3_column_int64(stmt, 0);
    sqlite3_finalize(stmt);
 
    return pk;
}

upsert_patient() [2/2]

auto kcenon::pacs::storage::patient_repository::upsert_patient ( std::string_view patient_id, std::string_view patient_name = "", std::string_view birth_date = "", std::string_view sex = "" ) -> Result<int64_t>

nodiscard

Definition at line 577 of file patient_repository.cpp.

                       {
    patient_record record;
    record.patient_id = std::string(patient_id);
    record.patient_name = std::string(patient_name);
    record.birth_date = std::string(birth_date);
    record.sex = std::string(sex);
    return upsert_patient(record);
}

Member Data Documentation

db_

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

private

Definition at line 211 of file patient_repository.h.

{nullptr};

Referenced by patient_count().

---

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

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