database_iface.hpp

/*
 Copyright 2019 Eugene Gershnik
 
 Use of this source code is governed by a BSD-style
 license that can be found in the LICENSE file or at
 https://github.com/gershnik/thinsqlitepp/blob/master/LICENSE
*/
 
#ifndef HEADER_SQLITEPP_DATABASE_IFACE_INCLUDED
#define HEADER_SQLITEPP_DATABASE_IFACE_INCLUDED
 
#include "handle.hpp"
#include "exception_iface.hpp"
#include "mutex_iface.hpp"
#include "blob_iface.hpp"
#include "snapshot_iface.hpp"
#include "memory_iface.hpp"
#include "string_param.hpp"
#include "span.hpp"
#include "meta.hpp"
 
#include <memory>
#include <functional>
#include <optional>
 
#ifdef __GNUC__
    #pragma GCC diagnostic push
    #pragma GCC diagnostic ignored "-Wcast-function-type"
    
    #if defined(__APPLE__) && defined(__clang__)
        #pragma GCC diagnostic ignored "-Wunguarded-availability-new"
        #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
    #endif
#endif
 
 
 
namespace thinsqlitepp
{
    SQLITEPP_EXPORTED class context;
    SQLITEPP_EXPORTED class row;
    SQLITEPP_EXPORTED class value;

 
    struct database_detector
    {
        SQLITEPP_CALL_DETECTOR(enable_load_extension, int, sqlite3_enable_load_extension, (T *)nullptr, int{});
        SQLITEPP_CALL_DETECTOR(load_extension, int, sqlite3_load_extension, (T *)nullptr, 
                                                                            (const char *)nullptr,
                                                                            (const char *)nullptr,
                                                                            (char **)nullptr);
 
        SQLITEPP_METHOD_DETECTOR(void, step, (context *)nullptr, int{}, (value **)nullptr);
        SQLITEPP_METHOD_DETECTOR(void, last, (context *)nullptr);
        SQLITEPP_METHOD_DETECTOR(void, inverse, (context *)nullptr, int{}, (value **)nullptr);
        SQLITEPP_METHOD_DETECTOR(void, current, (context *)nullptr);
 
    public:
        template<class T>
        static constexpr bool is_function = std::is_nothrow_invocable_r_v<void, T, context *, int, value **>;
 
        template<class T>
        static constexpr bool is_aggregate_function = has_noexcept_step<T> && has_noexcept_last<T>;
 
        template<class T>
        static constexpr bool is_aggregate_window_function = is_aggregate_function<T> && has_noexcept_inverse<T> && has_noexcept_current<T>;
        
        template<class R, class T, class... ArgTypes>
        static constexpr bool is_pointer_to_callback =  std::is_null_pointer_v<T> ||
            (std::is_pointer_v<T> && std::is_nothrow_invocable_r_v<R, std::remove_pointer_t<T>, ArgTypes...>);
 
        template<class R, class T, class... ArgTypes>
        static constexpr bool is_pointer_to_throwing_callback =  std::is_null_pointer_v<T> ||
            (std::is_pointer_v<T> && std::is_invocable_r_v<R, std::remove_pointer_t<T>, ArgTypes...>);
 
        template<class T>
        static constexpr bool is_pointer_to_function = std::is_null_pointer_v<T> ||
            (std::is_pointer_v<T> &&
                (
                   is_function<std::remove_pointer_t<T>> ||
                   is_aggregate_function<std::remove_pointer_t<T>>
                )
            );
 
        template<class T>
        static constexpr bool is_pointer_to_window_function = std::is_null_pointer_v<T> ||
                (std::is_pointer_v<T> && is_aggregate_window_function<std::remove_pointer_t<T>>);
    };



    SQLITEPP_EXPORTED
    class database final : public handle<sqlite3, database>
    {
    private:
        template<int Code, class ...Args>
        struct config_option
        {
            static void apply(database & db, Args && ...args)
            {
                int res = sqlite3_db_config(db.c_ptr(), Code, std::forward<Args>(args)...);
                if (res != SQLITE_OK)
                    throw exception(res, db);
            }
        };
        template<int Code> struct config_mapping;
 
