use anyhow::{Context, Result};
use rusqlite::OptionalExtension;
use std::path::Path;
use std::sync::Once;
static REGISTER_VEC: Once = Once::new();
#[allow(clippy::missing_transmute_annotations)]
pub fn register_sqlite_vec() {
REGISTER_VEC.call_once(|| unsafe {
rusqlite::ffi::sqlite3_auto_extension(Some(std::mem::transmute(
sqlite_vec::sqlite3_vec_init as *const (),
)));
});
}
pub struct Connection {
conn: rusqlite::Connection,
}
impl Connection {
pub fn open(path: &Path) -> Result<Self> {
register_sqlite_vec();
let existed = path.exists();
if let Some(parent) = path.parent() {
std::fs::create_dir_all(parent)
.with_context(|| format!("creating db directory {}", parent.display()))?;
}
let conn = rusqlite::Connection::open(path)
.with_context(|| format!("opening {}", path.display()))?;
if !existed {
let quick_check: String = conn.query_row("PRAGMA quick_check", [], |row| row.get(0))?;
if quick_check != "ok" {
anyhow::bail!("database quick_check failed: {quick_check}");
}
}
Self::finish(conn, !existed) }
pub fn open_or_create(path: &Path) -> Result<Self> {
Self::open(path)
}
pub fn open_in_memory() -> Result<Self> {
register_sqlite_vec();
let conn = rusqlite::Connection::open_in_memory()?;
Self::finish(conn, false) }
fn finish(conn: rusqlite::Connection, allow_page_size: bool) -> Result<Self> {
conn.busy_timeout(std::time::Duration::from_secs(5))?;
conn.execute_batch(
"PRAGMA journal_mode = WAL;
PRAGMA synchronous = NORMAL;
PRAGMA foreign_keys = ON;
PRAGMA mmap_size = 268435456;
PRAGMA wal_autocheckpoint = 1000;",
)?;
if allow_page_size {
conn.execute_batch("PRAGMA page_size = 8192;")?;
}
Ok(Self { conn })
}
pub fn inner(&self) -> &rusqlite::Connection {
&self.conn
}
pub fn inner_mut(&mut self) -> &mut rusqlite::Connection {
&mut self.conn
}
pub fn execute_batch(&self, sql: &str) -> Result<()> {
self.conn.execute_batch(sql)?;
Ok(())
}
pub fn query_i64(&self, sql: &str) -> Result<i64> {
Ok(self.conn.query_row(sql, [], |row| row.get(0))?)
}
pub fn query_row<T, P: rusqlite::Params>(
&self,
sql: &str,
params: P,
f: impl FnOnce(&rusqlite::Row<'_>) -> rusqlite::Result<T>,
) -> Result<T> {
Ok(self.conn.query_row(sql, params, f)?)
}
pub fn stored_embedding_model(&self) -> Result<Option<String>> {
let model: Option<String> = self
.conn
.query_row(
"SELECT value FROM index_meta WHERE key = 'embedding_model'",
[],
|row| row.get(0),
)
.optional()?;
Ok(model)
}
}