sqlite_cpp.h

Go to the documentation of this file.

#include "sqlite3.h"
#include <map>
#include <queue>
#include <vector>
#include <string>
#include <memory>

namespace SQLite {
    struct conn_base {
    public:
        sqlite3* db = nullptr;

        sqlite3** get_ref() {
            return &(this->db);
        }
        
        void close() {
            if (db) {
                sqlite3_close(db);
                db = nullptr;
            }
        };
        conn_base() {};
        ~conn_base() {
            this->close();
        }
    };

    struct stmt_base {
    public:
        stmt_base() {};
        ~stmt_base() {
            // Note: Calling sqlite3_finalize on a nullptr is harmless
            sqlite3_finalize(this->stmt);
        }

        void close() {
            if (stmt) {
                sqlite3_finalize(stmt);
                stmt = nullptr;
            }
        }

        sqlite3_stmt* stmt = nullptr;
    };

    class Conn {

        class PreparedStatement {
        public:
            PreparedStatement(Conn& conn, const std::string& stmt);
            template<typename... Args>
            
            void bind(Args... args) {
                if (sizeof...(Args) > this->params) {
                    throw ValueError("Too many arguments to bind() " +
                        std::to_string(this->params) + " expected " + std::to_string(sizeof...(Args)) + " specified");
                }

                size_t i = 0;
                _bind_many(i, args...); // Recurse through templates
                this->next();
            }

            template<typename T>
            void bind(const size_t i, const T value) {
                static_assert(false, "Cannot call bind() on values of this type. Supported types are:"
                    " char *, string, int, long int, and double.");
            }

            template<>
            inline void bind(const size_t i, const char* value) {
                sqlite3_bind_text(
                    this->get_ptr(),    // Pointer to prepared statement
                    i + 1,              // Index of parameter to set
                    value,              // Value to bind
                    strlen(value),      // Size of string in bytes
                    SQLITE_TRANSIENT);  // String destructor
            }

            template<>
            inline void bind(const size_t i, const std::string value) {
                sqlite3_bind_text(
                    this->get_ptr(),    // Pointer to prepared statement
                    i + 1,              // Index of parameter to set
                    value.c_str(),      // Value to bind
                    value.size(),       // Size of string in bytes
                    SQLITE_TRANSIENT);  // String destructor
            }

            template<>
            inline void bind(const size_t i, const int value) {
                sqlite3_bind_int(this->get_ptr(), i + 1, value);
            }

            template<>
            inline void bind(const size_t i, const long int value) {
                sqlite3_bind_int64(this->get_ptr(), i + 1, value);
            }

            template<>
            void bind(const size_t i, double value) {
                sqlite3_bind_double(this->get_ptr(), i + 1, value);
            }

            sqlite3_stmt* get_ptr();
            void commit();
            void next();
            void close() noexcept;

        protected:
            int params;
            Conn* conn;
            std::shared_ptr<stmt_base> base = std::make_shared<stmt_base>();
            const char * unused;

        private:
            template<typename T>
            void _bind_many(size_t i, T value) {
                bind<T>(i, value);
                i++;
            }

            template<typename T, typename... Args>
            void _bind_many(size_t i, T value, Args... args) {
                bind<T>(i, value);
                i++;
                _bind_many(i, args...); // Recurse through templates
            }
        };

        class ResultSet : PreparedStatement {
        public:
            std::vector<std::string> get_col_names();
            std::vector<std::string> get_row();
            int num_cols();
            bool next();
            using PreparedStatement::close;
            using PreparedStatement::PreparedStatement;
        };

    public:
        Conn(const char * db_name);
        Conn(const std::string db_name);
        void exec(const std::string query);
        Conn::PreparedStatement prepare(const std::string& stmt);
        Conn::ResultSet query(const std::string& stmt);
        void close() noexcept;

        sqlite3* get_ptr();
        std::shared_ptr<conn_base> base =
            std::make_shared<conn_base>(); 
        char * error_message;              
    private:
        std::queue<PreparedStatement*> stmts; 
    };


    class DatabaseClosed : public std::runtime_error {
    public:
        DatabaseClosed() :runtime_error("Attempted operation on a closed database.") {};
    };

    class StatementClosed : public std::runtime_error {
    public:
        StatementClosed() :runtime_error("Attempted operation on a closed statement.") {};
    };

    class ValueError : public std::runtime_error {
    public:
        ValueError() :runtime_error("[Value Error] Invalid value or value(s).") {};
        ValueError(const std::string& msg) :runtime_error("[Value Error] " + msg) {};
    };

    class SQLiteError : public std::runtime_error {
    public:
        SQLiteError(const std::string& msg) :runtime_error("[SQLite Error] " + msg) {};
    };

    const std::map<int, std::string> SQLITE_ERROR_MSG = {
        { 1, "SQLITE_ERROR: Generic SQLite Error" },
        { 19, "SQLITE_CONSTRAINT: SQL constrainted violated" }
    };

    const std::map<int, std::string> SQLITE_EXT_ERROR_MSG = {
        { 787, "SQLITE_CONSTRAINT_FOREIGNKEY: Foreign key constraint failed" },
        { 1555, "SQLITE_CONSTRAINT_PRIMARYKEY: Primary key constraint failed" }
    };

    void throw_sqlite_error(const int& error_code,
        const int& ext_error_code=-1);
}