913 lines
37 KiB
Rust
913 lines
37 KiB
Rust
use std::collections::HashMap;
|
|
|
|
use crate::wire as db;
|
|
|
|
#[cfg(test)]
|
|
pub fn duckdb_query_tables_in_database(
|
|
con: &duckdb::Connection,
|
|
database: &str,
|
|
schema: &str,
|
|
) -> Result<Vec<db::TableInfo>, String> {
|
|
duckdb_query_tables_in_database_with_attached(con, database, schema, &[])
|
|
}
|
|
|
|
pub fn duckdb_query_tables_in_database_with_attached(
|
|
con: &duckdb::Connection,
|
|
database: &str,
|
|
schema: &str,
|
|
attached_names: &[String],
|
|
) -> Result<Vec<db::TableInfo>, String> {
|
|
let database = duckdb_catalog_name(con, database, attached_names)?;
|
|
let mut stmt = con.prepare(
|
|
"SELECT table_name, table_type FROM information_schema.tables WHERE table_catalog = ? AND table_schema = ? ORDER BY table_name"
|
|
).map_err(|e| e.to_string())?;
|
|
let rows = stmt
|
|
.query_map((database.as_str(), schema), |row| {
|
|
Ok(db::TableInfo {
|
|
name: row.get::<_, String>(0)?,
|
|
table_type: row.get::<_, String>(1)?,
|
|
comment: None,
|
|
parent_schema: None,
|
|
parent_name: None,
|
|
})
|
|
})
|
|
.map_err(|e| e.to_string())?;
|
|
let tables: Vec<db::TableInfo> = rows.filter_map(|r| r.ok()).collect();
|
|
if tables.is_empty() && duckdb_is_quack_catalog(con, &database) {
|
|
if let Some(remote) = duckdb_quack_remote_tables(con, &database, schema) {
|
|
return Ok(remote);
|
|
}
|
|
}
|
|
Ok(tables)
|
|
}
|
|
|
|
pub fn duckdb_attach_database(con: &duckdb::Connection, name: &str, path: &str) -> Result<(), String> {
|
|
let name = name.trim();
|
|
let path = path.trim();
|
|
if name.is_empty() || path.is_empty() {
|
|
return Err("DuckDB attached database name and path are required".to_string());
|
|
}
|
|
let sql = format!("ATTACH {} AS {}", duckdb_quote_string(path), duckdb_quote_ident(name));
|
|
con.execute_batch(&sql).map_err(|e| format!("Failed to attach database \"{name}\": {e}"))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub fn duckdb_list_databases(con: &duckdb::Connection) -> Result<Vec<db::DatabaseInfo>, String> {
|
|
duckdb_list_databases_with_attached(con, &[])
|
|
}
|
|
|
|
pub fn duckdb_list_databases_with_attached(
|
|
con: &duckdb::Connection,
|
|
attached_names: &[String],
|
|
) -> Result<Vec<db::DatabaseInfo>, String> {
|
|
let primary = duckdb_primary_catalog(con, attached_names)?;
|
|
let mut stmt = con.prepare("SHOW DATABASES").map_err(|e| e.to_string())?;
|
|
let rows = stmt
|
|
.query_map([], |row| {
|
|
let name = row.get::<_, String>(0)?;
|
|
Ok(db::DatabaseInfo { name: if name == primary { "main".to_string() } else { name } })
|
|
})
|
|
.map_err(|e| e.to_string())?;
|
|
Ok(rows.filter_map(|row| row.ok()).collect())
|
|
}
|
|
|
|
pub fn duckdb_list_schemas_with_attached(
|
|
con: &duckdb::Connection,
|
|
database: &str,
|
|
attached_names: &[String],
|
|
) -> Result<Vec<String>, String> {
|
|
let database = duckdb_catalog_name(con, database, attached_names)?;
|
|
let mut stmt = con
|
|
.prepare(
|
|
"SELECT schema_name FROM information_schema.schemata WHERE catalog_name = ? AND schema_name NOT IN ('information_schema', 'pg_catalog') ORDER BY schema_name",
|
|
)
|
|
.map_err(|e| e.to_string())?;
|
|
let rows = stmt.query_map([database.as_str()], |row| row.get::<_, String>(0)).map_err(|e| e.to_string())?;
|
|
let schemas: Vec<String> = rows.filter_map(|r| r.ok()).collect();
|
|
if schemas.is_empty() && duckdb_is_quack_catalog(con, &database) {
|
|
if let Some(remote) = duckdb_quack_remote_schemas(con, &database) {
|
|
return Ok(remote);
|
|
}
|
|
}
|
|
Ok(schemas)
|
|
}
|
|
|
|
pub fn duckdb_object_source_with_attached(
|
|
con: &duckdb::Connection,
|
|
database: &str,
|
|
schema: &str,
|
|
name: &str,
|
|
object_type: &db::ObjectSourceKind,
|
|
attached_names: &[String],
|
|
) -> Result<String, String> {
|
|
if !matches!(object_type, db::ObjectSourceKind::View) {
|
|
return Err("DuckDB object source only supports views".to_string());
|
|
}
|
|
|
|
let database = duckdb_catalog_name(con, database, attached_names)?;
|
|
let mut stmt = con
|
|
.prepare("SELECT sql FROM duckdb_views() WHERE database_name = ? AND schema_name = ? AND view_name = ?")
|
|
.map_err(|e| e.to_string())?;
|
|
let mut rows =
|
|
stmt.query_map((database.as_str(), schema, name), |row| row.get::<_, String>(0)).map_err(|e| e.to_string())?;
|
|
|
|
match rows.next() {
|
|
Some(row) => row.map_err(|e| e.to_string()),
|
|
None => Err(format!("DuckDB view source not found: {database}.{schema}.{name}")),
|
|
}
|
|
}
|
|
|
|
pub fn duckdb_table_ddl_with_attached(
|
|
con: &duckdb::Connection,
|
|
database: &str,
|
|
schema: &str,
|
|
table: &str,
|
|
attached_names: &[String],
|
|
) -> Result<String, String> {
|
|
let database = duckdb_catalog_name(con, database, attached_names)?;
|
|
let mut stmt = con
|
|
.prepare("SELECT sql FROM duckdb_tables() WHERE database_name = ? AND schema_name = ? AND table_name = ?")
|
|
.map_err(|e| e.to_string())?;
|
|
let mut rows =
|
|
stmt.query_map((database.as_str(), schema, table), |row| row.get::<_, String>(0)).map_err(|e| e.to_string())?;
|
|
|
|
match rows.next() {
|
|
Some(row) => row.map_err(|e| e.to_string()),
|
|
None => Err(format!("DuckDB table not found: {database}.{schema}.{table}")),
|
|
}
|
|
}
|
|
|
|
/// Identifies quack catalogs by the storage-extension `type` that
|
|
/// `duckdb_databases()` reports, rather than by the attach aliases parsed from
|
|
/// the init script: `ATTACH 'quack:host:port'` without an `AS` alias gets a
|
|
/// derived catalog name (e.g. `localhost:9494`) that no parser sees.
|
|
fn duckdb_is_quack_catalog(con: &duckdb::Connection, database: &str) -> bool {
|
|
con.query_row("SELECT type FROM duckdb_databases() WHERE lower(database_name) = lower(?)", [database], |row| {
|
|
row.get::<_, String>(0)
|
|
})
|
|
.map(|catalog_type| catalog_type.eq_ignore_ascii_case("quack"))
|
|
.unwrap_or(false)
|
|
}
|
|
|
|
/// Quack-attached catalogs expose no metadata on the client side (the beta
|
|
/// extension implements name resolution and streaming scans, but not catalog
|
|
/// enumeration: `information_schema`, `duckdb_tables()` and `SHOW ALL TABLES`
|
|
/// all skip the remote catalog). The extension's `quack_query_by_name` table
|
|
/// function runs SQL on the remote server, so when a metadata query for an
|
|
/// attached catalog comes back empty we ask the remote for its own
|
|
/// information_schema. For non-quack catalogs (or when the extension is not
|
|
/// loaded) the function call errors and the fallback quietly yields `None`.
|
|
fn duckdb_quack_remote_query<T>(
|
|
con: &duckdb::Connection,
|
|
alias: &str,
|
|
remote_sql: &str,
|
|
map_row: impl Fn(&duckdb::Row<'_>) -> Result<T, duckdb::Error>,
|
|
) -> Option<Vec<T>> {
|
|
let sql = format!(
|
|
"SELECT * FROM quack_query_by_name({}, {})",
|
|
duckdb_quote_string(alias),
|
|
duckdb_quote_string(remote_sql)
|
|
);
|
|
let mut stmt = match con.prepare(&sql) {
|
|
Ok(stmt) => stmt,
|
|
Err(e) => {
|
|
log::debug!("quack metadata fallback unavailable for catalog {alias}: {e}");
|
|
return None;
|
|
}
|
|
};
|
|
let rows = match stmt.query_map([], |row| map_row(row)) {
|
|
Ok(rows) => rows,
|
|
Err(e) => {
|
|
log::debug!("quack metadata fallback query failed for catalog {alias}: {e}");
|
|
return None;
|
|
}
|
|
};
|
|
Some(rows.filter_map(|r| r.ok()).collect())
|
|
}
|
|
|
|
fn duckdb_quack_remote_schemas(con: &duckdb::Connection, alias: &str) -> Option<Vec<String>> {
|
|
duckdb_quack_remote_query(
|
|
con,
|
|
alias,
|
|
"SELECT DISTINCT schema_name FROM information_schema.schemata WHERE schema_name NOT IN ('information_schema', 'pg_catalog') ORDER BY schema_name",
|
|
|row| row.get::<_, String>(0),
|
|
)
|
|
}
|
|
|
|
fn duckdb_quack_remote_tables(con: &duckdb::Connection, alias: &str, schema: &str) -> Option<Vec<db::TableInfo>> {
|
|
let remote_sql = format!(
|
|
"SELECT table_name, table_type FROM information_schema.tables WHERE table_schema = {} ORDER BY table_name",
|
|
duckdb_quote_string(schema)
|
|
);
|
|
duckdb_quack_remote_query(con, alias, &remote_sql, |row| {
|
|
Ok(db::TableInfo {
|
|
name: row.get::<_, String>(0)?,
|
|
table_type: row.get::<_, String>(1)?,
|
|
comment: None,
|
|
parent_schema: None,
|
|
parent_name: None,
|
|
})
|
|
})
|
|
}
|
|
|
|
fn duckdb_quack_remote_columns(
|
|
con: &duckdb::Connection,
|
|
alias: &str,
|
|
schema: &str,
|
|
table: &str,
|
|
) -> Option<Vec<db::ColumnInfo>> {
|
|
let pk_sql = format!(
|
|
"SELECT kcu.column_name
|
|
FROM information_schema.table_constraints tc
|
|
JOIN information_schema.key_column_usage kcu
|
|
ON tc.constraint_name = kcu.constraint_name
|
|
AND tc.table_schema = kcu.table_schema
|
|
AND tc.table_name = kcu.table_name
|
|
WHERE tc.constraint_type = 'PRIMARY KEY'
|
|
AND tc.table_schema = {schema}
|
|
AND tc.table_name = {table}
|
|
ORDER BY kcu.ordinal_position",
|
|
schema = duckdb_quote_string(schema),
|
|
table = duckdb_quote_string(table),
|
|
);
|
|
let primary_keys: std::collections::HashSet<String> =
|
|
duckdb_quack_remote_query(con, alias, &pk_sql, |row| row.get::<_, String>(0))
|
|
.map(|names| names.into_iter().collect())
|
|
.unwrap_or_default();
|
|
|
|
let columns_sql = format!(
|
|
"SELECT column_name, data_type, is_nullable, column_default
|
|
FROM information_schema.columns
|
|
WHERE table_schema = {schema} AND table_name = {table}
|
|
ORDER BY ordinal_position",
|
|
schema = duckdb_quote_string(schema),
|
|
table = duckdb_quote_string(table),
|
|
);
|
|
duckdb_quack_remote_query(con, alias, &columns_sql, |row| {
|
|
let name = row.get::<_, String>(0)?;
|
|
Ok(db::ColumnInfo {
|
|
is_primary_key: primary_keys.contains(&name),
|
|
name,
|
|
data_type: row.get::<_, String>(1)?,
|
|
is_nullable: row.get::<_, String>(2).unwrap_or_default() == "YES",
|
|
column_default: row.get::<_, Option<String>>(3)?,
|
|
extra: None,
|
|
comment: None,
|
|
numeric_precision: None,
|
|
numeric_scale: None,
|
|
character_maximum_length: None,
|
|
enum_values: None,
|
|
..Default::default()
|
|
})
|
|
})
|
|
}
|
|
|
|
fn duckdb_catalog_name(con: &duckdb::Connection, database: &str, attached_names: &[String]) -> Result<String, String> {
|
|
if database.trim().is_empty() || database == "main" {
|
|
return duckdb_primary_catalog(con, attached_names);
|
|
}
|
|
Ok(database.to_string())
|
|
}
|
|
|
|
pub fn duckdb_primary_catalog(con: &duckdb::Connection, attached_names: &[String]) -> Result<String, String> {
|
|
if attached_names.is_empty() {
|
|
return duckdb_current_database(con);
|
|
}
|
|
let attached: std::collections::HashSet<String> = attached_names.iter().map(|name| name.to_lowercase()).collect();
|
|
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())?;
|
|
for row in rows {
|
|
let name = row.map_err(|e| e.to_string())?;
|
|
if !attached.contains(&name.to_lowercase()) {
|
|
return Ok(name);
|
|
}
|
|
}
|
|
duckdb_current_database(con)
|
|
}
|
|
|
|
fn duckdb_current_database(con: &duckdb::Connection) -> Result<String, String> {
|
|
con.query_row("SELECT current_database()", [], |row| row.get::<_, String>(0)).map_err(|e| e.to_string())
|
|
}
|
|
|
|
fn duckdb_quote_ident(value: &str) -> String {
|
|
format!("\"{}\"", value.replace('"', "\"\""))
|
|
}
|
|
|
|
fn duckdb_quote_string(value: &str) -> String {
|
|
format!("'{}'", value.replace('\'', "''"))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub fn duckdb_query_columns(con: &duckdb::Connection, table: &str) -> Result<Vec<db::ColumnInfo>, String> {
|
|
duckdb_query_columns_in_database(con, "main", "main", table)
|
|
}
|
|
|
|
#[cfg(test)]
|
|
pub fn duckdb_query_columns_in_database(
|
|
con: &duckdb::Connection,
|
|
database: &str,
|
|
schema: &str,
|
|
table: &str,
|
|
) -> Result<Vec<db::ColumnInfo>, String> {
|
|
duckdb_query_columns_in_database_with_attached(con, database, schema, table, &[])
|
|
}
|
|
|
|
pub fn duckdb_query_columns_in_database_with_attached(
|
|
con: &duckdb::Connection,
|
|
database: &str,
|
|
schema: &str,
|
|
table: &str,
|
|
attached_names: &[String],
|
|
) -> Result<Vec<db::ColumnInfo>, String> {
|
|
let use_primary_catalog = database.trim().is_empty() || database == "main";
|
|
let database = duckdb_catalog_name(con, database, attached_names)?;
|
|
let columns = duckdb_query_columns_in_catalog(con, &database, schema, table)?;
|
|
if columns.is_empty() && use_primary_catalog {
|
|
if let Some(attached) = attached_names.iter().find(|name| name.eq_ignore_ascii_case(schema)) {
|
|
return duckdb_query_columns_in_catalog(con, attached, "main", table);
|
|
}
|
|
}
|
|
Ok(columns)
|
|
}
|
|
|
|
fn duckdb_query_columns_in_catalog(
|
|
con: &duckdb::Connection,
|
|
database: &str,
|
|
schema: &str,
|
|
table: &str,
|
|
) -> Result<Vec<db::ColumnInfo>, String> {
|
|
let mut pk_stmt = con
|
|
.prepare(
|
|
"SELECT kcu.column_name
|
|
FROM information_schema.table_constraints tc
|
|
JOIN information_schema.key_column_usage kcu
|
|
ON tc.constraint_name = kcu.constraint_name
|
|
AND tc.table_schema = kcu.table_schema
|
|
AND tc.table_name = kcu.table_name
|
|
WHERE tc.constraint_type = 'PRIMARY KEY'
|
|
AND tc.table_catalog = ?
|
|
AND tc.table_schema = ?
|
|
AND tc.table_name = ?
|
|
ORDER BY kcu.ordinal_position",
|
|
)
|
|
.map_err(|e| e.to_string())?;
|
|
let pk_rows =
|
|
pk_stmt.query_map((database, schema, table), |row| row.get::<_, String>(0)).map_err(|e| e.to_string())?;
|
|
let primary_keys: std::collections::HashSet<String> = pk_rows.filter_map(|r| r.ok()).collect();
|
|
let column_comments = duckdb_column_comments(con, database, schema, table);
|
|
|
|
let mut stmt = con
|
|
.prepare(
|
|
"SELECT column_name, data_type, is_nullable, column_default
|
|
FROM information_schema.columns
|
|
WHERE table_catalog = ? AND table_schema = ? AND table_name = ?
|
|
ORDER BY ordinal_position",
|
|
)
|
|
.map_err(|e| e.to_string())?;
|
|
let rows = stmt
|
|
.query_map((database, schema, table), |row| {
|
|
let name = row.get::<_, String>(0)?;
|
|
let comment = column_comments.get(&name).cloned().flatten();
|
|
Ok(db::ColumnInfo {
|
|
is_primary_key: primary_keys.contains(&name),
|
|
name,
|
|
data_type: row.get::<_, String>(1)?,
|
|
is_nullable: row.get::<_, String>(2).unwrap_or_default() == "YES",
|
|
column_default: row.get::<_, Option<String>>(3)?,
|
|
extra: None,
|
|
comment,
|
|
numeric_precision: None,
|
|
numeric_scale: None,
|
|
character_maximum_length: None,
|
|
enum_values: None,
|
|
..Default::default()
|
|
})
|
|
})
|
|
.map_err(|e| e.to_string())?;
|
|
let columns: Vec<db::ColumnInfo> = rows.filter_map(|r| r.ok()).collect();
|
|
if columns.is_empty() && duckdb_is_quack_catalog(con, database) {
|
|
if let Some(remote) = duckdb_quack_remote_columns(con, database, schema, table) {
|
|
return Ok(remote);
|
|
}
|
|
}
|
|
Ok(columns)
|
|
}
|
|
|
|
fn duckdb_column_comments(
|
|
con: &duckdb::Connection,
|
|
database: &str,
|
|
schema: &str,
|
|
table: &str,
|
|
) -> HashMap<String, Option<String>> {
|
|
let Ok(mut stmt) = con.prepare(
|
|
"SELECT column_name, comment FROM duckdb_columns() \
|
|
WHERE database_name = ? AND schema_name = ? AND table_name = ?",
|
|
) else {
|
|
// Older DuckDB versions may not expose the comment column; keep metadata browsing functional.
|
|
return HashMap::new();
|
|
};
|
|
let Ok(rows) = stmt
|
|
.query_map((database, schema, table), |row| Ok((row.get::<_, String>(0)?, row.get::<_, Option<String>>(1)?)))
|
|
else {
|
|
return HashMap::new();
|
|
};
|
|
rows.filter_map(Result::ok).collect()
|
|
}
|
|
|
|
pub fn duckdb_completion_assistant_search(
|
|
con: &duckdb::Connection,
|
|
request: &db::CompletionAssistantRequest,
|
|
attached_names: &[String],
|
|
) -> Result<db::CompletionAssistantResponse, String> {
|
|
let limit = request.max_results.unwrap_or(100).clamp(1, 1000);
|
|
let kinds = if request.object_kinds.is_empty() {
|
|
vec![db::CompletionAssistantObjectKind::Table, db::CompletionAssistantObjectKind::View]
|
|
} else {
|
|
request.object_kinds.clone()
|
|
};
|
|
let mut candidates = Vec::new();
|
|
|
|
if kinds.iter().any(|kind| matches!(kind, db::CompletionAssistantObjectKind::Schema)) {
|
|
candidates.extend(duckdb_completion_schemas(con, request, attached_names, limit)?);
|
|
if candidates.len() >= limit {
|
|
return Ok(db::CompletionAssistantResponse { candidates, incomplete: true, fallback_used: false });
|
|
}
|
|
}
|
|
|
|
if kinds.iter().any(db::CompletionAssistantObjectKind::is_table_like) {
|
|
candidates.extend(duckdb_completion_tables(con, request, &kinds, attached_names, limit - candidates.len())?);
|
|
if candidates.len() >= limit {
|
|
return Ok(db::CompletionAssistantResponse { candidates, incomplete: true, fallback_used: false });
|
|
}
|
|
}
|
|
|
|
if kinds.iter().any(|kind| matches!(kind, db::CompletionAssistantObjectKind::Column)) {
|
|
candidates.extend(duckdb_completion_columns(con, request, attached_names, limit - candidates.len())?);
|
|
if candidates.len() >= limit {
|
|
return Ok(db::CompletionAssistantResponse { candidates, incomplete: true, fallback_used: false });
|
|
}
|
|
}
|
|
|
|
Ok(db::CompletionAssistantResponse { candidates, incomplete: false, fallback_used: false })
|
|
}
|
|
|
|
fn duckdb_completion_schemas(
|
|
con: &duckdb::Connection,
|
|
request: &db::CompletionAssistantRequest,
|
|
attached_names: &[String],
|
|
limit: usize,
|
|
) -> Result<Vec<db::CompletionAssistantCandidate>, String> {
|
|
if limit == 0 {
|
|
return Ok(Vec::new());
|
|
}
|
|
let database = duckdb_catalog_name(con, &request.database, attached_names)?;
|
|
let pattern = duckdb_completion_like_pattern(request);
|
|
let mut stmt = con
|
|
.prepare(
|
|
"SELECT schema_name
|
|
FROM information_schema.schemata
|
|
WHERE catalog_name = ?
|
|
AND schema_name NOT IN ('information_schema', 'pg_catalog')
|
|
AND lower(schema_name) LIKE lower(?) ESCAPE '\\'
|
|
ORDER BY schema_name
|
|
LIMIT ?",
|
|
)
|
|
.map_err(|e| e.to_string())?;
|
|
let rows = stmt
|
|
.query_map((database.as_str(), pattern.as_str(), limit as i64), |row| {
|
|
let schema = row.get::<_, String>(0)?;
|
|
Ok(db::CompletionAssistantCandidate {
|
|
name: schema.clone(),
|
|
kind: db::CompletionAssistantCandidateKind::Schema,
|
|
database: Some(request.database.clone()),
|
|
schema: Some(schema),
|
|
parent_schema: None,
|
|
parent_name: None,
|
|
comment: None,
|
|
data_type: None,
|
|
signature: None,
|
|
})
|
|
})
|
|
.map_err(|e| e.to_string())?;
|
|
Ok(rows.filter_map(|row| row.ok()).collect())
|
|
}
|
|
|
|
fn duckdb_completion_tables(
|
|
con: &duckdb::Connection,
|
|
request: &db::CompletionAssistantRequest,
|
|
kinds: &[db::CompletionAssistantObjectKind],
|
|
attached_names: &[String],
|
|
limit: usize,
|
|
) -> Result<Vec<db::CompletionAssistantCandidate>, String> {
|
|
if limit == 0 {
|
|
return Ok(Vec::new());
|
|
}
|
|
let database = duckdb_catalog_name(con, &request.database, attached_names)?;
|
|
let schema = request.parent_schema.as_deref().or(request.schema.as_deref()).unwrap_or("main");
|
|
let include_tables = kinds.iter().any(|kind| matches!(kind, db::CompletionAssistantObjectKind::Table));
|
|
let include_views = kinds.iter().any(|kind| matches!(kind, db::CompletionAssistantObjectKind::View));
|
|
let pattern = duckdb_completion_like_pattern(request);
|
|
let mut stmt = con
|
|
.prepare(
|
|
"SELECT table_name, table_type
|
|
FROM information_schema.tables
|
|
WHERE table_catalog = ?
|
|
AND table_schema = ?
|
|
AND ((? AND table_type = 'BASE TABLE') OR (? AND table_type = 'VIEW'))
|
|
AND lower(table_name) LIKE lower(?) ESCAPE '\\'
|
|
ORDER BY table_name
|
|
LIMIT ?",
|
|
)
|
|
.map_err(|e| e.to_string())?;
|
|
let rows = stmt
|
|
.query_map((database.as_str(), schema, include_tables, include_views, pattern.as_str(), limit as i64), |row| {
|
|
let table_type = row.get::<_, String>(1)?;
|
|
Ok(db::CompletionAssistantCandidate {
|
|
name: row.get(0)?,
|
|
kind: if table_type.eq_ignore_ascii_case("VIEW") {
|
|
db::CompletionAssistantCandidateKind::View
|
|
} else {
|
|
db::CompletionAssistantCandidateKind::Table
|
|
},
|
|
database: Some(request.database.clone()),
|
|
schema: Some(schema.to_string()),
|
|
parent_schema: None,
|
|
parent_name: None,
|
|
comment: None,
|
|
data_type: None,
|
|
signature: None,
|
|
})
|
|
})
|
|
.map_err(|e| e.to_string())?;
|
|
Ok(rows.filter_map(|row| row.ok()).collect())
|
|
}
|
|
|
|
fn duckdb_completion_columns(
|
|
con: &duckdb::Connection,
|
|
request: &db::CompletionAssistantRequest,
|
|
attached_names: &[String],
|
|
limit: usize,
|
|
) -> Result<Vec<db::CompletionAssistantCandidate>, String> {
|
|
if limit == 0 {
|
|
return Ok(Vec::new());
|
|
}
|
|
let Some(table) = request.parent_name.as_deref().filter(|table| !table.trim().is_empty()) else {
|
|
return Ok(Vec::new());
|
|
};
|
|
let database = duckdb_catalog_name(con, &request.database, attached_names)?;
|
|
let schema = request.parent_schema.as_deref().or(request.schema.as_deref()).unwrap_or("main");
|
|
let pattern = duckdb_completion_like_pattern(request);
|
|
let mut stmt = con
|
|
.prepare(
|
|
"SELECT column_name, data_type
|
|
FROM information_schema.columns
|
|
WHERE table_catalog = ?
|
|
AND table_schema = ?
|
|
AND table_name = ?
|
|
AND lower(column_name) LIKE lower(?) ESCAPE '\\'
|
|
ORDER BY ordinal_position
|
|
LIMIT ?",
|
|
)
|
|
.map_err(|e| e.to_string())?;
|
|
let rows = stmt
|
|
.query_map((database.as_str(), schema, table, pattern.as_str(), limit as i64), |row| {
|
|
Ok(db::CompletionAssistantCandidate {
|
|
name: row.get(0)?,
|
|
kind: db::CompletionAssistantCandidateKind::Column,
|
|
database: Some(request.database.clone()),
|
|
schema: Some(schema.to_string()),
|
|
parent_schema: Some(schema.to_string()),
|
|
parent_name: Some(table.to_string()),
|
|
comment: None,
|
|
data_type: Some(row.get(1)?),
|
|
signature: None,
|
|
})
|
|
})
|
|
.map_err(|e| e.to_string())?;
|
|
Ok(rows.filter_map(|row| row.ok()).collect())
|
|
}
|
|
|
|
fn duckdb_completion_like_pattern(request: &db::CompletionAssistantRequest) -> String {
|
|
let mask = request.mask.trim().trim_matches('%');
|
|
let escaped = mask.replace('\\', "\\\\").replace('%', "\\%").replace('_', "\\_");
|
|
match request.match_mode.as_ref().unwrap_or(&db::CompletionAssistantMatchMode::Prefix) {
|
|
db::CompletionAssistantMatchMode::Prefix => format!("{escaped}%"),
|
|
db::CompletionAssistantMatchMode::Contains => format!("%{escaped}%"),
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use dbx_core::models::connection::DatabaseType;
|
|
#[test]
|
|
fn duckdb_list_databases_includes_attached_database() {
|
|
let unique = uuid::Uuid::new_v4();
|
|
let path = std::env::temp_dir().join(format!("dbx-attached-{unique}.duckdb"));
|
|
let _ = std::fs::remove_file(&path);
|
|
let con = duckdb::Connection::open_in_memory().unwrap();
|
|
|
|
duckdb_attach_database(&con, "analytics", path.to_str().unwrap()).unwrap();
|
|
let databases = duckdb_list_databases(&con).unwrap();
|
|
|
|
assert!(databases.iter().any(|database| database.name == "main"));
|
|
assert!(databases.iter().any(|database| database.name == "analytics"));
|
|
|
|
let _ = std::fs::remove_file(path);
|
|
}
|
|
|
|
#[test]
|
|
fn duckdb_query_tables_filters_by_attached_database() {
|
|
let unique = uuid::Uuid::new_v4();
|
|
let path = std::env::temp_dir().join(format!("dbx-attached-tables-{unique}.duckdb"));
|
|
let _ = std::fs::remove_file(&path);
|
|
let con = duckdb::Connection::open_in_memory().unwrap();
|
|
|
|
con.execute_batch("CREATE TABLE main_table(id INTEGER);").unwrap();
|
|
duckdb_attach_database(&con, "analytics", path.to_str().unwrap()).unwrap();
|
|
con.execute_batch("CREATE TABLE analytics.attached_table(id INTEGER);").unwrap();
|
|
|
|
let main_tables = duckdb_query_tables_in_database(&con, "main", "main").unwrap();
|
|
let attached_tables = duckdb_query_tables_in_database(&con, "analytics", "main").unwrap();
|
|
|
|
assert!(main_tables.iter().any(|table| table.name == "main_table"));
|
|
assert!(!main_tables.iter().any(|table| table.name == "attached_table"));
|
|
assert!(attached_tables.iter().any(|table| table.name == "attached_table"));
|
|
assert!(!attached_tables.iter().any(|table| table.name == "main_table"));
|
|
|
|
let _ = std::fs::remove_file(path);
|
|
}
|
|
|
|
#[test]
|
|
fn duckdb_query_columns_includes_column_comments() {
|
|
let con = duckdb::Connection::open_in_memory().unwrap();
|
|
con.execute_batch(
|
|
"CREATE TABLE users (id INTEGER, name VARCHAR); \
|
|
COMMENT ON COLUMN users.name IS 'Display name';",
|
|
)
|
|
.unwrap();
|
|
|
|
let columns = duckdb_query_columns(&con, "users").unwrap();
|
|
let name = columns.iter().find(|column| column.name == "name").unwrap();
|
|
|
|
assert_eq!(name.comment.as_deref(), Some("Display name"));
|
|
}
|
|
|
|
fn duckdb_attached_columns_fixture() -> (duckdb::Connection, Vec<String>) {
|
|
let con = duckdb::Connection::open_in_memory().unwrap();
|
|
duckdb_attach_database(&con, "cost_db", ":memory:").unwrap();
|
|
duckdb_attach_database(&con, "other_db", ":memory:").unwrap();
|
|
con.execute_batch(
|
|
"CREATE TABLE memory.main.md_bom(primary_id INTEGER); \
|
|
CREATE TABLE cost_db.main.md_bom(product_id INTEGER PRIMARY KEY, description VARCHAR DEFAULT 'part'); \
|
|
COMMENT ON COLUMN cost_db.main.md_bom.description IS 'Product description'; \
|
|
CREATE TABLE other_db.main.md_bom(other_id INTEGER); \
|
|
CREATE TABLE other_db.main.other_only(id INTEGER);",
|
|
)
|
|
.unwrap();
|
|
(con, vec!["cost_db".to_string(), "other_db".to_string()])
|
|
}
|
|
|
|
#[test]
|
|
fn duckdb_query_columns_resolves_attached_catalog_as_schema() {
|
|
let (con, attached_names) = duckdb_attached_columns_fixture();
|
|
con.execute_batch("SELECT product_id FROM cost_db.md_bom").unwrap();
|
|
|
|
for database in ["main", "", " "] {
|
|
for schema in ["cost_db", "COST_DB"] {
|
|
let columns =
|
|
duckdb_query_columns_in_database_with_attached(&con, database, schema, "md_bom", &attached_names)
|
|
.unwrap();
|
|
assert_eq!(
|
|
columns.iter().map(|column| column.name.as_str()).collect::<Vec<_>>(),
|
|
["product_id", "description"]
|
|
);
|
|
assert!(columns[0].is_primary_key);
|
|
assert!(!columns[0].is_nullable);
|
|
assert_eq!(columns[0].data_type, "INTEGER");
|
|
assert!(!columns[1].is_primary_key);
|
|
assert!(columns[1].is_nullable);
|
|
assert_eq!(columns[1].column_default.as_deref(), Some("'part'"));
|
|
assert_eq!(columns[1].comment.as_deref(), Some("Product description"));
|
|
}
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn duckdb_query_columns_prefers_existing_schema_table_over_attached_catalog() {
|
|
let (con, attached_names) = duckdb_attached_columns_fixture();
|
|
con.execute_batch("CREATE SCHEMA memory.cost_db; CREATE TABLE memory.cost_db.md_bom(schema_id INTEGER);")
|
|
.unwrap();
|
|
|
|
let columns =
|
|
duckdb_query_columns_in_database_with_attached(&con, "main", "cost_db", "md_bom", &attached_names).unwrap();
|
|
assert_eq!(columns.iter().map(|column| column.name.as_str()).collect::<Vec<_>>(), ["schema_id"]);
|
|
|
|
con.execute_batch("DROP TABLE memory.cost_db.md_bom").unwrap();
|
|
let columns =
|
|
duckdb_query_columns_in_database_with_attached(&con, "main", "cost_db", "md_bom", &attached_names).unwrap();
|
|
assert_eq!(
|
|
columns.iter().map(|column| column.name.as_str()).collect::<Vec<_>>(),
|
|
["product_id", "description"]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn duckdb_query_columns_keeps_explicit_catalog_and_default_schema() {
|
|
let (con, attached_names) = duckdb_attached_columns_fixture();
|
|
for (database, expected) in [("main", "primary_id"), ("memory", "primary_id"), ("other_db", "other_id")] {
|
|
let columns =
|
|
duckdb_query_columns_in_database_with_attached(&con, database, "main", "md_bom", &attached_names)
|
|
.unwrap();
|
|
assert_eq!(columns.iter().map(|column| column.name.as_str()).collect::<Vec<_>>(), [expected]);
|
|
}
|
|
let columns =
|
|
duckdb_query_columns_in_database_with_attached(&con, "cost_db", "main", "md_bom", &attached_names).unwrap();
|
|
assert_eq!(
|
|
columns.iter().map(|column| column.name.as_str()).collect::<Vec<_>>(),
|
|
["product_id", "description"]
|
|
);
|
|
|
|
for database in ["memory", "other_db", "cost_db", "unknown"] {
|
|
let columns =
|
|
duckdb_query_columns_in_database_with_attached(&con, database, "cost_db", "md_bom", &attached_names)
|
|
.unwrap();
|
|
assert!(columns.is_empty(), "must not redirect explicit {database}.cost_db.md_bom");
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn duckdb_query_columns_isolates_attached_catalog_fallback() {
|
|
let (con, attached_names) = duckdb_attached_columns_fixture();
|
|
let columns =
|
|
duckdb_query_columns_in_database_with_attached(&con, "main", "other_db", "md_bom", &attached_names)
|
|
.unwrap();
|
|
assert_eq!(columns.iter().map(|column| column.name.as_str()).collect::<Vec<_>>(), ["other_id"]);
|
|
|
|
for (schema, table) in [("cost_db", "missing"), ("cost_db", "other_only"), ("unknown", "md_bom")] {
|
|
let columns =
|
|
duckdb_query_columns_in_database_with_attached(&con, "main", schema, table, &attached_names).unwrap();
|
|
assert!(columns.is_empty(), "unexpected columns for {schema}.{table}");
|
|
}
|
|
let columns = duckdb_query_columns_in_database_with_attached(&con, "main", "cost_db", "md_bom", &[]).unwrap();
|
|
assert!(columns.is_empty());
|
|
|
|
con.execute_batch("DETACH cost_db").unwrap();
|
|
let columns =
|
|
duckdb_query_columns_in_database_with_attached(&con, "main", "cost_db", "md_bom", &attached_names).unwrap();
|
|
assert!(columns.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn duckdb_table_ddl_filters_by_database_schema_and_table_name() {
|
|
let unique = uuid::Uuid::new_v4();
|
|
let path = std::env::temp_dir().join(format!("dbx-attached-ddl-{unique}.duckdb"));
|
|
let _ = std::fs::remove_file(&path);
|
|
let con = duckdb::Connection::open_in_memory().unwrap();
|
|
|
|
con.execute_batch(
|
|
"CREATE SCHEMA reporting; \
|
|
CREATE TABLE main.orders(main_id INTEGER); \
|
|
CREATE TABLE reporting.orders(reporting_id INTEGER);",
|
|
)
|
|
.unwrap();
|
|
duckdb_attach_database(&con, "analytics", path.to_str().unwrap()).unwrap();
|
|
con.execute_batch("CREATE TABLE analytics.orders(attached_id INTEGER);").unwrap();
|
|
|
|
let main_ddl =
|
|
duckdb_table_ddl_with_attached(&con, "main", "main", "orders", &["analytics".to_string()]).unwrap();
|
|
let reporting_ddl =
|
|
duckdb_table_ddl_with_attached(&con, "main", "reporting", "orders", &["analytics".to_string()]).unwrap();
|
|
let attached_ddl =
|
|
duckdb_table_ddl_with_attached(&con, "analytics", "main", "orders", &["analytics".to_string()]).unwrap();
|
|
|
|
assert!(main_ddl.contains("main_id"));
|
|
assert!(reporting_ddl.contains("reporting_id"));
|
|
assert!(attached_ddl.contains("attached_id"));
|
|
|
|
let _ = std::fs::remove_file(path);
|
|
}
|
|
|
|
#[test]
|
|
fn duckdb_completion_assistant_searches_catalog_metadata_with_limit() {
|
|
let con = duckdb::Connection::open_in_memory().unwrap();
|
|
con.execute_batch(
|
|
"CREATE TABLE account(id INTEGER, display_name VARCHAR); \
|
|
CREATE VIEW account_view AS SELECT id FROM account;",
|
|
)
|
|
.unwrap();
|
|
|
|
let request = db::CompletionAssistantRequest {
|
|
connection_id: "c1".to_string(),
|
|
database: "main".to_string(),
|
|
schema: Some("main".to_string()),
|
|
object_kinds: vec![db::CompletionAssistantObjectKind::Table, db::CompletionAssistantObjectKind::View],
|
|
mask: "account".to_string(),
|
|
case_sensitive: false,
|
|
global_search: false,
|
|
max_results: Some(1),
|
|
search_in_comments: false,
|
|
search_in_definitions: false,
|
|
parent_schema: Some("main".to_string()),
|
|
parent_name: None,
|
|
match_mode: Some(db::CompletionAssistantMatchMode::Prefix),
|
|
};
|
|
|
|
let tables = duckdb_completion_assistant_search(&con, &request, &[]).unwrap();
|
|
assert_eq!(tables.candidates.len(), 1);
|
|
assert!(tables.incomplete);
|
|
assert!(!tables.fallback_used);
|
|
assert_eq!(tables.candidates[0].name, "account");
|
|
|
|
let columns = duckdb_completion_assistant_search(
|
|
&con,
|
|
&db::CompletionAssistantRequest {
|
|
object_kinds: vec![db::CompletionAssistantObjectKind::Column],
|
|
mask: "name".to_string(),
|
|
max_results: Some(10),
|
|
parent_name: Some("account".to_string()),
|
|
match_mode: Some(db::CompletionAssistantMatchMode::Contains),
|
|
..request
|
|
},
|
|
&[],
|
|
)
|
|
.unwrap();
|
|
assert_eq!(columns.candidates.len(), 1);
|
|
assert_eq!(columns.candidates[0].name, "display_name");
|
|
}
|
|
|
|
#[test]
|
|
fn duckdb_object_source_filters_by_schema_and_view_name() {
|
|
let con = duckdb::Connection::open_in_memory().unwrap();
|
|
con.execute_batch(
|
|
"CREATE SCHEMA reporting; \
|
|
CREATE VIEW main.active_orders AS SELECT 'main' AS origin; \
|
|
CREATE VIEW reporting.active_orders AS SELECT 'reporting' AS origin;",
|
|
)
|
|
.unwrap();
|
|
|
|
let main_source =
|
|
duckdb_object_source_with_attached(&con, "main", "main", "active_orders", &db::ObjectSourceKind::View, &[])
|
|
.unwrap();
|
|
let reporting_source = duckdb_object_source_with_attached(
|
|
&con,
|
|
"main",
|
|
"reporting",
|
|
"active_orders",
|
|
&db::ObjectSourceKind::View,
|
|
&[],
|
|
)
|
|
.unwrap();
|
|
|
|
assert!(main_source.contains("'main'"));
|
|
assert!(reporting_source.contains("'reporting'"));
|
|
}
|
|
|
|
#[test]
|
|
fn duckdb_object_source_rejects_unsupported_or_missing_objects() {
|
|
let con = duckdb::Connection::open_in_memory().unwrap();
|
|
|
|
let unsupported = duckdb_object_source_with_attached(
|
|
&con,
|
|
"main",
|
|
"main",
|
|
"calculate_total",
|
|
&db::ObjectSourceKind::Function,
|
|
&[],
|
|
)
|
|
.unwrap_err();
|
|
let missing =
|
|
duckdb_object_source_with_attached(&con, "main", "main", "missing_view", &db::ObjectSourceKind::View, &[])
|
|
.unwrap_err();
|
|
|
|
assert_eq!(unsupported, "DuckDB object source only supports views");
|
|
assert!(missing.contains("DuckDB view source not found"));
|
|
}
|
|
|
|
#[test]
|
|
fn duckdb_catalog_view_source_can_replace_existing_view() {
|
|
let con = duckdb::Connection::open_in_memory().unwrap();
|
|
con.execute_batch("CREATE VIEW active_orders AS SELECT 1 AS value;").unwrap();
|
|
let source =
|
|
duckdb_object_source_with_attached(&con, "main", "main", "active_orders", &db::ObjectSourceKind::View, &[])
|
|
.unwrap();
|
|
let edited_source = source.replace("SELECT 1", "SELECT 2");
|
|
assert_ne!(edited_source, source);
|
|
|
|
let statements = dbx_core::object_source_sql::build_executable_object_source_statements(
|
|
dbx_core::object_source_sql::EditableObjectSourceSqlInput {
|
|
database_type: DatabaseType::DuckDb,
|
|
object_type: dbx_core::db::ObjectSourceKind::View,
|
|
schema: Some("main".to_string()),
|
|
name: "active_orders".to_string(),
|
|
source: edited_source,
|
|
},
|
|
)
|
|
.unwrap();
|
|
con.execute_batch(&statements.join("\n")).unwrap();
|
|
|
|
let value = con.query_row("SELECT value FROM active_orders", [], |row| row.get::<_, i32>(0)).unwrap();
|
|
assert_eq!(value, 2);
|
|
}
|
|
}
|