Statement.h

Go to the documentation of this file.

#ifndef __SQLITEXX_SQLITE_STATEMENT_H__
#define __SQLITEXX_SQLITE_STATEMENT_H__

#include "Blob.h"
#include "DBConnection.h"
#include "SQLiteEnums.h"
#include "Value.h"

#include <sqlite3.h>

#include <cassert>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <string>
#include <utility>
#include <vector>
#include <limits.h>

namespace sqlite
{
    template <typename T>
    class reader
    {
        public:

        virtual ~reader() = default;

        int get_int(const int column) const noexcept
        {
            return sqlite3_column_int(static_cast<T const *>(this)->handle(), column);
        }

        int get_int(const std::string& name) const noexcept
        {
            const int column = get_column_index(name);
            return get_int(column);
        }

        int64_t get_int64(const int column) const noexcept
        {
            return sqlite3_column_int64(static_cast<T const *>(this)->handle(), column);
        }

        int64_t get_int64(const std::string& name) const noexcept
        {
            const int column = get_column_index(name);
            return get_int64(column);
        }

        unsigned int get_uint(const int column) const noexcept
        {
            return static_cast<unsigned int>(get_int64(column));
        }

        unsigned int get_uint(const std::string& name) const noexcept
        {
            const int column = get_column_index(name);
            return get_uint(column);
        }

        double get_double(const int column) const noexcept
        {
            return sqlite3_column_double(static_cast<T const *>(this)->handle(), column);
        }

        double get_double(const std::string& name) const noexcept
        {
            const int column = get_column_index(name);
            return get_double(column);
        }

        const blob get_blob(const int column) const noexcept
        {
            const void *blob = sqlite3_column_blob(static_cast<T const *>(this)->handle(), column);
            return sqlite::blob(blob, get_bytes(column));
        }

        const blob get_blob(const std::string& name) const noexcept
        {
            const int column = get_column_index(name);
            return get_blob(column);
        }

        const std::string get_string(const int column) const noexcept
        {
            const char *txt = get_text(column);
            return std::string(txt, get_text_length(column));
        }

        const std::string get_string(const std::string& name) const noexcept
        {
            const int column = get_column_index(name);
            return get_string(column);
        }

        const std::u16string get_u16string(const int column) const noexcept
        {
            const char16_t *txt = get_text16(column);
            return std::u16string(txt, get_text16_length(column));
        }

        const std::u16string get_u16string(const std::string& name) const noexcept
        {
            const int column = get_column_index(name);
            return get_u16string(column);
        }

        value get_value(const int column) const noexcept
        {
            return value(sqlite3_column_value(static_cast<T const *>(this)->handle(), column));
        }

        value get_value(const std::string& name) const
        {
            const int column = get_column_index(name);
            return get_value(column);
        }


        int get_bytes(const int column) const noexcept
        {
            return sqlite3_column_bytes(static_cast<T const *>(this)->handle(), column);
        }

        int get_bytes(const std::string& name) const noexcept
        {
            const int column = get_column_index(name);
            return get_bytes(column);
        }

        datatype get_type(const int column) const noexcept
        {
            return static_cast<datatype>(sqlite3_column_type(static_cast<T const *>(this)->handle(), column));
        }

        datatype get_type(const std::string& name) const noexcept
        {
            const int column = get_column_index(name);
            return get_type(column);
        }

        int column_count() const noexcept
        {
            return sqlite3_column_count(static_cast<T const *>(this)->handle());
        }

        const char* get_column_name(const int index) const noexcept
        {
            return sqlite3_column_name(static_cast<T const *>(this)->handle(), index);
        }

        const char16_t* get_column_wide_name(const int index) const noexcept
        {
            return sqlite3_column_name16(static_cast<T const *>(this)->handle(), index);
        }

