Support for sqlite vtables as loadable extensions

.github/workflows/main.yml

@@ -33,8 +33,8 @@ jobs:
           toolchain: stable
           override: true
       - run: cargo build --features bundled --workspace --all-targets
-      - run: cargo test --features bundled --workspace --all-targets
-      - run: cargo test --features bundled --workspace --doc
+      - run: cargo test --features bundled --workspace --all-targets --exclude dummy-extension
+      - run: cargo test --features bundled --workspace --doc --exclude dummy-extension
       - name: Static build
         if: matrix.platform.os == 'windows-latest'
         shell: cmd

.travis.yml

@@ -27,6 +27,7 @@ script:
   - cargo build --features bundled
   - cargo build --features sqlcipher
   - cargo build --features "bundled sqlcipher"
+  - cargo build --features "loadable_extension backup blob collation functions limits hooks unlock_notify vtab window bundled"
   - cargo test
   - cargo test --features "backup blob extra_check"
   - cargo test --features "collation functions"

Cargo.toml

@@ -20,30 +20,31 @@ maintenance = { status = "actively-developed" }
 name = "rusqlite"
 
 [workspace]
-members = ["libsqlite3-sys"]
+members = ["libsqlite3-sys", "dummy-extension"]
 
 [features]
 load_extension = []
 # hot-backup interface: 3.6.11 (2009-02-18)
-backup = ["libsqlite3-sys/min_sqlite_version_3_6_23"]
+backup = ["libsqlite3-sys/min_sqlite_version_3_7_16"]
 # sqlite3_blob_reopen: 3.7.4
-blob = ["libsqlite3-sys/min_sqlite_version_3_7_7"]
+blob = ["libsqlite3-sys/min_sqlite_version_3_7_16"]
 collation = []
 # sqlite3_create_function_v2: 3.7.3 (2010-10-08)
-functions = ["libsqlite3-sys/min_sqlite_version_3_7_7"]
+functions = ["libsqlite3-sys/min_sqlite_version_3_7_16"]
 # sqlite3_log: 3.6.23 (2010-03-09)
-trace = ["libsqlite3-sys/min_sqlite_version_3_6_23"]
+trace = ["libsqlite3-sys/min_sqlite_version_3_7_16"]
 bundled = ["libsqlite3-sys/bundled", "modern_sqlite"]
 buildtime_bindgen = ["libsqlite3-sys/buildtime_bindgen"]
+loadable_extension = ["libsqlite3-sys/loadable_extension"]
+loadable_extension_embedded = ["libsqlite3-sys/loadable_extension_embedded"]
 limits = []
 hooks = []
 i128_blob = ["byteorder"]
+# when `sqlcipher` is used, `bundled` and `loadable_extension` are ignored
 sqlcipher = ["libsqlite3-sys/sqlcipher"]
 unlock_notify = ["libsqlite3-sys/unlock_notify"]
 # xSavepoint, xRelease and xRollbackTo: 3.7.7 (2011-06-23)
-vtab = ["libsqlite3-sys/min_sqlite_version_3_7_7", "lazy_static"]
-# xShadowName: 3.26.0
-vtab_v3 = ["vtab"]
+vtab = ["libsqlite3-sys/min_sqlite_version_3_7_16", "lazy_static"]
 csvtab = ["csv", "vtab"]
 # pointer passing interfaces: 3.20.0
 array = ["vtab"]

LICENSE

@@ -1,4 +1,5 @@
 Copyright (c) 2014 John Gallagher <johnkgallagher@gmail.com>
+Copyright (c) 2019 Genomics plc <info@genomicsplc.com>
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

README.md

@@ -152,8 +152,7 @@ minimum SQLite version that supports your chosen features. If you are using
 pregenerated bindings are chosen:
 
 * `min_sqlite_version_3_6_8` - SQLite 3.6.8 bindings (this is the default)
-* `min_sqlite_version_3_6_23` - SQLite 3.6.23 bindings
-* `min_sqlite_version_3_7_7` - SQLite 3.7.7 bindings
+* `min_sqlite_version_3_7_16` - SQLite 3.7.16 bindings
 
 If you use the `bundled` feature, you will get pregenerated bindings for the
 bundled version of SQLite. If you need other specific pregenerated binding

dummy-extension/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "dummy-extension"
+version = "0.0.1"
+authors = ["John Gallagher <jgallagher@bignerdranch.com>"]
+edition = "2018"
+repository = "https://github.com/jgallagher/rusqlite"
+description = "Dummy extension"
+license = "MIT"
+keywords = ["sqlite", "extension"]
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+lazy_static = "1.0"
+
+[dependencies.rusqlite]
+path = ".."
+default-features = false
+features = ["loadable_extension", "vtab"]
+version = "0.21.0"

dummy-extension/src/lib.rs

