remove submodule

crates/sqlez

@@ -1 +0,0 @@
-Subproject commit 10a78dbe535a0c270b6b4bc469fbbffe9fc8c36f

crates/sqlez/.gitignore

@@ -0,0 +1,2 @@
+debug/
+target/

crates/sqlez/Cargo.lock

@@ -0,0 +1,150 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "addr2line"
+version = "0.17.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b9ecd88a8c8378ca913a680cd98f0f13ac67383d35993f86c90a70e3f137816b"
+dependencies = [
+ "gimli",
+]
+
+[[package]]
+name = "adler"
+version = "1.0.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f26201604c87b1e01bd3d98f8d5d9a8fcbb815e8cedb41ffccbeb4bf593a35fe"
+
+[[package]]
+name = "anyhow"
+version = "1.0.66"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "216261ddc8289130e551ddcd5ce8a064710c0d064a4d2895c67151c92b5443f6"
+dependencies = [
+ "backtrace",
+]
+
+[[package]]
+name = "backtrace"
+version = "0.3.66"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "cab84319d616cfb654d03394f38ab7e6f0919e181b1b57e1fd15e7fb4077d9a7"
+dependencies = [
+ "addr2line",
+ "cc",
+ "cfg-if",
+ "libc",
+ "miniz_oxide",
+ "object",
+ "rustc-demangle",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.73"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2fff2a6927b3bb87f9595d67196a70493f627687a71d87a0d692242c33f58c11"
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "gimli"
+version = "0.26.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "22030e2c5a68ec659fde1e949a745124b48e6fa8b045b7ed5bd1fe4ccc5c4e5d"
+
+[[package]]
+name = "indoc"
+version = "1.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "adab1eaa3408fb7f0c777a73e7465fd5656136fc93b670eb6df3c88c2c1344e3"
+
+[[package]]
+name = "libc"
+version = "0.2.137"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc7fcc620a3bff7cdd7a365be3376c97191aeaccc2a603e600951e452615bf89"
+
+[[package]]
+name = "libsqlite3-sys"
+version = "0.25.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "29f835d03d717946d28b1d1ed632eb6f0e24a299388ee623d0c23118d3e8a7fa"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
+[[package]]
+name = "memchr"
+version = "2.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+
+[[package]]
+name = "miniz_oxide"
+version = "0.5.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96590ba8f175222643a85693f33d26e9c8a015f599c216509b1a6894af675d34"
+dependencies = [
+ "adler",
+]
+
+[[package]]
+name = "object"
+version = "0.29.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "21158b2c33aa6d4561f1c0a6ea283ca92bc54802a93b263e910746d679a7eb53"
+dependencies = [
+ "memchr",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e82dad04139b71a90c080c8463fe0dc7902db5192d939bd0950f074d014339e1"
+
+[[package]]
+name = "pkg-config"
+version = "0.3.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ac9a59f73473f1b8d852421e59e64809f025994837ef743615c6d0c5b305160"
+
+[[package]]
+name = "rustc-demangle"
+version = "0.1.21"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7ef03e0a2b150c7a90d01faf6254c9c48a41e95fb2a8c2ac1c6f0d2b9aefc342"
+
+[[package]]
+name = "sqlez"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "indoc",
+ "libsqlite3-sys",
+ "thread_local",
+]
+
+[[package]]
+name = "thread_local"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5516c27b78311c50bf42c071425c560ac799b11c30b31f87e3081965fe5e0180"
+dependencies = [
+ "once_cell",
+]
+
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"

crates/sqlez/Cargo.toml

@@ -0,0 +1,12 @@
+[package]
+name = "sqlez"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+anyhow = { version = "1.0.38", features = ["backtrace"] }
+indoc = "1.0.7"
+libsqlite3-sys = { version = "0.25.2", features = ["bundled"] }
+thread_local = "1.1.4"

crates/sqlez/src/bindable.rs

@@ -0,0 +1,209 @@
+use anyhow::Result;
+
+use crate::statement::{SqlType, Statement};
+
+pub trait Bind {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32>;
+}
+
+pub trait Column: Sized {
+    fn column(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)>;
+}
+
+impl Bind for &[u8] {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        statement.bind_blob(start_index, self)?;
+        Ok(start_index + 1)
+    }
+}
+
+impl Bind for Vec<u8> {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        statement.bind_blob(start_index, self)?;
+        Ok(start_index + 1)
+    }
+}
+
+impl Column for Vec<u8> {
+    fn column(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
+        let result = statement.column_blob(start_index)?;
+        Ok((Vec::from(result), start_index + 1))
+    }
+}
+
+impl Bind for f64 {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        statement.bind_double(start_index, *self)?;
+        Ok(start_index + 1)
+    }
+}
+
+impl Column for f64 {
+    fn column(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
+        let result = statement.column_double(start_index)?;
+        Ok((result, start_index + 1))
+    }
+}
+
+impl Bind for i32 {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        statement.bind_int(start_index, *self)?;
+        Ok(start_index + 1)
+    }
+}
+
+impl Column for i32 {
+    fn column<'a>(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
+        let result = statement.column_int(start_index)?;
+        Ok((result, start_index + 1))
+    }
+}
+
+impl Bind for i64 {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        statement.bind_int64(start_index, *self)?;
+        Ok(start_index + 1)
+    }
+}
+
+impl Column for i64 {
+    fn column(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
+        let result = statement.column_int64(start_index)?;
+        Ok((result, start_index + 1))
+    }
+}
+
+impl Bind for usize {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        (*self as i64).bind(statement, start_index)
+    }
+}
+
+impl Column for usize {
+    fn column(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
+        let result = statement.column_int64(start_index)?;
+        Ok((result as usize, start_index + 1))
+    }
+}
+
+impl Bind for () {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        statement.bind_null(start_index)?;
+        Ok(start_index + 1)
+    }
+}
+
+impl Bind for &str {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        statement.bind_text(start_index, self)?;
+        Ok(start_index + 1)
+    }
+}
+
+impl Bind for String {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        statement.bind_text(start_index, self)?;
+        Ok(start_index + 1)
+    }
+}
+
+impl Column for String {
+    fn column<'a>(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
+        let result = statement.column_text(start_index)?;
+        Ok((result.to_owned(), start_index + 1))
+    }
+}
+
+impl<T1: Bind, T2: Bind> Bind for (T1, T2) {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        let next_index = self.0.bind(statement, start_index)?;
+        self.1.bind(statement, next_index)
+    }
+}
+
+impl<T1: Column, T2: Column> Column for (T1, T2) {
+    fn column<'a>(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
+        let (first, next_index) = T1::column(statement, start_index)?;
+        let (second, next_index) = T2::column(statement, next_index)?;
+        Ok(((first, second), next_index))
+    }
+}
+
+impl<T1: Bind, T2: Bind, T3: Bind> Bind for (T1, T2, T3) {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        let next_index = self.0.bind(statement, start_index)?;
+        let next_index = self.1.bind(statement, next_index)?;
+        self.2.bind(statement, next_index)
+    }
+}
+
+impl<T1: Column, T2: Column, T3: Column> Column for (T1, T2, T3) {
+    fn column(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
+        let (first, next_index) = T1::column(statement, start_index)?;
+        let (second, next_index) = T2::column(statement, next_index)?;
+        let (third, next_index) = T3::column(statement, next_index)?;
+        Ok(((first, second, third), next_index))
+    }
+}
+
+impl<T1: Bind, T2: Bind, T3: Bind, T4: Bind> Bind for (T1, T2, T3, T4) {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        let next_index = self.0.bind(statement, start_index)?;
+        let next_index = self.1.bind(statement, next_index)?;
+        let next_index = self.2.bind(statement, next_index)?;
+        self.3.bind(statement, next_index)
+    }
+}
+
+impl<T1: Column, T2: Column, T3: Column, T4: Column> Column for (T1, T2, T3, T4) {
+    fn column(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
+        let (first, next_index) = T1::column(statement, start_index)?;
+        let (second, next_index) = T2::column(statement, next_index)?;
+        let (third, next_index) = T3::column(statement, next_index)?;
+        let (forth, next_index) = T4::column(statement, next_index)?;
+        Ok(((first, second, third, forth), next_index))
+    }
+}
+
+impl<T: Bind> Bind for Option<T> {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        if let Some(this) = self {
+            this.bind(statement, start_index)
+        } else {
+            statement.bind_null(start_index)?;
+            Ok(start_index + 1)
+        }
+    }
+}
+
+impl<T: Column> Column for Option<T> {
+    fn column(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
+        if let SqlType::Null = statement.column_type(start_index)? {
+            Ok((None, start_index + 1))
+        } else {
+            T::column(statement, start_index).map(|(result, next_index)| (Some(result), next_index))
+        }
+    }
+}
+
+impl<T: Bind, const COUNT: usize> Bind for [T; COUNT] {
+    fn bind(&self, statement: &Statement, start_index: i32) -> Result<i32> {
+        let mut current_index = start_index;
+        for binding in self {
+            current_index = binding.bind(statement, current_index)?
+        }
+
+        Ok(current_index)
+    }
+}
+
+impl<T: Column + Default + Copy, const COUNT: usize> Column for [T; COUNT] {
+    fn column(statement: &mut Statement, start_index: i32) -> Result<(Self, i32)> {
+        let mut array = [Default::default(); COUNT];
+        let mut current_index = start_index;
+        for i in 0..COUNT {
+            (array[i], current_index) = T::column(statement, current_index)?;
+        }
+        Ok((array, current_index))
+    }
+}

