Manages PostgreSQL database operations. More...

#include <postgres_manager.h>

Inheritance diagram for database::postgres_manager:

Collaboration diagram for database::postgres_manager:

Public Member Functions
	postgres_manager (void)
	Default constructor.

virtual	~postgres_manager (void)
	Destructor.

database_types	type () const override
	Returns the specific type of the database.

kcenon::common::VoidResult	initialize (const core::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.

kcenon::common::Result< core::database_result >	select_query (const std::string &query_string) override
	Executes a SELECT query on the connected PostgreSQL database and returns the resulting data.

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

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::database_backend
virtual	~database_backend ()=default

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

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

Private Member Functions
kcenon::common::Result< uint64_t >	execute_modification_query (const std::string &query_string)
	Common implementation for INSERT, UPDATE, and DELETE queries.

Private Attributes
void *	connection_
	Pointer to the underlying PostgreSQL connection object.

bool	initialized_
	Whether the backend is initialized.

bool	in_transaction_
	Whether a transaction is active.

std::string	last_error_
	Last error message.

std::string	connection_string_
	Connection string for connection_info.

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)

Detailed Description

Manages PostgreSQL database operations.

This class provides an implementation of the database_backend interface for PostgreSQL databases. It defines methods for connecting, querying, and disconnecting from a PostgreSQL database.

Definition at line 19 of file postgres_manager.h.

Constructor & Destructor Documentation

◆ postgres_manager()

database::postgres_manager::postgres_manager ( void )

Default constructor.

Definition at line 37 of file postgres_manager.cpp.

        : connection_(nullptr)
        , initialized_(false)
        , in_transaction_(false)
    {
    }

◆ ~postgres_manager()

database::postgres_manager::~postgres_manager ( void )

virtual

Destructor.

Definition at line 44 of file postgres_manager.cpp.

    {
        shutdown();
    }

References shutdown().

Here is the call graph for this function:

Member Function Documentation

◆ begin_transaction()

kcenon::common::VoidResult database::postgres_manager::begin_transaction ( )

overridevirtual

Begin a transaction.

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

Implements database::core::database_backend.

Definition at line 347 of file postgres_manager.cpp.

    {
        if (!initialized_) {
            return kcenon::common::error_info{-1, "Not initialized", "postgres_manager"};
        }
 
        if (in_transaction_) {
            return kcenon::common::error_info{-2, "Transaction already active", "postgres_manager"};
        }
 
        auto result = execute_query("BEGIN");
        if (result.is_ok()) {
            in_transaction_ = true;
        }
        return result;
    }

References execute_query(), in_transaction_, and initialized_.

Here is the call graph for this function:

◆ commit_transaction()

kcenon::common::VoidResult database::postgres_manager::commit_transaction ( )

overridevirtual

Commit the current transaction.

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

Implements database::core::database_backend.

Definition at line 364 of file postgres_manager.cpp.

    {
        if (!initialized_) {
            return kcenon::common::error_info{-1, "Not initialized", "postgres_manager"};
        }
 
        if (!in_transaction_) {
            return kcenon::common::error_info{-2, "No active transaction", "postgres_manager"};
        }
 
        auto result = execute_query("COMMIT");
        if (result.is_ok()) {
            in_transaction_ = false;
        }
        return result;
    }

References execute_query(), in_transaction_, and initialized_.

Here is the call graph for this function:

◆ connection_info()

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

overridevirtual

Get backend-specific connection information.

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

Implements database::core::database_backend.

Definition at line 408 of file postgres_manager.cpp.

    {
        std::map<std::string, std::string> info;
        info["backend"] = "postgresql";
        info["initialized"] = initialized_ ? "true" : "false";
        info["in_transaction"] = in_transaction_ ? "true" : "false";
 
#ifdef USE_POSTGRESQL
        info["driver"] = "libpqxx";
        if (initialized_ && connection_) {
            auto* conn = static_cast<pqxx::connection*>(connection_);
            info["server_version"] = std::to_string(conn->server_version());
            info["protocol_version"] = std::to_string(conn->protocol_version());
        }
#elif defined(HAVE_LIBPQ)
        info["driver"] = "libpq";
        if (initialized_ && connection_) {
            auto* conn = static_cast<PGconn*>(connection_);
            info["server_version"] = std::to_string(PQserverVersion(conn));
            info["protocol_version"] = std::to_string(PQprotocolVersion(conn));
        }
#else
        info["driver"] = "mock";
#endif
 
        return info;
    }

References connection_, in_transaction_, and initialized_.

◆ execute_modification_query()

