summaryrefslogtreecommitdiffstats
path: root/src/vtab_module.hh
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--src/vtab_module.hh929
1 files changed, 929 insertions, 0 deletions
diff --git a/src/vtab_module.hh b/src/vtab_module.hh
new file mode 100644
index 0000000..a45594c
--- /dev/null
+++ b/src/vtab_module.hh
@@ -0,0 +1,929 @@
+/**
+ * Copyright (c) 2017, Timothy Stack
+ *
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ * list of conditions and the following disclaimer.
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ * this list of conditions and the following disclaimer in the documentation
+ * and/or other materials provided with the distribution.
+ * * Neither the name of Timothy Stack nor the names of its contributors
+ * may be used to endorse or promote products derived from this software
+ * without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ''AS IS'' AND ANY
+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+ * DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef vtab_module_hh
+#define vtab_module_hh
+
+#include <string>
+#include <utility>
+#include <vector>
+
+#include <sqlite3.h>
+
+#include "base/auto_mem.hh"
+#include "base/intern_string.hh"
+#include "base/lnav.console.hh"
+#include "base/lnav_log.hh"
+#include "base/string_util.hh"
+#include "fmt/format.h"
+#include "help_text_formatter.hh"
+#include "mapbox/variant.hpp"
+#include "optional.hpp"
+#include "shlex.resolver.hh"
+#include "sqlite-extension-func.hh"
+
+lnav::console::user_message sqlite3_error_to_user_message(sqlite3*);
+
+struct from_sqlite_conversion_error : std::exception {
+ from_sqlite_conversion_error(const char* type, int argi)
+ : e_type(type), e_argi(argi)
+ {
+ }
+
+ const char* e_type;
+ int e_argi;
+};
+
+struct sqlite_func_error : std::exception {
+ template<typename... Args>
+ explicit sqlite_func_error(fmt::string_view format_str, const Args&... args)
+ : e_what(fmt::vformat(format_str, fmt::make_format_args(args...)))
+ {
+ }
+
+ const char* what() const noexcept override
+ {
+ return this->e_what.c_str();
+ }
+
+ const std::string e_what;
+};
+
+namespace vtab_types {
+
+template<typename T>
+struct nullable {
+ T* n_value{nullptr};
+};
+
+template<typename>
+struct is_nullable : std::false_type {
+};
+
+template<typename T>
+struct is_nullable<nullable<T>> : std::true_type {
+};
+
+} // namespace vtab_types
+
+template<typename T>
+struct from_sqlite {
+ using U = typename std::remove_reference<T>::type;
+
+ inline U operator()(int argc, sqlite3_value** val, int argi)
+ {
+ return U();
+ };
+};
+
+template<>
+struct from_sqlite<bool> {
+ inline bool operator()(int argc, sqlite3_value** val, int argi)
+ {
+ if (sqlite3_value_numeric_type(val[argi]) != SQLITE_INTEGER) {
+ throw from_sqlite_conversion_error("integer", argi);
+ }
+
+ return sqlite3_value_int64(val[argi]);
+ }
+};
+
+template<>
+struct from_sqlite<int64_t> {
+ inline int64_t operator()(int argc, sqlite3_value** val, int argi)
+ {
+ if (sqlite3_value_numeric_type(val[argi]) != SQLITE_INTEGER) {
+ throw from_sqlite_conversion_error("integer", argi);
+ }
+
+ return sqlite3_value_int64(val[argi]);
+ }
+};
+
+template<>
+struct from_sqlite<sqlite3_value*> {
+ inline sqlite3_value* operator()(int argc, sqlite3_value** val, int argi)
+ {
+ return val[argi];
+ }
+};
+
+template<>
+struct from_sqlite<int> {
+ inline int operator()(int argc, sqlite3_value** val, int argi)
+ {
+ if (sqlite3_value_numeric_type(val[argi]) != SQLITE_INTEGER) {
+ throw from_sqlite_conversion_error("integer", argi);
+ }
+
+ return sqlite3_value_int(val[argi]);
+ }
+};
+
+template<>
+struct from_sqlite<const char*> {
+ inline const char* operator()(int argc, sqlite3_value** val, int argi)
+ {
+ return (const char*) sqlite3_value_text(val[argi]);
+ }
+};
+
+template<>
+struct from_sqlite<string_fragment> {
+ inline string_fragment operator()(int argc, sqlite3_value** val, int argi)
+ {
+ return string_fragment::from_bytes(
+ (const char*) sqlite3_value_blob(val[argi]),
+ sqlite3_value_bytes(val[argi]));
+ }
+};
+
+template<>
+struct from_sqlite<std::string> {
+ inline std::string operator()(int argc, sqlite3_value** val, int argi)
+ {
+ return {
+ (const char*) sqlite3_value_blob(val[argi]),
+ (size_t) sqlite3_value_bytes(val[argi]),
+ };
+ }
+};
+
+template<>
+struct from_sqlite<double> {
+ inline double operator()(int argc, sqlite3_value** val, int argi)
+ {
+ return sqlite3_value_double(val[argi]);
+ }
+};
+
+template<typename T>
+struct from_sqlite<nonstd::optional<T>> {
+ inline nonstd::optional<T> operator()(int argc,
+ sqlite3_value** val,
+ int argi)
+ {
+ if (argi >= argc || sqlite3_value_type(val[argi]) == SQLITE_NULL) {
+ return nonstd::nullopt;
+ }
+
+ return nonstd::optional<T>(from_sqlite<T>()(argc, val, argi));
+ }
+};
+
+template<typename T>
+struct from_sqlite<const std::vector<T>&> {
+ inline std::vector<T> operator()(int argc, sqlite3_value** val, int argi)
+ {
+ std::vector<T> retval;
+
+ for (int lpc = argi; lpc < argc; lpc++) {
+ retval.emplace_back(from_sqlite<T>()(argc, val, lpc));
+ }
+
+ return retval;
+ }
+};
+
+template<typename T>
+struct from_sqlite<vtab_types::nullable<T>> {
+ inline vtab_types::nullable<T> operator()(int argc,
+ sqlite3_value** val,
+ int argi)
+ {
+ return {from_sqlite<T*>()(argc, val, argi)};
+ }
+};
+
+void to_sqlite(sqlite3_context* ctx, const lnav::console::user_message& um);
+
+inline void
+to_sqlite(sqlite3_context* ctx, null_value_t)
+{
+ sqlite3_result_null(ctx);
+}
+
+inline void
+to_sqlite(sqlite3_context* ctx, const char* str)
+{
+ if (str == nullptr) {
+ sqlite3_result_null(ctx);
+ } else {
+ sqlite3_result_text(ctx, str, -1, SQLITE_STATIC);
+ }
+}
+
+inline void
+to_sqlite(sqlite3_context* ctx, text_auto_buffer buf)
+{
+ auto pair = buf.inner.release();
+ sqlite3_result_text(ctx, pair.first, pair.second, free);
+}
+
+inline void
+to_sqlite(sqlite3_context* ctx, blob_auto_buffer buf)
+{
+ auto pair = buf.inner.release();
+ sqlite3_result_blob(ctx, pair.first, pair.second, free);
+}
+
+inline void
+to_sqlite(sqlite3_context* ctx, const std::string& str)
+{
+ sqlite3_result_text(ctx, str.c_str(), str.length(), SQLITE_TRANSIENT);
+}
+
+inline void
+to_sqlite(sqlite3_context* ctx, const string_fragment& sf)
+{
+ if (sf.is_valid()) {
+ sqlite3_result_text(
+ ctx, &sf.sf_string[sf.sf_begin], sf.length(), SQLITE_TRANSIENT);
+ } else {
+ sqlite3_result_null(ctx);
+ }
+}
+
+inline void
+to_sqlite(sqlite3_context* ctx, bool val)
+{
+ sqlite3_result_int(ctx, val);
+}
+
+template<typename T>
+inline void
+to_sqlite(sqlite3_context* ctx,
+ T val,
+ typename std::enable_if<std::is_integral<T>::value
+ && !std::is_same<T, bool>::value>::type* dummy
+ = 0)
+{
+ sqlite3_result_int64(ctx, val);
+}
+
+inline void
+to_sqlite(sqlite3_context* ctx, double val)
+{
+ sqlite3_result_double(ctx, val);
+}
+
+inline void
+to_sqlite(sqlite3_context* ctx, auto_mem<char> str)
+{
+ auto free_func = str.get_free_func<void(*)(void*)>();
+ sqlite3_result_text(ctx, str.release(), -1, free_func);
+}
+
+#define JSON_SUBTYPE 74 /* Ascii for "J" */
+#define FLATTEN_SUBTYPE 0x5f
+
+template<typename T>
+inline void
+to_sqlite(sqlite3_context* ctx, nonstd::optional<T>& val)
+{
+ if (val.has_value()) {
+ to_sqlite(ctx, val.value());
+ } else {
+ sqlite3_result_null(ctx);
+ }
+}
+
+template<typename T>
+inline void
+to_sqlite(sqlite3_context* ctx, nonstd::optional<T> val)
+{
+ if (val.has_value()) {
+ to_sqlite(ctx, std::move(val.value()));
+ } else {
+ sqlite3_result_null(ctx);
+ }
+}
+
+struct ToSqliteVisitor {
+ ToSqliteVisitor(sqlite3_context* vctx) : tsv_context(vctx) {}
+
+ template<typename T>
+ void operator()(T&& t) const
+ {
+ to_sqlite(this->tsv_context, std::move(t));
+ }
+
+ sqlite3_context* tsv_context;
+};
+
+template<typename... Types>
+void
+to_sqlite(sqlite3_context* ctx, mapbox::util::variant<Types...>&& val)
+{
+ ToSqliteVisitor visitor(ctx);
+
+ mapbox::util::apply_visitor(visitor, val);
+}
+
+template<typename... Args>
+struct optional_counter {
+ constexpr static int value = 0;
+};
+
+template<typename T>
+struct optional_counter<nonstd::optional<T>> {
+ constexpr static int value = 1;
+};
+
+template<typename T, typename U>
+struct optional_counter<nonstd::optional<T>, const std::vector<U>&> {
+ constexpr static int value = 1;
+};
+
+template<typename T, typename... Rest>
+struct optional_counter<nonstd::optional<T>, Rest...> {
+ constexpr static int value = 1 + sizeof...(Rest);
+};
+
+template<typename Arg>
+struct optional_counter<Arg> {
+ constexpr static int value = 0;
+};
+
+template<typename Arg1, typename... Args>
+struct optional_counter<Arg1, Args...> : optional_counter<Args...> {
+};
+
+template<typename... Args>
+struct variadic_counter {
+ constexpr static int value = 0;
+};
+
+template<typename T>
+struct variadic_counter<const std::vector<T>&> {
+ constexpr static int value = 1;
+};
+
+template<typename Arg>
+struct variadic_counter<Arg> {
+ constexpr static int value = 0;
+};
+
+template<typename Arg1, typename... Args>
+struct variadic_counter<Arg1, Args...> : variadic_counter<Args...> {
+};
+
+template<typename F, F f>
+struct sqlite_func_adapter;
+
+template<typename Return, typename... Args, Return (*f)(Args...)>
+struct sqlite_func_adapter<Return (*)(Args...), f> {
+ constexpr static size_t OPT_COUNT = optional_counter<Args...>::value;
+ constexpr static size_t VAR_COUNT = variadic_counter<Args...>::value;
+ constexpr static size_t REQ_COUNT = sizeof...(Args) - OPT_COUNT - VAR_COUNT;
+
+ template<size_t... Idx>
+ static void func2(sqlite3_context* context,
+ int argc,
+ sqlite3_value** argv,
+ std::index_sequence<Idx...>)
+ {
+ try {
+ Return retval = f(from_sqlite<Args>()(argc, argv, Idx)...);
+
+ to_sqlite(context, std::move(retval));
+ } catch (const lnav::console::user_message& um) {
+ to_sqlite(context, um);
+ } catch (from_sqlite_conversion_error& e) {
+ char buffer[256];
+
+ snprintf(buffer,
+ sizeof(buffer),
+ "Expecting an %s for argument number %d",
+ e.e_type,
+ e.e_argi);
+ sqlite3_result_error(context, buffer, -1);
+ } catch (const std::exception& e) {
+ const auto* fd = (const FuncDef*) sqlite3_user_data(context);
+ attr_line_t error_al;
+ error_al.append("call to ");
+ format_help_text_for_term(
+ fd->fd_help, 40, error_al, help_text_content::synopsis);
+ error_al.append(" failed");
+ auto um = lnav::console::user_message::error(error_al).with_reason(
+ e.what());
+
+ to_sqlite(context, um);
+ } catch (...) {
+ sqlite3_result_error(
+ context, "Function threw an unexpected exception", -1);
+ }
+ }
+
+ static void func1(sqlite3_context* context, int argc, sqlite3_value** argv)
+ {
+ const static bool IS_NULLABLE[]
+ = {vtab_types::is_nullable<Args>::value...};
+ const static bool IS_SQLITE3_VALUE[]
+ = {std::is_same<Args, sqlite3_value*>::value...};
+
+ if ((size_t) argc < REQ_COUNT && VAR_COUNT == 0) {
+ const struct FuncDef* fd
+ = (const FuncDef*) sqlite3_user_data(context);
+ char buffer[128];
+
+ if (OPT_COUNT == 0) {
+ snprintf(buffer,
+ sizeof(buffer),
+ "%s() expects exactly %ld argument%s",
+ fd->fd_help.ht_name,
+ REQ_COUNT,
+ REQ_COUNT == 1 ? "s" : "");
+ } else {
+ snprintf(buffer,
+ sizeof(buffer),
+ "%s() expects between %ld and %ld arguments",
+ fd->fd_help.ht_name,
+ REQ_COUNT,
+ REQ_COUNT + OPT_COUNT);
+ }
+ sqlite3_result_error(context, buffer, -1);
+ return;
+ }
+
+ for (size_t lpc = 0; lpc < REQ_COUNT; lpc++) {
+ if (!IS_NULLABLE[lpc] && !IS_SQLITE3_VALUE[lpc]
+ && sqlite3_value_type(argv[lpc]) == SQLITE_NULL)
+ {
+ sqlite3_result_null(context);
+ return;
+ }
+ }
+
+ func2(context, argc, argv, std::make_index_sequence<sizeof...(Args)>{});
+ }
+
+ static FuncDef builder(help_text ht)
+ {
+ require(ht.ht_parameters.size() == sizeof...(Args));
+
+ return {
+ ht.ht_name,
+ (OPT_COUNT > 0 || VAR_COUNT > 0) ? -1 : (int) REQ_COUNT,
+ SQLITE_UTF8 | SQLITE_DETERMINISTIC,
+ 0,
+ func1,
+ ht,
+ };
+ }
+};
+
+extern std::string vtab_module_schemas;
+extern std::map<intern_string_t, std::string> vtab_module_ddls;
+
+class vtab_index_constraints {
+public:
+ vtab_index_constraints(const sqlite3_index_info* index_info)
+ : vic_index_info(*index_info)
+ {
+ }
+
+ struct const_iterator {
+ const_iterator(vtab_index_constraints* parent, int index = 0)
+ : i_parent(parent), i_index(index)
+ {
+ while (this->i_index < this->i_parent->vic_index_info.nConstraint
+ && !this->i_parent->vic_index_info.aConstraint[this->i_index]
+ .usable)
+ {
+ this->i_index += 1;
+ }
+ }
+
+ const_iterator& operator++()
+ {
+ do {
+ this->i_index += 1;
+ } while (
+ this->i_index < this->i_parent->vic_index_info.nConstraint
+ && !this->i_parent->vic_index_info.aConstraint[this->i_index]
+ .usable);
+
+ return *this;
+ }
+
+ const sqlite3_index_info::sqlite3_index_constraint& operator*() const
+ {
+ return this->i_parent->vic_index_info.aConstraint[this->i_index];
+ }
+
+ const sqlite3_index_info::sqlite3_index_constraint* operator->() const
+ {
+ return &this->i_parent->vic_index_info.aConstraint[this->i_index];
+ }
+
+ bool operator!=(const const_iterator& rhs) const
+ {
+ return this->i_parent != rhs.i_parent
+ || this->i_index != rhs.i_index;
+ }
+
+ const vtab_index_constraints* i_parent;
+ int i_index;
+ };
+
+ const_iterator begin() { return {this}; }
+
+ const_iterator end() { return {this, this->vic_index_info.nConstraint}; }
+
+private:
+ const sqlite3_index_info& vic_index_info;
+};
+
+class vtab_index_usage {
+public:
+ vtab_index_usage(sqlite3_index_info* index_info)
+ : viu_index_info(*index_info)
+ {
+ }
+
+ void column_used(const vtab_index_constraints::const_iterator& iter);
+
+ void allocate_args(int low, int high, int required);
+
+private:
+ sqlite3_index_info& viu_index_info;
+ int viu_used_column_count{0};
+ int viu_min_column{INT_MAX};
+ int viu_max_column{0};
+};
+
+struct vtab_module_base {
+ virtual int create(sqlite3* db) = 0;
+
+ virtual ~vtab_module_base() = default;
+};
+
+template<typename T>
+struct vtab_module : public vtab_module_base {
+ struct vtab {
+ explicit vtab(sqlite3* db, T& impl) : v_db(db), v_impl(impl) {}
+
+ explicit operator sqlite3_vtab*() { return &this->base; }
+
+ sqlite3_vtab v_base{};
+ sqlite3* v_db;
+ T& v_impl;
+ };
+
+ static int tvt_create(sqlite3* db,
+ void* pAux,
+ int argc,
+ const char* const* argv,
+ sqlite3_vtab** pp_vt,
+ char** pzErr)
+ {
+ auto* mod = static_cast<vtab_module<T>*>(pAux);
+ auto vt = new vtab(db, mod->vm_impl);
+
+ *pp_vt = (sqlite3_vtab*) &vt->v_base;
+
+ return sqlite3_declare_vtab(db, T::CREATE_STMT);
+ }
+
+ template<typename... Args, size_t... Idx>
+ static int apply_impl(T& obj,
+ int (T::*func)(sqlite3_vtab*,
+ sqlite3_int64&,
+ Args...),
+ sqlite3_vtab* tab,
+ sqlite3_int64& rowid,
+ sqlite3_value** argv,
+ std::index_sequence<Idx...>)
+ {
+ return (obj.*func)(
+ tab, rowid, from_sqlite<Args>()(sizeof...(Args), argv, Idx)...);
+ }
+
+ template<typename... Args>
+ static int apply(T& obj,
+ int (T::*func)(sqlite3_vtab*, sqlite3_int64&, Args...),
+ sqlite3_vtab* tab,
+ sqlite3_int64& rowid,
+ int argc,
+ sqlite3_value** argv)
+ {
+ require(sizeof...(Args) == 0 || argc == sizeof...(Args));
+
+ try {
+ return apply_impl(obj,
+ func,
+ tab,
+ rowid,
+ argv,
+ std::make_index_sequence<sizeof...(Args)>{});
+ } catch (const from_sqlite_conversion_error& e) {
+ tab->zErrMsg = sqlite3_mprintf(
+ "Expecting an %s for column number %d", e.e_type, e.e_argi);
+ return SQLITE_ERROR;
+ } catch (const std::exception& e) {
+ tab->zErrMsg = sqlite3_mprintf("%s", e.what());
+ return SQLITE_ERROR;
+ } catch (...) {
+ tab->zErrMsg
+ = sqlite3_mprintf("Encountered an unexpected exception");
+ return SQLITE_ERROR;
+ }
+ }
+
+ static int tvt_destructor(sqlite3_vtab* p_svt)
+ {
+ vtab* vt = (vtab*) p_svt;
+
+ delete vt;
+
+ return SQLITE_OK;
+ }
+
+ static int tvt_open(sqlite3_vtab* p_svt, sqlite3_vtab_cursor** pp_cursor)
+ {
+ p_svt->zErrMsg = nullptr;
+
+ auto* p_cur = new (typename T::cursor)(p_svt);
+
+ if (p_cur == nullptr) {
+ return SQLITE_NOMEM;
+ } else {
+ *pp_cursor = (sqlite3_vtab_cursor*) p_cur;
+ }
+
+ return SQLITE_OK;
+ }
+
+ static int tvt_next(sqlite3_vtab_cursor* cur)
+ {
+ auto* p_cur = (typename T::cursor*) cur;
+
+ return p_cur->next();
+ }
+
+ static int tvt_eof(sqlite3_vtab_cursor* cur)
+ {
+ auto* p_cur = (typename T::cursor*) cur;
+
+ return p_cur->eof();
+ }
+
+ static int tvt_close(sqlite3_vtab_cursor* cur)
+ {
+ auto* p_cur = (typename T::cursor*) cur;
+
+ delete p_cur;
+
+ return SQLITE_OK;
+ }
+
+ static int tvt_rowid(sqlite3_vtab_cursor* cur, sqlite_int64* p_rowid)
+ {
+ auto* p_cur = (typename T::cursor*) cur;
+
+ return p_cur->get_rowid(*p_rowid);
+ }
+
+ static int tvt_column(sqlite3_vtab_cursor* cur,
+ sqlite3_context* ctx,
+ int col)
+ {
+ auto* mod_vt = (typename vtab_module<T>::vtab*) cur->pVtab;
+ auto* p_cur = (typename T::cursor*) cur;
+
+ return mod_vt->v_impl.get_column(*p_cur, ctx, col);
+ }
+
+ static int vt_best_index(sqlite3_vtab* tab, sqlite3_index_info* p_info)
+ {
+ return SQLITE_OK;
+ }
+
+ static int vt_filter(sqlite3_vtab_cursor* p_vtc,
+ int idxNum,
+ const char* idxStr,
+ int argc,
+ sqlite3_value** argv)
+ {
+ auto* p_cur = (typename T::cursor*) p_vtc;
+
+ return p_cur->reset();
+ }
+
+ static int tvt_update(sqlite3_vtab* tab,
+ int argc,
+ sqlite3_value** argv,
+ sqlite_int64* rowid)
+ {
+ auto* mod_vt = (typename vtab_module<T>::vtab*) tab;
+
+ if (argc <= 1) {
+ sqlite3_int64 rowid = sqlite3_value_int64(argv[0]);
+
+ return mod_vt->v_impl.delete_row(tab, rowid);
+ }
+
+ if (sqlite3_value_type(argv[0]) == SQLITE_NULL) {
+ sqlite3_int64* rowid2 = rowid;
+ return vtab_module<T>::apply(mod_vt->v_impl,
+ &T::insert_row,
+ tab,
+ *rowid2,
+ argc - 2,
+ argv + 2);
+ }
+
+ sqlite3_int64 index = sqlite3_value_int64(argv[0]);
+
+ if (index != sqlite3_value_int64(argv[1])) {
+ tab->zErrMsg = sqlite3_mprintf(
+ "The rowids in the lnav_views table cannot be changed");
+ return SQLITE_ERROR;
+ }
+
+ return vtab_module<T>::apply(
+ mod_vt->v_impl, &T::update_row, tab, index, argc - 2, argv + 2);
+ }
+
+ template<typename U>
+ auto addUpdate(U u) -> decltype(&U::delete_row, void())
+ {
+ this->vm_module.xUpdate = tvt_update;
+ }
+
+ template<typename U>
+ void addUpdate(...)
+ {
+ }
+
+ template<typename... Args>
+ vtab_module(Args&... args) noexcept : vm_impl(args...)
+ {
+ memset(&this->vm_module, 0, sizeof(this->vm_module));
+ this->vm_module.iVersion = 0;
+ this->vm_module.xCreate = tvt_create;
+ this->vm_module.xConnect = tvt_create;
+ this->vm_module.xOpen = tvt_open;
+ this->vm_module.xNext = tvt_next;
+ this->vm_module.xEof = tvt_eof;
+ this->vm_module.xClose = tvt_close;
+ this->vm_module.xDestroy = tvt_destructor;
+ this->vm_module.xRowid = tvt_rowid;
+ this->vm_module.xDisconnect = tvt_destructor;
+ this->vm_module.xBestIndex = vt_best_index;
+ this->vm_module.xFilter = vt_filter;
+ this->vm_module.xColumn = tvt_column;
+ this->addUpdate<T>(this->vm_impl);
+ }
+
+ ~vtab_module() override = default;
+
+ int create(sqlite3* db, const char* name)
+ {
+ auto impl_name = std::string(name);
+ vtab_module_schemas += T::CREATE_STMT;
+ vtab_module_ddls[intern_string::lookup(name)] = trim(T::CREATE_STMT);
+
+ // XXX Eponymous tables don't seem to work in older sqlite versions
+ impl_name += "_impl";
+ int rc = sqlite3_create_module(
+ db, impl_name.c_str(), &this->vm_module, this);
+ ensure(rc == SQLITE_OK);
+ auto create_stmt = fmt::format(
+ FMT_STRING("CREATE VIRTUAL TABLE {} USING {}()"), name, impl_name);
+ return sqlite3_exec(db, create_stmt.c_str(), nullptr, nullptr, nullptr);
+ }
+
+ int create(sqlite3* db) override
+ {
+ return this->create(db, T::NAME);
+ }
+
+ sqlite3_module vm_module;
+ T vm_impl;
+};
+
+template<typename T>
+struct tvt_iterator_cursor {
+ struct cursor {
+ sqlite3_vtab_cursor base{};
+
+ typename T::iterator iter;
+
+ explicit cursor(sqlite3_vtab* vt)
+ {
+ auto* mod_vt = (typename vtab_module<T>::vtab*) vt;
+
+ this->base.pVtab = vt;
+ this->iter = mod_vt->v_impl.begin();
+ }
+
+ int reset()
+ {
+ this->iter = get_handler().begin();
+
+ return SQLITE_OK;
+ }
+
+ int next()
+ {
+ if (this->iter != get_handler().end()) {
+ ++this->iter;
+ }
+
+ return SQLITE_OK;
+ }
+
+ int eof() { return this->iter == get_handler().end(); }
+
+ template<bool cond, typename U>
+ using resolvedType = typename std::enable_if<cond, U>::type;
+
+ template<typename U = int>
+ resolvedType<
+ std::is_same<std::random_access_iterator_tag,
+ typename std::iterator_traits<
+ typename T::iterator>::iterator_category>::value,
+ U>
+ get_rowid(sqlite_int64& rowid_out)
+ {
+ rowid_out = std::distance(get_handler().begin(), this->iter);
+
+ return SQLITE_OK;
+ }
+
+ template<typename U = int>
+ resolvedType<
+ !std::is_same<std::random_access_iterator_tag,
+ typename std::iterator_traits<
+ typename T::iterator>::iterator_category>::value,
+ U>
+ get_rowid(sqlite_int64& rowid_out)
+ {
+ rowid_out = get_handler().get_rowid(this->iter);
+
+ return SQLITE_OK;
+ }
+
+ protected:
+ T& get_handler()
+ {
+ auto* mod_vt = (typename vtab_module<T>::vtab*) this->base.pVtab;
+
+ return mod_vt->v_impl;
+ }
+ };
+};
+
+template<typename T>
+struct tvt_no_update : public T {
+ using T::T;
+
+ int delete_row(sqlite3_vtab* vt, sqlite3_int64 rowid)
+ {
+ vt->zErrMsg = sqlite3_mprintf("Rows cannot be deleted from this table");
+ return SQLITE_ERROR;
+ }
+
+ int insert_row(sqlite3_vtab* tab, sqlite3_int64& rowid_out)
+ {
+ tab->zErrMsg
+ = sqlite3_mprintf("Rows cannot be inserted into this table");
+ return SQLITE_ERROR;
+ }
+
+ int update_row(sqlite3_vtab* tab, sqlite3_int64& rowid_out)
+ {
+ tab->zErrMsg = sqlite3_mprintf("Rows cannot be updated in this table");
+ return SQLITE_ERROR;
+ }
+};
+
+#endif