use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
use std::sync::{Arc, Mutex};
use mlua::{AnyUserData, Function, Lua, Table, UserData, UserDataMethods, Value};
use rusqlite::Connection;
use tracing::Instrument as _;
use crate::db::types::{Conn, SqlValue, params_from_table, row_to_lua};
use nitr_core::Result;
pub(crate) mod execute;
pub mod migrate;
pub mod pragmas;
pub(crate) mod query;
pub(crate) mod query_one;
pub(crate) mod query_row;
pub(crate) mod types;
use crate::config::SqlitePragmas;
type TxFlag = Arc<AtomicBool>;
pub(crate) struct LuaDatabase {
conn: Conn,
in_transaction: TxFlag,
}
pub(crate) struct LuaTransaction {
conn: Conn,
savepoints: AtomicUsize,
}
async fn run_blocking<T, F>(
conn: Conn,
kind: &'static str,
sql: String,
params: Vec<SqlValue>,
f: F,
) -> mlua::Result<T>
where
T: Send + 'static,
F: FnOnce(&Connection, &str, &[SqlValue]) -> Result<T, rusqlite::Error> + Send + 'static,
{
let span = tracing::debug_span!("db_query", kind, elapsed_ms = tracing::field::Empty);
let started = std::time::Instant::now();
let result = tokio::task::spawn_blocking(move || {
let conn = conn.lock().map_err(|_| {
mlua::Error::RuntimeError("failed to lock the database connection".into())
})?;
f(&conn, &sql, ¶ms).map_err(|err| {
mlua::Error::RuntimeError(format!("SQL statement `{sql}` failed: {err}"))
})
})
.instrument(span.clone())
.await
.map_err(mlua::Error::external)?;
span.record("elapsed_ms", started.elapsed().as_millis() as u64);
result
}
async fn exec_batch(conn: Conn, sql: String) -> mlua::Result<()> {
run_blocking(conn, "tx", sql, Vec::new(), |conn, sql, _| {
conn.execute_batch(sql)
})
.await
}
fn add_stmt_methods<T, M>(methods: &mut M, conn_of: fn(&T) -> mlua::Result<Conn>)
where
T: UserData + 'static,
M: UserDataMethods<T>,
{
methods.add_async_method("execute", move |_, this, args: (String, Option<Table>)| {
let conn = conn_of(&this);
async move {
let (sql, params) = args;
let params = params_from_table(params.as_ref())?;
let affected = run_blocking(conn?, "execute", sql, params, execute::call).await?;
Ok(affected)
}
});
methods.add_async_method(
"query_row",
move |lua, this, args: (String, Option<Table>)| {
let conn = conn_of(&this);
async move {
let (sql, params) = args;
let params = params_from_table(params.as_ref())?;
let row = run_blocking(conn?, "query_row", sql, params, query_row::call).await?;
row_to_lua(&lua, row)
}
},
);
methods.add_async_method(
"query_one",
move |lua, this, args: (String, Option<Table>)| {
let conn = conn_of(&this);
async move {
let (sql, params) = args;
let params = params_from_table(params.as_ref())?;
let row = run_blocking(conn?, "query_one", sql, params, query_one::call).await?;
row_to_lua(&lua, row)
}
},
);
methods.add_async_method("query", move |lua, this, args: (String, Option<Table>)| {
let conn = conn_of(&this);
async move {
let (sql, params) = args;
let params = params_from_table(params.as_ref())?;
let rows = run_blocking(conn?, "query", sql, params, query::call).await?;
let table = lua.create_table()?;
for (i, row) in rows.into_iter().enumerate() {
table.raw_set(i + 1, row_to_lua(&lua, row)?)?;
}
Ok(table)
}
});
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
enum QueryKind {
Query,
QueryRow,
QueryOne,
Execute,
}
impl QueryKind {
fn parse(name: Option<&str>) -> mlua::Result<Self> {
match name.unwrap_or("query") {
"query" => Ok(QueryKind::Query),
"query_row" => Ok(QueryKind::QueryRow),
"query_one" => Ok(QueryKind::QueryOne),
"execute" => Ok(QueryKind::Execute),
other => Err(mlua::Error::RuntimeError(format!(
"unknown query kind `{other}`: expected \"query\", \"query_row\", \
\"query_one\" or \"execute\""
))),
}
}
}
pub struct PendingQuery {
conn: Conn,
kind: QueryKind,
sql: String,
params: Vec<SqlValue>,
}
impl PendingQuery {
pub async fn run(self, lua: &Lua) -> mlua::Result<Value> {
let PendingQuery {
conn,
kind,
sql,
params,
} = self;
match kind {
QueryKind::Execute => {
let affected = run_blocking(conn, "execute", sql, params, execute::call).await?;
Ok(Value::Integer(affected as i64))
}
QueryKind::QueryRow => {
let row = run_blocking(conn, "query_row", sql, params, query_row::call).await?;
row_to_lua(lua, row).map(Value::Table)
}
QueryKind::QueryOne => {
let row = run_blocking(conn, "query_one", sql, params, query_one::call).await?;
row_to_lua(lua, row).map(Value::Table)
}
QueryKind::Query => {
let rows = run_blocking(conn, "query", sql, params, query::call).await?;
let table = lua.create_table()?;
for (i, row) in rows.into_iter().enumerate() {
table.raw_set(i + 1, row_to_lua(lua, row)?)?;
}
Ok(Value::Table(table))
}
}
}
}
pub(crate) struct LuaPendingQuery(Mutex<Option<PendingQuery>>);
impl LuaPendingQuery {
pub(crate) fn take(&self) -> mlua::Result<PendingQuery> {
self.0
.lock()
.map_err(|_| mlua::Error::RuntimeError("the query handle lock is poisoned".into()))?
.take()
.ok_or_else(|| {
mlua::Error::RuntimeError(
"this query handle has already been awaited; build a new one".into(),
)
})
}
}
impl UserData for LuaPendingQuery {
fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
methods.add_async_method("send", |lua, handle, ()| {
let pending = handle.take();
async move { pending?.run(&lua).await }
});
}
}
fn add_async_query_method<T, M>(methods: &mut M, conn_of: fn(&T) -> mlua::Result<Conn>)
where
T: UserData + 'static,
M: UserDataMethods<T>,
{
methods.add_method(
"query_async",
move |_, this, (sql, params, kind): (String, Option<Table>, Option<String>)| {
Ok(LuaPendingQuery(Mutex::new(Some(PendingQuery {
conn: conn_of(this)?,
kind: QueryKind::parse(kind.as_deref())?,
sql,
params: params_from_table(params.as_ref())?,
}))))
},
);
}
async fn run_transaction(
lua: &Lua,
conn: Conn,
f: Function,
begin: String,
commit: String,
rollback: String,
) -> mlua::Result<Value> {
exec_batch(conn.clone(), begin).await?;
let scope = lua.create_userdata(LuaTransaction {
conn: conn.clone(),
savepoints: AtomicUsize::new(0),
})?;
match f.call_async::<Value>(&scope).await {
Ok(value) => {
exec_batch(conn, commit).await?;
Ok(value)
}
Err(err) => {
if let Err(rollback_err) = exec_batch(conn, rollback).await {
tracing::error!("transaction rollback failed: {rollback_err}");
}
Err(err)
}
}
}
impl UserData for LuaDatabase {
fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
add_stmt_methods(methods, |db: &LuaDatabase| {
if db.in_transaction.load(Ordering::Acquire) {
return Err(mlua::Error::RuntimeError(
"a transaction is open on this connection: use the `tx` handle passed \
to db:transaction(function(tx) ... end), not `nitr.db`. Statements on \
the outer handle would join the transaction without saying so."
.into(),
));
}
Ok(db.conn.clone())
});
add_async_query_method(methods, |db: &LuaDatabase| {
if db.in_transaction.load(Ordering::Acquire) {
return Err(mlua::Error::RuntimeError(
"a transaction is open on this connection: use the `tx` handle".into(),
));
}
Ok(db.conn.clone())
});
methods.add_async_method("transaction", |lua, db, f: Function| {
let conn = db.conn.clone();
let flag = db.in_transaction.clone();
async move {
if flag.swap(true, Ordering::AcqRel) {
return Err(mlua::Error::RuntimeError(
"a transaction is already open on this connection; nest with \
tx:transaction(...) instead"
.into(),
));
}
let result = run_transaction(
&lua,
conn,
f,
"BEGIN".into(),
"COMMIT".into(),
"ROLLBACK".into(),
)
.await;
flag.store(false, Ordering::Release);
result
}
});
}
}
impl UserData for LuaTransaction {
fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
add_stmt_methods(methods, |tx: &LuaTransaction| Ok(tx.conn.clone()));
add_async_query_method(methods, |tx: &LuaTransaction| Ok(tx.conn.clone()));
methods.add_async_method("transaction", |lua, tx, f: Function| {
let conn = tx.conn.clone();
let n = tx.savepoints.fetch_add(1, Ordering::Relaxed);
async move {
let name = format!("nitr_sp_{n}");
run_transaction(
&lua,
conn,
f,
format!("SAVEPOINT {name}"),
format!("RELEASE {name}"),
format!("ROLLBACK TO {name}; RELEASE {name}"),
)
.await
}
});
}
}
pub(crate) fn create_database_fn(
lua: &Lua,
path: &std::path::Path,
pragmas: &SqlitePragmas,
) -> Result<AnyUserData> {
let conn = Arc::new(Mutex::new(pragmas::open(path, pragmas)?));
let value = lua.create_userdata(LuaDatabase {
conn,
in_transaction: Arc::new(AtomicBool::new(false)),
})?;
Ok(value)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn query_kinds_parse_strictly_with_a_query_default() {
assert_eq!(QueryKind::parse(None).expect("default"), QueryKind::Query);
for (name, kind) in [
("query", QueryKind::Query),
("query_row", QueryKind::QueryRow),
("query_one", QueryKind::QueryOne),
("execute", QueryKind::Execute),
] {
assert_eq!(QueryKind::parse(Some(name)).expect(name), kind);
}
let err = QueryKind::parse(Some("insert")).expect_err("unknown kind");
assert!(err.to_string().contains("insert"), "{err}");
}
}