kcenon::common::Result< uint64_t > database::postgres_manager::execute_modification_query ( const std::string & query_string )

private

Common implementation for INSERT, UPDATE, and DELETE queries.

Parameters

query_string The SQL query to be executed.

Returns: Number of affected rows, or error

Definition at line 162 of file postgres_manager.cpp.

    {
        if (!initialized_) {
            return kcenon::common::error_info{-1, "Not initialized", "postgres_manager"};
        }
 
#ifdef USE_POSTGRESQL
        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<uint64_t>(result.affected_rows());
        } catch (const std::exception& e) {
            last_error_ = std::string("Modification query error: ") + e.what();
            POSTGRES_LOG_ERROR("execute_modification_query", last_error_);
            return kcenon::common::error_info{-2, last_error_, "postgres_manager"};
        }
#elif defined(HAVE_LIBPQ)
        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 kcenon::common::error_info{-2, last_error_, "postgres_manager"};
            }
            const char* affected_rows = PQcmdTuples(result);
            uint64_t count = 0;
            if (affected_rows && *affected_rows) {
                count = static_cast<uint64_t>(std::stoull(affected_rows));
            }
            PQclear(result);
            return count;
        } catch (const std::exception& e) {
            last_error_ = std::string("Modification query error: ") + e.what();
            POSTGRES_LOG_ERROR("execute_modification_query", last_error_);
            return kcenon::common::error_info{-2, last_error_, "postgres_manager"};
        }
#else
        POSTGRES_LOG_WARNING("PostgreSQL support not compiled. Mock modification: " + query_string.substr(0, 20) + "...");
        return uint64_t{1};
#endif
    }

References connection_, initialized_, last_error_, POSTGRES_LOG_ERROR, and POSTGRES_LOG_WARNING.

◆ execute_query()

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

overridevirtual

Executes a general SQL query (DDL, DML) on PostgreSQL.

Parameters

query_string The SQL query string to execute.

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

Implements database::core::database_backend.

Definition at line 304 of file postgres_manager.cpp.

    {
        if (!initialized_) {
            return kcenon::common::error_info{-1, "Not initialized", "postgres_manager"};
        }
 
#ifdef USE_POSTGRESQL
        try {
            pqxx::work txn{*static_cast<pqxx::connection*>(connection_)};
            txn.exec(query_string);
            txn.commit();
            return kcenon::common::ok();
        } catch (const std::exception& e) {
            last_error_ = std::string("Execute error: ") + e.what();
            POSTGRES_LOG_ERROR("execute_query", last_error_);
            return kcenon::common::error_info{-2, last_error_, "postgres_manager"};
        }
#elif defined(HAVE_LIBPQ)
        PGresult* result = PQexec(static_cast<PGconn*>(connection_), query_string.c_str());
        if (result == nullptr) {
            last_error_ = "PostgreSQL execute failed";
            POSTGRES_LOG_ERROR("execute_query", last_error_);
            return kcenon::common::error_info{-2, last_error_, "postgres_manager"};
        }
 
        ExecStatusType status = PQresultStatus(result);
        bool success = (status == PGRES_COMMAND_OK) || (status == PGRES_TUPLES_OK);
 
        if (!success) {
            last_error_ = PQerrorMessage(static_cast<PGconn*>(connection_));
            POSTGRES_LOG_ERROR("execute_query", last_error_);
            PQclear(result);
            return kcenon::common::error_info{-2, last_error_, "postgres_manager"};
        }
 
        PQclear(result);
        return kcenon::common::ok();
#else
        POSTGRES_LOG_INFO("PostgreSQL support not compiled. Mock execute: " + query_string);
        return kcenon::common::ok();
#endif
    }

References connection_, initialized_, last_error_, POSTGRES_LOG_ERROR, POSTGRES_LOG_INFO, and database::success.

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

Here is the caller graph for this function:

◆ in_transaction()

bool database::postgres_manager::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 398 of file postgres_manager.cpp.

    {
        return in_transaction_;
    }

References in_transaction_.

◆ initialize()

kcenon::common::VoidResult database::postgres_manager::initialize ( const core::connection_config & config )

overridevirtual

Initialize the database backend.

Parameters

config Connection configuration

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

Implements database::core::database_backend.

