fix(mysql): restore table fallback for proxy metadata
This commit is contained in:
1 parent
72083b476f
commit
7053609adc
1 file changed
+368
-49
+368
-49
@@ -1598,7 +1598,7 @@ pub async fn list_tables_filtered(
|
||||
log::debug!(
|
||||
"Falling back to SHOW TABLES for database `{database}` after information_schema.TABLES failed: {err}"
|
||||
);
|
||||
return list_tables_show(pool, database)
|
||||
return list_tables_show_filtered(pool, database, filter)
|
||||
.await
|
||||
.map(|tables| filter_list_tables_fallback(tables, filter, limit, offset, object_types));
|
||||
}
|
||||
@@ -1621,9 +1621,9 @@ pub async fn list_tables_filtered(
|
||||
})
|
||||
.collect();
|
||||
|
||||
if tables.is_empty() && should_fallback_empty_list_tables(filter) {
|
||||
if tables.is_empty() {
|
||||
log::debug!("Falling back to SHOW TABLES for database `{database}` after information_schema.TABLES returned no named tables");
|
||||
return list_tables_show(pool, database)
|
||||
return list_tables_show_filtered(pool, database, filter)
|
||||
.await
|
||||
.map(|tables| filter_list_tables_fallback(tables, filter, limit, offset, object_types));
|
||||
}
|
||||
@@ -1631,13 +1631,6 @@ pub async fn list_tables_filtered(
|
||||
Ok(tables)
|
||||
}
|
||||
|
||||
fn should_fallback_empty_list_tables(filter: Option<&str>) -> bool {
|
||||
// MySQL proxies such as MyCat can return an empty information_schema.TABLES
|
||||
// even when SHOW TABLES exposes objects. Avoid the fallback for active
|
||||
// searches so normal MySQL "no match" queries do not rescan large schemas.
|
||||
filter.is_none_or(|filter| filter.trim().is_empty())
|
||||
}
|
||||
|
||||
fn filter_list_tables_fallback(
|
||||
tables: Vec<TableInfo>,
|
||||
filter: Option<&str>,
|
||||
@@ -1980,11 +1973,33 @@ struct TableStatusMeta {
|
||||
}
|
||||
|
||||
async fn list_table_status_show(pool: &MySqlPool, database: &str) -> Result<HashMap<String, TableStatusMeta>, String> {
|
||||
let sql = if database.trim().is_empty() {
|
||||
"SHOW TABLE STATUS".to_string()
|
||||
} else {
|
||||
format!("SHOW TABLE STATUS FROM {}", quote_identifier(database))
|
||||
};
|
||||
query_table_status_show(pool, database, None).await
|
||||
}
|
||||
|
||||
async fn list_table_status_show_filtered(
|
||||
pool: &MySqlPool,
|
||||
database: &str,
|
||||
filter: Option<&str>,
|
||||
) -> Result<HashMap<String, TableStatusMeta>, String> {
|
||||
match query_table_status_show(pool, database, filter).await {
|
||||
Ok(status) => Ok(status),
|
||||
Err(filtered_err) => {
|
||||
log::debug!(
|
||||
"Falling back to unfiltered SHOW TABLE STATUS for database `{database}` after filtered SHOW failed: {filtered_err}"
|
||||
);
|
||||
query_table_status_show(pool, database, None)
|
||||
.await
|
||||
.map(|status| filter_table_status_fallback(status, filter))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn query_table_status_show(
|
||||
pool: &MySqlPool,
|
||||
database: &str,
|
||||
filter: Option<&str>,
|
||||
) -> Result<HashMap<String, TableStatusMeta>, String> {
|
||||
let sql = show_table_status_sql(database, filter);
|
||||
let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
|
||||
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())?;
|
||||
@@ -2006,17 +2021,53 @@ async fn list_table_status_show(pool: &MySqlPool, database: &str) -> Result<Hash
|
||||
.collect())
|
||||
}
|
||||
|
||||
fn filter_table_status_fallback(
|
||||
status: HashMap<String, TableStatusMeta>,
|
||||
filter: Option<&str>,
|
||||
) -> HashMap<String, TableStatusMeta> {
|
||||
let filter = filter.unwrap_or("").trim();
|
||||
status
|
||||
.into_iter()
|
||||
.filter(|(name, meta)| {
|
||||
crate::sql::contains_or_fuzzy_match(name, filter)
|
||||
|| meta.comment.as_deref().is_some_and(|comment| crate::sql::contains_or_fuzzy_match(comment, filter))
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
async fn list_table_names_show(pool: &MySqlPool, database: &str) -> Result<Vec<TableInfo>, String> {
|
||||
let sql = show_tables_sql(database, true);
|
||||
list_table_names_show_filtered(pool, database, None, &[]).await
|
||||
}
|
||||
|
||||
async fn list_table_names_show_filtered(
|
||||
pool: &MySqlPool,
|
||||
database: &str,
|
||||
filter: Option<&str>,
|
||||
exact_names: &[String],
|
||||
) -> Result<Vec<TableInfo>, String> {
|
||||
let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
|
||||
let rows: Vec<mysql_async::Row> = match conn.query_iter(&sql).await {
|
||||
Ok(result) => result.collect_and_drop().await.map_err(|e| e.to_string())?,
|
||||
Err(_) => {
|
||||
let sql = show_tables_sql(database, false);
|
||||
let result = conn.query_iter(&sql).await.map_err(|e| e.to_string())?;
|
||||
result.collect_and_drop().await.map_err(|e| e.to_string())?
|
||||
let mut last_error = None;
|
||||
let mut rows = None;
|
||||
for attempt in show_tables_query_attempts(database, filter, exact_names) {
|
||||
match conn.query_iter(&attempt.sql).await {
|
||||
Ok(result) => match result.collect_and_drop::<mysql_async::Row>().await {
|
||||
Ok(result_rows) => {
|
||||
rows = Some(result_rows);
|
||||
break;
|
||||
}
|
||||
Err(err) => last_error = Some(err.to_string()),
|
||||
},
|
||||
Err(err) => {
|
||||
if attempt.server_filtered {
|
||||
log::debug!(
|
||||
"Filtered SHOW TABLES is unsupported for database `{database}`; trying a compatible SHOW form: {err}"
|
||||
);
|
||||
}
|
||||
last_error = Some(err.to_string());
|
||||
}
|
||||
}
|
||||
};
|
||||
}
|
||||
let rows = rows.ok_or_else(|| last_error.unwrap_or_else(|| "SHOW TABLES returned no result".to_string()))?;
|
||||
let mut tables: Vec<TableInfo> = rows
|
||||
.iter()
|
||||
.filter_map(|row| {
|
||||
@@ -2038,13 +2089,99 @@ async fn list_table_names_show(pool: &MySqlPool, database: &str) -> Result<Vec<T
|
||||
Ok(tables)
|
||||
}
|
||||
|
||||
fn show_tables_sql(database: &str, full: bool) -> String {
|
||||
struct ShowTablesQueryAttempt {
|
||||
sql: String,
|
||||
server_filtered: bool,
|
||||
}
|
||||
|
||||
fn show_tables_query_attempts(
|
||||
database: &str,
|
||||
filter: Option<&str>,
|
||||
exact_names: &[String],
|
||||
) -> Vec<ShowTablesQueryAttempt> {
|
||||
// DBeaver-style server filtering is preferred for large schemas, but some
|
||||
// MySQL proxies only implement bare SHOW TABLES forms.
|
||||
let filtered_full = show_tables_filtered_sql(database, true, filter, exact_names);
|
||||
let filtered_plain = show_tables_filtered_sql(database, false, filter, exact_names);
|
||||
let unfiltered_full = show_tables_filtered_sql(database, true, None, &[]);
|
||||
let unfiltered_plain = show_tables_filtered_sql(database, false, None, &[]);
|
||||
let has_server_filter = filtered_full != unfiltered_full;
|
||||
let mut attempts = Vec::with_capacity(if has_server_filter { 4 } else { 2 });
|
||||
if has_server_filter {
|
||||
attempts.push(ShowTablesQueryAttempt { sql: filtered_full, server_filtered: true });
|
||||
attempts.push(ShowTablesQueryAttempt { sql: filtered_plain, server_filtered: true });
|
||||
}
|
||||
attempts.push(ShowTablesQueryAttempt { sql: unfiltered_full, server_filtered: false });
|
||||
attempts.push(ShowTablesQueryAttempt { sql: unfiltered_plain, server_filtered: false });
|
||||
attempts
|
||||
}
|
||||
|
||||
fn show_tables_filtered_sql(database: &str, full: bool, filter: Option<&str>, exact_names: &[String]) -> String {
|
||||
let prefix = if full { "SHOW FULL TABLES" } else { "SHOW TABLES" };
|
||||
if database.trim().is_empty() {
|
||||
let mut sql = if database.trim().is_empty() {
|
||||
prefix.to_string()
|
||||
} else {
|
||||
format!("{prefix} FROM {}", quote_identifier(database))
|
||||
};
|
||||
let conditions = show_tables_filter_conditions(database, filter, exact_names);
|
||||
if !conditions.is_empty() {
|
||||
sql.push_str(" WHERE ");
|
||||
sql.push_str(&conditions.join(" OR "));
|
||||
}
|
||||
sql
|
||||
}
|
||||
|
||||
fn show_table_status_sql(database: &str, filter: Option<&str>) -> String {
|
||||
let mut sql = if database.trim().is_empty() {
|
||||
"SHOW TABLE STATUS".to_string()
|
||||
} else {
|
||||
format!("SHOW TABLE STATUS FROM {}", quote_identifier(database))
|
||||
};
|
||||
if let Some(filter) = filter.map(str::trim).filter(|filter| !filter.is_empty()) {
|
||||
let patterns = mysql_fallback_like_patterns(filter);
|
||||
let conditions = patterns
|
||||
.iter()
|
||||
.flat_map(|pattern| {
|
||||
[
|
||||
format!("Name LIKE {} ESCAPE '\\\\'", quote_value(pattern)),
|
||||
format!("Comment LIKE {} ESCAPE '\\\\'", quote_value(pattern)),
|
||||
]
|
||||
})
|
||||
.collect::<Vec<_>>();
|
||||
sql.push_str(" WHERE ");
|
||||
sql.push_str(&conditions.join(" OR "));
|
||||
}
|
||||
sql
|
||||
}
|
||||
|
||||
fn show_tables_filter_conditions(database: &str, filter: Option<&str>, exact_names: &[String]) -> Vec<String> {
|
||||
if database.trim().is_empty() {
|
||||
// Catalogless services do not expose a stable Tables_in_<db> column name.
|
||||
// Preserve the existing compatible SHOW syntax; local filtering still
|
||||
// guarantees correctness for these uncommon endpoints.
|
||||
return Vec::new();
|
||||
}
|
||||
let table_name_column = quote_identifier(&format!("Tables_in_{database}"));
|
||||
let mut conditions = filter
|
||||
.map(str::trim)
|
||||
.filter(|filter| !filter.is_empty())
|
||||
.into_iter()
|
||||
.flat_map(mysql_fallback_like_patterns)
|
||||
.map(|pattern| format!("{table_name_column} LIKE {} ESCAPE '\\\\'", quote_value(&pattern)))
|
||||
.collect::<Vec<_>>();
|
||||
conditions.extend(exact_names.iter().map(|name| format!("{table_name_column} = {}", quote_value(name))));
|
||||
conditions
|
||||
}
|
||||
|
||||
fn mysql_fallback_like_patterns(filter: &str) -> Vec<String> {
|
||||
let escaped = filter.replace('\\', "\\\\").replace('%', "\\%").replace('_', "\\_");
|
||||
let mut patterns = vec![format!("%{escaped}%")];
|
||||
if crate::sql::fuzzy_filter_enabled(filter) {
|
||||
patterns.push(crate::sql::fuzzy_like_pattern_with_escape(filter, |value| {
|
||||
value.replace('\\', "\\\\").replace('%', "\\%").replace('_', "\\_")
|
||||
}));
|
||||
}
|
||||
patterns
|
||||
}
|
||||
|
||||
async fn list_tables_show_with_status(
|
||||
@@ -2068,6 +2205,35 @@ async fn list_tables_show_with_status(
|
||||
Ok((tables, status))
|
||||
}
|
||||
|
||||
async fn list_tables_show_filtered(
|
||||
pool: &MySqlPool,
|
||||
database: &str,
|
||||
filter: Option<&str>,
|
||||
) -> Result<Vec<TableInfo>, String> {
|
||||
if filter.is_none_or(|filter| filter.trim().is_empty()) {
|
||||
return list_tables_show(pool, database).await;
|
||||
}
|
||||
|
||||
let status = match list_table_status_show_filtered(pool, database, filter).await {
|
||||
Ok(status) => status,
|
||||
Err(err) => {
|
||||
log::warn!("Skipping filtered table status for database `{}`: {}", database, err);
|
||||
HashMap::new()
|
||||
}
|
||||
};
|
||||
let exact_names = status.keys().cloned().collect::<Vec<_>>();
|
||||
// DBeaver also uses SHOW FULL TABLES with server-side WHERE/LIKE filtering.
|
||||
// Keeping the filter on the SHOW query avoids turning a normal empty search
|
||||
// into an unbounded scan while preserving TABLE/VIEW classification.
|
||||
let mut tables = list_table_names_show_filtered(pool, database, filter, &exact_names).await?;
|
||||
for table in &mut tables {
|
||||
if let Some(meta) = status.get(&table.name) {
|
||||
table.comment = meta.comment.clone();
|
||||
}
|
||||
}
|
||||
Ok(tables)
|
||||
}
|
||||
|
||||
pub async fn list_tables_show(pool: &MySqlPool, database: &str) -> Result<Vec<TableInfo>, String> {
|
||||
list_tables_show_with_status(pool, database).await.map(|(tables, _)| tables)
|
||||
}
|
||||
@@ -2138,6 +2304,14 @@ fn requested_object_type(object_types: Option<&[String]>, object_type: &str) ->
|
||||
})
|
||||
}
|
||||
|
||||
fn wants_table_objects(object_types: Option<&[String]>) -> bool {
|
||||
requested_object_type(object_types, "TABLE") || requested_object_type(object_types, "VIEW")
|
||||
}
|
||||
|
||||
fn wants_routine_objects(object_types: Option<&[String]>) -> bool {
|
||||
requested_object_type(object_types, "PROCEDURE") || requested_object_type(object_types, "FUNCTION")
|
||||
}
|
||||
|
||||
fn sql_pagination(limit: Option<usize>, offset: Option<usize>) -> String {
|
||||
limit.map_or_else(String::new, |limit| format!(" LIMIT {limit} OFFSET {}", offset.unwrap_or(0)))
|
||||
}
|
||||
@@ -2260,36 +2434,49 @@ pub async fn list_objects(
|
||||
offset: Option<usize>,
|
||||
) -> Result<PagedObjectList, String> {
|
||||
let mut conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
|
||||
let wants_tables = requested_object_type(object_types, "TABLE") || requested_object_type(object_types, "VIEW");
|
||||
let wants_routines =
|
||||
requested_object_type(object_types, "PROCEDURE") || requested_object_type(object_types, "FUNCTION");
|
||||
let wants_tables = wants_table_objects(object_types);
|
||||
let wants_routines = wants_routine_objects(object_types);
|
||||
let paging_applied = limit.is_some() && object_query_supports_paging(object_types);
|
||||
let (query_limit, query_offset) = if paging_applied { (limit, offset) } else { (None, None) };
|
||||
let mut objects = Vec::new();
|
||||
|
||||
if wants_tables {
|
||||
let tables_sql = list_tables_objects_sql(database, object_types, query_limit, query_offset);
|
||||
let result = match conn.query_iter(&tables_sql).await {
|
||||
Ok(result) => result,
|
||||
let table_rows = match conn.query_iter(&tables_sql).await {
|
||||
Ok(result) => match result.collect_and_drop::<mysql_async::Row>().await {
|
||||
Ok(rows) if !rows.is_empty() => Some(rows),
|
||||
Ok(_) => {
|
||||
log::debug!(
|
||||
"Falling back to SHOW TABLES for object browser database `{database}` after information_schema.TABLES returned no named tables"
|
||||
);
|
||||
None
|
||||
}
|
||||
Err(err) => {
|
||||
log::debug!(
|
||||
"Falling back to SHOW TABLES for object browser database `{database}` after information_schema.TABLES rows failed: {err}"
|
||||
);
|
||||
None
|
||||
}
|
||||
},
|
||||
Err(err) => {
|
||||
log::debug!(
|
||||
"Falling back to SHOW TABLES for object browser database `{database}` after information_schema.TABLES failed: {err}"
|
||||
);
|
||||
return list_table_objects_show(pool, database)
|
||||
.await
|
||||
.map(|objects| PagedObjectList { objects, paging_applied: false });
|
||||
None
|
||||
}
|
||||
};
|
||||
let table_rows: Vec<mysql_async::Row> = result.collect_and_drop().await.map_err(|e| e.to_string())?;
|
||||
if table_rows.is_empty() && !wants_routines {
|
||||
log::debug!(
|
||||
"Falling back to SHOW TABLES for object browser database `{database}` after information_schema.TABLES returned no named tables"
|
||||
if let Some(table_rows) = table_rows {
|
||||
objects.extend(table_rows.iter().map(|row| row_to_object(row, database)));
|
||||
} else {
|
||||
drop(conn);
|
||||
objects.extend(
|
||||
list_table_objects_show_filtered(pool, database, object_types, query_limit, query_offset).await?,
|
||||
);
|
||||
return list_table_objects_show(pool, database)
|
||||
.await
|
||||
.map(|objects| PagedObjectList { objects, paging_applied: false });
|
||||
if !wants_routines {
|
||||
return Ok(PagedObjectList { objects, paging_applied });
|
||||
}
|
||||
conn = get_conn_with_timeout(pool, super::connection_timeout()).await?;
|
||||
}
|
||||
objects.extend(table_rows.iter().map(|row| row_to_object(row, database)));
|
||||
}
|
||||
|
||||
// Routines are queried separately: some MySQL-compatible servers (sharding proxies,
|
||||
@@ -2354,6 +2541,33 @@ pub async fn list_table_objects_show(pool: &MySqlPool, database: &str) -> Result
|
||||
Ok(objects)
|
||||
}
|
||||
|
||||
async fn list_table_objects_show_filtered(
|
||||
pool: &MySqlPool,
|
||||
database: &str,
|
||||
object_types: Option<&[String]>,
|
||||
limit: Option<usize>,
|
||||
offset: Option<usize>,
|
||||
) -> Result<Vec<ObjectInfo>, String> {
|
||||
let (tables, status) = list_tables_show_with_status(pool, database).await?;
|
||||
Ok(filter_table_objects_fallback(table_infos_to_objects(tables, &status, database), object_types, limit, offset))
|
||||
}
|
||||
|
||||
fn filter_table_objects_fallback(
|
||||
objects: Vec<ObjectInfo>,
|
||||
object_types: Option<&[String]>,
|
||||
limit: Option<usize>,
|
||||
offset: Option<usize>,
|
||||
) -> Vec<ObjectInfo> {
|
||||
let wants_table = requested_object_type(object_types, "TABLE");
|
||||
let wants_view = requested_object_type(object_types, "VIEW");
|
||||
objects
|
||||
.into_iter()
|
||||
.filter(|object| if object.object_type.eq_ignore_ascii_case("VIEW") { wants_view } else { wants_table })
|
||||
.skip(offset.unwrap_or(0))
|
||||
.take(limit.unwrap_or(usize::MAX))
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub async fn list_starrocks_table_objects(pool: &MySqlPool, database: &str) -> Result<Vec<ObjectInfo>, String> {
|
||||
let (tables, routines) =
|
||||
tokio::join!(list_starrocks_tables_with_status(pool, database), list_routine_objects(pool, database));
|
||||
@@ -3999,6 +4213,21 @@ mod tests {
|
||||
use crate::db::connection_timeout;
|
||||
use mysql_async::consts::ColumnFlags;
|
||||
|
||||
fn mysql_test_object(name: &str, object_type: &str) -> ObjectInfo {
|
||||
ObjectInfo {
|
||||
name: name.to_string(),
|
||||
object_type: object_type.to_string(),
|
||||
schema: Some("app".to_string()),
|
||||
valid: None,
|
||||
signature: None,
|
||||
comment: None,
|
||||
created_at: None,
|
||||
updated_at: None,
|
||||
parent_schema: None,
|
||||
parent_name: None,
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytes_to_string_reuses_valid_utf8_and_falls_back_lossy() {
|
||||
assert_eq!(super::bytes_to_string_lossy("héllo 世界".as_bytes().to_vec()), "héllo 世界");
|
||||
@@ -4233,11 +4462,60 @@ mod tests {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mysql_empty_list_tables_fallback_allows_sidebar_paging_and_type_filters() {
|
||||
assert!(should_fallback_empty_list_tables(None));
|
||||
assert!(should_fallback_empty_list_tables(Some("")));
|
||||
assert!(should_fallback_empty_list_tables(Some(" ")));
|
||||
assert!(!should_fallback_empty_list_tables(Some("missing")));
|
||||
fn mysql_filtered_show_fallback_is_server_bounded() {
|
||||
let tables_sql = show_tables_filtered_sql("app", true, Some("missing_%"), &[]);
|
||||
let status_sql = show_table_status_sql("app", Some("missing_%"));
|
||||
|
||||
assert!(tables_sql.starts_with("SHOW FULL TABLES FROM `app` WHERE "));
|
||||
assert!(tables_sql.contains("`Tables_in_app` LIKE"));
|
||||
assert!(tables_sql.contains("missing"));
|
||||
assert!(tables_sql.contains("ESCAPE"));
|
||||
assert!(status_sql.starts_with("SHOW TABLE STATUS FROM `app` WHERE "));
|
||||
assert!(status_sql.contains("Name LIKE"));
|
||||
assert!(status_sql.contains("Comment LIKE"));
|
||||
assert!(status_sql.contains("missing"));
|
||||
assert!(status_sql.contains("ESCAPE"));
|
||||
assert!(!tables_sql.eq(&show_tables_filtered_sql("app", true, None, &[])));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mysql_filtered_show_fallback_attempts_bare_show_after_syntax_errors() {
|
||||
let attempts = show_tables_query_attempts("app", Some("orders"), &[]);
|
||||
|
||||
assert_eq!(attempts.len(), 4);
|
||||
assert!(attempts[0].server_filtered);
|
||||
assert!(attempts[0].sql.starts_with("SHOW FULL TABLES FROM `app` WHERE "));
|
||||
assert!(attempts[1].server_filtered);
|
||||
assert!(attempts[1].sql.starts_with("SHOW TABLES FROM `app` WHERE "));
|
||||
assert!(!attempts[2].server_filtered);
|
||||
assert_eq!(attempts[2].sql, "SHOW FULL TABLES FROM `app`");
|
||||
assert!(!attempts[3].server_filtered);
|
||||
assert_eq!(attempts[3].sql, "SHOW TABLES FROM `app`");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mysql_unfiltered_show_avoids_duplicate_attempts() {
|
||||
let attempts = show_tables_query_attempts("app", None, &[]);
|
||||
|
||||
assert_eq!(attempts.len(), 2);
|
||||
assert_eq!(attempts[0].sql, "SHOW FULL TABLES FROM `app`");
|
||||
assert_eq!(attempts[1].sql, "SHOW TABLES FROM `app`");
|
||||
assert!(attempts.iter().all(|attempt| !attempt.server_filtered));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mysql_unfiltered_status_fallback_is_filtered_locally_once() {
|
||||
let status = HashMap::from([
|
||||
(
|
||||
"orders".to_string(),
|
||||
TableStatusMeta { comment: Some("purchase history".to_string()), ..Default::default() },
|
||||
),
|
||||
("users".to_string(), TableStatusMeta::default()),
|
||||
]);
|
||||
|
||||
let filtered = filter_table_status_fallback(status, Some("purchase"));
|
||||
|
||||
assert_eq!(filtered.keys().map(String::as_str).collect::<Vec<_>>(), vec!["orders"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -4281,6 +4559,47 @@ mod tests {
|
||||
assert_eq!(filtered.iter().map(|table| table.name.as_str()).collect::<Vec<_>>(), vec!["t_0001"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mysql_object_browser_fallback_keeps_tables_views_and_routines_by_default() {
|
||||
let table_objects = vec![mysql_test_object("orders", "TABLE"), mysql_test_object("orders_view", "VIEW")];
|
||||
let mut objects = filter_table_objects_fallback(table_objects, None, None, None);
|
||||
objects.push(mysql_test_object("refresh_orders", "PROCEDURE"));
|
||||
|
||||
assert_eq!(
|
||||
objects.iter().map(|object| object.object_type.as_str()).collect::<Vec<_>>(),
|
||||
vec!["TABLE", "VIEW", "PROCEDURE"]
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mysql_object_browser_routine_only_does_not_use_table_fallback() {
|
||||
let object_types = vec!["PROCEDURE".to_string(), "FUNCTION".to_string()];
|
||||
|
||||
assert!(!wants_table_objects(Some(&object_types)));
|
||||
assert!(wants_routine_objects(Some(&object_types)));
|
||||
assert!(filter_table_objects_fallback(
|
||||
vec![mysql_test_object("orders", "TABLE")],
|
||||
Some(&object_types),
|
||||
None,
|
||||
None,
|
||||
)
|
||||
.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mysql_object_browser_fallback_filters_type_limit_and_offset() {
|
||||
let objects = vec![
|
||||
mysql_test_object("a_table", "TABLE"),
|
||||
mysql_test_object("b_view", "VIEW"),
|
||||
mysql_test_object("c_table", "TABLE"),
|
||||
];
|
||||
let object_types = vec!["TABLE".to_string()];
|
||||
|
||||
let filtered = filter_table_objects_fallback(objects, Some(&object_types), Some(1), Some(1));
|
||||
|
||||
assert_eq!(filtered.iter().map(|object| object.name.as_str()).collect::<Vec<_>>(), vec!["c_table"]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn starrocks_materialized_views_are_classified_without_duplicating_tables() {
|
||||
let mut tables = vec![
|
||||
@@ -4402,9 +4721,9 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn mysql_show_metadata_sql_supports_catalogless_services() {
|
||||
assert_eq!(show_tables_sql("", true), "SHOW FULL TABLES");
|
||||
assert_eq!(show_tables_sql("", false), "SHOW TABLES");
|
||||
assert_eq!(show_tables_sql("app", true), "SHOW FULL TABLES FROM `app`");
|
||||
assert_eq!(show_tables_filtered_sql("", true, None, &[]), "SHOW FULL TABLES");
|
||||
assert_eq!(show_tables_filtered_sql("", false, None, &[]), "SHOW TABLES");
|
||||
assert_eq!(show_tables_filtered_sql("app", true, None, &[]), "SHOW FULL TABLES FROM `app`");
|
||||
assert_eq!(show_columns_sql("", "idx", true), "SHOW FULL COLUMNS FROM `idx`");
|
||||
assert_eq!(show_columns_sql("app", "idx", false), "SHOW COLUMNS FROM `app`.`idx`");
|
||||
}
|
||||
|
||||
Reference in new issue
Block a user