KeyValueDB.hpp

Go to the documentation of this file.

#pragma once
 
 
#include "parts/BaseDB.hpp"
 
namespace sqlite_containers {
 
    template<class KeyT, class ValueT>
    class KeyValueDB final : public BaseDB {
    public:
 
        KeyValueDB() : BaseDB() {}
 
        explicit KeyValueDB(const Config& config) : BaseDB() {
            set_config(config);
        }
 
        ~KeyValueDB() override final = default;
 
        // --- Operators ---
 
        template<template <class...> class ContainerT>
        KeyValueDB& operator=(const ContainerT<KeyT, ValueT>& container) {
            // Get the default transaction mode from the configuration
            auto txn_mode = get_config().default_txn_mode;
 
            execute_in_transaction([this, &container]() {
                db_reconcile(container);
            }, txn_mode);  // Use transaction mode from the configuration
            return *this;
        }
 
        template<template <class...> class ContainerT = std::map>
        ContainerT<KeyT, ValueT> operator()() {
            ContainerT<KeyT, ValueT> container;
            // Get the default transaction mode from the configuration
            auto txn_mode = get_config().default_txn_mode;
 
            execute_in_transaction([this, &container]() {
                db_load(container);
            }, txn_mode);  // Use transaction mode from the configuration
            return container;
        }
 
        // --- Existing methods ---
 
        template<template <class...> class ContainerT>
        void load(ContainerT<KeyT, ValueT>& container) {
            std::lock_guard<std::mutex> locker(m_sqlite_mutex);
            db_load(container);
        }
 
        template<template <class...> class ContainerT>
        void load(
                ContainerT<KeyT, ValueT>& container,
                const TransactionMode& mode) {
            execute_in_transaction([this, &container]() {
                db_load(container);
            }, mode);
        }
 
        template<template <class...> class ContainerT>
        ContainerT<KeyT, ValueT> retrieve_all() {
            ContainerT<KeyT, ValueT> container;
            std::lock_guard<std::mutex> locker(m_sqlite_mutex);
            db_load(container);
            return container;
        }
 
        template<template <class...> class ContainerT>
        ContainerT<KeyT, ValueT> retrieve_all(const TransactionMode& mode) {
            ContainerT<KeyT, ValueT> container;
            execute_in_transaction([this, &container]() {
                db_load(container);
            }, mode);
            return container;
        }
 
        template<template <class...> class ContainerT>
        void append(const ContainerT<KeyT, ValueT>& container) {
            std::lock_guard<std::mutex> locker(m_sqlite_mutex);
            db_append(container);
        }
 
        template<template <class...> class ContainerT>
        void append(
                const ContainerT<KeyT, ValueT>& container,
                const TransactionMode& mode) {
            execute_in_transaction([this, &container]() {
                db_append(container);
            }, mode);
        }
 
        template<template <class...> class ContainerT>
        void reconcile(const ContainerT<KeyT, ValueT>& container) {
            std::lock_guard<std::mutex> locker(m_sqlite_mutex);
            db_reconcile(container);
        }
 
        template<template <class...> class ContainerT>
        void reconcile(
                const ContainerT<KeyT, ValueT>& container,
                const TransactionMode& mode) {
            execute_in_transaction([this, &container]() {
                db_reconcile(container);
            }, mode);
        }
 
        void insert(const KeyT &key, const ValueT &value) {
            std::lock_guard<std::mutex> locker(m_sqlite_mutex);
            db_insert(key, value);
        }
 
        void insert(const std::pair<KeyT, ValueT> &pair) {
            std::lock_guard<std::mutex> locker(m_sqlite_mutex);
            db_insert(pair.first, pair.second);
        }
 
        bool find(const KeyT &key, ValueT &value) {
            std::lock_guard<std::mutex> locker(m_sqlite_mutex);
            return db_find(key, value);
        }
 
        std::size_t count() const {
            std::lock_guard<std::mutex> locker(m_sqlite_mutex);
            return db_count();
        }
 
        bool empty() const {
            return (db_count() == 0);
        }
 
        void remove(const KeyT &key) {
            std::lock_guard<std::mutex> locker(m_sqlite_mutex);
            db_remove(key);
        }
 
        void clear() {
            std::lock_guard<std::mutex> locker(m_sqlite_mutex);
            db_clear();
        }
 
    private:
        SqliteStmt m_stmt_load;         
        SqliteStmt m_stmt_replace;      
        SqliteStmt m_stmt_get_value;    
        mutable SqliteStmt m_stmt_count;
        SqliteStmt m_stmt_remove;       
        SqliteStmt m_stmt_clear_main;   
 
        SqliteStmt m_stmt_insert_temp;  
        SqliteStmt m_stmt_purge_main;   
        SqliteStmt m_stmt_merge_temp;   
        SqliteStmt m_stmt_clear_temp;   
 
