SQLite implementation of database_backend interface. More...

#include <sqlite_backend.h>

Inheritance diagram for database::backends::sqlite_backend:

Collaboration diagram for database::backends::sqlite_backend:

Public Member Functions
	sqlite_backend ()
	Default constructor.

	~sqlite_backend () override=default
	Destructor - ensures proper cleanup.

kcenon::common::Result< core::database_result >	select_query (const std::string &query_string) override
	Execute a SELECT query.

kcenon::common::VoidResult	execute_query (const std::string &query_string) override
	Execute a general SQL query (DDL, DML)

kcenon::common::Result< core::database_result >	select_prepared (const std::string &query, const std::vector< core::database_value > &params) override
	Execute a parameterized SELECT query (prepared statement)

kcenon::common::VoidResult	execute_prepared (const std::string &query, const std::vector< core::database_value > &params) override
	Execute a parameterized DML/DDL query (prepared statement)

kcenon::common::VoidResult	begin_transaction () override
	Begin a transaction.

kcenon::common::VoidResult	commit_transaction () override
	Commit the current transaction.

kcenon::common::VoidResult	rollback_transaction () override
	Rollback the current transaction.

bool	in_transaction () const override
	Check if backend is currently in a transaction.

std::string	last_error () const override
	Get last error message from backend.

std::map< std::string, std::string >	connection_info () const override
	Get backend-specific connection information.

Public Member Functions inherited from database::core::backend_base< sqlite_backend, database_types::sqlite >
	backend_base ()=default
	Default constructor.

	backend_base (const backend_base &)=delete

	backend_base (backend_base &&) noexcept=delete

	~backend_base () override
	Virtual destructor.

backend_base &	operator= (const backend_base &)=delete

backend_base &	operator= (backend_base &&) noexcept=delete

database_types	type () const override
	Get the database type of this backend.

kcenon::common::VoidResult	initialize (const connection_config &config) override
	Initialize the database backend.

kcenon::common::VoidResult	shutdown () override
	Shutdown the database backend gracefully.

bool	is_initialized () const override
	Check if backend is initialized and ready.

Public Member Functions inherited from database::core::database_backend
virtual	~database_backend ()=default

Static Public Member Functions
static constexpr const char *	backend_name ()
	Backend name for error messages.

Static Public Member Functions inherited from database::core::backend_base< sqlite_backend, database_types::sqlite >
static std::unique_ptr< database_backend >	create ()
	Factory method for backend_registry.

Protected Member Functions
kcenon::common::VoidResult	do_initialize (const core::connection_config &config)
	Database-specific initialization logic.

kcenon::common::VoidResult	do_shutdown ()
	Database-specific shutdown logic.

Private Member Functions
unsigned int	execute_modification_query (const std::string &query_string)
	Execute a modification query (INSERT, UPDATE, DELETE)

core::database_value	convert_sqlite_value (void *stmt, int column_index)
	Convert SQLite column value to database_value.

Private Attributes
void *	connection_ {nullptr}
	SQLite connection (sqlite3*)

std::atomic< bool >	in_transaction_ {false}
	Transaction state.

std::string	last_error_
	Last error message.

core::connection_config	connection_config_
	Cached connection config.

std::recursive_mutex	sqlite_mutex_
	Mutex for thread safety.

Friends
class	core::backend_base< sqlite_backend, database_types::sqlite >

Additional Inherited Members
Static Protected Member Functions inherited from database::core::database_backend
static std::string	expand_params (const std::string &query, const std::vector< database_value > &params)
	Expand positional parameters into a SQL string (fallback)

Protected Attributes inherited from database::core::backend_base< sqlite_backend, database_types::sqlite >
std::atomic< bool >	initialized_
	Initialization state.

Detailed Description

SQLite implementation of database_backend interface.

This class implements the database_backend interface for SQLite via backend_base CRTP template, using the SQLite3 C API.

Design Pattern: Strategy pattern with CRTP

Extends backend_base for common lifecycle management
Uses SQLite3 C API for database access
Provides Result-based error handling
Supports transactions natively
Thread-safe with internal mutex

