25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
use std::sync::{Arc, Mutex};
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader, Stdout};
use crate::wire as db;
use crate::wire::{
AttachedDatabaseConfig, DuckDbWorkerColumnParams, DuckDbWorkerConnectParams, DuckDbWorkerDatabaseParams,
DuckDbWorkerError, DuckDbWorkerExecuteParams, DuckDbWorkerMethod, DuckDbWorkerObjectSourceParams,
DuckDbWorkerRequest, DuckDbWorkerResponse, DuckDbWorkerTableParams,
};
#[derive(Default)]
pub struct DuckDbWorkerSession {
connection: Option<Arc<crate::connection::DuckDbConnection>>,
attached_names: Vec<String>,
}
impl DuckDbWorkerSession {
pub fn connect(&mut self, params: DuckDbWorkerConnectParams) -> Result<(), String> {
let path = expand_tilde(¶ms.path);
let connection = crate::connection::connect_path(&path)?;
let mut attached_names = Vec::new();
{
let locked = connection.lock().map_err(|e| e.to_string())?;
for attached in ¶ms.attached_databases {
let path = expand_tilde(&attached.path);
crate::schema::duckdb_attach_database(&locked, &attached.name, &path)?;
attached_names.push(attached.name.clone());
}
if let Some(script) = params.init_script.as_deref() {
// Track script attachments by diffing the actual catalog list
// instead of parsing the SQL, so ATTACH without an alias,
// dynamic statements, and extension-specific syntax all count.
let before = duckdb_catalog_list(&locked)?;
crate::connection::run_init_script(&locked, script)?;
for name in duckdb_catalog_list(&locked)? {
if !before.iter().any(|existing| existing.eq_ignore_ascii_case(&name))
&& !attached_names.iter().any(|attached| attached.eq_ignore_ascii_case(&name))
{
attached_names.push(name);
}
}
}
}
self.connection = Some(connection);
self.attached_names = attached_names;
Ok(())
}
pub fn execute(&mut self, params: DuckDbWorkerExecuteParams) -> Result<db::QueryResult, String> {
let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
let locked = connection.lock().map_err(|e| e.to_string())?;
let result = if params.preserve_insertion_order {
execute_with_preserved_insertion_order(&locked, &self.attached_names, ¶ms)?
} else {
crate::query::duckdb_execute_for_database(
&locked,
&self.attached_names,
params.database.as_deref(),
¶ms.sql,
params.max_rows,
)?
};
if let Some(name) = crate::sql::attached_name_from_attach_sql(¶ms.sql) {
if !self.attached_names.iter().any(|attached| attached.eq_ignore_ascii_case(&name)) {
self.attached_names.push(name);
}
}
Ok(result)
}
pub fn list_databases(&self) -> Result<Vec<db::DatabaseInfo>, String> {
let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
let locked = connection.lock().map_err(|e| e.to_string())?;
crate::schema::duckdb_list_databases_with_attached(&locked, &self.attached_names)
}
pub fn list_schemas(&self, params: DuckDbWorkerDatabaseParams) -> Result<Vec<String>, String> {
let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
let locked = connection.lock().map_err(|e| e.to_string())?;
crate::schema::duckdb_list_schemas_with_attached(&locked, ¶ms.database, &self.attached_names)
}
pub fn list_tables(&self, params: DuckDbWorkerTableParams) -> Result<Vec<db::TableInfo>, String> {
let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
let locked = connection.lock().map_err(|e| e.to_string())?;
crate::schema::duckdb_query_tables_in_database_with_attached(
&locked,
¶ms.database,
¶ms.schema,
&self.attached_names,
)
}
pub fn list_columns(&self, params: DuckDbWorkerColumnParams) -> Result<Vec<db::ColumnInfo>, String> {
let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
let locked = connection.lock().map_err(|e| e.to_string())?;
crate::schema::duckdb_query_columns_in_database_with_attached(
&locked,
¶ms.database,
¶ms.schema,
¶ms.table,
&self.attached_names,
)
}
pub fn get_table_ddl(&self, params: DuckDbWorkerColumnParams) -> Result<String, String> {
let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
let locked = connection.lock().map_err(|e| e.to_string())?;
crate::schema::duckdb_table_ddl_with_attached(
&locked,
¶ms.database,
¶ms.schema,
¶ms.table,
&self.attached_names,
)
}
pub fn completion_assistant(
&self,
request: db::CompletionAssistantRequest,
) -> Result<db::CompletionAssistantResponse, String> {
let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
let locked = connection.lock().map_err(|e| e.to_string())?;
crate::schema::duckdb_completion_assistant_search(&locked, &request, &self.attached_names)
}
pub fn get_object_source(&self, params: DuckDbWorkerObjectSourceParams) -> Result<String, String> {
let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
let locked = connection.lock().map_err(|e| e.to_string())?;
crate::schema::duckdb_object_source_with_attached(
&locked,
¶ms.database,
¶ms.schema,
¶ms.name,
¶ms.object_type,
&self.attached_names,
)
}
pub fn attach_database(&mut self, attached: AttachedDatabaseConfig) -> Result<(), String> {
let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
let locked = connection.lock().map_err(|e| e.to_string())?;
let path = expand_tilde(&attached.path);
crate::schema::duckdb_attach_database(&locked, &attached.name, &path)?;
self.attached_names.push(attached.name);
Ok(())
}
fn interrupt_handle(&self) -> Result<Arc<duckdb::InterruptHandle>, String> {
let connection = self.connection.as_ref().ok_or("DuckDB worker is not connected")?.clone();
Ok(connection.interrupt_handle())
}
/// Takes and closes the connection so DuckDB's shutdown checkpoint runs and
/// the database WAL is removed before this worker exits. Returns false —
/// leaving the connection untouched — when the connection is poisoned
/// (dropping it aborts the process) so the caller falls back to an
/// immediate exit and the WAL replays on the next open.
fn close_connection_for_shutdown(&mut self) -> bool {
if self.connection.is_none() {
return true;
}
if !self.is_connection_healthy() {
return false;
}
match self.connection.take() {
Some(connection) => {
crate::connection::close_connection(connection);
true
}
None => true,
}
}
/// Probes whether the connection is still usable after an execute error.
///
/// duckdb-rs 1.10503.1 has a bug where `Connection::prepare()` failing at the
/// `duckdb_extract_statements` stage (a syntax `Parser Error`) permanently poisons
/// the connection: every later operation returns `resource deadlock would occur`,
/// and dropping the connection aborts the whole process. Benign errors (binder,
/// catalog, runtime) do not poison the connection.
///
/// This probe runs a trivial query through `execute_batch`, which uses the
/// non-poisoning `duckdb_query_arrow` path and fails fast on a poisoned connection.
/// It returns `true` when the connection is healthy and safe to reuse.
fn is_connection_healthy(&self) -> bool {
match self.connection.as_ref() {
Some(connection) => match connection.lock() {
Ok(locked) => locked.execute_batch("SELECT 1").is_ok(),
Err(_) => false,
},
None => false,
}
}
}
fn execute_with_preserved_insertion_order(
connection: &duckdb::Connection,
attached_names: &[String],
params: &DuckDbWorkerExecuteParams,
) -> Result<db::QueryResult, String> {
let current: String = connection
.query_row("SELECT CAST(current_setting('preserve_insertion_order') AS VARCHAR)", [], |row| row.get(0))
.map_err(|error| format!("Failed to read DuckDB preserve_insertion_order setting: {error}"))?;
let was_enabled = current
.parse::<bool>()
.map_err(|error| format!("Invalid DuckDB preserve_insertion_order setting {current:?}: {error}"))?;
if was_enabled {
return crate::query::duckdb_execute_for_database(
connection,
attached_names,
params.database.as_deref(),
¶ms.sql,
params.max_rows,
);
}
// LIMIT/OFFSET Parquet pages are separate scans. Temporarily enabling this
// setting makes every page use the same source order without changing the
// user's connection-level setting after the request completes.
connection
.execute_batch("SET preserve_insertion_order = true")
.map_err(|error| format!("Failed to enable DuckDB insertion-order preservation: {error}"))?;
let result = crate::query::duckdb_execute_for_database(
connection,
attached_names,
params.database.as_deref(),
¶ms.sql,
params.max_rows,
);
let restore = connection.execute_batch("SET preserve_insertion_order = false");
match (result, restore) {
(result, Ok(())) => result,
(Ok(_), Err(error)) => {
Err(format!("DuckDB query succeeded but restoring preserve_insertion_order failed: {error}"))
}
(Err(query_error), Err(restore_error)) => {
Err(format!("{query_error}; restoring preserve_insertion_order also failed: {restore_error}"))
}
}
}
fn expand_tilde(path: &str) -> String {
if !path.starts_with('~') {
return path.to_string();
}
if path.len() == 1 {
return home_dir().unwrap_or_else(|| path.to_string());
}
if path.as_bytes().get(1) == Some(&b'/') {
return home_dir().map(|home| home + &path[1..]).unwrap_or_else(|| path.to_string());
}
path.to_string()
}
fn home_dir() -> Option<String> {
std::env::var("HOME").or_else(|_| std::env::var("USERPROFILE")).ok()
}
fn duckdb_catalog_list(con: &duckdb::Connection) -> Result<Vec<String>, String> {
let mut stmt = con.prepare("SHOW DATABASES").map_err(|e| e.to_string())?;
let rows = stmt.query_map([], |row| row.get::<_, String>(0)).map_err(|e| e.to_string())?;
Ok(rows.filter_map(|row| row.ok()).collect())
}
#[derive(Clone, Default)]
struct DuckDbWorkerRuntime {
session: Arc<Mutex<DuckDbWorkerSession>>,
active_interrupt: Arc<Mutex<Option<Arc<duckdb::InterruptHandle>>>>,
}
struct WorkerHandleResult {
response: Option<DuckDbWorkerResponse>,
shutdown: bool,
}
impl DuckDbWorkerRuntime {
/// Closes the session connection when the worker is idle and the connection
/// is healthy, so the DuckDB shutdown checkpoint removes the WAL. Returns
/// false when a query is running (the session is locked or an interrupt is
/// registered) or the connection is poisoned; callers then keep the legacy
/// immediate-exit behavior and rely on WAL replay at the next open.
fn close_session_for_shutdown(&self) -> bool {
if self.active_interrupt.lock().unwrap_or_else(|e| e.into_inner()).is_some() {
return false;
}
match self.session.try_lock() {
Ok(mut session) => session.close_connection_for_shutdown(),
Err(_) => false,
}
}
async fn handle_request(
&self,
request: DuckDbWorkerRequest,
stdout: Arc<tokio::sync::Mutex<Stdout>>,
) -> WorkerHandleResult {
match request.method {
DuckDbWorkerMethod::Connect => self.handle_session_request(request, |session, request| {
session.connect(request.parse_params()?)?;
Ok(DuckDbWorkerResponse::ok(request.id, serde_json::json!({ "connected": true })))
}),
DuckDbWorkerMethod::ListDatabases => self.handle_session_request(request, |session, request| {
Ok(DuckDbWorkerResponse::ok(request.id, session.list_databases()?))
}),
DuckDbWorkerMethod::ListSchemas => self.handle_session_request(request, |session, request| {
let params = request.parse_params()?;
Ok(DuckDbWorkerResponse::ok(request.id, session.list_schemas(params)?))
}),
DuckDbWorkerMethod::ListTables => self.handle_session_request(request, |session, request| {
let params = request.parse_params()?;
Ok(DuckDbWorkerResponse::ok(request.id, session.list_tables(params)?))
}),
DuckDbWorkerMethod::ListColumns => self.handle_session_request(request, |session, request| {
let params = request.parse_params()?;
Ok(DuckDbWorkerResponse::ok(request.id, session.list_columns(params)?))
}),
DuckDbWorkerMethod::GetTableDdl => self.handle_session_request(request, |session, request| {
let params = request.parse_params()?;
Ok(DuckDbWorkerResponse::ok(request.id, session.get_table_ddl(params)?))
}),
DuckDbWorkerMethod::CompletionAssistant => self.handle_session_request(request, |session, request| {
let params = request.parse_params()?;
Ok(DuckDbWorkerResponse::ok(request.id, session.completion_assistant(params)?))
}),
DuckDbWorkerMethod::GetObjectSource => self.handle_session_request(request, |session, request| {
let params = request.parse_params()?;
Ok(DuckDbWorkerResponse::ok(request.id, session.get_object_source(params)?))
}),
DuckDbWorkerMethod::AttachDatabase => self.handle_session_request(request, |session, request| {
session.attach_database(request.parse_params()?)?;
Ok(DuckDbWorkerResponse::ok_empty(request.id))
}),
DuckDbWorkerMethod::Execute => {
if self.active_interrupt.lock().unwrap_or_else(|e| e.into_inner()).is_some() {
return WorkerHandleResult {
response: Some(DuckDbWorkerResponse::err(
request.id,
DuckDbWorkerError::new("duckdb_worker_busy", "DuckDB worker is already executing a query"),
)),
shutdown: false,
};
}
let interrupt_handle = match self.session.lock().unwrap_or_else(|e| e.into_inner()).interrupt_handle() {
Ok(handle) => handle,
Err(err) => {
return WorkerHandleResult {
response: Some(DuckDbWorkerResponse::err(
request.id,
DuckDbWorkerError::from_message("duckdb_not_connected", err),
)),
shutdown: false,
}
}
};
*self.active_interrupt.lock().unwrap_or_else(|e| e.into_inner()) = Some(interrupt_handle);
let session = self.session.clone();
let active_interrupt = self.active_interrupt.clone();
tokio::spawn(async move {
let id = request.id.clone();
let params = request.parse_params::<DuckDbWorkerExecuteParams>();
let (result, poisoned) = match params {
Ok(params) => {
let probe_session = session.clone();
tokio::task::spawn_blocking(move || {
let mut session = probe_session.lock().unwrap_or_else(|e| e.into_inner());
let result = session.execute(params);
// Only probe connection health when execute failed: a syntax
// Parser Error can poison the connection (duckdb-rs bug), and any
// later use — including drop — would abort the process.
let poisoned = result.is_err() && !session.is_connection_healthy();
(result, poisoned)
})
.await
.map_err(|e| e.to_string())
.unwrap_or_else(|err| (Err(err), true))
}
Err(err) => (Err(err.message), false),
};
*active_interrupt.lock().unwrap_or_else(|e| e.into_inner()) = None;
let response = match result {
Ok(result) => DuckDbWorkerResponse::ok(id, result),
// A poisoned connection cannot be reused or even safely dropped in-process.
// Report a distinct code so the parent kills this worker (OS-level, skipping
// destructors) and restarts a fresh one on the next request. We must not exit
// here ourselves: process::exit races the parent's next request, which could
// be written to a dying worker. Killing on the parent side has no such window.
Err(err) if poisoned => {
log::warn!("[duckdb-worker:poisoned-connection] reporting to parent for restart");
DuckDbWorkerResponse::err(
id,
DuckDbWorkerError::from_message("duckdb_worker_poisoned", err),
)
}
Err(err) => {
DuckDbWorkerResponse::err(id, DuckDbWorkerError::from_message("duckdb_execute_failed", err))
}
};
write_response(stdout, &response).await;
});
WorkerHandleResult { response: None, shutdown: false }
}
DuckDbWorkerMethod::Cancel => {
if let Some(handle) = self.active_interrupt.lock().unwrap_or_else(|e| e.into_inner()).as_ref() {
handle.interrupt();
}
WorkerHandleResult {
response: Some(DuckDbWorkerResponse::ok(request.id, serde_json::json!({ "cancelled": true }))),
shutdown: false,
}
}
DuckDbWorkerMethod::Shutdown => {
// Close the connection before acking: the checkpoint that removes
// the WAL must finish before the parent observes this response
// (or the process exit it waits for). Busy or poisoned sessions
// skip the close; the parent's kill fallback and WAL replay on
// the next open cover them.
self.close_session_for_shutdown();
WorkerHandleResult {
response: Some(DuckDbWorkerResponse::ok(request.id, serde_json::json!({ "shutdown": true }))),
shutdown: true,
}
}
}
}
fn handle_session_request(
&self,
request: DuckDbWorkerRequest,
handler: impl FnOnce(
&mut DuckDbWorkerSession,
DuckDbWorkerRequest,
) -> Result<DuckDbWorkerResponse, DuckDbWorkerError>,
) -> WorkerHandleResult {
let id = request.id.clone();
if self.active_interrupt.lock().unwrap_or_else(|e| e.into_inner()).is_some() {
return WorkerHandleResult {
response: Some(DuckDbWorkerResponse::err(
id,
DuckDbWorkerError::new("duckdb_worker_busy", "DuckDB worker is executing a query"),
)),
shutdown: false,
};
}
let response = {
match self.session.try_lock() {
Ok(mut session) => match handler(&mut session, request) {
Ok(response) => response,
Err(err) => DuckDbWorkerResponse::err(id, err),
},
Err(_) => DuckDbWorkerResponse::err(
id,
DuckDbWorkerError::new("duckdb_worker_busy", "DuckDB worker session is busy"),
),
}
};
WorkerHandleResult { response: Some(response), shutdown: false }
}
}
pub async fn run_stdio_worker() -> Result<(), String> {
let runtime = DuckDbWorkerRuntime::default();
let stdout = Arc::new(tokio::sync::Mutex::new(tokio::io::stdout()));
let stdin = BufReader::new(tokio::io::stdin());
let mut lines = stdin.lines();
loop {
let line = lines.next_line().await.map_err(|e| e.to_string())?;
let Some(line) = line else {
// Parent closed stdin (exit or crash). Idle workers checkpoint and
// remove their WAL on the normal return path; a worker still running
// a query must not wait for it (nor drop a poisoned connection),
// so it keeps the legacy immediate exit and the WAL replays on the
// next open.
if !runtime.close_session_for_shutdown() {
std::process::exit(0);
}
break;
};
if line.trim().is_empty() {
continue;
}
let request: DuckDbWorkerRequest = match serde_json::from_str(&line) {
Ok(request) => request,
Err(err) => {
let response = DuckDbWorkerResponse::err(
"",
DuckDbWorkerError::new("invalid_json", format!("Invalid worker request JSON: {err}")),
);
write_response(stdout.clone(), &response).await;
continue;
}
};
let result = runtime.handle_request(request, stdout.clone()).await;
if let Some(response) = result.response {
write_response(stdout.clone(), &response).await;
}
if result.shutdown {
break;
}
}
Ok(())
}
async fn write_response(stdout: Arc<tokio::sync::Mutex<Stdout>>, response: &DuckDbWorkerResponse) {
let Ok(line) = serde_json::to_string(response) else {
return;
};
let mut stdout = stdout.lock().await;
let _ = stdout.write_all(line.as_bytes()).await;
let _ = stdout.write_all(b"\n").await;
let _ = stdout.flush().await;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn worker_session_connects_to_memory_duckdb() {
let mut session = DuckDbWorkerSession::default();
session
.connect(DuckDbWorkerConnectParams {
path: ":memory:".to_string(),
attached_databases: Vec::new(),
init_script: None,
})
.expect("connect");
assert_eq!(session.list_databases().expect("list databases")[0].name, "main");
}
#[test]
fn worker_session_executes_select_query() {
let mut session = DuckDbWorkerSession::default();
session
.connect(DuckDbWorkerConnectParams {
path: ":memory:".to_string(),
attached_databases: Vec::new(),
init_script: None,
})
.expect("connect");
let result = session
.execute(DuckDbWorkerExecuteParams {
sql: "SELECT 1 AS value".to_string(),
database: None,
max_rows: None,
preserve_insertion_order: false,
})
.expect("execute");
assert_eq!(result.columns, vec!["value"]);
assert_eq!(result.rows, vec![vec![serde_json::json!(1)]]);
}
#[test]
fn worker_session_scopes_insertion_order_preservation() {
let mut session = DuckDbWorkerSession::default();
session
.connect(DuckDbWorkerConnectParams {
path: ":memory:".to_string(),
attached_databases: Vec::new(),
init_script: Some("SET preserve_insertion_order = false".to_string()),
})
.expect("connect");
let disabled = session
.execute(DuckDbWorkerExecuteParams {
sql: "SELECT current_setting('preserve_insertion_order') AS setting".to_string(),
database: None,
max_rows: None,
preserve_insertion_order: false,
})
.expect("read initial setting");
assert_eq!(disabled.rows, vec![vec![serde_json::json!(false)]]);
let preserved = session
.execute(DuckDbWorkerExecuteParams {
sql: "SELECT current_setting('preserve_insertion_order') AS setting".to_string(),
database: None,
max_rows: None,
preserve_insertion_order: true,
})
.expect("execute with order preservation");
assert_eq!(preserved.rows, vec![vec![serde_json::json!(true)]]);
session
.execute(DuckDbWorkerExecuteParams {
sql: "SELECT * FROM missing_table".to_string(),
database: None,
max_rows: None,
preserve_insertion_order: true,
})
.expect_err("missing table should fail");
let restored = session
.execute(DuckDbWorkerExecuteParams {
sql: "SELECT current_setting('preserve_insertion_order') AS setting".to_string(),
database: None,
max_rows: None,
preserve_insertion_order: false,
})
.expect("read restored setting");
assert_eq!(restored.rows, vec![vec![serde_json::json!(false)]]);
}
#[test]
fn worker_session_lists_tables_and_columns() {
let mut session = DuckDbWorkerSession::default();
session
.connect(DuckDbWorkerConnectParams {
path: ":memory:".to_string(),
attached_databases: Vec::new(),
init_script: None,
})
.expect("connect");
session
.execute(DuckDbWorkerExecuteParams {
sql: "CREATE TABLE users (id INTEGER PRIMARY KEY, name VARCHAR); \
CREATE SCHEMA analytics; \
CREATE TABLE analytics.items (id INTEGER)"
.to_string(),
database: None,
max_rows: None,
preserve_insertion_order: false,
})
.expect("create table");
let schemas =
session.list_schemas(DuckDbWorkerDatabaseParams { database: "main".to_string() }).expect("list schemas");
let tables = session
.list_tables(DuckDbWorkerTableParams { database: "main".to_string(), schema: "main".to_string() })
.expect("list tables");
let columns = session
.list_columns(DuckDbWorkerColumnParams {
database: "main".to_string(),
schema: "main".to_string(),
table: "users".to_string(),
})
.expect("list columns");
let analytics_columns = session
.list_columns(DuckDbWorkerColumnParams {
database: "main".to_string(),
schema: "analytics".to_string(),
table: "items".to_string(),
})
.expect("list analytics columns");
assert!(schemas.iter().any(|schema| schema == "main"));
assert!(tables.iter().any(|table| table.name == "users"));
assert!(columns.iter().any(|column| column.name == "id" && column.is_primary_key));
assert_eq!(analytics_columns.iter().map(|column| column.name.as_str()).collect::<Vec<_>>(), vec!["id"]);
}
#[test]
fn worker_session_reads_view_source() {
let mut session = DuckDbWorkerSession::default();
session
.connect(DuckDbWorkerConnectParams {
path: ":memory:".to_string(),
attached_databases: Vec::new(),
init_script: None,
})
.expect("connect");
session
.execute(DuckDbWorkerExecuteParams {
sql: "CREATE VIEW active_orders AS SELECT 1 AS id".to_string(),
database: None,
max_rows: None,
preserve_insertion_order: false,
})
.expect("create view");
let source = session
.get_object_source(DuckDbWorkerObjectSourceParams {
database: "main".to_string(),
schema: "main".to_string(),
name: "active_orders".to_string(),
object_type: db::ObjectSourceKind::View,
})
.expect("get view source");
assert!(source.starts_with("CREATE VIEW"));
assert!(source.contains("active_orders"));
}
#[test]
fn worker_session_attaches_database() {
let dir = std::env::temp_dir().join(format!("dbx-duckdb-worker-{}", uuid::Uuid::new_v4()));
std::fs::create_dir_all(&dir).expect("create temp dir");
let attached_path = dir.join("analytics.duckdb");
{
let con = duckdb::Connection::open(&attached_path).expect("create attached db");
con.execute_batch("CREATE TABLE events (id INTEGER);").expect("create attached table");
}
let mut session = DuckDbWorkerSession::default();
session
.connect(DuckDbWorkerConnectParams {
path: ":memory:".to_string(),
attached_databases: Vec::new(),
init_script: None,
})
.expect("connect");
session
.attach_database(AttachedDatabaseConfig {
name: "analytics".to_string(),
path: attached_path.to_string_lossy().to_string(),
})
.expect("attach");
let databases = session.list_databases().expect("list databases");
let tables = session
.list_tables(DuckDbWorkerTableParams { database: "analytics".to_string(), schema: "main".to_string() })
.expect("list tables");
assert!(databases.iter().any(|database| database.name == "analytics"));
assert!(tables.iter().any(|table| table.name == "events"));
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn worker_session_runs_init_script_and_tracks_attached_alias() {
let dir = std::env::temp_dir().join(format!("dbx-duckdb-worker-{}", uuid::Uuid::new_v4()));
std::fs::create_dir_all(&dir).expect("create temp dir");
let attached_path = dir.join("warehouse.duckdb");
{
let con = duckdb::Connection::open(&attached_path).expect("create attached db");
con.execute_batch("CREATE TABLE facts (id INTEGER);").expect("create attached table");
}
let mut session = DuckDbWorkerSession::default();
let script = format!(
"SET memory_limit='512MB'; -- session tuning\nATTACH '{}' AS warehouse;\nCREATE TABLE staging (id INTEGER);",
attached_path.to_string_lossy().replace('\'', "''")
);
session
.connect(DuckDbWorkerConnectParams {
path: ":memory:".to_string(),
attached_databases: Vec::new(),
init_script: Some(script),
})
.expect("connect");
assert!(session.attached_names.iter().any(|name| name == "warehouse"));
let databases = session.list_databases().expect("list databases");
assert!(databases.iter().any(|database| database.name == "warehouse"));
let tables = session
.list_tables(DuckDbWorkerTableParams { database: "warehouse".to_string(), schema: "main".to_string() })
.expect("list tables");
assert!(tables.iter().any(|table| table.name == "facts"));
let columns = session
.list_columns(DuckDbWorkerColumnParams {
database: "main".to_string(),
schema: "warehouse".to_string(),
table: "facts".to_string(),
})
.expect("list init-script attached columns");
assert_eq!(columns.iter().map(|column| column.name.as_str()).collect::<Vec<_>>(), ["id"]);
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn worker_session_tracks_init_script_attach_without_alias() {
let dir = std::env::temp_dir().join(format!("dbx-duckdb-worker-{}", uuid::Uuid::new_v4()));
std::fs::create_dir_all(&dir).expect("create temp dir");
let attached_path = dir.join("noalias.duckdb");
{
let con = duckdb::Connection::open(&attached_path).expect("create attached db");
con.execute_batch("CREATE TABLE items (id INTEGER);").expect("create attached table");
}
let mut session = DuckDbWorkerSession::default();
session
.connect(DuckDbWorkerConnectParams {
path: ":memory:".to_string(),
attached_databases: Vec::new(),
init_script: Some(format!("ATTACH '{}';", attached_path.to_string_lossy().replace('\'', "''"))),
})
.expect("connect");
assert!(session.attached_names.iter().any(|name| name == "noalias"), "names: {:?}", session.attached_names);
let tables = session
.list_tables(DuckDbWorkerTableParams { database: "noalias".to_string(), schema: "main".to_string() })
.expect("list tables");
assert!(tables.iter().any(|table| table.name == "items"));
let _ = std::fs::remove_dir_all(dir);
}
#[test]
fn worker_session_reports_failing_init_script_statement() {
let mut session = DuckDbWorkerSession::default();
let err = session
.connect(DuckDbWorkerConnectParams {
path: ":memory:".to_string(),
attached_databases: Vec::new(),
init_script: Some("SELECT 1; SELECT * FROM missing_table;".to_string()),
})
.expect_err("init script should fail");
assert!(err.contains("statement 2"), "unexpected error: {err}");
}
#[test]
fn worker_session_tracks_attach_sql_alias() {
let dir = std::env::temp_dir().join(format!("dbx-duckdb-worker-{}", uuid::Uuid::new_v4()));
std::fs::create_dir_all(&dir).expect("create temp dir");
let attached_path = dir.join("sales.duckdb");
{
let con = duckdb::Connection::open(&attached_path).expect("create attached db");
con.execute_batch("CREATE TABLE orders (id INTEGER);").expect("create attached table");
}
let mut session = DuckDbWorkerSession::default();
session
.connect(DuckDbWorkerConnectParams {
path: ":memory:".to_string(),
attached_databases: Vec::new(),
init_script: None,
})
.expect("connect");
session
.execute(DuckDbWorkerExecuteParams {
sql: format!("ATTACH '{}' AS \"sales db\";", attached_path.to_string_lossy().replace('\'', "''")),
database: None,
max_rows: None,
preserve_insertion_order: false,
})
.expect("attach sql");
assert!(session.attached_names.iter().any(|name| name == "sales db"));
let tables = session
.list_tables(DuckDbWorkerTableParams { database: "sales db".to_string(), schema: "main".to_string() })
.expect("list tables");
assert!(tables.iter().any(|table| table.name == "orders"));
let columns = session
.list_columns(DuckDbWorkerColumnParams {
database: "main".to_string(),
schema: "SALES DB".to_string(),
table: "orders".to_string(),
})
.expect("list SQL-attached columns");
assert_eq!(columns.iter().map(|column| column.name.as_str()).collect::<Vec<_>>(), ["id"]);
let _ = std::fs::remove_dir_all(dir);
}
#[tokio::test]
async fn metadata_returns_busy_while_query_is_active() {
let runtime = DuckDbWorkerRuntime::default();
let stdout = Arc::new(tokio::sync::Mutex::new(tokio::io::stdout()));
*runtime.active_interrupt.lock().unwrap_or_else(|e| e.into_inner()) =
Some(duckdb::Connection::open_in_memory().expect("connection").interrupt_handle());
let result = runtime
.handle_request(
DuckDbWorkerRequest::new("req-busy", DuckDbWorkerMethod::ListDatabases, serde_json::json!({}))
.expect("request"),
stdout,
)
.await;
let response = result.response.expect("response");
assert!(!response.ok);
assert_eq!(response.error.expect("error").code, "duckdb_worker_busy");
}
}