        int get_column_index(const std::string& name) const
        {
            std::map<std::string, int> columnNamesToIndex;

            const int columnCount = column_count();
            for (int i = 0; i < columnCount; ++i) {
                const char* columnName = sqlite3_column_name(static_cast<T const *>(this)->handle(), i);
                columnNamesToIndex[columnName] = i;
            }

            const std::map<std::string, int>::const_iterator index = columnNamesToIndex.find(name);
            if (index == columnNamesToIndex.end())
            {
                throw SQLiteXXException("No column was found with that name");
            }
            return index->second;
        }

        private:

        const char* get_text(const int column) const noexcept
        {
            return reinterpret_cast<char const *>(sqlite3_column_text(
                    static_cast<T const *>(this)->handle(), column));
        }

        const char16_t* get_text16(const int column) const noexcept
        {
            return reinterpret_cast<char16_t const *>(sqlite3_column_text16(
                    static_cast<T const *>(this)->handle(), column));
        }

        int get_text_length(const int column) const noexcept
        {
            return sqlite3_column_bytes(static_cast<T const *>(this)->handle(), column);
        }

        int get_text16_length(const int column) const noexcept
        {
            return sqlite3_column_bytes16(static_cast<T const *>(this)->handle(), column) / sizeof(char16_t);
        }
    };


    class row : public reader<row>
    {
        public:

        row(sqlite3_stmt* const statement) noexcept :
            m_statement(statement)
         {}

        sqlite3_stmt* handle() const noexcept
        {
            return m_statement;
        }

        value operator[](int column) const
        {
            return get_value(column);
        }

        value operator[](const std::string& name) const
        {
            return get_value(name);
        }

        private:
        sqlite3_stmt* m_statement = nullptr;
    };


    class statement : public reader<statement>
    {
        public:
        statement() noexcept;

        template <typename ... Values>
        statement(
            const dbconnection& connection,
            const std::string& text,
            Values&& ... values) :
        m_handle(nullptr, sqlite3_finalize),
        m_done(false)
        {
            prepare(connection, text, std::forward<Values>(values) ...);
        }

        template <typename ... Values>
        statement(
            const dbconnection& connection,
            const std::u16string& text,
            Values&& ... values) :
        m_handle(nullptr, sqlite3_finalize),
        m_done(false)
        {
            prepare(connection, text, std::forward<Values>(values) ...);
        }

        operator bool() const noexcept;

        sqlite3_stmt* handle() const noexcept;

        template <typename ... Values>
        void prepare(
            dbconnection const& connection,
            const std::string& text,
            Values&& ... values)
        {
            internal_prepare(connection, sqlite3_prepare_v2, text.c_str(), std::forward<Values>(values) ...);
        }

        template <typename ... Values>
        void prepare(
            const dbconnection& connection,
            const std::u16string& text,
            Values&& ... values)
        {
            internal_prepare(connection, sqlite3_prepare16_v2, text.c_str(), std::forward<Values>(values) ...);
        }

        bool step() const;

        int execute() const;

        void bind(const int index, const int value) const;

        void bind(const int index, const double value) const;

        void bind(const int index, const void* const value, const int size, bindtype type = bindtype::transiently) const;

        void bind(const int index, const blob& value) const;

        void bind(const int index, const char* const value, const int size = -1, bindtype type = bindtype::transiently) const;

        void bind(const int index, const char16_t* const value, const int size = -1, bindtype type = bindtype::transiently) const;

        void bind(const int index, const std::string& value) const;

        void bind(const int index, const std::u16string& value) const;

        template <typename T>
        void bind_name(const std::string& name, T&& value)
        {
            const int index = sqlite3_bind_parameter_index(handle(), name.c_str());
            bind(index, value);
        }

        template <typename ... Values>
        void bind_all(Values&& ... values) const
        {
            internal_bind(1, std::forward<Values>(values) ...);
        }

        template <typename ... Values>
        void clear_bindings(Values&& ... values) const
        {
            if (SQLITE_OK != sqlite3_clear_bindings(handle()))
            {
                throw_last_error();
            }

            bind_all(values ...);
        }