Thread Safety:

All operations are thread-safe via recursive mutex
Suitable for multi-threaded access

Usage:

// Runtime selection via backend_registry
auto backend = backend_registry::instance().create("sqlite");
 
core::connection_config config;
config.database = "./mydb.db";  // File path or ":memory:" for in-memory DB
 
if (auto result = backend->initialize(config); !result) {
    // Handle error
}
 
auto rows = backend->select_query("SELECT * FROM users");

Definition at line 68 of file sqlite_backend.h.

Constructor & Destructor Documentation

◆ sqlite_backend()

database::backends::sqlite_backend::sqlite_backend ( )

Default constructor.

Definition at line 30 of file sqlite_backend.cpp.

    : connection_(nullptr)
{
}

◆ ~sqlite_backend()

database::backends::sqlite_backend::~sqlite_backend ( )

overridedefault

Destructor - ensures proper cleanup.

Member Function Documentation

◆ backend_name()

static constexpr const char * database::backends::sqlite_backend::backend_name ( )

inlinestaticconstexpr

Backend name for error messages.

Definition at line 75 of file sqlite_backend.h.

75{ return "sqlite_backend"; }

◆ begin_transaction()

kcenon::common::VoidResult database::backends::sqlite_backend::begin_transaction ( )

overridevirtual

Begin a transaction.

Returns: VoidResult::ok() on success, error on failure

Implements database::core::database_backend.

Definition at line 525 of file sqlite_backend.cpp.

{
    if (!is_initialized()) {
        last_error_ = "Backend not initialized";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::invalid_state),
            last_error_,
            "sqlite_backend"
        };
    }
 
    if (in_transaction_) {
        last_error_ = "Transaction already active";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::invalid_state),
            last_error_,
            "sqlite_backend"
        };
    }
 
    auto result = execute_query("BEGIN TRANSACTION");
    if (result.is_err()) {
        return result;
    }
 
    in_transaction_ = true;
    last_error_.clear();
    return kcenon::common::ok();
}

References execute_query(), in_transaction_, database::invalid_state, database::core::backend_base< sqlite_backend, database_types::sqlite >::is_initialized(), and last_error_.

Here is the call graph for this function:

◆ commit_transaction()

kcenon::common::VoidResult database::backends::sqlite_backend::commit_transaction ( )

overridevirtual

Commit the current transaction.

Returns: VoidResult::ok() on success, error on failure

Implements database::core::database_backend.

Definition at line 555 of file sqlite_backend.cpp.

{
    if (!is_initialized()) {
        last_error_ = "Backend not initialized";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::invalid_state),
            last_error_,
            "sqlite_backend"
        };
    }
 
    if (!in_transaction_) {
        last_error_ = "No active transaction";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::invalid_state),
            last_error_,
            "sqlite_backend"
        };
    }
 
    auto result = execute_query("COMMIT");
    if (result.is_err()) {
        return result;
    }
 
    in_transaction_ = false;
    last_error_.clear();
    return kcenon::common::ok();
}

References execute_query(), in_transaction_, database::invalid_state, database::core::backend_base< sqlite_backend, database_types::sqlite >::is_initialized(), and last_error_.

Here is the call graph for this function:

◆ connection_info()

std::map< std::string, std::string > database::backends::sqlite_backend::connection_info ( ) const

overridevirtual

Get backend-specific connection information.

Returns: Map of connection properties (for debugging/monitoring)

Example keys: "server_version", "connection_id", "protocol_version"

Implements database::core::database_backend.

Definition at line 622 of file sqlite_backend.cpp.

{
    std::map<std::string, std::string> info;
    info["backend"] = "sqlite";
    info["database"] = connection_config_.database;
    info["initialized"] = initialized_ ? "true" : "false";
    info["in_transaction"] = in_transaction_ ? "true" : "false";
    return info;
}

References connection_config_, database::core::connection_config::database, in_transaction_, and database::core::backend_base< sqlite_backend, database_types::sqlite >::initialized_.

