kcenon::pacs::storage::index_database Class Reference

PACS index database manager. More...

#include <index_database.h>

Collaboration diagram for kcenon::pacs::storage::index_database:

Classes
struct	storage_stats
	Storage statistics structure. More...

Public Member Functions
	~index_database ()
	Destructor - closes database connection.
	index_database (const index_database &)=delete
auto	operator= (const index_database &) -> index_database &=delete
	index_database (index_database &&) noexcept
auto	operator= (index_database &&) noexcept -> index_database &
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 >
	Insert or update a patient record.
auto	upsert_patient (const patient_record &record) -> Result< int64_t >
	Insert or update a patient record with full details.
auto	find_patient (std::string_view patient_id) const -> std::optional< patient_record >
	Find a patient by patient ID.
auto	find_patient_by_pk (int64_t pk) const -> std::optional< patient_record >
	Find a patient by primary key.
auto	search_patients (const patient_query &query) const -> Result< std::vector< patient_record > >
	Search patients with query criteria.
auto	delete_patient (std::string_view patient_id) -> VoidResult
	Delete a patient by patient ID.
auto	patient_count () const -> Result< size_t >
	Get total patient count.
auto	upsert_study (int64_t patient_pk, std::string_view study_uid, std::string_view study_id="", std::string_view study_date="", std::string_view study_time="", std::string_view accession_number="", std::string_view referring_physician="", std::string_view study_description="") -> Result< int64_t >
	Insert or update a study record.
auto	upsert_study (const study_record &record) -> Result< int64_t >
	Insert or update a study record with full details.
auto	find_study (std::string_view study_uid) const -> std::optional< study_record >
	Find a study by Study Instance UID.
auto	find_study_by_pk (int64_t pk) const -> std::optional< study_record >
	Find a study by primary key.
auto	list_studies (std::string_view patient_id) const -> Result< std::vector< study_record > >
	List all studies for a patient.
auto	search_studies (const study_query &query) const -> Result< std::vector< study_record > >
	Search studies with query criteria.
auto	delete_study (std::string_view study_uid) -> VoidResult
	Delete a study by Study Instance UID.
auto	study_count () const -> Result< size_t >
	Get total study count.
auto	study_count (std::string_view patient_id) const -> Result< size_t >
	Get study count for a specific patient.
auto	update_modalities_in_study (int64_t study_pk) -> VoidResult
	Update modalities in study (denormalized field)
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 >
	Insert or update a series record.
auto	upsert_series (const series_record &record) -> Result< int64_t >
	Insert or update a series record with full details.
auto	find_series (std::string_view series_uid) const -> std::optional< series_record >
	Find a series by Series Instance UID.
auto	find_series_by_pk (int64_t pk) const -> std::optional< series_record >
	Find a series by primary key.
auto	list_series (std::string_view study_uid) const -> Result< std::vector< series_record > >
	List all series for a study.
auto	search_series (const series_query &query) const -> Result< std::vector< series_record > >
	Search series with query criteria.
auto	delete_series (std::string_view series_uid) -> VoidResult
	Delete a series by Series Instance UID.
auto	series_count () const -> Result< size_t >
	Get total series count.
auto	series_count (std::string_view study_uid) const -> Result< size_t >
	Get series count for a specific study.
auto	upsert_instance (int64_t series_pk, std::string_view sop_uid, std::string_view sop_class_uid, std::string_view file_path, int64_t file_size, std::string_view transfer_syntax="", std::optional< int > instance_number=std::nullopt) -> Result< int64_t >
	Insert or update an instance record.
auto	upsert_instance (const instance_record &record) -> Result< int64_t >
	Insert or update an instance record with full details.
auto	find_instance (std::string_view sop_uid) const -> std::optional< instance_record >
	Find an instance by SOP Instance UID.
auto	find_instance_by_pk (int64_t pk) const -> std::optional< instance_record >
	Find an instance by primary key.
auto	list_instances (std::string_view series_uid) const -> Result< std::vector< instance_record > >
	List all instances for a series.
auto	search_instances (const instance_query &query) const -> Result< std::vector< instance_record > >
	Search instances with query criteria.
auto	delete_instance (std::string_view sop_uid) -> VoidResult
	Delete an instance by SOP Instance UID.
auto	instance_count () const -> Result< size_t >
	Get total instance count.
auto	instance_count (std::string_view series_uid) const -> Result< size_t >
	Get instance count for a specific series.
auto	create_mpps (std::string_view mpps_uid, std::string_view station_ae="", std::string_view modality="", std::string_view study_uid="", std::string_view accession_no="", std::string_view start_datetime="") -> Result< int64_t >
	Create a new MPPS record (N-CREATE)
auto	create_mpps (const mpps_record &record) -> Result< int64_t >
	Create a new MPPS record with full details.
auto	update_mpps (std::string_view mpps_uid, std::string_view new_status, std::string_view end_datetime="", std::string_view performed_series="") -> VoidResult
	Update an existing MPPS record (N-SET)
auto	update_mpps (const mpps_record &record) -> VoidResult
	Update an existing MPPS record with partial data.
auto	find_mpps (std::string_view mpps_uid) const -> std::optional< mpps_record >
	Find an MPPS by SOP Instance UID.
auto	find_mpps_by_pk (int64_t pk) const -> std::optional< mpps_record >
	Find an MPPS by primary key.
auto	list_active_mpps (std::string_view station_ae) const -> Result< std::vector< mpps_record > >
	List active (IN PROGRESS) MPPS records for a station.
auto	find_mpps_by_study (std::string_view study_uid) const -> Result< std::vector< mpps_record > >
	Find MPPS records by Study Instance UID.
auto	search_mpps (const mpps_query &query) const -> Result< std::vector< mpps_record > >
	Search MPPS records with query criteria.
auto	delete_mpps (std::string_view mpps_uid) -> VoidResult
	Delete an MPPS record.
auto	mpps_count () const -> Result< size_t >
	Get total MPPS count.
auto	mpps_count (std::string_view status) const -> Result< size_t >
	Get MPPS count by status.
auto	add_worklist_item (const worklist_item &item) -> Result< int64_t >
	Add a new worklist item.
auto	update_worklist_status (std::string_view step_id, std::string_view accession_no, std::string_view new_status) -> VoidResult
	Update worklist item status.
auto	query_worklist (const worklist_query &query) const -> Result< std::vector< worklist_item > >
	Query worklist items.
auto	find_worklist_item (std::string_view step_id, std::string_view accession_no) const -> std::optional< worklist_item >
	Find a worklist item by step ID and accession number.
auto	find_worklist_by_pk (int64_t pk) const -> std::optional< worklist_item >
	Find a worklist item by primary key.
auto	delete_worklist_item (std::string_view step_id, std::string_view accession_no) -> VoidResult
	Delete a worklist item.
auto	cleanup_old_worklist_items (std::chrono::hours age) -> Result< size_t >
	Cleanup old worklist items.
auto	cleanup_worklist_items_before (std::chrono::system_clock::time_point before) -> Result< size_t >
	Cleanup worklist items scheduled before a specific time.
auto	worklist_count () const -> Result< size_t >
	Get total worklist count.
auto	worklist_count (std::string_view status) const -> Result< size_t >
	Get worklist count by status.
auto	create_ups_workitem (const ups_workitem &workitem) -> Result< int64_t >
	Create a new UPS workitem (N-CREATE)
auto	update_ups_workitem (const ups_workitem &workitem) -> VoidResult
	Update an existing UPS workitem.
auto	change_ups_state (std::string_view workitem_uid, std::string_view new_state, std::string_view transaction_uid="") -> VoidResult
	Change UPS workitem state.
auto	find_ups_workitem (std::string_view workitem_uid) const -> std::optional< ups_workitem >
	Find a UPS workitem by SOP Instance UID.
auto	search_ups_workitems (const ups_workitem_query &query) const -> Result< std::vector< ups_workitem > >
	Search UPS workitems with query criteria.
auto	delete_ups_workitem (std::string_view workitem_uid) -> VoidResult
	Delete a UPS workitem.
auto	ups_workitem_count () const -> Result< size_t >
	Get total UPS workitem count.
auto	ups_workitem_count (std::string_view state) const -> Result< size_t >
	Get UPS workitem count by state.
auto	subscribe_ups (const ups_subscription &subscription) -> Result< int64_t >
	Subscribe to UPS workitem events.
auto	unsubscribe_ups (std::string_view subscriber_ae, std::string_view workitem_uid="") -> VoidResult
	Unsubscribe from UPS workitem events.
auto	get_ups_subscriptions (std::string_view subscriber_ae) const -> Result< std::vector< ups_subscription > >
	Get all subscriptions for a subscriber.
auto	get_ups_subscribers (std::string_view workitem_uid) const -> Result< std::vector< std::string > >
	Get all subscribers for a workitem.
auto	add_audit_log (const audit_record &record) -> Result< int64_t >
	Add a new audit log entry.
auto	query_audit_log (const audit_query &query) const -> Result< std::vector< audit_record > >
	Query audit log entries.
auto	find_audit_by_pk (int64_t pk) const -> std::optional< audit_record >
	Find an audit log entry by primary key.
auto	audit_count () const -> Result< size_t >
	Get total audit log count.
auto	cleanup_old_audit_logs (std::chrono::hours age) -> Result< size_t >
	Cleanup old audit log entries.
auto	path () const -> std::string_view
	Get the database file path.
auto	schema_version () const -> int
	Get the current schema version.
auto	is_open () const noexcept -> bool
	Check if the database is open.
auto	get_file_path (std::string_view sop_instance_uid) const -> Result< std::optional< std::string > >
	Get file path for a SOP Instance UID.
auto	get_study_files (std::string_view study_instance_uid) const -> Result< std::vector< std::string > >
	Get all file paths for a study.
auto	get_series_files (std::string_view series_instance_uid) const -> Result< std::vector< std::string > >
	Get all file paths for a series.
auto	vacuum () -> VoidResult
	Reclaim unused space in the database.
auto	analyze () -> VoidResult
	Update database statistics for query optimization.
auto	verify_integrity () const -> VoidResult
	Verify database integrity.
auto	native_handle () const noexcept -> sqlite3 *
	Get the raw SQLite database handle.
