vtable.hpp

//
// Copyright (c) 2022 Klemens Morgenstern (klemens.morgenstern@gmx.net)
//
// Distributed under the Boost Software License, Version 1.0. (See accompanying
// file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
//
 
#ifndef BOOST_SQLITE_VTABLE_HPP
#define BOOST_SQLITE_VTABLE_HPP
 
#include <boost/sqlite/detail/config.hpp>
#include <boost/sqlite/detail/catch.hpp>
#include <boost/sqlite/function.hpp>
 
#include <boost/core/span.hpp>
#include <boost/core/demangle.hpp>
 
#include <bitset>
 
BOOST_SQLITE_BEGIN_NAMESPACE
namespace detail
{
struct vtab_impl;
}
 
 
namespace vtab
{
 
struct function_setter
{
    template<typename Func>
    void set(Func & func)
    {
      set_impl(func, static_cast<callable_traits::args_t<Func>*>(nullptr));
    }
 
    template<typename ... Args, std::size_t Extent>
    void set(void(* ptr)(context<Args...>, span<value, Extent>)) noexcept
    {
      *ppArg_ = reinterpret_cast<void*>(ptr);
      *pxFunc_ =
          +[](sqlite3_context* ctx, int len, sqlite3_value** args)
          {
            auto cc = context<Args...>(ctx);
            auto aa =  reinterpret_cast<value*>(args);
            auto &f = *reinterpret_cast<void(*)(context<Args...>, span<value, Extent>)>(sqlite3_user_data(ctx));
            detail::execute_context_function(ctx, f, cc, boost::span<value, Extent>{aa, static_cast<std::size_t>(len)});
          };
    }
 
    template<typename T, typename ... Args,  std::size_t Extent>
    void set(T(* ptr)(context<Args...>, span<value, Extent>))
    {
      *ppArg_ = reinterpret_cast<void*>(ptr);
      *pxFunc_ =
          +[](sqlite3_context* ctx, int len, sqlite3_value** args) noexcept
          {
            auto cc = context<Args...>(ctx);
            auto aa =  reinterpret_cast<value*>(args);
            auto &f = *reinterpret_cast<T(*)(context<Args...>, span<value, Extent>)>(sqlite3_user_data(ctx));
            detail::execute_context_function(ctx, f, cc, boost::span<value, Extent>{aa, static_cast<std::size_t>(len)});
          };
    }
 
    template<std::size_t Extent>
    void set(void(* ptr)(span<value, Extent>))
    {
      *ppArg_ = reinterpret_cast<void*>(ptr);
      *pxFunc_ =
          +[](sqlite3_context* ctx, int len, sqlite3_value** args) noexcept
          {
            auto aa =  reinterpret_cast<value*>(args);
            auto &f = *reinterpret_cast<void(*)(span<value, Extent>)>(sqlite3_user_data(ctx));
            detail::execute_context_function(ctx, f, boost::span<value, Extent>{aa, static_cast<std::size_t>(len)});
          };
    }
 
    template<typename T, std::size_t Extent>
    void set(T(* ptr)(span<value, Extent>))
    {
      *ppArg_ = reinterpret_cast<void*>(ptr);
      *pxFunc_ =
          +[](sqlite3_context* ctx, int len, sqlite3_value** args) noexcept
          {
            auto aa =  reinterpret_cast<value*>(args);
            auto &f = *reinterpret_cast<T(*)(span<value, Extent>)>(sqlite3_user_data(ctx));
            detail::execute_context_function(ctx, f, boost::span<value, Extent>{aa, static_cast<std::size_t>(len)});
          };
    }
 
    explicit function_setter(void (**pxFunc)(sqlite3_context*,int,sqlite3_value**),
                             void **ppArg) : pxFunc_(pxFunc), ppArg_(ppArg) {}
  private:
 
    template<typename Func, typename ... Args, std::size_t Extent>
    void set_impl(Func & func, std::tuple<context<Args...>, span<value, Extent>>)
    {
      *ppArg_ = &func;
      *pxFunc_ =
          +[](sqlite3_context* ctx, int len, sqlite3_value** args) noexcept
          {
            auto cc = context<Args...>(ctx);
            auto aa =  reinterpret_cast<value*>(args);
            auto &f = *reinterpret_cast<Func*>(sqlite3_user_data(ctx));
            detail::execute_context_function(ctx, f, cc, boost::span<value, Extent>{aa, static_cast<std::size_t>(len)});
          };
    }
    template<typename Func, std::size_t Extent>
    void set_impl(Func & func, std::tuple<span<value, Extent>> * )
    {
      *ppArg_ = &func;
      *pxFunc_ =
          +[](sqlite3_context* ctx, int len, sqlite3_value** args) noexcept
          {
            auto aa =  reinterpret_cast<value*>(args);
            auto &f = *reinterpret_cast<Func *>(sqlite3_user_data(ctx));
            detail::execute_context_function(ctx, f, boost::span<value, Extent>{aa, static_cast<std::size_t>(len)});
          };
    }
 