◆ convert_sqlite_value()

core::database_value database::backends::sqlite_backend::convert_sqlite_value	(	void *	stmt,
		int	column_index )

private

Convert SQLite column value to database_value.

Parameters

stmt	SQLite prepared statement
column_index	Column index in the result set

Returns: database_value containing the converted value

Definition at line 123 of file sqlite_backend.cpp.

{
#ifdef USE_SQLITE
    sqlite3_stmt* sqlite_stmt = static_cast<sqlite3_stmt*>(stmt);
 
    int sqlite_type = sqlite3_column_type(sqlite_stmt, column_index);
 
    switch (sqlite_type) {
        case SQLITE_INTEGER:
            return static_cast<int64_t>(sqlite3_column_int64(sqlite_stmt, column_index));
 
        case SQLITE_FLOAT:
            return sqlite3_column_double(sqlite_stmt, column_index);
 
        case SQLITE_TEXT:
            {
                const char* text = reinterpret_cast<const char*>(sqlite3_column_text(sqlite_stmt, column_index));
                return std::string(text ? text : "");
            }
 
        case SQLITE_BLOB:
            {
                // For BLOB data, convert to string representation
                const void* blob = sqlite3_column_blob(sqlite_stmt, column_index);
                int blob_size = sqlite3_column_bytes(sqlite_stmt, column_index);
                if (blob && blob_size > 0) {
                    const char* blob_chars = static_cast<const char*>(blob);
                    return std::string(blob_chars, blob_size);
                }
                return std::string();
            }
 
        case SQLITE_NULL:
        default:
            return nullptr;
    }
#endif
    return nullptr;
}

Referenced by select_prepared(), and select_query().

Here is the caller graph for this function:

◆ do_initialize()

kcenon::common::VoidResult database::backends::sqlite_backend::do_initialize ( const core::connection_config & config )

protected

Database-specific initialization logic.

Parameters

config Connection configuration

Returns: VoidResult::ok() on success, error on failure

Definition at line 35 of file sqlite_backend.cpp.

{
    connection_config_ = config;
 
    // Use database field as file path, default to ":memory:" for in-memory database
    std::string db_path = config.database.empty() ? ":memory:" : config.database;
 
#ifdef USE_SQLITE
    std::lock_guard<std::recursive_mutex> lock(sqlite_mutex_);
    try {
        sqlite3* db = nullptr;
 
        // Open or create the database
        int result = sqlite3_open(db_path.c_str(), &db);
 
        if (result != SQLITE_OK) {
            last_error_ = std::string("Connection failed: ") + sqlite3_errmsg(db);
            logger_.error("do_initialize", last_error_);
            if (db) {
                sqlite3_close(db);
            }
            return kcenon::common::error_info{
                static_cast<int>(database::error_code::connection_failed),
                last_error_,
                "sqlite_backend"
            };
        }
 
        connection_ = db;
 
        // Enable foreign key constraints
        char* error_msg = nullptr;
        if (sqlite3_exec(db, "PRAGMA foreign_keys = ON", nullptr, nullptr, &error_msg) != SQLITE_OK) {
            logger_.warning(std::string("Failed to enable foreign key constraints: ") + (error_msg ? error_msg : ""));
            if (error_msg) sqlite3_free(error_msg);
        }
 
        last_error_.clear();
        return kcenon::common::ok();
    } catch (const std::exception& e) {
        last_error_ = std::string("Connection error: ") + e.what();
        logger_.error("do_initialize", last_error_);
    }
#else
    logger_.warning("SQLite support not compiled. Mock mode enabled.");
    // Mock mode for testing without SQLite
    last_error_.clear();
    return kcenon::common::ok();
#endif
 
    if (last_error_.empty()) {
        last_error_ = "Failed to connect to SQLite database";
    }
    return kcenon::common::error_info{
        static_cast<int>(database::error_code::connection_failed),
        last_error_,
        "sqlite_backend"
    };
}