        template<int Code, class ...Args>
        struct vtab_config_option
        {
            static void apply(database & db, Args && ...args)
            {
                int res = sqlite3_vtab_config(db.c_ptr(), Code, std::forward<Args>(args)...);
                if (res != SQLITE_OK)
                    throw exception(res, db);
            }
        };
        template<int Code> struct vtab_config_mapping;
        
    public:
        static std::unique_ptr<database> open(const string_param & db_filename, int flags, const char * vfs = nullptr);

        ~database() noexcept
            { sqlite3_close_v2(c_ptr()); }
        
        
        //MARK: -

        void busy_timeout(int ms)
            { check_error(sqlite3_busy_timeout(c_ptr(), ms)); }
 
 
        //MARK: -
 
    #if  SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 50, 0)

        void setlk_timeout(int ms, int flags = 0)
            { check_error(sqlite3_setlk_timeout(c_ptr(), ms, flags)); }
 
    #endif
 
        //MARK: Client data
 
    #if  SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 44, 0)
        
        void set_clientdata(const string_param & name, void * ptr, void(*destroy)(void*) = nullptr)
            { check_error(sqlite3_set_clientdata(c_ptr(), name.c_str(), ptr, destroy)); }

        template<class T>
        void set_clientdata(const string_param & name, std::unique_ptr<T> && data)
        { 
            set_clientdata(name, data.release(), [](void * d) {
                delete static_cast<T *>(d);
            });
        }

        template<class T>
        T * get_clientdata(const string_param & name) noexcept
            { return static_cast<T *>(sqlite3_get_clientdata(c_ptr(), name.c_str())); }
 
    #endif
        
        //MARK: -

        int64_t changes() const noexcept
        {
        #if  SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 36, 1)
            return sqlite3_changes64(c_ptr()); 
        #else
            return sqlite3_changes(c_ptr()); 
        #endif
        }
 
        //MARK: -
 
    #if  SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 51, 1)
        void set_errmsg(int errcode, const string_param & message)
            { check_error(sqlite3_set_errmsg(c_ptr(), errcode, message.c_str())); }
    #endif
 
        //MARK: - exec


        void exec(std::string_view sql);
 
    #if __cpp_char8_t >= 201811
        template<class T>
        T exec(std::u8string_view sql)
            {  return exec(std::string_view((const char *)sql.data(), sql.size())); }
    #endif
        
        template<class T>
        SQLITEPP_ENABLE_IF((
            std::is_invocable_r_v<bool, T, int, row> ||
            std::is_invocable_r_v<void, T, int, row> ||
            std::is_invocable_r_v<bool, T, row> ||
            std::is_invocable_r_v<void, T, row>),
        T) exec(std::string_view sql, T callback);
 
    #if __cpp_char8_t >= 201811
        template<class T>
        T exec(std::u8string_view sql, T callback)
            {  return exec(std::string_view((const char *)sql.data(), sql.size()), callback); }
    #endif


 
        //MARK: - busy_handler

        template<class T>
        SQLITEPP_ENABLE_IF(std::is_pointer_v<T> || std::is_null_pointer_v<T>,
        void) busy_handler(int (* handler)(type_identity_t<T> data_ptr, int count_invoked) noexcept, T data_ptr)
            { check_error(sqlite3_busy_handler(this->c_ptr(), (int (*)(void*,int))handler, data_ptr)); }
        
        template<class T>
        SQLITEPP_ENABLE_IF((database_detector::is_pointer_to_callback<bool, T, int>),
        void) busy_handler(T handler_ptr);
        
        
        //MARK: - collation_needed