crates/sqlez/src/connection.rs

@@ -0,0 +1,220 @@
+use std::{
+    ffi::{CStr, CString},
+    marker::PhantomData,
+};
+
+use anyhow::{anyhow, Result};
+use libsqlite3_sys::*;
+
+use crate::statement::Statement;
+
+pub struct Connection {
+    pub(crate) sqlite3: *mut sqlite3,
+    persistent: bool,
+    phantom: PhantomData<sqlite3>,
+}
+unsafe impl Send for Connection {}
+
+impl Connection {
+    fn open(uri: &str, persistent: bool) -> Result<Self> {
+        let mut connection = Self {
+            sqlite3: 0 as *mut _,
+            persistent,
+            phantom: PhantomData,
+        };
+
+        let flags = SQLITE_OPEN_CREATE | SQLITE_OPEN_NOMUTEX | SQLITE_OPEN_READWRITE;
+        unsafe {
+            sqlite3_open_v2(
+                CString::new(uri)?.as_ptr(),
+                &mut connection.sqlite3,
+                flags,
+                0 as *const _,
+            );
+
+            connection.last_error()?;
+        }
+
+        Ok(connection)
+    }
+
+    /// Attempts to open the database at uri. If it fails, a shared memory db will be opened
+    /// instead.
+    pub fn open_file(uri: &str) -> Self {
+        Self::open(uri, true).unwrap_or_else(|_| Self::open_memory(uri))
+    }
+
+    pub fn open_memory(uri: &str) -> Self {
+        let in_memory_path = format!("file:{}?mode=memory&cache=shared", uri);
+        Self::open(&in_memory_path, false).expect("Could not create fallback in memory db")
+    }
+
+    pub fn persistent(&self) -> bool {
+        self.persistent
+    }
+
+    pub fn exec(&self, query: impl AsRef<str>) -> Result<()> {
+        unsafe {
+            sqlite3_exec(
+                self.sqlite3,
+                CString::new(query.as_ref())?.as_ptr(),
+                None,
+                0 as *mut _,
+                0 as *mut _,
+            );
+            self.last_error()?;
+        }
+        Ok(())
+    }
+
+    pub fn prepare<T: AsRef<str>>(&self, query: T) -> Result<Statement> {
+        Statement::prepare(&self, query)
+    }
+
+    pub fn backup_main(&self, destination: &Connection) -> Result<()> {
+        unsafe {
+            let backup = sqlite3_backup_init(
+                destination.sqlite3,
+                CString::new("main")?.as_ptr(),
+                self.sqlite3,
+                CString::new("main")?.as_ptr(),
+            );
+            sqlite3_backup_step(backup, -1);
+            sqlite3_backup_finish(backup);
+            destination.last_error()
+        }
+    }
+
+    pub(crate) fn last_error(&self) -> Result<()> {
+        const NON_ERROR_CODES: &[i32] = &[SQLITE_OK, SQLITE_ROW];
+        unsafe {
+            let code = sqlite3_errcode(self.sqlite3);
+            if NON_ERROR_CODES.contains(&code) {
+                return Ok(());
+            }
+
+            let message = sqlite3_errmsg(self.sqlite3);
+            let message = if message.is_null() {
+                None
+            } else {
+                Some(
+                    String::from_utf8_lossy(CStr::from_ptr(message as *const _).to_bytes())
+                        .into_owned(),
+                )
+            };
+
+            Err(anyhow!(
+                "Sqlite call failed with code {} and message: {:?}",
+                code as isize,
+                message
+            ))
+        }
+    }
+}
+
+impl Drop for Connection {
+    fn drop(&mut self) {
+        unsafe { sqlite3_close(self.sqlite3) };
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use anyhow::Result;
+    use indoc::indoc;
+
+    use crate::connection::Connection;
+
+    #[test]
+    fn string_round_trips() -> Result<()> {
+        let connection = Connection::open_memory("string_round_trips");
+        connection
+            .exec(indoc! {"
+            CREATE TABLE text (
+                text TEXT
+            );"})
+            .unwrap();
+
+        let text = "Some test text";
+
+        connection
+            .prepare("INSERT INTO text (text) VALUES (?);")
+            .unwrap()
+            .bound(text)
+            .unwrap()
+            .run()
+            .unwrap();
+
+        assert_eq!(
+            &connection
+                .prepare("SELECT text FROM text;")
+                .unwrap()
+                .row::<String>()
+                .unwrap(),
+            text
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn tuple_round_trips() {
+        let connection = Connection::open_memory("tuple_round_trips");
+        connection
+            .exec(indoc! {"
+                CREATE TABLE test (
+                    text TEXT,
+                    integer INTEGER,
+                    blob BLOB
+                );"})
+            .unwrap();
+
+        let tuple1 = ("test".to_string(), 64, vec![0, 1, 2, 4, 8, 16, 32, 64]);
+        let tuple2 = ("test2".to_string(), 32, vec![64, 32, 16, 8, 4, 2, 1, 0]);
+
+        let mut insert = connection
+            .prepare("INSERT INTO test (text, integer, blob) VALUES (?, ?, ?)")
+            .unwrap();
+
+        insert.bound(tuple1.clone()).unwrap().run().unwrap();
+        insert.bound(tuple2.clone()).unwrap().run().unwrap();
+
+        assert_eq!(
+            connection
+                .prepare("SELECT * FROM test")
+                .unwrap()
+                .rows::<(String, usize, Vec<u8>)>()
+                .unwrap(),
+            vec![tuple1, tuple2]
+        );
+    }
+
+    #[test]
+    fn backup_works() {
+        let connection1 = Connection::open_memory("backup_works");
+        connection1
+            .exec(indoc! {"
+                CREATE TABLE blobs (
+                    data BLOB
+                );"})
+            .unwrap();
+        let blob = &[0, 1, 2, 4, 8, 16, 32, 64];
+        let mut write = connection1
+            .prepare("INSERT INTO blobs (data) VALUES (?);")
+            .unwrap();
+        write.bind_blob(1, blob).unwrap();
+        write.run().unwrap();
+
+        // Backup connection1 to connection2
+        let connection2 = Connection::open_memory("backup_works_other");
+        connection1.backup_main(&connection2).unwrap();
+
+        // Delete the added blob and verify its deleted on the other side
+        let read_blobs = connection1
+            .prepare("SELECT * FROM blobs;")
+            .unwrap()
+            .rows::<Vec<u8>>()
+            .unwrap();
+        assert_eq!(read_blobs, vec![blob]);
+    }
+}

crates/sqlez/src/lib.rs

@@ -0,0 +1,6 @@
+pub mod bindable;
+pub mod connection;
+pub mod migrations;
+pub mod savepoint;
+pub mod statement;
+pub mod thread_safe_connection;

crates/sqlez/src/migrations.rs

@@ -0,0 +1,261 @@
+// Migrations are constructed by domain, and stored in a table in the connection db with domain name,
+// effected tables, actual query text, and order.
+// If a migration is run and any of the query texts don't match, the app panics on startup (maybe fallback
+// to creating a new db?)
+// Otherwise any missing migrations are run on the connection
+
+use anyhow::{anyhow, Result};
+use indoc::{formatdoc, indoc};
+
+use crate::connection::Connection;
+
+const MIGRATIONS_MIGRATION: Migration = Migration::new(
+    "migrations",
+    // The migrations migration must be infallable because it runs to completion
+    // with every call to migration run and is run unchecked.
+    &[indoc! {"
+        CREATE TABLE IF NOT EXISTS migrations (
+            domain TEXT,
+            step INTEGER,
+            migration TEXT
+        );
+    "}],
+);
+
+pub struct Migration {
+    domain: &'static str,
+    migrations: &'static [&'static str],
+}
+
+impl Migration {
+    pub const fn new(domain: &'static str, migrations: &'static [&'static str]) -> Self {
+        Self { domain, migrations }
+    }
+
+    fn run_unchecked(&self, connection: &Connection) -> Result<()> {
+        connection.exec(self.migrations.join(";\n"))
+    }
+
+    pub fn run(&self, connection: &Connection) -> Result<()> {
+        // Setup the migrations table unconditionally
+        MIGRATIONS_MIGRATION.run_unchecked(connection)?;
+
+        let completed_migrations = connection
+            .prepare(indoc! {"
+                SELECT domain, step, migration FROM migrations
+                WHERE domain = ?
+                ORDER BY step
+                "})?
+            .bound(self.domain)?
+            .rows::<(String, usize, String)>()?;
+
+        let mut store_completed_migration = connection
+            .prepare("INSERT INTO migrations (domain, step, migration) VALUES (?, ?, ?)")?;
+
+        for (index, migration) in self.migrations.iter().enumerate() {
+            if let Some((_, _, completed_migration)) = completed_migrations.get(index) {
+                if completed_migration != migration {
+                    return Err(anyhow!(formatdoc! {"
+                        Migration changed for {} at step {}
+                        
+                        Stored migration:
+                        {}
+                        
+                        Proposed migration:
+                        {}", self.domain, index, completed_migration, migration}));
+                } else {
+                    // Migration already run. Continue
+                    continue;
+                }
+            }
+
+            connection.exec(migration)?;
+            store_completed_migration
+                .bound((self.domain, index, *migration))?
+                .run()?;
+        }
+
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use indoc::indoc;
+
+    use crate::{connection::Connection, migrations::Migration};
+
+    #[test]
+    fn test_migrations_are_added_to_table() {
+        let connection = Connection::open_memory("migrations_are_added_to_table");
+
+        // Create first migration with a single step and run it
+        let mut migration = Migration::new(
+            "test",
+            &[indoc! {"
+            CREATE TABLE test1 (
+                a TEXT,
+                b TEXT
+            );"}],
+        );
+        migration.run(&connection).unwrap();
+
+        // Verify it got added to the migrations table
+        assert_eq!(
+            &connection
+                .prepare("SELECT (migration) FROM migrations")
+                .unwrap()
+                .rows::<String>()
+                .unwrap()[..],
+            migration.migrations
+        );
+
+        // Add another step to the migration and run it again
+        migration.migrations = &[
+            indoc! {"
+                CREATE TABLE test1 (
+                    a TEXT,
+                    b TEXT
+                );"},
+            indoc! {"
+                CREATE TABLE test2 (
+                    c TEXT,
+                    d TEXT
+                );"},
+        ];
+        migration.run(&connection).unwrap();
+
+        // Verify it is also added to the migrations table
+        assert_eq!(
+            &connection
+                .prepare("SELECT (migration) FROM migrations")
+                .unwrap()
+                .rows::<String>()
+                .unwrap()[..],
+            migration.migrations
+        );
+    }
+
+    #[test]
+    fn test_migration_setup_works() {
+        let connection = Connection::open_memory("migration_setup_works");
+
+        connection
+            .exec(indoc! {"CREATE TABLE IF NOT EXISTS migrations (
+                    domain TEXT,
+                    step INTEGER,
+                    migration TEXT
+                );"})
+            .unwrap();
+
+        let mut store_completed_migration = connection
+            .prepare(indoc! {"
+                INSERT INTO migrations (domain, step, migration)
+                VALUES (?, ?, ?)"})
+            .unwrap();
+
+        let domain = "test_domain";
+        for i in 0..5 {
+            // Create a table forcing a schema change
+            connection
+                .exec(format!("CREATE TABLE table{} ( test TEXT );", i))
+                .unwrap();
+
+            store_completed_migration
+                .bound((domain, i, i.to_string()))
+                .unwrap()
+                .run()
+                .unwrap();
+        }
+    }
+
+    #[test]
+    fn migrations_dont_rerun() {
+        let connection = Connection::open_memory("migrations_dont_rerun");
+
+        // Create migration which clears a table
+        let migration = Migration::new("test", &["DELETE FROM test_table"]);
+
+        // Manually create the table for that migration with a row
+        connection
+            .exec(indoc! {"
+            CREATE TABLE test_table (
+                test_column INTEGER
+            );
+            INSERT INTO test_table (test_column) VALUES (1)"})
+            .unwrap();
+
+        assert_eq!(
+            connection
+                .prepare("SELECT * FROM test_table")
+                .unwrap()
+                .row::<usize>()
+                .unwrap(),
+            1
+        );
+
+        // Run the migration verifying that the row got dropped
+        migration.run(&connection).unwrap();
+        assert_eq!(
+            connection
+                .prepare("SELECT * FROM test_table")
+                .unwrap()
+                .rows::<usize>()
+                .unwrap(),
+            Vec::new()
+        );
+
+        // Recreate the dropped row
+        connection
+            .exec("INSERT INTO test_table (test_column) VALUES (2)")
+            .unwrap();
+
+        // Run the same migration again and verify that the table was left unchanged
+        migration.run(&connection).unwrap();
+        assert_eq!(
+            connection
+                .prepare("SELECT * FROM test_table")
+                .unwrap()
+                .row::<usize>()
+                .unwrap(),
+            2
+        );
+    }
+
+    #[test]
+    fn changed_migration_fails() {
+        let connection = Connection::open_memory("changed_migration_fails");
+
+        // Create a migration with two steps and run it
+        Migration::new(
+            "test migration",
+            &[
+                indoc! {"
+                CREATE TABLE test (
+                    col INTEGER
+                )"},
+                indoc! {"
+                INSERT INTO test (col) VALUES (1)"},
+            ],
+        )
+        .run(&connection)
+        .unwrap();
+
+        // Create another migration with the same domain but different steps
+        let second_migration_result = Migration::new(
+            "test migration",
+            &[
+                indoc! {"
+                CREATE TABLE test (
+                    color INTEGER
+                )"},
+                indoc! {"
+                INSERT INTO test (color) VALUES (1)"},
+            ],
+        )
+        .run(&connection);
+
+        // Verify new migration returns error when run
+        assert!(second_migration_result.is_err())
+    }
+}

crates/sqlez/src/savepoint.rs

@@ -0,0 +1,110 @@
+use anyhow::Result;
+
+use crate::connection::Connection;
+
+impl Connection {
+    // Run a set of commands within the context of a `SAVEPOINT name`. If the callback
+    // returns Ok(None) or Err(_), the savepoint will be rolled back. Otherwise, the save
+    // point is released.
+    pub fn with_savepoint<F, R>(&mut self, name: impl AsRef<str>, f: F) -> Result<Option<R>>
+    where
+        F: FnOnce(&mut Connection) -> Result<Option<R>>,
+    {
+        let name = name.as_ref().to_owned();
+        self.exec(format!("SAVEPOINT {}", &name))?;
+        let result = f(self);
+        match result {
+            Ok(Some(_)) => {
+                self.exec(format!("RELEASE {}", name))?;
+            }
+            Ok(None) | Err(_) => {
+                self.exec(format!("ROLLBACK TO {}", name))?;
+                self.exec(format!("RELEASE {}", name))?;
+            }
+        }
+        result
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::connection::Connection;
+    use anyhow::Result;
+    use indoc::indoc;
+
+    #[test]
+    fn test_nested_savepoints() -> Result<()> {
+        let mut connection = Connection::open_memory("nested_savepoints");
+
+        connection
+            .exec(indoc! {"
+            CREATE TABLE text (
+                text TEXT,
+                idx INTEGER
+            );"})
+            .unwrap();
+
+        let save1_text = "test save1";
+        let save2_text = "test save2";
+
+        connection.with_savepoint("first", |save1| {
+            save1
+                .prepare("INSERT INTO text(text, idx) VALUES (?, ?)")?
+                .bound((save1_text, 1))?
+                .run()?;
+
+            assert!(save1
+                .with_savepoint("second", |save2| -> Result<Option<()>, anyhow::Error> {
+                    save2
+                        .prepare("INSERT INTO text(text, idx) VALUES (?, ?)")?
+                        .bound((save2_text, 2))?
+                        .run()?;
+
+                    assert_eq!(
+                        save2
+                            .prepare("SELECT text FROM text ORDER BY text.idx ASC")?
+                            .rows::<String>()?,
+                        vec![save1_text, save2_text],
+                    );
+
+                    anyhow::bail!("Failed second save point :(")
+                })
+                .err()
+                .is_some());
+
+            assert_eq!(
+                save1
+                    .prepare("SELECT text FROM text ORDER BY text.idx ASC")?
+                    .rows::<String>()?,
+                vec![save1_text],
+            );
+
+            save1.with_savepoint("second", |save2| {
+                save2
+                    .prepare("INSERT INTO text(text, idx) VALUES (?, ?)")?
+                    .bound((save2_text, 2))?
+                    .run()?;
+
+                assert_eq!(
+                    save2
+                        .prepare("SELECT text FROM text ORDER BY text.idx ASC")?
+                        .rows::<String>()?,
+                    vec![save1_text, save2_text],
+                );
+
+                Ok(Some(()))
+            })?;
+
+            assert_eq!(
+                save1
+                    .prepare("SELECT text FROM text ORDER BY text.idx ASC")?
+                    .rows::<String>()?,
+                vec![save1_text, save2_text],
+            );
+
+            Ok(Some(()))
+        })?;
+
+        Ok(())
+    }
+}

crates/sqlez/src/statement.rs

@@ -0,0 +1,342 @@
+use std::ffi::{c_int, CString};
+use std::marker::PhantomData;
+use std::{slice, str};
+
+use anyhow::{anyhow, Context, Result};
+use libsqlite3_sys::*;
+
+use crate::bindable::{Bind, Column};
+use crate::connection::Connection;
+
+pub struct Statement<'a> {
+    raw_statement: *mut sqlite3_stmt,
+    connection: &'a Connection,
+    phantom: PhantomData<sqlite3_stmt>,
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum StepResult {
+    Row,
+    Done,
+    Misuse,
+    Other(i32),
+}
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug)]
+pub enum SqlType {
+    Text,
+    Integer,
+    Blob,
+    Float,
+    Null,
+}
+
+impl<'a> Statement<'a> {
+    pub fn prepare<T: AsRef<str>>(connection: &'a Connection, query: T) -> Result<Self> {
+        let mut statement = Self {
+            raw_statement: 0 as *mut _,
+            connection,
+            phantom: PhantomData,
+        };
+
+        unsafe {
+            sqlite3_prepare_v2(
+                connection.sqlite3,
+                CString::new(query.as_ref())?.as_ptr(),
+                -1,
+                &mut statement.raw_statement,
+                0 as *mut _,
+            );
+
+            connection.last_error().context("Prepare call failed.")?;
+        }
+
+        Ok(statement)
+    }
+
+    pub fn reset(&mut self) {
+        unsafe {
+            sqlite3_reset(self.raw_statement);
+        }
+    }
+
+    pub fn bind_blob(&self, index: i32, blob: &[u8]) -> Result<()> {
+        let index = index as c_int;
+        let blob_pointer = blob.as_ptr() as *const _;
+        let len = blob.len() as c_int;
+        unsafe {
+            sqlite3_bind_blob(
+                self.raw_statement,
+                index,
+                blob_pointer,
+                len,
+                SQLITE_TRANSIENT(),
+            );
+        }
+        self.connection.last_error()
+    }
+
+    pub fn column_blob<'b>(&'b mut self, index: i32) -> Result<&'b [u8]> {
+        let index = index as c_int;
+        let pointer = unsafe { sqlite3_column_blob(self.raw_statement, index) };
+
+        self.connection.last_error()?;
+        if pointer.is_null() {
+            return Ok(&[]);
+        }
+        let len = unsafe { sqlite3_column_bytes(self.raw_statement, index) as usize };
+        self.connection.last_error()?;
+        unsafe { Ok(slice::from_raw_parts(pointer as *const u8, len)) }
+    }
+
+    pub fn bind_double(&self, index: i32, double: f64) -> Result<()> {
+        let index = index as c_int;
+
+        unsafe {
+            sqlite3_bind_double(self.raw_statement, index, double);
+        }
+        self.connection.last_error()
+    }
+
+    pub fn column_double(&self, index: i32) -> Result<f64> {
+        let index = index as c_int;
+        let result = unsafe { sqlite3_column_double(self.raw_statement, index) };
+        self.connection.last_error()?;
+        Ok(result)
+    }
+
+    pub fn bind_int(&self, index: i32, int: i32) -> Result<()> {
+        let index = index as c_int;
+
+        unsafe {
+            sqlite3_bind_int(self.raw_statement, index, int);
+        }
+        self.connection.last_error()
+    }
+
+    pub fn column_int(&self, index: i32) -> Result<i32> {
+        let index = index as c_int;
+        let result = unsafe { sqlite3_column_int(self.raw_statement, index) };
+        self.connection.last_error()?;
+        Ok(result)
+    }
+
+    pub fn bind_int64(&self, index: i32, int: i64) -> Result<()> {
+        let index = index as c_int;
+        unsafe {
+            sqlite3_bind_int64(self.raw_statement, index, int);
+        }
+        self.connection.last_error()
+    }
+
+    pub fn column_int64(&self, index: i32) -> Result<i64> {
+        let index = index as c_int;
+        let result = unsafe { sqlite3_column_int64(self.raw_statement, index) };
+        self.connection.last_error()?;
+        Ok(result)
+    }
+
+    pub fn bind_null(&self, index: i32) -> Result<()> {
+        let index = index as c_int;
+        unsafe {
+            sqlite3_bind_null(self.raw_statement, index);
+        }
+        self.connection.last_error()
+    }
+
+    pub fn bind_text(&self, index: i32, text: &str) -> Result<()> {
+        let index = index as c_int;
+        let text_pointer = text.as_ptr() as *const _;
+        let len = text.len() as c_int;
+        unsafe {
+            sqlite3_bind_blob(
+                self.raw_statement,
+                index,
+                text_pointer,
+                len,
+                SQLITE_TRANSIENT(),
+            );
+        }
+        self.connection.last_error()
+    }
+
+    pub fn column_text<'b>(&'b mut self, index: i32) -> Result<&'b str> {
+        let index = index as c_int;
+        let pointer = unsafe { sqlite3_column_text(self.raw_statement, index) };
+
+        self.connection.last_error()?;
+        if pointer.is_null() {
+            return Ok("");
+        }
+        let len = unsafe { sqlite3_column_bytes(self.raw_statement, index) as usize };
+        self.connection.last_error()?;
+
+        let slice = unsafe { slice::from_raw_parts(pointer as *const u8, len) };
+        Ok(str::from_utf8(slice)?)
+    }
+
+    pub fn bind<T: Bind>(&self, value: T) -> Result<()> {
+        value.bind(self, 1)?;
+        Ok(())
+    }
+
+    pub fn column<T: Column>(&mut self) -> Result<T> {
+        let (result, _) = T::column(self, 0)?;
+        Ok(result)
+    }
+
+    pub fn column_type(&mut self, index: i32) -> Result<SqlType> {
+        let result = unsafe { sqlite3_column_type(self.raw_statement, index) }; // SELECT <FRIEND> FROM TABLE
+        self.connection.last_error()?;
+        match result {
+            SQLITE_INTEGER => Ok(SqlType::Integer),
+            SQLITE_FLOAT => Ok(SqlType::Float),
+            SQLITE_TEXT => Ok(SqlType::Text),
+            SQLITE_BLOB => Ok(SqlType::Blob),
+            SQLITE_NULL => Ok(SqlType::Null),
+            _ => Err(anyhow!("Column type returned was incorrect ")),
+        }
+    }
+
+    pub fn bound(&mut self, bindings: impl Bind) -> Result<&mut Self> {
+        self.bind(bindings)?;
+        Ok(self)
+    }
+
+    fn step(&mut self) -> Result<StepResult> {
+        unsafe {
+            match sqlite3_step(self.raw_statement) {
+                SQLITE_ROW => Ok(StepResult::Row),
+                SQLITE_DONE => Ok(StepResult::Done),
+                SQLITE_MISUSE => Ok(StepResult::Misuse),
+                other => self
+                    .connection
+                    .last_error()
+                    .map(|_| StepResult::Other(other)),
+            }
+        }
+    }
+
+    pub fn run(&mut self) -> Result<()> {
+        fn logic(this: &mut Statement) -> Result<()> {
+            while this.step()? == StepResult::Row {}
+            Ok(())
+        }
+        let result = logic(self);
+        self.reset();
+        result
+    }
+
+    pub fn map<R>(&mut self, callback: impl FnMut(&mut Statement) -> Result<R>) -> Result<Vec<R>> {
+        fn logic<R>(
+            this: &mut Statement,
+            mut callback: impl FnMut(&mut Statement) -> Result<R>,
+        ) -> Result<Vec<R>> {
+            let mut mapped_rows = Vec::new();
+            while this.step()? == StepResult::Row {
+                mapped_rows.push(callback(this)?);
+            }
+            Ok(mapped_rows)
+        }
+
+        let result = logic(self, callback);
+        self.reset();
+        result
+    }
+
+    pub fn rows<R: Column>(&mut self) -> Result<Vec<R>> {
+        self.map(|s| s.column::<R>())
+    }
+
+    pub fn single<R>(&mut self, callback: impl FnOnce(&mut Statement) -> Result<R>) -> Result<R> {
+        fn logic<R>(
+            this: &mut Statement,
+            callback: impl FnOnce(&mut Statement) -> Result<R>,
+        ) -> Result<R> {
+            if this.step()? != StepResult::Row {
+                return Err(anyhow!(
+                    "Single(Map) called with query that returns no rows."
+                ));
+            }
+            callback(this)
+        }
+        let result = logic(self, callback);
+        self.reset();
+        result
+    }
+
+    pub fn row<R: Column>(&mut self) -> Result<R> {
+        self.single(|this| this.column::<R>())
+    }
+
+    pub fn maybe<R>(
+        &mut self,
+        callback: impl FnOnce(&mut Statement) -> Result<R>,
+    ) -> Result<Option<R>> {
+        fn logic<R>(
+            this: &mut Statement,
+            callback: impl FnOnce(&mut Statement) -> Result<R>,
+        ) -> Result<Option<R>> {
+            if this.step()? != StepResult::Row {
+                return Ok(None);
+            }
+            callback(this).map(|r| Some(r))
+        }
+        let result = logic(self, callback);
+        self.reset();
+        result
+    }
+
+    pub fn maybe_row<R: Column>(&mut self) -> Result<Option<R>> {
+        self.maybe(|this| this.column::<R>())
+    }
+}
+
+impl<'a> Drop for Statement<'a> {
+    fn drop(&mut self) {
+        unsafe {
+            sqlite3_finalize(self.raw_statement);
+            self.connection
+                .last_error()
+                .expect("sqlite3 finalize failed for statement :(");
+        };
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use indoc::indoc;
+
+    use crate::{connection::Connection, statement::StepResult};
+
+    #[test]
+    fn blob_round_trips() {
+        let connection1 = Connection::open_memory("blob_round_trips");
+        connection1
+            .exec(indoc! {"
+            CREATE TABLE blobs (
+            data BLOB
+            );"})
+            .unwrap();
+
+        let blob = &[0, 1, 2, 4, 8, 16, 32, 64];
+
+        let mut write = connection1
+            .prepare("INSERT INTO blobs (data) VALUES (?);")
+            .unwrap();
+        write.bind_blob(1, blob).unwrap();
+        assert_eq!(write.step().unwrap(), StepResult::Done);
+
+        // Read the blob from the
+        let connection2 = Connection::open_memory("blob_round_trips");
+        let mut read = connection2.prepare("SELECT * FROM blobs;").unwrap();
+        assert_eq!(read.step().unwrap(), StepResult::Row);
+        assert_eq!(read.column_blob(0).unwrap(), blob);
+        assert_eq!(read.step().unwrap(), StepResult::Done);
+
+        // Delete the added blob and verify its deleted on the other side
+        connection2.exec("DELETE FROM blobs;").unwrap();
+        let mut read = connection1.prepare("SELECT * FROM blobs;").unwrap();
+        assert_eq!(read.step().unwrap(), StepResult::Done);
+    }
+}

crates/sqlez/src/thread_safe_connection.rs

@@ -0,0 +1,78 @@
+use std::{ops::Deref, sync::Arc};
+
+use connection::Connection;
+use thread_local::ThreadLocal;
+
+use crate::connection;
+
+pub struct ThreadSafeConnection {
+    uri: Arc<str>,
+    persistent: bool,
+    initialize_query: Option<&'static str>,
+    connection: Arc<ThreadLocal<Connection>>,
+}
+
+impl ThreadSafeConnection {
+    pub fn new(uri: &str, persistent: bool) -> Self {
+        Self {
+            uri: Arc::from(uri),
+            persistent,
+            initialize_query: None,
+            connection: Default::default(),
+        }
+    }
+
+    /// Sets the query to run every time a connection is opened. This must
+    /// be infallible (EG only use pragma statements)
+    pub fn with_initialize_query(mut self, initialize_query: &'static str) -> Self {
+        self.initialize_query = Some(initialize_query);
+        self
+    }
+
+    /// Opens a new db connection with the initialized file path. This is internal and only
+    /// called from the deref function.
+    /// If opening fails, the connection falls back to a shared memory connection
+    fn open_file(&self) -> Connection {
+        Connection::open_file(self.uri.as_ref())
+    }
+
+    /// Opens a shared memory connection using the file path as the identifier. This unwraps
+    /// as we expect it always to succeed
+    fn open_shared_memory(&self) -> Connection {
+        Connection::open_memory(self.uri.as_ref())
+    }
+}
+
+impl Clone for ThreadSafeConnection {
+    fn clone(&self) -> Self {
+        Self {
+            uri: self.uri.clone(),
+            persistent: self.persistent,
+            initialize_query: self.initialize_query.clone(),
+            connection: self.connection.clone(),
+        }
+    }
+}
+
+impl Deref for ThreadSafeConnection {
+    type Target = Connection;
+
+    fn deref(&self) -> &Self::Target {
+        self.connection.get_or(|| {
+            let connection = if self.persistent {
+                self.open_file()
+            } else {
+                self.open_shared_memory()
+            };
+
+            if let Some(initialize_query) = self.initialize_query {
+                connection.exec(initialize_query).expect(&format!(
+                    "Initialize query failed to execute: {}",
+                    initialize_query
+                ));
+            }
+
+            connection
+        })
+    }
+}