auto	checkpoint (bool truncate=false) -> VoidResult
	Checkpoint WAL file.
auto	get_storage_stats () const -> Result< storage_stats >
	Get storage statistics.

Static Public Member Functions
static auto	open (std::string_view db_path) -> Result< std::unique_ptr< index_database > >
	Open or create a database with default configuration.
static auto	open (std::string_view db_path, const index_config &config) -> Result< std::unique_ptr< index_database > >
	Open or create a database with custom configuration.

Private Member Functions
	index_database (sqlite3 *db, std::string path)
	Private constructor - use open() factory method.
auto	parse_patient_row (void *stmt) const -> patient_record
	Parse a patient record from a prepared statement.
auto	parse_study_row (void *stmt) const -> study_record
	Parse a study record from a prepared statement.
auto	parse_series_row (void *stmt) const -> series_record
	Parse a series record from a prepared statement.
auto	parse_instance_row (void *stmt) const -> instance_record
	Parse an instance record from a prepared statement.
auto	parse_mpps_row (void *stmt) const -> mpps_record
	Parse an MPPS record from a prepared statement.
auto	parse_worklist_row (void *stmt) const -> worklist_item
	Parse a worklist record from a prepared statement.
auto	parse_ups_workitem_row (void *stmt) const -> ups_workitem
	Parse a UPS workitem record from a prepared statement.
auto	parse_audit_row (void *stmt) const -> audit_record
	Parse an audit record from a prepared statement.
auto	initialize_repositories () -> VoidResult
	Initialize extracted repositories for facade delegation.

Static Private Member Functions
static auto	to_like_pattern (std::string_view pattern) -> std::string
	Convert wildcard pattern to SQL LIKE pattern.

Private Attributes
sqlite3 *	db_ {nullptr}
	SQLite database handle (used for migrations and fallback)
std::string	path_
	Database file path.
bool	remove_on_close_ {false}
	Remove the backing file on destruction for adapter-compatible memory DBs.
std::shared_ptr< patient_repository >	patient_repository_
	Extracted repositories used by the facade API.
std::shared_ptr< study_repository >	study_repository_
std::shared_ptr< series_repository >	series_repository_
std::shared_ptr< instance_repository >	instance_repository_
std::shared_ptr< mpps_repository >	mpps_repository_
std::shared_ptr< worklist_repository >	worklist_repository_
std::shared_ptr< ups_repository >	ups_repository_
std::shared_ptr< audit_repository >	audit_repository_
migration_runner	migration_runner_
	Migration runner for schema management.

Detailed Description

PACS index database manager.

Provides database operations for DICOM metadata storage and retrieval. Uses SQLite for persistence with automatic schema migration.

Thread Safety: This class is NOT thread-safe. External synchronization is required for concurrent access. Consider using a connection pool for multi-threaded applications.

Example:

// Open or create database
auto db_result = index_database::open(":memory:");
if (db_result.is_err()) {
    // Handle error
}
auto db = std::move(db_result.value());
 
// Insert patient
auto pk = db->upsert_patient("12345", "Doe^John", "19800115", "M");
 
// Find patient
auto patient = db->find_patient("12345");
if (patient) {
    std::cout << patient->patient_name << std::endl;
}
 
// Search with wildcards
patient_query query;
query.patient_name = "Doe*";
auto results = db->search_patients(query);

Definition at line 123 of file index_database.h.

Constructor & Destructor Documentation

~index_database()

kcenon::pacs::storage::index_database::~index_database

(

)

Destructor - closes database connection.

Definition at line 287 of file index_database.cpp.

                                {
    patient_repository_.reset();
    study_repository_.reset();
    series_repository_.reset();
    instance_repository_.reset();
    mpps_repository_.reset();
    worklist_repository_.reset();
    ups_repository_.reset();
    audit_repository_.reset();
#ifdef PACS_WITH_DATABASE_SYSTEM
    if (db_adapter_) {
        (void)db_adapter_->disconnect();
        db_adapter_.reset();
    }
#endif
    if (db_) {
        sqlite3_close(db_);
        db_ = nullptr;
    }
    if (remove_on_close_) {
        remove_database_sidecars(path_);
    }
}

References audit_repository_, db_, instance_repository_, mpps_repository_, path_, patient_repository_, remove_on_close_, series_repository_, study_repository_, ups_repository_, and worklist_repository_.

index_database() [1/3]

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

delete

index_database() [2/3]

kcenon::pacs::storage::index_database::index_database ( index_database && other )

noexcept

Definition at line 688 of file index_database.cpp.

    : db_(other.db_),
      path_(std::move(other.path_)),
      remove_on_close_(other.remove_on_close_),
      patient_repository_(std::move(other.patient_repository_)),
      study_repository_(std::move(other.study_repository_)),
      series_repository_(std::move(other.series_repository_)),
      instance_repository_(std::move(other.instance_repository_)),
      mpps_repository_(std::move(other.mpps_repository_)),
      worklist_repository_(std::move(other.worklist_repository_)),
      ups_repository_(std::move(other.ups_repository_)),
      audit_repository_(std::move(other.audit_repository_)) {
#ifdef PACS_WITH_DATABASE_SYSTEM
    db_adapter_ = std::move(other.db_adapter_);
#endif
    other.db_ = nullptr;
    other.remove_on_close_ = false;
}

index_database() [3/3]

kcenon::pacs::storage::index_database::index_database ( sqlite3 * db, std::string path )

explicitprivate

Private constructor - use open() factory method.

Definition at line 284 of file index_database.cpp.

    : db_(db), path_(std::move(path)) {}

Member Function Documentation

add_audit_log()

auto kcenon::pacs::storage::index_database::add_audit_log ( const audit_record & record ) -> Result<int64_t>

nodiscard

Add a new audit log entry.

Creates a new audit log record for HIPAA compliance and system monitoring.

Parameters

record

Audit record data (pk field is ignored)

Returns

Result containing the audit log primary key or error

Definition at line 1725 of file index_database.cpp.

                       {
    return audit_repository_->add_audit_log(record);
}

add_worklist_item()

auto kcenon::pacs::storage::index_database::add_worklist_item ( const worklist_item & item ) -> Result<int64_t>

nodiscard

Add a new worklist item.

Creates a new scheduled procedure step entry for Modality Worklist. The step_status is set to 'SCHEDULED' by default.

Parameters

item	Worklist item data (pk field is ignored)

Returns

Result containing the worklist primary key or error

Definition at line 1533 of file index_database.cpp.

                       {
    return worklist_repository_->add_worklist_item(item);
}

analyze()

auto kcenon::pacs::storage::index_database::analyze ( ) -> VoidResult

nodiscard

Update database statistics for query optimization.

ANALYZE collects statistics about tables and indexes, which helps the query planner choose better execution plans. Should be run periodically, especially after bulk insertions.

Returns

VoidResult indicating success or error

Definition at line 1186 of file index_database.cpp.

                                           {
#ifdef PACS_WITH_DATABASE_SYSTEM
    // Prefer pacs_database_adapter for unified database operations (Issue #616)
    if (db_adapter_ && db_adapter_->is_connected()) {
        return db_adapter_->execute("ANALYZE;");
    }
#endif
 
    auto rc = sqlite3_exec(db_, "ANALYZE;", nullptr, nullptr, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::monostate>(
            rc, kcenon::pacs::compat::format("ANALYZE failed: {}", sqlite3_errmsg(db_)),
            "storage");
    }
    return ok();
}

audit_count()

auto kcenon::pacs::storage::index_database::audit_count ( ) const -> Result<size_t>

nodiscard

Get total audit log count.

Returns

Result containing number of audit log entries in the database or error

Definition at line 1740 of file index_database.cpp.

                                                         {
    return audit_repository_->audit_count();
}

References audit_repository_.

change_ups_state()

auto kcenon::pacs::storage::index_database::change_ups_state ( std::string_view workitem_uid, std::string_view new_state, std::string_view transaction_uid = "" ) -> VoidResult

nodiscard

Change UPS workitem state.

Performs a state transition with validation per PS3.4 Table CC.1.1-2.

Parameters

workitem_uid	The workitem SOP Instance UID
new_state	The target state
transaction_uid	Transaction UID (required for IN PROGRESS transition)

Returns

VoidResult indicating success or error

Definition at line 1632 of file index_database.cpp.

                  {
    return ups_repository_->change_ups_state(workitem_uid, new_state,
                                             transaction_uid);
}

checkpoint()

auto kcenon::pacs::storage::index_database::checkpoint ( bool truncate = false ) -> VoidResult

nodiscard

Checkpoint WAL file.

Forces a WAL checkpoint, writing all WAL content to the main database file. Useful for ensuring durability before backup.

Parameters

truncate

If true, truncate the WAL file after checkpoint

Returns

VoidResult indicating success or error

Definition at line 1252 of file index_database.cpp.

                                                           {
    const char* sql =
        truncate ? "PRAGMA wal_checkpoint(TRUNCATE);"
                 : "PRAGMA wal_checkpoint(PASSIVE);";
 
#ifdef PACS_WITH_DATABASE_SYSTEM
    // Prefer pacs_database_adapter for unified database operations (Issue #616)
    if (db_adapter_ && db_adapter_->is_connected()) {
        return db_adapter_->execute(sql);
    }
#endif
 
    auto rc = sqlite3_exec(db_, sql, nullptr, nullptr, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::monostate>(
            rc, kcenon::pacs::compat::format("Checkpoint failed: {}", sqlite3_errmsg(db_)),
            "storage");
    }
    return ok();
}

cleanup_old_audit_logs()

auto kcenon::pacs::storage::index_database::cleanup_old_audit_logs ( std::chrono::hours age ) -> Result<size_t>

nodiscard

Cleanup old audit log entries.

Removes audit log entries older than the specified age.

Parameters

age	Maximum age of entries to keep

Returns

Result containing the number of deleted entries or error

Definition at line 1744 of file index_database.cpp.

                      {
    return audit_repository_->cleanup_old_audit_logs(age);
}

cleanup_old_worklist_items()

auto kcenon::pacs::storage::index_database::cleanup_old_worklist_items ( std::chrono::hours age ) -> Result<size_t>

nodiscard

Cleanup old worklist items.

Removes worklist items older than the specified age. Only deletes items that are not in SCHEDULED status.

Parameters