References connection_, connection_config_, database::connection_failed, database::core::connection_config::database, last_error_, and sqlite_mutex_.

◆ do_shutdown()

kcenon::common::VoidResult database::backends::sqlite_backend::do_shutdown ( )

protected

Database-specific shutdown logic.

Returns: VoidResult::ok() on success, error on failure

Definition at line 95 of file sqlite_backend.cpp.

{
    // Rollback any active transaction before disconnecting
    if (in_transaction_) {
        rollback_transaction();
    }
 
#ifdef USE_SQLITE
    std::lock_guard<std::recursive_mutex> lock(sqlite_mutex_);
    if (connection_) {
        sqlite3* db = static_cast<sqlite3*>(connection_);
        int result = sqlite3_close(db);
        connection_ = nullptr;
        if (result != SQLITE_OK) {
            last_error_ = "Failed to close SQLite database";
            return kcenon::common::error_info{
                static_cast<int>(database::error_code::connection_failed),
                last_error_,
                "sqlite_backend"
            };
        }
    }
#endif
 
    last_error_.clear();
    return kcenon::common::ok();
}

References connection_, database::connection_failed, in_transaction_, last_error_, rollback_transaction(), and sqlite_mutex_.

Here is the call graph for this function:

◆ execute_modification_query()

unsigned int database::backends::sqlite_backend::execute_modification_query ( const std::string & query_string )

private

Execute a modification query (INSERT, UPDATE, DELETE)

Parameters

query_string SQL query to execute

Returns: Number of affected rows

Definition at line 163 of file sqlite_backend.cpp.

{
#ifdef USE_SQLITE
    if (!connection_) return 0;
    std::lock_guard<std::recursive_mutex> lock(sqlite_mutex_);
    try {
        sqlite3* db = static_cast<sqlite3*>(connection_);
        char* error_msg = nullptr;
 
        int result = sqlite3_exec(db, query_string.c_str(), nullptr, nullptr, &error_msg);
 
        if (result != SQLITE_OK) {
            last_error_ = std::string("Modification query failed: ") + (error_msg ? error_msg : "Unknown error");
            logger_.error("execute_modification_query", last_error_);
            if (error_msg) sqlite3_free(error_msg);
            return 0;
        }
 
        last_error_.clear();
        return static_cast<unsigned int>(sqlite3_changes(db));
    } catch (const std::exception& e) {
        last_error_ = std::string("Modification query error: ") + e.what();
        logger_.error("execute_modification_query", last_error_);
    }
#else
    logger_.warning("SQLite support not compiled. Modification query: " + query_string.substr(0, 20) + "...");
    return 1; // Mock: return 1 affected row
#endif
    return 0;
}

References connection_, last_error_, and sqlite_mutex_.

◆ execute_prepared()

kcenon::common::VoidResult database::backends::sqlite_backend::execute_prepared	(	const std::string &	query,
		const std::vector< core::database_value > &	params )

nodiscardoverridevirtual

Execute a parameterized DML/DDL query (prepared statement)

Parameters

query	SQL with positional placeholders ($1, $2, ... or ?, ?, ...)
params	Parameter values to bind

Returns: VoidResult::ok() on success, error on failure

See also: select_prepared for details on parameterized queries

Reimplemented from database::core::database_backend.

Definition at line 433 of file sqlite_backend.cpp.

{
    if (!is_initialized()) {
        last_error_ = "Backend not initialized";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::invalid_state),
            last_error_,
            "sqlite_backend"
        };
    }
 
