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(postgres): keep expression index DDL text and key order in sync
zipg05d3bd063558
diff --git a/agents/common/src/main/java/com/dbx/agent/PostgresLikeAgent.java b/agents/common/src/main/java/com/dbx/agent/PostgresLikeAgent.javaindex 8e1e54b155..a29fb9af44 100644--- a/agents/common/src/main/java/com/dbx/agent/PostgresLikeAgent.java+++ b/agents/common/src/main/java/com/dbx/agent/PostgresLikeAgent.java@@ -542,10 +542,13 @@ public abstract class PostgresLikeAgent extends AbstractJdbcAgent {// dropped; their text comes from pg_get_indexdef instead of a.attname, and// is_expression records which case applied so Rust never has to guess from// characters in the text (#6312 review).+ // `a.attname::text` keeps the cast: a bare COALESCE(name, text) resolves to+ // `name`, which truncates an expression key part to 63 bytes (NAMEDATALEN - 1)+ // and makes the rebuilt CREATE INDEX invalid (#9988).Map<String, IndexBuilder> byName = new LinkedHashMap<>();String sql = "SELECT i.relname AS index_name, am.amname AS index_type, " +"(ix.indisunique AND ix.indisvalid) AS is_unique, ix.indisprimary AS is_primary, " +- "COALESCE(a.attname, " + profile.catalogPrefixedFunction("get_indexdef") + "(ix.indexrelid, k.n, true)) AS column_text, " ++ "COALESCE(a.attname::text, " + profile.catalogPrefixedFunction("get_indexdef") + "(ix.indexrelid, k.n, true)) AS column_text, " +"(a.attname IS NULL) AS is_expression, " +"array_length(ix.indoption, 1) AS nkeyatts, k.n AS key_position, " +"ix.indoption[(k.n - 1)::int] AS key_option " +diff --git a/agents/common/src/test/java/com/dbx/agent/PostgresLikeAgentTest.java b/agents/common/src/test/java/com/dbx/agent/PostgresLikeAgentTest.javaindex 073593061b..aa1ac77816 100644--- a/agents/common/src/test/java/com/dbx/agent/PostgresLikeAgentTest.java+++ b/agents/common/src/test/java/com/dbx/agent/PostgresLikeAgentTest.java@@ -201,6 +201,9 @@ class PostgresLikeAgentTest {String sql = String.join("\n", MetadataSqlFake.statements);assertTrue(sql.contains("LEFT JOIN pg_catalog.pg_attribute a ON a.attrelid = t.oid AND a.attnum = k.attnum AND k.attnum > 0"), sql);assertTrue(sql.contains("pg_catalog.pg_get_indexdef(ix.indexrelid, k.n, true)"), sql);+ // #9988: a bare COALESCE(name, text) resolves to `name`, so PostgreSQL truncated a+ // long expression key part to 63 bytes and the rebuilt CREATE INDEX was invalid.+ assertTrue(sql.contains("COALESCE(a.attname::text, pg_catalog.pg_get_indexdef(ix.indexrelid, k.n, true)) AS column_text"), sql);assertTrue(sql.contains("ix.indisunique AND ix.indisvalid"), sql);assertTrue(sql.contains("ix.indoption[(k.n - 1)::int]"), sql);assertTrue(sql.contains("array_length(ix.indoption, 1) AS nkeyatts"), sql);diff --git a/crates/dbx-drivers/src/db/postgres.rs b/crates/dbx-drivers/src/db/postgres.rsindex b6cd85f2a3..a2e00388b0 100644--- a/crates/dbx-drivers/src/db/postgres.rs+++ b/crates/dbx-drivers/src/db/postgres.rs@@ -4782,9 +4782,13 @@ fn postgres_indexes_for_relations_query_tiers() -> [&'static str; 2] {// (schema, table) pair. Not merged into a shared fragment for the same// reason as the columns queries above — an alias would need renaming to// line up, and result columns are read positionally.+// `COALESCE(a.attname::text, pg_get_indexdef(...))` keeps the cast: a bare+// `COALESCE(name, text)` resolves to `name`, so PostgreSQL silently truncates an+// expression key part to 63 bytes (NAMEDATALEN - 1) and the rebuilt CREATE INDEX+// becomes invalid SQL (#9988).fn postgres_indexes_for_relations_sql() -> &'static str {"SELECT t.oid::bigint AS relid, i.relname AS index_name, \- array_agg(COALESCE(a.attname, pg_get_indexdef(ix.indexrelid, k.n::int, false)) ORDER BY k.n) AS columns, \+ array_agg(COALESCE(a.attname::text, pg_get_indexdef(ix.indexrelid, k.n::int, false)) ORDER BY k.n) AS columns, \array_agg(CASE WHEN oc.opcdefault THEN NULL ELSE quote_ident(opcns.nspname) || '.' || quote_ident(oc.opcname) END ORDER BY k.n) AS column_opclasses, \(ix.indisunique AND ix.indisvalid) AS is_unique, \ix.indisprimary AS is_primary, \@@ -4814,7 +4818,7 @@ fn postgres_indexes_for_relations_sql() -> &'static str {fn postgres_indexes_for_relations_compat_sql() -> &'static str {"SELECT t.oid::bigint AS relid, i.relname AS index_name, \ARRAY( \- SELECT COALESCE(a.attname, pg_get_indexdef(ix.indexrelid, pos.n, false)) \+ SELECT COALESCE(a.attname::text, pg_get_indexdef(ix.indexrelid, pos.n, false)) \FROM generate_series(1, array_length(string_to_array(ix.indkey::text, ' '), 1)) AS pos(n) \LEFT JOIN pg_attribute a \ON a.attrelid = t.oid \@@ -8844,8 +8848,12 @@ async fn execute_query_with_max_rows_inner(// Sibling of `postgres_indexes_for_relations_sql` (~line 3288), for a single// (schema, table) instead of a batch of oids — see the note there.+// `COALESCE(a.attname::text, pg_get_indexdef(...))` keeps the cast: a bare+// `COALESCE(name, text)` resolves to `name`, so PostgreSQL silently truncates an+// expression key part to 63 bytes (NAMEDATALEN - 1) and the rebuilt CREATE INDEX+// becomes invalid SQL (#9988).const POSTGRES_INDEXES_SQL: &str = "SELECT i.relname AS index_name, \- array_agg(COALESCE(a.attname, pg_get_indexdef(ix.indexrelid, k.n::int, false)) ORDER BY k.n) AS columns, \+ array_agg(COALESCE(a.attname::text, pg_get_indexdef(ix.indexrelid, k.n::int, false)) ORDER BY k.n) AS columns, \array_agg(CASE WHEN oc.opcdefault THEN NULL ELSE quote_ident(opcns.nspname) || '.' || quote_ident(oc.opcname) END ORDER BY k.n) AS column_opclasses, \(ix.indisunique AND ix.indisvalid) AS is_unique, \ix.indisprimary AS is_primary, \@@ -8874,7 +8882,7 @@ const POSTGRES_INDEXES_SQL: &str = "SELECT i.relname AS index_name, \// 3312) — see the note on `POSTGRES_INDEXES_SQL` above.const POSTGRES_INDEXES_COMPAT_SQL: &str = "SELECT i.relname AS index_name, \ARRAY( \- SELECT COALESCE(a.attname, pg_get_indexdef(ix.indexrelid, pos.n, false)) \+ SELECT COALESCE(a.attname::text, pg_get_indexdef(ix.indexrelid, pos.n, false)) \FROM generate_series(1, array_length(string_to_array(ix.indkey::text, ' '), 1)) AS pos(n) \LEFT JOIN pg_attribute a \ON a.attrelid = t.oid \@@ -13207,6 +13215,23 @@ mod tests {}}+ #[test]+ fn postgres_index_queries_cast_attname_to_text() {+ // Regression for #9988: `COALESCE(a.attname, pg_get_indexdef(...))` resolves to the+ // `name` type, so PostgreSQL silently truncated an expression key part to 63 bytes+ // (NAMEDATALEN - 1). The rebuilt CREATE INDEX then failed with a syntax error and the+ // whole publish transaction rolled back.+ for sql in [+ POSTGRES_INDEXES_SQL,+ POSTGRES_INDEXES_COMPAT_SQL,+ postgres_indexes_for_relations_sql(),+ postgres_indexes_for_relations_compat_sql(),+ ] {+ assert!(sql.contains("COALESCE(a.attname::text, pg_get_indexdef("), "{sql}");+ assert!(!sql.contains("COALESCE(a.attname, pg_get_indexdef("), "{sql}");+ }+ }+#[test]fn postgres_column_metadata_marks_only_owned_integer_sequence_defaults_as_serial() {let modern_sql = [POSTGRES_COLUMNS_SQL, postgres_columns_for_relations_sql()];diff --git a/crates/dbx-sql/src/schema_diff.rs b/crates/dbx-sql/src/schema_diff.rsindex a8f248f7e8..c6bf66965c 100644--- a/crates/dbx-sql/src/schema_diff.rs+++ b/crates/dbx-sql/src/schema_diff.rs@@ -3995,16 +3995,38 @@ fn is_postgres_family_ddl(db_type: DatabaseType) -> bool {)}-fn postgres_index_column_sql(column: &str, is_expression: Option<bool>, db_type: DatabaseType) -> String {- // Expression/functional index key parts (e.g. from pg_get_indexdef) arrive as raw- // expression text, not a plain column name; quoting the whole expression as an- // identifier turns it into a literal column reference that doesn't exist (#6295).+/// One PostgreSQL index key part for DDL: the key text plus its operator class+/// and, for B-tree keys, the explicit ordering.+///+/// Expression/functional index key parts (e.g. from pg_get_indexdef) arrive as raw+/// expression text, not a plain column name; quoting the whole expression as an+/// identifier turns it into a literal column reference that doesn't exist (#6295).+///+/// `pg_index.indoption` carries bit 0 = DESC and bit 1 = NULLS FIRST per key.+/// Dropping it silently rebuilt `col DESC NULLS LAST` as a plain ASC key (#8559+/// fixed exactly this for data transfer; the sync DDL kept losing it, #9988).+/// Only B-tree keys carry meaningful flags, so other access methods keep the+/// bare key text - same rule as the transfer path.+fn postgres_index_column_sql(+ column: &str,+ is_expression: Option<bool>,+ opclass: Option<&str>,+ key_options: Option<i16>,+ db_type: DatabaseType,+) -> String {let trimmed = column.trim();- let is_expression = is_expression.unwrap_or(false);- if is_expression {- trimmed.to_string()- } else {- quote_id(column, db_type)+ let base = if is_expression.unwrap_or(false) { trimmed.to_string() } else { quote_id(column, db_type) };+ let with_opclass = match opclass.filter(|opclass| !opclass.is_empty()) {+ Some(opclass) => format!("{base} {opclass}"),+ None => base,+ };+ match key_options {+ Some(options) => format!(+ "{with_opclass} {} NULLS {}",+ if options & 1 != 0 { "DESC" } else { "ASC" },+ if options & 2 != 0 { "FIRST" } else { "LAST" }+ ),+ None => with_opclass,}}@@ -4030,7 +4052,19 @@ pub fn create_index_sql(table_name: &str, index: &IndexInfo, db_type: DatabaseTyif db_type == DatabaseType::Mysql {mysql_index_column_sql(column)} else if is_postgres_family_ddl(db_type) {- postgres_index_column_sql(column, index.key_is_expression.get(i).copied(), db_type)+ let opclass = index.column_opclasses.get(i).and_then(|opclass| opclass.as_deref());+ let key_options = index+ .index_type+ .as_deref()+ .filter(|index_type| index_type.trim().eq_ignore_ascii_case("btree"))+ .and_then(|_| index.key_options.get(i).copied());+ postgres_index_column_sql(+ column,+ index.key_is_expression.get(i).copied(),+ opclass,+ key_options,+ db_type,+ )} else {quote_id(column, db_type)}@@ -8499,6 +8533,139 @@ mod tests {assert!(!sql.contains(&format!("\"{expression_key_part}\"")));}+ #[test]+ fn postgres_sync_index_ddl_keeps_key_order_opclass_and_full_expression() {+ // Regression for #9988: `pg_index.indoption` (bit 0 = DESC, bit 1 = NULLS FIRST)+ // and `pg_index.indclass` were dropped by the sync DDL, so a published index came+ // back as plain ASC keys with default null ordering. The expression key part is+ // also asserted verbatim - the driver used to return it truncated to 63 bytes+ // because `COALESCE(name, text)` resolves to `name` (see postgres.rs).+ let expression_key_part =+ "(((category)::text = ANY ((ARRAY['industrial'::character varying, 'macro'::character varying])::text[])))";+ let new_index = index(IndexInfo {+ name: "index_repro_rank".to_string(),+ columns: vec![+ "((has_current_analysis AND (NOT dirty) AND researchable))".to_string(),+ "researchable".to_string(),+ expression_key_part.to_string(),+ "((new_events_24h > 0))".to_string(),+ "evidence_count".to_string(),+ "material_at".to_string(),+ "topic_id".to_string(),+ ],+ is_unique: false,+ is_primary: false,+ filter: Some("(NOT suppressed)".to_string()),+ index_type: Some("btree".to_string()),+ included_columns: None,+ comment: None,+ key_is_expression: vec![true, false, true, true, false, false, false],+ column_opclasses: vec![None, None, None, None, None, None, Some("pg_catalog.text_pattern_ops".to_string())],+ key_options: vec![3, 3, 3, 3, 3, 3, 3],+ constraint_backed: false,+ });++ let sql = generate_schema_sync_sql(+ &[TableDiff {+ diff_type: "modified".to_string(),+ object_type: Some("table".to_string()),+ name: "index_repro".to_string(),+ target_name: None,+ columns: None,+ indexes: Some(vec![IndexDiff {+ diff_type: "added".to_string(),+ name: new_index.name.clone(),+ source: Some(new_index),+ target: None,+ changes: vec![],+ }]),+ foreign_keys: None,+ triggers: None,+ ddl: None,+ target_ddl: None,+ source_table_comment: None,+ target_table_comment: None,+ sync_sql: None,+ }],+ &[],+ &[],+ &[],+ &[],+ DatabaseType::Postgres,+ Some("public"),+ false,+ None,+ &[],+ );++ assert!(+ sql.contains(+ "CREATE INDEX \"index_repro_rank\" ON \"public\".\"index_repro\" USING btree (((has_current_analysis AND (NOT dirty) AND researchable)) DESC NULLS FIRST, \"researchable\" DESC NULLS FIRST"+ ),+ "{sql}"+ );+ assert!(sql.contains(&format!("{expression_key_part} DESC NULLS FIRST")), "{sql}");+ assert!(sql.contains("\"topic_id\" pg_catalog.text_pattern_ops DESC NULLS FIRST"), "{sql}");+ assert!(sql.contains("WHERE (NOT suppressed);"), "{sql}");+ }++ #[test]+ fn postgres_sync_index_ddl_keeps_non_btree_keys_bare() {+ // `indoption` is only meaningful for B-tree keys, so a GIN index must not gain+ // `ASC NULLS LAST` suffixes even when the introspection reports the flags.+ let new_index = index(IndexInfo {+ name: "idx_payload_gin".to_string(),+ columns: vec!["payload".to_string()],+ is_unique: false,+ is_primary: false,+ filter: None,+ index_type: Some("gin".to_string()),+ included_columns: None,+ comment: None,+ key_is_expression: vec![false],+ column_opclasses: vec![Some("public.gin_trgm_ops".to_string())],+ key_options: vec![0],+ constraint_backed: false,+ });++ let sql = generate_schema_sync_sql(+ &[TableDiff {+ diff_type: "modified".to_string(),+ object_type: Some("table".to_string()),+ name: "events".to_string(),+ target_name: None,+ columns: None,+ indexes: Some(vec![IndexDiff {+ diff_type: "added".to_string(),+ name: new_index.name.clone(),+ source: Some(new_index),+ target: None,+ changes: vec![],+ }]),+ foreign_keys: None,+ triggers: None,+ ddl: None,+ target_ddl: None,+ source_table_comment: None,+ target_table_comment: None,+ sync_sql: None,+ }],+ &[],+ &[],+ &[],+ &[],+ DatabaseType::Postgres,+ Some("public"),+ false,+ None,+ &[],+ );++ assert!(sql.contains("USING gin (\"payload\" public.gin_trgm_ops)"), "{sql}");+ assert!(!sql.contains("NULLS LAST"), "{sql}");+ assert!(!sql.contains("NULLS FIRST"), "{sql}");+ }+#[test]fn quotes_real_columns_whose_names_contain_expression_like_characters() {// PR #6312 review: a quoted column identifier can legitimately contain whitespace,