age	Maximum age of items to keep

Returns

Result containing the number of deleted items or error

Definition at line 1568 of file index_database.cpp.

                      {
    return worklist_repository_->cleanup_old_worklist_items(age);
}

cleanup_worklist_items_before()

auto kcenon::pacs::storage::index_database::cleanup_worklist_items_before ( std::chrono::system_clock::time_point before ) -> Result<size_t>

nodiscard

Cleanup worklist items scheduled before a specific time.

Removes worklist items with scheduled_datetime before the specified time point. Only deletes items that are not in SCHEDULED status. This provides more precise control than the duration-based cleanup, eliminating timezone conversion ambiguities.

Parameters

before

Time point; items scheduled before this are eligible for deletion

Returns

Result containing the number of deleted items or error

Example:

// Delete items scheduled before 2024-01-01 00:00:00 UTC
std::tm tm = {};
tm.tm_year = 2024 - 1900;
tm.tm_mon = 0;
tm.tm_mday = 1;
auto time = std::chrono::system_clock::from_time_t(std::mktime(&tm));
auto result = db->cleanup_worklist_items_before(time);

Definition at line 1573 of file index_database.cpp.

                                                              {
    return worklist_repository_->cleanup_worklist_items_before(before);
}

create_mpps() [1/2]

auto kcenon::pacs::storage::index_database::create_mpps ( const mpps_record & record ) -> Result<int64_t>

nodiscard

Create a new MPPS record with full details.

Parameters

record

Complete MPPS record (pk field is ignored)

Returns

Result containing the MPPS primary key or error

Definition at line 1361 of file index_database.cpp.

                                                                             {
    return mpps_repository_->create_mpps(record);
}

create_mpps() [2/2]

auto kcenon::pacs::storage::index_database::create_mpps ( std::string_view mpps_uid, std::string_view station_ae = "", std::string_view modality = "", std::string_view study_uid = "", std::string_view accession_no = "", std::string_view start_datetime = "" ) -> Result<int64_t>

nodiscard

Create a new MPPS record (N-CREATE)

Creates a new MPPS with status "IN PROGRESS". This corresponds to the DICOM N-CREATE operation received from modalities.

Parameters

mpps_uid	SOP Instance UID for the MPPS (required, must be unique)
station_ae	Performing station AE Title
modality	Modality type (CT, MR, etc.)
study_uid	Related Study Instance UID
accession_no	Accession number
start_datetime	Procedure step start date/time (YYYYMMDDHHMMSS)

Returns

Result containing the MPPS primary key or error

Definition at line 1349 of file index_database.cpp.

                       {
    return mpps_repository_->create_mpps(mpps_uid, station_ae, modality,
                                         study_uid, accession_no,
                                         start_datetime);
}

create_ups_workitem()

auto kcenon::pacs::storage::index_database::create_ups_workitem ( const ups_workitem & workitem ) -> Result<int64_t>

nodiscard

Create a new UPS workitem (N-CREATE)

Creates a new UPS workitem with state "SCHEDULED". This corresponds to the DICOM N-CREATE operation.

Parameters

workitem

The workitem data (pk field is ignored)

Returns

Result containing the workitem primary key or error

Definition at line 1622 of file index_database.cpp.

                       {
    return ups_repository_->create_ups_workitem(workitem);
}

delete_instance()

auto kcenon::pacs::storage::index_database::delete_instance ( std::string_view sop_uid ) -> VoidResult

nodiscard

Delete an instance by SOP Instance UID.

Parameters

sop_uid

The SOP Instance UID to delete

Returns

VoidResult indicating success or error

Definition at line 1087 of file index_database.cpp.

                                                                         {
    return instance_repository_->delete_instance(sop_uid);
}

delete_mpps()

auto kcenon::pacs::storage::index_database::delete_mpps ( std::string_view mpps_uid ) -> VoidResult

nodiscard

Delete an MPPS record.

Parameters

mpps_uid

The MPPS SOP Instance UID to delete

Returns

VoidResult indicating success or error

Definition at line 1403 of file index_database.cpp.

                                                                      {
    return mpps_repository_->delete_mpps(mpps_uid);
}

delete_patient()

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

nodiscard

Delete a patient by patient ID.

This operation cascades to delete all related studies, series, and instances.

Parameters

patient_id

The patient ID to delete

Returns

VoidResult indicating success or error

Definition at line 779 of file index_database.cpp.

                                                                           {
    return patient_repository_->delete_patient(patient_id);
}

delete_series()

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

nodiscard

Delete a series by Series Instance UID.

This operation cascades to delete all related instances.

Parameters

series_uid

The Series Instance UID to delete

Returns

VoidResult indicating success or error

Definition at line 1000 of file index_database.cpp.

                                                                          {
    auto existing = find_series(series_uid);
    auto result = series_repository_->delete_series(series_uid);
    if (result.is_ok() && existing.has_value() && existing->study_pk > 0) {
        (void)update_modalities_in_study(existing->study_pk);
    }
    return result;
}

delete_study()

auto kcenon::pacs::storage::index_database::delete_study ( std::string_view study_uid ) -> VoidResult

nodiscard

Delete a study by Study Instance UID.

This operation cascades to delete all related series and instances.

Parameters

study_uid

The Study Instance UID to delete

Returns

VoidResult indicating success or error

Definition at line 891 of file index_database.cpp.

                                                                        {
    return study_repository_->delete_study(study_uid);
}

delete_ups_workitem()

auto kcenon::pacs::storage::index_database::delete_ups_workitem ( std::string_view workitem_uid ) -> VoidResult

nodiscard

Delete a UPS workitem.

Only COMPLETED or CANCELED workitems can be deleted unless no subscribers have a deletion lock.

Parameters

workitem_uid

The workitem SOP Instance UID

Returns

VoidResult indicating success or error

Definition at line 1650 of file index_database.cpp.

                  {
    return ups_repository_->delete_ups_workitem(workitem_uid);
}

delete_worklist_item()

auto kcenon::pacs::storage::index_database::delete_worklist_item ( std::string_view step_id, std::string_view accession_no ) -> VoidResult

nodiscard

Delete a worklist item.

Parameters

step_id	Scheduled Procedure Step ID
accession_no	Accession Number

Returns

VoidResult indicating success or error

Definition at line 1562 of file index_database.cpp.

                  {
    return worklist_repository_->delete_worklist_item(step_id, accession_no);
}

find_audit_by_pk()

auto kcenon::pacs::storage::index_database::find_audit_by_pk ( int64_t pk ) const -> std::optional<audit_record>

nodiscard

Find an audit log entry by primary key.

Parameters

pk	The audit log primary key

Returns

Optional containing the audit record if found

Definition at line 1735 of file index_database.cpp.

                                 {
    return audit_repository_->find_audit_by_pk(pk);
}

find_instance()

auto kcenon::pacs::storage::index_database::find_instance ( std::string_view sop_uid ) const -> std::optional<instance_record>

nodiscard

Find an instance by SOP Instance UID.

Parameters

sop_uid

The SOP Instance UID to search for

Returns

Optional containing the instance record if found

Definition at line 1067 of file index_database.cpp.

                                    {
    return instance_repository_->find_instance(sop_uid);
}

find_instance_by_pk()

auto kcenon::pacs::storage::index_database::find_instance_by_pk ( int64_t pk ) const -> std::optional<instance_record>

nodiscard

Find an instance by primary key.

Parameters

pk	The instance's primary key

Returns

Optional containing the instance record if found

Definition at line 1072 of file index_database.cpp.

                                    {
    return instance_repository_->find_instance_by_pk(pk);
}

find_mpps()

auto kcenon::pacs::storage::index_database::find_mpps ( std::string_view mpps_uid ) const -> std::optional<mpps_record>

nodiscard

Find an MPPS by SOP Instance UID.

Parameters

mpps_uid

The MPPS SOP Instance UID to search for

Returns

Optional containing the MPPS record if found

Definition at line 1378 of file index_database.cpp.

                                {
    return mpps_repository_->find_mpps(mpps_uid);
}

find_mpps_by_pk()

auto kcenon::pacs::storage::index_database::find_mpps_by_pk ( int64_t pk ) const -> std::optional<mpps_record>

nodiscard

Find an MPPS by primary key.

Parameters

pk	The MPPS primary key

Returns

Optional containing the MPPS record if found

Definition at line 1383 of file index_database.cpp.

                                {
    return mpps_repository_->find_mpps_by_pk(pk);
}

find_mpps_by_study()

auto kcenon::pacs::storage::index_database::find_mpps_by_study ( std::string_view study_uid ) const -> Result<std::vector<mpps_record>>

nodiscard

Find MPPS records by Study Instance UID.

Parameters

study_uid

The Study Instance UID to search for

Returns

Result containing vector of MPPS records associated with the study or error

Definition at line 1393 of file index_database.cpp.

                                      {
    return mpps_repository_->find_mpps_by_study(study_uid);
}

find_patient()

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

nodiscard

Find a patient by patient ID.

Parameters

patient_id

The patient ID to search for

Returns

Optional containing the patient record if found

Definition at line 764 of file index_database.cpp.

                                   {
    return patient_repository_->find_patient(patient_id);
}

find_patient_by_pk()

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

nodiscard

Find a patient by primary key.

Parameters

pk	The patient's primary key

Returns

Optional containing the patient record if found

Definition at line 769 of file index_database.cpp.

                                   {
    return patient_repository_->find_patient_by_pk(pk);
}

find_series()

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

nodiscard

Find a series by Series Instance UID.

Parameters

series_uid

The Series Instance UID to search for

Returns

Optional containing the series record if found

Definition at line 980 of file index_database.cpp.

                                  {
    return series_repository_->find_series(series_uid);
}

find_series_by_pk()

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

nodiscard

Find a series by primary key.

Parameters

pk	The series's primary key

Returns

Optional containing the series record if found

Definition at line 985 of file index_database.cpp.

                                  {
    return series_repository_->find_series_by_pk(pk);
}

find_study()

auto kcenon::pacs::storage::index_database::find_study ( std::string_view study_uid ) const -> std::optional<study_record>

nodiscard

Find a study by Study Instance UID.

Parameters

study_uid

The Study Instance UID to search for

Returns

Optional containing the study record if found

