database::integrated Namespace Reference

Namespaces
namespace	adapters

Classes
class	connection_string_builder
	Fluent builder for constructing database connection strings. More...
struct	database_config
	Database-specific configuration. More...
class	database_coordinator
	Manages lifecycle and coordination of all database system adapters. More...
struct	database_metrics
	Database performance metrics. More...
struct	db_logger_config
	Logger configuration. More...
struct	db_monitoring_config
	Monitoring and metrics configuration. More...
struct	db_thread_config
	Thread pool configuration for async operations. More...
struct	health_check
	Health check result. More...
struct	pool_config
	Connection pool configuration. More...
struct	query_param
struct	query_result
	Query result set. More...
class	transaction
	Transaction interface for ACID operations. More...
class	transaction_impl
class	unified_database_system
	Main unified database system class. More...
struct	unified_db_config

Typedefs
using	row_data = std::map<std::string, std::string>
	Database row representation.
using	database = unified_database_system
	Convenience alias for unified database system.

Enumerations
enum class	ssl_mode {   disable , allow , prefer , require ,   verify_ca , verify_full }
	SSL connection mode for database connections. More...
enum class	db_log_level {   trace , debug , info , warning ,   error , critical , fatal }
	Database logging level enumeration. More...
enum class	backend_type { postgres , sqlite , mongodb , redis }
	Database backend type enumeration. More...
enum class	thread_pool_type { standard , typed }
	Thread pool implementation type. More...
enum class	health_status { healthy , degraded , critical , failed }
	Database health status. More...

Functions
static std::string	backend_type_to_name (backend_type type)
	Convert backend_type to registry name string.
static std::shared_ptr< core::database_backend >	create_backend (backend_type type)
	Create database backend instance.
static std::string	value_to_string (const core::database_value &value)
	Convert database_value (variant) to string.
static query_result	convert_result (const core::database_result &db_result, std::chrono::microseconds exec_time)
	Convert core::database_result to query_result.
std::unique_ptr< unified_database_system >	create_database ()
	Create a database with zero configuration.
kcenon::common::Result< std::unique_ptr< unified_database_system > >	create_database (backend_type backend, const std::string &connection_string)
	Create a database with builder configuration.

Typedef Documentation

database

using database::integrated::database = unified_database_system

Convenience alias for unified database system.

Examples

/home/runner/work/database_system/database_system/database/integrated/connection_string_builder.h.

Definition at line 641 of file unified_database_system.h.

row_data

using database::integrated::row_data = std::map<std::string, std::string>

Database row representation.

Examples

/home/runner/work/database_system/database_system/database/integrated/unified_database_system.h.

Definition at line 99 of file unified_database_system.h.

Enumeration Type Documentation

backend_type

enum class database::integrated::backend_type

strong

Database backend type enumeration.

Specifies which database backend to use.

Enumerator
postgres	PostgreSQL database.
sqlite	SQLite embedded database.
mongodb	MongoDB NoSQL database.
redis	Redis key-value store.

Examples

/home/runner/work/database_system/database_system/database/integrated/unified_database_system.h.

Definition at line 65 of file configuration.h.

{
    postgres, 
    sqlite,   
    mongodb,  
    redis     
};

db_log_level

enum class database::integrated::db_log_level

strong

Database logging level enumeration.

Defines the verbosity level for database operation logging. Lower levels include higher levels (e.g., debug includes info, warning, error).

Enumerator
trace	Most verbose, includes all operations.
debug	Debug information for development.
info	Informational messages (default)
warning	Warning conditions.
error	Error conditions.
critical	Critical failures requiring immediate attention.
fatal	Fatal errors causing system shutdown.

Examples

/home/runner/work/database_system/database_system/database/integrated/unified_database_system.h.

Definition at line 49 of file configuration.h.

{
    trace,    
    debug,    
    info,     
    warning,  
    error,    
    critical, 
    fatal     
};

health_status

enum class database::integrated::health_status

strong

Database health status.

Enumerator
healthy
degraded
critical
failed

Examples

/home/runner/work/database_system/database_system/database/integrated/unified_database_system.h.

Definition at line 158 of file unified_database_system.h.

                         {
    healthy,        // All systems operational
    degraded,       // Some issues, but operational
    critical,       // Major issues, limited functionality
    failed          // System not operational
};

ssl_mode

enum class database::integrated::ssl_mode

strong

SSL connection mode for database connections.

Enumerator
disable	No SSL.
allow	Try SSL, fall back to non-SSL.
prefer	Try SSL first, fall back to non-SSL.
require	Require SSL, no verification.
verify_ca	Require SSL with CA verification.
verify_full	Require SSL with full verification.

Examples

/home/runner/work/database_system/database_system/database/integrated/connection_string_builder.h.

Definition at line 57 of file connection_string_builder.h.

                    {
    disable,   
    allow,     
    prefer,    
    require,   
    verify_ca, 
    verify_full 
};

