MongoDB implementation of database_backend interface. More...

#include <mongodb_backend.h>

Inheritance diagram for database::backends::mongodb_backend:

Collaboration diagram for database::backends::mongodb_backend:

Public Member Functions
	mongodb_backend ()
	Default constructor.

	~mongodb_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::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< mongodb_backend, database_types::mongodb >
	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

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)

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< mongodb_backend, database_types::mongodb >
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_uri (const core::connection_config &config) const
	Convert connection_config to MongoDB connection URI.

bool	parse_query_string (const std::string &query_string, std::string &collection, std::string &filter, std::string &update) const
	Parse query string format.

Private Attributes
void *	client_ {nullptr}
	MongoDB client (mongocxx::client*)

void *	database_ {nullptr}
	MongoDB database (mongocxx::database*)

std::string	db_name_
	Database name.

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

std::string	last_error_
	Last error message.

core::connection_config	connection_config_
	Cached connection config.

std::mutex	mongo_mutex_
	Mutex for thread safety.

Friends
class	core::backend_base< mongodb_backend, database_types::mongodb >

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

Detailed Description

MongoDB implementation of database_backend interface.

This class implements the database_backend interface for MongoDB via backend_base CRTP template, using the MongoDB C++ driver.

Design Pattern: Strategy pattern with CRTP

Extends backend_base for common lifecycle management
Uses mongocxx driver for database access
Provides Result-based error handling
Thread-safe with internal mutex

Thread Safety:

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

Usage:

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

Definition at line 71 of file mongodb_backend.h.

Constructor & Destructor Documentation

◆ mongodb_backend()

database::backends::mongodb_backend::mongodb_backend ( )

Default constructor.

Definition at line 36 of file mongodb_backend.cpp.

    : client_(nullptr), database_(nullptr)
{
}

◆ ~mongodb_backend()

database::backends::mongodb_backend::~mongodb_backend ( )

overridedefault

Destructor - ensures proper cleanup.

Member Function Documentation

◆ backend_name()

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

inlinestaticconstexpr

Backend name for error messages.

Definition at line 78 of file mongodb_backend.h.

78{ return "mongodb_backend"; }

Referenced by TEST_F().

Here is the caller graph for this function:

◆ begin_transaction()

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

overridevirtual

Begin a transaction.

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

Implements database::core::database_backend.

Definition at line 285 of file mongodb_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_,
            "mongodb_backend"
        };
    }
 
    if (in_transaction_) {
        last_error_ = "Transaction already active";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::invalid_state),
            last_error_,
            "mongodb_backend"
        };
    }
 
    // MongoDB transactions require replica sets or sharded clusters
    // For simplicity, we'll mark the transaction state
    in_transaction_ = true;
    last_error_.clear();
    return kcenon::common::ok();
}

References in_transaction_, database::invalid_state, database::core::backend_base< mongodb_backend, database_types::mongodb >::is_initialized(), and last_error_.

Here is the call graph for this function:

◆ build_connection_uri()

std::string database::backends::mongodb_backend::build_connection_uri ( const core::connection_config & config ) const

private

Convert connection_config to MongoDB connection URI.

Parameters

config Structured connection configuration

Returns: Connection URI for MongoDB C++ driver

Format: "mongodb://username:password@host:port/database"

Definition at line 381 of file mongodb_backend.cpp.

{
    std::ostringstream oss;
 
    oss << "mongodb://";
 
    // Add credentials if provided
    if (!config.username.empty()) {
        oss << config.username;
        if (!config.password.empty()) {
            oss << ":" << config.password;
        }
        oss << "@";
    }
 
    // Add host (default to localhost if not specified)
    if (!config.host.empty()) {
        oss << config.host;
    } else {
        oss << "localhost";
    }
 
    // Add port (default to 27017 if not specified)
    if (config.port > 0) {
        oss << ":" << config.port;
    } else {
        oss << ":27017";
    }
 
    // Add database
    if (!config.database.empty()) {
        oss << "/" << config.database;
    }
 
    // Add additional options
    if (!config.options.empty()) {
        oss << "?";
        bool first = true;
        for (const auto& [key, value] : config.options) {
            if (!first) {
                oss << "&";
            }
            oss << key << "=" << value;
            first = false;
        }
    }
 
    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::mongodb_backend::commit_transaction ( )

overridevirtual

Commit the current transaction.

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

Implements database::core::database_backend.

Definition at line 312 of file mongodb_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_,
            "mongodb_backend"
        };
    }
 
    if (!in_transaction_) {
        last_error_ = "No active transaction";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::invalid_state),
            last_error_,
            "mongodb_backend"
        };
    }
 
    in_transaction_ = false;
    last_error_.clear();
    return kcenon::common::ok();
}

