Redis implementation of database_backend interface. More...

#include <redis_backend.h>

Inheritance diagram for database::backends::redis_backend:

Collaboration diagram for database::backends::redis_backend:

Public Member Functions
	redis_backend ()
	Default constructor.

	~redis_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< redis_backend, database_types::redis >
	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< redis_backend, database_types::redis >
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
bool	parse_redis_query (const std::string &query_string, std::string &key, std::string &value) const
	Parse Redis query string format.

Private Attributes
void *	context_ {nullptr}
	Redis context (redisContext*)

std::string	host_
	Redis host.

int	port_ {6379}
	Redis port.

std::atomic< bool >	in_transaction_ {false}
	Transaction state (MULTI/EXEC)

std::string	last_error_
	Last error message.

core::connection_config	connection_config_
	Cached connection config.

std::mutex	redis_mutex_
	Mutex for thread safety.

Friends
class	core::backend_base< redis_backend, database_types::redis >

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

Detailed Description

Redis implementation of database_backend interface.

This class implements the database_backend interface for Redis via backend_base CRTP template, using hiredis.

Design Pattern: Strategy pattern with CRTP

Extends backend_base for common lifecycle management
Uses hiredis for Redis 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("redis");
 
core::connection_config config;
config.host = "localhost";
config.port = 6379;
 
if (auto result = backend->initialize(config); !result) {
    // Handle error
}
 
backend->execute_query("SET key value");
auto rows = backend->select_query("key");

Definition at line 69 of file redis_backend.h.

Constructor & Destructor Documentation

◆ redis_backend()

database::backends::redis_backend::redis_backend ( )

Default constructor.

Definition at line 29 of file redis_backend.cpp.

    : context_(nullptr), host_("localhost"), port_(6379)
{
}

◆ ~redis_backend()

database::backends::redis_backend::~redis_backend ( )

overridedefault

Destructor - ensures proper cleanup.

Member Function Documentation

◆ backend_name()

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

inlinestaticconstexpr

Backend name for error messages.

Definition at line 76 of file redis_backend.h.

76{ return "redis_backend"; }

Referenced by TEST_F().

Here is the caller graph for this function:

◆ begin_transaction()

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

overridevirtual

Begin a transaction.

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

Implements database::core::database_backend.

Definition at line 305 of file redis_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_,
            "redis_backend"
        };
    }
 
    if (in_transaction_) {
        last_error_ = "Transaction already active";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::invalid_state),
            last_error_,
            "redis_backend"
        };
    }
 
    // Redis uses MULTI to begin a transaction
    auto result = execute_query("MULTI");
    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< redis_backend, database_types::redis >::is_initialized(), and last_error_.

Here is the call graph for this function:

◆ commit_transaction()

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

overridevirtual

Commit the current transaction.

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

Implements database::core::database_backend.

Definition at line 336 of file redis_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_,
            "redis_backend"
        };
    }
 
    if (!in_transaction_) {
        last_error_ = "No active transaction";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::invalid_state),
            last_error_,
            "redis_backend"
        };
    }
 
    // Redis uses EXEC to commit a transaction
    auto result = execute_query("EXEC");
    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< redis_backend, database_types::redis >::is_initialized(), and last_error_.

Here is the call graph for this function:

◆ connection_info()

std::map< std::string, std::string > database::backends::redis_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 405 of file redis_backend.cpp.

{
    std::map<std::string, std::string> info;
    info["backend"] = "redis";
    info["host"] = host_;
    info["port"] = std::to_string(port_);
    info["initialized"] = initialized_ ? "true" : "false";
    info["in_transaction"] = in_transaction_ ? "true" : "false";
    return info;
}

References host_, in_transaction_, database::core::backend_base< redis_backend, database_types::redis >::initialized_, and port_.

◆ do_initialize()

kcenon::common::VoidResult database::backends::redis_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 34 of file redis_backend.cpp.