    void (**pxFunc_)(sqlite3_context*,int,sqlite3_value**);
    void **ppArg_;
};
 
#if SQLITE_VERSION_NUMBER >= 3038000
struct in
{
    struct iterator
    {
        iterator() = default;
        explicit iterator(sqlite3_value * value ) : value_(value)
        {
            if (value == nullptr)
                return ;
            auto res = sqlite3_vtab_in_first(value, &out_.handle());
            if (res != SQLITE_OK)
            {
              system::error_code ec;
              BOOST_SQLITE_ASSIGN_EC(ec, res);
              detail::throw_error_code(ec, ec.location());
            }
        }
 
        iterator & operator++()
        {
          auto res = sqlite3_vtab_in_next(value_, &out_.handle());
          if (res != SQLITE_OK)
          {
            system::error_code ec;
            BOOST_SQLITE_ASSIGN_EC(ec, res);
            detail::throw_error_code(ec, ec.location());
          }
          return *this;
        }
 
        iterator operator++(int)
        {
            auto last = *this;
            ++(*this);
            return last;
        }
 
 
        const value & operator*() const
        {
            return out_;
        }
 
        const value * operator->() const
        {
            return &out_;
        }
 
        bool operator==(const iterator& other) const
        {
            return value_ == other.value_
                && out_.handle() == other.out_.handle();
        }
 
        bool operator!=(const iterator& other) const
        {
            return value_ != other.value_
                || out_.handle()   != other.out_.handle();
        }
 
 
      private:
        sqlite3_value * value_{nullptr};
        value out_{nullptr};
    };
 
    iterator begin() {return iterator(out_);}
    iterator end() {return iterator();}
 
    explicit in(sqlite3_value * out) : out_(out) {}
    explicit in(sqlite::value   out) : out_(out.handle()) {}
 private:
    sqlite3_value * out_{nullptr};
};
 
#endif
 
struct index_info
{
  BOOST_ATTRIBUTE_NODISCARD
  span<const sqlite3_index_info::sqlite3_index_constraint> constraints() const
  {
    return {info_->aConstraint, static_cast<std::size_t>(info_->nConstraint)};
  }
 
  BOOST_ATTRIBUTE_NODISCARD
  span<const sqlite3_index_info::sqlite3_index_orderby> order_by() const
  {
    return {info_->aOrderBy, static_cast<std::size_t>(info_->nOrderBy)};
  }
 
  BOOST_ATTRIBUTE_NODISCARD
  span<sqlite3_index_info::sqlite3_index_constraint_usage> usage()
  {
    return {info_->aConstraintUsage, static_cast<std::size_t>(info_->nConstraint)};
  }
 
  BOOST_ATTRIBUTE_NODISCARD
  sqlite3_index_info::sqlite3_index_constraint_usage & usage_of(
      const sqlite3_index_info::sqlite3_index_constraint & info)
  {
    auto dist = std::distance(constraints().begin(), &info);
    auto itr = usage().begin() + dist;
    BOOST_ASSERT(itr < usage().end());
    return *itr;
  }
 
#if SQLITE_VERSION_NUMBER >= 3022000
 
  const char * collation(std::size_t idx) const
  {
    return sqlite3_vtab_collation(info_, static_cast<int>(idx));
  }
#endif
 
  int on_conflict() const {return sqlite3_vtab_on_conflict(db_);}
 
#if SQLITE_VERSION_NUMBER >= 3038000
  bool   distinct() const {return sqlite3_vtab_distinct(info_);}
 
  value * rhs_value(std::size_t idx) const
  {
    value * v = nullptr;
    if (sqlite3_vtab_rhs_value(
          info_, static_cast<int>(idx),
          reinterpret_cast<sqlite3_value**>(v)) == SQLITE_OK)
      return v;
    else
      return nullptr;
  }
#endif
 
  void set_already_ordered() { info_->orderByConsumed = 1; }
  void set_estimated_cost(double cost) { info_->estimatedCost = cost; }
#if SQLITE_VERSION_NUMBER >= 3008200
  void set_estimated_rows(sqlite3_int64 rows) { info_->estimatedRows = rows; }
#endif
#if SQLITE_VERSION_NUMBER >= 3009000
  void set_index_scan_flags(int flags) { info_->idxFlags = flags; }
#endif
#if SQLITE_VERSION_NUMBER >= 3010000
  std::bitset<64u> columns_used()
  {
    return std::bitset<64u>(info_->colUsed);
  }
#endif
 
