Collaboration diagram for database::integrated::unified_database_system::impl:

Public Member Functions
	impl (const unified_db_config &config)

	~impl ()

kcenon::common::VoidResult	connect (backend_type backend, const std::string &connection_string)

kcenon::common::VoidResult	disconnect ()

bool	is_connected () const

kcenon::common::Result< query_result >	execute (const std::string &query, const std::vector< query_param > &params)

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)

kcenon::common::Result< std::unique_ptr< transaction > >	begin_transaction ()

kcenon::common::VoidResult	execute_transaction (const std::vector< std::string > &queries)

database_metrics	get_metrics () const

health_check	check_health () const

void	reset_metrics ()

const unified_db_config &	get_config () const

backend_type	get_backend_type () const

unified_database_system::pool_stats	get_pool_stats () const

query_builder	create_query_builder () const

Private Member Functions
kcenon::common::VoidResult	ensure_initialized ()

void	update_metrics (std::chrono::microseconds latency, bool success)

Private Attributes
unified_db_config	config_

std::unique_ptr< database_coordinator >	coordinator_

backend_type	backend_type_

std::string	connection_string_

bool	connected_

bool	initialized_

std::shared_ptr< core::database_backend >	backend_

database_metrics	metrics_

std::mutex	mutex_

Detailed Description

Definition at line 285 of file unified_database_system.cpp.

Constructor & Destructor Documentation

◆ impl()

database::integrated::unified_database_system::impl::impl ( const unified_db_config & config )

inline

Definition at line 287 of file unified_database_system.cpp.

        : config_(config)
        , coordinator_(std::make_unique<database_coordinator>(config))
        , backend_type_(backend_type::postgres)
        , connected_(false)
        , initialized_(false)
    {
        // Coordinator initialization is deferred to ensure_initialized()
        // to maintain the no-throw guarantee documented in the public API.
        metrics_.measurement_start = std::chrono::steady_clock::now();
    }

References database::integrated::database_metrics::measurement_start, and metrics_.

◆ ~impl()

database::integrated::unified_database_system::impl::~impl ( )

inline

Definition at line 299 of file unified_database_system.cpp.

            {
        disconnect();
        coordinator_->shutdown();
    }

References coordinator_, and disconnect().

Here is the call graph for this function:

Member Function Documentation

◆ begin_transaction()

kcenon::common::Result< std::unique_ptr< transaction > > database::integrated::unified_database_system::impl::begin_transaction ( )

inline

Definition at line 494 of file unified_database_system.cpp.

                                                                       {
        std::lock_guard<std::mutex> lock(mutex_);
 
        if (!connected_) {
            return make_error_result<std::unique_ptr<transaction>>("Not connected to database", -1, "unified_database_system");
        }
 
        ++metrics_.transactions_started;
 
        auto tx_impl = std::make_unique<transaction_impl>(backend_);
        std::unique_ptr<transaction> tx = std::move(tx_impl);
        return tx;
    }

References backend_, connected_, metrics_, mutex_, and database::integrated::database_metrics::transactions_started.

Referenced by execute_transaction().

Here is the caller graph for this function:

◆ check_health()

health_check database::integrated::unified_database_system::impl::check_health ( ) const

inline

Definition at line 542 of file unified_database_system.cpp.

                                      {
        std::lock_guard<std::mutex> lock(mutex_);
 
        health_check health;
        health.last_check = std::chrono::steady_clock::now();
        health.is_connected = connected_;
 
        // Check coordinator health
        auto coord_health = coordinator_->check_health();
        if (coord_health.is_ok() && coord_health.value()) {
            health.logger_healthy = true;
            health.monitor_healthy = true;
            health.thread_pool_healthy = true;
        }
 
        // Connection pooling not yet implemented on client side
        health.connection_pool_healthy = true;
        health.connection_pool_utilization = 0.0;
 
        // Determine overall health
        if (!connected_) {
            health.status = health_status::failed;
            health.issues.push_back("Not connected to database");
        } else {
            health.status = health_status::healthy;
        }
 
        return health;
    }

◆ connect()

kcenon::common::VoidResult database::integrated::unified_database_system::impl::connect	(	backend_type	backend,
		const std::string &	connection_string )

inline