        template<class T>
        SQLITEPP_ENABLE_IF(std::is_pointer_v<T> || std::is_null_pointer_v<T>,
        void) collation_needed(T data_ptr, void (* handler)(type_identity_t<T> data_ptr, database *, int encoding, const char * name) noexcept)
            { check_error(sqlite3_collation_needed(this->c_ptr(), data_ptr, (void(*)(void*,sqlite3*,int,const char*))handler)); }
        
        template<class T>
        SQLITEPP_ENABLE_IF((database_detector::is_pointer_to_callback<void, T, database *, int, const char *>),
        void) collation_needed(T handler_ptr);
        
        //MARK: - commit_hook

        template<class T>
        SQLITEPP_ENABLE_IF(std::is_pointer_v<T> || std::is_null_pointer_v<T>,
        void) commit_hook(int (* handler)(type_identity_t<T> data_ptr) noexcept, T data_ptr) noexcept
            { sqlite3_commit_hook(this->c_ptr(), (int(*)(void*))handler, data_ptr); }
        
        template<class T>
        SQLITEPP_ENABLE_IF((database_detector::is_pointer_to_callback<bool, T>),
        void) commit_hook(T handler_ptr) noexcept;
        
        
        //MARK: - rollback_hook

        template<class T>
        SQLITEPP_ENABLE_IF(std::is_pointer_v<T> || std::is_null_pointer_v<T>,
        void) rollback_hook(void (* handler)(type_identity_t<T> data_ptr) noexcept, T data_ptr) noexcept
            { sqlite3_rollback_hook(this->c_ptr(), (void(*)(void*))(handler), data_ptr); }
        
        template<class T>
        SQLITEPP_ENABLE_IF((database_detector::is_pointer_to_callback<void, T>),
        void) rollback_hook(T handler_ptr) noexcept;
 
 
        //MARK: - update_hook

        template<class T>
        SQLITEPP_ENABLE_IF(std::is_pointer_v<T> || std::is_null_pointer_v<T>,
        void) update_hook(void (* handler)(type_identity_t<T> data_ptr, int op, const char * db_name, const char * table, sqlite3_int64 rowid) noexcept, 
                          T data_ptr) noexcept
            { sqlite3_update_hook(this->c_ptr(), (void(*)(void*,int,char const *,char const *,sqlite3_int64))(handler), data_ptr); }
 

        template<class T>
        SQLITEPP_ENABLE_IF((database_detector::is_pointer_to_callback<void, T, int, const char *, const char *, int64_t>),
        void) update_hook(T handler_ptr) noexcept;
 
        //MARK: - preupdate_hook
 
    #if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 16, 0) && defined(SQLITE_ENABLE_PREUPDATE_HOOK)
        template<class T>
        SQLITEPP_ENABLE_IF(std::is_pointer_v<T> || std::is_null_pointer_v<T>,
        void) preupdate_hook(void (* handler)(type_identity_t<T> data_ptr, 
                                              database * db, 
                                              int op, 
                                              const char * db_name, 
                                              const char * table, 
                                              sqlite3_int64 rowid_old,
                                              sqlite3_int64 rowid_new) noexcept, 
                             T data_ptr) noexcept
        { 
            sqlite3_preupdate_hook(this->c_ptr(), (void(*)(void*,sqlite3 *,int,char const *,char const *,sqlite3_int64,sqlite3_int64))(handler), 
                                    data_ptr); 
        }

        template<class T>
        SQLITEPP_ENABLE_IF((database_detector::is_pointer_to_callback<void, T, database *, int, const char *, const char *, int64_t, int64_t>),
        void) preupdate_hook(T handler_ptr) noexcept;
 
    #endif

        template<class T>
        SQLITEPP_ENABLE_IF(std::is_pointer_v<T> || std::is_null_pointer_v<T>,
        void) wal_hook(int (* handler)(type_identity_t<T> data_ptr, database * db, const char * db_name, int num_pages) noexcept, 
                       T data_ptr) noexcept
            { sqlite3_wal_hook(this->c_ptr(), (int(*)(void *,sqlite3*,const char*,int))(handler), data_ptr); }
 