References in_transaction_, database::invalid_state, database::core::backend_base< mongodb_backend, database_types::mongodb >::is_initialized(), and last_error_.

Here is the call graph for this function:

◆ connection_info()

std::map< std::string, std::string > database::backends::mongodb_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 368 of file mongodb_backend.cpp.

{
    std::map<std::string, std::string> info;
    info["backend"] = "mongodb";
    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< mongodb_backend, database_types::mongodb >::initialized_, database::core::connection_config::port, and database::core::connection_config::username.

◆ do_initialize()

kcenon::common::VoidResult database::backends::mongodb_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 41 of file mongodb_backend.cpp.

{
    connection_config_ = config;
    std::string conn_uri = build_connection_uri(config);
    db_name_ = config.database;
 
#ifdef USE_MONGODB
    std::lock_guard<std::mutex> lock(mongo_mutex_);
    try {
        // Initialize MongoDB instance (should only be done once per application)
        static mongocxx::instance instance{};
 
        // Create MongoDB URI
        mongocxx::uri uri{conn_uri};
 
        // Create MongoDB client
        auto client = std::make_unique<mongocxx::client>(uri);
        client_ = client.release();
 
        // Get database reference
        auto* mongo_client = static_cast<mongocxx::client*>(client_);
        auto db = std::make_unique<mongocxx::database>((*mongo_client)[db_name_]);
        database_ = db.release();
 
        // Test connection by running a simple command
        auto* mongo_db = static_cast<mongocxx::database*>(database_);
        auto result = mongo_db->run_command(bsoncxx::builder::stream::document{} << "ping" << 1 << bsoncxx::builder::stream::finalize);
 
        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("MongoDB support not compiled. Mock mode enabled.");
    // Mock mode for testing without MongoDB
    last_error_.clear();
    return kcenon::common::ok();
#endif
 
    if (last_error_.empty()) {
        last_error_ = "Failed to connect to MongoDB server";
    }
    return kcenon::common::error_info{
        static_cast<int>(database::error_code::connection_failed),
        last_error_,
        "mongodb_backend"
    };
}

References build_connection_uri(), client_, connection_config_, database::connection_failed, database::core::connection_config::database, database_, db_name_, last_error_, and mongo_mutex_.

Here is the call graph for this function:

◆ do_shutdown()

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

protected

Database-specific shutdown logic.

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

Definition at line 92 of file mongodb_backend.cpp.

{
    // Rollback any active transaction before disconnecting
    if (in_transaction_) {
        rollback_transaction();
    }
 
#ifdef USE_MONGODB
    std::lock_guard<std::mutex> lock(mongo_mutex_);
    if (database_) {
        delete static_cast<mongocxx::database*>(database_);
        database_ = nullptr;
    }
    if (client_) {
        delete static_cast<mongocxx::client*>(client_);
        client_ = nullptr;
    }
#endif
 
    last_error_.clear();
    return kcenon::common::ok();
}

References client_, database_, in_transaction_, last_error_, mongo_mutex_, and rollback_transaction().

Here is the call graph for this function:

◆ execute_query()

kcenon::common::VoidResult database::backends::mongodb_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 226 of file mongodb_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_,
            "mongodb_backend"
        };
    }
 
