unified_database_system.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "core/configuration.h"
 
#include <memory>
#include <string>
#include <vector>
#include <map>
#include <future>
#include <chrono>
#include <functional>
#include <optional>
 
// Use unified Result<T> implementation
#include "../core/result.h"
 
// Include query builder
#include "../query_builder.h"
 
namespace database::integrated {
 
// Forward declarations
class database_coordinator;
class transaction;
 
using row_data = std::map<std::string, std::string>;
 
struct query_result {
    std::vector<row_data> rows;
    size_t affected_rows{0};
    std::chrono::microseconds execution_time{0};
 
    bool empty() const { return rows.empty(); }
    size_t size() const { return rows.size(); }
 
    // Convenience accessors
    const row_data& operator[](size_t index) const { return rows.at(index); }
    row_data& operator[](size_t index) { return rows.at(index); }
 
    auto begin() { return rows.begin(); }
    auto end() { return rows.end(); }
    auto begin() const { return rows.begin(); }
    auto end() const { return rows.end(); }
};
 
struct database_metrics {
    // Query statistics
    size_t total_queries{0};
    size_t successful_queries{0};
    size_t failed_queries{0};
    size_t slow_queries{0};
 
    // Latency statistics
    std::chrono::microseconds average_latency{0};
    std::chrono::microseconds min_latency{0};
    std::chrono::microseconds max_latency{0};
    std::chrono::microseconds p95_latency{0};
    std::chrono::microseconds p99_latency{0};
 
    // Connection pool statistics
    size_t pool_size{0};
    size_t active_connections{0};
    size_t idle_connections{0};
    size_t wait_queue_size{0};
 
    // Throughput
    double queries_per_second{0.0};
    std::chrono::steady_clock::time_point measurement_start;
 
    // Transaction statistics
    size_t transactions_started{0};
    size_t transactions_committed{0};
    size_t transactions_rolled_back{0};
};
 
enum class health_status {
    healthy,        // All systems operational
    degraded,       // Some issues, but operational
    critical,       // Major issues, limited functionality
    failed          // System not operational
};
 
struct health_check {
    health_status status{health_status::healthy};
    bool is_connected{false};
    bool logger_healthy{false};
    bool monitor_healthy{false};
    bool thread_pool_healthy{false};
    bool connection_pool_healthy{false};
 
    double connection_pool_utilization{0.0};
    std::vector<std::string> issues;
    std::chrono::steady_clock::time_point last_check;
};
 
struct query_param {
    std::optional<std::string> value;
 
    // Implicit conversions for convenience with null safety
    query_param(const std::string& v) : value(v) {}
    query_param(std::string&& v) : value(std::move(v)) {}
    query_param(const char* v) : value(v ? std::optional<std::string>(v) : std::nullopt) {}
    query_param(std::nullptr_t) : value(std::nullopt) {}
    query_param(int v) : value(std::to_string(v)) {}
    query_param(long v) : value(std::to_string(v)) {}
    query_param(long long v) : value(std::to_string(v)) {}
    query_param(unsigned int v) : value(std::to_string(v)) {}
    query_param(unsigned long v) : value(std::to_string(v)) {}
    query_param(unsigned long long v) : value(std::to_string(v)) {}
    query_param(double v) : value(std::to_string(v)) {}
    query_param(float v) : value(std::to_string(v)) {}
    query_param(bool v) : value(v ? "true" : "false") {}
 
    bool is_null() const noexcept { return !value.has_value(); }
 
    const std::string& get_value() const noexcept {
        static const std::string empty_string;
        return value.has_value() ? *value : empty_string;
    }
 
    std::string to_sql_string() const {
        return value.has_value() ? *value : "NULL";
    }
};
 
class transaction {
public:
    virtual ~transaction() = default;
 
    virtual kcenon::common::Result<query_result> execute(
        const std::string& query,
        const std::vector<query_param>& params = {}) = 0;
 
    virtual kcenon::common::VoidResult commit() = 0;
 