        template<class T>
        SQLITEPP_ENABLE_IF((database_detector::is_pointer_to_throwing_callback<void, T, database *, const char *, int>),
        void) wal_hook(T handler_ptr) noexcept;

 
        //MARK: -
 
    #if defined(SQLITE_ENABLE_PREUPDATE_HOOK)
    #if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 16, 0)


        value * preupdate_old(int column_idx);

        value * preupdate_new(int column_idx);

        int preupdate_count() const noexcept
            { return sqlite3_preupdate_count(c_ptr()); }

        int preupdate_depth() const noexcept
            { return sqlite3_preupdate_depth(c_ptr()); }
 
 
    #endif
    #if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 36, 0)    
        int preupdate_blobwrite() const noexcept
            { return sqlite3_preupdate_blobwrite(c_ptr()); }
 
 
    #endif
    #endif
        

 
        //MARK: -


        std::pair<int, int> checkpoint(const string_param & db_name, int mode = SQLITE_CHECKPOINT_PASSIVE);

        void autocheckpoint(int num_frames)
            { check_error(sqlite3_wal_autocheckpoint(c_ptr(), num_frames)); }
 
        /* @} */
 
 
        
        //MARK: - create_collation

        
        template<class T>
        SQLITEPP_ENABLE_IF(std::is_pointer_v<T> || std::is_null_pointer_v<T>,
        void) create_collation(const string_param & name, int encoding,
                               T collator_ptr,
                               int (*compare)(type_identity_t<T> collator, int lhs_len, const void * lhs_bytes, int rhs_len, const void * rhs_bytes) noexcept,
                               void (*destructor)(type_identity_t<T> collator) noexcept);
        
        template<class T>
        SQLITEPP_ENABLE_IF((database_detector::is_pointer_to_callback<int, T, span<const std::byte>, span<const std::byte>>),
        void) create_collation(const string_param & name, int encoding, T collator_ptr,
                              void (*destructor)(type_identity_t<T> obj) noexcept = nullptr);

        
        //MARK: - create_function

        
        template<class T>
        SQLITEPP_ENABLE_IF(std::is_pointer_v<T> || std::is_null_pointer_v<T>,
        void) create_function(const char * name, int arg_count, int flags, T data_ptr,
                              void (*func)(context *, int, value **) noexcept,
                              void (*step)(context *, int, value **) noexcept,
                              void (*last)(context*) noexcept,
                              void (*destructor)(type_identity_t<T> data_ptr) noexcept);
        
        
        
        template<class T>
        SQLITEPP_ENABLE_IF(database_detector::is_pointer_to_function<T>,
        void) create_function(const char * name, int arg_count, int flags, 
                              T impl_ptr, void (*destructor)(type_identity_t<T> obj) noexcept = nullptr);
        
        //MARK: - create_window_function
 
#if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 25, 0)

        template<class T>
        SQLITEPP_ENABLE_IF(std::is_pointer_v<T> || std::is_null_pointer_v<T>,
        void) create_window_function(const char * name, int arg_count, int flags, T data_ptr,
                                     void (*step)(context *, int, value **) noexcept,
                                     void (*last)(context*) noexcept,
                                     void (*current)(context*) noexcept,
                                     void (*inverse)(context *, int, value **) noexcept,
                                     void (*destructor)(type_identity_t<T> data_ptr) noexcept);
        
        
        template<class T>
        SQLITEPP_ENABLE_IF(database_detector::is_pointer_to_window_function<T>,
        void) create_window_function(const char * name, int arg_count, int flags, 
                                     T impl_ptr, void (*destructor)(type_identity_t<T> obj) noexcept = nullptr);
#endif

        
        //MARK: -
#if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 10, 0) 
        void cacheflush()
        {
            if (int res = sqlite3_db_cacheflush(c_ptr()); res != SQLITE_OK)
                throw exception(res); //sic! sqlite3_db_cacheflush doesn't set DB error
        }
#endif
        template<int Code, class ...Args>
        auto config(Args && ...args) -> 
        #ifndef DOXYGEN
            //void but prevents instantiation with wrong types
            decltype(
              config_mapping<Code>::type::apply(*this, std::forward<decltype(args)>(args)...)
            )
        #else
            void
        #endif
            { config_mapping<Code>::type::apply(*this, std::forward<Args>(args)...); }
        
 
        //MARK: - create_module


