PostgreSQL implementation of database_backend interface. More...

#include <postgresql_backend.h>

Inheritance diagram for database::backends::postgresql_backend:

Collaboration diagram for database::backends::postgresql_backend:

Public Member Functions
	postgresql_backend ()
	Default constructor.

	~postgresql_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.

kcenon::common::Result< uint64_t >	execute_batch (const std::vector< std::string > &queries)
	Execute multiple queries in a single transaction (batch mode).

Public Member Functions inherited from database::core::backend_base< postgresql_backend, database_types::postgres >
	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< postgresql_backend, database_types::postgres >
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
std::string	build_connection_string (const core::connection_config &config) const
	Convert connection_config to PostgreSQL connection string.

std::string	build_safe_connection_string (const core::connection_config &config) const
	Build a connection string with password masked for safe logging.

std::string	sanitize_error (const std::string &error_message) const
	Remove password from an error message that may contain the connection string.

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

Private Attributes
void *	connection_ {nullptr}
	PostgreSQL connection (PGconn* or pqxx::connection*)

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

std::string	last_error_
	Last error message.

core::connection_config	connection_config_
	Cached connection config.

Friends
class	core::backend_base< postgresql_backend, database_types::postgres >

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< postgresql_backend, database_types::postgres >
std::atomic< bool >	initialized_
	Initialization state.

Detailed Description

PostgreSQL implementation of database_backend interface.

This class implements the database_backend interface for PostgreSQL via backend_base CRTP template, using libpq/pqxx libraries.

Design Pattern: Strategy pattern with CRTP

Extends backend_base for common lifecycle management
Uses libpq (C API) or pqxx (C++ API) for PostgreSQL access
Provides Result-based error handling
Supports transactions natively

Thread Safety:

Thread-safe for read operations (SELECT queries)
Write operations require external synchronization

Usage:

// Runtime selection via backend_registry
auto backend = backend_registry::instance().create("postgresql");
 
core::connection_config config;
config.host = "localhost";
config.port = 5432;
config.database = "mydb";
config.username = "user";
config.password = "pass";
 
if (auto result = backend->initialize(config); !result) {
    // Handle error
}
 
auto rows = backend->select_query("SELECT * FROM users");

Definition at line 71 of file postgresql_backend.h.

Constructor & Destructor Documentation

◆ postgresql_backend()

database::backends::postgresql_backend::postgresql_backend ( )

Default constructor.

Definition at line 38 of file postgresql_backend.cpp.

    : connection_(nullptr)
{
}

◆ ~postgresql_backend()

database::backends::postgresql_backend::~postgresql_backend ( )

overridedefault

Destructor - ensures proper cleanup.

Member Function Documentation

◆ backend_name()

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

inlinestaticconstexpr

Backend name for error messages.

Definition at line 78 of file postgresql_backend.h.

78{ return "postgresql_backend"; }

Referenced by TEST_F().

Here is the caller graph for this function:

◆ begin_transaction()

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

overridevirtual

Begin a transaction.

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

Implements database::core::database_backend.

Definition at line 712 of file postgresql_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_,
            "postgresql_backend"
        };
    }
 
    if (in_transaction_) {
        last_error_ = "Transaction already active";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::invalid_state),
            last_error_,
            "postgresql_backend"
        };
    }
 
    auto result = execute_query("BEGIN");
    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< postgresql_backend, database_types::postgres >::is_initialized(), and last_error_.

Referenced by execute_batch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ build_connection_string()

std::string database::backends::postgresql_backend::build_connection_string ( const core::connection_config & config ) const

private

Convert connection_config to PostgreSQL connection string.

Parameters

config Structured connection configuration

Returns: Connection string for libpq/pqxx

Format: "host=... port=... dbname=... user=... password=..."

Definition at line 878 of file postgresql_backend.cpp.