        void reset() const
        {
            if (SQLITE_OK != sqlite3_reset(handle()))
            {
                throw_last_error();
            }
            m_done = false;
        }

        private:
        using statement_handle = std::unique_ptr<sqlite3_stmt, decltype(&sqlite3_finalize)>;
        statement_handle m_handle;

        mutable bool m_done;

        template <typename F, typename C, typename ... Values>
        void internal_prepare(
            const dbconnection& connection,
            F prepare,
            const C * const text,
            Values&& ... values)
        {
            assert(connection);

            sqlite3_stmt *statement;
            if (SQLITE_OK != prepare(connection.handle(), text, -1, &statement, nullptr))
            {
                const int errcode = sqlite3_extended_errcode(connection.handle());
                const std::string message = sqlite3_errmsg(connection.handle());
                sqlite3_finalize(statement);
                throw_error_code(errcode, message);
            }

            m_handle.reset(statement);
            bind_all(std::forward<Values>(values) ...);
        }

        void internal_bind(int) const noexcept
        {}

        template <typename First, typename ... Rest>
        void internal_bind(const int index, First&& first, Rest&& ... rest) const
        {
            bind(index, std::forward<First>(first));
            internal_bind(index + 1, std::forward<Rest>(rest) ...);
        }

        void throw_last_error() const;

        statement(const statement& other) = delete;
        statement& operator=(statement& other) = delete;

    };

    class row_iterator
    {
        public:
        row_iterator() noexcept = default;

        row_iterator(const statement& statement) noexcept;

        row_iterator& operator++() noexcept;

        bool operator!=(const row_iterator& other) const noexcept;

        row operator*() const noexcept;

        private:
        const statement* m_statement = nullptr;

    };

    row_iterator begin(const statement& statement) noexcept;

    row_iterator end(const statement& statement) noexcept;

    template <typename ... Values>
    inline int execute(
        const dbconnection& connection,
        const std::string& text,
        Values&& ... values)
    {
        return statement(connection, text.c_str(), std::forward<Values>(values) ...).execute();
    }

    template <typename ... Values>
    inline int execute(
        const dbconnection& connection,
        const std::u16string& text,
        Values&& ... values)
    {
        return statement(connection, text.c_str(), std::forward<Values>(values) ...).execute();
    }

    template <typename Call>
    inline int internal_execute_callback(
        void *data,
        int numColumns,
        char **colData,
        char **colNames)
    {
        Call *userCallback = static_cast<Call *>(data);

        std::vector<std::string> columnData;
        std::vector<std::string> columnName;
        for (int i = 0; i < numColumns; i++) {
            columnData.push_back(colData[i]? colData[i]: "");
            columnName.push_back(colNames[i]? colNames[i]: "");
        }

        (*userCallback)(columnData, columnName);
        return 0;
    }

    template <typename F, typename ... Args>
    inline void execute_callback(
        const dbconnection& connection,
        const std::string& sql,
        F&& callback,
        Args&& ... args)
    {
        // TODO: Decide whether to go with lambda or with bind.
        // Using variadic templates in a lambda requires C++14 but could be more performant.
        // auto userCallback = [&](const std::vector<std::string> &colValues, const std::vector<std::string> &colNames) {
        //     callback(colValues, colNames, std::forward<Args>(args)...);
        // };

        auto userCallback =
            std::bind(
               std::forward<F>(callback),
               std::placeholders::_1,
               std::placeholders::_2,
               std::forward<Args>(args)...);

        typedef decltype(userCallback) Call;

        char *errmsgPtr = nullptr;
        sqlite3_exec(connection.handle(), sql.c_str(), internal_execute_callback<Call>, (void *)&userCallback, nullptr);
        delete errmsgPtr;

        throw_error_code(connection.handle());
    }
}

#endif