DBConnection.h

Go to the documentation of this file.

#ifndef __SQLITEXX_SQLITE_DBCONNECTION_H__
#define __SQLITEXX_SQLITE_DBCONNECTION_H__

#include "Exception.h"
#include "Functions.h"
#include "Mutex.h"
#include "Open.h"

#include <sqlite3.h>

#include <cassert>
#include <chrono>
#include <memory>
#include <thread>


namespace sqlite
{
    class dbconnection
    {
        public:

        dbconnection() noexcept;

        dbconnection(const dbconnection& other) noexcept;

        dbconnection(dbconnection&& other) noexcept;

        dbconnection(
            const std::string& filename,
            openmode mode = openmode::read_write | openmode::create,
            const std::chrono::milliseconds timeout = DEFAULT_TIMEOUT);

        dbconnection(const std::string& filename, const std::chrono::milliseconds timeout);

        dbconnection(const std::u16string& filename, const std::chrono::milliseconds timeout = DEFAULT_TIMEOUT);

        dbconnection& operator=(const dbconnection& other) noexcept;

        dbconnection& operator=(dbconnection&& other) noexcept;

        static dbconnection memory();

        static dbconnection wide_memory();

        sqlite::mutex mutex();

        explicit operator bool() const noexcept;

        sqlite3* handle() const noexcept;

        void open(const std::string& filename, openmode mode = openmode::read_write | openmode::create);

        void open(const std::u16string& filename);

        long long row_id() const noexcept;

        template <typename F>
        void create_general_function(
            const std::string& name,
            F&& function,
            int is_deterministic = false,
            const textencoding encoding = textencoding::utf8,
            int nargs = -1)
        {
            using FunctionType = typename SQLiteFunctionTraits<F>::f_type;
            FunctionType *userFunction = new FunctionType(function);

            int flags = static_cast<int>(encoding);
            if (is_deterministic) {
                flags |= SQLITE_DETERMINISTIC;
            }

            int errorcode = sqlite3_create_function_v2(
                handle(),
                name.c_str(),
                nargs,
                static_cast<int>(flags),
                (void*)userFunction,
                &internal_general_scalar_function<FunctionType>,
                nullptr,
                nullptr,
                &internal_delete<FunctionType>);

            throw_error_code(errorcode, "");
        }

        template <typename F>
        void create_function(
            const std::string& name,
            F&& function,
            bool is_deterministic = false,
            const textencoding encoding = textencoding::utf8)
        {
            using FunctionType = typename function_traits<F>::f_type;
            FunctionType *userFunction = new FunctionType(function);

            int flags = static_cast<int>(encoding);
            if (is_deterministic) {
                flags |= SQLITE_DETERMINISTIC;
            }

            int errorcode = sqlite3_create_function_v2(
                handle(),
                name.c_str(),
                function_traits<F>::nargs,
                flags,
                (void*)userFunction,
                &internal_scalar_function<FunctionType>,
                nullptr,
                nullptr,
                &internal_delete<FunctionType>);

            throw_error_code(errorcode, "");
        }

        template <typename A>
        void create_aggregate(
            const std::string& name,
            bool is_deterministic = false,
            const textencoding encoding = textencoding::utf8)
        {
            using StepFunctionType = function_traits<decltype(&A::step)>;
            aggregate_wrapper<A> *wrapper = new aggregate_wrapper<A>;

            int flags = static_cast<int>(encoding);
            if (is_deterministic) {
                flags |= SQLITE_DETERMINISTIC;
            }

            int errorcode = sqlite3_create_function_v2(
                handle(),
                name.c_str(),
                StepFunctionType::nargs,
                static_cast<int>(flags),
                (void*)wrapper,
                nullptr,
                &internal_step<aggregate_wrapper<A> >,
                &internal_final<aggregate_wrapper<A> >,
                &internal_dispose<aggregate_wrapper<A> >);

            throw_error_code(errorcode, "");
        }

        template <typename F>
        void create_collation(
            const std::string& name,
            F&& function,
            const textencoding encoding = textencoding::utf8)
        {
            using CollationType = typename collation_traits<F>::f_type;
            CollationType *userFunction = new CollationType(function);

            int flags = static_cast<int>(encoding);

            int errorcode = sqlite3_create_collation_v2(
                handle(),
                name.c_str(),
                flags,
                (void*)userFunction,
                &internal_collation_function<CollationType>,
                &internal_delete<CollationType>);

            throw_error_code(errorcode, "");
        }


        template <typename F>
        void profile(F&& callback, void* const context = nullptr)
        {
            sqlite3_profile(handle(), callback, context);
        }

        private:
        using connection_handle = std::shared_ptr<sqlite3>;
        connection_handle m_handle;

        static const std::chrono::minutes DEFAULT_TIMEOUT;
    };
}

#endif