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
fix(mysql): fall back completion metadata for incompatible servers
Guoyu Su40bfe0207411
diff --git a/crates/dbx-driver-mysql/src/mysql.rs b/crates/dbx-driver-mysql/src/mysql.rsindex 1e03c76b09..5949fe4226 100644--- a/crates/dbx-driver-mysql/src/mysql.rs+++ b/crates/dbx-driver-mysql/src/mysql.rs@@ -3142,14 +3142,16 @@ pub async fn completion_assistant_search(let pattern = mysql_completion_like_pattern(&request.mask, request.match_mode.as_ref());let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;let mut candidates = Vec::new();+ let mut compatibility = MysqlCompletionCompatibility::default();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())?;+ let rows = mysql_completion_rows(&mut conn, &mut compatibility, false, |policy| {+ mysql_completion_schemas_sql(&pattern, limit.saturating_sub(candidates.len()), policy)+ })+ .await?;for row in rows {let schema_name = get_str_by_name(&row, "schema_name");candidates.push(CompletionAssistantCandidate {@@ -3167,9 +3169,10 @@ pub async fn completion_assistant_search(}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())?;+ let rows = mysql_completion_rows(&mut conn, &mut compatibility, false, |policy| {+ mysql_completion_tables_sql(database, &pattern, &kinds, limit.saturating_sub(candidates.len()), policy)+ })+ .await?;for row in rows {let table_type = get_str_by_name(&row, "table_type");candidates.push(CompletionAssistantCandidate {@@ -3193,9 +3196,11 @@ pub async fn completion_assistant_search(}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())?;+ let remaining = limit.saturating_sub(candidates.len());+ let rows = mysql_completion_rows(&mut conn, &mut compatibility, true, |policy| {+ mysql_completion_routines_sql(database, &pattern, &kinds, remaining, policy)+ })+ .await?;for row in rows {let routine_type = get_str_by_name(&row, "routine_type");candidates.push(CompletionAssistantCandidate {@@ -3220,9 +3225,10 @@ pub async fn completion_assistant_search(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())?;+ let rows = mysql_completion_rows(&mut conn, &mut compatibility, false, |policy| {+ mysql_completion_columns_sql(database, table, &pattern, limit.saturating_sub(candidates.len()), policy)+ })+ .await?;for row in rows {candidates.push(CompletionAssistantCandidate {name: get_str_by_name(&row, "object_name"),@@ -3241,16 +3247,80 @@ pub async fn completion_assistant_search(}}- Ok(CompletionAssistantResponse { incomplete: candidates.len() >= limit, candidates, fallback_used: false })+ Ok(CompletionAssistantResponse {+ incomplete: candidates.len() >= limit,+ candidates,+ fallback_used: compatibility.omit_escape || compatibility.use_dtd_identifier,+ })+}++#[derive(Clone, Copy, Debug, Default)]+struct MysqlCompletionCompatibility {+ omit_escape: bool,+ use_dtd_identifier: bool,}-fn mysql_completion_schemas_sql(pattern: &str, limit: usize) -> String {+impl MysqlCompletionCompatibility {+ fn escape_clause(self) -> &'static str {+ if self.omit_escape {+ ""+ } else {+ " ESCAPE '\\\\'"+ }+ }++ fn retry_after(&mut self, error: &mysql_async::Error, routine: bool) -> bool {+ if !self.omit_escape && mysql_completion_escape_is_unsupported(error) {+ self.omit_escape = true;+ true+ } else if routine && !self.use_dtd_identifier && mysql_routine_data_type_is_unsupported(error) {+ self.use_dtd_identifier = true;+ true+ } else {+ false+ }+ }+}++fn mysql_completion_escape_is_unsupported(error: &mysql_async::Error) -> bool {+ let mysql_async::Error::Server(error) = error else {+ return false;+ };+ let message = error.message.to_ascii_lowercase();+ let diagnostic = message.trim().strip_prefix("errcode = 2, detailmessage =").unwrap_or(message.trim()).trim_start();+ error.code == 1105+ && error.state.eq_ignore_ascii_case("HY000")+ && diagnostic.starts_with("mismatched input 'escape' expecting ")+}++async fn mysql_completion_rows(+ conn: &mut mysql_async::Conn,+ compatibility: &mut MysqlCompletionCompatibility,+ routine: bool,+ build_sql: impl Fn(MysqlCompletionCompatibility) -> String,+) -> Result<Vec<mysql_async::Row>, String> {+ // Each flag can change only once: at most three attempts for routines,+ // two for other kinds. Share the discovered ESCAPE policy in this request.+ loop {+ let sql = build_sql(*compatibility);+ match conn.query_iter(&sql).await {+ Ok(result) => return result.collect_and_drop().await.map_err(|error| error.to_string()),+ Err(error) if compatibility.retry_after(&error, routine) => {+ log::debug!("Retrying MySQL completion with compatible catalog syntax: {error}");+ }+ Err(error) => return Err(error.to_string()),+ }+ }+}++fn mysql_completion_schemas_sql(pattern: &str, limit: usize, policy: MysqlCompletionCompatibility) -> String {format!("SELECT SCHEMA_NAME AS schema_name \FROM information_schema.SCHEMATA \- WHERE SCHEMA_NAME LIKE {} ESCAPE '\\\\' \+ WHERE SCHEMA_NAME LIKE {}{} \ORDER BY SCHEMA_NAME LIMIT {}",quote_value(pattern),+ policy.escape_clause(),limit,)}@@ -3260,15 +3330,17 @@ fn mysql_completion_tables_sql(pattern: &str,kinds: &[CompletionAssistantObjectKind],limit: usize,+ policy: MysqlCompletionCompatibility,) -> 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}) \+ 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),+ escape = policy.escape_clause(),table_types = table_types,limit = limit,)@@ -3279,29 +3351,48 @@ fn mysql_completion_routines_sql(pattern: &str,kinds: &[CompletionAssistantObjectKind],limit: usize,+ policy: MysqlCompletionCompatibility,) -> String {let routine_types = mysql_completion_routine_types(kinds);+ let data_type_column = if policy.use_dtd_identifier { "DTD_IDENTIFIER" } else { "DATA_TYPE" };format!(- "SELECT ROUTINE_NAME AS object_name, ROUTINE_TYPE AS routine_type, ROUTINE_COMMENT AS object_comment, DATA_TYPE AS data_type \+ "SELECT ROUTINE_NAME AS object_name, ROUTINE_TYPE AS routine_type, ROUTINE_COMMENT AS object_comment, {data_type_column} AS data_type \FROM information_schema.ROUTINES \- WHERE ROUTINE_SCHEMA = {db} AND ROUTINE_NAME LIKE {pattern} ESCAPE '\\\\' AND ROUTINE_TYPE IN ({routine_types}) \+ 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),+ escape = policy.escape_clause(),routine_types = routine_types,limit = limit,)}-fn mysql_completion_columns_sql(database: &str, table: &str, pattern: &str, limit: usize) -> String {+fn mysql_routine_data_type_is_unsupported(error: &mysql_async::Error) -> bool {+ let mysql_async::Error::Server(error) = error else {+ return false;+ };+ let missing_column = (error.code == 1054 && error.state.eq_ignore_ascii_case("42S22"))+ || (error.code == 1105 && error.state.eq_ignore_ascii_case("HY000"));+ missing_column && error.message.to_ascii_lowercase().contains("unknown column 'data_type' in ")+}++fn mysql_completion_columns_sql(+ database: &str,+ table: &str,+ pattern: &str,+ limit: usize,+ policy: MysqlCompletionCompatibility,+) -> 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 '\\\\' \+ 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),+ escape = policy.escape_clause(),limit = limit,)}@@ -7955,6 +8046,68 @@ mod tests {);}+ #[test]+ fn mysql_completion_routine_fallback_preserves_filters_and_escaping() {+ for kinds in [+ vec![CompletionAssistantObjectKind::Routine],+ vec![CompletionAssistantObjectKind::Function],+ vec![CompletionAssistantObjectKind::Procedure],+ ] {+ let primary = mysql_completion_routines_sql(+ "DATA_TYPE'app",+ "json\\_extract%",+ &kinds,+ 17,+ MysqlCompletionCompatibility::default(),+ );+ let fallback = mysql_completion_routines_sql(+ "DATA_TYPE'app",+ "json\\_extract%",+ &kinds,+ 17,+ MysqlCompletionCompatibility { use_dtd_identifier: true, ..Default::default() },+ );+ assert_eq!(fallback, primary.replacen("DATA_TYPE AS data_type", "DTD_IDENTIFIER AS data_type", 1));+ assert!(fallback.contains("ROUTINE_SCHEMA = 'DATA_TYPE\\'app'"));+ assert!(fallback.contains("ORDER BY ROUTINE_NAME LIMIT 17"));+ assert!(fallback.contains("ROUTINE_NAME LIKE 'json\\\\_extract%' ESCAPE '\\\\'"));+ }+ }++ #[test]+ fn mysql_completion_routine_fallback_requires_precise_missing_column_diagnostic() {+ let cases = [+ (1054, "42S22", "Unknown column 'DATA_TYPE' in 'field list'", true),+ (+ 1105,+ "HY000",+ "errCode = 2, detailMessage = Unknown column 'DATA_TYPE' in 'table list' in PROJECT clause",+ true,+ ),+ (1105, "HY000", "Unknown column 'data_type' in 'table list' in PROJECT clause", true),+ (1054, "42S22", "Unknown column 'ROUTINE_COMMENT' in 'field list'", false),+ (1054, "42S22", "Unknown column 'DATA_TYPE_EXTRA' in 'field list'", false),+ (1054, "42S22", "Unknown column 'DTD_IDENTIFIER' in 'field list'", false),+ (1105, "HY000", "Access denied to column DATA_TYPE", false),+ (1105, "HY000", "Unknown table 'DATA_TYPE'", false),+ (1105, "HY000", "DATA_TYPE not available", false),+ (1105, "HY000", "connection timed out", false),+ (1142, "42000", "Unknown column 'DATA_TYPE' in 'field list'", false),+ (1105, "42000", "Unknown column 'DATA_TYPE' in 'field list'", false),+ (1054, "HY000", "Unknown column 'DATA_TYPE' in 'field list'", false),+ ];+ for (code, state, message, expected) in cases {+ let error = mysql_async::Error::Server(mysql_async::ServerError {+ code,+ state: state.into(),+ message: message.into(),+ });+ assert_eq!(mysql_routine_data_type_is_unsupported(&error), expected, "{error}");+ }+ let error = mysql_async::Error::from(std::io::Error::new(std::io::ErrorKind::TimedOut, "query timed out"));+ assert!(!mysql_routine_data_type_is_unsupported(&error));+ }+#[test]fn mysql_completion_sql_filters_before_limit() {let table_sql = mysql_completion_tables_sql(@@ -7962,10 +8115,17 @@ mod tests {"Temp%",&[CompletionAssistantObjectKind::Table, CompletionAssistantObjectKind::View],100,+ MysqlCompletionCompatibility::default(),+ );+ let routine_sql = mysql_completion_routines_sql(+ "app",+ "%audit%",+ &[CompletionAssistantObjectKind::Routine],+ 50,+ MysqlCompletionCompatibility::default(),);- let routine_sql =- mysql_completion_routines_sql("app", "%audit%", &[CompletionAssistantObjectKind::Routine], 50);- let column_sql = mysql_completion_columns_sql("app", "users", "id%", 25);+ let column_sql =+ mysql_completion_columns_sql("app", "users", "id%", 25, MysqlCompletionCompatibility::default());assert!(table_sql.contains("TABLE_NAME LIKE 'Temp%' ESCAPE '\\\\'"));assert!(table_sql.contains("TABLE_TYPE IN ('BASE TABLE','SYSTEM VERSIONED','VIEW')"));@@ -7976,6 +8136,89 @@ mod tests {assert!(column_sql.contains("ORDER BY ORDINAL_POSITION LIMIT 25"));}+ fn completion_server_error(code: u16, state: &str, message: &str) -> mysql_async::Error {+ mysql_async::Error::Server(mysql_async::ServerError { code, state: state.into(), message: message.into() })+ }++ #[test]+ fn mysql_completion_escape_fallback_requires_precise_parser_diagnostic() {+ for (code, state, message, expected) in [+ (+ 1105,+ "HY000",+ "errCode = 2, detailMessage = mismatched input 'ESCAPE' expecting {<EOF>, ';'}(line 4, pos 32)",+ true,+ ),+ (1105, "hy000", "mismatched input 'escape' expecting <EOF>", true),+ (1064, "HY000", "mismatched input 'ESCAPE' expecting <EOF>", false),+ (1105, "42000", "mismatched input 'ESCAPE' expecting <EOF>", false),+ (1105, "HY000", "mismatched input 'ESCAPED' expecting <EOF>", false),+ (1105, "HY000", "mismatched input 'LIMIT' expecting ESCAPE", false),+ (1105, "HY000", "Unknown column 'ESCAPE' in 'field list'", false),+ (1105, "HY000", "Access denied to ESCAPE", false),+ (1105, "HY000", "query failed: SELECT 'mismatched input \'ESCAPE\' expecting <EOF>'", false),+ ] {+ let error = completion_server_error(code, state, message);+ assert_eq!(mysql_completion_escape_is_unsupported(&error), expected, "{error}");+ }+ let error = mysql_async::Error::from(std::io::Error::new(std::io::ErrorKind::TimedOut, "ESCAPE"));+ assert!(!mysql_completion_escape_is_unsupported(&error));+ }++ #[test]+ fn mysql_completion_retries_are_bounded_in_both_error_orders() {+ let escape = completion_server_error(1105, "HY000", "mismatched input 'ESCAPE' expecting <EOF>");+ let data_type = completion_server_error(1105, "HY000", "Unknown column 'DATA_TYPE' in 'table list'");+ let unrelated = completion_server_error(1105, "HY000", "Access denied");+ for errors in [[&escape, &data_type], [&data_type, &escape]] {+ let mut policy = MysqlCompletionCompatibility::default();+ let mut attempts = 1;+ for error in errors {+ assert!(policy.retry_after(error, true));+ attempts += 1;+ assert!(!policy.retry_after(error, true), "same rejected capability must not retry twice");+ }+ assert_eq!(attempts, 3);+ assert!(policy.omit_escape && policy.use_dtd_identifier);+ assert!(!policy.retry_after(&escape, true));+ assert!(!policy.retry_after(&data_type, true));+ assert!(!policy.retry_after(&unrelated, true));+ // Later candidate kinds inherit ESCAPE handling within the request.+ assert!(!policy.retry_after(&escape, false));+ }+ let mut policy = MysqlCompletionCompatibility::default();+ assert!(!policy.retry_after(&data_type, false), "column metadata must not use routine fallback");+ assert!(!policy.retry_after(&unrelated, true));+ assert!(policy.retry_after(&escape, false));+ assert!(!policy.retry_after(&escape, false));+ assert!(!policy.use_dtd_identifier);+ }++ #[test]+ fn mysql_completion_implicit_escape_preserves_all_builder_filters_and_patterns() {+ let pattern = mysql_completion_like_pattern("a_b%c\\d'ESCAPE", None);+ assert_eq!(pattern, "a\\_b\\%c\\\\d'ESCAPE%");+ let kinds = [CompletionAssistantObjectKind::Table, CompletionAssistantObjectKind::Routine];+ let build = |policy| {+ [+ mysql_completion_schemas_sql(&pattern, 7, policy),+ mysql_completion_tables_sql("db'ESCAPE", &pattern, &kinds, 7, policy),+ mysql_completion_routines_sql("db'ESCAPE", &pattern, &kinds, 7, policy),+ mysql_completion_columns_sql("db'ESCAPE", "t'ESCAPE", &pattern, 7, policy),+ ]+ };+ for dtd in [false, true] {+ let primary = MysqlCompletionCompatibility { use_dtd_identifier: dtd, ..Default::default() };+ let implicit = MysqlCompletionCompatibility { omit_escape: true, ..primary };+ for (original, compatible) in build(primary).into_iter().zip(build(implicit)) {+ assert_eq!(original.matches(primary.escape_clause()).count(), 1);+ assert_eq!(compatible, original.replacen(primary.escape_clause(), "", 1));+ assert!(compatible.contains("e_value(&pattern)));+ assert!(compatible.ends_with("LIMIT 7"));+ }+ }+ }+#[test]fn mysql_columns_sql_uses_column_key_for_primary_keys_without_join() {let sql = columns_sql("app", "users");diff --git a/crates/dbx-drivers/tests/live_mysql_routine_completion.rs b/crates/dbx-drivers/tests/live_mysql_routine_completion.rsnew file mode 100644index 0000000000..9af30491fa--- /dev/null+++ b/crates/dbx-drivers/tests/live_mysql_routine_completion.rs@@ -0,0 +1,75 @@+//! Read-only tests against explicitly configured disposable fixtures.+//! Doris is related-engine evidence, not an exact SelectDB 3.0.11 reproduction.+use dbx_drivers::db::mysql;+use dbx_drivers::types::{CompletionAssistantObjectKind, CompletionAssistantRequest};+use serde_json::json;+use std::time::Duration;++fn request(database: &str, mask: &str, kinds: &[&str], limit: usize) -> CompletionAssistantRequest {+ serde_json::from_value(json!({+ "connection_id": "live-routine-completion", "database": database, "schema": database,+ "object_kinds": kinds, "mask": mask, "max_results": limit, "match_mode": "prefix"+ }))+ .unwrap()+}++#[tokio::test]+#[ignore = "requires DBX_LIVE_DORIS_ROUTINES_URL and DATABASE with probe_table fixture on Doris lacking ROUTINES.DATA_TYPE"]+async fn live_doris_routine_completion_preserves_mixed_table_results() {+ let url = std::env::var("DBX_LIVE_DORIS_ROUTINES_URL").expect("DBX_LIVE_DORIS_ROUTINES_URL");+ let database = std::env::var("DBX_LIVE_DORIS_ROUTINES_DATABASE").expect("DBX_LIVE_DORIS_ROUTINES_DATABASE");+ // Doris does not accept MySQL-specific session initialization (for example+ // GROUP_CONCAT setup); test the shared metadata query over its bare protocol.+ let pool = mysql::connect_bare(&url, Duration::from_secs(15)).await.unwrap();+ let baseline = mysql::execute_query(&pool, "SELECT DATA_TYPE FROM information_schema.ROUTINES", false)+ .await+ .expect_err("fixture must lack DATA_TYPE to exercise the compatibility path");+ assert!(baseline.contains("Unknown column 'DATA_TYPE'"), "{baseline}");+ let mut query = request(&database, "probe", &["table", "function"], 200);+ let mixed = mysql::completion_assistant_search(&pool, &query).await.unwrap();+ assert!(mixed.fallback_used);+ assert!(!mixed.incomplete);+ assert!(mixed.candidates.iter().any(|candidate| candidate.name == "probe_table"));+ query.object_kinds = vec![CompletionAssistantObjectKind::Function];+ let routines = mysql::completion_assistant_search(&pool, &query).await.unwrap();+ assert!(routines.fallback_used);+ assert!(routines.candidates.is_empty());+ query.object_kinds = vec![CompletionAssistantObjectKind::Table, CompletionAssistantObjectKind::Function];+ query.max_results = Some(1);+ let limited = mysql::completion_assistant_search(&pool, &query).await.unwrap();+ assert_eq!(limited.candidates.len(), 1);+ assert!(limited.incomplete);+ assert!(!limited.fallback_used, "filled table limit must skip routine query");+ let schemas =+ mysql::completion_assistant_search(&pool, &request(&database, &database, &["schema"], 200)).await.unwrap();+ assert!(schemas.candidates.iter().any(|candidate| candidate.name == database));+ assert!(!schemas.fallback_used, "this Doris fixture accepts explicit ESCAPE");+ let mut columns = request(&database, "id", &["column"], 200);+ columns.parent_name = Some("probe_table".into());+ let columns = mysql::completion_assistant_search(&pool, &columns).await.unwrap();+ assert!(columns.candidates.iter().any(|candidate| candidate.name == "id"));+ assert!(!columns.fallback_used);+ pool.disconnect().await.unwrap();+}++#[tokio::test]+#[ignore = "requires DBX_LIVE_MYSQL_ROUTINES_URL and DATABASE with dbx_probe_fn(INT) RETURNS INT fixture"]+async fn live_mysql_routine_completion_keeps_primary_base_type() {+ let url = std::env::var("DBX_LIVE_MYSQL_ROUTINES_URL").expect("DBX_LIVE_MYSQL_ROUTINES_URL");+ let database = std::env::var("DBX_LIVE_MYSQL_ROUTINES_DATABASE").expect("DBX_LIVE_MYSQL_ROUTINES_DATABASE");+ let pool = mysql::connect(&url, Duration::from_secs(15)).await.unwrap();+ let query = request(&database, "dbx_probe_", &["function"], 200);+ let response = mysql::completion_assistant_search(&pool, &query).await.unwrap();+ assert!(!response.fallback_used);+ let function = response.candidates.iter().find(|candidate| candidate.name == "dbx_probe_fn").unwrap();+ assert_eq!(function.data_type.as_deref(), Some("int"));+ assert_eq!(function.schema.as_deref(), Some(database.as_str()));+ let mixed =+ mysql::completion_assistant_search(&pool, &request(&database, "%", &["schema", "table", "function"], 1000))+ .await+ .unwrap();+ assert!(!mixed.fallback_used);+ assert!(mixed.candidates.iter().any(|candidate| candidate.name == database));+ assert!(mixed.candidates.iter().any(|candidate| candidate.name == "dbx_probe_fn"));+ pool.disconnect().await.unwrap();+}