SqliteStmt.hpp

Go to the documentation of this file.

#pragma once

 
#include "Utils.hpp"
 
namespace sqlite_containers {

    class SqliteStmt {
    public:

        SqliteStmt() = default;

        SqliteStmt(sqlite3 *sqlite_db, const char *query) {
            init(sqlite_db, query);
        }

        SqliteStmt(sqlite3 *sqlite_db, const std::string &query) {
            init(sqlite_db, query);
        }

        ~SqliteStmt() {
            if (!m_stmt) return;
            sqlite3_finalize(m_stmt);
            m_stmt = nullptr;
        }

        void init(sqlite3 *sqlite_db, const char *query) {
            int err;
            do {
                err = sqlite3_prepare_v2(sqlite_db, query, -1, &m_stmt, nullptr);
                if (err == SQLITE_BUSY) {
                    sqlite3_sleep(SQLITE_CONTAINERS_BUSY_RETRY_DELAY_MS);
                } else
                if (err != SQLITE_OK) {
                    std::string err_msg = "Failed to prepare SQL statement: ";
                    err_msg += std::string(query);
                    err_msg += ". Error code: ";
                    err_msg += std::to_string(err);
                    throw sqlite_exception(err_msg, err);
                }
            } while (err == SQLITE_BUSY);
        }

        void init(sqlite3 *sqlite_db, const std::string &query) {
            init(sqlite_db, query.c_str());
        }

        sqlite3_stmt *get_stmt() noexcept {
            return m_stmt;
        }

        void reset() {
            const int err = sqlite3_reset(m_stmt);
            if (err == SQLITE_OK) return;
            throw sqlite_exception("Failed to reset SQL statement. Error code: " + std::to_string(err), err);
        }

        void clear_bindings() {
            const int err = sqlite3_clear_bindings(m_stmt);
            if (err == SQLITE_OK) return;
            throw sqlite_exception("Failed to clear bindings on SQL statement. Error code: " + std::to_string(err), err);
        }

        void execute(sqlite3 *sqlite_db) {
            sqlite_containers::execute(sqlite_db, m_stmt);
        }

        void execute() {
            sqlite_containers::execute(m_stmt);
        }

        int step() {
            return sqlite3_step(m_stmt);
        }

        template<typename T>
        inline T extract_column(const int &index,
                typename std::enable_if<std::is_integral<T>::value>::type* = 0) {
            return static_cast<T>(sqlite3_column_int64(m_stmt, index));
        }
 
        template<typename T>
        inline T extract_column(const int &index,
                typename std::enable_if<std::is_floating_point<T>::value>::type* = 0) {
            return static_cast<T>(sqlite3_column_double(m_stmt, index));
        }
 
        template<typename T>
        inline T extract_column(const int &index,
                typename std::enable_if<std::is_same<T, std::string>::value>::type* = 0) {
            const unsigned char *text = sqlite3_column_text(m_stmt, index);
            if (text) {
                return std::string(reinterpret_cast<const char*>(text));
            }
            return std::string();
        }
 
        template<typename T>
        inline T extract_column(const int &index,
                typename std::enable_if<std::is_same<T, std::vector<char>>::value>::type* = 0) {
            const void* blob = sqlite3_column_blob(m_stmt, index);
            const int blob_size = sqlite3_column_bytes(m_stmt, index);
            return std::vector<char>(static_cast<const char*>(blob), static_cast<const char*>(blob) + blob_size);
        }
 
        template<typename T>
        inline T extract_column(const int &index,
                typename std::enable_if<std::is_same<T, std::vector<uint8_t>>::value>::type* = 0) {
            const void* blob = sqlite3_column_blob(m_stmt, index);
            const int blob_size = sqlite3_column_bytes(m_stmt, index);
            return std::vector<uint8_t>(static_cast<const uint8_t*>(blob), static_cast<const uint8_t*>(blob) + blob_size);
        }
 
        template<typename T>
        inline T extract_column(const int &index,
                typename std::enable_if<
                    !std::is_integral<T>::value &&
                    !std::is_floating_point<T>::value &&
                    !std::is_same<T, std::string>::value &&
                    !std::is_same<T, std::vector<char>>::value &&
                    !std::is_same<T, std::vector<uint8_t>>::value &&
                    std::is_trivially_copyable<T>::value
                >::type* = 0) {
            T value;
            const void* blob = sqlite3_column_blob(m_stmt, index);
            const int blob_size = sqlite3_column_bytes(m_stmt, index);
            if (blob_size == sizeof(T)) {
                std::memcpy(&value, blob, sizeof(T));
            } else {
                throw sqlite_exception("Blob size does not match POD size.");
            }
            return value;
        }

        template<typename T>
        inline bool bind_value(const int &index, const T& value,
                typename std::enable_if<std::is_integral<T>::value>::type* = 0) {
            return (sqlite3_bind_int64(m_stmt, index, static_cast<int64_t>(value)) == SQLITE_OK);
        }
 
        template<typename T>
        inline bool bind_value(const int &index, const T& value,
                typename std::enable_if<std::is_floating_point<T>::value>::type* = 0) {
            return (sqlite3_bind_double(m_stmt, index, static_cast<double>(value)) == SQLITE_OK);
        }
 
        template<typename T>
        inline bool bind_value(const int &index, const T& value,
                typename std::enable_if<std::is_same<T, std::string>::value>::type* = 0) {
            return (sqlite3_bind_text(m_stmt, index, value.c_str(), static_cast<int>(value.size()), SQLITE_STATIC) == SQLITE_OK);
        }
 
        template<typename T>
        inline bool bind_value(const int &index, const T& value,
                typename std::enable_if<std::is_same<T, std::vector<char>>::value>::type* = 0) {
            return (sqlite3_bind_blob(m_stmt, index, value.data(), value.size(), SQLITE_STATIC) == SQLITE_OK);
        }
 
        template<typename T>
        inline bool bind_value(const int &index, const T& value,
                typename std::enable_if<std::is_same<T, std::vector<uint8_t>>::value>::type* = 0) {
            return (sqlite3_bind_blob(m_stmt, index, value.data(), value.size(), SQLITE_STATIC) == SQLITE_OK);
        }
 
        template<typename T>
        inline bool bind_value(const int &index, const T& value,
                typename std::enable_if<
                    !std::is_integral<T>::value &&
                    !std::is_floating_point<T>::value &&
                    !std::is_same<T, std::string>::value &&
                    !std::is_same<T, std::vector<char>>::value &&
                    !std::is_same<T, std::vector<uint8_t>>::value &&
                    std::is_trivially_copyable<T>::value
                >::type* = 0) {
            return (sqlite3_bind_blob(m_stmt, index, &value, sizeof(T), SQLITE_STATIC) == SQLITE_OK);
        }
 
    private:
        sqlite3_stmt *m_stmt = nullptr; 
    }; // SqliteStmt
 
}; // namespace sqlite_containers