database_backend.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include "../database_types.h"
 
#include <kcenon/common/patterns/result.h>
 
#include <memory>
#include <string>
#include <vector>
#include <map>
#include <variant>
 
namespace database
{
namespace core
{
 
// Forward declarations for type aliases
using database_value = std::variant<std::string, int64_t, double, bool, std::nullptr_t>;
using database_row = std::map<std::string, database_value>;
using database_result = std::vector<database_row>;
 
struct connection_config
{
    std::string host;
    uint16_t port = 0;
    std::string database;
    std::string username;
    std::string password;
    std::map<std::string, std::string> options; // Additional driver-specific options
 
    static connection_config from_string(const std::string& connect_string);
};
 
class database_backend
{
public:
    virtual ~database_backend() = default;
 
    virtual database_types type() const = 0;
 
    virtual kcenon::common::VoidResult initialize(const connection_config& config) = 0;
 
    virtual kcenon::common::VoidResult shutdown() = 0;
 
    virtual bool is_initialized() const = 0;
 
    virtual kcenon::common::Result<database_result> select_query(const std::string& query_string) = 0;
 
    virtual kcenon::common::VoidResult execute_query(const std::string& query_string) = 0;
 
    [[nodiscard]] virtual kcenon::common::Result<database_result> select_prepared(
        const std::string& query,
        const std::vector<database_value>& params)
    {
        // Default fallback: substitute params inline (less secure, but functional)
        auto expanded = expand_params(query, params);
        return select_query(expanded);
    }
 
    [[nodiscard]] virtual kcenon::common::VoidResult execute_prepared(
        const std::string& query,
        const std::vector<database_value>& params)
    {
        auto expanded = expand_params(query, params);
        return execute_query(expanded);
    }
 
    virtual kcenon::common::VoidResult begin_transaction() = 0;
 
    virtual kcenon::common::VoidResult commit_transaction() = 0;
 
    virtual kcenon::common::VoidResult rollback_transaction() = 0;
 
    virtual bool in_transaction() const = 0;
 
    virtual std::string last_error() const = 0;
 
    virtual std::map<std::string, std::string> connection_info() const = 0;
 
protected:
    static std::string expand_params(
        const std::string& query,
        const std::vector<database_value>& params)
    {
        std::string result = query;
 
        // Replace $N placeholders (PostgreSQL-style, 1-indexed)
        for (size_t i = params.size(); i > 0; --i) {
            auto placeholder = "$" + std::to_string(i);
            auto pos = result.find(placeholder);
            if (pos != std::string::npos) {
                result.replace(pos, placeholder.size(), value_to_sql(params[i - 1]));
            }
        }
 
        // Replace ? placeholders (SQLite-style, left-to-right)
        size_t param_idx = 0;
        auto pos = result.find('?');
        while (pos != std::string::npos && param_idx < params.size()) {
            auto val = value_to_sql(params[param_idx++]);
            result.replace(pos, 1, val);
            pos = result.find('?', pos + val.size());
        }
 
        return result;
    }
 
private:
    static std::string value_to_sql(const database_value& val)
    {
        return std::visit([](const auto& v) -> std::string {
            using T = std::decay_t<decltype(v)>;
            if constexpr (std::is_same_v<T, std::nullptr_t>) {
                return "NULL";
            } else if constexpr (std::is_same_v<T, bool>) {
                return v ? "TRUE" : "FALSE";
            } else if constexpr (std::is_same_v<T, std::string>) {
                // Basic escaping — backends should override for proper security
                std::string escaped;
                escaped.reserve(v.size() + 2);
                escaped += '\'';
                for (char c : v) {
                    if (c == '\'') escaped += "''";
                    else escaped += c;
                }
                escaped += '\'';
                return escaped;
            } else {
                return std::to_string(v);
            }
        }, val);
    }
};
 
using backend_factory_fn = std::unique_ptr<database_backend> (*)();
 
} // namespace core
} // namespace database