Definition at line 869 of file index_database.cpp.

                                 {
    return study_repository_->find_study(study_uid);
}

find_study_by_pk()

auto kcenon::pacs::storage::index_database::find_study_by_pk ( int64_t pk ) const -> std::optional<study_record>

nodiscard

Find a study by primary key.

Parameters

pk	The study's primary key

Returns

Optional containing the study record if found

Definition at line 874 of file index_database.cpp.

                                 {
    return study_repository_->find_study_by_pk(pk);
}

find_ups_workitem()

auto kcenon::pacs::storage::index_database::find_ups_workitem ( std::string_view workitem_uid ) const -> std::optional<ups_workitem>

nodiscard

Find a UPS workitem by SOP Instance UID.

Parameters

workitem_uid

The workitem SOP Instance UID

Returns

Optional containing the workitem if found

Definition at line 1640 of file index_database.cpp.

                                 {
    return ups_repository_->find_ups_workitem(workitem_uid);
}

find_worklist_by_pk()

auto kcenon::pacs::storage::index_database::find_worklist_by_pk ( int64_t pk ) const -> std::optional<worklist_item>

nodiscard

Find a worklist item by primary key.

Parameters

pk	The worklist primary key

Returns

Optional containing the worklist item if found

Definition at line 1557 of file index_database.cpp.

                                  {
    return worklist_repository_->find_worklist_by_pk(pk);
}

find_worklist_item()

auto kcenon::pacs::storage::index_database::find_worklist_item ( std::string_view step_id, std::string_view accession_no ) const -> std::optional<worklist_item>

nodiscard

Find a worklist item by step ID and accession number.

Parameters

step_id	Scheduled Procedure Step ID
accession_no	Accession Number

Returns

Optional containing the worklist item if found

Definition at line 1551 of file index_database.cpp.

                                  {
    return worklist_repository_->find_worklist_item(step_id, accession_no);
}

get_file_path()

auto kcenon::pacs::storage::index_database::get_file_path ( std::string_view sop_instance_uid ) const -> Result<std::optional<std::string>>

nodiscard

Get file path for a SOP Instance UID.

Convenience method to quickly look up the file path for a specific DICOM instance without loading the full record.

Parameters

sop_instance_uid

The SOP Instance UID to look up

Returns

Result containing optional file path (empty if not found) or error

Definition at line 1150 of file index_database.cpp.

                                      {
    return instance_repository_->get_file_path(sop_instance_uid);
}

get_series_files()

auto kcenon::pacs::storage::index_database::get_series_files ( std::string_view series_instance_uid ) const -> Result<std::vector<std::string>>

nodiscard

Get all file paths for a series.

Returns all DICOM file paths associated with a series.

Parameters

series_instance_uid

The Series Instance UID

Returns

Result containing vector of file paths for all instances in the series or error

Definition at line 1160 of file index_database.cpp.

                                          {
    return instance_repository_->get_series_files(series_instance_uid);
}

get_storage_stats()

auto kcenon::pacs::storage::index_database::get_storage_stats ( ) const -> Result<storage_stats>

nodiscard

Get storage statistics.

Returns aggregate statistics about the database contents.

Returns

Result containing storage statistics structure or error

Definition at line 1288 of file index_database.cpp.

                                                                      {
    storage_stats stats;
 
    auto patient_count_result = patient_count();
    if (patient_count_result.is_err()) {
        return Result<storage_stats>::err(patient_count_result.error());
    }
    stats.total_patients = patient_count_result.value();
 
    auto study_count_result = study_count();
    if (study_count_result.is_err()) {
        return Result<storage_stats>::err(study_count_result.error());
    }
    stats.total_studies = study_count_result.value();
 
    auto series_count_result = series_count();
    if (series_count_result.is_err()) {
        return Result<storage_stats>::err(series_count_result.error());
    }
    stats.total_series = series_count_result.value();
 
    auto instance_count_result = instance_count();
    if (instance_count_result.is_err()) {
        return Result<storage_stats>::err(instance_count_result.error());
    }
    stats.total_instances = instance_count_result.value();
 
    // Get total file size
    const char* file_size_sql =
        "SELECT COALESCE(SUM(file_size), 0) AS total_size FROM instances;";
 
    sqlite3_stmt* stmt = nullptr;
    auto rc = sqlite3_prepare_v2(db_, file_size_sql, -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        return pacs_error<storage_stats>(
            error_codes::database_query_error,
            kcenon::pacs::compat::format("Failed to prepare query: {}",
                                 sqlite3_errmsg(db_)));
    }
 
    if (sqlite3_step(stmt) == SQLITE_ROW) {
        stats.total_file_size = sqlite3_column_int64(stmt, 0);
    }
    sqlite3_finalize(stmt);
 
    // Get database file size
    if (path_ != ":memory:") {
        std::error_code ec;
        auto size = std::filesystem::file_size(path_, ec);
        if (!ec) {
            stats.database_size = static_cast<int64_t>(size);
        }
    }
 
    return ok(std::move(stats));
}

References kcenon::pacs::error_codes::database_query_error, kcenon::pacs::storage::index_database::storage_stats::database_size, db_, instance_count(), kcenon::pacs::pacs_error(), path_, patient_count(), series_count(), study_count(), kcenon::pacs::storage::index_database::storage_stats::total_file_size, kcenon::pacs::storage::index_database::storage_stats::total_instances, kcenon::pacs::storage::index_database::storage_stats::total_patients, kcenon::pacs::storage::index_database::storage_stats::total_series, and kcenon::pacs::storage::index_database::storage_stats::total_studies.

Here is the call graph for this function:

get_study_files()

auto kcenon::pacs::storage::index_database::get_study_files ( std::string_view study_instance_uid ) const -> Result<std::vector<std::string>>

nodiscard

Get all file paths for a study.

Returns all DICOM file paths associated with a study. Useful for bulk operations like C-MOVE or study export.

Parameters

study_instance_uid

The Study Instance UID

Returns

Result containing vector of file paths for all instances in the study or error

Definition at line 1155 of file index_database.cpp.

                                    {
    return instance_repository_->get_study_files(study_instance_uid);
}

get_ups_subscribers()

auto kcenon::pacs::storage::index_database::get_ups_subscribers ( std::string_view workitem_uid ) const -> Result<std::vector<std::string>>

nodiscard

Get all subscribers for a workitem.

Returns subscribers that would receive notifications for the specified workitem (workitem-specific + global subscriptions).

Parameters

workitem_uid

The workitem SOP Instance UID

Returns

Result containing vector of subscriber AE Titles or error

Definition at line 1684 of file index_database.cpp.

                                    {
    return ups_repository_->get_ups_subscribers(workitem_uid);
}

get_ups_subscriptions()

auto kcenon::pacs::storage::index_database::get_ups_subscriptions ( std::string_view subscriber_ae ) const -> Result<std::vector<ups_subscription>>

nodiscard

Get all subscriptions for a subscriber.

Parameters

subscriber_ae

The subscriber AE Title

Returns

Result containing vector of subscriptions or error

Definition at line 1679 of file index_database.cpp.

                                           {
    return ups_repository_->get_ups_subscriptions(subscriber_ae);
}

initialize_repositories()

auto kcenon::pacs::storage::index_database::initialize_repositories ( ) -> VoidResult

nodiscardprivate

Initialize extracted repositories for facade delegation.

Definition at line 650 of file index_database.cpp.

                                                           {
#ifdef PACS_WITH_DATABASE_SYSTEM
    if (!db_adapter_ || !db_adapter_->is_connected()) {
        return make_error<std::monostate>(
            database_connection_error,
            "PACS database adapter is not connected",
            "storage");
    }
 
    patient_repository_ = std::make_shared<patient_repository>(db_adapter_);
    study_repository_ = std::make_shared<study_repository>(db_adapter_);
    series_repository_ = std::make_shared<series_repository>(db_adapter_);
    instance_repository_ = std::make_shared<instance_repository>(db_adapter_);
    mpps_repository_ = std::make_shared<mpps_repository>(db_adapter_);
    worklist_repository_ = std::make_shared<worklist_repository>(db_adapter_);
    ups_repository_ = std::make_shared<ups_repository>(db_adapter_);
    audit_repository_ = std::make_shared<audit_repository>(db_adapter_);
#else
    if (db_ == nullptr) {
        return make_error<std::monostate>(
            database_connection_error,
            "SQLite database handle is not available",
            "storage");
    }
 
    patient_repository_ = std::make_shared<patient_repository>(db_);
    study_repository_ = std::make_shared<study_repository>(db_);
    series_repository_ = std::make_shared<series_repository>(db_);
    instance_repository_ = std::make_shared<instance_repository>(db_);
    mpps_repository_ = std::make_shared<mpps_repository>(db_);
    worklist_repository_ = std::make_shared<worklist_repository>(db_);
    ups_repository_ = std::make_shared<ups_repository>(db_);
    audit_repository_ = std::make_shared<audit_repository>(db_);
#endif
 
    return ok();
}

References kcenon::pacs::error_codes::database_connection_error.

instance_count() [1/2]

auto kcenon::pacs::storage::index_database::instance_count ( ) const -> Result<size_t>

nodiscard

Get total instance count.

Returns

Result containing number of instances in the database or error

Definition at line 1091 of file index_database.cpp.

                                                            {
    return instance_repository_->instance_count();
}

References instance_repository_.

Referenced by get_storage_stats().

Here is the caller graph for this function:

instance_count() [2/2]

auto kcenon::pacs::storage::index_database::instance_count ( std::string_view series_uid ) const -> Result<size_t>

nodiscard

Get instance count for a specific series.

Parameters

series_uid

The Series Instance UID

Returns

Result containing number of instances for the series or error

Definition at line 1095 of file index_database.cpp.

                      {
    return instance_repository_->instance_count(series_uid);
}

is_open()

auto kcenon::pacs::storage::index_database::is_open ( ) const -> bool

nodiscardnoexcept

Check if the database is open.

Returns

true if the database connection is active

Definition at line 797 of file index_database.cpp.

{ return db_ != nullptr; }

References db_.

list_active_mpps()

auto kcenon::pacs::storage::index_database::list_active_mpps ( std::string_view station_ae ) const -> Result<std::vector<mpps_record>>

nodiscard

List active (IN PROGRESS) MPPS records for a station.