#ifdef USE_MONGODB
    if (!database_) {
        last_error_ = "No active MongoDB connection";
        logger_.error("execute_query", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::connection_failed),
            last_error_,
            "mongodb_backend"
        };
    }
 
    std::lock_guard<std::mutex> lock(mongo_mutex_);
    try {
        auto* mongo_db = static_cast<mongocxx::database*>(database_);
 
        // Try to parse as MongoDB command (JSON format)
        try {
            auto command_doc = bsoncxx::from_json(query_string);
            auto result = mongo_db->run_command(command_doc.view());
            last_error_.clear();
            return kcenon::common::ok();
        } catch (const std::exception&) {
            // If JSON parsing fails, treat as collection creation
            std::string collection_name = query_string;
            auto collection = (*mongo_db)[collection_name];
            auto doc = bsoncxx::builder::stream::document{} << "test" << "creation" << bsoncxx::builder::stream::finalize;
            collection.insert_one(doc.view());
            collection.delete_one(doc.view());
            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_,
            "mongodb_backend"
        };
    }
#else
    // Mock execution
    logger_.info("MongoDB support not compiled. Mock execute: " + query_string);
    last_error_.clear();
    return kcenon::common::ok();
#endif
}

References database::connection_failed, database_, database::invalid_state, database::core::backend_base< mongodb_backend, database_types::mongodb >::is_initialized(), last_error_, mongo_mutex_, and database::query_failed.

Here is the call graph for this function:

◆ in_transaction()

bool database::backends::mongodb_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 358 of file mongodb_backend.cpp.

{
    return in_transaction_;
}

References in_transaction_.

◆ last_error()

std::string database::backends::mongodb_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 363 of file mongodb_backend.cpp.

{
    return last_error_;
}

References last_error_.

◆ parse_query_string()

bool database::backends::mongodb_backend::parse_query_string	(	const std::string &	query_string,
		std::string &	collection,
		std::string &	filter,
		std::string &	update ) const

private

Parse query string format.

Parameters

query_string	Query string in format "collection:filter:update"
collection	Output collection name
filter	Output filter JSON
update	Output update JSON (optional)

Returns: true if parsing succeeded

Definition at line 115 of file mongodb_backend.cpp.

{
    // Parse format: "collection_name:filter_json" or "collection_name:filter_json:update_json"
    std::istringstream ss(query_string);
    std::string part;
    std::vector<std::string> parts;
 
    while (std::getline(ss, part, ':')) {
        parts.push_back(part);
    }
 
    if (parts.size() >= 1) collection = parts[0];
    if (parts.size() >= 2) filter = parts[1];
    if (parts.size() >= 3) update = parts[2];
 
    return !collection.empty();
}

Referenced by select_query().

Here is the caller graph for this function:

◆ rollback_transaction()

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

overridevirtual

Rollback the current transaction.

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

Implements database::core::database_backend.

Definition at line 337 of file mongodb_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_,
            "mongodb_backend"
        };
    }
 
    if (!in_transaction_) {
        // Not an error - already rolled back or never started
        return kcenon::common::ok();
    }
 
    in_transaction_ = false;
    last_error_.clear();
    return kcenon::common::ok();
}

References in_transaction_, database::invalid_state, database::core::backend_base< mongodb_backend, database_types::mongodb >::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_query()

kcenon::common::Result< core::database_result > database::backends::mongodb_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 136 of file mongodb_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_,
            "mongodb_backend"
        };
    }
 
    core::database_result result;
 
#ifdef USE_MONGODB
    if (!database_) {
        last_error_ = "No active connection";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::connection_failed),
            last_error_,
            "mongodb_backend"
        };
    }
    std::lock_guard<std::mutex> lock(mongo_mutex_);
    try {
        std::string collection_name, filter_json, unused;
        if (!parse_query_string(query_string, collection_name, filter_json, unused)) {
            last_error_ = "Invalid query format";
            return kcenon::common::error_info{
                static_cast<int>(database::error_code::query_failed),
                last_error_,
                "mongodb_backend"
            };
        }
 
        auto* mongo_db = static_cast<mongocxx::database*>(database_);
        auto collection = (*mongo_db)[collection_name];
 
        // Parse JSON to BSON for filter
        bsoncxx::document::value filter_doc = filter_json.empty() ?
            bsoncxx::builder::stream::document{} << bsoncxx::builder::stream::finalize :
            bsoncxx::from_json(filter_json);
 
        auto cursor = collection.find(filter_doc.view());
 
        for (auto&& doc : cursor) {
            core::database_row row;
 
            // Convert BSON document to core::database_row
            auto json_string = bsoncxx::to_json(doc);
            row["_document"] = json_string;  // Store full document as JSON string
 
            // Also extract common fields
            auto view = doc.view();
            if (view["_id"]) {
                row["_id"] = bsoncxx::to_json(view["_id"].get_value());
            }
 
            // Extract other fields as strings for compatibility
            for (auto&& element : view) {
                std::string key = element.key().to_string();
                if (key != "_id") {  // _id already processed
                    row[key] = bsoncxx::to_json(element.get_value());
                }
            }
 
            result.push_back(std::move(row));
        }
    } catch (const std::exception& e) {
        last_error_ = std::string("Select error: ") + e.what();
        logger_.error("select_query", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::query_failed),
            last_error_,
            "mongodb_backend"
        };
    }