#ifdef USE_SQLITE
    if (!connection_) {
        last_error_ = "No active SQLite connection";
        logger_.error("execute_prepared", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::connection_failed),
            last_error_,
            "sqlite_backend"
        };
    }
 
    std::lock_guard<std::recursive_mutex> lock(sqlite_mutex_);
    sqlite3* db = static_cast<sqlite3*>(connection_);
    sqlite3_stmt* stmt = nullptr;
 
    int rc = sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        last_error_ = std::string("Prepare error: ") + sqlite3_errmsg(db);
        logger_.error("execute_prepared", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::query_failed),
            last_error_,
            "sqlite_backend"
        };
    }
 
    for (size_t i = 0; i < params.size(); ++i) {
        int bind_idx = static_cast<int>(i + 1);
        int bind_rc = SQLITE_OK;
 
        std::visit([&bind_rc, stmt, bind_idx](const auto& v) {
            using T = std::decay_t<decltype(v)>;
            if constexpr (std::is_same_v<T, std::nullptr_t>) {
                bind_rc = sqlite3_bind_null(stmt, bind_idx);
            } else if constexpr (std::is_same_v<T, bool>) {
                bind_rc = sqlite3_bind_int(stmt, bind_idx, v ? 1 : 0);
            } else if constexpr (std::is_same_v<T, int64_t>) {
                bind_rc = sqlite3_bind_int64(stmt, bind_idx, v);
            } else if constexpr (std::is_same_v<T, double>) {
                bind_rc = sqlite3_bind_double(stmt, bind_idx, v);
            } else if constexpr (std::is_same_v<T, std::string>) {
                bind_rc = sqlite3_bind_text(stmt, bind_idx, v.c_str(),
                    static_cast<int>(v.size()), SQLITE_TRANSIENT);
            }
        }, params[i]);
 
        if (bind_rc != SQLITE_OK) {
            last_error_ = std::string("Bind error at param ") + std::to_string(i + 1)
                + ": " + sqlite3_errmsg(db);
            logger_.error("execute_prepared", last_error_);
            sqlite3_finalize(stmt);
            return kcenon::common::error_info{
                static_cast<int>(database::error_code::query_failed),
                last_error_,
                "sqlite_backend"
            };
        }
    }
 
    rc = sqlite3_step(stmt);
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE && rc != SQLITE_ROW) {
        last_error_ = std::string("Execute prepared error: ") + sqlite3_errmsg(db);
        logger_.error("execute_prepared", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::query_failed),
            last_error_,
            "sqlite_backend"
        };
    }
 
    last_error_.clear();
    return kcenon::common::ok();
#else
    return database_backend::execute_prepared(query, params);
#endif
}

References connection_, database::connection_failed, database::invalid_state, database::core::backend_base< sqlite_backend, database_types::sqlite >::is_initialized(), last_error_, database::query_failed, and sqlite_mutex_.

Here is the call graph for this function:

◆ execute_query()

kcenon::common::VoidResult database::backends::sqlite_backend::execute_query ( const std::string & query_string )

overridevirtual

Execute a general SQL query (DDL, DML)

Parameters

query_string SQL statement

Returns: VoidResult::ok() on success, error on failure

Implements database::core::database_backend.

Definition at line 280 of file sqlite_backend.cpp.

{
    if (!is_initialized()) {
        last_error_ = "Backend not initialized";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::invalid_state),
            last_error_,
            "sqlite_backend"
        };
    }
 
#ifdef USE_SQLITE
    if (!connection_) {
        last_error_ = "No active SQLite connection";
        logger_.error("execute_query", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::connection_failed),
            last_error_,
            "sqlite_backend"
        };
    }
 
    std::lock_guard<std::recursive_mutex> lock(sqlite_mutex_);
    sqlite3* db = static_cast<sqlite3*>(connection_);
 
    char* error_msg = nullptr;
    int result = sqlite3_exec(db, query_string.c_str(), nullptr, nullptr, &error_msg);
 
    if (result != SQLITE_OK) {
        last_error_ = std::string("Execute error: ") + (error_msg ? error_msg : "Unknown error");
        logger_.error("execute_query", last_error_);
        if (error_msg) sqlite3_free(error_msg);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::query_failed),
            last_error_,
            "sqlite_backend"
        };
    }
 
    last_error_.clear();
    return kcenon::common::ok();
#else
    // Mock execution
    logger_.info("SQLite support not compiled. Mock execute: " + query_string);
    last_error_.clear();
    return kcenon::common::ok();
#endif
}