        void db_create_table(const Config &config) override final {
            const std::string table_name = config.table_name.empty() ? "kv_store" : config.table_name;
            const std::string temp_table_name = config.table_name.empty() ? "kv_temp_store" : config.table_name + "_temp";
 
            // Create table if they do not exist
            const std::string create_table_sql =
                "CREATE TABLE IF NOT EXISTS " + table_name + " ("
                "key " + get_sqlite_type<KeyT>() + " PRIMARY KEY NOT NULL,"
                "value " + get_sqlite_type<ValueT>() + "         NOT NULL);";
            execute(m_sqlite_db, create_table_sql);
 
            // Create the temporary table for synchronization if it does not exist
            const std::string create_temp_table_sql =
                "CREATE TEMPORARY TABLE IF NOT EXISTS " + temp_table_name + " ("
                "key " + get_sqlite_type<KeyT>() + " PRIMARY KEY NOT NULL,"
                "value " + get_sqlite_type<ValueT>() + "         NOT NULL);";
            execute(m_sqlite_db, create_temp_table_sql);
 
            // Initialize prepared statements for operations on the main table
            m_stmt_load.init(m_sqlite_db, "SELECT key, value FROM " + table_name + ";");
            m_stmt_replace.init(m_sqlite_db, "REPLACE INTO  " + table_name + " (key, value) VALUES (?, ?);");
            m_stmt_get_value.init(m_sqlite_db, "SELECT value FROM " + table_name + " WHERE key = ?;");
            m_stmt_count.init(m_sqlite_db, "SELECT COUNT(*) FROM " + table_name + ";");
            m_stmt_remove.init(m_sqlite_db, "DELETE FROM " + table_name + " WHERE key = ?;");
            m_stmt_clear_main.init(m_sqlite_db, "DELETE FROM " + table_name);
 
            // Initialize prepared statements for temporary table operations
            m_stmt_insert_temp.init(m_sqlite_db, "INSERT OR REPLACE INTO " + temp_table_name + " (key, value) VALUES (?, ?);");
            m_stmt_purge_main.init(m_sqlite_db, "DELETE FROM " + table_name + " WHERE key NOT IN (SELECT key FROM " + temp_table_name + ");");
            m_stmt_merge_temp.init(m_sqlite_db, "INSERT OR REPLACE INTO " + table_name + " (key, value) SELECT key, value FROM " + temp_table_name + ";");
            m_stmt_clear_temp.init(m_sqlite_db, "DELETE FROM " + temp_table_name + ";");
        }
 
        template<template <class...> class ContainerT>
        void db_load(ContainerT<KeyT, ValueT>& container) {
            int err;
            try {
                for (;;) {
                    while ((err = m_stmt_load.step()) == SQLITE_ROW) {
                        KeyT key = m_stmt_load.extract_column<KeyT>(0);
                        ValueT value = m_stmt_load.extract_column<ValueT>(1);
                        container.emplace(std::move(key), std::move(value));
                    }
                    if (err == SQLITE_DONE) {
                        m_stmt_load.reset();
                        return;
                    }
                    if (err == SQLITE_BUSY) {
                        // Handle busy database, retry reading
                        m_stmt_load.reset();
                        sqlite3_sleep(SQLITE_CONTAINERS_BUSY_RETRY_DELAY_MS);
                        continue;
                    }
                    // Handle SQLite errors
                    std::string err_msg = "SQLite error: ";
                    err_msg += std::to_string(err);
                    err_msg += ", ";
                    err_msg += sqlite3_errmsg(m_sqlite_db);
                    throw sqlite_exception(err_msg, err);
                }
            } catch (...) {
                db_handle_exception(
                    std::current_exception(),
                    {&m_stmt_load},
                    "Unknown error occurred while loading data from database.");
            }
        }
 
        bool db_find(const KeyT& key, ValueT& value) {
            bool is_found = false;
            int err;
            try {
                for (;;) {
                    m_stmt_get_value.bind_value<KeyT>(1, key);
                    while ((err = m_stmt_get_value.step()) == SQLITE_ROW) {
                        value = m_stmt_get_value.extract_column<ValueT>(0);
                        is_found = true;
                    }
                    if (err == SQLITE_DONE) {
                        m_stmt_get_value.reset();
                        m_stmt_get_value.clear_bindings();
                        return is_found;
                    }
                    if (err == SQLITE_BUSY) {
                        // Handle busy database, retry reading
                        m_stmt_get_value.reset();
                        m_stmt_get_value.clear_bindings();
                        sqlite3_sleep(SQLITE_CONTAINERS_BUSY_RETRY_DELAY_MS);
                        continue;
                    }
                    // Handle SQLite errors
                    std::string err_msg = "SQLite error: ";
                    err_msg += std::to_string(err);
                    err_msg += ", ";
                    err_msg += sqlite3_errmsg(m_sqlite_db);
                    throw sqlite_exception(err_msg, err);
                }
            } catch (...) {
                db_handle_exception(
                    std::current_exception(),
                    {&m_stmt_get_value},
                    "Unknown error occurred while retrieving value for the provided key.");
            }
            return false;
        }
 
