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(db2): preserve identifier and schema case in grid edits
Rendegou4b6896be3c16
diff --git a/apps/desktop/src/stores/__tests__/queryStore.db2Identifiers.spec.ts b/apps/desktop/src/stores/__tests__/queryStore.db2Identifiers.spec.tsnew file mode 100644index 0000000000..fa2e647e5d--- /dev/null+++ b/apps/desktop/src/stores/__tests__/queryStore.db2Identifiers.spec.ts@@ -0,0 +1,92 @@+import { createPinia, setActivePinia } from "pinia";+import { beforeEach, describe, expect, it, vi } from "vitest";+import { analyzeEditableQueryEditability as analyzeSql } from "@/lib/sql/sqlAnalysis";++const mocks = vi.hoisted(() => ({+ getConfig: vi.fn(),+ getColumns: vi.fn(),+ listIndexes: vi.fn(),+ executeMulti: vi.fn(),+}));++vi.mock("@/lib/backend/api", () => ({+ analyzeEditableQueryEditability: vi.fn(async (sql: string) => analyzeSql(sql)),+ getColumns: mocks.getColumns,+ listIndexes: mocks.listIndexes,+ executeMulti: mocks.executeMulti,+ listObjects: vi.fn().mockResolvedValue([]),+ listTables: vi.fn().mockResolvedValue([]),+ prepareQueryPaginationExecutionPlan: vi.fn(async (options) => ({ sqlToExecute: options.sql, useAgentResultSession: false })),+ saveOpenTabsState: vi.fn().mockResolvedValue(undefined),+}));+vi.mock("@/stores/connectionStore", () => ({+ useConnectionStore: () => ({+ ensureConnected: vi.fn().mockResolvedValue(undefined),+ getConfig: mocks.getConfig,+ lookupLocalCompletionTables: () => [],+ recordConnectionLostError: vi.fn(),+ metadataGenerationFor: () => 0,+ }),+}));+vi.mock("@/stores/settingsStore", () => ({+ useSettingsStore: () => ({ editorSettings: { pageSize: 100, autoCalculateTotalRows: false } }),+}));++describe("DB2 query source identifiers", () => {+ beforeEach(async () => {+ vi.clearAllMocks();+ const { clearTableMetadataCache } = await import("@/lib/metadata/tableMetadataCache");+ clearTableMetadataCache();+ setActivePinia(createPinia());+ mocks.listIndexes.mockResolvedValue([]);+ mocks.executeMulti.mockResolvedValue([{ columns: ["TEST_TX1ID", "DESCRIPTION"], rows: [[7, "before"]], affected_rows: 0, execution_time_ms: 1 }]);+ });++ for (const dbType of ["db2", "jdbc"] as const) {+ it.each([+ { sql: "select * from test_tx1", schema: "MAXIMO", table: "TEST_TX1" },+ { sql: "select * from TEST_TX1", schema: "MAXIMO", table: "TEST_TX1" },+ { sql: "select * from maximo.test_tx1 t", schema: "MAXIMO", table: "TEST_TX1" },+ { sql: 'select * from "MAXIMO"."test_tx1"', schema: "MAXIMO", table: "test_tx1" },+ { sql: 'select * from "MiXeD"."Test_Tx1"', schema: "MiXeD", table: "Test_Tx1" },+ { sql: 'select * from "MiXeD".test_tx1', schema: "MiXeD", table: "TEST_TX1" },+ { sql: 'select * from maximo."Test_Tx1"', schema: "MAXIMO", table: "Test_Tx1" },+ { sql: "select * from test_tx1", schema: "MiXeD", table: "TEST_TX1", tabSchema: "MiXeD" },+ { sql: "select * from test_tx1", schema: "lower", table: "TEST_TX1", tabSchema: "lower" },+ ])(`resolves ${dbType} metadata and write identity for $sql in $schema`, async ({ sql, schema, table, tabSchema }: { sql: string; schema: string; table: string; tabSchema?: string }) => {+ mocks.getConfig.mockReturnValue({+ id: "db2-1",+ name: "DB2",+ db_type: dbType,+ database: "DBX8834",+ default_schema: "MAXIMO",+ ...(dbType === "jdbc" ? { connection_string: "jdbc:db2://localhost:50000/DBX8834" } : {}),+ });+ // Ordinary wrong identities miss metadata. For selected mixed/lowercase+ // schemas, also model a same-named table in the uppercase schema: finding+ // metadata there must not redirect writes away from the selected schema.+ mocks.getColumns.mockImplementation(async (_id, _database, requestedSchema, requestedTable) =>+ (requestedSchema === schema || (tabSchema && requestedSchema === schema.toUpperCase())) && requestedTable === table+ ? [+ { name: "TEST_TX1ID", data_type: "INTEGER", is_nullable: false, column_default: null, is_primary_key: true, extra: null },+ { name: "DESCRIPTION", data_type: "VARCHAR(100)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },+ ]+ : [],+ );+ const { useQueryStore } = await import("@/stores/queryStore");+ const store = useQueryStore();+ const tabId = store.createTab("db2-1", "DBX8834", "Query", "query", tabSchema ?? "MAXIMO");+ store.setAutoCommit(tabId, true);+ await store.executeTabSql(tabId, sql);+ const tab = store.tabs.find((entry) => entry.id === tabId)!;+ expect(tab.error).toBeUndefined();+ await vi.waitFor(() => expect(mocks.getColumns).toHaveBeenCalledWith("db2-1", "DBX8834", schema, table, undefined));+ await vi.waitFor(() => expect(tab.tableMeta?.primaryKeys).toEqual(["TEST_TX1ID"]));+ // The grid's UPDATE builder and DDL panel both consume this canonical identity.+ expect(tab.tableMeta).toMatchObject({ schema, tableName: table });+ expect(tab.queryAnalysis).toMatchObject({ schema, tableName: table });+ expect(tab.queryEditabilityReason).toBeUndefined();+ expect(tab.tableMeta?.columns.map((column) => column.name)).toEqual(["TEST_TX1ID", "DESCRIPTION"]);+ });+ }+});diff --git a/apps/desktop/src/stores/queryStore.ts b/apps/desktop/src/stores/queryStore.tsindex a7a95d8c3d..33bd60ce0a 100644--- a/apps/desktop/src/stores/queryStore.ts+++ b/apps/desktop/src/stores/queryStore.ts@@ -164,7 +164,7 @@ const GROUPED_DISPLAY_LIMITER_SCOPE_PREFIX = "query-column-comments:";const groupedDisplayMetadataLimiter = new MetadataTaskLimiter(GROUPED_DISPLAY_METADATA_CONCURRENCY, (event) => {console.debug("[DBX][metadata-load:grouped-display-limiter]", event);});-const UPPERCASE_FOLDED_METADATA_TYPES = new Set<string>([...ORACLE_LIKE_METADATA_TYPES, "saphana"]);+const UPPERCASE_FOLDED_METADATA_TYPES = new Set<string>([...ORACLE_LIKE_METADATA_TYPES, "saphana", "db2"]);// Engines whose SQL takes dbx's appended hidden primary-key projection. The rewrite// quotes the key through the engine's own semantic dialect adapter, so Dameng and// OceanBase Oracle mode ride the Oracle adapter and HighGo rides the PostgreSQL one@@ -6469,7 +6469,11 @@ export const useQueryStore = defineStore("query", () => {// schema was selected instead of assuming public (or the database name).const useCurrentPostgresSchema = (dbType === "postgres" || dbType === "kwdb") && !source.schema && !tab.schema;const resolvedSchema = (dbType === "sqlserver" && !source.schema) || (ORACLE_LIKE_METADATA_TYPES.has(metadataDbType) && !schema) || resolveAgentSearchPathSchema || useCurrentPostgresSchema ? "" : metadataSchemaForConnection(conn, metadataDatabase, schema || undefined);- const metadataSchema = normalizeUppercaseFoldedMetadataIdentifier(metadataDbType, resolvedSchema || undefined, source.schema ? source.schemaQuoted : false) || "";+ // DB2 switches the selected execution schema using a quoted identifier.+ // That context already names a physical schema; only an explicit SQL+ // schema token may need folding according to its quoting flag.+ const preserveSchemaCase = source.schema ? source.schemaQuoted : metadataDbType === "db2";+ const metadataSchema = normalizeUppercaseFoldedMetadataIdentifier(metadataDbType, resolvedSchema || undefined, preserveSchemaCase) || "";const metadataTableName = normalizeUppercaseFoldedMetadataIdentifier(metadataDbType, foldUnquotedPostgresMetadataIdentifier(metadataDbType, source.tableName, source.tableNameQuoted)!, source.tableNameQuoted)!;// An unqualified source resolves in the tab's current external catalog on// Doris-family federation: the statement executed there through thediff --git a/scripts/db2-identifiers-proof.py b/scripts/db2-identifiers-proof.pynew file mode 100644index 0000000000..ffcee87a4c--- /dev/null+++ b/scripts/db2-identifiers-proof.py@@ -0,0 +1,108 @@+"""DB2 catalog/write identity proof; run remotely with db2.env loaded (no secrets printed)."""+import json+import os+import subprocess+import uuid++schema = os.environ["DB2INSTANCE"].upper()+base = "DBX_CASE_" + uuid.uuid4().hex[:12].upper()+names = [base, base.lower(), "Dbx_Case_" + base[9:].lower()]+process = subprocess.Popen(+ ["java", "-jar", os.environ["DBX_DB2_AGENT_JAR"]],+ stdin=subprocess.PIPE, stdout=subprocess.PIPE, universal_newlines=True,+)+assert json.loads(process.stdout.readline())["ready"]+request_id = 0+created = []+created_schemas = []+++def rpc(method, **params):+ global request_id+ request_id += 1+ params["agentSessionId"] = "identifier-proof"+ process.stdin.write(json.dumps({"jsonrpc": "2.0", "id": request_id, "method": method, "params": params}) + "\n")+ process.stdin.flush()+ return json.loads(process.stdout.readline())+++def call(method, **params):+ response = rpc(method, **params)+ if "error" in response:+ raise RuntimeError(method + ": " + json.dumps(response["error"]))+ return response["result"]+++def quote(name):+ return '"' + name.replace('"', '""') + '"'+++def target(name, target_schema=schema):+ return quote(target_schema) + "." + quote(name)+++def query(sql, execution_schema=schema):+ return call("execute_query", sql=sql, schema=execution_schema, maxRows=10, timeoutSecs=15)+++try:+ call("open_session", host="127.0.0.1", port=50000, database=os.environ["DBNAME"],+ username=os.environ["DB2INSTANCE"], password=os.environ["DB2INST1_PASSWORD"])+ query("CREATE TABLE " + target(base) + " (TEST_TX1ID INTEGER NOT NULL PRIMARY KEY, DESCRIPTION VARCHAR(100))")+ created.append((schema, base))+ query("INSERT INTO " + target(base) + " VALUES (7, 'upper')")+ row = query("select * from " + base.lower())["rows"][0]+ assert int(row[0]) == 7 and row[1] == "upper", row+ assert call("get_columns", schema=schema, table=base.lower()) == []+ failure = rpc("execute_query", sql="UPDATE " + target(base.lower()) + " SET DESCRIPTION='bad' WHERE TEST_TX1ID=7", schema=schema)+ assert "-204" in json.dumps(failure.get("error", {})), failure+ print("BASELINE: unquoted lowercase SELECT succeeds; lowercase catalog lookup misses; quoted lowercase UPDATE returns -204")+ for name, value in zip(names[1:], ["lower", "mixed"]):+ query("CREATE TABLE " + target(name) + " (TEST_TX1ID INTEGER NOT NULL PRIMARY KEY, DESCRIPTION VARCHAR(100))")+ created.append((schema, name))+ query("INSERT INTO " + target(name) + " VALUES (7, '" + value + "')")+ for name, original in zip(names, ["upper", "lower", "mixed"]):+ columns = call("get_columns", schema=schema, table=name)+ assert [column["name"] for column in columns if column["is_primary_key"]] == ["TEST_TX1ID"], columns+ ddl = call("get_table_ddl", schema=schema, table=name)+ assert "TEST_TX1ID" in ddl and "DESCRIPTION" in ddl, ddl+ query("UPDATE " + target(name) + " SET \"DESCRIPTION\"='" + original + "-saved' WHERE \"TEST_TX1ID\"=7")+ row = query("SELECT * FROM " + target(name))["rows"][0]+ assert int(row[0]) == 7 and row[1] == original + "-saved", row+ print("PASS: " + name + " exact catalog identity, primary key, DDL and quoted UPDATE")+ # These are simultaneously existing, distinct physical objects. Unquoted SQL+ # must select the uppercase one even when a lowercase exact spelling exists.+ assert query("select * from " + schema.lower() + "." + base.lower())["rows"][0][1] == "upper-saved"+ print("PASS: unquoted schema/table select uppercase object; quoted lowercase/mixed objects remain distinct")+ namespace = "Dbx_Schema_" + uuid.uuid4().hex[:12]+ namespaces = [namespace.upper(), namespace.lower(), namespace]+ for selected_schema in namespaces:+ query("CREATE SCHEMA " + quote(selected_schema))+ created_schemas.append(selected_schema)+ query("CREATE TABLE " + target(base, selected_schema) + " (TEST_TX1ID INTEGER NOT NULL PRIMARY KEY, DESCRIPTION VARCHAR(100))")+ created.append((selected_schema, base))+ query("INSERT INTO " + target(base, selected_schema) + " VALUES (7, '" + selected_schema + "')")+ for selected_schema in namespaces:+ # DB2's selected execution schema is exact, even for unquoted table SQL.+ row = query("select * from " + base.lower(), selected_schema)["rows"][0]+ assert row[1] == selected_schema, row+ columns = call("get_columns", schema=selected_schema, table=base)+ assert [column["name"] for column in columns if column["is_primary_key"]] == ["TEST_TX1ID"]+ ddl = call("get_table_ddl", schema=selected_schema, table=base)+ assert "TEST_TX1ID" in ddl and "DESCRIPTION" in ddl+ query("UPDATE " + target(base, selected_schema) + " SET DESCRIPTION='" + selected_schema + "-saved' WHERE TEST_TX1ID=7", selected_schema)+ for selected_schema in namespaces:+ assert query("SELECT * FROM " + target(base, selected_schema))["rows"][0][1] == selected_schema + "-saved"+ print("PASS: selected uppercase/lowercase/mixed schemas preserve exact SELECT, catalog, DDL and write targets with same-named tables")+finally:+ try:+ for table_schema, name in reversed(created):+ query("DROP TABLE " + target(name, table_schema))+ for created_schema in reversed(created_schemas):+ query("DROP SCHEMA " + quote(created_schema) + " RESTRICT")+ print("CLEANUP: dropped " + str(len(created)) + " random proof tables")+ print("CLEANUP: dropped " + str(len(created_schemas)) + " random proof schemas")+ call("close_session")+ finally:+ process.stdin.close()+ process.wait(timeout=20)