Definition at line 306 of file unified_database_system.cpp.

                                                                                             {
        std::lock_guard<std::mutex> lock(mutex_);
 
        auto init_result = ensure_initialized();
        if (!init_result.is_ok()) {
            return init_result;
        }
 
        if (connected_) {
            return make_error("Already connected", -1, "unified_database_system");
        }
 
        backend_type_ = backend;
        connection_string_ = connection_string;
 
        // Create backend instance
        backend_ = create_backend(backend);
        if (!backend_) {
            return make_error("Unsupported backend type", -2, "unified_database_system");
        }
 
        // Connect to database using connection_config
        auto config = core::connection_config::from_string(connection_string);
        auto result = backend_->initialize(config);
        if (result.is_err()) {
            return make_error("Connection failed: " + result.error().message, -3, "unified_database_system");
        }
 
        connected_ = true;
 
        // Log connection
        if (auto* logger = coordinator_->get_logger()) {
            logger->log_connection_event(
                "connected",
                "Connection established to: " + connection_string
            );
        }
 
        return kcenon::common::ok();
    }

References backend_, backend_type_, connected_, connection_string_, coordinator_, database::integrated::create_backend(), ensure_initialized(), database::core::connection_config::from_string(), and mutex_.

Here is the call graph for this function:

◆ create_query_builder()

query_builder database::integrated::unified_database_system::impl::create_query_builder ( ) const

inline

Definition at line 605 of file unified_database_system.cpp.

                                               {
        return query_builder{database_types::sqlite};
    }

References database::sqlite.

◆ disconnect()

kcenon::common::VoidResult database::integrated::unified_database_system::impl::disconnect ( )

inline

Definition at line 347 of file unified_database_system.cpp.

                                        {
        std::lock_guard<std::mutex> lock(mutex_);
 
        if (!connected_) {
            return kcenon::common::ok();
        }
 
        // Disconnect backend
        if (backend_) {
            backend_->shutdown();
            backend_.reset();
        }
 
        connected_ = false;
 
        // Log disconnection
        if (auto* logger = coordinator_->get_logger()) {
            logger->log_connection_event(
                "disconnected",
                "Connection closed: " + connection_string_
            );
        }
 
        return kcenon::common::ok();
    }

References backend_, connected_, connection_string_, coordinator_, and mutex_.

Referenced by ~impl().

Here is the caller graph for this function:

◆ ensure_initialized()

kcenon::common::VoidResult database::integrated::unified_database_system::impl::ensure_initialized ( )

inlineprivate

Definition at line 610 of file unified_database_system.cpp.

                                                {
        if (initialized_) {
            return kcenon::common::ok();
        }
        auto init_result = coordinator_->initialize();
        if (!init_result.is_ok()) {
            return make_error("Failed to initialize database coordinator: " +
                init_result.error().message, -10, "unified_database_system");
        }
        initialized_ = true;
        return kcenon::common::ok();
    }

References coordinator_, and initialized_.

Referenced by connect().

Here is the caller graph for this function:

◆ execute()

kcenon::common::Result< query_result > database::integrated::unified_database_system::impl::execute	(	const std::string &	query,
		const std::vector< query_param > &	params )

inline