References connection_, database::connection_failed, database::invalid_state, database::core::backend_base< sqlite_backend, database_types::sqlite >::is_initialized(), last_error_, database::query_failed, and sqlite_mutex_.

Referenced by begin_transaction(), commit_transaction(), and rollback_transaction().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ in_transaction()

bool database::backends::sqlite_backend::in_transaction ( ) const

overridevirtual

Check if backend is currently in a transaction.

Returns: true if transaction is active

Implements database::core::database_backend.

Definition at line 612 of file sqlite_backend.cpp.

{
    return in_transaction_;
}

References in_transaction_.

◆ last_error()

std::string database::backends::sqlite_backend::last_error ( ) const

overridevirtual

Get last error message from backend.

Returns: Error message, or empty string if no error

Implements database::core::database_backend.

Definition at line 617 of file sqlite_backend.cpp.

{
    return last_error_;
}

References last_error_.

◆ rollback_transaction()

kcenon::common::VoidResult database::backends::sqlite_backend::rollback_transaction ( )

overridevirtual

Rollback the current transaction.

Returns: VoidResult::ok() on success, error on failure

Implements database::core::database_backend.

Definition at line 585 of file sqlite_backend.cpp.

{
    if (!is_initialized()) {
        last_error_ = "Backend not initialized";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::invalid_state),
            last_error_,
            "sqlite_backend"
        };
    }
 
    if (!in_transaction_) {
        // Not an error - already rolled back or never started
        return kcenon::common::ok();
    }
 
    auto result = execute_query("ROLLBACK");
    in_transaction_ = false; // Force state reset even on error
 
    if (result.is_err()) {
        return result;
    }
 
    last_error_.clear();
    return kcenon::common::ok();
}

References execute_query(), in_transaction_, database::invalid_state, database::core::backend_base< sqlite_backend, database_types::sqlite >::is_initialized(), and last_error_.

Referenced by do_shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ select_prepared()

kcenon::common::Result< core::database_result > database::backends::sqlite_backend::select_prepared	(	const std::string &	query,
		const std::vector< core::database_value > &	params )

nodiscardoverridevirtual

Execute a parameterized SELECT query (prepared statement)

Parameters are bound at the wire-protocol level, providing stronger SQL injection protection than string escaping. Backends that support native prepared statements (PostgreSQL, SQLite) should override this.

Parameters

query	SQL with positional placeholders ($1, $2, ... or ?, ?, ...)
params	Parameter values to bind

Returns: Query results as rows, or error

Note: Default implementation falls back to string interpolation via execute_query/select_query for backends that have not yet implemented native prepared statement support.

Reimplemented from database::core::database_backend.

Definition at line 329 of file sqlite_backend.cpp.

{
    if (!is_initialized()) {
        last_error_ = "Backend not initialized";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::invalid_state),
            last_error_,
            "sqlite_backend"
        };
    }
 
    core::database_result result;
 
