fix(sqlite): run remote batch saves in a worker transaction

This commit is contained in:
64673a authored and GitHub committed 2026-09-24 16:27:03 +08:00
1 parent 4b5d4e6aa7
commit ad18b8b4ea
3 files changed
+176 -24

No files matched your search

+107
View File
@@ -5306,6 +5306,9 @@ async fn exec_tx_sqlite_inner(
) -> Result<db::QueryResult, String> {
let statements = statements.to_vec();
let query_timeout = budget.query_timeout;
if let Some(worker) = pool.worker() {
return exec_tx_sqlite_worker_inner(worker, statements, start, query_timeout).await;
}
tokio::task::spawn_blocking(move || {
pool.with_connection(|conn| {
conn.execute_batch("BEGIN").map_err(|e| format!("Failed to begin transaction: {}", e))?;
@@ -5476,6 +5479,55 @@ async fn exec_tx_sqlite_inner(
.map_err(|e| e.to_string())?
}
async fn exec_tx_sqlite_worker_inner(
worker: Arc<db::sqlite_worker::SqliteWorkerClient>,
statements: Vec<String>,
start: std::time::Instant,
query_timeout: Option<Duration>,
) -> Result<db::QueryResult, String> {
// Detached like the local spawn_blocking path, so a dropped caller cannot leave the
// worker connection inside an open transaction. One session keeps other requests out.
tokio::spawn(async move {
let mut session = worker.session().await;
session.query("BEGIN", None).await.map_err(|e| format!("Failed to begin transaction: {e}"))?;
// ponytail: the worker cannot interrupt a running statement, so the budget is only
// checked between statements; bounding one slow statement needs a worker interrupt op.
let within_budget = || match query_timeout {
Some(timeout) if start.elapsed() >= timeout => {
Err(format!("Query timed out after {} seconds", timeout.as_secs()))
}
_ => Ok(()),
};
let outcome: Result<db::QueryResult, String> = async {
let mut total_affected = 0;
for (i, sql) in statements.iter().enumerate() {
within_budget()?;
total_affected += session
.query(sql, None)
.await
.map_err(|e| {
query_error_with_omitted_sql_context(&format!("Statement {} failed: {}", i + 1, e), sql)
})?
.affected_rows;
}
within_budget()?;
let committed = session.query("COMMIT", None).await.map_err(|e| format!("COMMIT failed: {e}"))?;
Ok(db::QueryResult {
affected_rows: total_affected,
execution_time_ms: start.elapsed().as_millis(),
..committed
})
}
.await;
if outcome.is_err() {
let _ = session.query("ROLLBACK", None).await;
}
outcome
})
.await
.map_err(|e| e.to_string())?
}
async fn exec_tx_explicit_inner(
state: &AppState,
pool_key: &str,
@@ -7304,6 +7356,61 @@ mod tests {
assert!(error.contains("Statement 1 failed") && error.contains("interrupted_at"), "unexpected error: {error}");
}
#[tokio::test]
async fn sqlite_ssh_worker_transaction_rolls_back_on_failure_and_commits_on_success() {
let remote = Arc::new(Mutex::new(rusqlite::Connection::open_in_memory().expect("open remote SQLite")));
remote.lock().unwrap().execute_batch("CREATE TABLE t (id INTEGER PRIMARY KEY)").expect("create table");
let (client_stream, worker_stream) = tokio::io::duplex(64 * 1024);
tokio::spawn(fake_sqlite_ssh_worker(worker_stream, remote.clone()));
let pool = db::sqlite::SqliteHandle::from_worker(Arc::new(
db::sqlite_worker::SqliteWorkerClient::from_test_stream(client_stream),
));
let budget = DbOperationBudget::with_defaults();
let row_count =
|| remote.lock().unwrap().query_row("SELECT COUNT(*) FROM t", [], |row| row.get::<_, i64>(0)).unwrap();
let error = exec_tx_sqlite_inner(
pool.clone(),
&["INSERT INTO t VALUES (1)".to_string(), "INSERT INTO missing VALUES (2)".to_string()],
std::time::Instant::now(),
&budget,
)
.await
.expect_err("second statement fails");
assert!(error.contains("Statement 2 failed") && error.contains("no such table: missing"), "{error}");
assert_eq!(row_count(), 0);
let result = exec_tx_sqlite_inner(
pool,
&["INSERT INTO t VALUES (1)".to_string(), "INSERT INTO t VALUES (2)".to_string()],
std::time::Instant::now(),
&budget,
)
.await
.expect("transaction commits");
assert_eq!(result.affected_rows, 2);
assert_eq!(row_count(), 2);
}
/// Answers SQLite worker JSONL requests from a real SQLite connection.
async fn fake_sqlite_ssh_worker(stream: tokio::io::DuplexStream, conn: Arc<Mutex<rusqlite::Connection>>) {
use tokio::io::{AsyncBufReadExt, AsyncWriteExt};
let (reader, mut writer) = tokio::io::split(stream);
let mut lines = tokio::io::BufReader::new(reader).lines();
while let Ok(Some(line)) = lines.next_line().await {
let request: serde_json::Value = serde_json::from_str(&line).expect("worker request");
let mut response = {
let conn = conn.lock().unwrap();
match conn.execute_batch(request["sql"].as_str().unwrap_or_default()) {
Ok(()) => serde_json::json!({ "affected_rows": conn.changes() }),
Err(error) => serde_json::json!({ "error": error.to_string() }),
}
};
response["id"] = request["id"].clone();
writer.write_all(format!("{response}\n").as_bytes()).await.expect("worker response");
}
}
#[tokio::test]
async fn sqlite_external_interrupt_without_budget_does_not_panic() {
// Regression: with query_timeout = None (MCP policy can set it to 0 =