#else
    logger_.warning("MongoDB support not compiled. Select query: " + query_string.substr(0, 20) + "...");
    // Return mock data for testing
    core::database_row mock_row;
    mock_row["_id"] = std::string("mock_object_id");
    mock_row["name"] = std::string("mongodb_mock_data");
    mock_row["_document"] = std::string("{\"_id\":\"mock_object_id\",\"name\":\"mongodb_mock_data\"}");
    result.push_back(mock_row);
#endif
 
    last_error_.clear();
    return result;
}

References database::connection_failed, database_, database::invalid_state, database::core::backend_base< mongodb_backend, database_types::mongodb >::is_initialized(), last_error_, mongo_mutex_, parse_query_string(), and database::query_failed.

Here is the call graph for this function:

Friends And Related Symbol Documentation

◆ core::backend_base< mongodb_backend, database_types::mongodb >

friend class core::backend_base< mongodb_backend, database_types::mongodb >

friend

Definition at line 106 of file mongodb_backend.h.

Member Data Documentation

◆ client_

void* database::backends::mongodb_backend::client_ {nullptr}

private

MongoDB client (mongocxx::client*)

Definition at line 147 of file mongodb_backend.h.

147{nullptr};

Referenced by do_initialize(), and do_shutdown().

◆ connection_config_

core::connection_config database::backends::mongodb_backend::connection_config_

private

Cached connection config.

Definition at line 152 of file mongodb_backend.h.

Referenced by connection_info(), and do_initialize().

◆ database_

void* database::backends::mongodb_backend::database_ {nullptr}

private

MongoDB database (mongocxx::database*)

Definition at line 148 of file mongodb_backend.h.

148{nullptr};

Referenced by do_initialize(), do_shutdown(), execute_query(), and select_query().

◆ db_name_

std::string database::backends::mongodb_backend::db_name_

private

Database name.

Definition at line 149 of file mongodb_backend.h.

Referenced by do_initialize().

◆ in_transaction_

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

private

Transaction state.

Definition at line 150 of file mongodb_backend.h.

150{false};

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

◆ last_error_

std::string database::backends::mongodb_backend::last_error_

mutableprivate

Last error message.

Definition at line 151 of file mongodb_backend.h.

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

◆ mongo_mutex_

std::mutex database::backends::mongodb_backend::mongo_mutex_

mutableprivate

Mutex for thread safety.

Definition at line 153 of file mongodb_backend.h.

Referenced by do_initialize(), do_shutdown(), execute_query(), and select_query().

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

database/backends/mongodb_backend.h
database/backends/mongodb_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

◆ mongodb_backend()

◆ ~mongodb_backend()

Member Function Documentation

◆ backend_name()

◆ begin_transaction()

◆ build_connection_uri()

◆ commit_transaction()

◆ connection_info()

◆ do_initialize()

◆ do_shutdown()

◆ execute_query()

◆ in_transaction()

◆ last_error()

◆ parse_query_string()

◆ rollback_transaction()

◆ select_query()

Friends And Related Symbol Documentation

◆ core::backend_base< mongodb_backend, database_types::mongodb >

Member Data Documentation

◆ client_

◆ connection_config_

◆ database_

◆ db_name_

◆ in_transaction_

◆ last_error_

◆ mongo_mutex_