{
    connection_config_ = config;
    host_ = config.host.empty() ? "localhost" : config.host;
    port_ = config.port > 0 ? config.port : 6379;
 
#ifdef USE_REDIS
    std::lock_guard<std::mutex> lock(redis_mutex_);
    try {
        // Create Redis connection
        redisContext* ctx = redisConnect(host_.c_str(), port_);
        if (ctx == nullptr || ctx->err) {
            if (ctx) {
                last_error_ = std::string("Connection error: ") + ctx->errstr;
                logger_.error("do_initialize", last_error_);
                redisFree(ctx);
            } else {
                last_error_ = "Connection allocation error";
                logger_.error("do_initialize", last_error_);
            }
            return kcenon::common::error_info{
                static_cast<int>(database::error_code::connection_failed),
                last_error_,
                "redis_backend"
            };
        }
 
        context_ = ctx;
 
        // Authenticate if password provided
        if (!config.password.empty()) {
            redisReply* reply = static_cast<redisReply*>(
                redisCommand(ctx, "AUTH %s", config.password.c_str()));
            if (reply == nullptr || reply->type == REDIS_REPLY_ERROR) {
                last_error_ = "Authentication failed";
                logger_.error("do_initialize", last_error_);
                if (reply) freeReplyObject(reply);
                redisFree(ctx);
                context_ = nullptr;
                return kcenon::common::error_info{
                    static_cast<int>(database::error_code::connection_failed),
                    last_error_,
                    "redis_backend"
                };
            }
            freeReplyObject(reply);
        }
 
        // Test connection with PING
        redisReply* ping_reply = static_cast<redisReply*>(redisCommand(ctx, "PING"));
        if (ping_reply == nullptr || ping_reply->type == REDIS_REPLY_ERROR) {
            last_error_ = "PING failed";
            logger_.error("do_initialize", last_error_);
            if (ping_reply) freeReplyObject(ping_reply);
            redisFree(ctx);
            context_ = nullptr;
            return kcenon::common::error_info{
                static_cast<int>(database::error_code::connection_failed),
                last_error_,
                "redis_backend"
            };
        }
        freeReplyObject(ping_reply);
 
        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("Redis support not compiled. Mock mode enabled.");
    // Mock mode for testing without Redis
    last_error_.clear();
    return kcenon::common::ok();
#endif
 
    if (last_error_.empty()) {
        last_error_ = "Failed to connect to Redis server";
    }
    return kcenon::common::error_info{
        static_cast<int>(database::error_code::connection_failed),
        last_error_,
        "redis_backend"
    };
}

References connection_config_, database::connection_failed, context_, database::core::connection_config::host, host_, last_error_, database::core::connection_config::password, database::core::connection_config::port, port_, and redis_mutex_.

◆ do_shutdown()

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

protected

Database-specific shutdown logic.

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

Definition at line 121 of file redis_backend.cpp.

{
    // Discard any active transaction before disconnecting
    if (in_transaction_) {
        rollback_transaction();
    }
 
#ifdef USE_REDIS
    std::lock_guard<std::mutex> lock(redis_mutex_);
    if (context_) {
        redisFree(static_cast<redisContext*>(context_));
        context_ = nullptr;
    }
#endif
 
    last_error_.clear();
    return kcenon::common::ok();
}

References context_, in_transaction_, last_error_, redis_mutex_, and rollback_transaction().

Here is the call graph for this function:

◆ execute_query()

kcenon::common::VoidResult database::backends::redis_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 231 of file redis_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_,
            "redis_backend"
        };
    }
 
#ifdef USE_REDIS
    if (!context_) {
        last_error_ = "No active Redis connection";
        logger_.error("execute_query", last_error_);
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::connection_failed),
            last_error_,
            "redis_backend"
        };
    }
 
    std::lock_guard<std::mutex> lock(redis_mutex_);
    try {
        redisContext* ctx = static_cast<redisContext*>(context_);
        redisReply* reply = static_cast<redisReply*>(
            redisCommand(ctx, "%s", query_string.c_str()));
 
        if (reply == nullptr) {
            last_error_ = std::string("Command failed: ") + ctx->errstr;
            logger_.error("execute_query", last_error_);
            return kcenon::common::error_info{
                static_cast<int>(database::error_code::query_failed),
                last_error_,
                "redis_backend"
            };
        }
 
        bool success = true;
        if (reply->type == REDIS_REPLY_ERROR) {
            last_error_ = std::string("Execute error: ") + reply->str;
            logger_.error("execute_query", last_error_);
            success = false;
        }
 
        freeReplyObject(reply);
 
        if (!success) {
            return kcenon::common::error_info{
                static_cast<int>(database::error_code::query_failed),
                last_error_,
                "redis_backend"
            };
        }
 
        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_,
            "redis_backend"
        };
    }
#else
    // Mock execution
    logger_.info("Redis support not compiled. Mock execute: " + query_string);
    last_error_.clear();
    return kcenon::common::ok();
#endif
}

References database::connection_failed, context_, database::invalid_state, database::core::backend_base< redis_backend, database_types::redis >::is_initialized(), last_error_, database::query_failed, redis_mutex_, 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::redis_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 395 of file redis_backend.cpp.

{
    return in_transaction_;
}

References in_transaction_.

◆ last_error()

std::string database::backends::redis_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 400 of file redis_backend.cpp.

{
    return last_error_;
}

References last_error_.

◆ parse_redis_query()

bool database::backends::redis_backend::parse_redis_query	(	const std::string &	query_string,
		std::string &	key,
		std::string &	value ) const

private

Parse Redis query string format.

Parameters

query_string	Query string in format "key:value"
key	Output key
value	Output value