        std::size_t db_count() const {
            std::size_t count = 0;
            int err;
            try {
                for (;;) {
                    while ((err = m_stmt_count.step()) == SQLITE_ROW) {
                        count = m_stmt_count.extract_column<std::size_t>(0);
                    }
                    if (err == SQLITE_DONE) {
                        m_stmt_count.reset();
                        break;
                    }
                    if (err == SQLITE_BUSY) {
                        // Handle busy database, retry reading
                        m_stmt_count.reset();
                        sqlite3_sleep(SQLITE_CONTAINERS_BUSY_RETRY_DELAY_MS);
                        continue;
                    }
                    // Handle SQLite errors
                    std::string err_msg = "SQLite error: ";
                    err_msg += std::to_string(err);
                    err_msg += ", ";
                    err_msg += sqlite3_errmsg(m_sqlite_db);
                    throw sqlite_exception(err_msg, err);
                }
            } catch (...) {
                db_handle_exception(
                    std::current_exception(),
                    {&m_stmt_count},
                    "Unknown error occurred while counting key-value pairs in the database.");
            }
            return count;
        }
 
        template<template <class...> class ContainerT>
        void db_append(const ContainerT<KeyT, ValueT>& container) {
            try {
                for (const auto& pair : container) {
                    m_stmt_replace.bind_value<KeyT>(1, pair.first);
                    m_stmt_replace.bind_value<ValueT>(2, pair.second);
                    m_stmt_replace.execute();
                    m_stmt_replace.reset();
                    m_stmt_replace.clear_bindings();
                }
            } catch (...) {
                db_handle_exception(
                    std::current_exception(),
                    {&m_stmt_replace},
                    "Unknown error occurred while appending key-value pairs to the database.");
            }
        }
 
        template<template <class...> class ContainerT>
        void db_reconcile(const ContainerT<KeyT, ValueT>& container) {
            try {
                // Clear the temporary table
                m_stmt_clear_temp.execute();
                m_stmt_clear_temp.reset();
 
                // Insert all new data from the container into the temporary table
                for (const auto& pair : container) {
                    m_stmt_insert_temp.bind_value<KeyT>(1, pair.first);
                    m_stmt_insert_temp.bind_value<ValueT>(2, pair.second);
                    m_stmt_insert_temp.execute();
                    m_stmt_insert_temp.reset();
                    m_stmt_insert_temp.clear_bindings();
                }
 
                // Remove old data from the main table that is not in the temporary table
                m_stmt_purge_main.execute();
                m_stmt_purge_main.reset();
 
                // Insert or update records from the temporary table into the main table
                m_stmt_merge_temp.execute();
                m_stmt_merge_temp.reset();
 
                // Clear the temporary table
                m_stmt_clear_temp.execute();
                m_stmt_clear_temp.reset();
 
            } catch (...) {
                db_handle_exception(
                    std::current_exception(), {
                        &m_stmt_purge_main, &m_stmt_merge_temp,
                        &m_stmt_clear_temp, &m_stmt_insert_temp
                    },
                    "Unknown error occurred while reconciling data.");
            }
        }
 
        void db_insert(const KeyT &key, const ValueT &value) {
            try {
                m_stmt_replace.bind_value<KeyT>(1, key);
                m_stmt_replace.bind_value<ValueT>(2, value);
                m_stmt_replace.execute();
                m_stmt_replace.reset();
                m_stmt_replace.clear_bindings();
            } catch (...) {
                db_handle_exception(
                    std::current_exception(),
                    {&m_stmt_replace},
                    "Unknown error occurred while inserting key-value pair into the database.");
            }
        }
 
        void db_remove(const KeyT &key) {
            try {
                m_stmt_remove.bind_value<KeyT>(1, key);
                m_stmt_remove.execute();
                m_stmt_remove.reset();
                m_stmt_remove.clear_bindings();
            } catch (...) {
                db_handle_exception(
                    std::current_exception(),
                    {&m_stmt_remove},
                    "Unknown error occurred while removing key.");
            }
        }
 
        void db_clear() {
            try {
                m_stmt_clear_main.execute();
                m_stmt_clear_main.reset();
            } catch (...) {
                db_handle_exception(
                    std::current_exception(),
                    {&m_stmt_clear_main},
                    "Unknown error occurred while clearing the database tables.");
            }
        }
 
    }; // KeyValueDB
 
}; // namespace sqlite_containers