use std::future::Future;
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, Db, SqlValue, params_from_table, row_to_lua, rows_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 mod testing;
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,
alive: Arc<AtomicBool>,
}
fn tx_conn(tx: &LuaTransaction) -> mlua::Result<Conn> {
if !tx.alive.load(Ordering::Acquire) {
return Err(mlua::Error::RuntimeError(
"this transaction has ended: a `tx` handle is only valid inside the \
db:transaction(function(tx) ... end) body that received it"
.into(),
));
}
Ok(tx.conn.clone())
}
#[derive(Clone)]
enum QueryOrigin {
Outer(TxFlag),
Inner(Arc<AtomicBool>),
}
impl QueryOrigin {
fn check(&self) -> mlua::Result<()> {
match self {
QueryOrigin::Outer(flag) if flag.load(Ordering::Acquire) => {
Err(mlua::Error::RuntimeError(
"a transaction is open on this connection: a `nitr.db:query_async` handle \
cannot run inside db:transaction(...); use `tx:query_async` instead"
.into(),
))
}
QueryOrigin::Inner(alive) if !alive.load(Ordering::Acquire) => {
Err(mlua::Error::RuntimeError(
"this transaction has ended: the `tx:query_async` handle can no longer run"
.into(),
))
}
_ => Ok(()),
}
}
fn is_outer(&self) -> bool {
matches!(self, QueryOrigin::Outer(_))
}
}
async fn run_blocking<T, F>(
conn: Conn,
kind: &'static str,
sql: String,
params: Vec<SqlValue>,
outer: bool,
f: F,
) -> mlua::Result<T>
where
T: Send + 'static,
F: FnOnce(&Connection, &str, &[SqlValue], usize) -> Result<T, rusqlite::Error> + Send + 'static,
{
let span = tracing::debug_span!(
"db_query",
kind,
stmt = tracing::field::Empty,
elapsed_ms = tracing::field::Empty
);
let started = (!span.is_disabled()).then(|| {
span.record("stmt", stmt_tag(&sql).as_str());
std::time::Instant::now()
});
let result = tokio::task::spawn_blocking(move || {
let db = conn.lock().map_err(|_| {
mlua::Error::RuntimeError("failed to lock the database connection".into())
})?;
let conn = &db.conn;
if outer && !conn.is_autocommit() {
tracing::warn!(
"rolling back a transaction a previous request left open on this connection \
(its handler was cut off mid-transaction)"
);
conn.execute_batch("ROLLBACK").map_err(|err| {
mlua::Error::RuntimeError(format!(
"failed to roll back an abandoned transaction: {}",
redact(&err)
))
})?;
}
f(conn, &sql, ¶ms, db.max_rows).map_err(|err| {
mlua::Error::RuntimeError(format!(
"{kind} failed (stmt {}): {}",
stmt_tag(&sql),
redact(&err)
))
})
})
.instrument(span.clone())
.await
.map_err(mlua::Error::external)?;
if let Some(started) = started {
span.record("elapsed_ms", started.elapsed().as_millis() as u64);
}
result
}
fn redact(err: &rusqlite::Error) -> String {
match err {
rusqlite::Error::SqlInputError { msg, offset, .. } => {
format!("{msg} at offset {offset}")
}
other => other.to_string(),
}
}
fn stmt_tag(sql: &str) -> String {
use std::hash::{Hash as _, Hasher as _};
let mut hasher = std::collections::hash_map::DefaultHasher::new();
sql.hash(&mut hasher);
format!("{:08x}", hasher.finish() as u32)
}
async fn exec_batch(conn: Conn, sql: String, outer: bool) -> mlua::Result<()> {
run_blocking(conn, "tx", sql, Vec::new(), outer, |conn, sql, _, _| {
conn.execute_batch(sql)
})
.await
}
fn add_stmt_methods<T, M>(methods: &mut M, conn_of: fn(&T) -> mlua::Result<Conn>, outer: bool)
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, outer, 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, outer, query_row::call).await?;
match row {
Some(row) => row_to_lua(&lua, row).map(Value::Table),
None => Ok(Value::Nil),
}
}
},
);
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, outer, 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, outer, query::call).await?;
rows_to_lua(&lua, rows)
}
});
}
#[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>,
origin: QueryOrigin,
}
impl PendingQuery {
pub async fn run(self, lua: &Lua) -> mlua::Result<Value> {
let PendingQuery {
conn,
kind,
sql,
params,
origin,
} = self;
origin.check()?;
let outer = origin.is_outer();
match kind {
QueryKind::Execute => {
let affected =
run_blocking(conn, "execute", sql, params, outer, execute::call).await?;
Ok(Value::Integer(affected as i64))
}
QueryKind::QueryRow => {
let row =
run_blocking(conn, "query_row", sql, params, outer, query_row::call).await?;
match row {
Some(row) => row_to_lua(lua, row).map(Value::Table),
None => Ok(Value::Nil),
}
}
QueryKind::QueryOne => {
let row =
run_blocking(conn, "query_one", sql, params, outer, query_one::call).await?;
row_to_lua(lua, row).map(Value::Table)
}
QueryKind::Query => {
let rows = run_blocking(conn, "query", sql, params, outer, query::call).await?;
rows_to_lua(lua, rows).map(Value::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,
origin_of: fn(&T) -> mlua::Result<(Conn, QueryOrigin)>,
) where
T: UserData + 'static,
M: UserDataMethods<T>,
{
methods.add_method(
"query_async",
move |_, this, (sql, params, kind): (String, Option<Table>, Option<String>)| {
let (conn, origin) = origin_of(this)?;
Ok(LuaPendingQuery(Mutex::new(Some(PendingQuery {
conn,
kind: QueryKind::parse(kind.as_deref())?,
sql,
params: params_from_table(params.as_ref())?,
origin,
}))))
},
);
}
async fn rollback_if_open(conn: Conn, sql: String) -> mlua::Result<()> {
run_blocking(conn, "tx", sql, Vec::new(), false, |conn, sql, _, _| {
if conn.is_autocommit() {
Ok(())
} else {
conn.execute_batch(sql)
}
})
.await
}
struct ScopeEnd(Arc<AtomicBool>);
impl Drop for ScopeEnd {
fn drop(&mut self) {
self.0.store(false, Ordering::Release);
}
}
const TRANSACTION_WRAPPER: &str = r#"
local run, unpack = ...
return function(self, f)
local packed = run(self, f)
if packed[1] then
return unpack(packed, 2, packed.n)
end
error(packed[2], 0)
end
"#;
const TRANSACTION_BODY: &str = r#"
local pack = ...
return function(f, scope) return pack(pcall(f, scope)) end
"#;
const TRANSACTION_BODY_KEY: &str = "nitr::db::transaction_body";
const TRANSACTION_OUTER_KEY: &str = "nitr::db::transaction";
const TRANSACTION_SAVEPOINT_KEY: &str = "nitr::db::savepoint";
fn transaction_method<R>(
lua: &Lua,
key: &str,
run: fn(Lua, (AnyUserData, Function)) -> R,
) -> mlua::Result<Function>
where
R: Future<Output = mlua::Result<Table>> + mlua::MaybeSend + 'static,
{
if let Ok(wrapper) = lua.named_registry_value::<Function>(key) {
return Ok(wrapper);
}
let run = lua.create_async_function(run)?;
let unpack = lua.create_function(|_, (packed, from, to): (Table, usize, usize)| {
let mut values = mlua::MultiValue::with_capacity(to.saturating_sub(from) + 1);
for index in from..=to {
values.push_back(packed.raw_get::<Value>(index)?);
}
Ok(values)
})?;
let wrapper = lua
.load(TRANSACTION_WRAPPER)
.set_name("=nitr.db")
.call::<Function>((run, unpack))?;
lua.set_named_registry_value(key, wrapper.clone())?;
Ok(wrapper)
}
fn transaction_body(lua: &Lua) -> mlua::Result<Function> {
if let Ok(body) = lua.named_registry_value::<Function>(TRANSACTION_BODY_KEY) {
return Ok(body);
}
let pack = lua.create_function(|lua, args: mlua::MultiValue| {
let packed = lua.create_table_with_capacity(args.len(), 1)?;
packed.raw_set("n", args.len())?;
for (index, value) in args.into_iter().enumerate() {
packed.raw_set(index + 1, value)?;
}
Ok(packed)
})?;
let body = lua
.load(TRANSACTION_BODY)
.set_name("=nitr.db")
.call::<Function>(pack)?;
lua.set_named_registry_value(TRANSACTION_BODY_KEY, body.clone())?;
Ok(body)
}
async fn run_outer_transaction(lua: Lua, (db, f): (AnyUserData, Function)) -> mlua::Result<Table> {
let (conn, flag) = {
let db = db.borrow::<LuaDatabase>()?;
(db.conn.clone(), db.in_transaction.clone())
};
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 _guard = TxGuard(flag);
run_transaction(
&lua,
conn,
f,
"BEGIN".into(),
"COMMIT".into(),
"ROLLBACK".into(),
true,
)
.await
}
async fn run_savepoint(lua: Lua, (tx, f): (AnyUserData, Function)) -> mlua::Result<Table> {
let (conn, n) = {
let tx = tx.borrow::<LuaTransaction>()?;
(tx_conn(&tx)?, tx.savepoints.fetch_add(1, Ordering::Relaxed))
};
let name = format!("nitr_sp_{n}");
run_transaction(
&lua,
conn,
f,
format!("SAVEPOINT {name}"),
format!("RELEASE {name}"),
format!("ROLLBACK TO {name}; RELEASE {name}"),
false,
)
.await
}
async fn run_transaction(
lua: &Lua,
conn: Conn,
f: Function,
begin: String,
commit: String,
rollback: String,
outer: bool,
) -> mlua::Result<Table> {
let body = transaction_body(lua)?;
exec_batch(conn.clone(), begin, outer).await?;
let alive = Arc::new(AtomicBool::new(true));
let _scope_end = ScopeEnd(alive.clone());
let scope = lua.create_userdata(LuaTransaction {
conn: conn.clone(),
savepoints: AtomicUsize::new(0),
alive,
})?;
let result = body.call_async::<Table>((f, &scope)).await;
let roll_back = |conn: Conn| async move {
if outer {
rollback_if_open(conn, rollback).await
} else {
exec_batch(conn, rollback, false).await
}
};
let ok = match &result {
Ok(packed) => packed.raw_get::<bool>(1)?,
Err(_) => false,
};
if ok {
if let Err(commit_err) = exec_batch(conn.clone(), commit, false).await {
if let Err(rollback_err) = roll_back(conn).await {
tracing::error!("rollback after a failed commit failed: {rollback_err}");
}
return Err(commit_err);
}
} else if let Err(rollback_err) = roll_back(conn).await {
tracing::error!("transaction rollback failed: {rollback_err}");
}
result
}
struct TxGuard(TxFlag);
impl Drop for TxGuard {
fn drop(&mut self) {
self.0.store(false, Ordering::Release);
}
}
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())
},
true,
);
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(),
QueryOrigin::Outer(db.in_transaction.clone()),
))
});
}
fn add_fields<F: mlua::UserDataFields<Self>>(fields: &mut F) {
fields.add_field_method_get("transaction", |lua, _| {
transaction_method(lua, TRANSACTION_OUTER_KEY, run_outer_transaction)
});
}
}
impl UserData for LuaTransaction {
fn add_methods<M: UserDataMethods<Self>>(methods: &mut M) {
add_stmt_methods(methods, tx_conn, false);
add_async_query_method(methods, |tx: &LuaTransaction| {
Ok((tx_conn(tx)?, QueryOrigin::Inner(tx.alive.clone())))
});
}
fn add_fields<F: mlua::UserDataFields<Self>>(fields: &mut F) {
fields.add_field_method_get("transaction", |lua, _| {
transaction_method(lua, TRANSACTION_SAVEPOINT_KEY, run_savepoint)
});
}
}
pub(crate) fn create_database_fn(
lua: &Lua,
path: &std::path::Path,
pragmas: &SqlitePragmas,
) -> Result<AnyUserData> {
let conn = Arc::new(Mutex::new(Db {
conn: pragmas::open(path, pragmas)?,
max_rows: pragmas.max_rows,
}));
let value = lua.create_userdata(LuaDatabase {
conn,
in_transaction: Arc::new(AtomicBool::new(false)),
})?;
Ok(value)
}
#[cfg(test)]
mod tests {
use super::*;
async fn db_state(label: &str) -> (Lua, std::path::PathBuf) {
db_state_with(label, SqlitePragmas::default()).await
}
async fn db_state_with(label: &str, pragmas: SqlitePragmas) -> (Lua, std::path::PathBuf) {
static NEXT: AtomicUsize = AtomicUsize::new(0);
let id = NEXT.fetch_add(1, Ordering::Relaxed);
let dir =
std::env::temp_dir().join(format!("nitr-db-test-{label}-{}-{id}", std::process::id()));
std::fs::create_dir_all(&dir).expect("temp dir");
let path = dir.join("app.db");
let lua = Lua::new();
let db = create_database_fn(&lua, &path, &pragmas).expect("db");
let nitr = lua.create_table().expect("table");
nitr.set("db", db).expect("set");
lua.globals().set("nitr", nitr).expect("set");
let stall = lua
.create_async_function(|_, ()| async {
tokio::time::sleep(std::time::Duration::from_secs(60)).await;
Ok(())
})
.expect("stall");
lua.globals().set("stall", stall).expect("set");
lua.load("nitr.db:execute('CREATE TABLE t (x INTEGER)')")
.exec_async()
.await
.expect("setup statement");
(lua, dir)
}
async fn count(lua: &Lua) -> i64 {
lua.load("return nitr.db:query_row('SELECT COUNT(*) AS n FROM t').n")
.eval_async()
.await
.expect("count")
}
#[tokio::test(flavor = "multi_thread")]
async fn a_transaction_returns_every_value_and_reraises_the_original_error() {
let (lua, dir) = db_state("txvalues").await;
let (a, b, c): (i64, Option<i64>, i64) = lua
.load("return nitr.db:transaction(function(tx) return 1, nil, 3 end)")
.eval_async()
.await
.expect("values");
assert_eq!((a, b, c), (1, None, 3));
let (is_table, code, rolled_back): (bool, String, bool) = lua
.load(
r#"
local ok, err = pcall(nitr.db.transaction, nitr.db, function(tx)
tx:execute("INSERT INTO t VALUES (1)")
tx:transaction(function(sp)
sp:execute("INSERT INTO t VALUES (2)")
end)
error({ code = "OUT_OF_STOCK", item = 7 })
end)
local n = nitr.db:query_row("SELECT COUNT(*) AS n FROM t").n
return type(err) == "table", err.code, n == 0
"#,
)
.eval_async()
.await
.expect("pcall");
assert!(is_table, "the error value must stay a table");
assert_eq!(code, "OUT_OF_STOCK");
assert!(rolled_back);
let (code, n): (String, i64) = lua
.load(
r#"
return nitr.db:transaction(function(tx)
tx:execute("INSERT INTO t VALUES (1)")
local ok, err = pcall(tx.transaction, tx, function(sp)
sp:execute("INSERT INTO t VALUES (2)")
error({ code = "INNER" })
end)
return err.code, tx:query_row("SELECT COUNT(*) AS n FROM t").n
end)
"#,
)
.eval_async()
.await
.expect("savepoint");
assert_eq!((code.as_str(), n), ("INNER", 1));
let _ = std::fs::remove_dir_all(dir);
}
#[tokio::test(flavor = "multi_thread")]
async fn an_empty_result_set_is_a_list() {
let (lua, dir) = db_state("emptyrows").await;
let rows: Value = lua
.load("return nitr.db:query('SELECT x FROM t WHERE x = 42')")
.eval_async()
.await
.expect("query");
assert_eq!(crate::bounded::to_json_string(&rows).expect("json"), "[]");
let _ = std::fs::remove_dir_all(dir);
}
#[tokio::test(flavor = "multi_thread")]
async fn query_row_returns_nil_for_an_empty_result() {
let (lua, dir) = db_state("qrow").await;
let row: Value = lua
.load("return nitr.db:query_row('SELECT x FROM t WHERE x = 42')")
.eval_async()
.await
.expect("query_row");
assert!(row.is_nil(), "no rows must be nil, got {row:?}");
let _ = std::fs::remove_dir_all(dir);
}
#[tokio::test(flavor = "multi_thread")]
async fn a_nil_parameter_inserts_null_but_a_missing_list_does_not() {
let (lua, dir) = db_state("null").await;
let (trailing, packed): (bool, bool) = lua
.load(
"nitr.db:execute('CREATE TABLE p (a INTEGER, b TEXT)')
nitr.db:execute('INSERT INTO p (a, b) VALUES (?, ?)', { 1, nil })
nitr.db:execute('INSERT INTO p (a, b) VALUES (?, ?)', table.pack(nil, 'x'))
return nitr.db:query_one('SELECT b IS NULL AS missing FROM p WHERE a = 1').missing == 1,
nitr.db:query_one('SELECT a IS NULL AS missing FROM p WHERE b = ?', { 'x' }).missing == 1",
)
.eval_async()
.await
.expect("insert");
assert!(trailing && packed);
for params in ["", ", {}"] {
let err = lua
.load(format!(
"return nitr.db:query('SELECT * FROM p WHERE a = ?'{params})"
))
.eval_async::<Value>()
.await
.expect_err("no parameters")
.to_string();
assert!(err.contains("parameters"), "`{params}`: {err}");
}
let _ = std::fs::remove_dir_all(dir);
}
#[tokio::test(flavor = "multi_thread")]
async fn duplicate_column_names_are_refused() {
let (lua, dir) = db_state("dupcol").await;
for call in ["query", "query_row", "query_one"] {
let err = lua
.load(format!("return nitr.db:{call}('SELECT 1 AS id, 2 AS id')"))
.eval_async::<Value>()
.await
.expect_err(call)
.to_string();
assert!(err.contains("columns 1 and 2"), "{call}: {err}");
}
let _ = std::fs::remove_dir_all(dir);
}
#[tokio::test(flavor = "multi_thread")]
async fn an_abandoned_transaction_is_rolled_back_and_the_connection_recovers() {
let (lua, dir) = db_state("abandon").await;
let body = lua
.load(
"nitr.db:transaction(function(tx)
tx:execute('INSERT INTO t VALUES (1)')
stall()
end)",
)
.exec_async();
let timed = tokio::time::timeout(std::time::Duration::from_millis(200), body).await;
assert!(timed.is_err(), "the stall must outlive the timeout");
lua.load("nitr.db:execute('INSERT INTO t VALUES (2)')")
.exec_async()
.await
.expect("an outer statement runs after the abandoned transaction");
assert_eq!(count(&lua).await, 1, "the abandoned insert was rolled back");
lua.load("nitr.db:transaction(function(tx) tx:execute('INSERT INTO t VALUES (3)') end)")
.exec_async()
.await
.expect("a new transaction opens");
assert_eq!(count(&lua).await, 2);
let _ = std::fs::remove_dir_all(dir);
}
#[tokio::test(flavor = "multi_thread")]
async fn an_outer_pending_query_is_refused_inside_a_transaction() {
let (lua, dir) = db_state("pending").await;
let (ok, err): (bool, String) = lua
.load(
"local h = nitr.db:query_async('SELECT 1')
local ok, err = pcall(function()
nitr.db:transaction(function(tx)
tx:execute('INSERT INTO t VALUES (1)')
h:send()
end)
end)
return ok, tostring(err)",
)
.eval_async()
.await
.expect("script");
assert!(!ok, "the handle must be refused");
assert!(err.contains("transaction is open"), "got: {err}");
assert_eq!(
count(&lua).await,
0,
"the body's insert rolled back with the error"
);
let _ = std::fs::remove_dir_all(dir);
}
#[tokio::test(flavor = "multi_thread")]
async fn a_stashed_tx_handle_is_dead_after_its_transaction_ends() {
let (lua, dir) = db_state("stash").await;
let (ok, err): (bool, String) = lua
.load(
"local saved
nitr.db:transaction(function(tx) saved = tx end)
local ok, err = pcall(function() saved:execute('INSERT INTO t VALUES (1)') end)
return ok, tostring(err)",
)
.eval_async()
.await
.expect("script");
assert!(!ok);
assert!(err.contains("has ended"), "got: {err}");
assert_eq!(count(&lua).await, 0);
let _ = std::fs::remove_dir_all(dir);
}
#[tokio::test(flavor = "multi_thread")]
async fn queries_past_max_rows_are_refused_not_truncated() {
let pragmas = SqlitePragmas {
max_rows: 2,
..SqlitePragmas::default()
};
let (lua, dir) = db_state_with("maxrows", pragmas).await;
lua.load("nitr.db:execute('INSERT INTO t VALUES (1), (2), (3)')")
.exec_async()
.await
.expect("seed");
let (ok, err): (bool, String) = lua
.load(
"local ok, err = pcall(function() return nitr.db:query('SELECT x FROM t') end)
return ok, tostring(err)",
)
.eval_async()
.await
.expect("script");
assert!(!ok, "three rows over a cap of two must fail");
assert!(err.contains("max_rows"), "got: {err}");
let n: i64 = lua
.load("return #nitr.db:query('SELECT x FROM t LIMIT 2')")
.eval_async()
.await
.expect("at the cap");
assert_eq!(n, 2);
let _ = std::fs::remove_dir_all(dir);
}
#[tokio::test(flavor = "multi_thread")]
async fn a_failed_commit_rolls_back_and_the_connection_recovers() {
let pragmas = SqlitePragmas {
journal_mode: "delete".into(),
busy_timeout: 50,
..SqlitePragmas::default()
};
let (lua, dir) = db_state_with("commitfail", pragmas).await;
lua.load("nitr.db:execute('INSERT INTO t VALUES (1)')")
.exec_async()
.await
.expect("seed");
let reader = Connection::open(dir.join("app.db")).expect("reader");
let mut stmt = reader.prepare("SELECT x FROM t").expect("prepare");
let mut rows = stmt.query([]).expect("query");
assert!(
rows.next().expect("step").is_some(),
"the cursor must be live"
);
let (ok, err): (bool, String) = lua
.load(
"local ok, err = pcall(function()
nitr.db:transaction(function(tx) tx:execute('INSERT INTO t VALUES (2)') end)
end)
return ok, tostring(err)",
)
.eval_async()
.await
.expect("script");
assert!(!ok, "COMMIT must fail while the reader holds its lock");
assert!(
err.contains("locked") || err.contains("busy"),
"the failure must be the lock, got: {err}"
);
drop(rows);
drop(stmt);
drop(reader);
lua.load("nitr.db:execute('INSERT INTO t VALUES (3)')")
.exec_async()
.await
.expect("the connection is usable after the failed commit");
let xs: Vec<i64> = lua
.load(
"local out = {}
for _, r in ipairs(nitr.db:query('SELECT x FROM t ORDER BY x')) do
out[#out + 1] = r.x
end
return out",
)
.eval_async()
.await
.expect("rows");
assert_eq!(
xs,
vec![1, 3],
"row 2 was rolled back with the failed commit"
);
let _ = std::fs::remove_dir_all(dir);
}
#[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}");
}
}