        void create_module(const string_param & name, const sqlite3_module * mod)
            { check_error(sqlite3_create_module_v2(c_ptr(), name.c_str(), mod, nullptr, nullptr)); }

        template<typename T, typename D = void(*)(T *) noexcept>
        SQLITEPP_ENABLE_IF((std::is_convertible_v<D, void(*)(T *) noexcept>),
        void) create_module(const string_param & name, const sqlite3_module * mod, 
                           T * data, D destructor = nullptr)
            { check_error(sqlite3_create_module_v2(c_ptr(), name.c_str(), mod, (void*)data, (void (*)(void *))(void(*)(T *) noexcept)destructor)); }
 
        
        //MARK: -
        
        void declare_vtab(const string_param & sdl)
            { check_error(sqlite3_declare_vtab(c_ptr(), sdl.c_str())); }
 

        template<int Code, class ...Args>
        auto vtab_config(Args && ...args) -> 
        #ifndef DOXYGEN
            //void but prevents instantiation with wrong types
            decltype(
              vtab_config_mapping<Code>::type::apply(*this, std::forward<decltype(args)>(args)...)
            )
        #else
            void
        #endif
            { vtab_config_mapping<Code>::type::apply(*this, std::forward<Args>(args)...); }

        int vtab_on_conflict() const noexcept 
            { return sqlite3_vtab_on_conflict(c_ptr()); }
 
        //MARK: - drop_modules
#if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 30, 0)
        void drop_modules()
            { check_error(sqlite3_drop_modules(c_ptr(), nullptr)); }
                  
        void drop_modules_except(const char * const * keep)
            { check_error(sqlite3_drop_modules(c_ptr(), (const char **)keep)); }
        
              
        template<size_t N>
        SQLITEPP_ENABLE_IF(N > 0,
        void) drop_modules_except(const char * const (&keep)[N])
        {
            if (keep[N-1] != nullptr) throw exception(SQLITE_MISUSE);
            check_error(sqlite3_drop_modules(this->c_ptr(), (const char **)keep));
        }
          
        template<class ...Args>
        SQLITEPP_ENABLE_IF((std::conjunction_v<std::is_convertible<Args, string_param>...>),
        void) drop_modules_except(Args && ...args)
        {
            const char * buf[] = {string_param(std::forward<Args>(args)).c_str() ..., nullptr};
            check_error(sqlite3_drop_modules(this->c_ptr(), buf));
        }
#endif

        
        //MARK: -

        void extended_result_codes(bool onoff)
            { check_error(sqlite3_extended_result_codes(c_ptr(), onoff)); }
        
        
        void file_control(const string_param & db_name, int op, void * data)
            { check_error(sqlite3_file_control(c_ptr(), db_name.c_str(), op, data)); }
        
        const char * filename(const string_param & db_name) const noexcept
        {
            auto ret = sqlite3_db_filename(c_ptr(), db_name.c_str());
            return ret ? ret : "";
        }
        
        bool get_autocommit() const noexcept
            { return sqlite3_get_autocommit(c_ptr()); }
        
        void interrupt() noexcept
            { sqlite3_interrupt(c_ptr()); }
 
    #if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 41, 0)
        bool is_interrupted() noexcept
            { return sqlite3_is_interrupted(c_ptr()) != 0; }
    #endif
        
        int64_t last_insert_rowid() const noexcept
            { return sqlite3_last_insert_rowid(c_ptr()); }
        
#if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 18, 0)
        void set_last_insert_rowid(int64_t value) noexcept
            { sqlite3_set_last_insert_rowid(c_ptr(), value); }
#endif
        
