Skip to content

armgit / dbx

Public Imported from GitHub
0

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。

chore(postgres): add tier diagnostics to column metadata queries

jearhe3883b96c1414
diff --git a/crates/dbx-driver-postgres/src/postgres.rs b/crates/dbx-driver-postgres/src/postgres.rs
index a87a82c19d..2b893f0792 100644
--- a/crates/dbx-driver-postgres/src/postgres.rs
+++ b/crates/dbx-driver-postgres/src/postgres.rs
@@ -1591,18 +1591,135 @@ where
Err(errors.into_iter().next_back().unwrap_or_else(|| format!("[postgres][{log_context}] no SQL tiers configured")))
}
+#[derive(Debug, PartialEq, Eq)]
+enum GetColumnsTierDiagnostic {
+ TierStarted { tier: &'static str },
+ TierSucceeded { tier: &'static str, tier_elapsed_ms: u128, column_count: usize },
+ TierEmpty { tier: &'static str, tier_elapsed_ms: u128, column_count: usize },
+ TierFailed { tier: &'static str, tier_elapsed_ms: u128, sqlstate: Option<String> },
+ Done { status: &'static str, selected_tier: Option<&'static str>, total_elapsed_ms: u128 },
+}
+
+fn log_get_columns_tier_diagnostic(event: GetColumnsTierDiagnostic) {
+ match event {
+ GetColumnsTierDiagnostic::TierStarted { tier } => {
+ log::debug!("[postgres][get_columns:tier:start] tier={tier}");
+ }
+ GetColumnsTierDiagnostic::TierSucceeded { tier, tier_elapsed_ms, column_count } => {
+ log::debug!(
+ "[postgres][get_columns:tier:success] tier={tier} tier_elapsed_ms={tier_elapsed_ms} column_count={column_count}"
+ );
+ }
+ GetColumnsTierDiagnostic::TierEmpty { tier, tier_elapsed_ms, column_count } => {
+ log::debug!(
+ "[postgres][get_columns:tier:empty] tier={tier} tier_elapsed_ms={tier_elapsed_ms} column_count={column_count}"
+ );
+ }
+ GetColumnsTierDiagnostic::TierFailed { tier, tier_elapsed_ms, sqlstate } => {
+ log::debug!(
+ "[postgres][get_columns:tier:failed] tier={tier} tier_elapsed_ms={tier_elapsed_ms} sqlstate={}",
+ sqlstate.as_deref().unwrap_or("none")
+ );
+ }
+ GetColumnsTierDiagnostic::Done { status, selected_tier, total_elapsed_ms } => {
+ log::debug!(
+ "[postgres][get_columns:done] status={status} selected_tier={} total_elapsed_ms={total_elapsed_ms}",
+ selected_tier.unwrap_or("none")
+ );
+ }
+ }
+}
+
/// Column-list tier runner: a tier is useful once it reported at least one
-/// column. See [`query_with_useful_compat_fallback`].
-async fn query_with_non_empty_compat_fallback<F, Fut>(
- log_context: &str,
- tiers: &[&'static str],
- run: F,
+/// column. Diagnostics are intentionally scoped to single-table `get_columns`;
+/// errors remain unchanged for callers but are never copied into these logs.
+/// `tier_elapsed_ms` measures the full driver call, not server-side execution.
+async fn query_with_column_metadata_fallback<F, Fut, E, ErrorToString, SqlStateForError, Emit>(
+ tiers: &[(&'static str, &'static str)],
+ mut run: F,
+ total_started: Option<Instant>,
+ error_to_string: ErrorToString,
+ sqlstate_for_error: SqlStateForError,
+ mut emit: Emit,
) -> Result<Vec<ColumnInfo>, String>
where
F: FnMut(&'static str) -> Fut,
- Fut: std::future::Future<Output = Result<Vec<ColumnInfo>, tokio_postgres::Error>>,
+ Fut: std::future::Future<Output = Result<Vec<ColumnInfo>, E>>,
+ ErrorToString: Fn(E) -> String,
+ SqlStateForError: Fn(&E) -> Option<String>,
+ Emit: FnMut(GetColumnsTierDiagnostic),
{
- query_with_useful_compat_fallback(log_context, tiers, run, |columns: &Vec<ColumnInfo>| !columns.is_empty()).await
+ let diagnostics_enabled = total_started.is_some();
+ let mut unuseful_result = None;
+ let mut errors = Vec::new();
+
+ for &(tier, sql) in tiers {
+ if diagnostics_enabled {
+ emit(GetColumnsTierDiagnostic::TierStarted { tier });
+ }
+ let tier_started = diagnostics_enabled.then(Instant::now);
+
+ match run(sql).await {
+ Ok(columns) if !columns.is_empty() => {
+ if let Some(started) = tier_started.as_ref() {
+ emit(GetColumnsTierDiagnostic::TierSucceeded {
+ tier,
+ tier_elapsed_ms: started.elapsed().as_millis(),
+ column_count: columns.len(),
+ });
+ }
+ if let Some(started) = total_started.as_ref() {
+ emit(GetColumnsTierDiagnostic::Done {
+ status: "success",
+ selected_tier: Some(tier),
+ total_elapsed_ms: started.elapsed().as_millis(),
+ });
+ }
+ return Ok(columns);
+ }
+ Ok(columns) => {
+ if let Some(started) = tier_started.as_ref() {
+ emit(GetColumnsTierDiagnostic::TierEmpty {
+ tier,
+ tier_elapsed_ms: started.elapsed().as_millis(),
+ column_count: columns.len(),
+ });
+ }
+ unuseful_result = Some((tier, columns));
+ }
+ Err(error) => {
+ let sqlstate = diagnostics_enabled.then(|| sqlstate_for_error(&error)).flatten();
+ if let Some(started) = tier_started.as_ref() {
+ emit(GetColumnsTierDiagnostic::TierFailed {
+ tier,
+ tier_elapsed_ms: started.elapsed().as_millis(),
+ sqlstate,
+ });
+ }
+ errors.push(error_to_string(error));
+ }
+ }
+ }
+
+ if let Some((tier, columns)) = unuseful_result {
+ if let Some(started) = total_started.as_ref() {
+ emit(GetColumnsTierDiagnostic::Done {
+ status: "empty",
+ selected_tier: Some(tier),
+ total_elapsed_ms: started.elapsed().as_millis(),
+ });
+ }
+ return Ok(columns);
+ }
+
+ if let Some(started) = total_started.as_ref() {
+ emit(GetColumnsTierDiagnostic::Done {
+ status: "failed",
+ selected_tier: None,
+ total_elapsed_ms: started.elapsed().as_millis(),
+ });
+ }
+ Err(errors.into_iter().next_back().unwrap_or_else(|| "[postgres][get_columns] no SQL tiers configured".to_string()))
}
fn pg_db_error_to_string(err: &tokio_postgres::error::DbError) -> String {
@@ -7936,10 +8053,35 @@ async fn get_columns_with_sql(
}
pub async fn get_columns(pool: &Pool, schema: &str, table: &str) -> Result<Vec<ColumnInfo>, String> {
- let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
- let tiers = [POSTGRES_COLUMNS_SQL, POSTGRES_COLUMNS_COMPAT_SQL, POSTGRES_COLUMNS_INFORMATION_SCHEMA_SQL];
- query_with_non_empty_compat_fallback("get_columns", &tiers, |sql| get_columns_with_sql(&client, sql, schema, table))
- .await
+ let diagnostics_enabled = log::log_enabled!(log::Level::Debug);
+ let total_started = diagnostics_enabled.then(Instant::now);
+ let client = match checkout_postgres_client(pool, None, super::connection_timeout()).await {
+ Ok(client) => client,
+ Err(error) => {
+ if let Some(started) = total_started.as_ref() {
+ log_get_columns_tier_diagnostic(GetColumnsTierDiagnostic::Done {
+ status: "failed",
+ selected_tier: None,
+ total_elapsed_ms: started.elapsed().as_millis(),
+ });
+ }
+ return Err(error);
+ }
+ };
+ let tiers = [
+ ("primary", POSTGRES_COLUMNS_SQL),
+ ("compat", POSTGRES_COLUMNS_COMPAT_SQL),
+ ("information_schema", POSTGRES_COLUMNS_INFORMATION_SCHEMA_SQL),
+ ];
+ query_with_column_metadata_fallback(
+ &tiers,
+ |sql| get_columns_with_sql(&client, sql, schema, table),
+ total_started,
+ pg_error_to_string,
+ |error: &tokio_postgres::Error| error.as_db_error().map(|db_error| db_error.code().code().to_string()),
+ log_get_columns_tier_diagnostic,
+ )
+ .await
}
pub fn pg_quote_literal(value: &str) -> String {
@@ -13989,6 +14131,311 @@ mod tests {
assert!(!error.is_empty());
}
+ #[derive(Debug)]
+ struct TestColumnMetadataError {
+ message: &'static str,
+ sqlstate: Option<&'static str>,
+ }
+
+ fn test_column_metadata_error_string(error: TestColumnMetadataError) -> String {
+ error.message.to_string()
+ }
+
+ fn test_column_metadata_sqlstate(error: &TestColumnMetadataError) -> Option<String> {
+ error.sqlstate.map(str::to_string)
+ }
+
+ #[tokio::test]
+ async fn get_columns_tier_diagnostics_fall_back_after_sqlstate_error() {
+ let tiers = [("primary", "primary-sql"), ("compat", "compat-sql"), ("information_schema", "info-sql")];
+ let calls = Cell::new(Vec::new());
+ let mut events = Vec::new();
+ let result = query_with_column_metadata_fallback(
+ &tiers,
+ |sql| {
+ calls.set({
+ let mut seen = calls.take();
+ seen.push(sql);
+ seen
+ });
+ async move {
+ if sql == "primary-sql" {
+ Err(TestColumnMetadataError { message: "primary failure", sqlstate: Some("42703") })
+ } else {
+ Ok(vec![ColumnInfo { name: "id".to_string(), ..Default::default() }])
+ }
+ }
+ },
+ Some(Instant::now()),
+ test_column_metadata_error_string,
+ test_column_metadata_sqlstate,
+ |event| events.push(event),
+ )
+ .await
+ .expect("compat tier succeeds");
+
+ assert_eq!(calls.take(), vec!["primary-sql", "compat-sql"]);
+ assert_eq!(result.len(), 1);
+ assert_eq!(result[0].name, "id");
+ assert!(matches!(&events[0], GetColumnsTierDiagnostic::TierStarted { tier } if *tier == "primary"));
+ assert!(
+ matches!(&events[1], GetColumnsTierDiagnostic::TierFailed { tier, sqlstate, .. } if *tier == "primary" && sqlstate.as_deref() == Some("42703"))
+ );
+ assert!(matches!(&events[2], GetColumnsTierDiagnostic::TierStarted { tier } if *tier == "compat"));
+ assert!(
+ matches!(&events[3], GetColumnsTierDiagnostic::TierSucceeded { tier, column_count: 1, .. } if *tier == "compat")
+ );
+ assert!(matches!(
+ events.last(),
+ Some(GetColumnsTierDiagnostic::Done { status: "success", selected_tier: Some("compat"), .. })
+ ));
+ }
+
+ #[tokio::test]
+ async fn get_columns_tier_diagnostics_reach_information_schema_after_two_failures() {
+ let tiers = [("primary", "primary-sql"), ("compat", "compat-sql"), ("information_schema", "info-sql")];
+ let calls = Cell::new(Vec::new());
+ let mut events = Vec::new();
+ let result = query_with_column_metadata_fallback(
+ &tiers,
+ |sql| {
+ calls.set({
+ let mut seen = calls.take();
+ seen.push(sql);
+ seen
+ });
+ async move {
+ if sql == "info-sql" {
+ Ok(vec![ColumnInfo { name: "fallback-column".to_string(), ..Default::default() }])
+ } else {
+ Err(TestColumnMetadataError { message: "tier failure", sqlstate: Some("0A000") })
+ }
+ }
+ },
+ Some(Instant::now()),
+ test_column_metadata_error_string,
+ test_column_metadata_sqlstate,
+ |event| events.push(event),
+ )
+ .await
+ .expect("information_schema tier succeeds");
+
+ assert_eq!(calls.take(), vec!["primary-sql", "compat-sql", "info-sql"]);
+ assert_eq!(result[0].name, "fallback-column");
+ assert!(matches!(
+ events.last(),
+ Some(GetColumnsTierDiagnostic::Done { status: "success", selected_tier: Some("information_schema"), .. })
+ ));
+ }
+
+ #[tokio::test]
+ async fn get_columns_tier_diagnostics_fall_back_after_empty_result() {
+ let tiers = [("primary", "primary-sql"), ("compat", "compat-sql"), ("information_schema", "info-sql")];
+ let calls = Cell::new(Vec::new());
+ let mut events = Vec::new();
+ let result = query_with_column_metadata_fallback(
+ &tiers,
+ |sql| {
+ calls.set({
+ let mut seen = calls.take();
+ seen.push(sql);
+ seen
+ });
+ async move {
+ if sql == "primary-sql" {
+ Ok(Vec::new())
+ } else {
+ Ok(vec![ColumnInfo { name: "id".to_string(), ..Default::default() }])
+ }
+ }
+ },
+ Some(Instant::now()),
+ test_column_metadata_error_string,
+ test_column_metadata_sqlstate,
+ |event| events.push(event),
+ )
+ .await
+ .expect("compat tier succeeds");
+
+ assert_eq!(calls.take(), vec!["primary-sql", "compat-sql"]);
+ assert_eq!(result.len(), 1);
+ assert!(
+ matches!(&events[1], GetColumnsTierDiagnostic::TierEmpty { tier, column_count: 0, .. } if *tier == "primary")
+ );
+ assert!(!events.iter().any(|event| matches!(event, GetColumnsTierDiagnostic::TierFailed { .. })));
+ assert!(matches!(
+ events.last(),
+ Some(GetColumnsTierDiagnostic::Done { status: "success", selected_tier: Some("compat"), .. })
+ ));
+ }
+
+ #[tokio::test]
+ async fn get_columns_tier_diagnostics_keep_last_error_without_logging_error_text() {
+ let tiers = [
+ ("primary", "sensitive-primary-sql"),
+ ("compat", "sensitive-compat-sql"),
+ ("information_schema", "sensitive-info-sql"),
+ ];
+ let calls = Cell::new(Vec::new());
+ let mut events = Vec::new();
+ let result = query_with_column_metadata_fallback(
+ &tiers,
+ |sql| {
+ calls.set({
+ let mut seen = calls.take();
+ seen.push(sql);
+ seen
+ });
+ async move {
+ Err(TestColumnMetadataError {
+ message: if sql == "sensitive-info-sql" { "last tier error" } else { "earlier tier error" },
+ sqlstate: Some("0A000"),
+ })
+ }
+ },
+ Some(Instant::now()),
+ test_column_metadata_error_string,
+ test_column_metadata_sqlstate,
+ |event| events.push(event),
+ )
+ .await;
+
+ assert_eq!(calls.take(), vec!["sensitive-primary-sql", "sensitive-compat-sql", "sensitive-info-sql"]);
+ assert_eq!(result.expect_err("all tiers fail"), "last tier error");
+ assert_eq!(
+ events.iter().filter(|event| matches!(event, GetColumnsTierDiagnostic::TierFailed { .. })).count(),
+ 3
+ );
+ assert!(matches!(
+ events.last(),
+ Some(GetColumnsTierDiagnostic::Done { status: "failed", selected_tier: None, .. })
+ ));
+ let event_text = format!("{events:?}");
+ assert!(!event_text.contains("sensitive"));
+ assert!(!event_text.contains("tier error"));
+ }
+
+ #[tokio::test]
+ async fn get_columns_tier_diagnostics_select_primary_without_fallback() {
+ let tiers = [("primary", "primary-sql"), ("compat", "compat-sql"), ("information_schema", "info-sql")];
+ let calls = Cell::new(Vec::new());
+ let mut events = Vec::new();
+ let result = query_with_column_metadata_fallback(
+ &tiers,
+ |sql| {
+ calls.set({
+ let mut seen = calls.take();
+ seen.push(sql);
+ seen
+ });
+ async move { Ok(vec![ColumnInfo { name: "stable-name".to_string(), ..Default::default() }]) }
+ },
+ Some(Instant::now()),
+ test_column_metadata_error_string,
+ test_column_metadata_sqlstate,
+ |event| events.push(event),
+ )
+ .await
+ .expect("primary tier succeeds");
+
+ assert_eq!(calls.take(), vec!["primary-sql"]);
+ assert_eq!(result[0].name, "stable-name");
+ assert!(matches!(
+ events.last(),
+ Some(GetColumnsTierDiagnostic::Done { status: "success", selected_tier: Some("primary"), .. })
+ ));
+ }
+
+ #[tokio::test]
+ async fn get_columns_tier_diagnostics_preserve_empty_fallback_result() {
+ let tiers = [("primary", "primary-sql"), ("compat", "compat-sql"), ("information_schema", "info-sql")];
+ let calls = Cell::new(Vec::new());
+ let mut events = Vec::new();
+ let result = query_with_column_metadata_fallback(
+ &tiers,
+ |sql| {
+ calls.set({
+ let mut seen = calls.take();
+ seen.push(sql);
+ seen
+ });
+ async move {
+ if sql == "compat-sql" {
+ Err(TestColumnMetadataError { message: "compat failure", sqlstate: Some("0A000") })
+ } else {
+ Ok(Vec::new())
+ }
+ }
+ },
+ Some(Instant::now()),
+ test_column_metadata_error_string,
+ test_column_metadata_sqlstate,
+ |event| events.push(event),
+ )
+ .await
+ .expect("successful empty tier is returned when none is useful");
+
+ assert!(result.is_empty());
+ assert_eq!(calls.take(), vec!["primary-sql", "compat-sql", "info-sql"]);
+ assert!(matches!(
+ events.last(),
+ Some(GetColumnsTierDiagnostic::Done { status: "empty", selected_tier: Some("information_schema"), .. })
+ ));
+ }
+
+ #[tokio::test]
+ async fn get_columns_tier_diagnostics_are_silent_when_disabled() {
+ let tiers = [("primary", "primary-sql"), ("compat", "compat-sql")];
+ let calls = Cell::new(Vec::new());
+ let mut events = Vec::new();
+ let result = query_with_column_metadata_fallback(
+ &tiers,
+ |sql| {
+ calls.set({
+ let mut seen = calls.take();
+ seen.push(sql);
+ seen
+ });
+ async move { Ok(vec![ColumnInfo { name: "id".to_string(), ..Default::default() }]) }
+ },
+ None,
+ test_column_metadata_error_string,
+ test_column_metadata_sqlstate,
+ |event| events.push(event),
+ )
+ .await
+ .expect("primary tier succeeds with diagnostics disabled");
+
+ assert_eq!(calls.take(), vec!["primary-sql"]);
+ assert_eq!(result[0].name, "id");
+ assert!(events.is_empty());
+ }
+
+ #[tokio::test]
+ async fn get_columns_tier_diagnostics_handle_errors_without_sqlstate() {
+ let tiers = [("primary", "primary-sql"), ("compat", "compat-sql")];
+ let mut events = Vec::new();
+ let result = query_with_column_metadata_fallback(
+ &tiers,
+ |sql| async move {
+ if sql == "primary-sql" {
+ Err(TestColumnMetadataError { message: "transport failure", sqlstate: None })
+ } else {
+ Ok(vec![ColumnInfo { name: "id".to_string(), ..Default::default() }])
+ }
+ },
+ Some(Instant::now()),
+ test_column_metadata_error_string,
+ test_column_metadata_sqlstate,
+ |event| events.push(event),
+ )
+ .await
+ .expect("compat tier succeeds after unstructured error");
+
+ assert_eq!(result.len(), 1);
+ assert!(matches!(&events[1], GetColumnsTierDiagnostic::TierFailed { tier: "primary", sqlstate: None, .. }));
+ }
+
#[test]
fn opengauss_sequence_metadata_uses_compatible_information_schema_view() {
let sql = opengauss_sequences_sql();