Parameters

station_ae

The station AE Title to filter by

Returns

Result containing vector of active MPPS records or error

Definition at line 1388 of file index_database.cpp.

                                      {
    return mpps_repository_->list_active_mpps(station_ae);
}

list_instances()

auto kcenon::pacs::storage::index_database::list_instances ( std::string_view series_uid ) const -> Result<std::vector<instance_record>>

nodiscard

List all instances for a series.

Parameters

series_uid

The Series Instance UID to list instances for

Returns

Result containing vector of instance records for the series or error

Definition at line 1077 of file index_database.cpp.

                                          {
    return instance_repository_->list_instances(series_uid);
}

list_series()

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

nodiscard

List all series for a study.

Parameters

study_uid

The Study Instance UID to list series for

Returns

Result containing vector of series records for the study or error

Definition at line 990 of file index_database.cpp.

                                        {
    return series_repository_->list_series(study_uid);
}

list_studies()

auto kcenon::pacs::storage::index_database::list_studies ( std::string_view patient_id ) const -> Result<std::vector<study_record>>

nodiscard

List all studies for a patient.

Parameters

patient_id

The patient ID to list studies for

Returns

Result containing vector of study records for the patient or error

Definition at line 879 of file index_database.cpp.

                                       {
    study_query query;
    query.patient_id = std::string(patient_id);
    return study_repository_->search_studies(query);
}

mpps_count() [1/2]

auto kcenon::pacs::storage::index_database::mpps_count ( ) const -> Result<size_t>

nodiscard

Get total MPPS count.

Returns

Result containing number of MPPS records in the database or error

Definition at line 1407 of file index_database.cpp.

                                                        {
    return mpps_repository_->mpps_count();
}

References mpps_repository_.

mpps_count() [2/2]

auto kcenon::pacs::storage::index_database::mpps_count ( std::string_view status ) const -> Result<size_t>

nodiscard

Get MPPS count by status.

Parameters

status

The status to count (IN PROGRESS, COMPLETED, DISCONTINUED)

Returns

Result containing number of MPPS records with the given status or error

Definition at line 1411 of file index_database.cpp.

                                                                             {
    return mpps_repository_->mpps_count(status);
}

native_handle()

auto kcenon::pacs::storage::index_database::native_handle ( ) const -> sqlite3*

nodiscardnoexcept

Get the raw SQLite database handle.

Returns the underlying SQLite database handle for advanced operations such as creating cursors for streaming queries. The returned handle should not be closed or modified directly.

Warning

The returned handle is managed by this class. Do not close it.

Returns

Raw SQLite database handle

Definition at line 1273 of file index_database.cpp.

                                                              {
    return db_;
}

References db_.

open() [1/2]

auto kcenon::pacs::storage::index_database::open ( std::string_view db_path ) -> Result<std::unique_ptr<index_database>>

staticnodiscard

Open or create a database with default configuration.

Opens an existing database or creates a new one at the specified path. Automatically runs pending migrations. Uses default configuration with WAL mode enabled.

Parameters

db_path

Path to the database file, or ":memory:" for in-memory DB

Returns

Result containing the database instance or error

Definition at line 156 of file index_database.cpp.

                                             {
    return open(db_path, index_config{});
}

Referenced by kcenon::pacs::samples::mini_pacs::initialize_storage().

Here is the caller graph for this function:

open() [2/2]

auto kcenon::pacs::storage::index_database::open ( std::string_view db_path, const index_config & config ) -> Result<std::unique_ptr<index_database>>

staticnodiscard

Open or create a database with custom configuration.

Opens an existing database or creates a new one at the specified path. Automatically runs pending migrations.

Parameters

db_path	Path to the database file, or ":memory:" for in-memory DB. When compiled with PACS_WITH_DATABASE_SYSTEM, ":memory:" is silently redirected to a unique temporary file so the database_system SQLite backend can attach to it; WAL mode (if requested via config.wal_mode) is enabled on that rewritten path, and the temp file is removed on close.
config	Configuration options for database behavior

Returns

Result containing the database instance or error

Definition at line 161 of file index_database.cpp.

                                             {
    sqlite3* db = nullptr;
 
    std::string effective_path;
#ifdef PACS_WITH_DATABASE_SYSTEM
    bool remove_on_close = false;
    if (db_path == ":memory:") {
        // database_system's SQLite backend expects a filesystem path, so use
        // a temporary file that both sqlite3 and pacs_database_adapter can open.
        effective_path = create_adapter_compatible_memory_path();
        remove_on_close = true;
    } else {
        effective_path = std::string(db_path);
    }
#else
    effective_path = std::string(db_path);
#endif
 
    auto rc = sqlite3_open_v2(effective_path.c_str(), &db,
                              SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_URI,
                              nullptr);
    if (rc != SQLITE_OK) {
        std::string error_msg =
            db ? sqlite3_errmsg(db) : "Failed to allocate memory";
        if (db) {
            sqlite3_close(db);
        }
        return make_error<std::unique_ptr<index_database>>(
            rc, kcenon::pacs::compat::format("Failed to open database: {}", error_msg),
            "storage");
    }
 
    // Enable foreign keys
    rc = sqlite3_exec(db, "PRAGMA foreign_keys = ON;", nullptr, nullptr,
                      nullptr);
    if (rc != SQLITE_OK) {
        sqlite3_close(db);
        return make_error<std::unique_ptr<index_database>>(
            rc, "Failed to enable foreign keys", "storage");
    }
 
    // Configure WAL mode for better concurrency (except for in-memory DB).
    // Gate on effective_path, not the caller-supplied db_path: under
    // PACS_WITH_DATABASE_SYSTEM, ":memory:" is rewritten to a temp file so
    // database_system's SQLite backend can attach, and that rewritten file
    // both needs and benefits from WAL.
    if (config.wal_mode && effective_path != ":memory:") {
        rc = sqlite3_exec(db, "PRAGMA journal_mode = WAL;", nullptr, nullptr,
                          nullptr);
        if (rc != SQLITE_OK) {
            sqlite3_close(db);
            return make_error<std::unique_ptr<index_database>>(
                rc, "Failed to enable WAL mode", "storage");
        }
    }
 
    // Configure cache size (negative value means KB)
    auto cache_sql =
        kcenon::pacs::compat::format("PRAGMA cache_size = -{};", config.cache_size_mb * 1024);
    rc = sqlite3_exec(db, cache_sql.c_str(), nullptr, nullptr, nullptr);
    if (rc != SQLITE_OK) {
        sqlite3_close(db);
        return make_error<std::unique_ptr<index_database>>(
            rc, "Failed to set cache size", "storage");
    }
 
    // Configure memory-mapped I/O. Use effective_path for the same reason
    // as the WAL gate above.
    if (config.mmap_enabled && effective_path != ":memory:") {
        auto mmap_sql = kcenon::pacs::compat::format("PRAGMA mmap_size = {};", config.mmap_size);
        rc = sqlite3_exec(db, mmap_sql.c_str(), nullptr, nullptr, nullptr);
        if (rc != SQLITE_OK) {
            // mmap failure is not critical, continue with regular I/O
        }
    }
 
    // Set synchronous mode for durability with WAL
    rc = sqlite3_exec(db, "PRAGMA synchronous = NORMAL;", nullptr, nullptr,
                      nullptr);
    if (rc != SQLITE_OK) {
        // Not critical, continue
    }
 
    // Create database instance
    auto instance = std::unique_ptr<index_database>(
        new index_database(db, effective_path));
#ifdef PACS_WITH_DATABASE_SYSTEM
    instance->remove_on_close_ = remove_on_close;
#endif
 
    // Run migrations
    auto migration_result = instance->migration_runner_.run_migrations(db);
    if (migration_result.is_err()) {
        return make_error<std::unique_ptr<index_database>>(
            migration_result.error().code,
            kcenon::pacs::compat::format("Migration failed: {}",
                       migration_result.error().message),
            "storage");
    }
 
#ifdef PACS_WITH_DATABASE_SYSTEM
    // Initialize database_system for query building
    // Support in-memory databases for testing (Issue #625)
    auto db_init_result = instance->initialize_database_system();
    if (db_init_result.is_err()) {
        // unified_database_system may not have SQLite backend support in the
        // current build, so keep the direct SQLite path available.
    }
#endif
 
    auto repository_result = instance->initialize_repositories();
    if (repository_result.is_err()) {
        return make_error<std::unique_ptr<index_database>>(
            repository_result.error().code,
            kcenon::pacs::compat::format("Repository initialization failed: {}",
                                 repository_result.error().message),
            "storage");
    }
 
    return instance;
}

References code.

operator=() [1/2]

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

delete

operator=() [2/2]

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

noexcept

Definition at line 707 of file index_database.cpp.

                       {
    if (this != &other) {
        patient_repository_.reset();
        study_repository_.reset();
        series_repository_.reset();
        instance_repository_.reset();
        mpps_repository_.reset();
        worklist_repository_.reset();
        ups_repository_.reset();
        audit_repository_.reset();
#ifdef PACS_WITH_DATABASE_SYSTEM
        if (db_adapter_) {
            (void)db_adapter_->disconnect();
        }
        db_adapter_ = std::move(other.db_adapter_);
#endif
        if (db_) {
            sqlite3_close(db_);
        }
        if (remove_on_close_) {
            remove_database_sidecars(path_);
        }
        db_ = other.db_;
        path_ = std::move(other.path_);
        remove_on_close_ = other.remove_on_close_;
        patient_repository_ = std::move(other.patient_repository_);
        study_repository_ = std::move(other.study_repository_);
        series_repository_ = std::move(other.series_repository_);
        instance_repository_ = std::move(other.instance_repository_);
        mpps_repository_ = std::move(other.mpps_repository_);
        worklist_repository_ = std::move(other.worklist_repository_);
        ups_repository_ = std::move(other.ups_repository_);
        audit_repository_ = std::move(other.audit_repository_);
        other.db_ = nullptr;
        other.remove_on_close_ = false;
    }
    return *this;
}

parse_audit_row()

auto kcenon::pacs::storage::index_database::parse_audit_row ( void * stmt ) const -> audit_record

nodiscardprivate

Parse an audit record from a prepared statement.