  void set_index(int value) { info_->idxNum = value; }
  void set_index_string(char * str,
                        bool take_ownership = true)
  {
    info_->idxStr = str;
    info_->needToFreeIdxStr = take_ownership ? 1 : 0;
  }
 
  sqlite3_index_info * info() const { return info_; }
  sqlite3 * db() const { return db_; }
 
 private:
  explicit index_info(sqlite3 * db, sqlite3_index_info * info) : db_(db), info_(info) {}
  sqlite3 * db_;
  sqlite3_index_info * info_{nullptr};
  friend struct detail::vtab_impl;
};
 
 
struct module_config
{
#if SQLITE_VERSION_NUMBER >= 3031000
  void set_innocuous()
  {
    sqlite3_vtab_config(db_, SQLITE_VTAB_INNOCUOUS);
  }
  void set_directonly() {sqlite3_vtab_config(db_, SQLITE_VTAB_DIRECTONLY);}
 
#endif
 
  void set_constraint_support(bool enabled = false)
  {
    sqlite3_vtab_config(db_, SQLITE_VTAB_CONSTRAINT_SUPPORT, enabled ? 1 : 0);
  }
 
 private:
  explicit module_config(sqlite3 *db) : db_(db) {}
  friend struct detail::vtab_impl;
  sqlite3 *db_;
};
 
template<typename Table>
struct module
{
  using table_type = Table;
 
  BOOST_SQLITE_VIRTUAL result<table_type> create(sqlite::connection db, int argc, const char * const argv[]) BOOST_SQLITE_PURE;
 
  BOOST_SQLITE_VIRTUAL result<table_type> connect(sqlite::connection db, int argc, const char * const argv[]) BOOST_SQLITE_PURE;
};
 
template<typename Table>
struct eponymous_module
{
  using table_type = Table;
 
  BOOST_SQLITE_VIRTUAL result<table_type> connect(sqlite::connection db, int argc, const char * const argv[]) BOOST_SQLITE_PURE;
 
  eponymous_module(bool eponymous_only = false) : eponymous_only_(eponymous_only) {}
 
  bool eponymous_only() const {return eponymous_only_;}
 protected:
  bool eponymous_only_{false};
 
};
 
template<typename ColumnType>
struct cursor;
 
template<typename Cursor>
struct table : protected sqlite3_vtab
{
  using cursor_type = Cursor;
 
  BOOST_SQLITE_VIRTUAL result<void> config(module_config &) {return {};}
 
  BOOST_SQLITE_VIRTUAL const char *declaration() BOOST_SQLITE_PURE;
 
  BOOST_SQLITE_VIRTUAL result<void> destroy() { return {}; }
 
  BOOST_SQLITE_VIRTUAL result<void> best_index(index_info & info) {return {system::in_place_error, SQLITE_OK};}
 
  BOOST_SQLITE_VIRTUAL result<cursor_type> open() BOOST_SQLITE_PURE;
 
  sqlite::connection connection() const {return sqlite::connection{db_, false};}
 
  table(const sqlite::connection & conn) : db_(conn.handle()) {}
  table(sqlite3  * db = nullptr) : db_(db) {}
 private:
  template<typename ColumnType>
  friend struct cursor;
  friend struct detail::vtab_impl;
 
  sqlite3 * db_{nullptr};
};
 
template<typename ColumnType = void>
struct cursor : protected sqlite3_vtab_cursor
{
  using column_type = ColumnType;
 
  BOOST_SQLITE_VIRTUAL result<void> filter(
        int index, const char * index_data,
        boost::span<sqlite::value> values)
  {
    return {system::in_place_error, SQLITE_OK};
  }
 
  BOOST_SQLITE_VIRTUAL result<void> next() BOOST_SQLITE_PURE;
 
  BOOST_SQLITE_VIRTUAL bool eof() BOOST_SQLITE_PURE;
 
  BOOST_SQLITE_VIRTUAL result<column_type> column(int idx, bool no_change) BOOST_SQLITE_PURE;
  BOOST_SQLITE_VIRTUAL result<sqlite3_int64> row_id() BOOST_SQLITE_PURE;
 
        vtab::table<cursor> & table()       { return *static_cast<      vtab::table<cursor>*>(this->pVtab);}
  const vtab::table<cursor> & table() const { return *static_cast<const vtab::table<cursor>*>(this->pVtab);}
 
