vtab_iface.hpp

/*
 Copyright 2024 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_VTAB_IFACE_INCLUDED
#define HEADER_SQLITEPP_VTAB_IFACE_INCLUDED
 
#include "database_iface.hpp"
#include "exception_iface.hpp"
#include "value_iface.hpp"
#include "context_iface.hpp"
#include "memory_iface.hpp"
#include "span.hpp"
 
#include <type_traits>
#include <string.h>
#include <cstdint>
 
namespace thinsqlitepp {


    SQLITEPP_EXPORTED
    template<class T = void>
    class index_info : public handle<sqlite3_index_info, index_info<T>>
    {
        static_assert(std::is_void_v<T> || (std::is_pointer_v<T> && std::is_trivially_destructible_v<T>),
                     "template argument must be void or a pointer to a trivially destructible type");
    public:
        using constraint = sqlite3_index_info::sqlite3_index_constraint;
        using constraint_usage = sqlite3_index_info::sqlite3_index_constraint_usage;
        using orderby = sqlite3_index_info::sqlite3_index_orderby;
    public:
        ~index_info() = delete;

        span<const constraint> constraints() const noexcept
            { return { this->c_ptr()->aConstraint, size_t(this->c_ptr()->nConstraint)}; };

        span<const orderby> orderbys() const noexcept
            { return { this->c_ptr()->aOrderBy, size_t(this->c_ptr()->nOrderBy)}; };
 
        #if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 10, 0)

            uint64_t columns_used() const noexcept
                { return uint64_t(this->c_ptr()->colUsed); }
 
        #endif

        const char * collation(int constraint_idx) const noexcept
            { return sqlite3_vtab_collation(this->c_ptr(), constraint_idx); }

        int distinct() const noexcept 
            { return sqlite3_vtab_distinct(this->c_ptr()); }
 
        #if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 38, 0)

            bool is_in(int constraint_idx) const noexcept 
                { return sqlite3_vtab_in(this->c_ptr(), constraint_idx, -1); }

            void handle_in(int constraint_idx, bool handle) const noexcept 
                { sqlite3_vtab_in(this->c_ptr(), constraint_idx, handle); }
 
         #endif
 
        
        span<const constraint_usage> constraints_usage() const noexcept
            { return { this->c_ptr()->aConstraintUsage, size_t(this->c_ptr()->nConstraint)}; }

        span<constraint_usage> constraints_usage() noexcept
            { return { this->c_ptr()->aConstraintUsage, size_t(this->c_ptr()->nConstraint)}; }

        int index_number() const noexcept
            { return this->c_ptr()->idxNum; }

        void set_index_number(int val) noexcept
            { this->c_ptr()->idxNum = val; }

        T index_data() const noexcept
            { return (T)this->c_ptr()->idxStr; }

        template<class X>
        SQLITEPP_ENABLE_IF((std::is_convertible_v<X *, T>),
        void) set_index_data(X * data, bool allocated = false) noexcept
        {
            this->c_ptr()->idxStr = (char *)data;
            this->c_ptr()->needToFreeIdxStr = allocated;
        }

        template<class X>
        SQLITEPP_ENABLE_IF((std::is_convertible_v<X *, T> && std::is_trivially_destructible_v<X>),
        void) set_index_data(std::unique_ptr<X, sqlite_deleter<X>> data) noexcept
            { set_index_data(data.release(), true); }

        template<class X>
        SQLITEPP_ENABLE_IF((
            std::is_convertible_v<X *, T> &&
            std::is_trivially_destructible_v<X> &&
            std::is_base_of_v<sqlite_allocated, X>),
        void) set_index_data(std::unique_ptr<X> data) noexcept
            { set_index_data(data.release(), true); }

        bool order_by_consumed() const noexcept
            { return this->c_ptr()->orderByConsumed != 0; }

        void set_order_by_consumed(bool val) noexcept
            { this->c_ptr()->orderByConsumed = val; }

        double estimated_cost() const noexcept
            { return this->c_ptr()->estimatedCost; }

        void set_estimated_cost(double val) noexcept
            { this->c_ptr()->estimatedCost = val; }
 
        #if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 8, 2)

            int64_t estimated_rows() const noexcept
                { return int64_t(this->c_ptr()->estimatedRows); }

            void set_estimated_rows(int64_t val) noexcept
                { this->c_ptr()->estimatedRows = sqlite3_int64(val); }
 
        #endif
 
        #if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 9, 0)

            int index_flags() const noexcept
                { return this->c_ptr()->idxFlags; }

            void set_index_flags(int val) noexcept
                { this->c_ptr()->idxFlags = val; }
 
        #endif
 
    };



    SQLITEPP_EXPORTED
    template<class Derived>
    class vtab : private sqlite3_vtab
    {
    public:
        using constructor_data_type = void;

        using index_data_type = void;

        class cursor : private sqlite3_vtab_cursor
        {
        friend vtab;
        public:
            cursor(cursor &) = delete;
            cursor & operator=(cursor &) = delete;

            sqlite3_vtab_cursor * c_ptr() const noexcept
                { return const_cast<cursor *>(this); }

            template<class D=Derived> //defer resolution of nested data types
            SQLITEPP_ENABLE_IF((std::is_pointer_v<typename D::index_data_type>),
            void) filter([[maybe_unused]] int idx, 
                         [[maybe_unused]] typename D::index_data_type idx_data, 
                         [[maybe_unused]] int argc, 
                         [[maybe_unused]] value ** argv)
            {
                static_assert(std::is_same_v<D, Derived>, "please invoke this function only with default template parameter");
            }

            template<class D=Derived> //defer resolution of nested data types
            SQLITEPP_ENABLE_IF((std::is_void_v<typename D::index_data_type>),
            void) filter([[maybe_unused]] int idx, 
                         [[maybe_unused]] int argc, 
                         [[maybe_unused]] value ** argv)
            {
                static_assert(std::is_same_v<D, Derived>, "please invoke this function only with default template parameter");
            }

            bool eof() const noexcept
                { return true; }

            void next()
                { throw exception(SQLITE_INTERNAL, error::message_ptr("cursor::next is not implemented")); }

            void column(context & ctxt, [[maybe_unused]] int idx) const
                { ctxt.result(nullptr); }

            sqlite_int64 rowid() const
                { throw exception(SQLITE_INTERNAL, error::message_ptr("cursor::rowid is not implemented")); }
        protected:
            cursor(Derived * owner):
                sqlite3_vtab_cursor{owner}
            {}
            ~cursor()
            {}

            Derived * owner() const noexcept
                { return static_cast<Derived *>(this->pVtab); }
        };
    public:
        struct create_t {};

        struct connect_t {};
    public:
        static void create_module(database & db, const string_param & name)
        {
            db.create_module(name, vtab::get_module());
        }

        template<class D=Derived>
        SQLITEPP_ENABLE_IFP(
        static,
            (std::is_pointer_v<typename D::constructor_data_type>),
        void) create_module(database & db,
                            const string_param & name, 
                            typename D::constructor_data_type data, 
                            void(*destructor)(typename D::constructor_data_type) noexcept = nullptr)
        {
            static_assert(std::is_same_v<D, Derived>, "please invoke this function only with default template parameter");
            db.create_module(name, vtab::get_module(), data, destructor);
        }

        template<class D=Derived> 
        SQLITEPP_ENABLE_IFP(
        static,
            (std::is_pointer_v<typename D::constructor_data_type>),
        void) create_module(database & db,
                            const string_param & name, 
                            std::unique_ptr<std::remove_pointer_t<typename D::constructor_data_type>> data)
        {
            static_assert(std::is_same_v<D, Derived>, "please invoke this function only with default template parameter");
            db.create_module(name, vtab::get_module(), data.release(), [](typename D::constructor_data_type ptr) noexcept {
                delete ptr;
            });
        }

        template<class D=Derived> 
        bool best_index(index_info<typename D::index_data_type> & info) const
        {
            static_assert(std::is_same_v<D, Derived>, "please invoke this function only with default template parameter");
            info.set_estimated_cost(0);
            return true;
        }

        template<class D=Derived>
        std::unique_ptr<typename D::cursor> open()
        {
            static_assert(std::is_same_v<D, Derived>, "please invoke this function only with default template parameter");
            return std::unique_ptr<typename D::cursor>(
                        new typename D::cursor(static_cast<D *>(this))
                   );
        }
 
        static sqlite3_module * get_module();
 
    protected:
        vtab():
            sqlite3_vtab{nullptr, 0, nullptr}
        {}

        vtab(const vtab &) = delete;
        vtab & operator=(const vtab &) = delete;
        ~vtab()
        {}
 
 
    private:
        void set_error_message(error & err) const
        {
            auto me = const_cast<vtab *>(this);
            if (me->zErrMsg)
                sqlite3_free(me->zErrMsg);
            auto message = err.extract_message();
            me->zErrMsg = (char *)message.release();
        }
 
        void set_error_message(exception & ex) const
            { set_error_message(ex.error()); }
 
        void set_error_message(std::exception & ex) const
        {
            auto me = const_cast<vtab *>(this);
            if (me->zErrMsg)
            {
                sqlite3_free(me->zErrMsg);
                me->zErrMsg = nullptr;
            }
            auto message = ex.what();
            const auto len = strlen(message) + 1;
            if (char * const ret = (char *)sqlite_allocate_nothrow(len))
            {
                memcpy(ret, message, len);
                me->zErrMsg = ret;
            }
        }
 
        static constexpr void check_requirements();
 
        #define SQLITEPP_DECLARE_IMPL(xname, name) \
            static std::remove_pointer_t<decltype(sqlite3_module::xname)> name##_impl
        #define SQLITEPP_DECLARE_CONDITIONAL_IMPL(xname, name) \
            SQLITEPP_DECLARE_IMPL(xname, name); \
            static constexpr decltype(sqlite3_module::xname) get_##name##_impl()
 
        SQLITEPP_DECLARE_CONDITIONAL_IMPL(xCreate, create);
        SQLITEPP_DECLARE_CONDITIONAL_IMPL(xConnect, connect);
        SQLITEPP_DECLARE_IMPL(xBestIndex, best_index);
        SQLITEPP_DECLARE_IMPL(xDisconnect, disconnect);
        SQLITEPP_DECLARE_IMPL(xDestroy, destroy);
        SQLITEPP_DECLARE_IMPL(xOpen, open);
        SQLITEPP_DECLARE_IMPL(xClose, close);
        SQLITEPP_DECLARE_IMPL(xEof, eof);
        SQLITEPP_DECLARE_IMPL(xFilter, filter);
        SQLITEPP_DECLARE_IMPL(xNext, next);
        SQLITEPP_DECLARE_IMPL(xColumn, column);
        SQLITEPP_DECLARE_IMPL(xRowid, rowid);
        SQLITEPP_DECLARE_CONDITIONAL_IMPL(xUpdate, update);
        SQLITEPP_DECLARE_CONDITIONAL_IMPL(xFindFunction, find_function);
        SQLITEPP_DECLARE_CONDITIONAL_IMPL(xBegin, begin);
        SQLITEPP_DECLARE_CONDITIONAL_IMPL(xSync, sync);
        SQLITEPP_DECLARE_CONDITIONAL_IMPL(xCommit, commit);
        SQLITEPP_DECLARE_CONDITIONAL_IMPL(xRollback, rollback);
        SQLITEPP_DECLARE_CONDITIONAL_IMPL(xRename, rename);
        SQLITEPP_DECLARE_CONDITIONAL_IMPL(xSavepoint, savepoint);
        SQLITEPP_DECLARE_CONDITIONAL_IMPL(xRelease, release);
        SQLITEPP_DECLARE_CONDITIONAL_IMPL(xRollbackTo, rollback_to);
 
        #if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 26, 0)
 
            SQLITEPP_DECLARE_CONDITIONAL_IMPL(xShadowName, shadow_name);
 
        #endif
 
        #if SQLITE_VERSION_NUMBER >= SQLITEPP_SQLITE_VERSION(3, 44, 0)
 
            SQLITEPP_DECLARE_CONDITIONAL_IMPL(xIntegrity, integrity);
 
        #endif
 
        #undef SQLITEPP_DECLARE_IMPL
        #undef SQLITEPP_DECLARE_CONDITIONAL_IMPL
 
    };

 
}
 
 
#endif