Definition at line 1749 of file index_database.cpp.

                                                                         {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    audit_record record;
 
    record.pk = sqlite3_column_int64(stmt, 0);
    record.event_type = get_text(stmt, 1);
    record.outcome = get_text(stmt, 2);
 
    auto timestamp_str = get_text(stmt, 3);
    record.timestamp = parse_datetime(timestamp_str.c_str());
 
    record.user_id = get_text(stmt, 4);
    record.source_ae = get_text(stmt, 5);
    record.target_ae = get_text(stmt, 6);
    record.source_ip = get_text(stmt, 7);
    record.patient_id = get_text(stmt, 8);
    record.study_uid = get_text(stmt, 9);
    record.message = get_text(stmt, 10);
    record.details = get_text(stmt, 11);
 
    return record;
}

parse_instance_row()

auto kcenon::pacs::storage::index_database::parse_instance_row ( void * stmt ) const -> instance_record

nodiscardprivate

Parse an instance record from a prepared statement.

Definition at line 1100 of file index_database.cpp.

                       {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    instance_record record;
 
    record.pk = sqlite3_column_int64(stmt, 0);
    record.series_pk = sqlite3_column_int64(stmt, 1);
    record.sop_uid = get_text(stmt, 2);
    record.sop_class_uid = get_text(stmt, 3);
 
    // Handle nullable instance_number
    if (sqlite3_column_type(stmt, 4) != SQLITE_NULL) {
        record.instance_number = sqlite3_column_int(stmt, 4);
    }
 
    record.transfer_syntax = get_text(stmt, 5);
    record.content_date = get_text(stmt, 6);
    record.content_time = get_text(stmt, 7);
 
    // Handle nullable image properties
    if (sqlite3_column_type(stmt, 8) != SQLITE_NULL) {
        record.rows = sqlite3_column_int(stmt, 8);
    }
 
    if (sqlite3_column_type(stmt, 9) != SQLITE_NULL) {
        record.columns = sqlite3_column_int(stmt, 9);
    }
 
    if (sqlite3_column_type(stmt, 10) != SQLITE_NULL) {
        record.bits_allocated = sqlite3_column_int(stmt, 10);
    }
 
    if (sqlite3_column_type(stmt, 11) != SQLITE_NULL) {
        record.number_of_frames = sqlite3_column_int(stmt, 11);
    }
 
    record.file_path = get_text(stmt, 12);
    record.file_size = sqlite3_column_int64(stmt, 13);
    record.file_hash = get_text(stmt, 14);
 
    auto created_str = get_text(stmt, 15);
    record.created_at = parse_datetime(created_str.c_str());
 
    return record;
}

parse_mpps_row()

auto kcenon::pacs::storage::index_database::parse_mpps_row ( void * stmt ) const -> mpps_record

nodiscardprivate

Parse an MPPS record from a prepared statement.

Definition at line 1415 of file index_database.cpp.

                                                                       {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    mpps_record record;
 
    record.pk = sqlite3_column_int64(stmt, 0);
    record.mpps_uid = get_text(stmt, 1);
    record.status = get_text(stmt, 2);
    record.start_datetime = get_text(stmt, 3);
    record.end_datetime = get_text(stmt, 4);
    record.station_ae = get_text(stmt, 5);
    record.station_name = get_text(stmt, 6);
    record.modality = get_text(stmt, 7);
    record.study_uid = get_text(stmt, 8);
    record.accession_no = get_text(stmt, 9);
    record.scheduled_step_id = get_text(stmt, 10);
    record.requested_proc_id = get_text(stmt, 11);
    record.performed_series = get_text(stmt, 12);
 
    auto created_str = get_text(stmt, 13);
    record.created_at = parse_datetime(created_str.c_str());
 
    auto updated_str = get_text(stmt, 14);
    record.updated_at = parse_datetime(updated_str.c_str());
 
    return record;
}

parse_patient_row()

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

nodiscardprivate

Parse a patient record from a prepared statement.

Definition at line 803 of file index_database.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;
}

parse_series_row()

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

nodiscardprivate

Parse a series record from a prepared statement.

Definition at line 1017 of file index_database.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);
 
    // Handle nullable series_number
    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);
 
    auto created_str = get_text(stmt, 9);
    record.created_at = parse_datetime(created_str.c_str());
 
    auto updated_str = get_text(stmt, 10);
    record.updated_at = parse_datetime(updated_str.c_str());
 
    return record;
}

parse_study_row()

auto kcenon::pacs::storage::index_database::parse_study_row ( void * stmt ) const -> study_record

nodiscardprivate

Parse a study record from a prepared statement.

Definition at line 912 of file index_database.cpp.

                                                                         {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    study_record record;
 
    record.pk = sqlite3_column_int64(stmt, 0);
    record.patient_pk = sqlite3_column_int64(stmt, 1);
    record.study_uid = get_text(stmt, 2);
    record.study_id = get_text(stmt, 3);
    record.study_date = get_text(stmt, 4);
    record.study_time = get_text(stmt, 5);
    record.accession_number = get_text(stmt, 6);
    record.referring_physician = get_text(stmt, 7);
    record.study_description = get_text(stmt, 8);
    record.modalities_in_study = get_text(stmt, 9);
    record.num_series = sqlite3_column_int(stmt, 10);
    record.num_instances = sqlite3_column_int(stmt, 11);
 
    auto created_str = get_text(stmt, 12);
    record.created_at = parse_datetime(created_str.c_str());
 
    auto updated_str = get_text(stmt, 13);
    record.updated_at = parse_datetime(updated_str.c_str());
 
    return record;
}

parse_ups_workitem_row()

auto kcenon::pacs::storage::index_database::parse_ups_workitem_row ( void * stmt ) const -> ups_workitem

nodiscardprivate

Parse a UPS workitem record from a prepared statement.

Definition at line 1689 of file index_database.cpp.

                                                                                {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    ups_workitem item;
 
    item.pk = sqlite3_column_int64(stmt, 0);
    item.workitem_uid = get_text(stmt, 1);
    item.state = get_text(stmt, 2);
    item.procedure_step_label = get_text(stmt, 3);
    item.worklist_label = get_text(stmt, 4);
    item.priority = get_text(stmt, 5);
    item.scheduled_start_datetime = get_text(stmt, 6);
    item.expected_completion_datetime = get_text(stmt, 7);
    item.scheduled_station_name = get_text(stmt, 8);
    item.scheduled_station_class = get_text(stmt, 9);
    item.scheduled_station_geographic = get_text(stmt, 10);
    item.scheduled_human_performers = get_text(stmt, 11);
    item.input_information = get_text(stmt, 12);
    item.performing_ae = get_text(stmt, 13);
    item.progress_description = get_text(stmt, 14);
    item.progress_percent = sqlite3_column_int(stmt, 15);
    item.output_information = get_text(stmt, 16);
    item.transaction_uid = get_text(stmt, 17);
 
    auto created_str = get_text(stmt, 18);
    item.created_at = parse_datetime(created_str.c_str());
 
    auto updated_str = get_text(stmt, 19);
    item.updated_at = parse_datetime(updated_str.c_str());
 
    return item;
}

parse_worklist_row()

auto kcenon::pacs::storage::index_database::parse_worklist_row ( void * stmt ) const -> worklist_item

nodiscardprivate

Parse a worklist record from a prepared statement.

Definition at line 1586 of file index_database.cpp.

                                                                             {
    auto* stmt = static_cast<sqlite3_stmt*>(stmt_ptr);
    worklist_item item;
 
    item.pk = sqlite3_column_int64(stmt, 0);
    item.step_id = get_text(stmt, 1);
    item.step_status = get_text(stmt, 2);
    item.patient_id = get_text(stmt, 3);
    item.patient_name = get_text(stmt, 4);
    item.birth_date = get_text(stmt, 5);
    item.sex = get_text(stmt, 6);
    item.accession_no = get_text(stmt, 7);
    item.requested_proc_id = get_text(stmt, 8);
    item.study_uid = get_text(stmt, 9);
    item.scheduled_datetime = get_text(stmt, 10);
    item.station_ae = get_text(stmt, 11);
    item.station_name = get_text(stmt, 12);
    item.modality = get_text(stmt, 13);
    item.procedure_desc = get_text(stmt, 14);
    item.protocol_code = get_text(stmt, 15);
    item.referring_phys = get_text(stmt, 16);
    item.referring_phys_id = get_text(stmt, 17);
 
    auto created_str = get_text(stmt, 18);
    item.created_at = parse_datetime(created_str.c_str());
 
    auto updated_str = get_text(stmt, 19);
    item.updated_at = parse_datetime(updated_str.c_str());
 
    return item;
}

path()

auto kcenon::pacs::storage::index_database::path ( ) const -> std::string_view

nodiscard

Get the database file path.

Returns

Path to the database file

Definition at line 791 of file index_database.cpp.

{ return path_; }

References path_.

patient_count()

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

nodiscard

Get total patient count.

Returns

Result containing number of patients in the database or error

Definition at line 783 of file index_database.cpp.

                                                           {
    return patient_repository_->patient_count();
}

References patient_repository_.

Referenced by get_storage_stats().

Here is the caller graph for this function:

query_audit_log()

auto kcenon::pacs::storage::index_database::query_audit_log ( const audit_query & query ) const -> Result<std::vector<audit_record>>

nodiscard

Query audit log entries.

Returns audit log entries matching the query criteria.

Parameters

query

Query parameters with optional filters

Returns

Result containing vector of matching audit records or error

Definition at line 1730 of file index_database.cpp.

                                       {
    return audit_repository_->query_audit_log(query);
}

query_worklist()

auto kcenon::pacs::storage::index_database::query_worklist ( const worklist_query & query ) const -> Result<std::vector<worklist_item>>

nodiscard

Query worklist items.

Returns worklist items matching the query criteria. By default, only returns items with status 'SCHEDULED'. Used for MWL C-FIND operations.

Parameters

query

Query parameters with optional filters

Returns

Result containing vector of matching worklist items or error

Definition at line 1546 of file index_database.cpp.

                                        {
    return worklist_repository_->query_worklist(query);
}

schema_version()

auto kcenon::pacs::storage::index_database::schema_version ( ) const -> int

nodiscard

Get the current schema version.

Returns

Current schema version number

Definition at line 793 of file index_database.cpp.

                                                 {
    return migration_runner_.get_current_version(db_);
}

References db_, kcenon::pacs::storage::migration_runner::get_current_version(), and migration_runner_.

Here is the call graph for this function:

search_instances()

auto kcenon::pacs::storage::index_database::search_instances ( const instance_query & query ) const -> Result<std::vector<instance_record>>

nodiscard

Search instances with query criteria.

Can filter by series UID, SOP class, and other attributes.

Parameters

query

Query parameters with optional filters

Returns

Result containing vector of matching instance records or error

Definition at line 1082 of file index_database.cpp.

                                          {
    return instance_repository_->search_instances(query);
}

search_mpps()

auto kcenon::pacs::storage::index_database::search_mpps ( const mpps_query & query ) const -> Result<std::vector<mpps_record>>

nodiscard

Search MPPS records with query criteria.

Parameters

query

Query parameters with optional filters

Returns

Result containing vector of matching MPPS records or error

Definition at line 1398 of file index_database.cpp.

                                      {
    return mpps_repository_->search_mpps(query);
}

search_patients()

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

nodiscard

Search patients with query criteria.

Supports wildcard matching using '' character.

• "Doe</em>" matches names starting with "Doe"
• "*John" matches names ending with "John"
• "*oh*" matches names containing "oh"

Parameters

query

Query parameters with optional filters

Returns

Result containing vector of matching patient records or error

Definition at line 774 of file index_database.cpp.

                                         {
    return patient_repository_->search_patients(query);
}

search_series()

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

nodiscard

Search series with query criteria.

Supports wildcard matching using '*' character. Can filter by study UID, modality, and other attributes.

Parameters

query

Query parameters with optional filters

Returns

Result containing vector of matching series records or error

Definition at line 995 of file index_database.cpp.

                                        {
    return series_repository_->search_series(query);
}

search_studies()

auto kcenon::pacs::storage::index_database::search_studies ( const study_query & query ) const -> Result<std::vector<study_record>>

nodiscard

Search studies with query criteria.

Supports wildcard matching using '*' character. Can filter by patient attributes, study attributes, and date ranges.

Parameters

query

Query parameters with optional filters

Returns

Result containing vector of matching study records or error

Definition at line 886 of file index_database.cpp.

                                       {
    return study_repository_->search_studies(query);
}

search_ups_workitems()

auto kcenon::pacs::storage::index_database::search_ups_workitems ( const ups_workitem_query & query ) const -> Result<std::vector<ups_workitem>>

nodiscard

Search UPS workitems with query criteria.

Used for UPS C-FIND operations.

Parameters

query

Query parameters with optional filters

Returns

Result containing vector of matching workitems or error

Definition at line 1645 of file index_database.cpp.

                                       {
    return ups_repository_->search_ups_workitems(query);
}

series_count() [1/2]

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

nodiscard

Get total series count.

Returns

Result containing number of series in the database or error

Definition at line 1009 of file index_database.cpp.

                                                          {
    return series_repository_->series_count();
}

References series_repository_.

Referenced by get_storage_stats().

Here is the caller graph for this function:

series_count() [2/2]

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

nodiscard

Get series count for a specific study.

Parameters

study_uid

The Study Instance UID

Returns

Result containing number of series for the study or error

Definition at line 1013 of file index_database.cpp.

                                                                                  {
    return series_repository_->series_count(study_uid);
}

study_count() [1/2]

auto kcenon::pacs::storage::index_database::study_count ( ) const -> Result<size_t>

nodiscard

Get total study count.

Returns

Result containing number of studies in the database or error

Definition at line 895 of file index_database.cpp.

                                                         {
    return study_repository_->study_count();
}

References study_repository_.

Referenced by get_storage_stats().

Here is the caller graph for this function:

study_count() [2/2]

auto kcenon::pacs::storage::index_database::study_count ( std::string_view patient_id ) const -> Result<size_t>

nodiscard

Get study count for a specific patient.

Parameters

patient_id

The patient ID

Returns

Result containing number of studies for the patient or error

Definition at line 899 of file index_database.cpp.

                                                                                  {
    auto patient = patient_repository_->find_patient(patient_id);
    if (!patient.has_value()) {
        return ok(static_cast<size_t>(0));
    }
    return study_repository_->study_count_for_patient(patient->pk);
}

subscribe_ups()

auto kcenon::pacs::storage::index_database::subscribe_ups ( const ups_subscription & subscription ) -> Result<int64_t>

nodiscard

Subscribe to UPS workitem events.

Parameters

subscription

The subscription data (pk field is ignored)

Returns

Result containing the subscription primary key or error

Definition at line 1668 of file index_database.cpp.

                       {
    return ups_repository_->subscribe_ups(subscription);
}

to_like_pattern()

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

staticnodiscardprivate

Convert wildcard pattern to SQL LIKE pattern.

Converts '*' to '' for SQL LIKE matching

Definition at line 825 of file index_database.cpp.

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

unsubscribe_ups()

auto kcenon::pacs::storage::index_database::unsubscribe_ups ( std::string_view subscriber_ae, std::string_view workitem_uid = "" ) -> VoidResult

nodiscard

Unsubscribe from UPS workitem events.

Parameters

subscriber_ae	The subscriber AE Title
workitem_uid	The workitem UID (empty for global unsubscribe)

Returns

VoidResult indicating success or error

Definition at line 1673 of file index_database.cpp.

                  {
    return ups_repository_->unsubscribe_ups(subscriber_ae, workitem_uid);
}

update_modalities_in_study()

auto kcenon::pacs::storage::index_database::update_modalities_in_study ( int64_t study_pk ) -> VoidResult

nodiscard

Update modalities in study (denormalized field)

Called after series insert/delete to update the modalities_in_study field.

Parameters

study_pk

The study's primary key

Returns

VoidResult indicating success or error

Definition at line 907 of file index_database.cpp.

                  {
    return study_repository_->update_modalities_in_study(study_pk);
}

update_mpps() [1/2]

auto kcenon::pacs::storage::index_database::update_mpps ( const mpps_record & record ) -> VoidResult

nodiscard

Update an existing MPPS record with partial data.

Only non-empty fields in the record will be updated.

Parameters

record

MPPS record with fields to update (mpps_uid required)

Returns

VoidResult indicating success or error

Definition at line 1374 of file index_database.cpp.

                                                                        {
    return mpps_repository_->update_mpps(record);
}

update_mpps() [2/2]

auto kcenon::pacs::storage::index_database::update_mpps ( std::string_view mpps_uid, std::string_view new_status, std::string_view end_datetime = "", std::string_view performed_series = "" ) -> VoidResult

nodiscard

Update an existing MPPS record (N-SET)

Updates the MPPS status and attributes. This corresponds to the DICOM N-SET operation. Status transitions are validated:

• IN PROGRESS -> COMPLETED or DISCONTINUED (allowed)
• COMPLETED or DISCONTINUED -> any (not allowed, final states)

Parameters

mpps_uid	SOP Instance UID of the MPPS to update
new_status	New status (COMPLETED or DISCONTINUED)
end_datetime	Procedure step end date/time
performed_series	JSON string of performed series information

Returns

VoidResult indicating success or error

Definition at line 1365 of file index_database.cpp.

                  {
    return mpps_repository_->update_mpps(mpps_uid, new_status, end_datetime,
                                         performed_series);
}

update_ups_workitem()

auto kcenon::pacs::storage::index_database::update_ups_workitem ( const ups_workitem & workitem ) -> VoidResult

nodiscard

Update an existing UPS workitem.

Updates the workitem attributes. State transitions are validated:

• SCHEDULED -> IN PROGRESS or CANCELED (allowed)
• IN PROGRESS -> COMPLETED or CANCELED (allowed)
• COMPLETED or CANCELED -> any (not allowed, final states)

Parameters

workitem

Updated workitem data (workitem_uid required)

Returns

VoidResult indicating success or error

Definition at line 1627 of file index_database.cpp.

                  {
    return ups_repository_->update_ups_workitem(workitem);
}

update_worklist_status()

auto kcenon::pacs::storage::index_database::update_worklist_status ( std::string_view step_id, std::string_view accession_no, std::string_view new_status ) -> VoidResult

nodiscard

Update worklist item status.

Called when MPPS is received to update the corresponding worklist item status from SCHEDULED to STARTED or COMPLETED.

Parameters

step_id	Scheduled Procedure Step ID
accession_no	Accession Number
new_status	New status (STARTED or COMPLETED)

Returns

VoidResult indicating success or error

Definition at line 1538 of file index_database.cpp.

                  {
    return worklist_repository_->update_worklist_status(step_id, accession_no,
                                                        new_status);
}

ups_workitem_count() [1/2]

auto kcenon::pacs::storage::index_database::ups_workitem_count ( ) const -> Result<size_t>

nodiscard

Get total UPS workitem count.

Returns

Result containing number of workitems in the database or error

Definition at line 1655 of file index_database.cpp.

                                                                {
    return ups_repository_->ups_workitem_count();
}

References ups_repository_.

ups_workitem_count() [2/2]

auto kcenon::pacs::storage::index_database::ups_workitem_count ( std::string_view state ) const -> Result<size_t>

nodiscard

Get UPS workitem count by state.

Parameters

state

The state to count

Returns

Result containing number of workitems with the given state or error

Definition at line 1659 of file index_database.cpp.

                      {
    return ups_repository_->ups_workitem_count(state);
}

upsert_instance() [1/2]

auto kcenon::pacs::storage::index_database::upsert_instance ( const instance_record & record ) -> Result<int64_t>

nodiscard

Insert or update an instance record with full details.

Parameters

record

Complete instance record (pk field is ignored for insert)

Returns

Result containing the instance's primary key or error

Definition at line 1062 of file index_database.cpp.

                       {
    return instance_repository_->upsert_instance(record);
}

upsert_instance() [2/2]

auto kcenon::pacs::storage::index_database::upsert_instance ( int64_t series_pk, std::string_view sop_uid, std::string_view sop_class_uid, std::string_view file_path, int64_t file_size, std::string_view transfer_syntax = "", std::optional< int > instance_number = std::nullopt ) -> Result<int64_t>

nodiscard

Insert or update an instance record.

If an instance with the same sop_uid exists, updates the record. Otherwise, inserts a new record.

