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。

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.ts
new file mode 100644
index 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.ts
index 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 the
diff --git a/scripts/db2-identifiers-proof.py b/scripts/db2-identifiers-proof.py
new file mode 100644
index 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)