        //returns -1 on bad limit or other issues
        int limit(int id, int new_val) noexcept
            { return sqlite3_limit(c_ptr(), id, new_val); }
 
 


        void enable_load_extension(bool val)
            { check_error(call_sqlite3_enable_load_extension(this->c_ptr(), val)); }
        
        
        void load_extension(const string_param & file, const string_param & proc = nullptr);
 
    #if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 8, 7)

        void auto_extension(void(*entry_point)(database *, const char **, const struct sqlite3_api_routines *))
            { check_error(sqlite3_auto_extension((void(*)(void))entry_point)); }

        void cancel_auto_extension(void(*entry_point)(database *, const char **, const struct sqlite3_api_routines *))
            { check_error(sqlite3_cancel_auto_extension((void(*)(void))entry_point)); }
 
    
        void reset_auto_extension() noexcept
            { sqlite3_reset_auto_extension(); }
    
    #endif

        
        class mutex * mutex() const noexcept
            { return (class mutex *)sqlite3_db_mutex(c_ptr()); }
        
        //MARK: - next_statement
        
        const class statement * next_statement(const class statement * prev) const noexcept
            { return (class statement *)sqlite3_next_stmt(c_ptr(), (sqlite3_stmt *)prev); }
        
        class statement * next_statement(const class statement * prev) noexcept
            { return (class statement *)sqlite3_next_stmt(c_ptr(), (sqlite3_stmt *)prev); }
        
        //MARK: -
        
        void overload_function(const string_param & name, int arg_count)
            { check_error(sqlite3_overload_function(c_ptr(), name.c_str(), arg_count)); }
        
        //MARK: - progress_handler

        template<class T>
        SQLITEPP_ENABLE_IF(std::is_pointer_v<T> || std::is_null_pointer_v<T>,
        void) progress_handler(int step_count, int(*handler)(type_identity_t<T> data_ptr) noexcept, T data_ptr) const noexcept
            { sqlite3_progress_handler(this->c_ptr(), step_count, (int(*)(void*))handler, data_ptr); }
        
        template<class T>
        SQLITEPP_ENABLE_IF((std::is_null_pointer_v<T> ||
            (std::is_pointer_v<T> && std::is_nothrow_invocable_r_v<bool, std::remove_pointer_t<T>>)),
        void) progress_handler(int step_count, T handler_ptr) const noexcept;
        
        //MARK: -
        std::optional<bool> readonly(const string_param & db_name) const noexcept;
        
        void release_memory() const
            { check_error(sqlite3_db_release_memory(c_ptr())); }
        
        //MARK: - status

        struct status
        {
            int current;
            int high;
        };
 
    #if  SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 51, 0)
        [[deprecated("use status64")]]
    #endif
        struct status status(int op, bool reset = false) const;
 
    #if  SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 51, 1)

        struct status64
        {
            sqlite3_int64 current;
            sqlite3_int64 high;
        };

        struct status64 status64(int op, bool reset = false) const;
 
    #endif
        
        //MARK: - table_column_metadata
        
        struct column_metadata
        {
            const char * data_type;             
            const char * collation_sequence;    
            bool not_null;                      
            bool primary_key;                   
            bool auto_increment;                
        };

        column_metadata table_column_metadata(const string_param & db_name, 
                                              const string_param & table_name, 
                                              const string_param & column_name) const;
        
        //MARK: -
        
        int64_t total_changes() const noexcept
        { 
        #if  SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 36, 1)
            return sqlite3_total_changes64(c_ptr()); 
        #else
            return sqlite3_total_changes(c_ptr()); 
        #endif
        }
        
#if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 34, 0)

        int txn_state(const string_param & schema) const noexcept
            { return sqlite3_txn_state(c_ptr(), schema.c_str()); }
#endif

        std::unique_ptr<blob> open_blob(const string_param & dbname, 
                                        const string_param & table,
                                        const string_param & column,
                                        int64_t rowid,
                                        bool writable);
 
#if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 39, 0)