@@ -0,0 +1,105 @@
+use std::os::raw::{c_char, c_int};
+
+use rusqlite::ffi;
+use rusqlite::vtab::{
+    eponymous_only_module, sqlite3_vtab, sqlite3_vtab_cursor, Context, IndexInfo, Module, VTab,
+    VTabConnection, VTabCursor, Values,
+};
+use rusqlite::{to_sqlite_error, Connection, Result};
+
+#[allow(clippy::not_unsafe_ptr_arg_deref)]
+#[no_mangle]
+pub extern "C" fn sqlite3_extension_init(
+    db: *mut ffi::sqlite3,
+    pz_err_msg: *mut *mut c_char,
+    p_api: *mut ffi::sqlite3_api_routines,
+) -> c_int {
+    // SQLITE_EXTENSION_INIT2 equivalent
+    unsafe {
+        ffi::sqlite3_api = p_api;
+    }
+    let res = dummy_init(db);
+    if let Err(err) = res {
+        return unsafe { to_sqlite_error(&err, pz_err_msg) };
+    }
+
+    ffi::SQLITE_OK
+}
+
+lazy_static::lazy_static! {
+    static ref DUMMY_MODULE: Module<DummyTab> = eponymous_only_module::<DummyTab>(1);
+}
+#[repr(C)]
+struct DummyTab {
+    /// Base class. Must be first
+    base: sqlite3_vtab,
+}
+
+impl VTab for DummyTab {
+    type Aux = ();
+    type Cursor = DummyTabCursor;
+
+    fn connect(
+        _: &mut VTabConnection,
+        _aux: Option<&()>,
+        _args: &[&[u8]],
+    ) -> Result<(String, DummyTab)> {
+        let vtab = DummyTab {
+            base: sqlite3_vtab::default(),
+        };
+        Ok(("CREATE TABLE x(value)".to_owned(), vtab))
+    }
+
+    fn best_index(&self, info: &mut IndexInfo) -> Result<()> {
+        info.set_estimated_cost(1.);
+        Ok(())
+    }
+
+    fn open(&self) -> Result<DummyTabCursor> {
+        Ok(DummyTabCursor::default())
+    }
+}
+
+#[derive(Default)]
+#[repr(C)]
+struct DummyTabCursor {
+    /// Base class. Must be first
+    base: sqlite3_vtab_cursor,
+    /// The rowid
+    row_id: i64,
+}
+
+impl VTabCursor for DummyTabCursor {
+    fn filter(
+        &mut self,
+        _idx_num: c_int,
+        _idx_str: Option<&str>,
+        _args: &Values<'_>,
+    ) -> Result<()> {
+        self.row_id = 1;
+        Ok(())
+    }
+
+    fn next(&mut self) -> Result<()> {
+        self.row_id += 1;
+        Ok(())
+    }
+
+    fn eof(&self) -> bool {
+        self.row_id > 1
+    }
+
+    fn column(&self, ctx: &mut Context, _: c_int) -> Result<()> {
+        ctx.set_result(&self.row_id)
+    }
+
+    fn rowid(&self) -> Result<i64> {
+        Ok(self.row_id)
+    }
+}
+
+fn dummy_init(db: *mut ffi::sqlite3) -> Result<()> {
+    let conn = unsafe { Connection::from_handle(db)? };
+
+    conn.create_module::<DummyTab>("dummy", &DUMMY_MODULE, None)
+}

libsqlite3-sys/Cargo.toml

@@ -14,12 +14,14 @@ categories = ["external-ffi-bindings"]
 [features]
 default = ["min_sqlite_version_3_6_8"]
 bundled = ["cc", "bundled_bindings"]
+# allows a dependency to use `bundled` only on windows
 bundled-windows = ["cc", "bundled_bindings"]
 buildtime_bindgen = ["bindgen", "pkg-config", "vcpkg"]
+loadable_extension = ["syn", "quote"]
+loadable_extension_embedded = ["loadable_extension"]
+# when `sqlcipher` is used, `bundled` and `loadable_extension` are ignored
 sqlcipher = []
 min_sqlite_version_3_6_8 = ["pkg-config", "vcpkg"]
-min_sqlite_version_3_6_23 = ["pkg-config", "vcpkg"]
-min_sqlite_version_3_7_7 = ["pkg-config", "vcpkg"]
 min_sqlite_version_3_7_16 = ["pkg-config", "vcpkg"]
 # Bundle only the bindings file. Note that this does nothing if
 # `buildtime_bindgen` is enabled.
@@ -36,6 +38,8 @@ in_gecko = []
 bindgen = { version = "0.53", optional = true, default-features = false, features = ["runtime"] }
 pkg-config = { version = "0.3", optional = true }
 cc = { version = "1.0", optional = true }
+syn = { version = "1.0", features = ["extra-traits", "full", "printing"], optional = true }
+quote = { version = "1.0", optional = true }
 
 [target.'cfg(target_env = "msvc")'.build-dependencies]
 vcpkg = { version = "0.2", optional = true }

libsqlite3-sys/bindgen-bindings/README.md

@@ -0,0 +1,21 @@
+Pre-built sqlite bindings
+=========================
+
+This directory contains pre built (by rust-bindgen) bindings for various sqlite versions.
+
+The general recipe for doing this is:
+  1. Download sqlite amalgamation sources for the desired version (see links below)
+  2. Expand the zip archive into a temporary directory
+  3. Set environment variables `SQLITE3_LIB_DIR` and `SQLITE3_INCLUDE_DIR` to the location of the resulting source directory
+  4. Build libsqlite3-sys with the feature `buildtime_bindgen` (e.g. `cargo build --features "buildtime_bindgen" -p libsqlite3-sys`)
+  5. Copy `bindgen.rs` from within the `target` directory at the top level of the rusqlite workspace to an appropriate file in this directory (it will be found under `target/debug/build/libsqlite3-sys-*/out/bindgen.rs`)
+
+Repeat the above process for each desired version, and also re-run each build using `--features "buildtime_bindgen,loadable_extension"` to generate the `-ext.h` versions to support sqlite3 loadable extensions.
+
+sqlite3 amalgamation source links
+---------------------------------
+The location of the amalgamation sources used to build these are:
+  - [3.7.16](https://sqlite.org/2013/sqlite-amalgamation-3071600.zip)
+  - [3.6.8](https://sqlite.org/sqlite-amalgamation-3_6_8.zip)
+
+