pacs_database_adapter.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <kcenon/common/patterns/result.h>
 
#include <chrono>
#include <cstdint>
#include <filesystem>
#include <functional>
#include <map>
#include <memory>
#include <string>
#include <vector>
 
#ifdef PACS_WITH_DATABASE_SYSTEM
#include <database/database_types.h>
#include <database/integrated/unified_database_system.h>
#include <database/query_builder.h>
#endif
 
namespace kcenon::pacs::storage {
 
template <typename T>
using Result = kcenon::common::Result<T>;
 
using VoidResult = kcenon::common::VoidResult;
 
#ifdef PACS_WITH_DATABASE_SYSTEM
 
using database_row = std::map<std::string, std::string>;
 
struct database_result {
    std::vector<database_row> rows;
 
    std::size_t affected_rows{0};
 
    std::chrono::microseconds execution_time{0};
 
    [[nodiscard]] auto empty() const noexcept -> bool { return rows.empty(); }
 
    [[nodiscard]] auto size() const noexcept -> std::size_t {
        return rows.size();
    }
 
    [[nodiscard]] auto operator[](std::size_t index) const
        -> const database_row& {
        return rows.at(index);
    }
 
    [[nodiscard]] auto operator[](std::size_t index) -> database_row& {
        return rows.at(index);
    }
 
    // Iterator support
    auto begin() { return rows.begin(); }
    auto end() { return rows.end(); }
    [[nodiscard]] auto begin() const { return rows.begin(); }
    [[nodiscard]] auto end() const { return rows.end(); }
};
 
// Forward declaration
class scoped_transaction;
class pacs_database_adapter;
class pacs_unit_of_work;
 
class pacs_storage_session {
public:
    explicit pacs_storage_session(pacs_database_adapter& adapter) noexcept;
 
    [[nodiscard]] auto create_query_builder() const -> database::query_builder;
    [[nodiscard]] auto select(const std::string& query)
        -> Result<database_result>;
    [[nodiscard]] auto insert(const std::string& query) -> Result<uint64_t>;
    [[nodiscard]] auto update(const std::string& query) -> Result<uint64_t>;
    [[nodiscard]] auto remove(const std::string& query) -> Result<uint64_t>;
    [[nodiscard]] auto execute(const std::string& query) -> VoidResult;
    [[nodiscard]] auto last_insert_rowid() const -> int64_t;
    [[nodiscard]] auto begin_unit_of_work() -> Result<pacs_unit_of_work>;
 
private:
    pacs_database_adapter* adapter_{nullptr};
};
 
class pacs_unit_of_work {
public:
    pacs_unit_of_work() = default;
    pacs_unit_of_work(pacs_database_adapter& adapter, bool active) noexcept;
    ~pacs_unit_of_work();
 
    pacs_unit_of_work(const pacs_unit_of_work&) = delete;
    auto operator=(const pacs_unit_of_work&) -> pacs_unit_of_work& = delete;
    pacs_unit_of_work(pacs_unit_of_work&& other) noexcept;
    auto operator=(pacs_unit_of_work&& other) noexcept -> pacs_unit_of_work&;
 
    [[nodiscard]] auto create_query_builder() const -> database::query_builder;
    [[nodiscard]] auto select(const std::string& query)
        -> Result<database_result>;
    [[nodiscard]] auto insert(const std::string& query) -> Result<uint64_t>;
    [[nodiscard]] auto update(const std::string& query) -> Result<uint64_t>;
    [[nodiscard]] auto remove(const std::string& query) -> Result<uint64_t>;
    [[nodiscard]] auto execute(const std::string& query) -> VoidResult;
    [[nodiscard]] auto last_insert_rowid() const -> int64_t;
    [[nodiscard]] auto commit() -> VoidResult;
    [[nodiscard]] auto rollback() -> VoidResult;
    [[nodiscard]] auto is_active() const noexcept -> bool;
 
private:
    pacs_database_adapter* adapter_{nullptr};
    bool active_{false};
};
 
class pacs_database_adapter {
public:
    explicit pacs_database_adapter(const std::filesystem::path& db_path);
 
    pacs_database_adapter(database::database_types type,
                          const std::string& connection_string);
 
    ~pacs_database_adapter();
 
    // Non-copyable
    pacs_database_adapter(const pacs_database_adapter&) = delete;
    auto operator=(const pacs_database_adapter&)
        -> pacs_database_adapter& = delete;
 