Parameters

series_pk	Foreign key to the series (required)
sop_uid	SOP Instance UID (required, max 64 chars)
sop_class_uid	SOP Class UID (required)
file_path	Path to the stored DICOM file (required)
file_size	Size of the file in bytes (required, >= 0)
transfer_syntax	Transfer Syntax UID
instance_number	Instance number

Returns

Result containing the instance's primary key or error

Definition at line 1049 of file index_database.cpp.

                       {
    return instance_repository_->upsert_instance(
        series_pk, sop_uid, sop_class_uid, file_path, file_size,
        transfer_syntax, instance_number);
}

upsert_patient() [1/2]

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

nodiscard

Insert or update a patient record with full details.

Parameters

record

Complete patient record (pk field is ignored for insert)

Returns

Result containing the patient's primary key or error

Definition at line 759 of file index_database.cpp.

                       {
    return patient_repository_->upsert_patient(record);
}

upsert_patient() [2/2]

auto kcenon::pacs::storage::index_database::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

Insert or update a patient record.

If a patient with the same patient_id exists, updates the record. Otherwise, inserts a new record.

Parameters

patient_id	Patient ID (required, max 64 chars)
patient_name	Patient's name in DICOM PN format
birth_date	Birth date in YYYYMMDD format
sex	Sex code (M, F, O)

Returns

Result containing the patient's primary key or error

Definition at line 751 of file index_database.cpp.

                                                                           {
    return patient_repository_->upsert_patient(patient_id, patient_name,
                                               birth_date, sex);
}

upsert_series() [1/2]

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

nodiscard

Insert or update a series record with full details.

Parameters

record

Complete series record (pk field is ignored for insert)

Returns

Result containing the series's primary key or error

Definition at line 961 of file index_database.cpp.

                       {
    auto existing = find_series(record.series_uid);
    auto result = series_repository_->upsert_series(record);
    if (result.is_err()) {
        return result;
    }
 
    if (existing.has_value() && existing->study_pk > 0 &&
        existing->study_pk != record.study_pk) {
        (void)update_modalities_in_study(existing->study_pk);
    }
    if (record.study_pk > 0) {
        (void)update_modalities_in_study(record.study_pk);
    }
 
    return result;
}

upsert_series() [2/2]

auto kcenon::pacs::storage::index_database::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

Insert or update a series record.

If a series with the same series_uid exists, updates the record. Otherwise, inserts a new record.

Parameters

study_pk	Foreign key to the study (required)
series_uid	Series Instance UID (required, max 64 chars)
modality	Modality (e.g., CT, MR)
series_number	Series number
series_description	Series description
body_part_examined	Body part examined
station_name	Station name

Returns

Result containing the series's primary key or error

Definition at line 942 of file index_database.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);
}

upsert_study() [1/2]

auto kcenon::pacs::storage::index_database::upsert_study ( const study_record & record ) -> Result<int64_t>

nodiscard

Insert or update a study record with full details.

Parameters

record

Complete study record (pk field is ignored for insert)

Returns

Result containing the study's primary key or error

Definition at line 864 of file index_database.cpp.

                       {
    return study_repository_->upsert_study(record);
}

upsert_study() [2/2]

auto kcenon::pacs::storage::index_database::upsert_study ( int64_t patient_pk, std::string_view study_uid, std::string_view study_id = "", std::string_view study_date = "", std::string_view study_time = "", std::string_view accession_number = "", std::string_view referring_physician = "", std::string_view study_description = "" ) -> Result<int64_t>

nodiscard

Insert or update a study record.

If a study with the same study_uid exists, updates the record. Otherwise, inserts a new record.

Parameters

patient_pk	Foreign key to the patient (required)
study_uid	Study Instance UID (required, max 64 chars)
study_id	Study ID
study_date	Study date in YYYYMMDD format
study_time	Study time in HHMMSS format
accession_number	Accession number
referring_physician	Referring physician's name
study_description	Study description

Returns

Result containing the study's primary key or error

Definition at line 850 of file index_database.cpp.

                       {
    return study_repository_->upsert_study(
        patient_pk, study_uid, study_id, study_date, study_time,
        accession_number, referring_physician, study_description);
}

vacuum()

auto kcenon::pacs::storage::index_database::vacuum ( ) -> VoidResult

nodiscard

Reclaim unused space in the database.

VACUUM rebuilds the database file, repacking it into a minimal amount of disk space. This can reduce file size after large deletions but may take time for large databases.

Note: This operation requires exclusive access and may take significant time for large databases.

Returns

VoidResult indicating success or error

Definition at line 1169 of file index_database.cpp.

                                          {
#ifdef PACS_WITH_DATABASE_SYSTEM
    // Prefer pacs_database_adapter for unified database operations (Issue #616)
    if (db_adapter_ && db_adapter_->is_connected()) {
        return db_adapter_->execute("VACUUM;");
    }
#endif
 
    auto rc = sqlite3_exec(db_, "VACUUM;", nullptr, nullptr, nullptr);
    if (rc != SQLITE_OK) {
        return make_error<std::monostate>(
            rc, kcenon::pacs::compat::format("VACUUM failed: {}", sqlite3_errmsg(db_)),
            "storage");
    }
    return ok();
}

verify_integrity()

auto kcenon::pacs::storage::index_database::verify_integrity ( ) const -> VoidResult

nodiscard

Verify database integrity.

Runs SQLite's integrity check to verify the database structure and detect any corruption issues.

Returns

VoidResult indicating success or error with details

Definition at line 1203 of file index_database.cpp.

                                                          {
#ifdef PACS_WITH_DATABASE_SYSTEM
    // Prefer pacs_database_adapter for unified database operations (Issue #616)
    if (db_adapter_ && db_adapter_->is_connected()) {
        auto result = db_adapter_->select("PRAGMA integrity_check;");
        if (result.is_err()) {
            return make_error<std::monostate>(
                result.error().code, result.error().message, "storage");
        }
 
        for (const auto& row : result.value()) {
            auto it = row.find("integrity_check");
            if (it != row.end() && it->second != "ok") {
                return make_error<std::monostate>(
                    -1, kcenon::pacs::compat::format("Integrity check failed: {}", it->second),
                    "storage");
            }
        }
        return ok();
    }
#endif
 
    const char* sql = "PRAGMA integrity_check;";
 
    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 integrity check: {}",
                       sqlite3_errmsg(db_)),
            "storage");
    }
 
    std::string result;
    while (sqlite3_step(stmt) == SQLITE_ROW) {
        result = get_text(stmt, 0);
        if (result != "ok") {
            sqlite3_finalize(stmt);
            return make_error<std::monostate>(
                -1, kcenon::pacs::compat::format("Integrity check failed: {}", result),
                "storage");
        }
    }
 
    sqlite3_finalize(stmt);
    return ok();
}

References db_.

worklist_count() [1/2]

auto kcenon::pacs::storage::index_database::worklist_count ( ) const -> Result<size_t>

nodiscard

Get total worklist count.

Returns

Result containing number of worklist items in the database or error

Definition at line 1578 of file index_database.cpp.

                                                            {
    return worklist_repository_->worklist_count();
}

References worklist_repository_.

worklist_count() [2/2]

auto kcenon::pacs::storage::index_database::worklist_count ( std::string_view status ) const -> Result<size_t>

nodiscard

Get worklist count by status.

Parameters

status

The status to count (SCHEDULED, STARTED, COMPLETED)

Returns

Result containing number of worklist items with the given status or error

Definition at line 1582 of file index_database.cpp.

                                                                                 {
    return worklist_repository_->worklist_count(status);
}

Member Data Documentation

audit_repository_

std::shared_ptr<audit_repository> kcenon::pacs::storage::index_database::audit_repository_

mutableprivate

Definition at line 1358 of file index_database.h.

Referenced by audit_count(), and ~index_database().

db_

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

private

SQLite database handle (used for migrations and fallback)

Definition at line 1342 of file index_database.h.

{nullptr};

Referenced by get_storage_stats(), is_open(), native_handle(), schema_version(), verify_integrity(), and ~index_database().

instance_repository_

std::shared_ptr<instance_repository> kcenon::pacs::storage::index_database::instance_repository_

mutableprivate

Definition at line 1354 of file index_database.h.

Referenced by instance_count(), and ~index_database().

migration_runner_

migration_runner kcenon::pacs::storage::index_database::migration_runner_

private

Migration runner for schema management.

Definition at line 1361 of file index_database.h.

Referenced by schema_version().

mpps_repository_

std::shared_ptr<mpps_repository> kcenon::pacs::storage::index_database::mpps_repository_

mutableprivate

Definition at line 1355 of file index_database.h.

Referenced by mpps_count(), and ~index_database().

path_

std::string kcenon::pacs::storage::index_database::path_

private

Database file path.

Definition at line 1345 of file index_database.h.

Referenced by get_storage_stats(), path(), and ~index_database().

patient_repository_

std::shared_ptr<patient_repository> kcenon::pacs::storage::index_database::patient_repository_

mutableprivate

Extracted repositories used by the facade API.

Definition at line 1351 of file index_database.h.

Referenced by patient_count(), and ~index_database().

remove_on_close_

bool kcenon::pacs::storage::index_database::remove_on_close_ {false}

private

Remove the backing file on destruction for adapter-compatible memory DBs.

Definition at line 1348 of file index_database.h.

{false};

Referenced by ~index_database().

series_repository_

std::shared_ptr<series_repository> kcenon::pacs::storage::index_database::series_repository_

mutableprivate

Definition at line 1353 of file index_database.h.

Referenced by series_count(), and ~index_database().

study_repository_

std::shared_ptr<study_repository> kcenon::pacs::storage::index_database::study_repository_

mutableprivate

Definition at line 1352 of file index_database.h.

Referenced by study_count(), and ~index_database().

ups_repository_

std::shared_ptr<ups_repository> kcenon::pacs::storage::index_database::ups_repository_

mutableprivate

Definition at line 1357 of file index_database.h.

Referenced by ups_workitem_count(), and ~index_database().

worklist_repository_

std::shared_ptr<worklist_repository> kcenon::pacs::storage::index_database::worklist_repository_

mutableprivate

Definition at line 1356 of file index_database.h.

Referenced by worklist_count(), and ~index_database().

---

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

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