        std::pair<allocated_bytes, size_t> serialize(const string_param & schema_name);

        span<std::byte> serialize_reference(const string_param & schema_name) noexcept;
 

        void deserialize(const string_param & schema_name, 
                         std::byte * buf, 
                         size_t size, 
                         size_t buf_size,
                         unsigned flags = 0)
            { check_error(sqlite3_deserialize(c_ptr(), schema_name.c_str(), (unsigned char *)buf, int64_size(size), int64_size(buf_size), flags)); }
        
        
        void deserialize(const string_param & schema_name, 
                         const std::byte * buf, 
                         size_t size, 
                         size_t buf_size,
                         unsigned flags = 0)
            { deserialize(schema_name, (std::byte *)buf, size, buf_size, flags | SQLITE_DESERIALIZE_READONLY); }
 

        void deserialize(const string_param & schema_name, 
                         allocated_bytes buf, 
                         size_t size, 
                         size_t buf_size,
                         unsigned flags = 0);
        
 

#endif

 
#if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 10, 0) && (THINSQLITEPP_ENABLE_EXPERIMENTAL || THINSQLITEPP_ENABLE_EXPIREMENTAL)
        std::unique_ptr<snapshot> get_snapshot(const string_param & schema);

        void open_snapshot(const string_param & schema, const snapshot & snap)
            { check_error(sqlite3_snapshot_open(c_ptr(), schema.c_str(), snap.c_ptr())); }

        void recover_snapshot(const string_param & db)
            { check_error(sqlite3_snapshot_recover(c_ptr(), db.c_str())); }
 
#endif

        
        
    #if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 39, 0)
        const char * db_name(int idx) noexcept
            { return sqlite3_db_name(c_ptr(), idx); }
 
    #endif
 
        //MARK: - Private methods
        
    private:
        void check_error(int res) const
        {
            if (res != SQLITE_OK)
                throw exception(res, this);
        }
 
        template<class T>
        static int call_sqlite3_enable_load_extension(T * db, int onoff)
        {
            if constexpr (database_detector::has_enable_load_extension<T>)
                return sqlite3_enable_load_extension(db, onoff);
            else
                return SQLITE_ERROR;
        }
 
        template<class T>
        static int call_sqlite3_load_extension(T * db, const char * file, const char * proc, char ** err)
        {
            if constexpr (database_detector::has_load_extension<T>)
                return sqlite3_load_extension(db, file, proc, err);
            else
                return SQLITE_ERROR;
        }
    };


    
 
    SQLITEPP_SUPPRESS_SILLY_VARARG_WARNING_BEGIN
 
    #if SQLITEPP_USE_VARARG_POUND_POUND_TRICK
 