Definition at line 380 of file unified_database_system.cpp.

                                              {
 
        std::lock_guard<std::mutex> lock(mutex_);
 
        if (!connected_) {
            return make_error_result<query_result>("Not connected to database", -1, "unified_database_system");
        }
 
        // Record query start
        auto start = std::chrono::steady_clock::now();
 
        // Execute query — use prepared statements when params are provided
        kcenon::common::Result<core::database_result> db_result = [&]() {
            if (params.empty()) {
                if (is_select_query(query)) {
                    return backend_->select_query(query);
                }
                auto exec_res = backend_->execute_query(query);
                if (exec_res.is_err()) {
                    return kcenon::common::Result<core::database_result>(exec_res.error());
                }
                return kcenon::common::Result<core::database_result>(core::database_result{});
            }
            auto values = convert_params(params);
            if (is_select_query(query)) {
                return backend_->select_prepared(query, values);
            }
            auto exec_res = backend_->execute_prepared(query, values);
            if (exec_res.is_err()) {
                return kcenon::common::Result<core::database_result>(exec_res.error());
            }
            return kcenon::common::Result<core::database_result>(core::database_result{});
        }();
 
        // Calculate execution time
        auto duration = std::chrono::duration_cast<std::chrono::microseconds>(
            std::chrono::steady_clock::now() - start);
 
        if (db_result.is_err()) {
            update_metrics(duration, false);
            return db_result.error();
        }
 
        // Update metrics
        update_metrics(duration, true);
 
        // Log query
        if (auto* logger = coordinator_->get_logger()) {
            logger->log(
                config_.logger.min_log_level,
                "Query executed: " + query + " (" + std::to_string(duration.count()) + "us)"
            );
        }
 
        // Record metrics
        if (auto* monitor = coordinator_->get_monitor()) {
            monitor->record_query_execution(duration, true);
        }
 
        auto qr = convert_result(db_result.value(), duration);
        // execute_query / execute_prepared return VoidResult (no row count),
        // so affected_rows stays 0 after convert_result.  For successful DML
        // queries we report at least 1 affected row.
        if (!is_select_query(query) && qr.affected_rows == 0) {
            qr.affected_rows = 1;
        }
        return qr;
    }

References backend_, config_, connected_, database::integrated::convert_result(), coordinator_, database::integrated::unified_db_config::logger, database::integrated::db_logger_config::min_log_level, mutex_, and update_metrics().

Referenced by execute_async(), and execute_async_priority().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ execute_async()

std::future< kcenon::common::Result< query_result > > database::integrated::unified_database_system::impl::execute_async	(	const std::string &	query,
		const std::vector< query_param > &	params )

inline

Definition at line 453 of file unified_database_system.cpp.

                                              {
 
        // Submit to thread pool
        auto* thread_pool = coordinator_->get_thread_pool();
        if (!thread_pool) {
            std::promise<kcenon::common::Result<query_result>> promise;
            promise.set_value(make_error_result<query_result>("Thread pool not available", -1, "unified_database_system"));
            return promise.get_future();
        }
 
        // Create task
        return thread_pool->submit([this, query, params]() -> kcenon::common::Result<query_result> {
            return this->execute(query, params);
        });
    }

References coordinator_, and execute().

Here is the call graph for this function:

◆ execute_async_priority()

std::future< kcenon::common::Result< query_result > > database::integrated::unified_database_system::impl::execute_async_priority	(	const std::string &	query,
		int	priority,
		const std::vector< query_param > &	params )

inline

Definition at line 471 of file unified_database_system.cpp.

                                              {
 
        auto* thread_pool = coordinator_->get_thread_pool();
        if (!thread_pool) {
            std::promise<kcenon::common::Result<query_result>> promise;
            promise.set_value(make_error_result<query_result>("Thread pool not available", -1, "unified_database_system"));
            return promise.get_future();
        }
 
        // Note: Priority parameter is currently ignored
        // Backend pattern removed priority support for simplification
        (void)priority; // Suppress unused parameter warning
 
        return thread_pool->submit([this, query, params]() -> kcenon::common::Result<query_result> {
            return this->execute(query, params);
        });
    }

References coordinator_, and execute().

Here is the call graph for this function:

◆ execute_transaction()

kcenon::common::VoidResult database::integrated::unified_database_system::impl::execute_transaction ( const std::vector< std::string > & queries )

inline

Definition at line 508 of file unified_database_system.cpp.

                                                                                    {
        auto tx_result = begin_transaction();
        if (!tx_result.is_ok()) {
            return tx_result.error();
        }
 
        auto tx = std::move(tx_result.value());
 
        for (const auto& query : queries) {
            auto result = tx->execute(query, {});
            if (!result.is_ok()) {
                tx->rollback();
                ++metrics_.transactions_rolled_back;
                return result.error();
            }
        }
 
        auto commit_result = tx->commit();
        if (commit_result.is_ok()) {
            ++metrics_.transactions_committed;
        } else {
            ++metrics_.transactions_rolled_back;
        }
 
        return commit_result;
    }

References begin_transaction(), metrics_, database::integrated::database_metrics::transactions_committed, and database::integrated::database_metrics::transactions_rolled_back.

Here is the call graph for this function:

◆ get_backend_type()

backend_type database::integrated::unified_database_system::impl::get_backend_type ( ) const