{
    std::ostringstream oss;
 
    if (!config.host.empty()) {
        oss << "host=" << config.host << " ";
    }
 
    if (config.port > 0) {
        oss << "port=" << config.port << " ";
    }
 
    if (!config.database.empty()) {
        oss << "dbname=" << config.database << " ";
    }
 
    if (!config.username.empty()) {
        oss << "user=" << config.username << " ";
    }
 
    if (!config.password.empty()) {
        oss << "password=" << config.password << " ";
    }
 
    // Append any additional options
    for (const auto& [key, value] : config.options) {
        oss << key << "=" << value << " ";
    }
 
    return oss.str();
}

References database::core::connection_config::database, database::core::connection_config::host, database::core::connection_config::options, database::core::connection_config::password, database::core::connection_config::port, and database::core::connection_config::username.

Referenced by do_initialize().

Here is the caller graph for this function:

◆ build_safe_connection_string()

std::string database::backends::postgresql_backend::build_safe_connection_string ( const core::connection_config & config ) const

private

Build a connection string with password masked for safe logging.

Parameters

config Structured connection configuration

Returns: Connection string with password replaced by "***"

Definition at line 910 of file postgresql_backend.cpp.

{
    std::ostringstream oss;
 
    if (!config.host.empty()) {
        oss << "host=" << config.host << " ";
    }
 
    if (config.port > 0) {
        oss << "port=" << config.port << " ";
    }
 
    if (!config.database.empty()) {
        oss << "dbname=" << config.database << " ";
    }
 
    if (!config.username.empty()) {
        oss << "user=" << config.username << " ";
    }
 
    if (!config.password.empty()) {
        oss << "password=*** ";
    }
 
    for (const auto& [key, value] : config.options) {
        oss << key << "=" << value << " ";
    }
 
    return oss.str();
}

References database::core::connection_config::database, database::core::connection_config::host, database::core::connection_config::options, database::core::connection_config::password, database::core::connection_config::port, and database::core::connection_config::username.

Referenced by do_initialize().

Here is the caller graph for this function:

◆ commit_transaction()

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

overridevirtual

Commit the current transaction.

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

Implements database::core::database_backend.

Definition at line 742 of file postgresql_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_,
            "postgresql_backend"
        };
    }
 
    if (!in_transaction_) {
        last_error_ = "No active transaction";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::invalid_state),
            last_error_,
            "postgresql_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< postgresql_backend, database_types::postgres >::is_initialized(), and last_error_.

Referenced by execute_batch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ connection_info()

std::map< std::string, std::string > database::backends::postgresql_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 865 of file postgresql_backend.cpp.

{
    std::map<std::string, std::string> info;
    info["backend"] = "postgresql";
    info["host"] = connection_config_.host;
    info["port"] = std::to_string(connection_config_.port);
    info["database"] = connection_config_.database;
    info["username"] = connection_config_.username;
    info["initialized"] = initialized_ ? "true" : "false";
    info["in_transaction"] = in_transaction_ ? "true" : "false";
    return info;
}

References connection_config_, database::core::connection_config::database, database::core::connection_config::host, in_transaction_, database::core::backend_base< postgresql_backend, database_types::postgres >::initialized_, database::core::connection_config::port, and database::core::connection_config::username.

◆ do_initialize()

kcenon::common::VoidResult database::backends::postgresql_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 43 of file postgresql_backend.cpp.

{
    connection_config_ = config;
    std::string conn_str = build_connection_string(config);
 
#ifdef USE_POSTGRESQL
    try {
        auto conn = std::make_unique<pqxx::connection>(conn_str);
        if (conn->is_open()) {
            connection_ = conn.release();
            last_error_.clear();
            return kcenon::common::ok();
        }
    } catch (const std::exception& e) {
        last_error_ = std::string("Connection error: ") + sanitize_error(e.what());
        logger_.error("do_initialize", last_error_);
    }
#elif defined(HAVE_LIBPQ)
    try {
        connection_ = PQconnectdb(conn_str.c_str());
        if (PQstatus(static_cast<PGconn*>(connection_)) == CONNECTION_OK) {
            last_error_.clear();
            return kcenon::common::ok();
        }
        last_error_ = sanitize_error(PQerrorMessage(static_cast<PGconn*>(connection_)));
        PQfinish(static_cast<PGconn*>(connection_));
        connection_ = nullptr;
    } catch (const std::exception& e) {
        last_error_ = std::string("Connection error: ") + sanitize_error(e.what());
        logger_.error("do_initialize", last_error_);
    }
#else
    logger_.warning("PostgreSQL support not compiled. Connection: " + build_safe_connection_string(config));
    // Mock mode for testing without PostgreSQL
    last_error_.clear();
    return kcenon::common::ok();
#endif
 
    if (last_error_.empty()) {
        last_error_ = "Failed to connect to PostgreSQL server";
    }
    return kcenon::common::error_info{
        static_cast<int>(database::error_code::connection_failed),
        last_error_,
        "postgresql_backend"
    };
}