    virtual kcenon::common::VoidResult rollback() = 0;
 
    virtual bool is_active() const = 0;
};
 
class unified_database_system {
public:
    class builder {
    public:
        builder();
 
        builder& set_backend(backend_type type);
 
        builder& set_connection_string(const std::string& conn_str);
 
        builder& set_pool_size(size_t min_size, size_t max_size);
 
        builder& enable_logging(db_log_level level, const std::string& log_dir = "./logs");
 
        builder& enable_monitoring(bool enable = true);
 
        builder& enable_async(size_t worker_threads = 4);
 
        builder& set_slow_query_threshold(std::chrono::milliseconds threshold);
 
        kcenon::common::Result<std::unique_ptr<unified_database_system>> build();
 
    private:
        unified_db_config config_;
        std::string connection_string_;
    };
 
    static builder create_builder();
 
    // Constructors and destructor
 
    unified_database_system();
 
    explicit unified_database_system(const unified_db_config& config);
 
    ~unified_database_system();
 
    // Disable copy, enable move
    unified_database_system(const unified_database_system&) = delete;
    unified_database_system& operator=(const unified_database_system&) = delete;
    unified_database_system(unified_database_system&&) noexcept;
    unified_database_system& operator=(unified_database_system&&) noexcept;
 
    // Connection management
 
    kcenon::common::VoidResult connect(const std::string& connection_string);
 
    kcenon::common::VoidResult connect(backend_type backend, const std::string& connection_string);
 
    kcenon::common::VoidResult disconnect();
 
    bool is_connected() const;
 
    // Query execution (synchronous)
 
    kcenon::common::Result<query_result> execute(
        const std::string& query,
        const std::vector<query_param>& params = {});
 
    kcenon::common::Result<query_result> select(
        const std::string& query,
        const std::vector<query_param>& params = {});
 
    kcenon::common::Result<size_t> insert(
        const std::string& query,
        const std::vector<query_param>& params = {});
 
    kcenon::common::Result<size_t> update(
        const std::string& query,
        const std::vector<query_param>& params = {});
 
    kcenon::common::Result<size_t> remove(
        const std::string& query,
        const std::vector<query_param>& params = {});
 
    // Query execution (asynchronous)
 
    std::future<kcenon::common::Result<query_result>> execute_async(
        const std::string& query,
        const std::vector<query_param>& params = {});
 
    std::future<kcenon::common::Result<query_result>> execute_async_priority(
        const std::string& query,
        int priority,
        const std::vector<query_param>& params = {});
 
    // Transaction management
 
    kcenon::common::Result<std::unique_ptr<transaction>> begin_transaction();
 
    kcenon::common::VoidResult execute_transaction(
        const std::vector<std::string>& queries);
 
    template<typename Func>
    kcenon::common::Result<typename std::invoke_result_t<Func, transaction&>> in_transaction(Func&& func);
 
    // Query builder integration
 
    query_builder create_query_builder() const;
 
    // Monitoring and health
 
    database_metrics get_metrics() const;
 
    health_check check_health() const;
 
    void reset_metrics();
 
    // Configuration access
 
    const unified_db_config& get_config() const;
 
    backend_type get_backend_type() const;
 
    struct pool_stats {
        size_t total_connections{0};
        size_t active_connections{0};
        size_t idle_connections{0};
        size_t wait_queue_size{0};
        double utilization_percent{0.0};
    };
    pool_stats get_pool_stats() const;
 
private:
    // PIMPL idiom for ABI stability
    class impl;
    std::unique_ptr<impl> pimpl_;
};
 
using database = unified_database_system;
 
inline std::unique_ptr<unified_database_system> create_database() {
    return std::make_unique<unified_database_system>();
}
 
inline kcenon::common::Result<std::unique_ptr<unified_database_system>> create_database(
    backend_type backend,
    const std::string& connection_string) {
 
    return unified_database_system::create_builder()
        .set_backend(backend)
        .set_connection_string(connection_string)
        .build();
}
 
} // namespace database::integrated