feat(completion): add scoped metadata assistant
This commit is contained in:
1 parent
3f65297f25
commit
cebb39cb80
37 files changed
+2709
-85
No files matched your search
@@ -120,6 +120,7 @@ pub enum AgentMethod {
|
||||
ListSchemas,
|
||||
ListTables,
|
||||
ListObjects,
|
||||
CompletionAssistantSearchV1,
|
||||
GetObjectSource,
|
||||
GetColumns,
|
||||
ListIndexes,
|
||||
@@ -137,7 +138,7 @@ pub enum AgentMethod {
|
||||
}
|
||||
|
||||
impl AgentMethod {
|
||||
pub const ALL: [Self; 22] = [
|
||||
pub const ALL: [Self; 23] = [
|
||||
Self::Handshake,
|
||||
Self::Connect,
|
||||
Self::TestConnection,
|
||||
@@ -146,6 +147,7 @@ impl AgentMethod {
|
||||
Self::ListSchemas,
|
||||
Self::ListTables,
|
||||
Self::ListObjects,
|
||||
Self::CompletionAssistantSearchV1,
|
||||
Self::GetObjectSource,
|
||||
Self::GetTableDdl,
|
||||
Self::GetColumns,
|
||||
@@ -172,6 +174,7 @@ impl AgentMethod {
|
||||
Self::ListSchemas => "list_schemas",
|
||||
Self::ListTables => "list_tables",
|
||||
Self::ListObjects => "list_objects",
|
||||
Self::CompletionAssistantSearchV1 => "completion_assistant_search_v1",
|
||||
Self::GetObjectSource => "get_object_source",
|
||||
Self::GetTableDdl => "get_table_ddl",
|
||||
Self::GetColumns => "get_columns",
|
||||
@@ -569,6 +572,19 @@ impl AgentDriverClient {
|
||||
.await
|
||||
}
|
||||
|
||||
pub async fn completion_assistant_search<T: DeserializeOwned + Send + 'static>(
|
||||
&mut self,
|
||||
request: &crate::types::CompletionAssistantRequest,
|
||||
timeout_duration: Option<Duration>,
|
||||
) -> Result<T, String> {
|
||||
self.call_method_with_timeout(
|
||||
AgentMethod::CompletionAssistantSearchV1,
|
||||
serde_json::to_value(request).map_err(|e| e.to_string())?,
|
||||
timeout_duration,
|
||||
)
|
||||
.await
|
||||
}
|
||||
|
||||
pub async fn get_object_source<T: DeserializeOwned + Send + 'static, K: Serialize>(
|
||||
&mut self,
|
||||
database: &str,
|
||||
@@ -1245,6 +1261,7 @@ mod tests {
|
||||
assert_eq!(AgentMethod::ListSchemas.as_str(), "list_schemas");
|
||||
assert_eq!(AgentMethod::ListTables.as_str(), "list_tables");
|
||||
assert_eq!(AgentMethod::ListObjects.as_str(), "list_objects");
|
||||
assert_eq!(AgentMethod::CompletionAssistantSearchV1.as_str(), "completion_assistant_search_v1");
|
||||
assert_eq!(AgentMethod::GetObjectSource.as_str(), "get_object_source");
|
||||
assert_eq!(AgentMethod::GetColumns.as_str(), "get_columns");
|
||||
assert_eq!(AgentMethod::ListIndexes.as_str(), "list_indexes");
|
||||
|
||||
@@ -13,8 +13,9 @@ use std::time::Instant;
|
||||
use crate::models::connection::DatabaseType;
|
||||
use crate::sql::starts_with_executable_sql_keyword;
|
||||
use crate::types::{
|
||||
ColumnInfo, DatabaseInfo, ForeignKeyInfo, IndexInfo, ObjectInfo, ObjectStatistics, QueryResult, TableInfo,
|
||||
TriggerInfo,
|
||||
ColumnInfo, CompletionAssistantCandidate, CompletionAssistantCandidateKind, CompletionAssistantMatchMode,
|
||||
CompletionAssistantObjectKind, CompletionAssistantRequest, CompletionAssistantResponse, DatabaseInfo,
|
||||
ForeignKeyInfo, IndexInfo, ObjectInfo, ObjectStatistics, QueryResult, TableInfo, TriggerInfo,
|
||||
};
|
||||
|
||||
use super::file_validator::validate_file_path;
|
||||
@@ -1025,6 +1026,228 @@ pub async fn list_tables(pool: &MySqlPool, database: &str) -> Result<Vec<TableIn
|
||||
Ok(tables)
|
||||
}
|
||||
|
||||
pub async fn completion_assistant_search(
|
||||
pool: &MySqlPool,
|
||||
request: &CompletionAssistantRequest,
|
||||
) -> Result<CompletionAssistantResponse, String> {
|
||||
let database = request.schema.as_deref().filter(|schema| !schema.trim().is_empty()).unwrap_or(&request.database);
|
||||
let limit = request.max_results.unwrap_or(100).clamp(1, 1000);
|
||||
let kinds = if request.object_kinds.is_empty() {
|
||||
vec![CompletionAssistantObjectKind::Table, CompletionAssistantObjectKind::View]
|
||||
} else {
|
||||
request.object_kinds.clone()
|
||||
};
|
||||
let pattern = mysql_completion_like_pattern(&request.mask, request.match_mode.as_ref());
|
||||
let mut conn = pool.get_conn().await.map_err(|e| e.to_string())?;
|
||||
let mut candidates = Vec::new();
|
||||
|
||||
if kinds
|
||||
.iter()
|
||||
.any(|kind| matches!(kind, CompletionAssistantObjectKind::Database | CompletionAssistantObjectKind::Schema))
|
||||
{
|
||||
let sql = mysql_completion_schemas_sql(&pattern, limit.saturating_sub(candidates.len()));
|
||||
let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
|
||||
let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
|
||||
for row in rows {
|
||||
let schema_name = get_str_by_name(&row, "schema_name");
|
||||
candidates.push(CompletionAssistantCandidate {
|
||||
name: schema_name.clone(),
|
||||
kind: CompletionAssistantCandidateKind::Schema,
|
||||
database: Some(schema_name.clone()),
|
||||
schema: Some(schema_name),
|
||||
parent_schema: None,
|
||||
parent_name: None,
|
||||
comment: None,
|
||||
data_type: None,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if candidates.len() < limit && kinds.iter().any(CompletionAssistantObjectKind::is_table_like) {
|
||||
let sql = mysql_completion_tables_sql(database, &pattern, &kinds, limit.saturating_sub(candidates.len()));
|
||||
let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
|
||||
let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
|
||||
for row in rows {
|
||||
let table_type = get_str_by_name(&row, "table_type");
|
||||
candidates.push(CompletionAssistantCandidate {
|
||||
name: get_str_by_name(&row, "object_name"),
|
||||
kind: if table_type.eq_ignore_ascii_case("VIEW") {
|
||||
CompletionAssistantCandidateKind::View
|
||||
} else {
|
||||
CompletionAssistantCandidateKind::Table
|
||||
},
|
||||
database: Some(database.to_string()),
|
||||
schema: Some(database.to_string()),
|
||||
parent_schema: None,
|
||||
parent_name: None,
|
||||
comment: get_opt_str(&row, "object_comment")
|
||||
.map(|s| fix_potential_double_encoding(&s))
|
||||
.filter(|s| !s.is_empty()),
|
||||
data_type: None,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if candidates.len() < limit && kinds.iter().any(CompletionAssistantObjectKind::is_routine_like) {
|
||||
let sql = mysql_completion_routines_sql(database, &pattern, &kinds, limit.saturating_sub(candidates.len()));
|
||||
let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
|
||||
let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
|
||||
for row in rows {
|
||||
let routine_type = get_str_by_name(&row, "routine_type");
|
||||
candidates.push(CompletionAssistantCandidate {
|
||||
name: get_str_by_name(&row, "object_name"),
|
||||
kind: if routine_type.eq_ignore_ascii_case("PROCEDURE") {
|
||||
CompletionAssistantCandidateKind::Procedure
|
||||
} else {
|
||||
CompletionAssistantCandidateKind::Function
|
||||
},
|
||||
database: Some(database.to_string()),
|
||||
schema: Some(database.to_string()),
|
||||
parent_schema: None,
|
||||
parent_name: None,
|
||||
comment: get_opt_str(&row, "object_comment")
|
||||
.map(|s| fix_potential_double_encoding(&s))
|
||||
.filter(|s| !s.is_empty()),
|
||||
data_type: get_opt_str(&row, "data_type"),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if candidates.len() < limit && kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::Column)) {
|
||||
if let Some(table) = request.parent_name.as_deref().filter(|table| !table.trim().is_empty()) {
|
||||
let sql = mysql_completion_columns_sql(database, table, &pattern, limit.saturating_sub(candidates.len()));
|
||||
let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
|
||||
let rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
|
||||
for row in rows {
|
||||
candidates.push(CompletionAssistantCandidate {
|
||||
name: get_str_by_name(&row, "object_name"),
|
||||
kind: CompletionAssistantCandidateKind::Column,
|
||||
database: Some(database.to_string()),
|
||||
schema: Some(database.to_string()),
|
||||
parent_schema: Some(database.to_string()),
|
||||
parent_name: Some(table.to_string()),
|
||||
comment: get_opt_str(&row, "object_comment")
|
||||
.map(|s| fix_potential_double_encoding(&s))
|
||||
.filter(|s| !s.is_empty()),
|
||||
data_type: Some(get_str_by_name(&row, "data_type")),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(CompletionAssistantResponse { incomplete: candidates.len() >= limit, candidates, fallback_used: false })
|
||||
}
|
||||
|
||||
fn mysql_completion_schemas_sql(pattern: &str, limit: usize) -> String {
|
||||
format!(
|
||||
"SELECT SCHEMA_NAME AS schema_name \
|
||||
FROM information_schema.SCHEMATA \
|
||||
WHERE SCHEMA_NAME LIKE {} ESCAPE '\\\\' \
|
||||
ORDER BY SCHEMA_NAME LIMIT {}",
|
||||
quote_value(pattern),
|
||||
limit,
|
||||
)
|
||||
}
|
||||
|
||||
fn mysql_completion_tables_sql(
|
||||
database: &str,
|
||||
pattern: &str,
|
||||
kinds: &[CompletionAssistantObjectKind],
|
||||
limit: usize,
|
||||
) -> String {
|
||||
let table_types = mysql_completion_table_types(kinds);
|
||||
format!(
|
||||
"SELECT TABLE_NAME AS object_name, TABLE_TYPE AS table_type, TABLE_COMMENT AS object_comment \
|
||||
FROM information_schema.TABLES \
|
||||
WHERE TABLE_SCHEMA = {db} AND TABLE_NAME LIKE {pattern} ESCAPE '\\\\' AND TABLE_TYPE IN ({table_types}) \
|
||||
ORDER BY TABLE_NAME LIMIT {limit}",
|
||||
db = quote_value(database),
|
||||
pattern = quote_value(pattern),
|
||||
table_types = table_types,
|
||||
limit = limit,
|
||||
)
|
||||
}
|
||||
|
||||
fn mysql_completion_routines_sql(
|
||||
database: &str,
|
||||
pattern: &str,
|
||||
kinds: &[CompletionAssistantObjectKind],
|
||||
limit: usize,
|
||||
) -> String {
|
||||
let routine_types = mysql_completion_routine_types(kinds);
|
||||
format!(
|
||||
"SELECT ROUTINE_NAME AS object_name, ROUTINE_TYPE AS routine_type, ROUTINE_COMMENT AS object_comment, DATA_TYPE AS data_type \
|
||||
FROM information_schema.ROUTINES \
|
||||
WHERE ROUTINE_SCHEMA = {db} AND ROUTINE_NAME LIKE {pattern} ESCAPE '\\\\' AND ROUTINE_TYPE IN ({routine_types}) \
|
||||
ORDER BY ROUTINE_NAME LIMIT {limit}",
|
||||
db = quote_value(database),
|
||||
pattern = quote_value(pattern),
|
||||
routine_types = routine_types,
|
||||
limit = limit,
|
||||
)
|
||||
}
|
||||
|
||||
fn mysql_completion_columns_sql(database: &str, table: &str, pattern: &str, limit: usize) -> String {
|
||||
format!(
|
||||
"SELECT COLUMN_NAME AS object_name, COLUMN_TYPE AS data_type, COLUMN_COMMENT AS object_comment \
|
||||
FROM information_schema.COLUMNS \
|
||||
WHERE TABLE_SCHEMA = {db} AND TABLE_NAME = {table} AND COLUMN_NAME LIKE {pattern} ESCAPE '\\\\' \
|
||||
ORDER BY ORDINAL_POSITION LIMIT {limit}",
|
||||
db = quote_value(database),
|
||||
table = quote_value(table),
|
||||
pattern = quote_value(pattern),
|
||||
limit = limit,
|
||||
)
|
||||
}
|
||||
|
||||
fn mysql_completion_table_types(kinds: &[CompletionAssistantObjectKind]) -> String {
|
||||
let mut types = Vec::new();
|
||||
if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::Table)) {
|
||||
types.push("'BASE TABLE'");
|
||||
types.push("'SYSTEM VERSIONED'");
|
||||
}
|
||||
if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::View)) {
|
||||
types.push("'VIEW'");
|
||||
}
|
||||
if types.is_empty() {
|
||||
"'BASE TABLE','VIEW'".to_string()
|
||||
} else {
|
||||
types.join(",")
|
||||
}
|
||||
}
|
||||
|
||||
fn mysql_completion_routine_types(kinds: &[CompletionAssistantObjectKind]) -> String {
|
||||
let mut types = Vec::new();
|
||||
if kinds
|
||||
.iter()
|
||||
.any(|kind| matches!(kind, CompletionAssistantObjectKind::Procedure | CompletionAssistantObjectKind::Routine))
|
||||
{
|
||||
types.push("'PROCEDURE'");
|
||||
}
|
||||
if kinds
|
||||
.iter()
|
||||
.any(|kind| matches!(kind, CompletionAssistantObjectKind::Function | CompletionAssistantObjectKind::Routine))
|
||||
{
|
||||
types.push("'FUNCTION'");
|
||||
}
|
||||
if types.is_empty() {
|
||||
"'PROCEDURE','FUNCTION'".to_string()
|
||||
} else {
|
||||
types.join(",")
|
||||
}
|
||||
}
|
||||
|
||||
fn mysql_completion_like_pattern(value: &str, mode: Option<&CompletionAssistantMatchMode>) -> String {
|
||||
if value.trim().is_empty() || value == "%" {
|
||||
return "%".to_string();
|
||||
}
|
||||
let escaped = value.trim().replace('\\', "\\\\").replace('%', "\\%").replace('_', "\\_");
|
||||
match mode.unwrap_or(&CompletionAssistantMatchMode::Prefix) {
|
||||
CompletionAssistantMatchMode::Prefix => format!("{escaped}%"),
|
||||
CompletionAssistantMatchMode::Contains => format!("%{escaped}%"),
|
||||
}
|
||||
}
|
||||
|
||||
fn table_comment_sql(database: &str, table: &str) -> String {
|
||||
format!(
|
||||
"SELECT TABLE_COMMENT \
|
||||
@@ -2153,6 +2376,37 @@ mod tests {
|
||||
assert!(sql.contains("TRIGGER_SCHEMA = 'app'"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mysql_completion_like_pattern_uses_prefix_by_default() {
|
||||
assert_eq!(mysql_completion_like_pattern("Temp", Some(&CompletionAssistantMatchMode::Prefix)), "Temp%");
|
||||
assert_eq!(mysql_completion_like_pattern("Temp", Some(&CompletionAssistantMatchMode::Contains)), "%Temp%");
|
||||
assert_eq!(
|
||||
mysql_completion_like_pattern("order_100%", Some(&CompletionAssistantMatchMode::Prefix)),
|
||||
"order\\_100\\%%"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mysql_completion_sql_filters_before_limit() {
|
||||
let table_sql = mysql_completion_tables_sql(
|
||||
"app",
|
||||
"Temp%",
|
||||
&[CompletionAssistantObjectKind::Table, CompletionAssistantObjectKind::View],
|
||||
100,
|
||||
);
|
||||
let routine_sql =
|
||||
mysql_completion_routines_sql("app", "%audit%", &[CompletionAssistantObjectKind::Routine], 50);
|
||||
let column_sql = mysql_completion_columns_sql("app", "users", "id%", 25);
|
||||
|
||||
assert!(table_sql.contains("TABLE_NAME LIKE 'Temp%' ESCAPE '\\\\'"));
|
||||
assert!(table_sql.contains("TABLE_TYPE IN ('BASE TABLE','SYSTEM VERSIONED','VIEW')"));
|
||||
assert!(table_sql.contains("ORDER BY TABLE_NAME LIMIT 100"));
|
||||
assert!(routine_sql.contains("ROUTINE_NAME LIKE '%audit%' ESCAPE '\\\\'"));
|
||||
assert!(routine_sql.contains("ROUTINE_TYPE IN ('PROCEDURE','FUNCTION')"));
|
||||
assert!(column_sql.contains("COLUMN_NAME LIKE 'id%' ESCAPE '\\\\'"));
|
||||
assert!(column_sql.contains("ORDER BY ORDINAL_POSITION LIMIT 25"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mysql_columns_sql_uses_column_key_for_primary_keys_without_join() {
|
||||
let sql = columns_sql("app", "users");
|
||||
|
||||
@@ -22,8 +22,10 @@ use tokio_util::sync::CancellationToken;
|
||||
use super::file_validator::validate_file_path;
|
||||
use crate::sql::starts_with_executable_sql_keyword;
|
||||
use crate::types::{
|
||||
ColumnInfo, DatabaseInfo, ForeignKeyInfo, FunctionInfo, IndexInfo, ObjectInfo, ObjectStatistics, OwnerInfo,
|
||||
QueryResult, RuleInfo, SequenceInfo, TableInfo, TriggerInfo,
|
||||
ColumnInfo, CompletionAssistantCandidate, CompletionAssistantCandidateKind, CompletionAssistantMatchMode,
|
||||
CompletionAssistantObjectKind, CompletionAssistantRequest, CompletionAssistantResponse, DatabaseInfo,
|
||||
ForeignKeyInfo, FunctionInfo, IndexInfo, ObjectInfo, ObjectStatistics, OwnerInfo, QueryResult, RuleInfo,
|
||||
SequenceInfo, TableInfo, TriggerInfo,
|
||||
};
|
||||
|
||||
fn pg_temporal_to_json_value(row: &Row, idx: usize) -> Option<serde_json::Value> {
|
||||
@@ -964,6 +966,199 @@ pub async fn list_tables_filtered(
|
||||
.collect())
|
||||
}
|
||||
|
||||
pub async fn completion_assistant_search(
|
||||
pool: &Pool,
|
||||
request: &CompletionAssistantRequest,
|
||||
) -> Result<CompletionAssistantResponse, String> {
|
||||
let schema = request.schema.as_deref().or(request.parent_schema.as_deref()).unwrap_or("public");
|
||||
let limit = request.max_results.unwrap_or(100).clamp(1, 1000);
|
||||
let kinds = if request.object_kinds.is_empty() {
|
||||
vec![CompletionAssistantObjectKind::Table, CompletionAssistantObjectKind::View]
|
||||
} else {
|
||||
request.object_kinds.clone()
|
||||
};
|
||||
let pattern = postgres_completion_like_pattern(&request.mask, request.match_mode.as_ref());
|
||||
let client = pool.get().await.map_err(|e| e.to_string())?;
|
||||
let mut candidates = Vec::new();
|
||||
|
||||
if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::Schema)) {
|
||||
let stmt = client
|
||||
.prepare_cached(
|
||||
"SELECT nspname FROM pg_catalog.pg_namespace \
|
||||
WHERE nspname NOT LIKE 'pg_%' AND nspname <> 'information_schema' \
|
||||
AND ($1 = '%%' OR nspname ILIKE $1 ESCAPE '~') \
|
||||
ORDER BY nspname LIMIT $2",
|
||||
)
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
for row in client.query(&stmt, &[&pattern, &(limit as i64)]).await.map_err(|e| e.to_string())? {
|
||||
let schema_name: String = row.get(0);
|
||||
candidates.push(CompletionAssistantCandidate {
|
||||
name: schema_name.clone(),
|
||||
kind: CompletionAssistantCandidateKind::Schema,
|
||||
database: Some(request.database.clone()),
|
||||
schema: Some(schema_name),
|
||||
parent_schema: None,
|
||||
parent_name: None,
|
||||
comment: None,
|
||||
data_type: None,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if candidates.len() < limit && kinds.iter().any(CompletionAssistantObjectKind::is_table_like) {
|
||||
let relkinds = postgres_completion_relkinds(&kinds);
|
||||
let stmt = client.prepare_cached(postgres_completion_tables_sql()).await.map_err(|e| e.to_string())?;
|
||||
let rows = client
|
||||
.query(&stmt, &[&schema, &pattern, &relkinds, &((limit - candidates.len()) as i64)])
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
for row in rows {
|
||||
let table_type: String = row.get(2);
|
||||
candidates.push(CompletionAssistantCandidate {
|
||||
name: row.get(0),
|
||||
kind: if table_type == "VIEW" {
|
||||
CompletionAssistantCandidateKind::View
|
||||
} else {
|
||||
CompletionAssistantCandidateKind::Table
|
||||
},
|
||||
database: Some(request.database.clone()),
|
||||
schema: Some(row.get(1)),
|
||||
parent_schema: row.try_get::<_, Option<String>>(4).ok().flatten(),
|
||||
parent_name: row.try_get::<_, Option<String>>(5).ok().flatten(),
|
||||
comment: row.try_get::<_, Option<String>>(3).ok().flatten(),
|
||||
data_type: None,
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if candidates.len() < limit && kinds.iter().any(CompletionAssistantObjectKind::is_routine_like) {
|
||||
let prokinds = postgres_completion_prokinds(&kinds);
|
||||
let stmt = client.prepare_cached(postgres_completion_routines_sql()).await.map_err(|e| e.to_string())?;
|
||||
let rows = client
|
||||
.query(&stmt, &[&schema, &pattern, &prokinds, &((limit - candidates.len()) as i64)])
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
for row in rows {
|
||||
let routine_type: String = row.get(2);
|
||||
candidates.push(CompletionAssistantCandidate {
|
||||
name: row.get(0),
|
||||
kind: if routine_type == "PROCEDURE" {
|
||||
CompletionAssistantCandidateKind::Procedure
|
||||
} else {
|
||||
CompletionAssistantCandidateKind::Function
|
||||
},
|
||||
database: Some(request.database.clone()),
|
||||
schema: Some(row.get(1)),
|
||||
parent_schema: None,
|
||||
parent_name: None,
|
||||
comment: row.try_get::<_, Option<String>>(3).ok().flatten(),
|
||||
data_type: row.try_get::<_, Option<String>>(4).ok().flatten(),
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
if candidates.len() < limit && kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::Column)) {
|
||||
let table = request.parent_name.as_deref().unwrap_or("");
|
||||
if !table.is_empty() {
|
||||
let stmt = client.prepare_cached(postgres_completion_columns_sql()).await.map_err(|e| e.to_string())?;
|
||||
let rows = client
|
||||
.query(&stmt, &[&schema, &table, &pattern, &((limit - candidates.len()) as i64)])
|
||||
.await
|
||||
.map_err(|e| e.to_string())?;
|
||||
for row in rows {
|
||||
candidates.push(CompletionAssistantCandidate {
|
||||
name: row.get(0),
|
||||
kind: 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: row.try_get::<_, Option<String>>(2).ok().flatten(),
|
||||
data_type: Some(row.get(1)),
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(CompletionAssistantResponse { incomplete: candidates.len() >= limit, candidates, fallback_used: false })
|
||||
}
|
||||
|
||||
fn postgres_completion_tables_sql() -> &'static str {
|
||||
"SELECT c.relname, n.nspname, \
|
||||
CASE c.relkind WHEN 'v' THEN 'VIEW' WHEN 'm' THEN 'VIEW' ELSE 'TABLE' END AS table_type, \
|
||||
obj_description(c.oid) AS table_comment, \
|
||||
CASE WHEN pc.relkind = 'p' THEN pn.nspname ELSE NULL END AS parent_schema, \
|
||||
CASE WHEN pc.relkind = 'p' THEN pc.relname ELSE NULL END AS parent_name \
|
||||
FROM pg_catalog.pg_class c \
|
||||
JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
|
||||
LEFT JOIN pg_catalog.pg_inherits i ON i.inhrelid = c.oid \
|
||||
LEFT JOIN pg_catalog.pg_class pc ON pc.oid = i.inhparent \
|
||||
LEFT JOIN pg_catalog.pg_namespace pn ON pn.oid = pc.relnamespace \
|
||||
WHERE n.nspname = $1 AND c.relkind = ANY($3) \
|
||||
AND ($2 = '%%' OR c.relname ILIKE $2 ESCAPE '~') \
|
||||
ORDER BY c.relname LIMIT $4"
|
||||
}
|
||||
|
||||
fn postgres_completion_routines_sql() -> &'static str {
|
||||
"SELECT p.proname, n.nspname, CASE p.prokind WHEN 'p' THEN 'PROCEDURE' ELSE 'FUNCTION' END, \
|
||||
obj_description(p.oid) AS routine_comment, COALESCE(pg_get_function_result(p.oid), '') AS data_type \
|
||||
FROM pg_catalog.pg_proc p \
|
||||
JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace \
|
||||
WHERE n.nspname = $1 AND p.prokind = ANY($3) \
|
||||
AND ($2 = '%%' OR p.proname ILIKE $2 ESCAPE '~') \
|
||||
ORDER BY p.proname LIMIT $4"
|
||||
}
|
||||
|
||||
fn postgres_completion_columns_sql() -> &'static str {
|
||||
"SELECT a.attname, pg_catalog.format_type(a.atttypid, a.atttypmod), col_description(c.oid, a.attnum) \
|
||||
FROM pg_catalog.pg_attribute a \
|
||||
JOIN pg_catalog.pg_class c ON c.oid = a.attrelid \
|
||||
JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \
|
||||
WHERE n.nspname = $1 AND c.relname = $2 AND a.attnum > 0 AND NOT a.attisdropped \
|
||||
AND ($3 = '%%' OR a.attname ILIKE $3 ESCAPE '~') \
|
||||
ORDER BY a.attnum LIMIT $4"
|
||||
}
|
||||
|
||||
fn postgres_completion_relkinds(kinds: &[CompletionAssistantObjectKind]) -> Vec<String> {
|
||||
let mut relkinds = Vec::new();
|
||||
if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::Table)) {
|
||||
relkinds.extend(["r", "p", "f"].into_iter().map(str::to_string));
|
||||
}
|
||||
if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::View)) {
|
||||
relkinds.extend(["v", "m"].into_iter().map(str::to_string));
|
||||
}
|
||||
relkinds
|
||||
}
|
||||
|
||||
fn postgres_completion_prokinds(kinds: &[CompletionAssistantObjectKind]) -> Vec<String> {
|
||||
let mut prokinds = Vec::new();
|
||||
if kinds
|
||||
.iter()
|
||||
.any(|kind| matches!(kind, CompletionAssistantObjectKind::Procedure | CompletionAssistantObjectKind::Routine))
|
||||
{
|
||||
prokinds.push("p".to_string());
|
||||
}
|
||||
if kinds
|
||||
.iter()
|
||||
.any(|kind| matches!(kind, CompletionAssistantObjectKind::Function | CompletionAssistantObjectKind::Routine))
|
||||
{
|
||||
prokinds.push("f".to_string());
|
||||
}
|
||||
prokinds
|
||||
}
|
||||
|
||||
fn postgres_completion_like_pattern(value: &str, mode: Option<&CompletionAssistantMatchMode>) -> String {
|
||||
if value.trim().is_empty() || value == "%" {
|
||||
return "%%".to_string();
|
||||
}
|
||||
let escaped = value.trim().replace('~', "~~").replace('%', "~%").replace('_', "~_");
|
||||
match mode.unwrap_or(&CompletionAssistantMatchMode::Prefix) {
|
||||
CompletionAssistantMatchMode::Prefix => format!("{escaped}%"),
|
||||
CompletionAssistantMatchMode::Contains => format!("%{escaped}%"),
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn get_table_comment(pool: &Pool, schema: &str, table: &str) -> Result<Option<String>, String> {
|
||||
let schema = if schema.is_empty() { "public" } else { schema };
|
||||
let client = pool.get().await.map_err(|e| e.to_string())?;
|
||||
@@ -2526,4 +2721,22 @@ mod tests {
|
||||
|
||||
assert!(sql.contains("ILIKE $2 ESCAPE '~'"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn postgres_completion_like_pattern_uses_prefix_by_default() {
|
||||
assert_eq!(postgres_completion_like_pattern("Temp", Some(&CompletionAssistantMatchMode::Prefix)), "Temp%");
|
||||
assert_eq!(postgres_completion_like_pattern("Temp", Some(&CompletionAssistantMatchMode::Contains)), "%Temp%");
|
||||
assert_eq!(
|
||||
postgres_completion_like_pattern("order_100%", Some(&CompletionAssistantMatchMode::Prefix)),
|
||||
"order~_100~%%"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn postgres_completion_sql_filters_before_limit() {
|
||||
assert!(postgres_completion_tables_sql().contains("c.relname ILIKE $2 ESCAPE '~'"));
|
||||
assert!(postgres_completion_tables_sql().contains("ORDER BY c.relname LIMIT $4"));
|
||||
assert!(postgres_completion_routines_sql().contains("p.proname ILIKE $2 ESCAPE '~'"));
|
||||
assert!(postgres_completion_columns_sql().contains("a.attname ILIKE $3 ESCAPE '~'"));
|
||||
}
|
||||
}
|
||||
@@ -9,7 +9,11 @@ use std::time::Instant;
|
||||
|
||||
use super::file_validator::validate_file_path;
|
||||
use crate::sql::starts_with_executable_sql_keyword;
|
||||
use crate::types::{ColumnInfo, DatabaseInfo, ForeignKeyInfo, IndexInfo, QueryResult, TableInfo, TriggerInfo};
|
||||
use crate::types::{
|
||||
ColumnInfo, CompletionAssistantCandidate, CompletionAssistantCandidateKind, CompletionAssistantMatchMode,
|
||||
CompletionAssistantObjectKind, CompletionAssistantRequest, CompletionAssistantResponse, DatabaseInfo,
|
||||
ForeignKeyInfo, IndexInfo, QueryResult, TableInfo, TriggerInfo,
|
||||
};
|
||||
|
||||
const SQLITE_DATABASE_HEADER: &[u8; 16] = b"SQLite format 3\0";
|
||||
|
||||
@@ -567,6 +571,68 @@ mod tests {
|
||||
let id = cols.iter().find(|c| c.name == "id").expect("id col");
|
||||
assert!(id.extra.is_none());
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn completion_assistant_searches_sqlite_tables_and_columns_with_limit() {
|
||||
let pool = connect_path(":memory:").await.expect("connect in-memory SQLite");
|
||||
execute_query(
|
||||
&pool,
|
||||
"CREATE TABLE account(id INTEGER PRIMARY KEY, display_name TEXT); CREATE VIEW account_view AS SELECT id FROM account; CREATE TABLE audit_log(id INTEGER);",
|
||||
)
|
||||
.await
|
||||
.expect("setup schema");
|
||||
|
||||
let tables = completion_assistant_search(
|
||||
&pool,
|
||||
&CompletionAssistantRequest {
|
||||
connection_id: "c1".to_string(),
|
||||
database: "main".to_string(),
|
||||
schema: Some("main".to_string()),
|
||||
object_kinds: vec![CompletionAssistantObjectKind::Table, 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(CompletionAssistantMatchMode::Prefix),
|
||||
},
|
||||
)
|
||||
.await
|
||||
.expect("table completion");
|
||||
|
||||
assert_eq!(tables.candidates.len(), 1);
|
||||
assert!(tables.incomplete);
|
||||
assert!(!tables.fallback_used);
|
||||
assert_eq!(tables.candidates[0].name, "account");
|
||||
|
||||
let columns = completion_assistant_search(
|
||||
&pool,
|
||||
&CompletionAssistantRequest {
|
||||
connection_id: "c1".to_string(),
|
||||
database: "main".to_string(),
|
||||
schema: Some("main".to_string()),
|
||||
object_kinds: vec![CompletionAssistantObjectKind::Column],
|
||||
mask: "name".to_string(),
|
||||
case_sensitive: false,
|
||||
global_search: false,
|
||||
max_results: Some(10),
|
||||
search_in_comments: false,
|
||||
search_in_definitions: false,
|
||||
parent_schema: Some("main".to_string()),
|
||||
parent_name: Some("account".to_string()),
|
||||
match_mode: Some(CompletionAssistantMatchMode::Contains),
|
||||
},
|
||||
)
|
||||
.await
|
||||
.expect("column completion");
|
||||
|
||||
assert_eq!(columns.candidates.len(), 1);
|
||||
assert_eq!(columns.candidates[0].name, "display_name");
|
||||
assert_eq!(columns.candidates[0].data_type.as_deref(), Some("TEXT"));
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn list_databases(_pool: &SqliteHandle) -> Result<Vec<DatabaseInfo>, String> {
|
||||
@@ -640,6 +706,240 @@ pub async fn get_columns(pool: &SqliteHandle, _schema: &str, table: &str) -> Res
|
||||
.map_err(|e| e.to_string())?
|
||||
}
|
||||
|
||||
pub async fn completion_assistant_search(
|
||||
pool: &SqliteHandle,
|
||||
request: &CompletionAssistantRequest,
|
||||
) -> Result<CompletionAssistantResponse, String> {
|
||||
let pool = pool.clone();
|
||||
let request = request.clone();
|
||||
tokio::task::spawn_blocking(move || pool.with_connection(|conn| sqlite_completion_assistant_search(conn, &request)))
|
||||
.await
|
||||
.map_err(|e| e.to_string())?
|
||||
}
|
||||
|
||||
fn sqlite_completion_assistant_search(
|
||||
conn: &mut Connection,
|
||||
request: &CompletionAssistantRequest,
|
||||
) -> Result<CompletionAssistantResponse, String> {
|
||||
let limit = request.max_results.unwrap_or(100).clamp(1, 1000);
|
||||
let kinds = completion_object_kinds(request);
|
||||
let mut candidates = Vec::new();
|
||||
|
||||
if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::Schema)) {
|
||||
for schema in sqlite_completion_schemas(conn, request, limit - candidates.len())? {
|
||||
candidates.push(schema);
|
||||
if candidates.len() >= limit {
|
||||
return Ok(CompletionAssistantResponse { candidates, incomplete: true, fallback_used: false });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if kinds.iter().any(CompletionAssistantObjectKind::is_table_like) {
|
||||
for table in sqlite_completion_tables(conn, request, &kinds, limit - candidates.len())? {
|
||||
candidates.push(table);
|
||||
if candidates.len() >= limit {
|
||||
return Ok(CompletionAssistantResponse { candidates, incomplete: true, fallback_used: false });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::Column)) {
|
||||
for column in sqlite_completion_columns(conn, request, limit - candidates.len())? {
|
||||
candidates.push(column);
|
||||
if candidates.len() >= limit {
|
||||
return Ok(CompletionAssistantResponse { candidates, incomplete: true, fallback_used: false });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Ok(CompletionAssistantResponse { candidates, incomplete: false, fallback_used: false })
|
||||
}
|
||||
|
||||
fn completion_object_kinds(request: &CompletionAssistantRequest) -> Vec<CompletionAssistantObjectKind> {
|
||||
if request.object_kinds.is_empty() {
|
||||
vec![CompletionAssistantObjectKind::Table, CompletionAssistantObjectKind::View]
|
||||
} else {
|
||||
request.object_kinds.clone()
|
||||
}
|
||||
}
|
||||
|
||||
fn sqlite_completion_schemas(
|
||||
conn: &mut Connection,
|
||||
request: &CompletionAssistantRequest,
|
||||
limit: usize,
|
||||
) -> Result<Vec<CompletionAssistantCandidate>, String> {
|
||||
if limit == 0 {
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
let mut stmt = conn.prepare("PRAGMA database_list").map_err(|e| e.to_string())?;
|
||||
let rows = stmt.query_map([], |row| row.get::<_, String>(1)).map_err(|e| e.to_string())?;
|
||||
let mut schemas = rows.collect::<Result<Vec<_>, _>>().map_err(|e| e.to_string())?;
|
||||
schemas.sort_by_key(|schema| schema.to_lowercase());
|
||||
Ok(schemas
|
||||
.into_iter()
|
||||
.filter(|schema| sqlite_completion_name_matches(schema, request))
|
||||
.take(limit)
|
||||
.map(|schema| CompletionAssistantCandidate {
|
||||
name: schema.clone(),
|
||||
kind: CompletionAssistantCandidateKind::Schema,
|
||||
database: Some(request.database.clone()),
|
||||
schema: Some(schema),
|
||||
parent_schema: None,
|
||||
parent_name: None,
|
||||
comment: None,
|
||||
data_type: None,
|
||||
})
|
||||
.collect())
|
||||
}
|
||||
|
||||
fn sqlite_completion_tables(
|
||||
conn: &mut Connection,
|
||||
request: &CompletionAssistantRequest,
|
||||
kinds: &[CompletionAssistantObjectKind],
|
||||
limit: usize,
|
||||
) -> Result<Vec<CompletionAssistantCandidate>, String> {
|
||||
if limit == 0 {
|
||||
return Ok(Vec::new());
|
||||
}
|
||||
let schema = sqlite_completion_schema(request);
|
||||
let mut type_filters = Vec::new();
|
||||
if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::Table)) {
|
||||
type_filters.push("table");
|
||||
}
|
||||
if kinds.iter().any(|kind| matches!(kind, CompletionAssistantObjectKind::View)) {
|
||||
type_filters.push("view");
|
||||
}
|
||||
if type_filters.is_empty() {
|
||||
type_filters.extend(["table", "view"]);
|
||||
}
|
||||
let placeholders = std::iter::repeat("?").take(type_filters.len()).collect::<Vec<_>>().join(", ");
|
||||
let sql = format!(
|
||||
"SELECT name, type FROM {}.sqlite_master WHERE type IN ({}) AND name NOT LIKE 'sqlite_%' AND {} ORDER BY name LIMIT ?",
|
||||
sqlite_quote_ident(&schema),
|
||||
placeholders,
|
||||
sqlite_completion_filter_sql("name", request)
|
||||
);
|
||||
let pattern = sqlite_completion_like_pattern(request);
|
||||
let mut params: Vec<&dyn rusqlite::ToSql> =
|
||||
type_filters.iter().map(|value| value as &dyn rusqlite::ToSql).collect();
|
||||
params.push(&pattern);
|
||||
params.push(&limit);
|
||||
let mut stmt = conn.prepare(&sql).map_err(|e| e.to_string())?;
|
||||
let rows = stmt
|
||||
.query_map(params.as_slice(), |row| {
|
||||
let object_type = row.get::<_, String>(1)?;
|
||||
Ok(CompletionAssistantCandidate {
|
||||
name: row.get(0)?,
|
||||
kind: if object_type.eq_ignore_ascii_case("view") {
|
||||
CompletionAssistantCandidateKind::View
|
||||
} else {
|
||||
CompletionAssistantCandidateKind::Table
|
||||
},
|
||||
database: Some(request.database.clone()),
|
||||
schema: Some(schema.clone()),
|
||||
parent_schema: None,
|
||||
parent_name: None,
|
||||
comment: None,
|
||||
data_type: None,
|
||||
})
|
||||
})
|
||||
.map_err(|e| e.to_string())?;
|
||||
rows.collect::<Result<Vec<_>, _>>().map_err(|e| e.to_string())
|
||||
}
|
||||
|
||||
fn sqlite_completion_columns(
|
||||
conn: &mut Connection,
|
||||
request: &CompletionAssistantRequest,
|
||||
limit: usize,
|
||||
) -> Result<Vec<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 schema = sqlite_completion_schema(request);
|
||||
let sql = format!("PRAGMA {}.table_info({})", sqlite_quote_ident(&schema), sqlite_quote_string(table));
|
||||
let mut stmt = conn.prepare(&sql).map_err(|e| e.to_string())?;
|
||||
let rows = stmt
|
||||
.query_map([], |row| Ok((row.get::<_, String>("name")?, row.get::<_, String>("type")?)))
|
||||
.map_err(|e| e.to_string())?;
|
||||
let mut candidates = Vec::new();
|
||||
for row in rows {
|
||||
let (name, data_type) = row.map_err(|e| e.to_string())?;
|
||||
if !sqlite_completion_name_matches(&name, request) {
|
||||
continue;
|
||||
}
|
||||
candidates.push(CompletionAssistantCandidate {
|
||||
name,
|
||||
kind: CompletionAssistantCandidateKind::Column,
|
||||
database: Some(request.database.clone()),
|
||||
schema: Some(schema.clone()),
|
||||
parent_schema: Some(schema.clone()),
|
||||
parent_name: Some(table.to_string()),
|
||||
comment: None,
|
||||
data_type: Some(data_type),
|
||||
});
|
||||
if candidates.len() >= limit {
|
||||
break;
|
||||
}
|
||||
}
|
||||
Ok(candidates)
|
||||
}
|
||||
|
||||
fn sqlite_completion_schema(request: &CompletionAssistantRequest) -> String {
|
||||
request
|
||||
.parent_schema
|
||||
.as_deref()
|
||||
.or(request.schema.as_deref())
|
||||
.filter(|schema| !schema.trim().is_empty())
|
||||
.unwrap_or("main")
|
||||
.to_string()
|
||||
}
|
||||
|
||||
fn sqlite_completion_name_matches(name: &str, request: &CompletionAssistantRequest) -> bool {
|
||||
let mask = request.mask.trim().trim_matches('%');
|
||||
if mask.is_empty() {
|
||||
return true;
|
||||
}
|
||||
let (name, mask) = if request.case_sensitive {
|
||||
(name.to_string(), mask.to_string())
|
||||
} else {
|
||||
(name.to_lowercase(), mask.to_lowercase())
|
||||
};
|
||||
match request.match_mode.as_ref().unwrap_or(&CompletionAssistantMatchMode::Prefix) {
|
||||
CompletionAssistantMatchMode::Prefix => name.starts_with(&mask),
|
||||
CompletionAssistantMatchMode::Contains => name.contains(&mask),
|
||||
}
|
||||
}
|
||||
|
||||
fn sqlite_completion_filter_sql(column: &str, request: &CompletionAssistantRequest) -> String {
|
||||
if request.case_sensitive {
|
||||
format!("{column} GLOB ?")
|
||||
} else {
|
||||
format!("LOWER({column}) LIKE LOWER(?) ESCAPE '\\'")
|
||||
}
|
||||
}
|
||||
|
||||
fn sqlite_completion_like_pattern(request: &CompletionAssistantRequest) -> String {
|
||||
let mask = request.mask.trim().trim_matches('%');
|
||||
let escaped = mask.replace('\\', "\\\\").replace('%', "\\%").replace('_', "\\_");
|
||||
match request.match_mode.as_ref().unwrap_or(&CompletionAssistantMatchMode::Prefix) {
|
||||
CompletionAssistantMatchMode::Prefix if request.case_sensitive => format!("{}*", mask.replace('[', "[[]")),
|
||||
CompletionAssistantMatchMode::Contains if request.case_sensitive => format!("*{}*", mask.replace('[', "[[]")),
|
||||
CompletionAssistantMatchMode::Prefix => format!("{escaped}%"),
|
||||
CompletionAssistantMatchMode::Contains => format!("%{escaped}%"),
|
||||
}
|
||||
}
|
||||
|
||||
fn sqlite_quote_ident(value: &str) -> String {
|
||||
format!("\"{}\"", value.replace('"', "\"\""))
|
||||
}
|
||||
|
||||
fn sqlite_quote_string(value: &str) -> String {
|
||||
format!("'{}'", value.replace('\'', "''"))
|
||||
}
|
||||
|
||||
/// Read `sqlite_master.sql` for `table` and return the lowercase column names that
|
||||
/// are rowid-alias autoincrement primary keys (i.e. SQLite will assign a value when
|
||||
/// the column is omitted from an INSERT). Returns `None` only on connection / query
|
||||
|
||||
@@ -842,9 +842,215 @@ pub async fn list_tables(
|
||||
limit: Option<usize>,
|
||||
offset: Option<usize>,
|
||||
) -> Result<Vec<TableInfo>, String> {
|
||||
let sql = sqlserver_list_tables_sql(schema, filter, limit, offset);
|
||||
let stream = client.query(&*sql, &[]).await.map_err(|e| e.to_string())?;
|
||||
let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
|
||||
Ok(rows
|
||||
.iter()
|
||||
.map(|row| TableInfo {
|
||||
name: row.get::<&str, _>(0).unwrap_or("").to_string(),
|
||||
table_type: row.get::<&str, _>(1).unwrap_or("BASE TABLE").to_string(),
|
||||
comment: row.get::<&str, _>(2).filter(|s: &&str| !s.is_empty()).map(|s: &str| s.to_string()),
|
||||
parent_schema: None,
|
||||
parent_name: None,
|
||||
})
|
||||
.collect())
|
||||
}
|
||||
|
||||
pub async fn completion_assistant_search(
|
||||
client: &mut SqlServerClient,
|
||||
request: &crate::types::CompletionAssistantRequest,
|
||||
) -> Result<crate::types::CompletionAssistantResponse, String> {
|
||||
let limit = request.max_results.unwrap_or(100).clamp(1, 1000);
|
||||
let sql = sqlserver_completion_assistant_sql(request, limit);
|
||||
let stream = client.query(&*sql, &[]).await.map_err(|e| e.to_string())?;
|
||||
let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
|
||||
let candidates = rows
|
||||
.iter()
|
||||
.map(|row| {
|
||||
let object_type = row.get::<&str, _>(2).unwrap_or("OBJECT");
|
||||
crate::types::CompletionAssistantCandidate {
|
||||
name: row.get::<&str, _>(0).unwrap_or("").to_string(),
|
||||
kind: sqlserver_completion_candidate_kind(object_type),
|
||||
database: Some(request.database.clone()),
|
||||
schema: row.get::<&str, _>(1).map(str::to_string),
|
||||
parent_schema: row.get::<&str, _>(3).map(str::to_string),
|
||||
parent_name: row.get::<&str, _>(4).map(str::to_string),
|
||||
comment: row.get::<&str, _>(5).filter(|s: &&str| !s.is_empty()).map(|s| (*s).to_string()),
|
||||
data_type: row.get::<&str, _>(6).map(str::to_string),
|
||||
}
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
Ok(crate::types::CompletionAssistantResponse {
|
||||
incomplete: candidates.len() >= limit,
|
||||
candidates,
|
||||
fallback_used: false,
|
||||
})
|
||||
}
|
||||
|
||||
fn sqlserver_completion_candidate_kind(object_type: &str) -> crate::types::CompletionAssistantCandidateKind {
|
||||
match object_type.to_ascii_uppercase().as_str() {
|
||||
"SCHEMA" => crate::types::CompletionAssistantCandidateKind::Schema,
|
||||
"TABLE" | "BASE TABLE" => crate::types::CompletionAssistantCandidateKind::Table,
|
||||
"VIEW" => crate::types::CompletionAssistantCandidateKind::View,
|
||||
"PROCEDURE" => crate::types::CompletionAssistantCandidateKind::Procedure,
|
||||
"FUNCTION" => crate::types::CompletionAssistantCandidateKind::Function,
|
||||
"COLUMN" => crate::types::CompletionAssistantCandidateKind::Column,
|
||||
_ => crate::types::CompletionAssistantCandidateKind::Object,
|
||||
}
|
||||
}
|
||||
|
||||
fn sqlserver_completion_assistant_sql(request: &crate::types::CompletionAssistantRequest, limit: usize) -> String {
|
||||
let object_kinds = if request.object_kinds.is_empty() {
|
||||
vec![crate::types::CompletionAssistantObjectKind::Table, crate::types::CompletionAssistantObjectKind::View]
|
||||
} else {
|
||||
request.object_kinds.clone()
|
||||
};
|
||||
let mask = request.mask.trim();
|
||||
let like_pattern = completion_like_pattern(mask, request.match_mode.as_ref());
|
||||
let like_clause = if like_pattern == "%" {
|
||||
String::new()
|
||||
} else {
|
||||
format!(" AND LOWER({}) LIKE LOWER('{like_pattern}') ESCAPE '\\' ", "name_expr")
|
||||
};
|
||||
let schema_filter = request
|
||||
.schema
|
||||
.as_deref()
|
||||
.or(request.parent_schema.as_deref())
|
||||
.filter(|schema| !schema.trim().is_empty())
|
||||
.map(|schema| format!(" AND s.name = '{}' ", schema.replace('\'', "''")))
|
||||
.unwrap_or_default();
|
||||
|
||||
let mut queries = Vec::new();
|
||||
if (mask.starts_with('#') || mask.starts_with("%#"))
|
||||
&& object_kinds.iter().any(crate::types::CompletionAssistantObjectKind::is_table_like)
|
||||
{
|
||||
let object_like = sqlserver_completion_object_search_clause(request, &like_pattern);
|
||||
queries.push(format!(
|
||||
"SELECT TOP ({limit}) o.name, s.name AS schema_name, 'TABLE' AS object_type, NULL AS parent_schema, NULL AS parent_name, NULL AS object_comment, NULL AS data_type \
|
||||
FROM tempdb.sys.all_objects o \
|
||||
JOIN tempdb.sys.schemas s ON s.schema_id = o.schema_id \
|
||||
WHERE o.type = 'U' {object_like}"
|
||||
));
|
||||
return format!("SELECT * FROM ({}) AS dbx_completion ORDER BY name", queries.remove(0));
|
||||
}
|
||||
if object_kinds.iter().any(|kind| matches!(kind, crate::types::CompletionAssistantObjectKind::Schema)) {
|
||||
let schema_like = like_clause.replace("name_expr", "s.name");
|
||||
queries.push(format!(
|
||||
"SELECT TOP ({limit}) s.name, s.name AS schema_name, 'SCHEMA' AS object_type, NULL AS parent_schema, NULL AS parent_name, NULL AS object_comment, NULL AS data_type \
|
||||
FROM sys.schemas s \
|
||||
WHERE s.name NOT IN ('guest','INFORMATION_SCHEMA','sys') {schema_like}"
|
||||
));
|
||||
}
|
||||
if object_kinds.iter().any(crate::types::CompletionAssistantObjectKind::is_table_like)
|
||||
|| object_kinds.iter().any(crate::types::CompletionAssistantObjectKind::is_routine_like)
|
||||
{
|
||||
let mut type_ids = Vec::new();
|
||||
if object_kinds.iter().any(|kind| matches!(kind, crate::types::CompletionAssistantObjectKind::Table)) {
|
||||
type_ids.push("'U'");
|
||||
}
|
||||
if object_kinds.iter().any(|kind| matches!(kind, crate::types::CompletionAssistantObjectKind::View)) {
|
||||
type_ids.push("'V'");
|
||||
}
|
||||
if object_kinds.iter().any(|kind| {
|
||||
matches!(
|
||||
kind,
|
||||
crate::types::CompletionAssistantObjectKind::Procedure
|
||||
| crate::types::CompletionAssistantObjectKind::Routine
|
||||
)
|
||||
}) {
|
||||
type_ids.push("'P'");
|
||||
}
|
||||
if object_kinds.iter().any(|kind| {
|
||||
matches!(
|
||||
kind,
|
||||
crate::types::CompletionAssistantObjectKind::Function
|
||||
| crate::types::CompletionAssistantObjectKind::Routine
|
||||
)
|
||||
}) {
|
||||
type_ids.extend(["'FN'", "'IF'", "'TF'", "'FS'", "'FT'"]);
|
||||
}
|
||||
let object_like = sqlserver_completion_object_search_clause(request, &like_pattern);
|
||||
queries.push(format!(
|
||||
"SELECT TOP ({limit}) o.name, s.name AS schema_name, \
|
||||
CASE o.type WHEN 'U' THEN 'TABLE' WHEN 'V' THEN 'VIEW' WHEN 'P' THEN 'PROCEDURE' WHEN 'FN' THEN 'FUNCTION' WHEN 'IF' THEN 'FUNCTION' WHEN 'TF' THEN 'FUNCTION' WHEN 'FS' THEN 'FUNCTION' WHEN 'FT' THEN 'FUNCTION' ELSE o.type_desc END AS object_type, \
|
||||
NULL AS parent_schema, NULL AS parent_name, ep.value AS object_comment, NULL AS data_type \
|
||||
FROM sys.objects o \
|
||||
JOIN sys.schemas s ON s.schema_id = o.schema_id \
|
||||
OUTER APPLY (SELECT CAST(ep.value AS NVARCHAR(MAX)) AS value FROM sys.extended_properties ep WHERE ep.major_id = o.object_id AND ep.minor_id = 0 AND ep.name = N'MS_Description') ep \
|
||||
WHERE o.type IN ({}) AND o.is_ms_shipped = 0 {schema_filter} {object_like}",
|
||||
type_ids.join(",")
|
||||
));
|
||||
}
|
||||
if object_kinds.iter().any(|kind| matches!(kind, crate::types::CompletionAssistantObjectKind::Column)) {
|
||||
let column_like = like_clause.replace("name_expr", "c.name");
|
||||
let parent_table_filter = request
|
||||
.parent_name
|
||||
.as_deref()
|
||||
.filter(|table| !table.trim().is_empty())
|
||||
.map(|table| format!(" AND o.name = '{}' ", table.replace('\'', "''")))
|
||||
.unwrap_or_default();
|
||||
queries.push(format!(
|
||||
"SELECT TOP ({limit}) c.name, s.name AS schema_name, 'COLUMN' AS object_type, s.name AS parent_schema, o.name AS parent_name, NULL AS object_comment, TYPE_NAME(c.user_type_id) AS data_type \
|
||||
FROM sys.columns c \
|
||||
JOIN sys.objects o ON o.object_id = c.object_id \
|
||||
JOIN sys.schemas s ON s.schema_id = o.schema_id \
|
||||
WHERE o.type IN ('U','V') AND o.is_ms_shipped = 0 {schema_filter} {parent_table_filter} {column_like}"
|
||||
));
|
||||
}
|
||||
|
||||
if queries.is_empty() {
|
||||
format!("SELECT TOP (0) '' AS name, '' AS schema_name, '' AS object_type, NULL AS parent_schema, NULL AS parent_name, NULL AS object_comment, NULL AS data_type")
|
||||
} else if queries.len() == 1 {
|
||||
format!("SELECT * FROM ({}) AS dbx_completion ORDER BY name", queries.remove(0))
|
||||
} else {
|
||||
format!("SELECT TOP ({limit}) * FROM ({}) AS dbx_completion ORDER BY name", queries.join(" UNION ALL "))
|
||||
}
|
||||
}
|
||||
|
||||
fn sqlserver_completion_object_search_clause(
|
||||
request: &crate::types::CompletionAssistantRequest,
|
||||
like_pattern: &str,
|
||||
) -> String {
|
||||
if like_pattern == "%" {
|
||||
return String::new();
|
||||
}
|
||||
let mut predicates = vec![format!("LOWER(o.name) LIKE LOWER('{like_pattern}') ESCAPE '\\'")];
|
||||
if request.search_in_comments {
|
||||
predicates.push(format!("LOWER(COALESCE(ep.value, '')) LIKE LOWER('{like_pattern}') ESCAPE '\\'"));
|
||||
}
|
||||
if request.search_in_definitions {
|
||||
predicates.push(format!(
|
||||
"LOWER(COALESCE(OBJECT_DEFINITION(o.object_id), '')) LIKE LOWER('{like_pattern}') ESCAPE '\\'"
|
||||
));
|
||||
}
|
||||
format!(" AND ({}) ", predicates.join(" OR "))
|
||||
}
|
||||
|
||||
fn completion_like_pattern(mask: &str, mode: Option<&crate::types::CompletionAssistantMatchMode>) -> String {
|
||||
if mask.is_empty() || mask == "%" {
|
||||
return "%".to_string();
|
||||
}
|
||||
let has_wildcard = mask.contains('%');
|
||||
if has_wildcard {
|
||||
return mask.split('%').map(escape_like_literal).collect::<Vec<_>>().join("%");
|
||||
}
|
||||
let escaped = escape_like_literal(mask);
|
||||
match mode.unwrap_or(&crate::types::CompletionAssistantMatchMode::Prefix) {
|
||||
crate::types::CompletionAssistantMatchMode::Prefix => format!("{escaped}%"),
|
||||
crate::types::CompletionAssistantMatchMode::Contains => format!("%{escaped}%"),
|
||||
}
|
||||
}
|
||||
|
||||
fn sqlserver_list_tables_sql(
|
||||
schema: &str,
|
||||
filter: Option<&str>,
|
||||
limit: Option<usize>,
|
||||
offset: Option<usize>,
|
||||
) -> String {
|
||||
let filter_clause = filter
|
||||
.filter(|value| !value.trim().is_empty())
|
||||
.map(|value| format!(" AND o.name LIKE '%{}%' ESCAPE '\\' ", escape_like_literal(value.trim())))
|
||||
.map(|value| format!(" AND LOWER(o.name) LIKE LOWER('%{}%') ESCAPE '\\' ", escape_like_literal(value.trim())))
|
||||
.unwrap_or_default();
|
||||
let schema_escaped = schema.replace('\'', "''");
|
||||
let base_columns = "o.name, CASE WHEN o.type = 'V' THEN 'VIEW' ELSE 'BASE TABLE' END, ep.value AS TABLE_COMMENT";
|
||||
@@ -858,7 +1064,7 @@ pub async fn list_tables(
|
||||
|
||||
// Use SELECT TOP for broad SQL Server version compatibility.
|
||||
// OFFSET / FETCH NEXT is only available in SQL Server 2012+.
|
||||
let sql = match (limit, offset) {
|
||||
match (limit, offset) {
|
||||
(Some(limit), Some(offset)) if offset > 0 => {
|
||||
let end = offset + limit.min(1000);
|
||||
format!(
|
||||
@@ -874,19 +1080,7 @@ pub async fn list_tables(
|
||||
_ => {
|
||||
format!("SELECT {base_columns} {base_from} {base_where} {order_by}")
|
||||
}
|
||||
};
|
||||
let stream = client.query(&*sql, &[]).await.map_err(|e| e.to_string())?;
|
||||
let rows = stream.into_first_result().await.map_err(|e| e.to_string())?;
|
||||
Ok(rows
|
||||
.iter()
|
||||
.map(|row| TableInfo {
|
||||
name: row.get::<&str, _>(0).unwrap_or("").to_string(),
|
||||
table_type: row.get::<&str, _>(1).unwrap_or("BASE TABLE").to_string(),
|
||||
comment: row.get::<&str, _>(2).filter(|s: &&str| !s.is_empty()).map(|s: &str| s.to_string()),
|
||||
parent_schema: None,
|
||||
parent_name: None,
|
||||
})
|
||||
.collect())
|
||||
}
|
||||
}
|
||||
|
||||
fn escape_like_literal(value: &str) -> String {
|
||||
@@ -1414,9 +1608,11 @@ mod tests {
|
||||
use super::{
|
||||
build_spatial_safe_sqlserver_query, is_sqlserver_spatial_column, requires_simple_query_batch,
|
||||
sqlserver_batch_can_use_execute, sqlserver_cell_to_json, sqlserver_columns_sql,
|
||||
sqlserver_dml_output_returns_rows, sqlserver_indexes_sql, sqlserver_list_objects_sql,
|
||||
sqlserver_table_comment_sql, SqlServerDescribedColumn, SqlServerResultSet,
|
||||
sqlserver_completion_assistant_sql, sqlserver_dml_output_returns_rows, sqlserver_indexes_sql,
|
||||
sqlserver_list_objects_sql, sqlserver_list_tables_sql, sqlserver_table_comment_sql, SqlServerDescribedColumn,
|
||||
SqlServerResultSet,
|
||||
};
|
||||
use crate::types::{CompletionAssistantMatchMode, CompletionAssistantObjectKind, CompletionAssistantRequest};
|
||||
use chrono::NaiveDate;
|
||||
use std::time::Instant;
|
||||
use tiberius::{ColumnData, IntoSql};
|
||||
@@ -1556,6 +1752,137 @@ mod tests {
|
||||
assert!(sql.contains("modify_date"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sqlserver_list_tables_filter_is_case_insensitive() {
|
||||
let sql = sqlserver_list_tables_sql("dbo", Some("temp"), Some(200), None);
|
||||
|
||||
assert!(sql.contains("LOWER(o.name) LIKE LOWER('%temp%') ESCAPE '\\'"));
|
||||
assert!(sql.contains("SELECT TOP (200)"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sqlserver_list_tables_filter_escapes_like_literals() {
|
||||
let sql = sqlserver_list_tables_sql("dbo", Some("Temp_Table[%]"), Some(200), None);
|
||||
|
||||
assert!(sql.contains("LOWER(o.name) LIKE LOWER('%Temp\\_Table\\[\\%]%') ESCAPE '\\'"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sqlserver_completion_assistant_searches_objects_before_limiting() {
|
||||
let request = CompletionAssistantRequest {
|
||||
connection_id: "c1".to_string(),
|
||||
database: "app".to_string(),
|
||||
schema: Some("dbo".to_string()),
|
||||
object_kinds: vec![CompletionAssistantObjectKind::Table, CompletionAssistantObjectKind::View],
|
||||
mask: "Temp".to_string(),
|
||||
case_sensitive: false,
|
||||
global_search: false,
|
||||
max_results: Some(100),
|
||||
search_in_comments: false,
|
||||
search_in_definitions: false,
|
||||
parent_schema: None,
|
||||
parent_name: None,
|
||||
match_mode: Some(CompletionAssistantMatchMode::Prefix),
|
||||
};
|
||||
|
||||
let sql = sqlserver_completion_assistant_sql(&request, 100);
|
||||
|
||||
assert!(sql.contains("SELECT TOP (100)"));
|
||||
assert!(sql.contains("FROM sys.objects o"));
|
||||
assert!(sql.contains("o.type IN ('U','V')"));
|
||||
assert!(sql.contains("s.name = 'dbo'"));
|
||||
assert!(sql.contains("LOWER(o.name) LIKE LOWER('Temp%') ESCAPE '\\'"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sqlserver_completion_assistant_searches_columns_by_parent_table() {
|
||||
let request = CompletionAssistantRequest {
|
||||
connection_id: "c1".to_string(),
|
||||
database: "app".to_string(),
|
||||
schema: Some("dbo".to_string()),
|
||||
object_kinds: vec![CompletionAssistantObjectKind::Column],
|
||||
mask: "id".to_string(),
|
||||
case_sensitive: false,
|
||||
global_search: false,
|
||||
max_results: Some(50),
|
||||
search_in_comments: false,
|
||||
search_in_definitions: false,
|
||||
parent_schema: Some("dbo".to_string()),
|
||||
parent_name: Some("Users".to_string()),
|
||||
match_mode: Some(CompletionAssistantMatchMode::Contains),
|
||||
};
|
||||
|
||||
let sql = sqlserver_completion_assistant_sql(&request, 50);
|
||||
|
||||
assert!(sql.contains("FROM sys.columns c"));
|
||||
assert!(sql.contains("o.name = 'Users'"));
|
||||
assert!(sql.contains("LOWER(c.name) LIKE LOWER('%id%') ESCAPE '\\'"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sqlserver_completion_assistant_searches_tempdb_for_temp_table_masks() {
|
||||
let request = CompletionAssistantRequest {
|
||||
connection_id: "c1".to_string(),
|
||||
database: "app".to_string(),
|
||||
schema: Some("dbo".to_string()),
|
||||
object_kinds: vec![CompletionAssistantObjectKind::Table],
|
||||
mask: "#Temp".to_string(),
|
||||
case_sensitive: false,
|
||||
global_search: false,
|
||||
max_results: Some(100),
|
||||
search_in_comments: false,
|
||||
search_in_definitions: false,
|
||||
parent_schema: None,
|
||||
parent_name: None,
|
||||
match_mode: Some(CompletionAssistantMatchMode::Prefix),
|
||||
};
|
||||
|
||||
let sql = sqlserver_completion_assistant_sql(&request, 100);
|
||||
|
||||
assert!(sql.contains("FROM tempdb.sys.all_objects o"));
|
||||
assert!(sql.contains("o.type = 'U'"));
|
||||
assert!(sql.contains("LOWER(o.name) LIKE LOWER('#Temp%') ESCAPE '\\'"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sqlserver_completion_assistant_generates_scoped_search_masks() {
|
||||
assert_eq!(super::completion_like_pattern("Temp", Some(&CompletionAssistantMatchMode::Prefix)), "Temp%");
|
||||
assert_eq!(super::completion_like_pattern("Temp", Some(&CompletionAssistantMatchMode::Contains)), "%Temp%");
|
||||
assert_eq!(
|
||||
super::completion_like_pattern("dbo.Temp%", Some(&CompletionAssistantMatchMode::Prefix)),
|
||||
"dbo.Temp%"
|
||||
);
|
||||
assert_eq!(
|
||||
super::completion_like_pattern("Temp_Table", Some(&CompletionAssistantMatchMode::Prefix)),
|
||||
"Temp\\_Table%"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sqlserver_completion_assistant_can_search_comments_and_definitions() {
|
||||
let request = CompletionAssistantRequest {
|
||||
connection_id: "c1".to_string(),
|
||||
database: "app".to_string(),
|
||||
schema: Some("dbo".to_string()),
|
||||
object_kinds: vec![CompletionAssistantObjectKind::Procedure],
|
||||
mask: "audit".to_string(),
|
||||
case_sensitive: false,
|
||||
global_search: false,
|
||||
max_results: Some(100),
|
||||
search_in_comments: true,
|
||||
search_in_definitions: true,
|
||||
parent_schema: None,
|
||||
parent_name: None,
|
||||
match_mode: Some(CompletionAssistantMatchMode::Contains),
|
||||
};
|
||||
|
||||
let sql = sqlserver_completion_assistant_sql(&request, 100);
|
||||
|
||||
assert!(sql.contains("COALESCE(ep.value, '')"));
|
||||
assert!(sql.contains("OBJECT_DEFINITION(o.object_id)"));
|
||||
assert!(sql.contains("LOWER('%audit%')"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sqlserver_tinyint_cells_are_json_numbers() {
|
||||
assert_eq!(sqlserver_cell_to_json(&ColumnData::U8(Some(7))), serde_json::json!(7));
|
||||
|
||||
Reference in new issue
Block a user