References build_connection_string(), build_safe_connection_string(), connection_, connection_config_, database::connection_failed, last_error_, and sanitize_error().

Here is the call graph for this function:

◆ do_shutdown()

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

protected

Database-specific shutdown logic.

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

Definition at line 91 of file postgresql_backend.cpp.

{
    // Rollback any active transaction before disconnecting
    if (in_transaction_) {
        rollback_transaction();
    }
 
#ifdef USE_POSTGRESQL
    try {
        delete static_cast<pqxx::connection*>(connection_);
        connection_ = nullptr;
        last_error_.clear();
        return kcenon::common::ok();
    } catch (const std::exception& e) {
        last_error_ = std::string("Disconnect error: ") + e.what();
        logger_.error("do_shutdown", last_error_);
    }
#elif defined(HAVE_LIBPQ)
    try {
        PQfinish(static_cast<PGconn*>(connection_));
        connection_ = nullptr;
        last_error_.clear();
        return kcenon::common::ok();
    } catch (const std::exception& e) {
        last_error_ = std::string("Disconnect error: ") + e.what();
        logger_.error("do_shutdown", last_error_);
    }
#else
    connection_ = nullptr;
    last_error_.clear();
    return kcenon::common::ok();
#endif
 
    return kcenon::common::error_info{
        static_cast<int>(database::error_code::connection_failed),
        last_error_,
        "postgresql_backend"
    };
}

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

Here is the call graph for this function:

◆ execute_batch()

kcenon::common::Result< uint64_t > database::backends::postgresql_backend::execute_batch ( const std::vector< std::string > & queries )

Execute multiple queries in a single transaction (batch mode).

Parameters

queries Vector of SQL statements to execute atomically.

Returns: Result containing total affected rows on success, or error on failure.

All queries run inside a single BEGIN/COMMIT block. If any query fails, the entire batch is rolled back and the error is returned.

Definition at line 799 of file postgresql_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_,
            "postgresql_backend"
        };
    }
 
    if (queries.empty()) {
        return static_cast<uint64_t>(0);
    }
 
    // Use existing transaction API for atomicity
    auto begin_result = begin_transaction();
    if (begin_result.is_err()) {
        return kcenon::common::error_info{
            begin_result.error().code,
            "Batch begin failed: " + begin_result.error().message,
            "postgresql_backend"
        };
    }
 
    uint64_t total_affected = 0;
    for (size_t i = 0; i < queries.size(); ++i) {
        unsigned int affected = execute_modification_query(queries[i]);
        if (!last_error_.empty()) {
            std::string batch_error = "Batch query " + std::to_string(i) +
                " failed: " + last_error_;
            rollback_transaction();
            last_error_ = batch_error;
            return kcenon::common::error_info{
                static_cast<int>(database::error_code::query_failed),
                last_error_,
                "postgresql_backend"
            };
        }
        total_affected += affected;
    }
 
    auto commit_result = commit_transaction();
    if (commit_result.is_err()) {
        return kcenon::common::error_info{
            commit_result.error().code,
            "Batch commit failed: " + commit_result.error().message,
            "postgresql_backend"
        };
    }
 
    last_error_.clear();
    return total_affected;
}

References begin_transaction(), commit_transaction(), execute_modification_query(), database::invalid_state, database::core::backend_base< postgresql_backend, database_types::postgres >::is_initialized(), last_error_, database::query_failed, and rollback_transaction().

Here is the call graph for this function:

◆ execute_modification_query()

