🐛 fix(metadata): 修复多数据源主键唯一索引识别

- 统一 PG-like 数据源字段和索引元数据查询，支持 search_path 可见表

- 兼容 snake_case、布尔别名和字符串唯一索引标记

- 修复 DuckDB main/memory 路径解析，避免误判外部 catalog

- 补充前后端回归测试，覆盖可编辑结果定位和元数据重试路径

internal/db/duckdb_metadata.go

@@ -200,6 +200,12 @@ func normalizeDuckDBObjectPath(dbName string, tableName string) duckDBObjectPath
 	case 2:
 		if rawDB != "" {
 			dbParts := splitDuckDBQualifiedName(rawDB)
+			if len(dbParts) == 1 && (strings.EqualFold(dbParts[0], "main") || strings.EqualFold(dbParts[0], "memory")) {
+				return duckDBObjectPath{
+					Schema: normalizeDuckDBIdentifier(parts[0]),
+					Object: normalizeDuckDBIdentifier(parts[1]),
+				}
+			}
 			if len(dbParts) == 1 {
 				return duckDBObjectPath{
 					Catalog: normalizeDuckDBIdentifier(dbParts[0]),

internal/db/duckdb_metadata_test.go

@@ -226,6 +226,20 @@ func TestNormalizeDuckDBObjectPath_PreservesCatalogSchemaAndQuotedDots(t *testin
 	}
 }
 
+func TestNormalizeDuckDBObjectPath_DoesNotTreatMainDatabaseAsExternalCatalog(t *testing.T) {
+	t.Parallel()
+
+	path := normalizeDuckDBObjectPath("main", "main.events")
+	if path.Catalog != "" || path.Schema != "main" || path.Object != "events" {
+		t.Fatalf("unexpected duckdb main path: %+v", path)
+	}
+
+	memoryPath := normalizeDuckDBObjectPath("memory", "main.events")
+	if memoryPath.Catalog != "" || memoryPath.Schema != "main" || memoryPath.Object != "events" {
+		t.Fatalf("unexpected duckdb memory path: %+v", memoryPath)
+	}
+}
+
 func TestParseDuckDBExpressionList_KeepsQuotedExpressionsIntact(t *testing.T) {
 	t.Parallel()
 

internal/db/highgo_impl.go

@@ -250,178 +250,31 @@ func (h *HighGoDB) GetCreateStatement(dbName, tableName string) (string, error)
 }
 
 func (h *HighGoDB) GetColumns(dbName, tableName string) ([]connection.ColumnDefinition, error) {
-	schema := strings.TrimSpace(dbName)
-	if schema == "" {
-		schema = "public"
-	}
-	table := strings.TrimSpace(tableName)
+	schema, table := normalizePGLikeMetadataTable(dbName, tableName)
 	if table == "" {
 		return nil, fmt.Errorf("表名不能为空")
 	}
 
-	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
-
-	query := fmt.Sprintf(`
-SELECT
-	a.attname AS column_name,
-	pg_catalog.format_type(a.atttypid, a.atttypmod) AS data_type,
-	CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable,
-	pg_get_expr(ad.adbin, ad.adrelid) AS column_default,
-	col_description(a.attrelid, a.attnum) AS comment,
-	CASE WHEN pk.attname IS NOT NULL THEN 'PRI' ELSE '' END AS column_key
-FROM pg_class c
-JOIN pg_namespace n ON n.oid = c.relnamespace
-JOIN pg_attribute a ON a.attrelid = c.oid
-LEFT JOIN pg_attrdef ad ON ad.adrelid = c.oid AND ad.adnum = a.attnum
-LEFT JOIN (
-	SELECT i.indrelid, a3.attname
-	FROM pg_index i
-	JOIN pg_attribute a3 ON a3.attrelid = i.indrelid AND a3.attnum = ANY(i.indkey)
-	WHERE i.indisprimary
-) pk ON pk.indrelid = c.oid AND pk.attname = a.attname
-WHERE c.relkind IN ('r', 'p')
-  AND n.nspname = '%s'
-  AND c.relname = '%s'
-  AND a.attnum > 0
-  AND NOT a.attisdropped
-ORDER BY a.attnum`, esc(schema), esc(table))
-
-	data, _, err := h.Query(query)
+	data, _, err := h.Query(buildPGLikeColumnsMetadataQuery(schema, table))
 	if err != nil {
 		return nil, err
 	}
 
-	var columns []connection.ColumnDefinition
-	for _, row := range data {
-		col := connection.ColumnDefinition{
-			Name:     fmt.Sprintf("%v", row["column_name"]),
-			Type:     fmt.Sprintf("%v", row["data_type"]),
-			Nullable: fmt.Sprintf("%v", row["is_nullable"]),
-			Key:      fmt.Sprintf("%v", row["column_key"]),
-			Extra:    "",
-			Comment:  "",
-		}
-
-		if v, ok := row["comment"]; ok && v != nil {
-			col.Comment = fmt.Sprintf("%v", v)
-		}
-
-		if v, ok := row["column_default"]; ok && v != nil {
-			def := fmt.Sprintf("%v", v)
-			col.Default = &def
-			if strings.HasPrefix(strings.ToLower(strings.TrimSpace(def)), "nextval(") {
-				col.Extra = "auto_increment"
-			}
-		}
-
-		columns = append(columns, col)
-	}
-	return columns, nil
+	return buildPGLikeColumnDefinitions(data), nil
 }
 
 func (h *HighGoDB) GetIndexes(dbName, tableName string) ([]connection.IndexDefinition, error) {
-	schema := strings.TrimSpace(dbName)
-	if schema == "" {
-		schema = "public"
-	}
-	table := strings.TrimSpace(tableName)
+	schema, table := normalizePGLikeMetadataTable(dbName, tableName)
 	if table == "" {
 		return nil, fmt.Errorf("表名不能为空")
 	}
 
-	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
-
-	query := fmt.Sprintf(`
-SELECT
-	i.relname AS index_name,
-	a.attname AS column_name,
-	ix.indisunique AS is_unique,
-	x.ordinality AS seq_in_index,
-	am.amname AS index_type
-FROM pg_class t
-JOIN pg_namespace n ON n.oid = t.relnamespace
-JOIN pg_index ix ON t.oid = ix.indrelid
-JOIN pg_class i ON i.oid = ix.indexrelid
-JOIN pg_am am ON i.relam = am.oid
-JOIN unnest(ix.indkey) WITH ORDINALITY AS x(attnum, ordinality) ON TRUE
-JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = x.attnum
-WHERE t.relkind IN ('r', 'p')
-  AND t.relname = '%s'
-  AND n.nspname = '%s'
-ORDER BY i.relname, x.ordinality`, esc(table), esc(schema))
-
-	data, _, err := h.Query(query)
+	data, _, err := h.Query(buildPGLikeIndexesMetadataQuery(schema, table))
 	if err != nil {
 		return nil, err
 	}
 
-	parseBool := func(v interface{}) bool {
-		switch val := v.(type) {
-		case bool:
-			return val
-		case string:
-			s := strings.ToLower(strings.TrimSpace(val))
-			return s == "t" || s == "true" || s == "1" || s == "y" || s == "yes"
-		default:
-			s := strings.ToLower(strings.TrimSpace(fmt.Sprintf("%v", v)))
-			return s == "t" || s == "true" || s == "1" || s == "y" || s == "yes"
-		}
-	}
-
-	parseInt := func(v interface{}) int {
-		switch val := v.(type) {
-		case int:
-			return val
-		case int64:
-			return int(val)
-		case float64:
-			return int(val)
-		case string:
-			var n int
-			_, _ = fmt.Sscanf(strings.TrimSpace(val), "%d", &n)
-			return n
-		default:
-			var n int
-			_, _ = fmt.Sscanf(strings.TrimSpace(fmt.Sprintf("%v", v)), "%d", &n)
-			return n
-		}
-	}
-
-	var indexes []connection.IndexDefinition
-	for _, row := range data {
-		isUnique := false
-		if v, ok := row["is_unique"]; ok && v != nil {
-			isUnique = parseBool(v)
-		}
-
-		nonUnique := 1
-		if isUnique {
-			nonUnique = 0
-		}
-
-		seq := 0
-		if v, ok := row["seq_in_index"]; ok && v != nil {
-			seq = parseInt(v)
-		}
-
-		indexType := ""
-		if v, ok := row["index_type"]; ok && v != nil {
-			indexType = strings.ToUpper(fmt.Sprintf("%v", v))
-		}
-		if indexType == "" {
-			indexType = "BTREE"
-		}
-
-		idx := connection.IndexDefinition{
-			Name:       fmt.Sprintf("%v", row["index_name"]),
-			ColumnName: fmt.Sprintf("%v", row["column_name"]),
-			NonUnique:  nonUnique,
-			SeqInIndex: seq,
-			IndexType:  indexType,
-		}
-		indexes = append(indexes, idx)
-	}
-	return indexes, nil
+	return buildPGLikeIndexDefinitions(data), nil
 }
 
 func (h *HighGoDB) GetForeignKeys(dbName, tableName string) ([]connection.ForeignKeyDefinition, error) {

internal/db/kingbase_impl.go

@@ -443,264 +443,31 @@ func (k *KingbaseDB) GetCreateStatement(dbName, tableName string) (string, error
 }
 
 func (k *KingbaseDB) GetColumns(dbName, tableName string) ([]connection.ColumnDefinition, error) {
-	// 解析 schema.table 格式
-	schema := strings.TrimSpace(dbName)
-	table := strings.TrimSpace(tableName)
-
-	// 如果 tableName 包含 schema (格式: schema.table)
-	if parts := strings.SplitN(table, ".", 2); len(parts) == 2 {
-		parsedSchema := strings.TrimSpace(parts[0])
-		parsedTable := strings.TrimSpace(parts[1])
-		if parsedSchema != "" && parsedTable != "" {
-			schema = parsedSchema
-			table = parsedTable
-		}
-	}
-
-	// 如果仍然没有 schema,使用 current_schema()
-	// 这样可以自动匹配当前连接的 search_path
-	if schema == "" {
-		return k.getColumnsWithCurrentSchema(table)
-	}
-
+	schema, table := normalizePGLikeMetadataTable(dbName, tableName)
 	if table == "" {
 		return nil, fmt.Errorf("表名不能为空")
 	}
 
-	// 转义函数:处理单引号,移除双引号
-	esc := func(s string) string {
-		// 移除前后的双引号(如果存在)
-		s = strings.Trim(s, "\"")
-		// 转义单引号
-		return strings.ReplaceAll(s, "'", "''")
-	}
-
-	query := fmt.Sprintf(`
-SELECT
-	a.attname AS column_name,
-	pg_catalog.format_type(a.atttypid, a.atttypmod) AS data_type,
-	CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable,
-	pg_get_expr(ad.adbin, ad.adrelid) AS column_default,
-	col_description(a.attrelid, a.attnum) AS comment,
-	CASE WHEN pk.attname IS NOT NULL THEN 'PRI' ELSE '' END AS column_key
-FROM pg_class c
-JOIN pg_namespace n ON n.oid = c.relnamespace
-JOIN pg_attribute a ON a.attrelid = c.oid
-LEFT JOIN pg_attrdef ad ON ad.adrelid = c.oid AND ad.adnum = a.attnum
-LEFT JOIN (
-	SELECT i.indrelid, a3.attname
-	FROM pg_index i
-	JOIN pg_attribute a3 ON a3.attrelid = i.indrelid AND a3.attnum = ANY(i.indkey)
-	WHERE i.indisprimary
-) pk ON pk.indrelid = c.oid AND pk.attname = a.attname
-WHERE c.relkind IN ('r', 'p')
-	AND n.nspname = '%s'
-	AND c.relname = '%s'
-	AND a.attnum > 0
-	AND NOT a.attisdropped
-ORDER BY a.attnum`, esc(schema), esc(table))
-
-	data, _, err := k.Query(query)
+	data, _, err := k.Query(buildPGLikeColumnsMetadataQuery(schema, table))
 	if err != nil {
 		return nil, err
 	}
 
-	var columns []connection.ColumnDefinition
-	for _, row := range data {
-		col := connection.ColumnDefinition{
-			Name:     fmt.Sprintf("%v", row["column_name"]),
-			Type:     fmt.Sprintf("%v", row["data_type"]),
-			Nullable: fmt.Sprintf("%v", row["is_nullable"]),
-			Key:      fmt.Sprintf("%v", row["column_key"]),
-			Extra:    "",
-			Comment:  "",
-		}
-
-		if row["column_default"] != nil {
-			def := fmt.Sprintf("%v", row["column_default"])
-			col.Default = &def
-			if strings.HasPrefix(strings.ToLower(strings.TrimSpace(def)), "nextval(") {
-				col.Extra = "auto_increment"
-			}
-		}
-
-		if v, ok := row["comment"]; ok && v != nil {
-			col.Comment = fmt.Sprintf("%v", v)
-		}
-
-		columns = append(columns, col)
-	}
-	return columns, nil
-}
-
-// getColumnsWithCurrentSchema 使用 current_schema() 查询当前schema的表
-func (k *KingbaseDB) getColumnsWithCurrentSchema(tableName string) ([]connection.ColumnDefinition, error) {
-	table := strings.TrimSpace(tableName)
-	if table == "" {
-		return nil, fmt.Errorf("表名不能为空")
-	}
-
-	// 转义函数
-	esc := func(s string) string {
-		s = strings.Trim(s, "\"")
-		return strings.ReplaceAll(s, "'", "''")
-	}
-
-	// 使用 current_schema() 获取当前schema
-	query := fmt.Sprintf(`
-SELECT
-	a.attname AS column_name,
-	pg_catalog.format_type(a.atttypid, a.atttypmod) AS data_type,
-	CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable,
-	pg_get_expr(ad.adbin, ad.adrelid) AS column_default,
-	col_description(a.attrelid, a.attnum) AS comment,
-	CASE WHEN pk.attname IS NOT NULL THEN 'PRI' ELSE '' END AS column_key
-FROM pg_class c
-JOIN pg_namespace n ON n.oid = c.relnamespace
-JOIN pg_attribute a ON a.attrelid = c.oid
-LEFT JOIN pg_attrdef ad ON ad.adrelid = c.oid AND ad.adnum = a.attnum
-LEFT JOIN (
-	SELECT i.indrelid, a3.attname
-	FROM pg_index i
-	JOIN pg_attribute a3 ON a3.attrelid = i.indrelid AND a3.attnum = ANY(i.indkey)
-	WHERE i.indisprimary
-) pk ON pk.indrelid = c.oid AND pk.attname = a.attname
-WHERE c.relkind IN ('r', 'p')
-	AND n.nspname = current_schema()
-	AND c.relname = '%s'
-	AND a.attnum > 0
-	AND NOT a.attisdropped
-ORDER BY a.attnum`, esc(table))
-
-	data, _, err := k.Query(query)
-	if err != nil {
-		return nil, err
-	}
-
-	var columns []connection.ColumnDefinition
-	for _, row := range data {
-		col := connection.ColumnDefinition{
-			Name:     fmt.Sprintf("%v", row["column_name"]),
-			Type:     fmt.Sprintf("%v", row["data_type"]),
-			Nullable: fmt.Sprintf("%v", row["is_nullable"]),
-			Key:      fmt.Sprintf("%v", row["column_key"]),
-			Extra:    "",
-			Comment:  "",
-		}
-
-		if row["column_default"] != nil {
-			def := fmt.Sprintf("%v", row["column_default"])
-			col.Default = &def
-			if strings.HasPrefix(strings.ToLower(strings.TrimSpace(def)), "nextval(") {
-				col.Extra = "auto_increment"
-			}
-		}
-
-		if v, ok := row["comment"]; ok && v != nil {
-			col.Comment = fmt.Sprintf("%v", v)
-		}
-
-		columns = append(columns, col)
-	}
-	return columns, nil
+	return buildPGLikeColumnDefinitions(data), nil
 }
 
 func (k *KingbaseDB) GetIndexes(dbName, tableName string) ([]connection.IndexDefinition, error) {
-	// 解析 schema.table 格式
-	schema := strings.TrimSpace(dbName)
-	table := strings.TrimSpace(tableName)
-
-	// 如果 tableName 包含 schema (格式: schema.table)
-	if parts := strings.SplitN(table, ".", 2); len(parts) == 2 {
-		parsedSchema := strings.TrimSpace(parts[0])
-		parsedTable := strings.TrimSpace(parts[1])
-		if parsedSchema != "" && parsedTable != "" {
-			schema = parsedSchema
-			table = parsedTable
-		}
-	}
-
+	schema, table := normalizePGLikeMetadataTable(dbName, tableName)
 	if table == "" {
 		return nil, fmt.Errorf("表名不能为空")
 	}
 
-	// 转义函数:处理单引号,移除双引号
-	esc := func(s string) string {
-		s = strings.Trim(s, "\"")
-		return strings.ReplaceAll(s, "'", "''")
-	}
-
-	// 构建查询：如果没有指定schema,使用current_schema()
-	var query string
-	if schema != "" {
-		query = fmt.Sprintf(`
-			SELECT
-				i.relname as index_name,
-				a.attname as column_name,
-				ix.indisunique as is_unique
-			FROM
-				pg_class t,
-				pg_class i,
-				pg_index ix,
-				pg_attribute a,
-				pg_namespace n
-			WHERE
-				t.oid = ix.indrelid
-				AND i.oid = ix.indexrelid
-				AND a.attrelid = t.oid
-				AND a.attnum = ANY(ix.indkey)
-				AND t.relkind = 'r'
-				AND t.relname = '%s'
-				AND n.oid = t.relnamespace
-				AND n.nspname = '%s'
-		`, esc(table), esc(schema))
-	} else {
-		query = fmt.Sprintf(`
-			SELECT
-				i.relname as index_name,
-				a.attname as column_name,
-				ix.indisunique as is_unique
-			FROM
-				pg_class t,
-				pg_class i,
-				pg_index ix,
-				pg_attribute a,
-				pg_namespace n
-			WHERE
-				t.oid = ix.indrelid
-				AND i.oid = ix.indexrelid
-				AND a.attrelid = t.oid
-				AND a.attnum = ANY(ix.indkey)
-				AND t.relkind = 'r'
-				AND t.relname = '%s'
-				AND n.oid = t.relnamespace
-				AND n.nspname = current_schema()
-		`, esc(table))
-	}
-
-	data, _, err := k.Query(query)
+	data, _, err := k.Query(buildPGLikeIndexesMetadataQuery(schema, table))
 	if err != nil {
 		return nil, err
 	}
 
-	var indexes []connection.IndexDefinition
-	for _, row := range data {
-		nonUnique := 1
-		if val, ok := row["is_unique"]; ok {
-			if b, ok := val.(bool); ok && b {
-				nonUnique = 0
-			}
-		}
-
-		idx := connection.IndexDefinition{
-			Name:       fmt.Sprintf("%v", row["index_name"]),
-			ColumnName: fmt.Sprintf("%v", row["column_name"]),
-			NonUnique:  nonUnique,
-			IndexType:  "BTREE", // Default
-		}
-		indexes = append(indexes, idx)
-	}
-	return indexes, nil
+	return buildPGLikeIndexDefinitions(data), nil
 }
 
 func (k *KingbaseDB) GetForeignKeys(dbName, tableName string) ([]connection.ForeignKeyDefinition, error) {

internal/db/kingbase_impl_test.go

@@ -199,6 +199,50 @@ func TestKingbaseGetDatabasesFallsBackToCurrentDatabase(t *testing.T) {
 	}
 }
 
+func TestKingbaseGetIndexesParsesStringUniqueAndVisibleRelation(t *testing.T) {
+	registerFakeKingbaseDriverOnce.Do(func() {
+		sql.Register(fakeKingbaseDriverName, fakeKingbaseDriver{})
+	})
+
+	db, err := sql.Open(fakeKingbaseDriverName, "")
+	if err != nil {
+		t.Fatalf("open fake kingbase db failed: %v", err)
+	}
+	defer db.Close()
+
+	fakeKingbaseStateMu.Lock()
+	fakeKingbaseState.queryErr = nil
+	fakeKingbaseState.queryResults = map[string]fakeKingbaseQueryResult{}
+	fakeKingbaseState.lastQuery = ""
+	fakeKingbaseState.queries = nil
+	fakeKingbaseStateMu.Unlock()
+
+	client := &KingbaseDB{conn: db}
+	indexes, err := client.GetIndexes("", "users")
+	if err != nil {
+		t.Fatalf("GetIndexes returned error: %v", err)
+	}
+	if len(indexes) != 2 {
+		t.Fatalf("expected two index rows, got %+v", indexes)
+	}
+	if indexes[0].Name != "users_email_key" || indexes[0].ColumnName != "tenant_id" || indexes[0].NonUnique != 0 || indexes[0].SeqInIndex != 1 {
+		t.Fatalf("unexpected first index row: %+v", indexes[0])
+	}
+	if indexes[1].Name != "users_email_key" || indexes[1].ColumnName != "email" || indexes[1].NonUnique != 0 || indexes[1].SeqInIndex != 2 {
+		t.Fatalf("unexpected second index row: %+v", indexes[1])
+	}
+
+	fakeKingbaseStateMu.Lock()
+	lastQuery := fakeKingbaseState.lastQuery
+	fakeKingbaseStateMu.Unlock()
+	if !strings.Contains(lastQuery, "pg_catalog.pg_table_is_visible(t.oid)") {
+		t.Fatalf("expected search_path visible relation metadata query, got %s", lastQuery)
+	}
+	if strings.Contains(lastQuery, "current_schema()") || strings.Contains(lastQuery, "n.nspname = 'public'") {
+		t.Fatalf("metadata query should not force current_schema/public, got %s", lastQuery)
+	}
+}
+
 type fakeKingbaseDriver struct{}
 
 func (fakeKingbaseDriver) Open(name string) (driver.Conn, error) {
@@ -230,6 +274,15 @@ func (fakeKingbaseConn) QueryContext(ctx context.Context, query string, args []d
 		}
 		return &fakeKingbaseRows{columns: result.columns, rows: result.rows}, nil
 	}
+	if strings.Contains(query, "FROM pg_class t") && strings.Contains(query, "JOIN pg_index ix") && strings.Contains(query, "t.relname = 'users'") {
+		return &fakeKingbaseRows{
+			columns: []string{"index_name", "column_name", "is_unique", "seq_in_index", "index_type"},
+			rows: [][]driver.Value{
+				{"users_email_key", "tenant_id", "t", "1", "btree"},
+				{"users_email_key", "email", "t", "2", "btree"},
+			},
+		}, nil
+	}
 	if fakeKingbaseState.queryErr != nil {
 		return nil, fakeKingbaseState.queryErr
 	}

internal/db/metadata_value.go

@@ -0,0 +1,44 @@
+package db
+
+import (
+	"fmt"
+	"strings"
+)
+
+func parseMetadataBool(value interface{}) bool {
+	switch val := value.(type) {
+	case bool:
+		return val
+	case int:
+		return val != 0
+	case int64:
+		return val != 0
+	case float64:
+		return val != 0
+	case string:
+		text := strings.ToLower(strings.TrimSpace(val))
+		return text == "t" || text == "true" || text == "1" || text == "y" || text == "yes" || text == "unique"
+	default:
+		text := strings.ToLower(strings.TrimSpace(fmt.Sprintf("%v", value)))
+		return text == "t" || text == "true" || text == "1" || text == "y" || text == "yes" || text == "unique"
+	}
+}
+
+func parseMetadataInt(value interface{}) int {
+	switch val := value.(type) {
+	case int:
+		return val
+	case int64:
+		return int(val)
+	case float64:
+		return int(val)
+	case string:
+		var n int
+		_, _ = fmt.Sscanf(strings.TrimSpace(val), "%d", &n)
+		return n
+	default:
+		var n int
+		_, _ = fmt.Sscanf(strings.TrimSpace(fmt.Sprintf("%v", value)), "%d", &n)
+		return n
+	}
+}

internal/db/pg_metadata.go

@@ -0,0 +1,159 @@
+package db
+
+import (
+	"fmt"
+	"strings"
+
+	"GoNavi-Wails/internal/connection"
+)
+
+func normalizePGLikeMetadataTable(schemaName, tableName string) (string, string) {
+	schema := strings.TrimSpace(schemaName)
+	table := strings.TrimSpace(tableName)
+	if parsedSchema, parsedTable := SplitSQLQualifiedName(table); parsedSchema != "" && parsedTable != "" {
+		schema = parsedSchema
+		table = parsedTable
+	}
+	schema = strings.TrimSpace(normalizeSQLIdentifierEscapes(schema))
+	table = strings.TrimSpace(normalizeSQLIdentifierEscapes(table))
+	schema = strings.Trim(schema, `"`)
+	table = strings.Trim(table, `"`)
+	return schema, table
+}
+
+func escapePGLikeMetadataLiteral(raw string) string {
+	text := strings.TrimSpace(raw)
+	text = strings.Trim(text, `"`)
+	return strings.ReplaceAll(text, "'", "''")
+}
+
+func buildPGLikeVisibleRelationPredicate(alias string, schemaName string) string {
+	relAlias := strings.TrimSpace(alias)
+	if relAlias == "" {
+		relAlias = "c"
+	}
+	if strings.TrimSpace(schemaName) == "" {
+		return fmt.Sprintf("pg_catalog.pg_table_is_visible(%s.oid)", relAlias)
+	}
+	return fmt.Sprintf("n.nspname = '%s'", escapePGLikeMetadataLiteral(schemaName))
+}
+
+func buildPGLikeColumnsMetadataQuery(schemaName, tableName string) string {
+	return fmt.Sprintf(`
+SELECT
+	a.attname AS column_name,
+	pg_catalog.format_type(a.atttypid, a.atttypmod) AS data_type,
+	CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable,
+	pg_get_expr(ad.adbin, ad.adrelid) AS column_default,
+	col_description(a.attrelid, a.attnum) AS comment,
+	CASE WHEN pk.attname IS NOT NULL THEN 'PRI' ELSE '' END AS column_key
+FROM pg_class c
+JOIN pg_namespace n ON n.oid = c.relnamespace
+JOIN pg_attribute a ON a.attrelid = c.oid
+LEFT JOIN pg_attrdef ad ON ad.adrelid = c.oid AND ad.adnum = a.attnum
+LEFT JOIN (
+	SELECT i.indrelid, a3.attname
+	FROM pg_index i
+	JOIN pg_attribute a3 ON a3.attrelid = i.indrelid AND a3.attnum = ANY(i.indkey)
+	WHERE i.indisprimary
+) pk ON pk.indrelid = c.oid AND pk.attname = a.attname
+WHERE c.relkind IN ('r', 'p')
+  AND %s
+  AND c.relname = '%s'
+  AND a.attnum > 0
+  AND NOT a.attisdropped
+ORDER BY a.attnum`, buildPGLikeVisibleRelationPredicate("c", schemaName), escapePGLikeMetadataLiteral(tableName))
+}
+
+func buildPGLikeIndexesMetadataQuery(schemaName, tableName string) string {
+	return fmt.Sprintf(`
+SELECT
+	i.relname AS index_name,
+	a.attname AS column_name,
+	ix.indisunique AS is_unique,
+	x.ordinality AS seq_in_index,
+	am.amname AS index_type
+FROM pg_class t
+JOIN pg_namespace n ON n.oid = t.relnamespace
+JOIN pg_index ix ON t.oid = ix.indrelid
+JOIN pg_class i ON i.oid = ix.indexrelid
+JOIN pg_am am ON i.relam = am.oid
+JOIN unnest(ix.indkey) WITH ORDINALITY AS x(attnum, ordinality) ON TRUE
+JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = x.attnum
+WHERE t.relkind IN ('r', 'p')
+  AND t.relname = '%s'
+  AND %s
+  AND ix.indisvalid
+  AND ix.indpred IS NULL
+  AND x.ordinality <= ix.indnkeyatts
+  AND NOT EXISTS (
+    SELECT 1 FROM unnest(ix.indkey) AS expr_key(attnum) WHERE expr_key.attnum <= 0
+  )
+ORDER BY i.relname, x.ordinality`, escapePGLikeMetadataLiteral(tableName), buildPGLikeVisibleRelationPredicate("t", schemaName))
+}
+
+func buildPGLikeColumnDefinitions(data []map[string]interface{}) []connection.ColumnDefinition {
+	columns := make([]connection.ColumnDefinition, 0, len(data))
+	for _, row := range data {
+		col := connection.ColumnDefinition{
+			Name:     fmt.Sprintf("%v", row["column_name"]),
+			Type:     fmt.Sprintf("%v", row["data_type"]),
+			Nullable: fmt.Sprintf("%v", row["is_nullable"]),
+			Key:      fmt.Sprintf("%v", row["column_key"]),
+			Extra:    "",
+			Comment:  "",
+		}
+
+		if v, ok := row["comment"]; ok && v != nil {
+			col.Comment = fmt.Sprintf("%v", v)
+		}
+
+		if v, ok := row["column_default"]; ok && v != nil {
+			def := fmt.Sprintf("%v", v)
+			col.Default = &def
+			if strings.HasPrefix(strings.ToLower(strings.TrimSpace(def)), "nextval(") {
+				col.Extra = "auto_increment"
+			}
+		}
+
+		columns = append(columns, col)
+	}
+	return columns
+}
+
+func buildPGLikeIndexDefinitions(data []map[string]interface{}) []connection.IndexDefinition {
+	indexes := make([]connection.IndexDefinition, 0, len(data))
+	for _, row := range data {
+		isUnique := false
+		if v, ok := row["is_unique"]; ok && v != nil {
+			isUnique = parseMetadataBool(v)
+		}
+
+		nonUnique := 1
+		if isUnique {
+			nonUnique = 0
+		}
+
+		seq := 0
+		if v, ok := row["seq_in_index"]; ok && v != nil {
+			seq = parseMetadataInt(v)
+		}
+
+		indexType := ""
+		if v, ok := row["index_type"]; ok && v != nil {
+			indexType = strings.ToUpper(fmt.Sprintf("%v", v))
+		}
+		if indexType == "" {
+			indexType = "BTREE"
+		}
+
+		indexes = append(indexes, connection.IndexDefinition{
+			Name:       fmt.Sprintf("%v", row["index_name"]),
+			ColumnName: fmt.Sprintf("%v", row["column_name"]),
+			NonUnique:  nonUnique,
+			SeqInIndex: seq,
+			IndexType:  indexType,
+		})
+	}
+	return indexes
+}

internal/db/pg_metadata_test.go

@@ -0,0 +1,80 @@
+package db
+
+import (
+	"strings"
+	"testing"
+)
+
+func TestBuildPGLikeMetadataQueriesUseVisibleRelationForPureTable(t *testing.T) {
+	t.Parallel()
+
+	columnQuery := buildPGLikeColumnsMetadataQuery("", "users")
+	if !strings.Contains(columnQuery, "pg_catalog.pg_table_is_visible(c.oid)") {
+		t.Fatalf("expected visible relation predicate for column metadata, got %s", columnQuery)
+	}
+	if strings.Contains(columnQuery, "n.nspname = 'public'") || strings.Contains(columnQuery, "current_schema()") {
+		t.Fatalf("pure table column metadata should not force public/current_schema, got %s", columnQuery)
+	}
+
+	indexQuery := buildPGLikeIndexesMetadataQuery("", "users")
+	if !strings.Contains(indexQuery, "pg_catalog.pg_table_is_visible(t.oid)") {
+		t.Fatalf("expected visible relation predicate for index metadata, got %s", indexQuery)
+	}
+	if strings.Contains(indexQuery, "n.nspname = 'public'") || strings.Contains(indexQuery, "current_schema()") {
+		t.Fatalf("pure table index metadata should not force public/current_schema, got %s", indexQuery)
+	}
+}
+
+func TestBuildPGLikeMetadataQueriesKeepExplicitSchema(t *testing.T) {
+	t.Parallel()
+
+	columnQuery := buildPGLikeColumnsMetadataQuery("audit", "users")
+	if !strings.Contains(columnQuery, "n.nspname = 'audit'") {
+		t.Fatalf("expected explicit schema predicate, got %s", columnQuery)
+	}
+	if strings.Contains(columnQuery, "pg_catalog.pg_table_is_visible") {
+		t.Fatalf("explicit schema metadata should not use visibility predicate, got %s", columnQuery)
+	}
+}
+
+func TestBuildPGLikeColumnDefinitionsMarksPrimaryKey(t *testing.T) {
+	t.Parallel()
+
+	columns := buildPGLikeColumnDefinitions([]map[string]interface{}{
+		{
+			"column_name":    "id",
+			"data_type":      "bigint",
+			"is_nullable":    "NO",
+			"column_default": "nextval('users_id_seq'::regclass)",
+			"column_key":     "PRI",
+		},
+	})
+
+	if len(columns) != 1 {
+		t.Fatalf("unexpected column count: %d", len(columns))
+	}
+	if columns[0].Name != "id" || columns[0].Key != "PRI" || columns[0].Extra != "auto_increment" {
+		t.Fatalf("unexpected primary key column: %+v", columns[0])
+	}
+}
+
+func TestBuildPGLikeIndexDefinitionsParsesStringUnique(t *testing.T) {
+	t.Parallel()
+
+	indexes := buildPGLikeIndexDefinitions([]map[string]interface{}{
+		{
+			"index_name":   "users_email_key",
+			"column_name":  "email",
+			"is_unique":    "t",
+			"seq_in_index": "1",
+			"index_type":   "btree",
+		},
+	})
+
+	if len(indexes) != 1 {
+		t.Fatalf("unexpected index count: %d", len(indexes))
+	}
+	if indexes[0].Name != "users_email_key" || indexes[0].ColumnName != "email" || indexes[0].NonUnique != 0 || indexes[0].SeqInIndex != 1 {
+		t.Fatalf("unexpected unique index metadata: %+v", indexes[0])
+	}
+}

internal/db/postgres_impl.go

@@ -355,185 +355,31 @@ func (p *PostgresDB) GetCreateStatement(dbName, tableName string) (string, error
 }
 
 func (p *PostgresDB) GetColumns(dbName, tableName string) ([]connection.ColumnDefinition, error) {
-	schema := strings.TrimSpace(dbName)
-	if schema == "" {
-		schema = "public"
-	}
-	table := strings.TrimSpace(tableName)
+	schema, table := normalizePGLikeMetadataTable(dbName, tableName)
 	if table == "" {
 		return nil, fmt.Errorf("表名不能为空")
 	}
 
-	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
-
-	query := fmt.Sprintf(`
-SELECT
-	a.attname AS column_name,
-	pg_catalog.format_type(a.atttypid, a.atttypmod) AS data_type,
-	CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable,
-	pg_get_expr(ad.adbin, ad.adrelid) AS column_default,
-	col_description(a.attrelid, a.attnum) AS comment,
-	CASE WHEN pk.attname IS NOT NULL THEN 'PRI' ELSE '' END AS column_key
-FROM pg_class c
-JOIN pg_namespace n ON n.oid = c.relnamespace
-JOIN pg_attribute a ON a.attrelid = c.oid
-LEFT JOIN pg_attrdef ad ON ad.adrelid = c.oid AND ad.adnum = a.attnum
-LEFT JOIN (
-	SELECT i.indrelid, a3.attname
-	FROM pg_index i
-	JOIN pg_attribute a3 ON a3.attrelid = i.indrelid AND a3.attnum = ANY(i.indkey)
-	WHERE i.indisprimary
-) pk ON pk.indrelid = c.oid AND pk.attname = a.attname
-WHERE c.relkind IN ('r', 'p')
-  AND n.nspname = '%s'
-  AND c.relname = '%s'
-  AND a.attnum > 0
-  AND NOT a.attisdropped
-ORDER BY a.attnum`, esc(schema), esc(table))
-
-	data, _, err := p.Query(query)
+	data, _, err := p.Query(buildPGLikeColumnsMetadataQuery(schema, table))
 	if err != nil {
 		return nil, err
 	}
 
-	var columns []connection.ColumnDefinition
-	for _, row := range data {
-		col := connection.ColumnDefinition{
-			Name:     fmt.Sprintf("%v", row["column_name"]),
-			Type:     fmt.Sprintf("%v", row["data_type"]),
-			Nullable: fmt.Sprintf("%v", row["is_nullable"]),
-			Key:      fmt.Sprintf("%v", row["column_key"]),
-			Extra:    "",
-			Comment:  "",
-		}
-
-		if v, ok := row["comment"]; ok && v != nil {
-			col.Comment = fmt.Sprintf("%v", v)
-		}
-
-		if v, ok := row["column_default"]; ok && v != nil {
-			def := fmt.Sprintf("%v", v)
-			col.Default = &def
-			if strings.HasPrefix(strings.ToLower(strings.TrimSpace(def)), "nextval(") {
-				col.Extra = "auto_increment"
-			}
-		}
-
-		columns = append(columns, col)
-	}
-	return columns, nil
+	return buildPGLikeColumnDefinitions(data), nil
 }
 
 func (p *PostgresDB) GetIndexes(dbName, tableName string) ([]connection.IndexDefinition, error) {
-	schema := strings.TrimSpace(dbName)
-	if schema == "" {
-		schema = "public"
-	}
-	table := strings.TrimSpace(tableName)
+	schema, table := normalizePGLikeMetadataTable(dbName, tableName)
 	if table == "" {
 		return nil, fmt.Errorf("表名不能为空")
 	}
 
-	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
-
-	query := fmt.Sprintf(`
-SELECT
-	i.relname AS index_name,
-	a.attname AS column_name,
-	ix.indisunique AS is_unique,
-	x.ordinality AS seq_in_index,
-	am.amname AS index_type
-FROM pg_class t
-JOIN pg_namespace n ON n.oid = t.relnamespace
-JOIN pg_index ix ON t.oid = ix.indrelid
-JOIN pg_class i ON i.oid = ix.indexrelid
-JOIN pg_am am ON i.relam = am.oid
-JOIN unnest(ix.indkey) WITH ORDINALITY AS x(attnum, ordinality) ON TRUE
-JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = x.attnum
-WHERE t.relkind IN ('r', 'p')
-  AND t.relname = '%s'
-  AND n.nspname = '%s'
-  AND ix.indisvalid
-  AND ix.indpred IS NULL
-  AND x.ordinality <= ix.indnkeyatts
-  AND NOT EXISTS (
-    SELECT 1 FROM unnest(ix.indkey) AS expr_key(attnum) WHERE expr_key.attnum <= 0
-  )
-ORDER BY i.relname, x.ordinality`, esc(table), esc(schema))
-
-	data, _, err := p.Query(query)
+	data, _, err := p.Query(buildPGLikeIndexesMetadataQuery(schema, table))
 	if err != nil {
 		return nil, err
 	}
 
-	parseBool := func(v interface{}) bool {
-		switch val := v.(type) {
-		case bool:
-			return val
-		case string:
-			s := strings.ToLower(strings.TrimSpace(val))
-			return s == "t" || s == "true" || s == "1" || s == "y" || s == "yes"
-		default:
-			s := strings.ToLower(strings.TrimSpace(fmt.Sprintf("%v", v)))
-			return s == "t" || s == "true" || s == "1" || s == "y" || s == "yes"
-		}
-	}
-
-	parseInt := func(v interface{}) int {
-		switch val := v.(type) {
-		case int:
-			return val
-		case int64:
-			return int(val)
-		case float64:
-			return int(val)
-		case string:
-			// best effort
-			var n int
-			_, _ = fmt.Sscanf(strings.TrimSpace(val), "%d", &n)
-			return n
-		default:
-			var n int
-			_, _ = fmt.Sscanf(strings.TrimSpace(fmt.Sprintf("%v", v)), "%d", &n)
-			return n
-		}
-	}
-
-	var indexes []connection.IndexDefinition
-	for _, row := range data {
-		isUnique := false
-		if v, ok := row["is_unique"]; ok && v != nil {
-			isUnique = parseBool(v)
-		}
-
-		nonUnique := 1
-		if isUnique {
-			nonUnique = 0
-		}
-
-		seq := 0
-		if v, ok := row["seq_in_index"]; ok && v != nil {
-			seq = parseInt(v)
-		}
-
-		indexType := ""
-		if v, ok := row["index_type"]; ok && v != nil {
-			indexType = strings.ToUpper(fmt.Sprintf("%v", v))
-		}
-		if indexType == "" {
-			indexType = "BTREE"
-		}
-
-		idx := connection.IndexDefinition{
-			Name:       fmt.Sprintf("%v", row["index_name"]),
-			ColumnName: fmt.Sprintf("%v", row["column_name"]),
-			NonUnique:  nonUnique,
-			SeqInIndex: seq,
-			IndexType:  indexType,
-		}
-		indexes = append(indexes, idx)
-	}
-	return indexes, nil
+	return buildPGLikeIndexDefinitions(data), nil
 }
 
 func (p *PostgresDB) GetForeignKeys(dbName, tableName string) ([]connection.ForeignKeyDefinition, error) {

internal/db/vastbase_impl.go

@@ -249,178 +249,31 @@ func (v *VastbaseDB) GetCreateStatement(dbName, tableName string) (string, error
 }
 
 func (v *VastbaseDB) GetColumns(dbName, tableName string) ([]connection.ColumnDefinition, error) {
-	schema := strings.TrimSpace(dbName)
-	if schema == "" {
-		schema = "public"
-	}
-	table := strings.TrimSpace(tableName)
+	schema, table := normalizePGLikeMetadataTable(dbName, tableName)
 	if table == "" {
 		return nil, fmt.Errorf("表名不能为空")
 	}
 
-	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
-
-	query := fmt.Sprintf(`
-SELECT
-	a.attname AS column_name,
-	pg_catalog.format_type(a.atttypid, a.atttypmod) AS data_type,
-	CASE WHEN a.attnotnull THEN 'NO' ELSE 'YES' END AS is_nullable,
-	pg_get_expr(ad.adbin, ad.adrelid) AS column_default,
-	col_description(a.attrelid, a.attnum) AS comment,
-	CASE WHEN pk.attname IS NOT NULL THEN 'PRI' ELSE '' END AS column_key
-FROM pg_class c
-JOIN pg_namespace n ON n.oid = c.relnamespace
-JOIN pg_attribute a ON a.attrelid = c.oid
-LEFT JOIN pg_attrdef ad ON ad.adrelid = c.oid AND ad.adnum = a.attnum
-LEFT JOIN (
-	SELECT i.indrelid, a3.attname
-	FROM pg_index i
-	JOIN pg_attribute a3 ON a3.attrelid = i.indrelid AND a3.attnum = ANY(i.indkey)
-	WHERE i.indisprimary
-) pk ON pk.indrelid = c.oid AND pk.attname = a.attname
-WHERE c.relkind IN ('r', 'p')
-  AND n.nspname = '%s'
-  AND c.relname = '%s'
-  AND a.attnum > 0
-  AND NOT a.attisdropped
-ORDER BY a.attnum`, esc(schema), esc(table))
-
-	data, _, err := v.Query(query)
+	data, _, err := v.Query(buildPGLikeColumnsMetadataQuery(schema, table))
 	if err != nil {
 		return nil, err
 	}
 
-	var columns []connection.ColumnDefinition
-	for _, row := range data {
-		col := connection.ColumnDefinition{
-			Name:     fmt.Sprintf("%v", row["column_name"]),
-			Type:     fmt.Sprintf("%v", row["data_type"]),
-			Nullable: fmt.Sprintf("%v", row["is_nullable"]),
-			Key:      fmt.Sprintf("%v", row["column_key"]),
-			Extra:    "",
-			Comment:  "",
-		}
-
-		if val, ok := row["comment"]; ok && val != nil {
-			col.Comment = fmt.Sprintf("%v", val)
-		}
-
-		if val, ok := row["column_default"]; ok && val != nil {
-			def := fmt.Sprintf("%v", val)
-			col.Default = &def
-			if strings.HasPrefix(strings.ToLower(strings.TrimSpace(def)), "nextval(") {
-				col.Extra = "auto_increment"
-			}
-		}
-
-		columns = append(columns, col)
-	}
-	return columns, nil
+	return buildPGLikeColumnDefinitions(data), nil
 }
 
 func (v *VastbaseDB) GetIndexes(dbName, tableName string) ([]connection.IndexDefinition, error) {
-	schema := strings.TrimSpace(dbName)
-	if schema == "" {
-		schema = "public"
-	}
-	table := strings.TrimSpace(tableName)
+	schema, table := normalizePGLikeMetadataTable(dbName, tableName)
 	if table == "" {
 		return nil, fmt.Errorf("表名不能为空")
 	}
 
-	esc := func(s string) string { return strings.ReplaceAll(s, "'", "''") }
-
-	query := fmt.Sprintf(`
-SELECT
-	i.relname AS index_name,
-	a.attname AS column_name,
-	ix.indisunique AS is_unique,
-	x.ordinality AS seq_in_index,
-	am.amname AS index_type
-FROM pg_class t
-JOIN pg_namespace n ON n.oid = t.relnamespace
-JOIN pg_index ix ON t.oid = ix.indrelid
-JOIN pg_class i ON i.oid = ix.indexrelid
-JOIN pg_am am ON i.relam = am.oid
-JOIN unnest(ix.indkey) WITH ORDINALITY AS x(attnum, ordinality) ON TRUE
-JOIN pg_attribute a ON a.attrelid = t.oid AND a.attnum = x.attnum
-WHERE t.relkind IN ('r', 'p')
-  AND t.relname = '%s'
-  AND n.nspname = '%s'
-ORDER BY i.relname, x.ordinality`, esc(table), esc(schema))
-
-	data, _, err := v.Query(query)
+	data, _, err := v.Query(buildPGLikeIndexesMetadataQuery(schema, table))
 	if err != nil {
 		return nil, err
 	}
 
-	parseBool := func(val interface{}) bool {
-		switch v := val.(type) {
-		case bool:
-			return v
-		case string:
-			s := strings.ToLower(strings.TrimSpace(v))
-			return s == "t" || s == "true" || s == "1" || s == "y" || s == "yes"
-		default:
-			s := strings.ToLower(strings.TrimSpace(fmt.Sprintf("%v", val)))
-			return s == "t" || s == "true" || s == "1" || s == "y" || s == "yes"
-		}
-	}
-
-	parseInt := func(val interface{}) int {
-		switch v := val.(type) {
-		case int:
-			return v
-		case int64:
-			return int(v)
-		case float64:
-			return int(v)
-		case string:
-			var n int
-			_, _ = fmt.Sscanf(strings.TrimSpace(v), "%d", &n)
-			return n
-		default:
-			var n int
-			_, _ = fmt.Sscanf(strings.TrimSpace(fmt.Sprintf("%v", val)), "%d", &n)
-			return n
-		}
-	}
-
-	var indexes []connection.IndexDefinition
-	for _, row := range data {
-		isUnique := false
-		if val, ok := row["is_unique"]; ok && val != nil {
-			isUnique = parseBool(val)
-		}
-
-		nonUnique := 1
-		if isUnique {
-			nonUnique = 0
-		}
-
-		seq := 0
-		if val, ok := row["seq_in_index"]; ok && val != nil {
-			seq = parseInt(val)
-		}
-
-		indexType := ""
-		if val, ok := row["index_type"]; ok && val != nil {
-			indexType = strings.ToUpper(fmt.Sprintf("%v", val))
-		}
-		if indexType == "" {
-			indexType = "BTREE"
-		}
-
-		idx := connection.IndexDefinition{
-			Name:       fmt.Sprintf("%v", row["index_name"]),
-			ColumnName: fmt.Sprintf("%v", row["column_name"]),
-			NonUnique:  nonUnique,
-			SeqInIndex: seq,
-			IndexType:  indexType,
-		}
-		indexes = append(indexes, idx)
-	}
-	return indexes, nil
+	return buildPGLikeIndexDefinitions(data), nil
 }
 
 func (v *VastbaseDB) GetForeignKeys(dbName, tableName string) ([]connection.ForeignKeyDefinition, error) {