Returns: true if parsing succeeded

Definition at line 140 of file redis_backend.cpp.

{
    // Parse format: "key:value"
    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) key = parts[0];
    if (parts.size() >= 2) value = parts[1];
 
    return !key.empty();
}

◆ rollback_transaction()

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

overridevirtual

Rollback the current transaction.

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

Implements database::core::database_backend.

Definition at line 367 of file redis_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_,
            "redis_backend"
        };
    }
 
    if (!in_transaction_) {
        // Not an error - already discarded or never started
        return kcenon::common::ok();
    }
 
    // Redis uses DISCARD to rollback a transaction
    auto result = execute_query("DISCARD");
    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< redis_backend, database_types::redis >::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::redis_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 159 of file redis_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_,
            "redis_backend"
        };
    }
 
    core::database_result result;
 
#ifdef USE_REDIS
    if (!context_) {
        last_error_ = "No active connection";
        return kcenon::common::error_info{
            static_cast<int>(database::error_code::connection_failed),
            last_error_,
            "redis_backend"
        };
    }
    std::lock_guard<std::mutex> lock(redis_mutex_);
    try {
        // For select, query_string is the key
        std::string key = query_string;
 
        redisContext* ctx = static_cast<redisContext*>(context_);
        redisReply* reply = static_cast<redisReply*>(
            redisCommand(ctx, "GET %s", key.c_str()));
 
        if (reply != nullptr && reply->type != REDIS_REPLY_ERROR &&
            reply->type != REDIS_REPLY_NIL) {
            core::database_row row;
            row["key"] = key;
 
            if (reply->type == REDIS_REPLY_STRING) {
                row["value"] = std::string(reply->str, reply->len);
            } else if (reply->type == REDIS_REPLY_INTEGER) {
                row["value"] = static_cast<int64_t>(reply->integer);
            } else {
                row["value"] = std::string("");
            }
 
            result.push_back(std::move(row));
        }
 
        if (reply) freeReplyObject(reply);
    } 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_,
            "redis_backend"
        };
    }
#else
    logger_.warning("Redis support not compiled. Select query: " + query_string.substr(0, 20) + "...");
    // Return mock data for testing
    if (!query_string.empty()) {
        core::database_row mock_row;
        mock_row["key"] = query_string;
        mock_row["value"] = std::string("redis_mock_value");
        result.push_back(mock_row);
    }
#endif
 
    last_error_.clear();
    return result;
}

References database::connection_failed, context_, database::invalid_state, database::core::backend_base< redis_backend, database_types::redis >::is_initialized(), last_error_, database::query_failed, and redis_mutex_.

Here is the call graph for this function:

Friends And Related Symbol Documentation

◆ core::backend_base< redis_backend, database_types::redis >

friend class core::backend_base< redis_backend, database_types::redis >

friend

Definition at line 104 of file redis_backend.h.

Member Data Documentation

◆ connection_config_

core::connection_config database::backends::redis_backend::connection_config_

private

Cached connection config.

Definition at line 139 of file redis_backend.h.

Referenced by do_initialize().

◆ context_

void* database::backends::redis_backend::context_ {nullptr}

private

Redis context (redisContext*)

Definition at line 134 of file redis_backend.h.

134{nullptr};

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

◆ host_

std::string database::backends::redis_backend::host_

private

Redis host.

Definition at line 135 of file redis_backend.h.

Referenced by connection_info(), and do_initialize().

◆ in_transaction_

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

private

Transaction state (MULTI/EXEC)

Definition at line 137 of file redis_backend.h.

137{false};

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

◆ last_error_

std::string database::backends::redis_backend::last_error_

mutableprivate

Last error message.

Definition at line 138 of file redis_backend.h.

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

◆ port_

int database::backends::redis_backend::port_ {6379}

private

Redis port.

Definition at line 136 of file redis_backend.h.

136{6379};

Referenced by connection_info(), and do_initialize().

◆ redis_mutex_

std::mutex database::backends::redis_backend::redis_mutex_

mutableprivate

Mutex for thread safety.

Definition at line 140 of file redis_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/redis_backend.h
database/backends/redis_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

◆ redis_backend()

◆ ~redis_backend()

Member Function Documentation

◆ backend_name()

◆ begin_transaction()

◆ commit_transaction()

◆ connection_info()

◆ do_initialize()

◆ do_shutdown()

◆ execute_query()

◆ in_transaction()

◆ last_error()

◆ parse_redis_query()

◆ rollback_transaction()

◆ select_query()

Friends And Related Symbol Documentation

◆ core::backend_base< redis_backend, database_types::redis >

Member Data Documentation

◆ connection_config_

◆ context_

◆ host_

◆ in_transaction_

◆ last_error_

◆ port_

◆ redis_mutex_