unsigned int database::backends::postgresql_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 132 of file postgresql_backend.cpp.

{
#ifdef USE_POSTGRESQL
    if (!connection_) return 0;
    try {
        pqxx::connection* conn = static_cast<pqxx::connection*>(connection_);
        pqxx::work txn(*conn);
        pqxx::result result = txn.exec(query_string);
        txn.commit();
        return static_cast<unsigned int>(result.affected_rows());
    } catch (const std::exception& e) {
        last_error_ = std::string("Modification query error: ") + e.what();
        logger_.error("execute_modification_query", last_error_);
    }
#elif defined(HAVE_LIBPQ)
    if (!connection_) return 0;
    try {
        PGresult* result = PQexec(static_cast<PGconn*>(connection_), query_string.c_str());
        if (PQresultStatus(result) != PGRES_COMMAND_OK) {
            last_error_ = PQerrorMessage(static_cast<PGconn*>(connection_));
            PQclear(result);
            return 0;
        }
        const char* affected_rows = PQcmdTuples(result);
        unsigned int count = 0;
        if (affected_rows && *affected_rows) {
            count = static_cast<unsigned int>(std::stoul(affected_rows));
        }
        PQclear(result);
        return count;
    } catch (const std::exception& e) {
        last_error_ = std::string("Modification query error: ") + e.what();
        logger_.error("execute_modification_query", last_error_);
    }
#else
    logger_.warning("PostgreSQL support not compiled. Modification query: " + query_string.substr(0, 20) + "...");
    return 1; // Mock: return 1 affected row
#endif
    return 0;
}

References connection_, and last_error_.

Referenced by execute_batch().

Here is the caller graph for this function:

◆ execute_prepared()

kcenon::common::VoidResult database::backends::postgresql_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 575 of file postgresql_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_,
            "postgresql_backend"
        };
    }
 
#ifdef USE_POSTGRESQL
    try {
        if (!connection_) {
            last_error_ = "No active PostgreSQL connection";
            logger_.error("execute_prepared", last_error_);
            return kcenon::common::error_info{
                static_cast<int>(database::error_code::connection_failed),
                last_error_,
                "postgresql_backend"
            };
        }
 
        pqxx::connection* conn = static_cast<pqxx::connection*>(connection_);
        pqxx::work txn(*conn);
 
        pqxx::params pq_params;
        for (const auto& val : params) {
            std::visit([&pq_params](const auto& v) {
                using T = std::decay_t<decltype(v)>;
                if constexpr (std::is_same_v<T, std::nullptr_t>) {
                    pq_params.append();
                } else if constexpr (std::is_same_v<T, bool>) {
                    pq_params.append(v);
                } else if constexpr (std::is_same_v<T, int64_t>) {
                    pq_params.append(v);
                } else if constexpr (std::is_same_v<T, double>) {
                    pq_params.append(v);
                } else if constexpr (std::is_same_v<T, std::string>) {
                    pq_params.append(v);
                }
            }, val);
        }
 
        txn.exec_params(query, pq_params);
        txn.commit();
        last_error_.clear();
        return kcenon::common::ok();
    } catch (const std::exception& e) {
        last_error_ = std::string("Execute prepared error: ") + e.what();
        logger_.error("execute_prepared", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::query_failed),
            last_error_,
            "postgresql_backend"
        };
    }
