Utils.hpp

Go to the documentation of this file.

#pragma once
 
 
#include <sqlite3.h>
#include <stdexcept>
#include <string>
#include <thread>
#include <chrono>
#include <vector>
#include <deque>
#include <list>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <string>
#include <cstring>
#include <type_traits>
 
#define SQLITE_CONTAINERS_BUSY_RETRY_DELAY_MS 50
 
namespace sqlite_containers {
 
    class sqlite_exception : public std::runtime_error {
    public:
        explicit sqlite_exception(const std::string &message, const int &error_code = -1) :
            std::runtime_error(message), m_error_code(error_code) {}
 
        int error_code() const noexcept {
            return m_error_code;
        }
    private:
        int m_error_code; // The SQLite error code
    }; // sqlite_exception
 
    inline void execute(sqlite3_stmt *stmt) {
        if (!stmt) throw sqlite_exception("Invalid statement pointer.");
        int err;
        for (;;) {
            while ((err = sqlite3_step(stmt)) == SQLITE_ROW);
            switch (err) {
            case SQLITE_DONE:
                return;
            case SQLITE_BUSY:
                sqlite3_sleep(SQLITE_CONTAINERS_BUSY_RETRY_DELAY_MS);
                continue;
            case SQLITE_FULL:
                throw sqlite_exception("Disk full or IO error.", err);
            case SQLITE_IOERR:
                throw sqlite_exception("Failed to insert data into database.", err);
            default:
                throw sqlite_exception("SQLite error.", err);
            }
        }
    }
 
    inline void execute(sqlite3 *sqlite_db, sqlite3_stmt *stmt) {
        if (!sqlite_db || !stmt) throw sqlite_exception("Invalid database or statement pointer.");
        int err;
        for (;;) {
            while ((err = sqlite3_step(stmt)) == SQLITE_ROW);
            switch (err) {
            case SQLITE_DONE:
                return;
            case SQLITE_BUSY:
                sqlite3_sleep(SQLITE_CONTAINERS_BUSY_RETRY_DELAY_MS);
                continue;
            case SQLITE_FULL:
                throw sqlite_exception("Disk full or IO error: " + std::string(sqlite3_errmsg(sqlite_db)) + ". Error code: " + std::to_string(err), err);
            case SQLITE_IOERR:
                throw sqlite_exception("Failed to insert data into database: " + std::string(sqlite3_errmsg(sqlite_db)) + ". Error code: " + std::to_string(err), err);
            default:
                throw sqlite_exception("SQLite error: " + std::string(sqlite3_errmsg(sqlite_db)) + ". Error code: " + std::to_string(err), err);
            }
        }
    }
 
    inline void execute(sqlite3 *sqlite_db, const char *query) {
        if (!sqlite_db) throw sqlite_exception("Invalid database pointer.");
        if (!query || std::strlen(query) == 0) throw sqlite_exception("Empty SQL request.");
        int err;
        do {
            err = sqlite3_exec(sqlite_db, query, nullptr, nullptr, nullptr);
            if (err == SQLITE_BUSY) {
                sqlite3_sleep(SQLITE_CONTAINERS_BUSY_RETRY_DELAY_MS);
            } else
            if (err != SQLITE_OK) {
                std::string err_msg = "SQLite error during prepare: ";
                err_msg += sqlite3_errmsg(sqlite_db);
                err_msg += ". Error code: ";
                err_msg += std::to_string(err);
                throw sqlite_exception(err_msg, err);
            }
        } while (err == SQLITE_BUSY);
    }
 
    inline void execute(sqlite3 *sqlite_db, const std::string &query) {
        execute(sqlite_db, query.c_str());
    }
 
//------------------------------------------------------------------------------
 
    template<typename T>
    inline std::string get_sqlite_type(
            typename std::enable_if<std::is_integral<T>::value>::type* = 0) {
        return "INTEGER";
    }
 
    template<typename T>
    inline std::string get_sqlite_type(
            typename std::enable_if<std::is_floating_point<T>::value>::type* = 0) {
        return "REAL";
    }
 
    template<typename T>
    inline std::string get_sqlite_type(
            typename std::enable_if<std::is_same<T, std::string>::value>::type* = 0) {
        return "TEXT";
    }
 
    template<typename T>
    inline std::string get_sqlite_type(
            typename std::enable_if<
                !std::is_integral<T>::value &&
                !std::is_floating_point<T>::value &&
                std::is_trivially_copyable<T>::value>::type* = 0) {
        return "BLOB";
    }
 
    template<typename T>
    inline typename std::enable_if<
        std::is_trivially_copyable<
            typename T::value_type>::value &&
            std::is_same<T, std::vector<typename T::value_type>>::value,
            std::string
        >::type get_sqlite_type() {
        return "BLOB";
    }
 
    template<typename T>
    inline typename std::enable_if<
        std::is_trivially_copyable<
            typename T::value_type>::value &&
            std::is_same<T, std::deque<typename T::value_type>>::value,
            std::string
        >::type get_sqlite_type() {
        return "BLOB";
    }
 
//------------------------------------------------------------------------------
 