#ifdef USE_SQLITE
    if (!connection_) {
        last_error_ = "No active connection";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::connection_failed),
            last_error_,
            "sqlite_backend"
        };
    }
 
    std::lock_guard<std::recursive_mutex> lock(sqlite_mutex_);
    sqlite3* db = static_cast<sqlite3*>(connection_);
    sqlite3_stmt* stmt = nullptr;
 
    int rc = sqlite3_prepare_v2(db, query.c_str(), -1, &stmt, nullptr);
    if (rc != SQLITE_OK) {
        last_error_ = std::string("Prepare error: ") + sqlite3_errmsg(db);
        logger_.error("select_prepared", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::query_failed),
            last_error_,
            "sqlite_backend"
        };
    }
 
    // Bind parameters
    for (size_t i = 0; i < params.size(); ++i) {
        int bind_idx = static_cast<int>(i + 1); // SQLite uses 1-based indexing
        int bind_rc = SQLITE_OK;
 
        std::visit([&bind_rc, stmt, bind_idx](const auto& v) {
            using T = std::decay_t<decltype(v)>;
            if constexpr (std::is_same_v<T, std::nullptr_t>) {
                bind_rc = sqlite3_bind_null(stmt, bind_idx);
            } else if constexpr (std::is_same_v<T, bool>) {
                bind_rc = sqlite3_bind_int(stmt, bind_idx, v ? 1 : 0);
            } else if constexpr (std::is_same_v<T, int64_t>) {
                bind_rc = sqlite3_bind_int64(stmt, bind_idx, v);
            } else if constexpr (std::is_same_v<T, double>) {
                bind_rc = sqlite3_bind_double(stmt, bind_idx, v);
            } else if constexpr (std::is_same_v<T, std::string>) {
                bind_rc = sqlite3_bind_text(stmt, bind_idx, v.c_str(),
                    static_cast<int>(v.size()), SQLITE_TRANSIENT);
            }
        }, params[i]);
 
        if (bind_rc != SQLITE_OK) {
            last_error_ = std::string("Bind error at param ") + std::to_string(i + 1)
                + ": " + sqlite3_errmsg(db);
            logger_.error("select_prepared", last_error_);
            sqlite3_finalize(stmt);
            return kcenon::common::error_info{
                static_cast<int>(database::error_code::query_failed),
                last_error_,
                "sqlite_backend"
            };
        }
    }
 
    // Execute and collect results
    int col_count = sqlite3_column_count(stmt);
    while ((rc = sqlite3_step(stmt)) == SQLITE_ROW) {
        core::database_row db_row;
        for (int col = 0; col < col_count; ++col) {
            std::string column_name = sqlite3_column_name(stmt, col);
            db_row[column_name] = convert_sqlite_value(stmt, col);
        }
        result.push_back(std::move(db_row));
    }
 
    sqlite3_finalize(stmt);
 
    if (rc != SQLITE_DONE) {
        last_error_ = std::string("Step error: ") + sqlite3_errmsg(db);
        logger_.error("select_prepared", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::query_failed),
            last_error_,
            "sqlite_backend"
        };
    }
#else
    return database_backend::select_prepared(query, params);
#endif
 
    last_error_.clear();
    return result;
}

References connection_, database::connection_failed, convert_sqlite_value(), database::invalid_state, database::core::backend_base< sqlite_backend, database_types::sqlite >::is_initialized(), last_error_, database::query_failed, and sqlite_mutex_.

Here is the call graph for this function:

◆ select_query()

kcenon::common::Result< core::database_result > database::backends::sqlite_backend::select_query ( const std::string & query_string )

overridevirtual

Execute a SELECT query.

Parameters

query_string SQL SELECT statement

Returns: Query results as rows, or error

Implements database::core::database_backend.

Definition at line 194 of file sqlite_backend.cpp.

{
    if (!is_initialized()) {
        last_error_ = "Backend not initialized";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::invalid_state),
            last_error_,
            "sqlite_backend"
        };
    }
 
    core::database_result result;
 
#ifdef USE_SQLITE
    if (!connection_) {
        last_error_ = "No active connection";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::connection_failed),
            last_error_,
            "sqlite_backend"
        };
    }
    std::lock_guard<std::recursive_mutex> lock(sqlite_mutex_);
    try {
        sqlite3* db = static_cast<sqlite3*>(connection_);
        sqlite3_stmt* stmt = nullptr;
 
        // Prepare the statement
        int prepare_result = sqlite3_prepare_v2(db, query_string.c_str(), -1, &stmt, nullptr);
        if (prepare_result != SQLITE_OK) {
            last_error_ = std::string("Prepare failed: ") + sqlite3_errmsg(db);
            logger_.error("select_query", last_error_);
            return kcenon::common::error_info{
                static_cast<int>(database::error_code::query_failed),
                last_error_,
                "sqlite_backend"
            };
        }
 
        // Get column count and names
        int column_count = sqlite3_column_count(stmt);
        std::vector<std::string> column_names;
        for (int i = 0; i < column_count; i++) {
            column_names.push_back(sqlite3_column_name(stmt, i));
        }
 
        // Execute and fetch results
        while (sqlite3_step(stmt) == SQLITE_ROW) {
            core::database_row row;
 
            for (int i = 0; i < column_count; i++) {
                const std::string& column_name = column_names[i];
                row[column_name] = convert_sqlite_value(stmt, i);
            }
 
            result.push_back(std::move(row));
        }
 
        // Clean up
        sqlite3_finalize(stmt);
 
    } catch (const std::exception& e) {
        last_error_ = std::string("Select query error: ") + e.what();
        logger_.error("select_query", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::query_failed),
            last_error_,
            "sqlite_backend"
        };
    }