#elif defined(HAVE_LIBPQ)
    if (!connection_) {
        last_error_ = "No active PostgreSQL connection";
        logger_.error("execute_prepared", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::connection_failed),
            last_error_,
            "postgresql_backend"
        };
    }
 
    std::vector<std::string> param_strings;
    std::vector<const char*> param_values;
    param_strings.reserve(params.size());
    param_values.reserve(params.size());
 
    for (const auto& val : params) {
        std::visit([&param_strings, &param_values](const auto& v) {
            using T = std::decay_t<decltype(v)>;
            if constexpr (std::is_same_v<T, std::nullptr_t>) {
                param_strings.emplace_back();
                param_values.push_back(nullptr);
            } else if constexpr (std::is_same_v<T, bool>) {
                param_strings.push_back(v ? "t" : "f");
                param_values.push_back(param_strings.back().c_str());
            } else if constexpr (std::is_same_v<T, std::string>) {
                param_strings.push_back(v);
                param_values.push_back(param_strings.back().c_str());
            } else {
                param_strings.push_back(std::to_string(v));
                param_values.push_back(param_strings.back().c_str());
            }
        }, val);
    }
 
    PGresult* pg_result = PQexecParams(
        static_cast<PGconn*>(connection_),
        query.c_str(),
        static_cast<int>(params.size()),
        nullptr,
        param_values.data(),
        nullptr,
        nullptr,
        0
    );
 
    if (pg_result == nullptr) {
        last_error_ = "PostgreSQL execute prepared failed";
        logger_.error("execute_prepared", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::query_failed),
            last_error_,
            "postgresql_backend"
        };
    }
 
    ExecStatusType status = PQresultStatus(pg_result);
    bool success = (status == PGRES_COMMAND_OK) || (status == PGRES_TUPLES_OK);
 
    if (!success) {
        last_error_ = PQerrorMessage(static_cast<PGconn*>(connection_));
        logger_.error("execute_prepared", last_error_);
        PQclear(pg_result);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::query_failed),
            last_error_,
            "postgresql_backend"
        };
    }
 
    PQclear(pg_result);
    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< postgresql_backend, database_types::postgres >::is_initialized(), last_error_, database::query_failed, and database::success.

Here is the call graph for this function:

◆ execute_query()

kcenon::common::VoidResult database::backends::postgresql_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 309 of file postgresql_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_,
            "postgresql_backend"
        };
    }
 
#ifdef USE_POSTGRESQL
    try {
        if (!connection_) {
            last_error_ = "No active PostgreSQL connection";
            logger_.error("execute_query", last_error_);
            return kcenon::common::error_info{
                static_cast<int>(database::error_code::connection_failed),
                last_error_,
                "postgresql_backend"
            };
        }
 
        pqxx::work txn{*static_cast<pqxx::connection*>(connection_)};
        txn.exec(query_string);
        txn.commit();
        last_error_.clear();
        return kcenon::common::ok();
    } catch (const std::exception& e) {
        last_error_ = std::string("Execute error: ") + e.what();
        logger_.error("execute_query", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::query_failed),
            last_error_,
            "postgresql_backend"
        };
    }
#elif defined(HAVE_LIBPQ)
    if (!connection_) {
        last_error_ = "No active PostgreSQL connection";
        logger_.error("execute_query", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::connection_failed),
            last_error_,
            "postgresql_backend"
        };
    }
 
    PGresult* result = PQexec(static_cast<PGconn*>(connection_), query_string.c_str());
    if (result == nullptr) {
        last_error_ = "PostgreSQL execute failed";
        logger_.error("execute_query", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::query_failed),
            last_error_,
            "postgresql_backend"
        };
    }
 
    ExecStatusType status = PQresultStatus(result);
    bool success = (status == PGRES_COMMAND_OK) || (status == PGRES_TUPLES_OK);
 
    if (!success) {
        last_error_ = PQerrorMessage(static_cast<PGconn*>(connection_));
        logger_.error("execute_query", last_error_);
        PQclear(result);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::query_failed),
            last_error_,
            "postgresql_backend"
        };
    }
 
    PQclear(result);
    last_error_.clear();
    return kcenon::common::ok();