    // Movable
    pacs_database_adapter(pacs_database_adapter&&) noexcept;
    auto operator=(pacs_database_adapter&&) noexcept -> pacs_database_adapter&;
 
    // ========================================================================
    // Connection Management
    // ========================================================================
 
    [[nodiscard]] auto connect() -> VoidResult;
 
    [[nodiscard]] auto disconnect() -> VoidResult;
 
    [[nodiscard]] auto is_connected() const noexcept -> bool;
 
    [[nodiscard]] auto open_session() -> pacs_storage_session;
    [[nodiscard]] auto open_session() const -> pacs_storage_session;
 
    [[nodiscard]] auto begin_unit_of_work() -> Result<pacs_unit_of_work>;
 
    // ========================================================================
    // Query Builder Factory
    // ========================================================================
 
    [[nodiscard]] auto create_query_builder() -> database::query_builder;
 
    // ========================================================================
    // CRUD Operations
    // ========================================================================
 
    [[nodiscard]] auto select(const std::string& query)
        -> Result<database_result>;
 
    [[nodiscard]] auto insert(const std::string& query) -> Result<uint64_t>;
 
    [[nodiscard]] auto update(const std::string& query) -> Result<uint64_t>;
 
    [[nodiscard]] auto remove(const std::string& query) -> Result<uint64_t>;
 
    [[nodiscard]] auto execute(const std::string& query) -> VoidResult;
 
    // ========================================================================
    // Transaction Support
    // ========================================================================
 
    [[nodiscard]] auto begin_transaction() -> VoidResult;
 
    [[nodiscard]] auto commit() -> VoidResult;
 
    [[nodiscard]] auto rollback() -> VoidResult;
 
    [[nodiscard]] auto in_transaction() const noexcept -> bool;
 
    template <typename Func>
    [[nodiscard]] auto transaction(Func&& func) -> VoidResult {
        auto begin_result = begin_transaction();
        if (begin_result.is_err()) {
            return begin_result;
        }
 
        try {
            auto result = std::forward<Func>(func)();
            if (result.is_err()) {
                (void)rollback();
                return result;
            }
 
            return commit();
        } catch (const std::exception& e) {
            (void)rollback();
            return VoidResult(kcenon::common::error_info{
                -1, std::string("Transaction failed: ") + e.what(), "storage"});
        }
    }
 
    // ========================================================================
    // SQLite Compatibility
    // ========================================================================
 
    [[nodiscard]] auto last_insert_rowid() const -> int64_t;
 
    [[nodiscard]] auto last_error() const -> std::string;
 
private:
    friend class pacs_storage_session;
    friend class pacs_unit_of_work;
 
    [[nodiscard]] auto run_select(const std::string& query)
        -> Result<database_result>;
    [[nodiscard]] auto run_insert(const std::string& query)
        -> Result<uint64_t>;
    [[nodiscard]] auto run_update(const std::string& query)
        -> Result<uint64_t>;
    [[nodiscard]] auto run_remove(const std::string& query)
        -> Result<uint64_t>;
    [[nodiscard]] auto run_execute(const std::string& query) -> VoidResult;
    [[nodiscard]] auto begin_transaction_internal() -> VoidResult;
    [[nodiscard]] auto commit_internal() -> VoidResult;
    [[nodiscard]] auto rollback_internal() -> VoidResult;
 
    struct impl;
    std::unique_ptr<impl> impl_;
};
 
class scoped_transaction {
public:
    explicit scoped_transaction(pacs_database_adapter& db);
 
    ~scoped_transaction();
 
    // Non-copyable, non-movable
    scoped_transaction(const scoped_transaction&) = delete;
    auto operator=(const scoped_transaction&) -> scoped_transaction& = delete;
    scoped_transaction(scoped_transaction&&) = delete;
    auto operator=(scoped_transaction&&) -> scoped_transaction& = delete;
 
    [[nodiscard]] auto commit() -> VoidResult;
 
    void rollback() noexcept;
 
    [[nodiscard]] auto is_active() const noexcept -> bool;
 
private:
    pacs_database_adapter& db_;
    bool committed_{false};
    bool active_{false};
};
 
#endif  // PACS_WITH_DATABASE_SYSTEM
 
}  // namespace kcenon::pacs::storage