Definition at line 54 of file postgres_manager.cpp.

    {
        if (initialized_) {
            return kcenon::common::error_info{-1, "Already initialized", "postgres_manager"};
        }
 
        // Build connection string from config
        std::ostringstream conn_str;
        if (!config.host.empty()) {
            conn_str << "host=" << config.host << " ";
        }
        if (config.port > 0) {
            conn_str << "port=" << config.port << " ";
        }
        if (!config.database.empty()) {
            conn_str << "dbname=" << config.database << " ";
        }
        if (!config.username.empty()) {
            conn_str << "user=" << config.username << " ";
        }
        if (!config.password.empty()) {
            conn_str << "password=" << config.password << " ";
        }
        for (const auto& [key, value] : config.options) {
            conn_str << key << "=" << value << " ";
        }
 
        connection_string_ = conn_str.str();
 
#ifdef USE_POSTGRESQL
        try {
            auto conn = std::make_unique<pqxx::connection>(connection_string_);
            if (conn->is_open()) {
                connection_ = conn.release();
                initialized_ = true;
                return kcenon::common::ok();
            }
            last_error_ = "Connection failed to open";
        } catch (const std::exception& e) {
            last_error_ = std::string("Connection error: ") + e.what();
            POSTGRES_LOG_ERROR("initialize", last_error_);
        }
#elif defined(HAVE_LIBPQ)
        try {
            connection_ = PQconnectdb(connection_string_.c_str());
            if (PQstatus(static_cast<PGconn*>(connection_)) == CONNECTION_OK) {
                initialized_ = true;
                return kcenon::common::ok();
            }
            last_error_ = PQerrorMessage(static_cast<PGconn*>(connection_));
            PQfinish(static_cast<PGconn*>(connection_));
            connection_ = nullptr;
        } catch (const std::exception& e) {
            last_error_ = std::string("Connection error: ") + e.what();
            POSTGRES_LOG_ERROR("initialize", last_error_);
        }
#else
        POSTGRES_LOG_WARNING("PostgreSQL support not compiled. Mock connection established.");
        initialized_ = true;
        return kcenon::common::ok();
#endif
        return kcenon::common::error_info{-2, last_error_, "postgres_manager"};
    }

References connection_, connection_string_, database::core::connection_config::database, database::core::connection_config::host, initialized_, last_error_, database::core::connection_config::options, database::core::connection_config::password, database::core::connection_config::port, POSTGRES_LOG_ERROR, POSTGRES_LOG_WARNING, and database::core::connection_config::username.

◆ is_initialized()

bool database::postgres_manager::is_initialized ( ) const

overridevirtual

Check if backend is initialized and ready.

Returns: true if initialized and can accept queries

Implements database::core::database_backend.

Definition at line 157 of file postgres_manager.cpp.

    {
        return initialized_;
    }

References initialized_.

◆ last_error()

std::string database::postgres_manager::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 403 of file postgres_manager.cpp.

    {
        return last_error_;
    }

References last_error_.

◆ rollback_transaction()

kcenon::common::VoidResult database::postgres_manager::rollback_transaction ( )

overridevirtual

Rollback the current transaction.

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

Implements database::core::database_backend.

Definition at line 381 of file postgres_manager.cpp.

    {
        if (!initialized_) {
            return kcenon::common::error_info{-1, "Not initialized", "postgres_manager"};
        }
 
        if (!in_transaction_) {
            return kcenon::common::error_info{-2, "No active transaction", "postgres_manager"};
        }
 
        auto result = execute_query("ROLLBACK");
        if (result.is_ok()) {
            in_transaction_ = false;
        }
        return result;
    }

References execute_query(), in_transaction_, and initialized_.

Referenced by shutdown().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ select_query()

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

overridevirtual

Executes a SELECT query on the connected PostgreSQL database and returns the resulting data.

Parameters

query_string The SQL SELECT query to be executed.

Returns: Query results as rows, or error

Implements database::core::database_backend.

Definition at line 206 of file postgres_manager.cpp.

    {
        if (!initialized_) {
            return kcenon::common::error_info{-1, "Not initialized", "postgres_manager"};
        }
 
        core::database_result result;
 
#ifdef USE_POSTGRESQL
        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 {
                        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));
            }
            return result;
        } catch (const std::exception& e) {
            last_error_ = std::string("Select query error: ") + e.what();
            POSTGRES_LOG_ERROR("select_query", last_error_);
            return kcenon::common::error_info{-2, last_error_, "postgres_manager"};
        }
#elif defined(HAVE_LIBPQ)
        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{-2, last_error_, "postgres_manager"};
            }
 
            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_oid = PQftype(pg_result, col);
 
                        if (type_oid == 20 || type_oid == 21 || type_oid == 23) { // int8, int2, int4
                            db_row[column_name] = static_cast<int64_t>(std::stoll(value));
                        } else if (type_oid == 700 || type_oid == 701) { // float4, float8
                            db_row[column_name] = std::stod(value);
                        } else if (type_oid == 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);
            return result;
        } catch (const std::exception& e) {
            last_error_ = std::string("Select query error: ") + e.what();
            POSTGRES_LOG_ERROR("select_query", last_error_);
            return kcenon::common::error_info{-2, last_error_, "postgres_manager"};
        }