#else
    // Mock execution
    logger_.info("PostgreSQL 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< postgresql_backend, database_types::postgres >::is_initialized(), last_error_, database::query_failed, and database::success.

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::postgresql_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 855 of file postgresql_backend.cpp.

{
    return in_transaction_;
}

References in_transaction_.

◆ last_error()

std::string database::backends::postgresql_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 860 of file postgresql_backend.cpp.

{
    return last_error_;
}

References last_error_.

◆ rollback_transaction()

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

overridevirtual

Rollback the current transaction.

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

Implements database::core::database_backend.

Definition at line 772 of file postgresql_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_,
            "postgresql_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< postgresql_backend, database_types::postgres >::is_initialized(), and last_error_.

Referenced by do_shutdown(), and execute_batch().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ sanitize_error()

std::string database::backends::postgresql_backend::sanitize_error ( const std::string & error_message ) const

private

Remove password from an error message that may contain the connection string.

Parameters

error_message The error message to sanitize

Returns: Error message with password masked

Definition at line 941 of file postgresql_backend.cpp.

{
    if (connection_config_.password.empty()) {
        return error_message;
    }
 
    std::string sanitized = error_message;
    std::string::size_type pos = 0;
    while ((pos = sanitized.find(connection_config_.password, pos)) != std::string::npos) {
        sanitized.replace(pos, connection_config_.password.length(), "***");
        pos += 3;
    }
 
    return sanitized;
}

References connection_config_, and database::core::connection_config::password.

Referenced by do_initialize().

Here is the caller graph for this function:

◆ select_prepared()

kcenon::common::Result< core::database_result > database::backends::postgresql_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 393 of file postgresql_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_,
            "postgresql_backend"
        };
    }
 
    core::database_result result;
 
#ifdef USE_POSTGRESQL
    if (!connection_) {
        last_error_ = "No active connection";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::connection_failed),
            last_error_,
            "postgresql_backend"
        };
    }
    try {
        pqxx::connection* conn = static_cast<pqxx::connection*>(connection_);
        pqxx::work txn(*conn);
 
        // Build pqxx::params from database_value vector
        pqxx::params pq_params;
        for (const auto& val : params) {
            std::visit([&pq_params](const auto& v) {
                using T = std::decay_t<decltype(v)>;
                if constexpr (std::is_same_v<T, std::nullptr_t>) {
                    pq_params.append();
                } else if constexpr (std::is_same_v<T, bool>) {
                    pq_params.append(v);
                } else if constexpr (std::is_same_v<T, int64_t>) {
                    pq_params.append(v);
                } else if constexpr (std::is_same_v<T, double>) {
                    pq_params.append(v);
                } else if constexpr (std::is_same_v<T, std::string>) {
                    pq_params.append(v);
                }
            }, val);
        }
 
        pqxx::result pqxx_result = txn.exec_params(query, pq_params);
        txn.commit();
 
        for (const auto& row : pqxx_result) {
            core::database_row db_row;
            for (size_t i = 0; i < row.size(); ++i) {
                std::string column_name = pqxx_result.column_name(i);
                if (row[i].is_null()) {
                    db_row[column_name] = nullptr;
                } else {
                    if (row[i].type() == PG_INT8OID ||
                        row[i].type() == PG_INT4OID) {
                        db_row[column_name] = row[i].as<int64_t>();
                    } else if (row[i].type() == PG_FLOAT8OID ||
                               row[i].type() == PG_FLOAT4OID) {
                        db_row[column_name] = row[i].as<double>();
                    } else if (row[i].type() == PG_BOOLOID) {
                        db_row[column_name] = row[i].as<bool>();
                    } else {
                        db_row[column_name] = row[i].as<std::string>();
                    }
                }
            }
            result.push_back(std::move(db_row));
        }
    } catch (const std::exception& e) {
        last_error_ = std::string("Select prepared error: ") + e.what();
        logger_.error("select_prepared", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::query_failed),
            last_error_,
            "postgresql_backend"
        };
    }
