story-kit: merge 260_refactor_upgrade_libsqlite3_sys

vendor/rusqlite/tests/auto_ext.rs

@@ -0,0 +1,41 @@
+#[cfg(all(feature = "bundled", not(feature = "loadable_extension")))]
+#[test]
+fn auto_ext() -> rusqlite::Result<()> {
+    use rusqlite::auto_extension::*;
+    use rusqlite::{ffi, Connection, Error, Result};
+    use std::os::raw::{c_char, c_int};
+
+    fn test_ok(_: Connection) -> Result<()> {
+        Ok(())
+    }
+    unsafe extern "C" fn sqlite_test_ok(
+        db: *mut ffi::sqlite3,
+        pz_err_msg: *mut *mut c_char,
+        _: *const ffi::sqlite3_api_routines,
+    ) -> c_int {
+        init_auto_extension(db, pz_err_msg, test_ok)
+    }
+    fn test_err(_: Connection) -> Result<()> {
+        Err(Error::SqliteFailure(
+            ffi::Error::new(ffi::SQLITE_CORRUPT),
+            Some("AutoExtErr".to_owned()),
+        ))
+    }
+    unsafe extern "C" fn sqlite_test_err(
+        db: *mut ffi::sqlite3,
+        pz_err_msg: *mut *mut c_char,
+        _: *const ffi::sqlite3_api_routines,
+    ) -> c_int {
+        init_auto_extension(db, pz_err_msg, test_err)
+    }
+
+    //assert!(!cancel_auto_extension(sqlite_test_ok));
+    unsafe { register_auto_extension(sqlite_test_ok)? };
+    Connection::open_in_memory()?;
+    assert!(cancel_auto_extension(sqlite_test_ok));
+    assert!(!cancel_auto_extension(sqlite_test_ok));
+    unsafe { register_auto_extension(sqlite_test_err)? };
+    Connection::open_in_memory().unwrap_err();
+    reset_auto_extension();
+    Ok(())
+}

vendor/rusqlite/tests/config_log.rs

@@ -0,0 +1,32 @@
+//! This file contains unit tests for `rusqlite::trace::config_log`. This
+//! function affects SQLite process-wide and so is not safe to run as a normal
+//! #[test] in the library.
+
+#[cfg(feature = "trace")]
+fn main() {
+    use std::os::raw::c_int;
+    use std::sync::{LazyLock, Mutex};
+
+    static LOGS_RECEIVED: LazyLock<Mutex<Vec<(c_int, String)>>> =
+        LazyLock::new(|| Mutex::new(Vec::new()));
+
+    fn log_handler(err: c_int, message: &str) {
+        let mut logs_received = LOGS_RECEIVED.lock().unwrap();
+        logs_received.push((err, message.to_owned()));
+    }
+
+    use rusqlite::trace;
+
+    unsafe { trace::config_log(Some(log_handler)) }.unwrap();
+    trace::log(10, "First message from rusqlite");
+    unsafe { trace::config_log(None) }.unwrap();
+    trace::log(11, "Second message from rusqlite");
+
+    let logs_received = LOGS_RECEIVED.lock().unwrap();
+    assert_eq!(logs_received.len(), 1);
+    assert_eq!(logs_received[0].0, 10);
+    assert_eq!(logs_received[0].1, "First message from rusqlite");
+}
+
+#[cfg(not(feature = "trace"))]
+fn main() {}

vendor/rusqlite/tests/deny_single_threaded_sqlite_config.rs

@@ -0,0 +1,23 @@
+//! Ensure we reject connections when SQLite is in single-threaded mode, as it
+//! would violate safety if multiple Rust threads tried to use connections.
+
+#[cfg(all(target_family = "wasm", target_os = "unknown"))]
+use wasm_bindgen_test::wasm_bindgen_test as test;
+
+#[cfg(not(feature = "loadable_extension"))]
+#[test]
+fn test_error_when_singlethread_mode() {
+    use rusqlite::ffi;
+    use rusqlite::Connection;
+    // put SQLite into single-threaded mode
+    unsafe {
+        // Note: macOS system SQLite seems to return an error if you attempt to
+        // reconfigure to single-threaded mode.
+        if ffi::sqlite3_config(ffi::SQLITE_CONFIG_SINGLETHREAD) != ffi::SQLITE_OK {
+            return;
+        }
+        assert_eq!(ffi::sqlite3_initialize(), ffi::SQLITE_OK);
+    }
+    let res = Connection::open_in_memory();
+    res.unwrap_err();
+}

vendor/rusqlite/tests/vtab.rs

@@ -0,0 +1,102 @@
+//! Ensure Virtual tables can be declared outside `rusqlite` crate.
+#[cfg(all(feature = "vtab", target_family = "wasm", target_os = "unknown"))]
+use wasm_bindgen_test::wasm_bindgen_test as test;
+
+#[cfg(feature = "vtab")]
+#[test]
+fn test_dummy_module() -> rusqlite::Result<()> {
+    use rusqlite::vtab::{
+        eponymous_only_module, sqlite3_vtab, sqlite3_vtab_cursor, Context, Filters, IndexInfo,
+        VTab, VTabConnection, VTabCursor,
+    };
+    use rusqlite::{version_number, Connection, Result};
+    use std::marker::PhantomData;
+    use std::os::raw::c_int;
+
+    let module = eponymous_only_module::<DummyTab>();
+
+    #[repr(C)]
+    struct DummyTab {
+        /// Base class. Must be first
+        base: sqlite3_vtab,
+    }
+
+    unsafe impl<'vtab> VTab<'vtab> for DummyTab {
+        type Aux = ();
+        type Cursor = DummyTabCursor<'vtab>;
+
+        fn connect(
+            _: &mut VTabConnection,
+            _aux: Option<&()>,
+            _args: &[&[u8]],
+        ) -> Result<(String, Self)> {
+            let vtab = Self {
+                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(&'vtab mut self) -> Result<DummyTabCursor<'vtab>> {
+            Ok(DummyTabCursor::default())
+        }
+    }
+
+    #[derive(Default)]
+    #[repr(C)]
+    struct DummyTabCursor<'vtab> {
+        /// Base class. Must be first
+        base: sqlite3_vtab_cursor,
+        /// The rowid
+        row_id: i64,
+        phantom: PhantomData<&'vtab DummyTab>,
+    }
+
+    unsafe impl VTabCursor for DummyTabCursor<'_> {
+        fn filter(
+            &mut self,
+            _idx_num: c_int,
+            _idx_str: Option<&str>,
+            _args: &Filters<'_>,
+        ) -> 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)
+        }
+    }
+
+    let db = Connection::open_in_memory()?;
+
+    db.create_module::<DummyTab, _>(c"dummy", module, None)?;
+
+    let version = version_number();
+    if version < 3_009_000 {
+        return Ok(());
+    }
+
+    let mut s = db.prepare("SELECT * FROM dummy()")?;
+
+    let dummy = s.query_row([], |row| row.get::<_, i32>(0))?;
+    assert_eq!(1, dummy);
+    Ok(())
+}