  friend struct detail::vtab_impl;
};
 
template<>
struct cursor<void> : protected sqlite3_vtab_cursor
{
  using column_type = void;
 
  BOOST_SQLITE_VIRTUAL result<void> filter(
      int index, const char * index_data,
      boost::span<sqlite::value> values)
  {
    return {system::in_place_error, SQLITE_OK};
  }
 
  BOOST_SQLITE_VIRTUAL result<void> next() BOOST_SQLITE_PURE;
 
  BOOST_SQLITE_VIRTUAL bool eof() BOOST_SQLITE_PURE;
 
  BOOST_SQLITE_VIRTUAL void column(context<> ctx, int idx, bool no_change) BOOST_SQLITE_PURE;
  BOOST_SQLITE_VIRTUAL result<sqlite3_int64> row_id() BOOST_SQLITE_PURE;
 
  vtab::table<cursor>       & table()       { return *static_cast<      vtab::table<cursor>*>(this->pVtab);}
  const vtab::table<cursor> & table() const { return *static_cast<const vtab::table<cursor>*>(this->pVtab);}
 
  friend struct detail::vtab_impl;
};
 
 
struct modifiable
{
  BOOST_SQLITE_VIRTUAL result<void> delete_(sqlite::value key) BOOST_SQLITE_PURE;
  BOOST_SQLITE_VIRTUAL result<sqlite_int64> insert(sqlite::value key, span<sqlite::value> values, int on_conflict) BOOST_SQLITE_PURE;
  BOOST_SQLITE_VIRTUAL result<sqlite_int64> update(sqlite::value old_key, sqlite::value new_key, span<sqlite::value> values, int on_conflict) BOOST_SQLITE_PURE;
};
 
struct transaction
{
  BOOST_SQLITE_VIRTUAL result<void> begin()    BOOST_SQLITE_PURE;
  BOOST_SQLITE_VIRTUAL result<void> sync()     BOOST_SQLITE_PURE;
  BOOST_SQLITE_VIRTUAL result<void> commit()   BOOST_SQLITE_PURE;
  BOOST_SQLITE_VIRTUAL result<void> rollback() BOOST_SQLITE_PURE;
};
 
struct overload_functions
{
  BOOST_SQLITE_VIRTUAL result<void> find_function(
          function_setter fs,
          int arg, const char * name) BOOST_SQLITE_PURE;
};
 
struct renamable
{
  BOOST_SQLITE_VIRTUAL result<void> rename(const char * new_name) BOOST_SQLITE_PURE;
 
};
 
#if SQLITE_VERSION_NUMBER >= 3007007
struct recursive_transaction
{
  BOOST_SQLITE_VIRTUAL result<void> savepoint(int i)   BOOST_SQLITE_PURE;
  BOOST_SQLITE_VIRTUAL result<void> release(int i)     BOOST_SQLITE_PURE;
  BOOST_SQLITE_VIRTUAL result<void> rollback_to(int i) BOOST_SQLITE_PURE;
};
#endif
 
}
 
 
namespace detail
{
 
template<typename Module>
const sqlite3_module make_module(const Module & mod);
 
}
 
 
template<typename T>
auto create_module(connection & conn,
                   cstring_ref name,
                   T && module,
                   system::error_code & ec,
                   error_info & ei) -> typename std::decay<T>::type &
{
    using module_type = typename std::decay<T>::type;
    static const sqlite3_module mod = detail::make_module(module);
 
    std::unique_ptr<module_type> p{new (memory_tag{}) module_type(std::forward<T>(module))};
    auto pp = p.get();
 
    int res = sqlite3_create_module_v2(
                             conn.handle(), name.c_str(),
                             &mod, p.release(),
                             +[](void * ptr)
                             {
                               static_cast<module_type*>(ptr)->~module_type();
                               sqlite3_free(ptr);
                             });
 
    if (res != SQLITE_OK)
    {
       BOOST_SQLITE_ASSIGN_EC(ec, res);
       ei.set_message(sqlite3_errmsg(conn.handle()));
    }
    return *pp;
}
 
template<typename T>
auto create_module(connection & conn,
                   const char * name,
                   T && module)  -> typename std::decay<T>::type &
{
    system::error_code ec;
    error_info ei;
    T & ref = create_module(conn, name, std::forward<T>(module), ec, ei);
    if (ec)
        detail::throw_error_code(ec, ei);
    return ref;
}
 
 
BOOST_SQLITE_END_NAMESPACE
 
#include <boost/sqlite/detail/vtable.hpp>
 
#endif //BOOST_SQLITE_VTABLE_HPP