inline

Definition at line 584 of file unified_database_system.cpp.

                                          {
        return backend_type_;
    }

References backend_type_.

◆ get_config()

const unified_db_config & database::integrated::unified_database_system::impl::get_config ( ) const

inline

Definition at line 580 of file unified_database_system.cpp.

                                                {
        return config_;
    }

References config_.

◆ get_metrics()

database_metrics database::integrated::unified_database_system::impl::get_metrics ( ) const

inline

Definition at line 537 of file unified_database_system.cpp.

                                         {
        std::lock_guard<std::mutex> lock(mutex_);
        return metrics_;
    }

References metrics_, and mutex_.

◆ get_pool_stats()

unified_database_system::pool_stats database::integrated::unified_database_system::impl::get_pool_stats ( ) const

inline

Definition at line 588 of file unified_database_system.cpp.

                                                             {
        std::lock_guard<std::mutex> lock(mutex_);
 
        // Connection pooling not yet implemented on client side
        // Return empty stats for client-side
        unified_database_system::pool_stats stats;
        stats.total_connections = connected_ ? 1 : 0;
        stats.active_connections = connected_ ? 1 : 0;
        stats.idle_connections = 0;
        stats.wait_queue_size = 0;
        stats.utilization_percent = connected_ ? 100.0 : 0.0;
 
        return stats;
    }

References database::integrated::unified_database_system::pool_stats::active_connections, connected_, database::integrated::unified_database_system::pool_stats::idle_connections, mutex_, database::integrated::unified_database_system::pool_stats::total_connections, database::integrated::unified_database_system::pool_stats::utilization_percent, and database::integrated::unified_database_system::pool_stats::wait_queue_size.

◆ is_connected()

bool database::integrated::unified_database_system::impl::is_connected ( ) const

inline

Definition at line 373 of file unified_database_system.cpp.

                              {
        std::lock_guard<std::mutex> lock(mutex_);
        return connected_;
    }

References connected_, and mutex_.

◆ reset_metrics()

void database::integrated::unified_database_system::impl::reset_metrics ( )

inline

Definition at line 572 of file unified_database_system.cpp.

                         {
        std::lock_guard<std::mutex> lock(mutex_);
        metrics_ = database_metrics{};
        metrics_.measurement_start = std::chrono::steady_clock::now();
    }

References database::integrated::database_metrics::measurement_start, metrics_, and mutex_.

◆ update_metrics()

void database::integrated::unified_database_system::impl::update_metrics	(	std::chrono::microseconds	latency,
		bool	success )

inlineprivate

Definition at line 623 of file unified_database_system.cpp.

                                                                     {
        ++metrics_.total_queries;
 
        if (success) {
            ++metrics_.successful_queries;
        } else {
            ++metrics_.failed_queries;
        }
 
        // Update latency stats
        if (metrics_.min_latency == std::chrono::microseconds{0} ||
            latency < metrics_.min_latency) {
            metrics_.min_latency = latency;
        }
 
        if (latency > metrics_.max_latency) {
            metrics_.max_latency = latency;
        }
 
        // Exponential Moving Average (EMA) with alpha = 0.1 (gives more weight to recent values)
        // EMA formula: EMA_new = alpha * value + (1 - alpha) * EMA_old
        constexpr double alpha = 0.1;
        if (metrics_.total_queries == 1) {
            // First query: initialize with actual latency
            metrics_.average_latency = latency;
        } else {
            // Subsequent queries: apply EMA formula
            auto current_avg_us = metrics_.average_latency.count();
            auto new_latency_us = latency.count();
            auto ema_us = static_cast<int64_t>(alpha * new_latency_us + (1.0 - alpha) * current_avg_us);
            metrics_.average_latency = std::chrono::microseconds{ema_us};
        }
 
        // Calculate throughput
        auto duration = std::chrono::steady_clock::now() - metrics_.measurement_start;
        auto seconds = std::chrono::duration_cast<std::chrono::seconds>(duration).count();
        if (seconds > 0) {
            metrics_.queries_per_second = static_cast<double>(metrics_.total_queries) / seconds;
        }
 
        // Check for slow query
        if (latency > config_.logger.slow_query_threshold) {
            ++metrics_.slow_queries;
        }
    }