#elif defined(HAVE_LIBPQ)
    if (!connection_) {
        last_error_ = "No active connection";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::connection_failed),
            last_error_,
            "postgresql_backend"
        };
    }
    try {
        // Convert params to C string array for PQexecParams
        std::vector<std::string> param_strings;
        std::vector<const char*> param_values;
        param_strings.reserve(params.size());
        param_values.reserve(params.size());
 
        for (const auto& val : params) {
            std::visit([&param_strings, &param_values](const auto& v) {
                using T = std::decay_t<decltype(v)>;
                if constexpr (std::is_same_v<T, std::nullptr_t>) {
                    param_strings.emplace_back();
                    param_values.push_back(nullptr);
                } else if constexpr (std::is_same_v<T, bool>) {
                    param_strings.push_back(v ? "t" : "f");
                    param_values.push_back(param_strings.back().c_str());
                } else if constexpr (std::is_same_v<T, std::string>) {
                    param_strings.push_back(v);
                    param_values.push_back(param_strings.back().c_str());
                } else {
                    param_strings.push_back(std::to_string(v));
                    param_values.push_back(param_strings.back().c_str());
                }
            }, val);
        }
 
        PGresult* pg_result = PQexecParams(
            static_cast<PGconn*>(connection_),
            query.c_str(),
            static_cast<int>(params.size()),
            nullptr,  // let server infer types
            param_values.data(),
            nullptr,  // text format lengths
            nullptr,  // text format
            0         // text result format
        );
 
        if (PQresultStatus(pg_result) != PGRES_TUPLES_OK) {
            last_error_ = PQerrorMessage(static_cast<PGconn*>(connection_));
            PQclear(pg_result);
            return kcenon::common::error_info{
                static_cast<int>(database::error_code::query_failed),
                last_error_,
                "postgresql_backend"
            };
        }
 
        int rows = PQntuples(pg_result);
        int cols = PQnfields(pg_result);
 
        for (int row = 0; row < rows; ++row) {
            core::database_row db_row;
            for (int col = 0; col < cols; ++col) {
                std::string column_name = PQfname(pg_result, col);
                if (PQgetisnull(pg_result, row, col)) {
                    db_row[column_name] = nullptr;
                } else {
                    const char* value = PQgetvalue(pg_result, row, col);
                    Oid type = PQftype(pg_result, col);
 
                    if (type == 20 || type == 21 || type == 23) {
                        db_row[column_name] = static_cast<int64_t>(std::stoll(value));
                    } else if (type == 700 || type == 701) {
                        db_row[column_name] = std::stod(value);
                    } else if (type == 16) {
                        db_row[column_name] = (*value == 't' || *value == '1');
                    } else {
                        db_row[column_name] = std::string(value);
                    }
                }
            }
            result.push_back(std::move(db_row));
        }
        PQclear(pg_result);
    } catch (const std::exception& e) {
        last_error_ = std::string("Select prepared error: ") + e.what();
        logger_.error("select_prepared", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::query_failed),
            last_error_,
            "postgresql_backend"
        };
    }
#else
    // Fallback to string interpolation for mock mode
    return database_backend::select_prepared(query, params);
#endif
 
    last_error_.clear();
    return result;
}

References connection_, database::connection_failed, database::invalid_state, database::core::backend_base< postgresql_backend, database_types::postgres >::is_initialized(), last_error_, database::query_failed, and database::core::backend_base< postgresql_backend, database_types::postgres >::type().

Here is the call graph for this function:

◆ select_query()

kcenon::common::Result< core::database_result > database::backends::postgresql_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 175 of file postgresql_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_,
            "postgresql_backend"
        };
    }
 
    core::database_result result;
 
#ifdef USE_POSTGRESQL
    if (!connection_) {
        last_error_ = "No active connection";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::connection_failed),
            last_error_,
            "postgresql_backend"
        };
    }
    try {
        pqxx::connection* conn = static_cast<pqxx::connection*>(connection_);
        pqxx::work txn(*conn);
        pqxx::result pqxx_result = txn.exec(query_string);
        txn.commit();
 
        for (const auto& row : pqxx_result) {
            core::database_row db_row;
            for (size_t i = 0; i < row.size(); ++i) {
                std::string column_name = pqxx_result.column_name(i);
                if (row[i].is_null()) {
                    db_row[column_name] = nullptr;
                } else {
                    // Try to convert to appropriate type
                    if (row[i].type() == PG_INT8OID ||
                        row[i].type() == PG_INT4OID) {
                        db_row[column_name] = row[i].as<int64_t>();
                    } else if (row[i].type() == PG_FLOAT8OID ||
                               row[i].type() == PG_FLOAT4OID) {
                        db_row[column_name] = row[i].as<double>();
                    } else if (row[i].type() == PG_BOOLOID) {
                        db_row[column_name] = row[i].as<bool>();
                    } else {
                        db_row[column_name] = row[i].as<std::string>();
                    }
                }
            }
            result.push_back(std::move(db_row));
        }
    } 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_,
            "postgresql_backend"
        };
    }