#else
        POSTGRES_LOG_WARNING("PostgreSQL support not compiled. Mock select: " + query_string.substr(0, 20) + "...");
        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);
        }
        return result;
#endif
    }

References connection_, initialized_, last_error_, POSTGRES_LOG_ERROR, POSTGRES_LOG_WARNING, and type().

Here is the call graph for this function:

◆ shutdown()

kcenon::common::VoidResult database::postgres_manager::shutdown ( )

overridevirtual

Shutdown the database backend gracefully.

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

Implements database::core::database_backend.

Definition at line 118 of file postgres_manager.cpp.

    {
        if (!initialized_) {
            return kcenon::common::ok();
        }
 
        if (in_transaction_) {
            rollback_transaction();
        }
 
#ifdef USE_POSTGRESQL
        try {
            delete static_cast<pqxx::connection*>(connection_);
            connection_ = nullptr;
            initialized_ = false;
            return kcenon::common::ok();
        } catch (const std::exception& e) {
            last_error_ = std::string("Disconnect error: ") + e.what();
            POSTGRES_LOG_ERROR("shutdown", last_error_);
        }
#elif defined(HAVE_LIBPQ)
        try {
            PQfinish(static_cast<PGconn*>(connection_));
            connection_ = nullptr;
            initialized_ = false;
            return kcenon::common::ok();
        } catch (const std::exception& e) {
            last_error_ = std::string("Disconnect error: ") + e.what();
            POSTGRES_LOG_ERROR("shutdown", last_error_);
        }
#else
        connection_ = nullptr;
        initialized_ = false;
        POSTGRES_LOG_WARNING("PostgreSQL support not compiled. Mock disconnect.");
        return kcenon::common::ok();
#endif
        return kcenon::common::error_info{-3, last_error_, "postgres_manager"};
    }

References connection_, in_transaction_, initialized_, last_error_, POSTGRES_LOG_ERROR, POSTGRES_LOG_WARNING, and rollback_transaction().

Referenced by ~postgres_manager().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ type()

database_types database::postgres_manager::type ( ) const

overridevirtual

Returns the specific type of the database.

Returns: An enum value of type database_types indicating that this is a PostgreSQL database.

Implements database::core::database_backend.

Definition at line 49 of file postgres_manager.cpp.

    {
        return database_types::postgres;
    }

References database::postgres.

Referenced by select_query().

Here is the caller graph for this function:

Member Data Documentation

◆ connection_

void* database::postgres_manager::connection_

private

Pointer to the underlying PostgreSQL connection object.

Definition at line 122 of file postgres_manager.h.

Referenced by connection_info(), execute_modification_query(), execute_query(), initialize(), select_query(), and shutdown().

◆ connection_string_

std::string database::postgres_manager::connection_string_

private

Connection string for connection_info.

Definition at line 126 of file postgres_manager.h.

Referenced by initialize().

◆ in_transaction_

bool database::postgres_manager::in_transaction_

private

Whether a transaction is active.

Definition at line 124 of file postgres_manager.h.

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

◆ initialized_

bool database::postgres_manager::initialized_

private

Whether the backend is initialized.

Definition at line 123 of file postgres_manager.h.

Referenced by begin_transaction(), commit_transaction(), connection_info(), execute_modification_query(), execute_query(), initialize(), is_initialized(), rollback_transaction(), select_query(), and shutdown().

◆ last_error_

std::string database::postgres_manager::last_error_

private

Last error message.

Definition at line 125 of file postgres_manager.h.

Referenced by execute_modification_query(), execute_query(), initialize(), last_error(), select_query(), and shutdown().

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

database/postgres_manager.h
database/postgres_manager.cpp

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ postgres_manager()

◆ ~postgres_manager()

Member Function Documentation

◆ begin_transaction()

◆ commit_transaction()

◆ connection_info()

◆ execute_modification_query()

◆ execute_query()

◆ in_transaction()

◆ initialize()

◆ is_initialized()

◆ last_error()

◆ rollback_transaction()

◆ select_query()

◆ shutdown()

◆ type()

Member Data Documentation

◆ connection_

◆ connection_string_

◆ in_transaction_

◆ initialized_

◆ last_error_