thread_pool_type

enum class database::integrated::thread_pool_type

strong

Thread pool implementation type.

Determines which thread pool implementation to use for async operations.

Enumerator
standard	Standard thread pool (default)
typed	Typed thread pool with priority support.

Definition at line 78 of file configuration.h.

{
    standard, 
    typed     
};

Function Documentation

backend_type_to_name()

static std::string database::integrated::backend_type_to_name ( backend_type type )

static

Convert backend_type to registry name string.

Definition at line 53 of file unified_database_system.cpp.

                                                         {
    switch (type) {
        case backend_type::postgres: return "postgresql";
        case backend_type::sqlite:   return "sqlite";
        case backend_type::mongodb:  return "mongodb";
        case backend_type::redis:    return "redis";
        default:                     return "";
    }
}

References mongodb, postgres, redis, and sqlite.

Referenced by create_backend().

Here is the caller graph for this function:

convert_result()

static query_result database::integrated::convert_result ( const core::database_result & db_result, std::chrono::microseconds exec_time )

static

Convert core::database_result to query_result.

Definition at line 111 of file unified_database_system.cpp.

                                     {
 
    query_result result;
    result.rows.reserve(db_result.size());
 
    // Convert each row: map<string, database_value> -> map<string, string>
    for (const auto& db_row : db_result) {
        row_data converted_row;
        for (const auto& [key, value] : db_row) {
            converted_row[key] = value_to_string(value);
        }
        result.rows.push_back(std::move(converted_row));
    }
 
    result.affected_rows = db_result.size();
    result.execution_time = exec_time;
 
    return result;
}

References database::integrated::query_result::affected_rows, database::integrated::query_result::execution_time, database::integrated::query_result::rows, and value_to_string().

Referenced by database::integrated::transaction_impl::execute(), and database::integrated::unified_database_system::impl::execute().

Here is the call graph for this function:

Here is the caller graph for this function:

create_backend()

static std::shared_ptr< core::database_backend > database::integrated::create_backend ( backend_type type )

static

Create database backend instance.

First tries hardcoded backends, then falls back to backend_registry for dynamically registered backends (including test stubs).

Definition at line 69 of file unified_database_system.cpp.

                                                                             {
    switch (type) {
        case backend_type::postgres:
            return std::make_shared<postgres_manager>();
        default: {
            // Fall back to backend_registry for other types
            auto name = backend_type_to_name(type);
            if (!name.empty()) {
                auto backend = core::backend_registry::instance().create(name);
                if (backend) {
                    return std::shared_ptr<core::database_backend>(std::move(backend));
                }
            }
            return nullptr;
        }
    }
}

References backend_type_to_name(), database::core::backend_registry::create(), database::core::backend_registry::instance(), and postgres.

Referenced by database::integrated::unified_database_system::impl::connect().

Here is the call graph for this function:

Here is the caller graph for this function:

create_database() [1/2]

std::unique_ptr< unified_database_system > database::integrated::create_database ( )

inline

Create a database with zero configuration.

Returns

Unique pointer to database system

Examples

/home/runner/work/database_system/database_system/database/integrated/unified_database_system.h.

Definition at line 647 of file unified_database_system.h.

                                                                {
    return std::make_unique<unified_database_system>();
}

create_database() [2/2]

kcenon::common::Result< std::unique_ptr< unified_database_system > > database::integrated::create_database ( backend_type backend, const std::string & connection_string )

inline

Create a database with builder configuration.

Parameters

backend	Database backend type
connection_string	Connection string

Returns

Result containing configured database system or error

Definition at line 657 of file unified_database_system.h.

                                        {
 
    return unified_database_system::create_builder()
        .set_backend(backend)
        .set_connection_string(connection_string)
        .build();
}

References database::integrated::unified_database_system::builder::build(), database::integrated::unified_database_system::create_builder(), database::integrated::unified_database_system::builder::set_backend(), and database::integrated::unified_database_system::builder::set_connection_string().

Here is the call graph for this function:

value_to_string()

static std::string database::integrated::value_to_string ( const core::database_value & value )

static

Convert database_value (variant) to string.

Definition at line 90 of file unified_database_system.cpp.

                                                                  {
    return std::visit([](const auto& v) -> std::string {
        using T = std::decay_t<decltype(v)>;
        if constexpr (std::is_same_v<T, std::string>) {
            return v;
        } else if constexpr (std::is_same_v<T, int64_t>) {
            return std::to_string(v);
        } else if constexpr (std::is_same_v<T, double>) {
            return std::to_string(v);
        } else if constexpr (std::is_same_v<T, bool>) {
            return v ? "true" : "false";
        } else if constexpr (std::is_same_v<T, std::nullptr_t>) {
            return "NULL";
        }
        return "";
    }, value);
}

Referenced by convert_result().

Here is the caller graph for this function: