feat(sidebar): add configurable object metadata display

This commit is contained in:
zipg authored and GitHub committed 2026-07-23 00:23:19 +08:00
1 parent 8adf802444
commit 57f2d27313
29 files changed
+889 -143

No files matched your search

+59 -11
View File
@@ -26,8 +26,8 @@ use crate::sql::starts_with_executable_sql_keyword;
use crate::types::{
ColumnInfo, CompletionAssistantCandidate, CompletionAssistantCandidateKind, CompletionAssistantMatchMode,
CompletionAssistantObjectKind, CompletionAssistantRequest, CompletionAssistantResponse, DatabaseInfo,
ExtensionInfo, ForeignKeyInfo, FunctionInfo, IndexInfo, ObjectInfo, ObjectStatistics, OwnerInfo, QueryResult,
RuleInfo, SchemaInfo, SequenceInfo, TableInfo, TriggerInfo,
DatabaseStorageInfo, ExtensionInfo, ForeignKeyInfo, FunctionInfo, IndexInfo, ObjectInfo, ObjectStatistics,
OwnerInfo, QueryResult, RuleInfo, SchemaInfo, SequenceInfo, TableInfo, TriggerInfo,
};
fn pg_temporal_to_json_value(row: &Row, idx: usize) -> Option<serde_json::Value> {
@@ -1542,21 +1542,53 @@ fn validate_postgres_ssl_paths(url: &str) -> Result<(), String> {
postgres_connection_url(url).map(|_| ())
}
fn list_databases_sql() -> &'static str {
"SELECT datname FROM pg_database \
WHERE datallowconn = true \
ORDER BY datname"
}
fn database_storage_sql() -> &'static str {
"SELECT d.datname, \
CASE \
WHEN has_database_privilege(d.datname, 'CONNECT') \
OR COALESCE(( \
SELECT pg_has_role(current_user, r.oid, 'MEMBER') \
FROM pg_roles r \
WHERE r.rolname = 'pg_read_all_stats' \
), false) \
THEN pg_database_size(d.oid) \
ELSE NULL \
END AS size_bytes \
FROM pg_database d \
WHERE d.datallowconn = true \
AND d.datname = ANY($1::text[]) \
ORDER BY d.datname"
}
pub async fn list_databases(pool: &Pool) -> Result<Vec<DatabaseInfo>, String> {
let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
let rows = postgres_query_cached(
&client,
"SELECT datname FROM pg_database \
WHERE datallowconn = true \
ORDER BY datname",
&[],
)
.await
.map_err(|e| e.to_string())?;
let rows = postgres_query_cached(&client, list_databases_sql(), &[]).await.map_err(|e| e.to_string())?;
Ok(rows.iter().map(|row| DatabaseInfo { name: pg_row_try_string(row, 0) }).collect())
}
pub async fn list_database_storage(pool: &Pool, database_names: &[String]) -> Result<Vec<DatabaseStorageInfo>, String> {
if database_names.is_empty() {
return Ok(Vec::new());
}
let client = checkout_postgres_client(pool, None, super::connection_timeout()).await?;
let rows =
postgres_query_cached(&client, database_storage_sql(), &[&database_names]).await.map_err(|e| e.to_string())?;
Ok(rows
.iter()
.map(|row| DatabaseStorageInfo {
name: pg_row_try_string(row, 0),
size_bytes: row.try_get::<_, Option<i64>>(1).ok().flatten(),
})
.collect())
}
pub async fn list_tables(pool: &Pool, schema: &str) -> Result<Vec<TableInfo>, String> {
list_tables_filtered(pool, schema, None, None, None).await
}
@@ -3579,6 +3611,22 @@ mod tests {
use std::time::Instant;
use tokio_postgres::types::FromSql;
#[test]
fn database_list_does_not_collect_storage_usage() {
assert!(list_databases_sql().contains("pg_database"));
assert!(!list_databases_sql().contains("pg_database_size"));
}
#[test]
fn database_storage_is_scoped_and_permission_guarded() {
let sql = database_storage_sql();
assert!(sql.contains("d.datname = ANY($1::text[])"));
assert!(sql.contains("has_database_privilege"));
assert!(sql.contains("pg_read_all_stats"));
assert!(sql.contains("pg_database_size"));
assert!(sql.contains("ELSE NULL"));
}
#[test]
fn classify_pg_type_covers_all_dispatch_branches() {
assert_eq!(classify_pg_type("bytea"), PgColType::Bytea);
+265 -7
View File
@@ -653,6 +653,56 @@ pub async fn list_databases_core(state: &AppState, connection_id: &str) -> Resul
retry_metadata_connection(state, connection_id, None, || list_databases_once(state, connection_id)).await
}
pub async fn list_database_storage_core(
state: &AppState,
connection_id: &str,
database_names: &[String],
) -> Result<Vec<db::DatabaseStorageInfo>, String> {
const DATABASE_STORAGE_TIMEOUT: Duration = Duration::from_secs(5);
const MAX_DATABASE_STORAGE_NAMES: usize = 2048;
if database_names.is_empty() {
return Ok(Vec::new());
}
let config = connection_config(state, connection_id).await;
if !config.as_ref().is_some_and(|config| {
config.db_type == DatabaseType::Postgres && config.driver_profile.as_deref() != Some("cockroachdb")
}) {
return Ok(Vec::new());
}
let pool = {
let connections = state.connections.read().await;
match connections.get(connection_id) {
Some(PoolKind::Postgres(pool)) => pool.clone(),
_ => return Ok(Vec::new()),
}
};
let mut seen = std::collections::HashSet::new();
let requested = database_names
.iter()
.filter(|name| !name.is_empty() && seen.insert((*name).clone()))
.take(MAX_DATABASE_STORAGE_NAMES)
.cloned()
.collect::<Vec<_>>();
if requested.is_empty() {
return Ok(Vec::new());
}
match tokio::time::timeout(DATABASE_STORAGE_TIMEOUT, db::postgres::list_database_storage(&pool, &requested)).await {
Ok(result) => result,
Err(_) => {
log::warn!(
"[list_database_storage:timeout] connection_id={} database_count={} timeout_ms={}",
connection_id,
requested.len(),
DATABASE_STORAGE_TIMEOUT.as_millis()
);
Ok(Vec::new())
}
}
}
pub async fn list_sqlserver_linked_servers_core(
state: &AppState,
connection_id: &str,
@@ -1573,6 +1623,91 @@ fn oracle_object_statistics_rows_only_sql(schema: &str) -> String {
)
}
fn dameng_object_statistics_dba_segments_sql(schema: &str) -> String {
format!(
"SELECT t.TABLE_NAME, t.OWNER, t.NUM_ROWS, NVL(s.BYTES, 0) AS TOTAL_BYTES \
FROM ALL_TABLES t \
LEFT JOIN ( \
SELECT owner, table_name, SUM(bytes) AS BYTES \
FROM ( \
SELECT s.OWNER, s.SEGMENT_NAME AS TABLE_NAME, s.BYTES \
FROM DBA_SEGMENTS s \
WHERE s.OWNER = {} AND s.SEGMENT_TYPE IN ('TABLE','TABLE PARTITION','TABLE SUBPARTITION') \
UNION ALL \
SELECT i.TABLE_OWNER AS OWNER, i.TABLE_NAME, s.BYTES \
FROM ALL_INDEXES i \
JOIN DBA_SEGMENTS s ON s.OWNER = i.OWNER AND s.SEGMENT_NAME = i.INDEX_NAME \
WHERE i.TABLE_OWNER = {} AND s.SEGMENT_TYPE IN ('INDEX','INDEX PARTITION','INDEX SUBPARTITION') \
) \
GROUP BY owner, table_name \
) s ON s.OWNER = t.OWNER AND s.TABLE_NAME = t.TABLE_NAME \
WHERE t.OWNER = {} AND (t.NESTED IS NULL OR t.NESTED = 'NO') \
ORDER BY t.TABLE_NAME",
oracle_owner_filter(schema),
oracle_owner_filter(schema),
oracle_owner_filter(schema),
)
}
fn dameng_object_statistics_user_segments_sql(schema: &str) -> String {
format!(
"SELECT t.TABLE_NAME, t.OWNER, t.NUM_ROWS, NVL(s.BYTES, 0) AS TOTAL_BYTES \
FROM ALL_TABLES t \
LEFT JOIN ( \
SELECT table_name, SUM(bytes) AS BYTES \
FROM ( \
SELECT s.SEGMENT_NAME AS TABLE_NAME, s.BYTES \
FROM USER_SEGMENTS s \
WHERE s.SEGMENT_TYPE IN ('TABLE','TABLE PARTITION','TABLE SUBPARTITION') \
UNION ALL \
SELECT i.TABLE_NAME, s.BYTES \
FROM ALL_INDEXES i \
JOIN USER_SEGMENTS s ON s.SEGMENT_NAME = i.INDEX_NAME \
WHERE i.TABLE_OWNER = {} AND s.SEGMENT_TYPE IN ('INDEX','INDEX PARTITION','INDEX SUBPARTITION') \
) \
GROUP BY table_name \
) s ON s.TABLE_NAME = t.TABLE_NAME \
WHERE t.OWNER = {} AND t.OWNER = USER AND (t.NESTED IS NULL OR t.NESTED = 'NO') \
ORDER BY t.TABLE_NAME",
oracle_owner_filter(schema),
oracle_owner_filter(schema),
)
}
fn dameng_object_statistics_rows_only_sql(schema: &str) -> String {
format!(
"SELECT t.TABLE_NAME, t.OWNER, t.NUM_ROWS, CAST(NULL AS NUMBER) AS TOTAL_BYTES \
FROM ALL_TABLES t \
WHERE t.OWNER = {} AND (t.NESTED IS NULL OR t.NESTED = 'NO') \
ORDER BY t.TABLE_NAME",
oracle_owner_filter(schema),
)
}
fn kingbase_object_statistics_sql(schema: &str) -> String {
format!(
"SELECT c.relname, n.nspname, \
CAST(CASE WHEN c.reltuples < 0 THEN 0 ELSE c.reltuples END AS BIGINT) AS estimated_rows, \
CAST(sys_total_relation_size(c.oid) AS BIGINT) AS total_bytes \
FROM sys_catalog.sys_class c \
JOIN sys_catalog.sys_namespace n ON n.oid = c.relnamespace \
WHERE n.nspname = {} AND c.relkind IN ('r','m','f','p') \
ORDER BY c.relname",
sql_string(schema),
)
}
fn gbase8a_object_statistics_sql(database: &str) -> String {
format!(
"SELECT TABLE_NAME, TABLE_SCHEMA, TABLE_ROWS, \
COALESCE(DATA_LENGTH, 0) + COALESCE(INDEX_LENGTH, 0) AS TOTAL_BYTES \
FROM information_schema.TABLES \
WHERE TABLE_SCHEMA = {} AND TABLE_TYPE <> 'VIEW' \
ORDER BY TABLE_NAME",
sql_string(database),
)
}
fn query_result_cell_i64(row: &[serde_json::Value], index: usize) -> Option<i64> {
let value = row.get(index)?;
if value.is_null() {
@@ -1755,7 +1890,7 @@ async fn oracle_agent_list_object_statistics(
];
let mut last_error = None;
for (source, sql, accept_empty) in queries {
match oracle_agent_object_statistics_query(&mut client, database, schema, &sql, timeout_duration).await {
match agent_object_statistics_query(&mut client, database, schema, &sql, timeout_duration).await {
Ok(result) if accept_empty || !result.rows.is_empty() => {
return Ok(oracle_object_statistics_from_query_result(result));
}
@@ -1780,7 +1915,58 @@ async fn oracle_agent_list_object_statistics(
Err(last_error.unwrap_or_else(|| "Oracle object statistics are unavailable".to_string()))
}
async fn oracle_agent_object_statistics_query(
async fn dameng_agent_list_object_statistics(
client: Arc<tokio::sync::Mutex<db::agent_driver::AgentDriverClient>>,
database: &str,
schema: &str,
timeout_duration: Option<Duration>,
) -> Result<Vec<db::ObjectStatistics>, String> {
let mut client = client.lock().await;
let queries = [
("dba-segments", dameng_object_statistics_dba_segments_sql(schema), true),
("user-segments", dameng_object_statistics_user_segments_sql(schema), false),
("rows-only", dameng_object_statistics_rows_only_sql(schema), true),
];
let mut last_error = None;
for (source, sql, accept_empty) in queries {
match agent_object_statistics_query(&mut client, database, schema, &sql, timeout_duration).await {
Ok(result) if accept_empty || !result.rows.is_empty() => {
return Ok(oracle_object_statistics_from_query_result(result));
}
Ok(_) => {
log::debug!(
"[schema][dameng:list_object_statistics:empty-fallback] schema={} source={}",
schema,
source
);
}
Err(error) => {
log::debug!(
"[schema][dameng:list_object_statistics:fallback-failed] schema={} source={} error={}",
schema,
source,
error
);
last_error = Some(error);
}
}
}
Err(last_error.unwrap_or_else(|| "Dameng object statistics are unavailable".to_string()))
}
async fn agent_list_object_statistics(
client: Arc<tokio::sync::Mutex<db::agent_driver::AgentDriverClient>>,
database: &str,
schema: &str,
sql: String,
timeout_duration: Option<Duration>,
) -> Result<Vec<db::ObjectStatistics>, String> {
let mut client = client.lock().await;
let result = agent_object_statistics_query(&mut client, database, schema, &sql, timeout_duration).await?;
Ok(oracle_object_statistics_from_query_result(result))
}
async fn agent_object_statistics_query(
client: &mut db::agent_driver::AgentDriverClient,
database: &str,
schema: &str,
@@ -2453,11 +2639,13 @@ fn escape_presto_like_pattern(value: &str) -> String {
mod tests {
use super::db;
use super::{
clickhouse_metadata_database, deduplicate_column_infos, filter_mysql_system_databases_for_config,
filter_object_infos, filter_table_infos, filter_visible_schema_names,
is_agent_postgres_metadata_fallback_config, is_retryable_metadata_error, mysql_object_source_sql,
mysql_table_metadata_catalog, normalize_information_schema_table_type, oracle_columns_from_query_result,
oracle_columns_sql, oracle_object_statistics_dba_segments_sql, oracle_object_statistics_from_query_result,
clickhouse_metadata_database, dameng_object_statistics_dba_segments_sql,
dameng_object_statistics_rows_only_sql, dameng_object_statistics_user_segments_sql, deduplicate_column_infos,
filter_mysql_system_databases_for_config, filter_object_infos, filter_table_infos, filter_visible_schema_names,
gbase8a_object_statistics_sql, is_agent_postgres_metadata_fallback_config, is_retryable_metadata_error,
kingbase_object_statistics_sql, mysql_object_source_sql, mysql_table_metadata_catalog,
normalize_information_schema_table_type, oracle_columns_from_query_result, oracle_columns_sql,
oracle_object_statistics_dba_segments_sql, oracle_object_statistics_from_query_result,
oracle_object_statistics_rows_only_sql, oracle_object_statistics_sql,
oracle_object_statistics_user_segments_sql, oracle_table_comment_from_query_result, oracle_table_comment_sql,
oracle_table_comments_from_query_result, oracle_table_comments_sql, presto_like_columns_from_query_result,
@@ -3465,6 +3653,40 @@ mod tests {
assert!(!rows_only_sql.contains("ALL_SEGMENTS"));
}
#[test]
fn dameng_object_statistics_sql_uses_available_segment_views() {
let dba_sql = dameng_object_statistics_dba_segments_sql("app's");
assert!(dba_sql.contains("DBA_SEGMENTS"));
assert!(dba_sql.contains("ALL_INDEXES"));
assert!(!dba_sql.contains("ALL_SEGMENTS"));
assert!(!dba_sql.contains("ALL_LOBS"));
assert!(dba_sql.contains("OWNER = 'APP''S'"));
assert!(dba_sql.contains("t.NESTED IS NULL OR t.NESTED = 'NO'"));
let user_sql = dameng_object_statistics_user_segments_sql("app's");
assert!(user_sql.contains("USER_SEGMENTS"));
assert!(user_sql.contains("t.OWNER = USER"));
let rows_only_sql = dameng_object_statistics_rows_only_sql("app's");
assert!(rows_only_sql.contains("CAST(NULL AS NUMBER) AS TOTAL_BYTES"));
assert!(!rows_only_sql.contains("SEGMENTS"));
}
#[test]
fn agent_database_object_statistics_sql_uses_native_catalogs() {
let kingbase_sql = kingbase_object_statistics_sql("core's");
assert!(kingbase_sql.contains("sys_catalog.sys_class"));
assert!(kingbase_sql.contains("sys_catalog.sys_namespace"));
assert!(kingbase_sql.contains("sys_total_relation_size"));
assert!(kingbase_sql.contains("n.nspname = 'core''s'"));
let gbase_sql = gbase8a_object_statistics_sql("shop's");
assert!(gbase_sql.contains("information_schema.TABLES"));
assert!(gbase_sql.contains("DATA_LENGTH"));
assert!(gbase_sql.contains("INDEX_LENGTH"));
assert!(gbase_sql.contains("TABLE_SCHEMA = 'shop''s'"));
}
#[test]
fn oracle_object_statistics_from_query_result_maps_numbers() {
let result = db::QueryResult {
@@ -3935,6 +4157,42 @@ async fn list_object_statistics_once(
)
.await;
}
if db_config.as_ref().is_some_and(|config| config.db_type == DatabaseType::Dameng) {
drop(connections);
return dameng_agent_list_object_statistics(
client,
database,
schema,
agent_metadata_timeout(db_config.as_ref()),
)
.await;
}
if db_config.as_ref().is_some_and(|config| config.db_type == DatabaseType::Kingbase) {
let sql = kingbase_object_statistics_sql(schema);
drop(connections);
return agent_list_object_statistics(
client,
database,
schema,
sql,
agent_metadata_timeout(db_config.as_ref()),
)
.await;
}
if db_config.as_ref().is_some_and(|config| {
config.db_type == DatabaseType::Gbase && config.driver_profile.as_deref() != Some("gbase8s")
}) {
let sql = gbase8a_object_statistics_sql(database);
drop(connections);
return agent_list_object_statistics(
client,
database,
schema,
sql,
agent_metadata_timeout(db_config.as_ref()),
)
.await;
}
}
let pool = connections.get(&pool_key).ok_or("Pool not found")?;
match pool {
+6
View File
@@ -5,6 +5,12 @@ pub struct DatabaseInfo {
pub name: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
pub struct DatabaseStorageInfo {
pub name: String,
pub size_bytes: Option<i64>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct SchemaInfo {
pub name: String,