treewide: migrate from rusqlite to libsql and libsql_sys

This huge patch migrates sqld from rusqlite to libsql crate.
Since both rusqlite and libsql link with compiled sqlite3.c,
the migration has to be done in one piece.
Good luck, reviewers!

Author: psarna

Cargo.lock

@@ -10,9 +10,4 @@ members = [
 ]
 
 [workspace.dependencies]
-rusqlite = { version = "0.29.0", git = "https://github.com/psarna/rusqlite", rev = "477264453b", default-features = false, features = [
-    "buildtime_bindgen",
-    "bundled-libsql-wasm-experimental",
-    "column_decltype",
-    "load_extension"
-] }
+libsql = { version = "0.1.6", default-features = false }

Cargo.toml

@@ -57,18 +57,18 @@ pub extern "C" fn xOpen(
     let rc = unsafe {
         (orig_methods.xOpen.unwrap())(vfs, db_file, wal_name, no_shm_mode, max_size, methods, wal)
     };
-    if rc != ffi::SQLITE_OK {
+    if rc != ffi::SQLITE_OK as i32 {
         return rc;
     }
 
     if !is_regular(vfs) {
         tracing::error!("Bottomless WAL is currently only supported for regular VFS");
-        return ffi::SQLITE_CANTOPEN;
+        return ffi::SQLITE_CANTOPEN as i32;
     }
 
     if is_local() {
         tracing::info!("Running in local-mode only, without any replication");
-        return ffi::SQLITE_OK;
+        return ffi::SQLITE_OK as i32;
     }
 
     let runtime = match tokio::runtime::Builder::new_current_thread()
@@ -78,7 +78,7 @@ pub extern "C" fn xOpen(
         Ok(runtime) => runtime,
         Err(e) => {
             tracing::error!("Failed to initialize async runtime: {}", e);
-            return ffi::SQLITE_CANTOPEN;
+            return ffi::SQLITE_CANTOPEN as i32;
         }
     };
 
@@ -88,7 +88,7 @@ pub extern "C" fn xOpen(
             Ok(path) => path,
             Err(e) => {
                 tracing::error!("Failed to parse the main database path: {}", e);
-                return ffi::SQLITE_CANTOPEN;
+                return ffi::SQLITE_CANTOPEN as i32;
             }
         }
     };
@@ -98,12 +98,12 @@ pub extern "C" fn xOpen(
         Ok(repl) => repl,
         Err(e) => {
             tracing::error!("Failed to initialize replicator: {}", e);
-            return ffi::SQLITE_CANTOPEN;
+            return ffi::SQLITE_CANTOPEN as i32;
         }
     };
 
     let rc = block_on!(runtime, try_restore(&mut replicator));
-    if rc != ffi::SQLITE_OK {
+    if rc != ffi::SQLITE_OK as i32 {
         return rc;
     }
 
@@ -114,7 +114,7 @@ pub extern "C" fn xOpen(
     let context_ptr = Box::into_raw(Box::new(context)) as *mut c_void;
     unsafe { (*(*wal)).pMethodsData = context_ptr };
 
-    ffi::SQLITE_OK
+    ffi::SQLITE_OK as i32
 }
 
 fn get_orig_methods(wal: *mut Wal) -> &'static libsql_wal_methods {
@@ -138,7 +138,7 @@ pub extern "C" fn xClose(
     let orig_methods = get_orig_methods(wal);
     let methods_data = unsafe { (*wal).pMethodsData as *mut replicator::Context };
     let rc = unsafe { (orig_methods.xClose.unwrap())(wal, db, sync_flags, n_buf, z_buf) };
-    if rc != ffi::SQLITE_OK {
+    if rc != ffi::SQLITE_OK as i32 {
         return rc;
     }
     if !is_local() && !methods_data.is_null() {
@@ -194,7 +194,7 @@ pub extern "C" fn xUndo(
 ) -> i32 {
     let orig_methods = get_orig_methods(wal);
     let rc = unsafe { (orig_methods.xUndo.unwrap())(wal, func, ctx) };
-    if is_local() || rc != ffi::SQLITE_OK {
+    if is_local() || rc != ffi::SQLITE_OK as i32 {
         return rc;
     }
 
@@ -207,7 +207,7 @@ pub extern "C" fn xUndo(
     );
     ctx.replicator.rollback_to_frame(last_valid_frame);
 
-    ffi::SQLITE_OK
+    ffi::SQLITE_OK as i32
 }
 
 pub extern "C" fn xSavepoint(wal: *mut Wal, wal_data: *mut u32) {
@@ -218,7 +218,7 @@ pub extern "C" fn xSavepoint(wal: *mut Wal, wal_data: *mut u32) {
 pub extern "C" fn xSavepointUndo(wal: *mut Wal, wal_data: *mut u32) -> i32 {
     let orig_methods = get_orig_methods(wal);
     let rc = unsafe { (orig_methods.xSavepointUndo.unwrap())(wal, wal_data) };
-    if is_local() || rc != ffi::SQLITE_OK {
+    if is_local() || rc != ffi::SQLITE_OK as i32 {
         return rc;
     }
 
@@ -231,7 +231,7 @@ pub extern "C" fn xSavepointUndo(wal: *mut Wal, wal_data: *mut u32) -> i32 {
     );
     ctx.replicator.rollback_to_frame(last_valid_frame);
 
-    ffi::SQLITE_OK
+    ffi::SQLITE_OK as i32
 }
 
 pub extern "C" fn xFrames(
@@ -253,7 +253,7 @@ pub extern "C" fn xFrames(
         // supported by bottomless storage.
         if let Err(e) = ctx.replicator.set_page_size(page_size as usize) {
             tracing::error!("{}", e);
-            return ffi::SQLITE_IOERR_WRITE;
+            return ffi::SQLITE_IOERR_WRITE as i32;
         }
         let frame_count = ffi::PageHdrIter::new(page_headers, page_size as usize).count();
         if size_after != 0 {
@@ -273,11 +273,11 @@ pub extern "C" fn xFrames(
             sync_flags,
         )
     };
-    if is_local() || rc != ffi::SQLITE_OK {
+    if is_local() || rc != ffi::SQLITE_OK as i32 {
         return rc;
     }
 
-    ffi::SQLITE_OK
+    ffi::SQLITE_OK as i32
 }
 
 extern "C" fn always_wait(_busy_param: *mut c_void) -> i32 {
@@ -307,9 +307,9 @@ pub extern "C" fn xCheckpoint(
      ** In order to avoid autocheckpoint on close (that's too often),
      ** checkpoint attempts weaker than TRUNCATE are ignored.
      */
-    if emode < ffi::SQLITE_CHECKPOINT_TRUNCATE {
+    if emode < ffi::SQLITE_CHECKPOINT_TRUNCATE as i32 {
         tracing::trace!("Ignoring a checkpoint request weaker than TRUNCATE");
-        return ffi::SQLITE_OK;
+        return ffi::SQLITE_OK as i32;
     }
     /* If there's no busy handler, let's provide a default one,
      ** since we auto-upgrade the passive checkpoint
@@ -335,14 +335,14 @@ pub extern "C" fn xCheckpoint(
         )
     };
 
-    if is_local() || rc != ffi::SQLITE_OK {
+    if is_local() || rc != ffi::SQLITE_OK as i32 {
         return rc;
     }
 
     let ctx = get_replicator_context(wal);
     if ctx.replicator.commits_in_current_generation() == 0 {
         tracing::debug!("No commits happened in this generation, not snapshotting");
-        return ffi::SQLITE_OK;
+        return ffi::SQLITE_OK as i32;
     }
 
     let last_known_frame = ctx.replicator.last_known_frame();
@@ -352,7 +352,7 @@ pub extern "C" fn xCheckpoint(
         ctx.replicator.wait_until_committed(last_known_frame)
     ) {
         tracing::error!("Failed to finalize replication: {}", e);
-        return ffi::SQLITE_IOERR_WRITE;
+        return ffi::SQLITE_IOERR_WRITE as i32;
     }
 
     ctx.replicator.new_generation();
@@ -363,10 +363,10 @@ pub extern "C" fn xCheckpoint(
             "Failed to snapshot the main db file during checkpoint: {}",
             e
         );
-        return ffi::SQLITE_IOERR_WRITE;
+        return ffi::SQLITE_IOERR_WRITE as i32;
     }
 
-    ffi::SQLITE_OK
+    ffi::SQLITE_OK as i32
 }
 
 pub extern "C" fn xCallback(wal: *mut Wal) -> i32 {
@@ -416,42 +416,42 @@ async fn try_restore(replicator: &mut replicator::Replicator) -> i32 {
             replicator.new_generation();
             if let Err(e) = replicator.snapshot_main_db_file().await {
                 tracing::error!("Failed to snapshot the main db file: {}", e);
-                return ffi::SQLITE_CANTOPEN;
+                return ffi::SQLITE_CANTOPEN as i32;
             }
             // Restoration process only leaves the local WAL file if it was
             // detected to be newer than its remote counterpart.
             if let Err(e) = replicator.maybe_replicate_wal().await {
                 tracing::error!("Failed to replicate local WAL: {}", e);
-                return ffi::SQLITE_CANTOPEN;
+                return ffi::SQLITE_CANTOPEN as i32;
             }
         }
         Ok(replicator::RestoreAction::ReuseGeneration(gen)) => {
             replicator.set_generation(gen);
         }
         Err(e) => {
             tracing::error!("Failed to restore the database: {}", e);
-            return ffi::SQLITE_CANTOPEN;
+            return ffi::SQLITE_CANTOPEN as i32;
         }
     }
 
-    ffi::SQLITE_OK
+    ffi::SQLITE_OK as i32
 }
 
 pub extern "C" fn xPreMainDbOpen(_methods: *mut libsql_wal_methods, path: *const c_char) -> i32 {
     if is_local() {
         tracing::info!("Running in local-mode only, without any replication");
-        return ffi::SQLITE_OK;
+        return ffi::SQLITE_OK as i32;
     }
 
     if path.is_null() {
-        return ffi::SQLITE_OK;
+        return ffi::SQLITE_OK as i32;
     }
     let path = unsafe {
         match std::ffi::CStr::from_ptr(path).to_str() {
             Ok(path) => path,
             Err(e) => {
                 tracing::error!("Failed to parse the main database path: {}", e);
-                return ffi::SQLITE_CANTOPEN;
+                return ffi::SQLITE_CANTOPEN as i32;
             }
         }
     };
@@ -464,23 +464,23 @@ pub extern "C" fn xPreMainDbOpen(_methods: *mut libsql_wal_methods, path: *const
         Ok(runtime) => runtime,
         Err(e) => {
             tracing::error!("Failed to initialize async runtime: {}", e);
-            return ffi::SQLITE_CANTOPEN;
+            return ffi::SQLITE_CANTOPEN as i32;
         }
     };
 
     let options = match replicator::Options::from_env() {
         Ok(options) => options,
         Err(e) => {
             tracing::error!("Failed to parse replicator options: {}", e);
-            return ffi::SQLITE_CANTOPEN;
+            return ffi::SQLITE_CANTOPEN as i32;
         }
     };
     let replicator = block_on!(runtime, replicator::Replicator::with_options(path, options));
     let mut replicator = match replicator {
         Ok(repl) => repl,
         Err(e) => {
             tracing::error!("Failed to initialize replicator: {}", e);
-            return ffi::SQLITE_CANTOPEN;
+            return ffi::SQLITE_CANTOPEN as i32;
         }
     };
     block_on!(runtime, try_restore(&mut replicator))
@@ -561,7 +561,7 @@ pub mod static_init {
             if orig_methods.is_null() {}
             let methods = crate::bottomless_methods(orig_methods);
             let rc = unsafe { libsql_wal_methods_register(methods) };
-            if rc != crate::ffi::SQLITE_OK {
+            if rc != crate::ffi::SQLITE_OK as i32 {
                 let _box = unsafe { Box::from_raw(methods as *mut libsql_wal_methods) };
                 tracing::warn!("Failed to instantiate bottomless WAL methods");
             }

bottomless/src/lib.rs

@@ -7,9 +7,9 @@ edition = "2021"
 
 [dependencies]
 anyhow = "1.0.66"
-rusqlite = { workspace = true }
 tracing = "0.1.37"
 once_cell = "1.17.1"
+libsql = { workspace = true }
 
 [features]
 unix-excl-vfs = []

sqld-libsql-bindings/Cargo.toml

@@ -2,16 +2,9 @@
 
 pub mod types;
 
-pub use rusqlite::ffi::{
-    libsql_wal_methods, libsql_wal_methods_find, libsql_wal_methods_register,
-    libsql_wal_methods_unregister, sqlite3, sqlite3_file, sqlite3_hard_heap_limit64,
-    sqlite3_io_methods, sqlite3_soft_heap_limit64, sqlite3_vfs, WalIndexHdr, SQLITE_CANTOPEN,
-    SQLITE_CHECKPOINT_FULL, SQLITE_CHECKPOINT_TRUNCATE, SQLITE_IOERR_WRITE, SQLITE_OK,
-};
-
-pub use rusqlite::ffi::libsql_pghdr as PgHdr;
-pub use rusqlite::ffi::libsql_wal as Wal;
-pub use rusqlite::ffi::*;
+pub use libsql::ffi::libsql_pghdr as PgHdr;
+pub use libsql::ffi::libsql_wal as Wal;
+pub use libsql::ffi::*;
 
 pub struct PageHdrIter {
     current_ptr: *const PgHdr,

sqld-libsql-bindings/src/ffi/mod.rs

@@ -2,7 +2,7 @@
 use std::ffi::{c_char, c_int, c_uint, c_void};
 
 use super::{libsql_wal_methods, sqlite3_file, sqlite3_vfs, PgHdr, Wal};
-use rusqlite::ffi::sqlite3;
+use libsql::ffi::sqlite3;
 
 // WAL methods
 pub type XWalLimitFn = extern "C" fn(wal: *mut Wal, limit: i64);
@@ -18,7 +18,7 @@ pub type XWalSavepointFn = extern "C" fn(wal: *mut Wal, wal_data: *mut u32);
 pub type XWalSavePointUndoFn = unsafe extern "C" fn(wal: *mut Wal, wal_data: *mut u32) -> c_int;
 pub type XWalCheckpointFn = unsafe extern "C" fn(
     wal: *mut Wal,
-    db: *mut rusqlite::ffi::sqlite3,
+    db: *mut libsql::ffi::sqlite3,
     emode: c_int,
     busy_handler: Option<unsafe extern "C" fn(busy_param: *mut c_void) -> c_int>,
     busy_arg: *mut c_void,
@@ -32,7 +32,7 @@ pub type XWalCallbackFn = extern "C" fn(wal: *mut Wal) -> c_int;
 pub type XWalExclusiveModeFn = extern "C" fn(wal: *mut Wal, op: c_int) -> c_int;
 pub type XWalHeapMemoryFn = extern "C" fn(wal: *mut Wal) -> c_int;
 pub type XWalFileFn = extern "C" fn(wal: *mut Wal) -> *mut sqlite3_file;
-pub type XWalDbFn = extern "C" fn(wal: *mut Wal, db: *mut rusqlite::ffi::sqlite3);
+pub type XWalDbFn = extern "C" fn(wal: *mut Wal, db: *mut libsql::ffi::sqlite3);
 pub type XWalPathNameLenFn = extern "C" fn(orig_len: c_int) -> c_int;
 pub type XWalGetPathNameFn = extern "C" fn(buf: *mut c_char, orig: *const c_char, orig_len: c_int);
 pub type XWalPreMainDbOpen =

sqld-libsql-bindings/src/ffi/types.rs

@@ -3,11 +3,13 @@
 pub mod ffi;
 pub mod wal_hook;
 
-use std::{ffi::CString, marker::PhantomData, ops::Deref, time::Duration};
+use std::{ffi::CString, marker::PhantomData, ops::Deref};
 
 pub use crate::wal_hook::WalMethodsHook;
 pub use once_cell::sync::Lazy;
 
+pub use libsql;
+
 use self::{
     ffi::{libsql_wal_methods, libsql_wal_methods_find},
     wal_hook::WalHook,
@@ -23,41 +25,25 @@ pub fn get_orig_wal_methods() -> anyhow::Result<*mut libsql_wal_methods> {
 }
 
 pub struct Connection<'a> {
-    conn: rusqlite::Connection,
+    conn: libsql::Connection,
     _pth: PhantomData<&'a mut ()>,
 }
 
 impl Deref for Connection<'_> {
-    type Target = rusqlite::Connection;
+    type Target = libsql::Connection;
 
     fn deref(&self) -> &Self::Target {
         &self.conn
     }
 }
 
-impl Drop for Connection<'_> {
-    fn drop(&mut self) {
-        unsafe {
-            let db = self.conn.handle();
-            if db.is_null() {
-                return;
-            }
-            let mut stmt = ffi::sqlite3_next_stmt(db, std::ptr::null_mut());
-            while !stmt.is_null() {
-                let rc = ffi::sqlite3_finalize(stmt);
-                if rc != ffi::SQLITE_OK {
-                    tracing::error!("Failed to finalize a dangling statement: {rc}")
-                }
-                stmt = ffi::sqlite3_next_stmt(db, stmt);
-            }
-        }
-    }
-}
-
 impl<'a> Connection<'a> {
     /// returns a dummy, in-memory connection. For testing purposes only
     pub fn test(_: &mut ()) -> Self {
-        let conn = rusqlite::Connection::open_in_memory().unwrap();
+        let conn = libsql::Database::open(":memory:")
+            .unwrap()
+            .connect()
+            .unwrap();
         Self {
             conn,
             _pth: PhantomData,
@@ -67,12 +53,12 @@ impl<'a> Connection<'a> {
     /// Opens a database with the regular wal methods in the directory pointed to by path
     pub fn open<W: WalHook>(
         path: impl AsRef<std::path::Path>,
-        flags: rusqlite::OpenFlags,
+        flags: std::ffi::c_int,
         // we technically _only_ need to know about W, but requiring a static ref to the wal_hook ensures that
         // it has been instanciated and lives for long enough
         _wal_hook: &'static WalMethodsHook<W>,
         hook_ctx: &'a mut W::Context,
-    ) -> Result<Self, rusqlite::Error> {
+    ) -> Result<Self, std::ffi::c_int> {
         let path = path.as_ref().join("data");
         tracing::trace!(
             "Opening a connection with regular WAL at {}",
@@ -81,34 +67,31 @@ impl<'a> Connection<'a> {
 
         let conn_str = format!("file:{}?_journal_mode=WAL", path.display());
         let filename = CString::new(conn_str).unwrap();
-        let mut db: *mut rusqlite::ffi::sqlite3 = std::ptr::null_mut();
+        let mut db: *mut ffi::sqlite3 = std::ptr::null_mut();
 
         unsafe {
             // We pass a pointer to the WAL methods data to the database connection. This means
             // that the reference must outlive the connection. This is guaranteed by the marker in
             // the returned connection.
-            let rc = rusqlite::ffi::libsql_open_v2(
+            let rc = ffi::libsql_open_v2(
                 filename.as_ptr(),
                 &mut db as *mut _,
-                flags.bits(),
+                flags,
                 std::ptr::null_mut(),
                 W::name().as_ptr(),
                 hook_ctx as *mut _ as *mut _,
             );
 
             if rc != 0 {
-                rusqlite::ffi::sqlite3_close(db);
-                return Err(rusqlite::Error::SqliteFailure(
-                    rusqlite::ffi::Error::new(rc),
-                    None,
-                ));
+                ffi::sqlite3_close(db);
+                return Err(rc);
             }
 
             assert!(!db.is_null());
+            ffi::sqlite3_busy_timeout(db, 5000);
         };
 
-        let conn = unsafe { rusqlite::Connection::from_handle_owned(db)? };
-        conn.busy_timeout(Duration::from_millis(5000))?;
+        let conn = libsql::Connection::from_handle(db);
 
         Ok(Connection {
             conn,

sqld-libsql-bindings/src/lib.rs

@@ -227,7 +227,7 @@ fn get_methods<T>(wal: &mut Wal) -> &mut WalMethodsHook<T> {
 #[allow(non_snake_case)]
 pub extern "C" fn xClose<T: WalHook>(
     wal: *mut Wal,
-    db: *mut rusqlite::ffi::sqlite3,
+    db: *mut libsql::ffi::sqlite3,
     sync_flags: i32,
     n_buf: c_int,
     z_buf: *mut u8,
@@ -343,7 +343,7 @@ pub extern "C" fn xFrames<T: WalHook>(
 #[allow(non_snake_case)]
 pub extern "C" fn xCheckpoint<T: WalHook>(
     wal: *mut Wal,
-    db: *mut rusqlite::ffi::sqlite3,
+    db: *mut libsql::ffi::sqlite3,
     emode: c_int,
     busy_handler: Option<unsafe extern "C" fn(busy_param: *mut c_void) -> c_int>,
     busy_arg: *mut c_void,
@@ -395,7 +395,7 @@ pub extern "C" fn xFile<T: WalHook>(wal: *mut Wal) -> *mut sqlite3_file {
 }
 
 #[allow(non_snake_case)]
-pub extern "C" fn xDb<T: WalHook>(wal: *mut Wal, db: *mut rusqlite::ffi::sqlite3) {
+pub extern "C" fn xDb<T: WalHook>(wal: *mut Wal, db: *mut libsql::ffi::sqlite3) {
     let orig_methods = unsafe { get_orig_methods::<T>(&mut *wal) };
     unsafe { (orig_methods.xDb.unwrap())(wal, db) }
 }

sqld-libsql-bindings/src/wal_hook.rs

@@ -27,6 +27,7 @@ hyper = { version = "0.14.23", features = ["http2"] }
 hyper-tungstenite = "0.10"
 itertools = "0.10.5"
 jsonwebtoken = "8.2.0"
+libsql = { workspace = true }
 memmap = "0.7.0"
 mimalloc = { version = "0.1.36", default-features = false }
 nix = { version = "0.26.2", features = ["fs"] }
@@ -37,7 +38,6 @@ prost = "0.11.3"
 rand = "0.8"
 regex = "1.7.0"
 reqwest = { version = "0.11.16", features = ["json", "rustls-tls"], default-features = false }
-rusqlite = { workspace = true }
 serde = { version = "1.0.149", features = ["derive", "rc"] }
 serde_json = { version = "1.0.91", features = ["preserve_order"] }
 sha2 = "0.10"
@@ -76,4 +76,4 @@ vergen = { version = "8", features = ["build", "git", "gitcl"] }
 
 [features]
 unix-excl-vfs = ["sqld-libsql-bindings/unix-excl-vfs"]
-debug-tools = ["console-subscriber", "rusqlite/trace", "tokio/tracing"]
+debug-tools = ["console-subscriber", "tokio/tracing"]

sqld/Cargo.toml

@@ -3,26 +3,25 @@ use std::ffi::CString;
 use std::fmt::{Display, Write as _};
 use std::io::Write;
 
-use anyhow::bail;
-use rusqlite::types::ValueRef;
-use rusqlite::OptionalExtension;
+use anyhow::{bail, Context};
+use libsql::params::{Params, ValueRef};
 
 struct DumpState<W: Write> {
     /// true if db is in writable_schema mode
     writable_schema: bool,
     writer: W,
 }
 
-use rusqlite::ffi::{sqlite3_keyword_check, sqlite3_table_column_metadata, SQLITE_OK};
+use sqld_libsql_bindings::ffi::{sqlite3_keyword_check, sqlite3_table_column_metadata, SQLITE_OK};
 
 impl<W: Write> DumpState<W> {
     fn run_schema_dump_query(
         &mut self,
-        txn: &rusqlite::Connection,
+        txn: &libsql::Connection,
         stmt: &str,
     ) -> anyhow::Result<()> {
-        let mut stmt = txn.prepare(stmt)?;
-        let mut rows = stmt.query(())?;
+        let stmt = txn.prepare(stmt)?;
+        let rows = stmt.execute(&Params::None).context("Empty response")?;
         while let Some(row) = rows.next()? {
             let ValueRef::Text(table) = row.get_ref(0)? else { bail!("invalid schema table") };
             let ValueRef::Text(ty) = row.get_ref(1)? else { bail!("invalid schema table") };
@@ -92,8 +91,8 @@ impl<W: Write> DumpState<W> {
 
                 write!(&mut select, " FROM {}", Quoted(table_str))?;
 
-                let mut stmt = txn.prepare(&select)?;
-                let mut rows = stmt.query(())?;
+                let stmt = txn.prepare(&select)?;
+                let rows = stmt.execute(&Params::None).context("Empty response")?;
                 while let Some(row) = rows.next()? {
                     write!(self.writer, "{insert}")?;
                     if row_id_col.is_some() {
@@ -105,7 +104,7 @@ impl<W: Write> DumpState<W> {
                         if i != 0 || row_id_col.is_some() {
                             write!(self.writer, ",")?;
                         }
-                        write_value_ref(&mut self.writer, row.get_ref(i)?)?;
+                        write_value_ref(&mut self.writer, row.get_ref(i as i32)?)?;
                     }
                     writeln!(self.writer, ");")?;
                 }
@@ -115,15 +114,15 @@ impl<W: Write> DumpState<W> {
         Ok(())
     }
 
-    fn run_table_dump_query(&mut self, txn: &rusqlite::Connection, q: &str) -> anyhow::Result<()> {
-        let mut stmt = txn.prepare(q)?;
+    fn run_table_dump_query(&mut self, txn: &libsql::Connection, q: &str) -> anyhow::Result<()> {
+        let stmt = txn.prepare(q)?;
         let col_count = stmt.column_count();
-        let mut rows = stmt.query(())?;
+        let rows = stmt.execute(&Params::None).context("Empty response")?;
         while let Some(row) = rows.next()? {
             let ValueRef::Text(sql) = row.get_ref(0)? else { bail!("the first row in a table dump query should be of type text") };
             self.writer.write_all(sql)?;
             for i in 1..col_count {
-                let ValueRef::Text(s) = row.get_ref(i)? else { bail!("row {i} in table dump query should be of type text") };
+                let ValueRef::Text(s) = row.get_ref(i as i32)? else { bail!("row {i} in table dump query should be of type text") };
                 let s = std::str::from_utf8(s)?;
                 write!(self.writer, ",{s}")?;
             }
@@ -134,7 +133,7 @@ impl<W: Write> DumpState<W> {
 
     fn list_table_columns(
         &self,
-        txn: &rusqlite::Connection,
+        txn: &libsql::Connection,
         table: &str,
     ) -> anyhow::Result<(Option<String>, Vec<String>)> {
         let mut cols = Vec::new();
@@ -143,18 +142,18 @@ impl<W: Write> DumpState<W> {
         let mut preserve_row_id = false;
         let mut row_id_col = None;
 
-        txn.pragma(None, "table_info", table, |row| {
-            let name: String = row.get_unwrap(1);
-            cols.push(name);
-            // this is a primary key col
-            if row.get_unwrap::<_, usize>(5) != 0 {
-                num_primary_keys += 1;
-                is_integer_primary_key = num_primary_keys == 1
-                    && matches!(row.get_ref_unwrap(2), ValueRef::Text(b"INTEGER"));
+        if let Some(results) = txn.execute("pragma table_info", ())? {
+            while let Ok(Some(row)) = results.next() {
+                let name: String = row.get(1).unwrap();
+                cols.push(name);
+                // this is a primary key col
+                if row.get::<i64>(5).unwrap() != 0 {
+                    num_primary_keys += 1;
+                    is_integer_primary_key = num_primary_keys == 1
+                        && matches!(row.get_ref(2).unwrap(), ValueRef::Text(b"INTEGER"));
+                }
             }
-
-            Ok(())
-        })?;
+        }
 
         // from sqlite:
         // > The decision of whether or not a rowid really needs to be preserved
@@ -171,16 +170,12 @@ impl<W: Write> DumpState<W> {
             // > there is a "pk" entry in "PRAGMA index_list".  There will be
             // > no "pk" index if the PRIMARY KEY really is an alias for the ROWID.
 
-            txn.query_row(
-                "SELECT 1 FROM pragma_index_list(?)  WHERE origin='pk'",
-                [table],
-                |_| {
-                    // re-set preserve_row_id iif there is a row
-                    preserve_row_id = true;
-                    Ok(())
-                },
-            )
-            .optional()?;
+            if let Ok(Some(rows)) = txn.execute(
+                "SELECT 1 FROM pragma_index_list(?) WHERE origin='pk'",
+                Params::Positional(vec![table.into()]),
+            ) {
+                preserve_row_id = rows.next()?.is_none();
+            }
         }
 
         if preserve_row_id {
@@ -206,7 +201,7 @@ impl<W: Write> DumpState<W> {
                         )
                     };
 
-                    if rc == SQLITE_OK {
+                    if rc == SQLITE_OK as i32 {
                         row_id_col = Some(row_id_name.to_owned());
                         break;
                     }
@@ -420,10 +415,11 @@ fn find_unused_str(haystack: &str, needle1: &str, needle2: &str) -> String {
     }
 }
 
-pub fn export_dump(mut db: rusqlite::Connection, writer: impl Write) -> anyhow::Result<()> {
-    let mut txn = db.transaction()?;
-    txn.execute("PRAGMA writable_schema=ON", ())?;
-    let savepoint = txn.savepoint_with_name("dump")?;
+pub fn export_dump(mut db: libsql::Connection, writer: impl Write) -> anyhow::Result<()> {
+    db.execute("BEGIN", ())?;
+    db.execute("PRAGMA writable_schema=ON", ())?;
+    // FIXME: savepoint logic is lost during the out-of-rusqlite migration, we need to restore it
+    db.execute("SAVEPOINT dump", ())?;
     let mut state = DumpState {
         writable_schema: false,
         writer,
@@ -441,21 +437,21 @@ pub fn export_dump(mut db: rusqlite::Connection, writer: impl Write) -> anyhow::
 WHERE type=='table' 
 AND sql NOT NULL 
 ORDER BY tbl_name='sqlite_sequence', rowid";
-    state.run_schema_dump_query(&savepoint, q)?;
+    state.run_schema_dump_query(&mut db, q)?;
 
     let q = "SELECT sql FROM sqlite_schema AS o 
 WHERE sql NOT NULL 
 AND type IN ('index','trigger','view')";
-    state.run_table_dump_query(&savepoint, q)?;
+    state.run_table_dump_query(&mut db, q)?;
 
     if state.writable_schema {
         writeln!(state.writer, "PRAGMA writable_schema=OFF;")?;
     }
 
     writeln!(state.writer, "COMMIT;")?;
 
-    let _ = savepoint.execute("PRAGMA writable_schema = OFF;", ());
-    let _ = savepoint.finish();
+    db.execute("PRAGMA writable_schema = OFF;", ())?;
+    db.execute("COMMIT", ())?;
 
     Ok(())
 }

sqld/src/database/dump/exporter.rs

@@ -5,14 +5,13 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use anyhow::anyhow;
-use rusqlite::ErrorCode;
 use tokio::sync::{mpsc, oneshot};
 
 use crate::database::libsql::open_db;
 use crate::replication::primary::logger::{ReplicationLoggerHookCtx, REPLICATION_METHODS};
 use crate::replication::ReplicationLogger;
 
-type OpMsg = Box<dyn FnOnce(&rusqlite::Connection) + 'static + Send + Sync>;
+type OpMsg = Box<dyn FnOnce(&libsql::Connection) + 'static + Send + Sync>;
 
 #[derive(Debug)]
 pub struct DumpLoader {
@@ -25,6 +24,7 @@ impl DumpLoader {
         logger: Arc<ReplicationLogger>,
         bottomless_replicator: Option<Arc<std::sync::Mutex<bottomless::replicator::Replicator>>>,
     ) -> anyhow::Result<Self> {
+        const BUSY: i32 = sqld_libsql_bindings::ffi::SQLITE_BUSY as i32;
         let (sender, mut receiver) = mpsc::channel::<OpMsg>(1);
 
         let (ok_snd, ok_rcv) = oneshot::channel::<anyhow::Result<()>>();
@@ -43,13 +43,7 @@ impl DumpLoader {
                     // Creating the loader database can, in rare occurences, return sqlite busy,
                     // because of a race condition opening the monitor thread db. This is there to
                     // retry a bunch of times if that happens.
-                    Err(rusqlite::Error::SqliteFailure(
-                        rusqlite::ffi::Error {
-                            code: ErrorCode::DatabaseBusy,
-                            ..
-                        },
-                        _,
-                    )) if retries < 10 => {
+                    Err(libsql::Error::LibError(BUSY)) if retries < 10 => {
                         retries += 1;
                         std::thread::sleep(Duration::from_millis(100));
                     }
@@ -93,7 +87,7 @@ impl DumpLoader {
 const WASM_TABLE_CREATE: &str =
     "CREATE TABLE libsql_wasm_func_table (name text PRIMARY KEY, body text) WITHOUT ROWID;";
 
-fn perform_load_dump(conn: &rusqlite::Connection, path: PathBuf) -> anyhow::Result<()> {
+fn perform_load_dump(conn: &libsql::Connection, path: PathBuf) -> anyhow::Result<()> {
     let mut f = BufReader::new(File::open(path)?);
     let mut curr = String::new();
     let mut line = String::new();

sqld/src/database/dump/loader.rs

@@ -3,7 +3,6 @@ use std::sync::Arc;
 use std::time::{Duration, Instant};
 
 use crossbeam::channel::RecvTimeoutError;
-use rusqlite::{ErrorCode, OpenFlags, StatementStatus};
 use sqld_libsql_bindings::wal_hook::WalMethodsHook;
 use tokio::sync::oneshot;
 use tracing::warn;
@@ -78,18 +77,11 @@ where
     async fn try_create_db(&self) -> Result<LibSqlDb> {
         // try 100 times to acquire initial db connection.
         let mut retries = 0;
+        const BUSY: i32 = sqld_libsql_bindings::ffi::SQLITE_BUSY as std::ffi::c_int;
         loop {
             match self.create_database().await {
                 Ok(conn) => return Ok(conn),
-                Err(
-                    err @ Error::RusqliteError(rusqlite::Error::SqliteFailure(
-                        rusqlite::ffi::Error {
-                            code: ErrorCode::DatabaseBusy,
-                            ..
-                        },
-                        _,
-                    )),
-                ) => {
+                Err(err @ Error::LibSqlError(libsql::Error::LibError(BUSY))) => {
                     if retries < 100 {
                         tracing::warn!("Database file is busy, retrying...");
                         retries += 1;
@@ -141,19 +133,20 @@ pub fn open_db<'a, W>(
     path: &Path,
     wal_methods: &'static WalMethodsHook<W>,
     hook_ctx: &'a mut W::Context,
-    flags: Option<OpenFlags>,
-) -> Result<sqld_libsql_bindings::Connection<'a>, rusqlite::Error>
+    flags: Option<std::ffi::c_int>,
+) -> Result<sqld_libsql_bindings::Connection<'a>, libsql::Error>
 where
     W: WalHook,
 {
     let flags = flags.unwrap_or(
-        OpenFlags::SQLITE_OPEN_READ_WRITE
-            | OpenFlags::SQLITE_OPEN_CREATE
-            | OpenFlags::SQLITE_OPEN_URI
-            | OpenFlags::SQLITE_OPEN_NO_MUTEX,
+        (sqld_libsql_bindings::ffi::SQLITE_OPEN_READWRITE
+            | sqld_libsql_bindings::ffi::SQLITE_OPEN_CREATE
+            | sqld_libsql_bindings::ffi::SQLITE_OPEN_URI
+            | sqld_libsql_bindings::ffi::SQLITE_OPEN_NOMUTEX) as i32,
     );
 
     sqld_libsql_bindings::Connection::open(path, flags, wal_methods, hook_ctx)
+        .map_err(|rc| libsql::Error::LibError(rc))
 }
 
 impl LibSqlDb {
@@ -261,14 +254,21 @@ impl<'a> Connection<'a> {
         };
 
         for ext in extensions {
-            unsafe {
-                let _guard = rusqlite::LoadExtensionGuard::new(&this.conn).unwrap();
-                if let Err(e) = this.conn.load_extension(&ext, None) {
-                    tracing::error!("failed to load extension: {}", ext.display());
-                    Err(e)?;
-                }
-                tracing::debug!("Loaded extension {}", ext.display());
+            let rc = unsafe {
+                // FIXME: gather the error message from the 4th param and print/return it
+                // if applicable.
+                libsql::ffi::sqlite3_load_extension(
+                    this.conn.handle(),
+                    ext.to_str().unwrap().as_ptr() as *const _,
+                    std::ptr::null(),
+                    std::ptr::null_mut(),
+                )
+            };
+            if rc != libsql::ffi::SQLITE_OK as i32 {
+                tracing::error!("failed to load extension: {}", ext.display());
+                Err(libsql::Error::LibError(rc))?;
             }
+            tracing::debug!("Loaded extension {}", ext.display());
         }
 
         Ok(this)
@@ -354,26 +354,28 @@ impl<'a> Connection<'a> {
 
         let cols = stmt.columns();
         let cols_count = cols.len();
-        builder.cols_description(cols.iter())?;
-        drop(cols);
+        builder.cols_description(cols.into_iter())?;
 
         query
             .params
             .bind(&mut stmt)
             .map_err(Error::LibSqlInvalidQueryParams)?;
 
-        let mut qresult = stmt.raw_query();
-        builder.begin_rows()?;
-        while let Some(row) = qresult.next()? {
-            builder.begin_row()?;
-            for i in 0..cols_count {
-                let val = row.get_ref(i)?;
-                builder.add_row_value(val)?;
+        // FIXME: in current libsql implementation, the error will only be returned
+        // upon first call to `next()`. Let's reconsider? That's not very intuitive.
+        if let Some(qresult) = stmt.execute(&libsql::Params::None) {
+            builder.begin_rows()?;
+            while let Some(row) = qresult.next()? {
+                builder.begin_row()?;
+                for i in 0..cols_count {
+                    let val = row.get_ref(i as i32)?;
+                    builder.add_row_value(val)?;
+                }
+                builder.finish_row()?;
             }
-            builder.finish_row()?;
-        }
 
-        builder.finish_rows()?;
+            builder.finish_rows()?;
+        }
 
         // sqlite3_changes() is only modified for INSERT, UPDATE or DELETE; it is not reset for SELECT,
         // but we want to return 0 in that case.
@@ -389,8 +391,6 @@ impl<'a> Connection<'a> {
             false => None,
         };
 
-        drop(qresult);
-
         self.update_stats(&stmt);
 
         Ok((affected_row_count, last_insert_rowid))
@@ -400,9 +400,10 @@ impl<'a> Connection<'a> {
         let _ = self.conn.execute("ROLLBACK", ());
     }
 
-    fn update_stats(&self, stmt: &rusqlite::Statement) {
-        let rows_read = stmt.get_status(StatementStatus::RowsRead);
-        let rows_written = stmt.get_status(StatementStatus::RowsWritten);
+    fn update_stats(&self, stmt: &libsql::Statement) {
+        use sqld_libsql_bindings::ffi;
+        let rows_read = stmt.get_status(ffi::LIBSQL_STMTSTATUS_ROWS_READ as i32);
+        let rows_written = stmt.get_status(ffi::LIBSQL_STMTSTATUS_ROWS_WRITTEN as i32);
         let rows_read = if rows_read == 0 && rows_written == 0 {
             1
         } else {
@@ -417,7 +418,7 @@ impl<'a> Connection<'a> {
 
         let params = (1..=stmt.parameter_count())
             .map(|param_i| {
-                let name = stmt.parameter_name(param_i).map(|n| n.into());
+                let name = stmt.parameter_name(param_i as i32).map(|n| n.into());
                 DescribeParam { name }
             })
             .collect();

sqld/src/database/libsql.rs

@@ -2,7 +2,6 @@ use std::path::PathBuf;
 use std::sync::Arc;
 
 use parking_lot::Mutex as PMutex;
-use rusqlite::types::ValueRef;
 use sqld_libsql_bindings::wal_hook::TRANSPARENT_METHODS;
 use tokio::sync::{watch, Mutex};
 use tonic::transport::Channel;
@@ -25,6 +24,7 @@ use crate::Result;
 use super::config::DatabaseConfigStore;
 use super::Program;
 use super::{factory::DbFactory, libsql::LibSqlDb, Database, DescribeResult};
+use libsql::params::ValueRef;
 
 #[derive(Clone)]
 pub struct WriteProxyDbFactory {
@@ -108,7 +108,7 @@ fn execute_results_to_builder<B: QueryResultBuilder>(
                 builder.begin_step()?;
                 builder.cols_description(rows.column_descriptions.iter().map(|c| Column {
                     name: &c.name,
-                    decl_ty: c.decltype.as_deref(),
+                    decl_type: c.decltype.as_deref(),
                 }))?;
 
                 builder.begin_rows()?;

sqld/src/database/write_proxy.rs

@@ -12,7 +12,7 @@ pub enum Error {
     #[error(transparent)]
     IOError(#[from] std::io::Error),
     #[error(transparent)]
-    RusqliteError(#[from] rusqlite::Error),
+    LibSqlError(#[from] libsql::Error),
     #[error("Failed to execute query via RPC. Error code: {}, message: {}", .0.code, .0.message)]
     RpcQueryError(crate::rpc::proxy::rpc::Error),
     #[error("Failed to execute queries via RPC protocol: `{0}`")]

sqld/src/error.rs

@@ -2,7 +2,7 @@ use std::fmt::{self, Write as _};
 use std::io;
 
 use bytes::Bytes;
-use rusqlite::types::ValueRef;
+use libsql::params::ValueRef;
 
 use crate::hrana::stmt::{proto_error_from_stmt_error, stmt_error_from_sqld_error};
 use crate::query_result_builder::{
@@ -115,7 +115,7 @@ impl QueryResultBuilder for SingleStatementBuilder {
             cols_size += estimate_cols_json_size(&c);
             proto::Col {
                 name: Some(c.name.to_owned()),
-                decltype: c.decl_ty.map(ToString::to_string),
+                decltype: c.decl_type.map(ToString::to_string),
             }
         }));
 
@@ -207,7 +207,7 @@ fn estimate_cols_json_size(c: &Column) -> u64 {
         &mut f,
         r#"{{"name":"{}","decltype":"{}"}}"#,
         c.name,
-        c.decl_ty.unwrap_or("null")
+        c.decl_type.unwrap_or("null")
     )
     .unwrap();
     f.0

sqld/src/hrana/result_builder.rs

@@ -1,4 +1,5 @@
 use anyhow::{anyhow, bail, Result};
+use sqld_libsql_bindings::ffi;
 use std::collections::HashMap;
 
 use super::result_builder::SingleStatementBuilder;
@@ -31,16 +32,9 @@ pub enum StmtError {
     TransactionBusy,
     #[error("SQLite error: {message}")]
     SqliteError {
-        source: rusqlite::ffi::Error,
+        source: libsql::Error,
         message: String,
     },
-    #[error("SQL input error: {message} (at offset {offset})")]
-    SqlInputError {
-        source: rusqlite::ffi::Error,
-        message: String,
-        offset: i32,
-    },
-
     #[error("Operation was blocked{}", .reason.as_ref().map(|msg| format!(": {}", msg)).unwrap_or_default())]
     Blocked { reason: Option<String> },
     #[error("Response is too large")]
@@ -202,26 +196,9 @@ pub fn stmt_error_from_sqld_error(sqld_error: SqldError) -> Result<StmtError, Sq
             StmtError::ResponseTooLarge
         }
         SqldError::Blocked(reason) => StmtError::Blocked { reason },
-        SqldError::RusqliteError(rusqlite_error) => match rusqlite_error {
-            rusqlite::Error::SqliteFailure(sqlite_error, Some(message)) => StmtError::SqliteError {
-                source: sqlite_error,
-                message,
-            },
-            rusqlite::Error::SqliteFailure(sqlite_error, None) => StmtError::SqliteError {
-                message: sqlite_error.to_string(),
-                source: sqlite_error,
-            },
-            rusqlite::Error::SqlInputError {
-                error: sqlite_error,
-                msg: message,
-                offset,
-                ..
-            } => StmtError::SqlInputError {
-                source: sqlite_error,
-                message,
-                offset,
-            },
-            rusqlite_error => return Err(SqldError::RusqliteError(rusqlite_error)),
+        SqldError::LibSqlError(libsql::Error::LibError(rc)) => StmtError::SqliteError {
+            message: libsql::errors::error_from_code(rc),
+            source: libsql::Error::LibError(rc),
         },
         sqld_error => return Err(sqld_error),
     })
@@ -244,40 +221,41 @@ impl StmtError {
             Self::ArgsBothPositionalAndNamed => "ARGS_BOTH_POSITIONAL_AND_NAMED",
             Self::TransactionTimeout => "TRANSACTION_TIMEOUT",
             Self::TransactionBusy => "TRANSACTION_BUSY",
-            Self::SqliteError { source, .. } => sqlite_error_code(source.code),
-            Self::SqlInputError { .. } => "SQL_INPUT_ERROR",
+            Self::SqliteError { source, .. } => sqlite_error_code(source),
             Self::Blocked { .. } => "BLOCKED",
             Self::ResponseTooLarge => "RESPONSE_TOO_LARGE",
         }
     }
 }
 
-fn sqlite_error_code(code: rusqlite::ffi::ErrorCode) -> &'static str {
-    match code {
-        rusqlite::ErrorCode::InternalMalfunction => "SQLITE_INTERNAL",
-        rusqlite::ErrorCode::PermissionDenied => "SQLITE_PERM",
-        rusqlite::ErrorCode::OperationAborted => "SQLITE_ABORT",
-        rusqlite::ErrorCode::DatabaseBusy => "SQLITE_BUSY",
-        rusqlite::ErrorCode::DatabaseLocked => "SQLITE_LOCKED",
-        rusqlite::ErrorCode::OutOfMemory => "SQLITE_NOMEM",
-        rusqlite::ErrorCode::ReadOnly => "SQLITE_READONLY",
-        rusqlite::ErrorCode::OperationInterrupted => "SQLITE_INTERRUPT",
-        rusqlite::ErrorCode::SystemIoFailure => "SQLITE_IOERR",
-        rusqlite::ErrorCode::DatabaseCorrupt => "SQLITE_CORRUPT",
-        rusqlite::ErrorCode::NotFound => "SQLITE_NOTFOUND",
-        rusqlite::ErrorCode::DiskFull => "SQLITE_FULL",
-        rusqlite::ErrorCode::CannotOpen => "SQLITE_CANTOPEN",
-        rusqlite::ErrorCode::FileLockingProtocolFailed => "SQLITE_PROTOCOL",
-        rusqlite::ErrorCode::SchemaChanged => "SQLITE_SCHEMA",
-        rusqlite::ErrorCode::TooBig => "SQLITE_TOOBIG",
-        rusqlite::ErrorCode::ConstraintViolation => "SQLITE_CONSTRAINT",
-        rusqlite::ErrorCode::TypeMismatch => "SQLITE_MISMATCH",
-        rusqlite::ErrorCode::ApiMisuse => "SQLITE_MISUSE",
-        rusqlite::ErrorCode::NoLargeFileSupport => "SQLITE_NOLFS",
-        rusqlite::ErrorCode::AuthorizationForStatementDenied => "SQLITE_AUTH",
-        rusqlite::ErrorCode::ParameterOutOfRange => "SQLITE_RANGE",
-        rusqlite::ErrorCode::NotADatabase => "SQLITE_NOTADB",
-        rusqlite::ErrorCode::Unknown => "SQLITE_UNKNOWN",
+fn sqlite_error_code(err: &libsql::Error) -> &'static str {
+    match err {
+        libsql::Error::LibError(code) => match (*code) as u32 {
+            ffi::SQLITE_INTERNAL => "SQLITE_INTERNAL",
+            ffi::SQLITE_PERM => "SQLITE_PERM",
+            ffi::SQLITE_ABORT => "SQLITE_ABORT",
+            ffi::SQLITE_BUSY => "SQLITE_BUSY",
+            ffi::SQLITE_LOCKED => "SQLITE_LOCKED",
+            ffi::SQLITE_NOMEM => "SQLITE_NOMEM",
+            ffi::SQLITE_READONLY => "SQLITE_READONLY",
+            ffi::SQLITE_INTERRUPT => "SQLITE_INTERRUPT",
+            ffi::SQLITE_IOERR => "SQLITE_IOERR",
+            ffi::SQLITE_CORRUPT => "SQLITE_CORRUPT",
+            ffi::SQLITE_NOTFOUND => "SQLITE_NOTFOUND",
+            ffi::SQLITE_FULL => "SQLITE_FULL",
+            ffi::SQLITE_CANTOPEN => "SQLITE_CANTOPEN",
+            ffi::SQLITE_PROTOCOL => "SQLITE_PROTOCOL",
+            ffi::SQLITE_SCHEMA => "SQLITE_SCHEMA",
+            ffi::SQLITE_TOOBIG => "SQLITE_TOOBIG",
+            ffi::SQLITE_CONSTRAINT => "SQLITE_CONSTRAINT",
+            ffi::SQLITE_MISMATCH => "SQLITE_MISMATCH",
+            ffi::SQLITE_MISUSE => "SQLITE_MISUSE",
+            ffi::SQLITE_NOLFS => "SQLITE_NOLFS",
+            ffi::SQLITE_AUTH => "SQLITE_AUTH",
+            ffi::SQLITE_RANGE => "SQLITE_RANGE",
+            ffi::SQLITE_NOTADB => "SQLITE_NOTADB",
+            _ => "SQLITE_UNKNOWN",
+        },
         _ => "SQLITE_UNKNOWN",
     }
 }

sqld/src/hrana/stmt.rs

@@ -137,7 +137,6 @@ fn response_error_response(err: ResponseError) -> hyper::Response<hyper::Body> {
             | StmtError::SqlNoStmt
             | StmtError::SqlManyStmts
             | StmtError::ArgsInvalid { .. }
-            | StmtError::SqlInputError { .. }
             | StmtError::ResponseTooLarge
             | StmtError::Blocked { .. } => hyper::StatusCode::BAD_REQUEST,
             StmtError::ArgsBothPositionalAndNamed => hyper::StatusCode::NOT_IMPLEMENTED,

sqld/src/http/hrana_over_http_1.rs

@@ -1,7 +1,7 @@
+use libsql::params::ValueRef;
 use std::io;
 use std::ops::{Deref, DerefMut};
 
-use rusqlite::types::ValueRef;
 use serde::{Serialize, Serializer};
 use serde_json::ser::{CompactFormatter, Formatter};
 
@@ -70,7 +70,7 @@ impl io::Write for LimitBuffer {
     }
 }
 
-struct HttpJsonValueSerializer<'a>(&'a ValueRef<'a>);
+struct HttpJsonValueSerializer<'a>(&'a libsql::params::ValueRef<'a>);
 
 impl JsonHttpPayloadBuilder {
     pub fn new() -> Self {

sqld/src/http/result_builder.rs

@@ -5,10 +5,10 @@ use std::sync::mpsc::RecvTimeoutError;
 use std::sync::Arc;
 use std::time::Duration;
 
+use crate::libsql::wal_hook::TRANSPARENT_METHODS;
 use anyhow::Context as AnyhowContext;
 use enclose::enclose;
 use futures::never::Never;
-use libsql::wal_hook::TRANSPARENT_METHODS;
 use once_cell::sync::Lazy;
 use rpc::run_rpc_server;
 use tokio::sync::{mpsc, Notify};
@@ -551,7 +551,7 @@ async fn run_storage_monitor(db_path: PathBuf, stats: Stats) -> anyhow::Result<(
             // initialize a connection here, and keep it alive for the entirety of the program. If we
             // fail to open it, we wait for `duration` and try again later.
             let ctx = &mut ();
-            let maybe_conn = match open_db(&db_path, &TRANSPARENT_METHODS, ctx, Some(rusqlite::OpenFlags::SQLITE_OPEN_READ_ONLY)) {
+            let maybe_conn = match open_db(&db_path, &TRANSPARENT_METHODS, ctx, Some(sqld_libsql_bindings::ffi::SQLITE_OPEN_READONLY as i32)) {
                 Ok(conn) => Some(conn),
                 Err(e) => {
                     tracing::warn!("failed to open connection for storager monitor: {e}, trying again in {duration:?}");
@@ -561,12 +561,14 @@ async fn run_storage_monitor(db_path: PathBuf, stats: Stats) -> anyhow::Result<(
 
             loop {
                 if let Some(ref conn) = maybe_conn {
-                    if let Ok(storage_bytes_used) =
-                        conn.query_row("select sum(pgsize) from dbstat;", [], |row| {
-                            row.get::<usize, u64>(0)
-                        })
+                    if let Ok(Some(rows)) =
+                        conn.execute("select sum(pgsize) from dbstat;", ())
                     {
-                        stats.set_storage_bytes_used(storage_bytes_used);
+                        if let Ok(Some(storage_bytes_used)) = rows.next() {
+                            if let Ok(storage_bytes_used) = storage_bytes_used.get(0) {
+                                stats.set_storage_bytes_used(storage_bytes_used);
+                            }
+                        }
                     }
                 }
 

sqld/src/lib.rs

@@ -312,7 +312,7 @@ fn perform_dump(dump_path: Option<&Path>, db_path: &Path) -> anyhow::Result<()>
         }
         None => Box::new(stdout()),
     };
-    let conn = rusqlite::Connection::open(db_path.join("data"))?;
+    let conn = libsql::Database::open(db_path.join("data").to_str().unwrap())?.connect()?;
 
     export_dump(conn, out)?;
 
@@ -329,9 +329,11 @@ fn enable_libsql_logging() {
         tracing::error!("sqlite error {code}: {msg}");
     }
 
+    /* FIXME: introduce tracing to libsql/libsql_sys
     ONCE.call_once(|| unsafe {
         rusqlite::trace::config_log(Some(libsql_log)).unwrap();
     });
+    */
 }
 
 #[tokio::main]

sqld/src/main.rs

@@ -1,8 +1,6 @@
 use std::collections::HashMap;
 
 use anyhow::{anyhow, ensure, Context};
-use rusqlite::types::{ToSqlOutput, ValueRef};
-use rusqlite::ToSql;
 use serde::{Deserialize, Serialize};
 
 use crate::query_analysis::Statement;
@@ -18,28 +16,28 @@ pub enum Value {
     Blob(Vec<u8>),
 }
 
-impl<'a> From<&'a Value> for ValueRef<'a> {
+impl<'a> From<&'a Value> for libsql::params::ValueRef<'a> {
     fn from(value: &'a Value) -> Self {
         match value {
-            Value::Null => ValueRef::Null,
-            Value::Integer(i) => ValueRef::Integer(*i),
-            Value::Real(x) => ValueRef::Real(*x),
-            Value::Text(s) => ValueRef::Text(s.as_bytes()),
-            Value::Blob(b) => ValueRef::Blob(b.as_slice()),
+            Value::Null => libsql::params::ValueRef::Null,
+            Value::Integer(i) => libsql::params::ValueRef::Integer(*i),
+            Value::Real(x) => libsql::params::ValueRef::Real(*x),
+            Value::Text(s) => libsql::params::ValueRef::Text(s.as_bytes()),
+            Value::Blob(b) => libsql::params::ValueRef::Blob(b),
         }
     }
 }
 
-impl TryFrom<rusqlite::types::ValueRef<'_>> for Value {
+impl TryFrom<libsql::params::ValueRef<'_>> for Value {
     type Error = anyhow::Error;
 
-    fn try_from(value: rusqlite::types::ValueRef<'_>) -> anyhow::Result<Value> {
+    fn try_from(value: libsql::params::ValueRef<'_>) -> anyhow::Result<Value> {
         let val = match value {
-            rusqlite::types::ValueRef::Null => Value::Null,
-            rusqlite::types::ValueRef::Integer(i) => Value::Integer(i),
-            rusqlite::types::ValueRef::Real(x) => Value::Real(x),
-            rusqlite::types::ValueRef::Text(s) => Value::Text(String::from_utf8(Vec::from(s))?),
-            rusqlite::types::ValueRef::Blob(b) => Value::Blob(Vec::from(b)),
+            libsql::params::ValueRef::Null => Value::Null,
+            libsql::params::ValueRef::Integer(i) => Value::Integer(i),
+            libsql::params::ValueRef::Real(x) => Value::Real(x),
+            libsql::params::ValueRef::Text(s) => Value::Text(String::from_utf8(Vec::from(s))?),
+            libsql::params::ValueRef::Blob(b) => Value::Blob(Vec::from(b)),
         };
 
         Ok(val)
@@ -53,20 +51,6 @@ pub struct Query {
     pub want_rows: bool,
 }
 
-impl ToSql for Value {
-    fn to_sql(&self) -> rusqlite::Result<rusqlite::types::ToSqlOutput<'_>> {
-        let val = match self {
-            Value::Null => ToSqlOutput::Owned(rusqlite::types::Value::Null),
-            Value::Integer(i) => ToSqlOutput::Owned(rusqlite::types::Value::Integer(*i)),
-            Value::Real(x) => ToSqlOutput::Owned(rusqlite::types::Value::Real(*x)),
-            Value::Text(s) => ToSqlOutput::Borrowed(rusqlite::types::ValueRef::Text(s.as_bytes())),
-            Value::Blob(b) => ToSqlOutput::Borrowed(rusqlite::types::ValueRef::Blob(b)),
-        };
-
-        Ok(val)
-    }
-}
-
 #[derive(Debug, Serialize, Clone)]
 pub enum Params {
     Named(HashMap<String, Value>),
@@ -108,7 +92,7 @@ impl Params {
         }
     }
 
-    pub fn bind(&self, stmt: &mut rusqlite::Statement) -> anyhow::Result<()> {
+    pub fn bind(&self, stmt: &mut libsql::Statement) -> anyhow::Result<()> {
         let param_count = stmt.parameter_count();
         ensure!(
             param_count >= self.len(),
@@ -120,7 +104,7 @@ impl Params {
             for index in 1..=param_count {
                 let mut param_name = None;
                 // get by name
-                let maybe_value = match stmt.parameter_name(index) {
+                let maybe_value = match stmt.parameter_name(index as i32) {
                     Some(name) => {
                         param_name = Some(name);
                         let mut chars = name.chars();
@@ -140,7 +124,7 @@ impl Params {
                 };
 
                 if let Some(value) = maybe_value {
-                    stmt.raw_bind_parameter(index, value)?;
+                    stmt.bind_value(index as i32, value.try_into()?);
                 } else if let Some(name) = param_name {
                     return Err(anyhow!("value for parameter {} not found", name));
                 } else {
@@ -159,7 +143,10 @@ mod test {
 
     #[test]
     fn test_bind_params_positional_simple() {
-        let con = rusqlite::Connection::open_in_memory().unwrap();
+        let con = libsql::Database::open(":memory:")
+            .unwrap()
+            .connect()
+            .unwrap();
         let mut stmt = con.prepare("SELECT ?").unwrap();
         let params = Params::new_positional(vec![Value::Integer(10)]);
         params.bind(&mut stmt).unwrap();
@@ -169,7 +156,10 @@ mod test {
 
     #[test]
     fn test_bind_params_positional_numbered() {
-        let con = rusqlite::Connection::open_in_memory().unwrap();
+        let con = libsql::Database::open(":memory:")
+            .unwrap()
+            .connect()
+            .unwrap();
         let mut stmt = con.prepare("SELECT ? || ?2 || ?1").unwrap();
         let params = Params::new_positional(vec![Value::Integer(10), Value::Integer(20)]);
         params.bind(&mut stmt).unwrap();
@@ -179,7 +169,10 @@ mod test {
 
     #[test]
     fn test_bind_params_positional_named() {
-        let con = rusqlite::Connection::open_in_memory().unwrap();
+        let con = libsql::Database::open(":memory:")
+            .unwrap()
+            .connect()
+            .unwrap();
         let mut stmt = con.prepare("SELECT :first || $second").unwrap();
         let mut params = HashMap::new();
         params.insert(":first".to_owned(), Value::Integer(10));
@@ -192,7 +185,10 @@ mod test {
 
     #[test]
     fn test_bind_params_positional_named_no_prefix() {
-        let con = rusqlite::Connection::open_in_memory().unwrap();
+        let con = libsql::Database::open(":memory:")
+            .unwrap()
+            .connect()
+            .unwrap();
         let mut stmt = con.prepare("SELECT :first || $second").unwrap();
         let mut params = HashMap::new();
         params.insert("first".to_owned(), Value::Integer(10));
@@ -205,7 +201,10 @@ mod test {
 
     #[test]
     fn test_bind_params_positional_named_conflict() {
-        let con = rusqlite::Connection::open_in_memory().unwrap();
+        let con = libsql::Database::open(":memory:")
+            .unwrap()
+            .connect()
+            .unwrap();
         let mut stmt = con.prepare("SELECT :first || $first").unwrap();
         let mut params = HashMap::new();
         params.insert("first".to_owned(), Value::Integer(10));
@@ -218,7 +217,10 @@ mod test {
 
     #[test]
     fn test_bind_params_positional_named_repeated() {
-        let con = rusqlite::Connection::open_in_memory().unwrap();
+        let con = libsql::Database::open(":memory:")
+            .unwrap()
+            .connect()
+            .unwrap();
         let mut stmt = con
             .prepare("SELECT :first || $second || $first || $second")
             .unwrap();
@@ -233,7 +235,10 @@ mod test {
 
     #[test]
     fn test_bind_params_too_many_params() {
-        let con = rusqlite::Connection::open_in_memory().unwrap();
+        let con = libsql::Database::open(":memory:")
+            .unwrap()
+            .connect()
+            .unwrap();
         let mut stmt = con.prepare("SELECT :first || $second").unwrap();
         let mut params = HashMap::new();
         params.insert(":first".to_owned(), Value::Integer(10));
@@ -245,7 +250,10 @@ mod test {
 
     #[test]
     fn test_bind_params_too_few_params() {
-        let con = rusqlite::Connection::open_in_memory().unwrap();
+        let con = libsql::Database::open(":memory:")
+            .unwrap()
+            .connect()
+            .unwrap();
         let mut stmt = con.prepare("SELECT :first || $second").unwrap();
         let mut params = HashMap::new();
         params.insert(":first".to_owned(), Value::Integer(10));
@@ -255,7 +263,10 @@ mod test {
 
     #[test]
     fn test_bind_params_invalid_positional() {
-        let con = rusqlite::Connection::open_in_memory().unwrap();
+        let con = libsql::Database::open(":memory:")
+            .unwrap()
+            .connect()
+            .unwrap();
         let mut stmt = con.prepare("SELECT ?invalid").unwrap();
         let params = Params::empty();
         assert!(params.bind(&mut stmt).is_err());

sqld/src/query.rs

@@ -3,10 +3,12 @@ use std::io::{self, ErrorKind};
 use std::ops::{Deref, DerefMut};
 
 use bytesize::ByteSize;
-use rusqlite::types::ValueRef;
+use libsql::params::ValueRef;
 use serde::Serialize;
 use serde_json::ser::Formatter;
 
+pub use libsql::Column;
+
 #[derive(Debug)]
 pub enum QueryResultBuilderError {
     ResponseTooLarge(u64),
@@ -54,28 +56,6 @@ impl From<io::Error> for QueryResultBuilderError {
     }
 }
 
-/// Identical to rusqlite::Column, with visible fields.
-#[cfg_attr(test, derive(arbitrary::Arbitrary))]
-pub struct Column<'a> {
-    pub(crate) name: &'a str,
-    pub(crate) decl_ty: Option<&'a str>,
-}
-
-impl<'a> From<(&'a str, Option<&'a str>)> for Column<'a> {
-    fn from((name, decl_ty): (&'a str, Option<&'a str>)) -> Self {
-        Self { name, decl_ty }
-    }
-}
-
-impl<'a> From<&'a rusqlite::Column<'a>> for Column<'a> {
-    fn from(value: &'a rusqlite::Column<'a>) -> Self {
-        Self {
-            name: value.name(),
-            decl_ty: value.decl_type(),
-        }
-    }
-}
-
 #[derive(Debug, Clone, Copy, Default)]
 pub struct QueryBuilderConfig {
     pub max_size: Option<u64>,
@@ -107,7 +87,8 @@ pub trait QueryResultBuilder: Send + 'static {
     /// begin a new row for the current step
     fn begin_row(&mut self) -> Result<(), QueryResultBuilderError>;
     /// add value to current row
-    fn add_row_value(&mut self, v: ValueRef) -> Result<(), QueryResultBuilderError>;
+    fn add_row_value(&mut self, v: libsql::params::ValueRef)
+        -> Result<(), QueryResultBuilderError>;
     /// finish current row
     fn finish_row(&mut self) -> Result<(), QueryResultBuilderError>;
     /// end adding rows
@@ -588,14 +569,14 @@ pub mod test {
             Blob(&'a [u8]),
         }
 
-        impl<'a> From<ValueRef<'a>> for rusqlite::types::ValueRef<'a> {
+        impl<'a> From<ValueRef<'a>> for libsql::params::ValueRef<'a> {
             fn from(value: ValueRef<'a>) -> Self {
                 match value {
-                    ValueRef::Null => rusqlite::types::ValueRef::Null,
-                    ValueRef::Integer(i) => rusqlite::types::ValueRef::Integer(i),
-                    ValueRef::Real(x) => rusqlite::types::ValueRef::Real(x),
-                    ValueRef::Text(s) => rusqlite::types::ValueRef::Text(s.as_bytes()),
-                    ValueRef::Blob(b) => rusqlite::types::ValueRef::Blob(b),
+                    ValueRef::Null => libsql::params::Value::Null,
+                    ValueRef::Integer(i) => libsql::params::Value::Integer(i),
+                    ValueRef::Real(x) => libsql::params::Value::Float(x),
+                    ValueRef::Text(s) => libsql::params::Value::Text(s.as_bytes()),
+                    ValueRef::Blob(b) => libsql::params::Value::Blob(b),
                 }
             }
         }

sqld/src/query_result_builder.rs

@@ -86,7 +86,7 @@ unsafe impl WalHook for ReplicationLoggerHook {
         if let Err(e) = ctx.flush(ntruncate) {
             tracing::error!("error writing to replication log: {e}");
             // returning IO_ERR ensure that xUndo will be called by sqlite.
-            return SQLITE_IOERR;
+            return SQLITE_IOERR as c_int;
         }
 
         let rc = unsafe {
@@ -149,7 +149,7 @@ unsafe impl WalHook for ReplicationLoggerHook {
 
     fn on_savepoint_undo(wal: &mut Wal, wal_data: *mut u32, orig: XWalSavePointUndoFn) -> i32 {
         let rc = unsafe { orig(wal, wal_data) };
-        if rc != SQLITE_OK {
+        if rc != SQLITE_OK as i32 {
             return rc;
         };
 
@@ -193,9 +193,9 @@ unsafe impl WalHook for ReplicationLoggerHook {
              ** In order to avoid autocheckpoint on close (that's too often),
              ** checkpoint attempts weaker than TRUNCATE are ignored.
              */
-            if emode < SQLITE_CHECKPOINT_TRUNCATE {
+            if emode < SQLITE_CHECKPOINT_TRUNCATE as i32 {
                 tracing::trace!("Ignoring a checkpoint request weaker than TRUNCATE");
-                return SQLITE_OK;
+                return SQLITE_OK as i32;
             }
         }
         let rc = unsafe {
@@ -213,7 +213,7 @@ unsafe impl WalHook for ReplicationLoggerHook {
             )
         };
 
-        if rc != SQLITE_OK {
+        if rc != SQLITE_OK as i32 {
             return rc;
         }
 
@@ -226,7 +226,7 @@ unsafe impl WalHook for ReplicationLoggerHook {
                 let mut replicator = replicator.lock().unwrap();
                 if replicator.commits_in_current_generation() == 0 {
                     tracing::debug!("No commits happened in this generation, not snapshotting");
-                    return SQLITE_OK;
+                    return SQLITE_OK as i32;
                 }
                 let last_known_frame = replicator.last_known_frame();
                 replicator.request_flush();
@@ -237,18 +237,18 @@ unsafe impl WalHook for ReplicationLoggerHook {
                         last_known_frame,
                         e
                     );
-                    return SQLITE_IOERR_WRITE;
+                    return SQLITE_IOERR_WRITE as i32;
                 }
                 replicator.new_generation();
                 if let Err(e) =
                     runtime.block_on(async move { replicator.snapshot_main_db_file().await })
                 {
                     tracing::error!("Failed to snapshot the main db file during checkpoint: {e}");
-                    return SQLITE_IOERR_WRITE;
+                    return SQLITE_IOERR_WRITE as i32;
                 }
             }
         }
-        SQLITE_OK
+        SQLITE_OK as i32
     }
 }
 
@@ -887,21 +887,24 @@ impl ReplicationLogger {
 
 fn checkpoint_db(data_path: &Path) -> anyhow::Result<()> {
     unsafe {
-        let conn = rusqlite::Connection::open(data_path)?;
-        conn.pragma_query(None, "page_size", |row| {
-            let page_size = row.get::<_, i32>(0).unwrap();
+        // unwrap: data_path is expected to be a validated path
+        let conn = libsql::Database::open(data_path.to_str().unwrap())?.connect()?;
+        if let Ok(row) = conn
+            .prepare("pragma page_size")?
+            .query_row(&libsql::Params::None)
+        {
+            let page_size: i32 = row.get(0).unwrap();
             assert_eq!(
                 page_size, WAL_PAGE_SIZE,
                 "invalid database file, expected page size to be {}, but found {} instead",
                 WAL_PAGE_SIZE, page_size
             );
-            Ok(())
-        })?;
+        }
         let mut num_checkpointed: c_int = 0;
-        let rc = rusqlite::ffi::sqlite3_wal_checkpoint_v2(
+        let rc = sqld_libsql_bindings::ffi::sqlite3_wal_checkpoint_v2(
             conn.handle(),
             std::ptr::null(),
-            SQLITE_CHECKPOINT_TRUNCATE,
+            SQLITE_CHECKPOINT_TRUNCATE as i32,
             &mut num_checkpointed as *mut _,
             std::ptr::null_mut(),
         );

sqld/src/replication/primary/logger.rs

@@ -1,8 +1,7 @@
 use std::ffi::{c_int, CStr};
 use std::marker::PhantomData;
 
-use rusqlite::ffi::{PgHdr, SQLITE_ERROR};
-use sqld_libsql_bindings::ffi::Wal;
+use sqld_libsql_bindings::ffi::{PgHdr, Wal, SQLITE_ERROR};
 use sqld_libsql_bindings::init_static_wal_method;
 use sqld_libsql_bindings::{ffi::types::XWalFrameFn, wal_hook::WalHook};
 
@@ -167,7 +166,7 @@ unsafe impl WalHook for InjectorHook {
 
                     if let Err(e) = ret {
                         tracing::error!("replication error: {e}");
-                        return SQLITE_ERROR;
+                        return SQLITE_ERROR as c_int;
                     }
 
                     if !ctx.is_txn {

sqld/src/replication/replica/hook.rs

@@ -1,7 +1,6 @@
+use sqld_libsql_bindings::ffi;
 use std::path::Path;
 
-use rusqlite::OpenFlags;
-
 use crate::replication::replica::hook::{SQLITE_CONTINUE_REPLICATION, SQLITE_EXIT_REPLICATION};
 
 use super::hook::{InjectorHookCtx, INJECTOR_METHODS};
@@ -14,30 +13,31 @@ impl<'a> FrameInjector<'a> {
     pub fn new(db_path: &Path, hook_ctx: &'a mut InjectorHookCtx) -> anyhow::Result<Self> {
         let conn = sqld_libsql_bindings::Connection::open(
             db_path,
-            OpenFlags::SQLITE_OPEN_READ_WRITE
-                | OpenFlags::SQLITE_OPEN_CREATE
-                | OpenFlags::SQLITE_OPEN_URI
-                | OpenFlags::SQLITE_OPEN_NO_MUTEX,
+            (ffi::SQLITE_OPEN_READWRITE
+                | ffi::SQLITE_OPEN_CREATE
+                | ffi::SQLITE_OPEN_URI
+                | ffi::SQLITE_OPEN_NOMUTEX) as i32,
             &INJECTOR_METHODS,
             hook_ctx,
-        )?;
+        )
+        .map_err(|rc| libsql::Error::LibError(rc))?;
 
         Ok(Self { conn })
     }
 
     pub fn step(&mut self) -> anyhow::Result<bool> {
-        self.conn.pragma_update(None, "writable_schema", "on")?;
+        self.conn.execute("pragma writable_schema=on", ())?;
         let res = self.conn.execute("create table __dummy__ (dummy);", ());
 
         match res {
             Ok(_) => panic!("replication hook was not called"),
             Err(e) => {
-                if let Some(e) = e.sqlite_error() {
-                    if e.extended_code == SQLITE_EXIT_REPLICATION {
-                        self.conn.pragma_update(None, "writable_schema", "reset")?;
+                if let libsql::Error::LibError(rc) = e {
+                    if rc == SQLITE_EXIT_REPLICATION {
+                        self.conn.execute("pragma writable_schema=reset", ())?;
                         return Ok(false);
                     }
-                    if e.extended_code == SQLITE_CONTINUE_REPLICATION {
+                    if rc == SQLITE_CONTINUE_REPLICATION {
                         return Ok(true);
                     }
                 }

sqld/src/replication/replica/injector.rs

@@ -353,15 +353,15 @@ impl QueryResultBuilder for ExecuteResultBuilder {
         for col in cols {
             let col = col.into();
             let col_len =
-                (col.decl_ty.map(|s| s.len()).unwrap_or_default() + col.name.len()) as u64;
+                (col.decl_type.map(|s| s.len()).unwrap_or_default() + col.name.len()) as u64;
             if col_len + self.current_step_size + self.current_size > self.max_size {
                 return Err(QueryResultBuilderError::ResponseTooLarge(self.max_size));
             }
             self.current_step_size += col_len;
 
             let col = rpc::Column {
                 name: col.name.to_owned(),
-                decltype: col.decl_ty.map(ToString::to_string),
+                decltype: col.decl_type.map(ToString::to_string),
             };
 
             self.current_col_description.push(col);
@@ -380,7 +380,7 @@ impl QueryResultBuilder for ExecuteResultBuilder {
 
     fn add_row_value(
         &mut self,
-        v: rusqlite::types::ValueRef,
+        v: libsql::params::ValueRef,
     ) -> Result<(), QueryResultBuilderError> {
         let data = bincode::serialize(
             &crate::query::Value::try_from(v).map_err(QueryResultBuilderError::from_any)?,