#elif defined(HAVE_LIBPQ)
    if (!connection_) {
        last_error_ = "No active connection";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::connection_failed),
            last_error_,
            "postgresql_backend"
        };
    }
    try {
        PGresult* pg_result = PQexec(static_cast<PGconn*>(connection_), query_string.c_str());
        if (PQresultStatus(pg_result) != PGRES_TUPLES_OK) {
            last_error_ = PQerrorMessage(static_cast<PGconn*>(connection_));
            PQclear(pg_result);
            return kcenon::common::error_info{
                static_cast<int>(database::error_code::query_failed),
                last_error_,
                "postgresql_backend"
            };
        }
 
        int rows = PQntuples(pg_result);
        int cols = PQnfields(pg_result);
 
        for (int row = 0; row < rows; ++row) {
            core::database_row db_row;
            for (int col = 0; col < cols; ++col) {
                std::string column_name = PQfname(pg_result, col);
                if (PQgetisnull(pg_result, row, col)) {
                    db_row[column_name] = nullptr;
                } else {
                    const char* value = PQgetvalue(pg_result, row, col);
                    Oid type = PQftype(pg_result, col);
 
                    // Convert based on PostgreSQL type
                    if (type == 20 || type == 21 || type == 23) { // int8, int2, int4
                        db_row[column_name] = static_cast<int64_t>(std::stoll(value));
                    } else if (type == 700 || type == 701) { // float4, float8
                        db_row[column_name] = std::stod(value);
                    } else if (type == 16) { // bool
                        db_row[column_name] = (*value == 't' || *value == '1');
                    } else {
                        db_row[column_name] = std::string(value);
                    }
                }
            }
            result.push_back(std::move(db_row));
        }
        PQclear(pg_result);
    } 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_,
            "postgresql_backend"
        };
    }
#else
    logger_.warning("PostgreSQL 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("mock_data");
        mock_row["active"] = true;
        result.push_back(mock_row);
    }
#endif
 
    last_error_.clear();
    return result;
}

References connection_, database::connection_failed, database::invalid_state, database::core::backend_base< postgresql_backend, database_types::postgres >::is_initialized(), last_error_, database::query_failed, and database::core::backend_base< postgresql_backend, database_types::postgres >::type().

Here is the call graph for this function:

Friends And Related Symbol Documentation

◆ core::backend_base< postgresql_backend, database_types::postgres >

friend class core::backend_base< postgresql_backend, database_types::postgres >

friend

Definition at line 124 of file postgresql_backend.h.

Member Data Documentation

◆ connection_

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

private

PostgreSQL connection (PGconn* or pqxx::connection*)

Definition at line 173 of file postgresql_backend.h.

173{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::postgresql_backend::connection_config_

private

Cached connection config.

Definition at line 176 of file postgresql_backend.h.

Referenced by connection_info(), do_initialize(), and sanitize_error().

◆ in_transaction_

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

private

Transaction state.

Definition at line 174 of file postgresql_backend.h.

174{false};

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

◆ last_error_

std::string database::backends::postgresql_backend::last_error_

mutableprivate

Last error message.

Definition at line 175 of file postgresql_backend.h.

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

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

database/backends/postgresql_backend.h
database/backends/postgresql_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

◆ postgresql_backend()

◆ ~postgresql_backend()

Member Function Documentation

◆ backend_name()

◆ begin_transaction()

◆ build_connection_string()

◆ build_safe_connection_string()

◆ commit_transaction()

◆ connection_info()

◆ do_initialize()

◆ do_shutdown()

◆ execute_batch()

◆ execute_modification_query()

◆ execute_prepared()

◆ execute_query()

◆ in_transaction()

◆ last_error()

◆ rollback_transaction()

◆ sanitize_error()

◆ select_prepared()

◆ select_query()

Friends And Related Symbol Documentation

◆ core::backend_base< postgresql_backend, database_types::postgres >

Member Data Documentation

◆ connection_

◆ connection_config_

◆ in_transaction_

◆ last_error_