#else
    logger_.warning("SQLite support not compiled. Select query: " + query_string.substr(0, 20) + "...");
    // Return mock data for testing
    if (query_string.find("SELECT") != std::string::npos) {
        core::database_row mock_row;
        mock_row["id"] = int64_t(1);
        mock_row["name"] = std::string("sqlite_mock_data");
        mock_row["active"] = true;
        result.push_back(mock_row);
    }
#endif
 
    last_error_.clear();
    return result;
}

References connection_, database::connection_failed, convert_sqlite_value(), database::invalid_state, database::core::backend_base< sqlite_backend, database_types::sqlite >::is_initialized(), last_error_, database::query_failed, and sqlite_mutex_.

Here is the call graph for this function:

Friends And Related Symbol Documentation

◆ core::backend_base< sqlite_backend, database_types::sqlite >

friend class core::backend_base< sqlite_backend, database_types::sqlite >

friend

Definition at line 111 of file sqlite_backend.h.

Member Data Documentation

◆ connection_

void* database::backends::sqlite_backend::connection_ {nullptr}

private

SQLite connection (sqlite3*)

Definition at line 145 of file sqlite_backend.h.

145{nullptr};

Referenced by do_initialize(), do_shutdown(), execute_modification_query(), execute_prepared(), execute_query(), select_prepared(), and select_query().

◆ connection_config_

core::connection_config database::backends::sqlite_backend::connection_config_

private

Cached connection config.

Definition at line 148 of file sqlite_backend.h.

Referenced by connection_info(), and do_initialize().

◆ in_transaction_

std::atomic<bool> database::backends::sqlite_backend::in_transaction_ {false}

private

Transaction state.

Definition at line 146 of file sqlite_backend.h.

146{false};

Referenced by begin_transaction(), commit_transaction(), connection_info(), do_shutdown(), in_transaction(), and rollback_transaction().

◆ last_error_

std::string database::backends::sqlite_backend::last_error_

mutableprivate

Last error message.

Definition at line 147 of file sqlite_backend.h.

Referenced by begin_transaction(), commit_transaction(), do_initialize(), do_shutdown(), execute_modification_query(), execute_prepared(), execute_query(), last_error(), rollback_transaction(), select_prepared(), and select_query().

◆ sqlite_mutex_

std::recursive_mutex database::backends::sqlite_backend::sqlite_mutex_

mutableprivate

Mutex for thread safety.

Definition at line 149 of file sqlite_backend.h.

Referenced by do_initialize(), do_shutdown(), execute_modification_query(), execute_prepared(), execute_query(), select_prepared(), and select_query().

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

database/backends/sqlite_backend.h
database/backends/sqlite_backend.cpp

Public Member Functions

Static Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Friends

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ sqlite_backend()

◆ ~sqlite_backend()

Member Function Documentation

◆ backend_name()

◆ begin_transaction()

◆ commit_transaction()

◆ connection_info()

◆ convert_sqlite_value()

◆ do_initialize()

◆ do_shutdown()

◆ execute_modification_query()

◆ execute_prepared()

◆ execute_query()

◆ in_transaction()

◆ last_error()

◆ rollback_transaction()

◆ select_prepared()

◆ select_query()

Friends And Related Symbol Documentation

◆ core::backend_base< sqlite_backend, database_types::sqlite >

Member Data Documentation

◆ connection_

◆ connection_config_

◆ in_transaction_

◆ last_error_

◆ sqlite_mutex_