        #define SQLITEPP_DEFINE_DB_OPTION(code, ...) \
            template<> struct database::config_mapping<code> { using type = database::config_option<code, ##__VA_ARGS__>; };
 
        //Idiotic GCC in pedantic mode warns on MACRO(arg) for MARCO(x,...) in < C++20 mode
        //with no way to disable the warning(!!!). 
        #define SQLITEPP_DEFINE_VTAB_OPTION_0(code) \
            template<> struct database::vtab_config_mapping<code> { using type = database::vtab_config_option<code>; };
        #define SQLITEPP_DEFINE_VTAB_OPTION_N(code, ...) \
            template<> struct database::vtab_config_mapping<code> { using type = database::vtab_config_option<code, ##__VA_ARGS__>; };
 
    #else
 
        #define SQLITEPP_DEFINE_DB_OPTION(code, ...) \
            template<> struct database::config_mapping<code> { using type = database::config_option<code __VA_OPT__(,) __VA_ARGS__>; };
 
        #define SQLITEPP_DEFINE_VTAB_OPTION_N(code, ...) \
            template<> struct database::vtab_config_mapping<code> { using type = database::vtab_config_option<code __VA_OPT__(,) __VA_ARGS__>; };
 
        #define SQLITEPP_DEFINE_VTAB_OPTION_0(code) SQLITEPP_DEFINE_VTAB_OPTION_N(code)
 
    #endif
 
 
    //@ [DB Options]
#ifdef SQLITE_DBCONFIG_MAINDBNAME
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_MAINDBNAME,              const char *);
#endif
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_LOOKASIDE,               void *, int, int);
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_ENABLE_FKEY,             int, int *);
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_ENABLE_TRIGGER,          int, int *);
#ifdef SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_ENABLE_FTS3_TOKENIZER,   int, int *);
#endif
#ifdef SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_ENABLE_LOAD_EXTENSION,   int, int *);
#endif
#ifdef SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_NO_CKPT_ON_CLOSE,        int, int *);
#endif
#ifdef SQLITE_DBCONFIG_ENABLE_QPSG
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_ENABLE_QPSG,             int, int *);
#endif
#ifdef SQLITE_DBCONFIG_TRIGGER_EQP
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_TRIGGER_EQP,             int, int *);
#endif
#ifdef SQLITE_DBCONFIG_RESET_DATABASE
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_RESET_DATABASE,          int, int *);
#endif
#ifdef SQLITE_DBCONFIG_DEFENSIVE
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_DEFENSIVE,               int, int *);
#endif
#ifdef SQLITE_DBCONFIG_WRITABLE_SCHEMA
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_WRITABLE_SCHEMA,         int, int *);
#endif
#ifdef SQLITE_DBCONFIG_LEGACY_ALTER_TABLE
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_LEGACY_ALTER_TABLE,      int, int *);
#endif
#ifdef SQLITE_DBCONFIG_ENABLE_VIEW
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_ENABLE_VIEW,             int, int *);
#endif
#ifdef SQLITE_DBCONFIG_LEGACY_FILE_FORMAT
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_LEGACY_FILE_FORMAT,      int, int *);
#endif
#ifdef SQLITE_DBCONFIG_TRUSTED_SCHEMA
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_TRUSTED_SCHEMA,          int, int *);
#endif
#ifdef SQLITE_DBCONFIG_STMT_SCANSTATUS
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_STMT_SCANSTATUS,         int, int *);
#endif
#ifdef SQLITE_DBCONFIG_REVERSE_SCANORDER
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_REVERSE_SCANORDER,       int, int *);
#endif
#ifdef SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_ENABLE_ATTACH_CREATE,    int, int *);
#endif
#ifdef SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_ENABLE_ATTACH_WRITE,     int, int *);
#endif
#ifdef SQLITE_DBCONFIG_ENABLE_COMMENTS
    SQLITEPP_DEFINE_DB_OPTION( SQLITE_DBCONFIG_ENABLE_COMMENTS,         int, int *);
#endif
    //@ [DB Options]
 
    //@ [VTab Options]
 
    SQLITEPP_DEFINE_VTAB_OPTION_N(SQLITE_VTAB_CONSTRAINT_SUPPORT,       int);
#ifdef SQLITE_VTAB_INNOCUOUS
    SQLITEPP_DEFINE_VTAB_OPTION_0(SQLITE_VTAB_INNOCUOUS                 );
#endif
#ifdef SQLITE_VTAB_DIRECTONLY
    SQLITEPP_DEFINE_VTAB_OPTION_0(SQLITE_VTAB_DIRECTONLY                );
#endif
#ifdef SQLITE_VTAB_USES_ALL_SCHEMAS
    SQLITEPP_DEFINE_VTAB_OPTION_0(SQLITE_VTAB_USES_ALL_SCHEMAS          );
#endif
 
    //@ [VTab Options]
 
    #undef SQLITEPP_DEFINE_DB_OPTION
    #undef SQLITEPP_DEFINE_VTAB_OPTION_0
    #undef SQLITEPP_DEFINE_VTAB_OPTION_N
 
    SQLITEPP_SUPPRESS_SILLY_VARARG_WARNING_END

}
 
#ifdef __GNUC__
    #pragma GCC diagnostic pop
#endif
 
#endif