    template<template <class...> class ContainerT, class T>
    inline void add_value(ContainerT<T> &container, T &value,
            typename std::enable_if<
                std::is_same<ContainerT<T>, std::set<T>>::value ||
                std::is_same<ContainerT<T>, std::unordered_set<T>>::value>::type* = 0) {
        container.insert(std::move(value));
    }
 
    template<template <class...> class ContainerT, class T>
    inline void add_value(ContainerT<T> &container, const T &value, const size_t& value_count = 0,
            typename std::enable_if<
                std::is_same<ContainerT<T>, std::multiset<T>>::value ||
                std::is_same<ContainerT<T>, std::unordered_multiset<T>>::value>::type* = 0) {
        for (size_t i = 0; i < value_count; ++i) {
            container.insert(value);
        }
    }
 
    template<template <class...> class ContainerT, class T>
    inline void add_value(ContainerT<T> &container, T &value,
            typename std::enable_if<
                std::is_same<ContainerT<T>, std::list<T>>::value ||
                std::is_same<ContainerT<T>, std::vector<T>>::value ||
                std::is_same<ContainerT<T>, std::deque<T>>::value>::type* = 0) {
        container.emplace(container.end(), std::move(value));
    }
 
    template<template <class...> class ContainerT, class T>
    inline void add_value(ContainerT<T> &container, const T &value, const size_t& value_count,
            typename std::enable_if<
                std::is_same<ContainerT<T>, std::list<T>>::value ||
                std::is_same<ContainerT<T>, std::vector<T>>::value ||
                std::is_same<ContainerT<T>, std::deque<T>>::value>::type* = 0) {
        for (size_t i = 0; i < value_count; ++i) {
            container.emplace(container.end(), value);
        }
    }
 
    template<template <class...> class ContainerT, class T>
    inline void add_value(ContainerT<T> &container, const T &value, const size_t& value_count,
            typename std::enable_if<
                std::is_same<ContainerT<T>, std::set<T>>::value ||
                std::is_same<ContainerT<T>, std::multiset<T>>::value ||
                std::is_same<ContainerT<T>, std::unordered_set<T>>::value ||
                std::is_same<ContainerT<T>, std::unordered_multiset<T>>::value>::type* = 0) {
        for (size_t i = 0; i < value_count; ++i) {
            container.emplace(value);
        }
    }
 
    template <template <class...> class ContainerT, typename KeyT, typename ValueT>
    inline void add_value(ContainerT<KeyT, ValueT> &container, KeyT& key, ValueT& value, const size_t& value_count,
        typename std::enable_if<
            std::is_same<ContainerT<KeyT, ValueT>, std::multimap<KeyT, ValueT>>::value ||
            std::is_same<ContainerT<KeyT, ValueT>, std::unordered_multimap<KeyT, ValueT>>::value>::type* = 0) {
        for (size_t i = 0; i < value_count; ++i) {
            container.emplace(key, value);
        }
    }
 
//------------------------------------------------------------------------------
 
    template <template <class...> class ContainerT, typename KeyT, typename ValueT>
    inline std::list<ValueT> get_values(ContainerT<KeyT, ValueT> &container, const KeyT& key,
        typename std::enable_if<
            std::is_same<ContainerT<KeyT, ValueT>, std::map<KeyT, ValueT>>::value ||
            std::is_same<ContainerT<KeyT, ValueT>, std::unordered_map<KeyT, ValueT>>::value>::type* = 0) {
        std::list<ValueT> values;
        auto it = container.find(key);
        if (it == container.end()) return values;
        values.push_back(it->second);
        return values;
    }
 
    template<template <class...> class ContainerT, template <class...> class ValueContainerT, typename KeyT, typename ValueT>
    inline std::list<ValueT> get_values(ContainerT<KeyT, ValueContainerT<ValueT>> &container, const KeyT& key,
        typename std::enable_if<
            std::is_same<ContainerT<KeyT, ValueT>, std::map<KeyT, ValueContainerT<ValueT>>>::value ||
            std::is_same<ContainerT<KeyT, ValueT>, std::unordered_map<KeyT, ValueContainerT<ValueT>>>::value>::type* = 0) {
        auto it = container.find(key);
        std::list<ValueT> values;
        for (const auto& item : it->second) {
            values.push_back(item);
        }
        return values;
    }
 
    template <template <class...> class ContainerT, typename KeyT, typename ValueT>
    inline std::list<ValueT> get_values(ContainerT<KeyT, ValueT> &container, const KeyT& key,
        typename std::enable_if<
            std::is_same<ContainerT<KeyT, ValueT>, std::multimap<KeyT, ValueT>>::value ||
            std::is_same<ContainerT<KeyT, ValueT>, std::unordered_multimap<KeyT, ValueT>>::value>::type* = 0) {
        auto range = container.equal_range(key);
        std::list<ValueT> values;
        for (auto it = range.first; it != range.second; ++it) {
            values.push_back(it->second);
        }
        return values;
    }
 
//------------------------------------------------------------------------------
 
    template <typename T>
    bool byte_compare(const T& a, const T& b) {
        return std::memcmp(&a, &b, sizeof(T)) == 0;
    }
 
}; // namespace sqlite_containers