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(oracle): support sequence and pseudo-column completion
lxk955eda4d3e2d505
diff --git a/agents/drivers/oracle-go/main.go b/agents/drivers/oracle-go/main.goindex e852bd984e..4c126c75b2 100644--- a/agents/drivers/oracle-go/main.go+++ b/agents/drivers/oracle-go/main.go@@ -2004,7 +2004,7 @@ func completionRequestHasTableLikeKind(kinds []string) bool {func completionRequestHasRoutineKind(kinds []string) bool {for _, kind := range kinds {switch strings.ToLower(strings.TrimSpace(kind)) {- case "routine", "procedure", "function":+ case "routine", "procedure", "function", "sequence":return true}}@@ -2450,13 +2450,54 @@ func oracleCompletionSynonymTargetsQuery(targets []oracleCompletionSynonymTarget}}+func oracleCompletionRoutineObjectTypes(kinds []string) []string {+ if len(kinds) == 0 {+ return []string{"'FUNCTION'", "'PROCEDURE'", "'PACKAGE'", "'SEQUENCE'"}+ }+ hasRoutine := false+ hasProc := false+ hasFunc := false+ hasSeq := false+ for _, kind := range kinds {+ switch strings.ToLower(strings.TrimSpace(kind)) {+ case "routine":+ hasRoutine = true+ case "procedure":+ hasProc = true+ case "function":+ hasFunc = true+ case "sequence":+ hasSeq = true+ }+ }+ types := make([]string, 0, 4)+ if hasRoutine {+ types = append(types, "'FUNCTION'", "'PROCEDURE'", "'PACKAGE'")+ } else {+ if hasProc {+ types = append(types, "'PROCEDURE'")+ }+ if hasFunc {+ types = append(types, "'FUNCTION'")+ }+ }+ if hasSeq {+ types = append(types, "'SEQUENCE'")+ }+ if len(types) == 0 {+ return []string{"'FUNCTION'", "'PROCEDURE'", "'PACKAGE'"}+ }+ return types+}+func oracleCompletionRoutinesQuery(request completionAssistantRequest, preferredSchema string, limit int) oracleMetadataListQuery {pattern := oracleCompletionLikePattern(request.Mask, request.MatchMode)args := make([]any, 0, 5)- baseSQL := `+ objectTypes := oracleCompletionRoutineObjectTypes(request.ObjectKinds)+ baseSQL := fmt.Sprintf(`SELECT o.OWNER, o.OBJECT_NAME, o.OBJECT_TYPE, CAST(NULL AS VARCHAR2(128)) AS PARENT_NAMEFROM ALL_OBJECTS o-WHERE o.OBJECT_TYPE IN ('FUNCTION', 'PROCEDURE', 'PACKAGE')`+WHERE o.OBJECT_TYPE IN (%s)`, strings.Join(objectTypes, ", "))args = append(args, pattern)nameParam := len(args)diff --git a/agents/drivers/oracle-go/main_test.go b/agents/drivers/oracle-go/main_test.goindex f10f577efe..7b43abdb58 100644--- a/agents/drivers/oracle-go/main_test.go+++ b/agents/drivers/oracle-go/main_test.go@@ -2347,6 +2347,30 @@ func TestOracleCompletionRoutinesQueryUsesPublicPackageMetadata(t *testing.T) {}}+func TestOracleCompletionRoutinesQueryIncludesSequences(t *testing.T) {+ query := oracleCompletionRoutinesQuery(completionAssistantRequest{+ Schema: "HR",+ ObjectKinds: []string{"routine", "sequence"},+ Mask: "SEQ",+ GlobalSearch: false,+ }, "HR", 100)+ sqlText := strings.ToUpper(query.SQL)+ if !strings.Contains(sqlText, "'SEQUENCE'") {+ t.Fatalf("routines query should include SEQUENCE when requested: %s", query.SQL)+ }++ seqOnlyQuery := oracleCompletionRoutinesQuery(completionAssistantRequest{+ Schema: "HR",+ ObjectKinds: []string{"sequence"},+ Mask: "SEQ",+ GlobalSearch: false,+ }, "HR", 100)+ seqSQL := strings.ToUpper(seqOnlyQuery.SQL)+ if !strings.Contains(seqSQL, "IN ('SEQUENCE')") {+ t.Fatalf("sequence-only query should only include SEQUENCE: %s", seqOnlyQuery.SQL)+ }+}+func TestOracleCompletionPackageCandidatesPreserveOverloadsAndReturnTypes(t *testing.T) {rows := []oraclePackageRoutineRow{{diff --git a/apps/desktop/src/components/editor/useQueryEditorCompletion.ts b/apps/desktop/src/components/editor/useQueryEditorCompletion.tsindex 225e0ebdf0..45ac875763 100644--- a/apps/desktop/src/components/editor/useQueryEditorCompletion.ts+++ b/apps/desktop/src/components/editor/useQueryEditorCompletion.ts@@ -1411,6 +1411,12 @@ export function useQueryEditorCompletion(options: QueryEditorCompletionOptions)function completionObjectKindsForContext(completionContext: ReturnType<typeof getSqlCompletionContext>): CompletionAssistantObjectKind[] {if (completionContext.contextKind === "exec") return ["procedure"];+ if (isOracleCompletionDatabase(props.databaseType)) {+ if (completionContext.suggestColumns && completionContext.referencedTables.length > 0 && !completionContext.qualifier) {+ return ["function", "sequence"];+ }+ return ["routine", "sequence"];+ }if (completionContext.suggestColumns && completionContext.referencedTables.length > 0 && !completionContext.qualifier) return ["function"];return ["routine"];}diff --git a/apps/desktop/src/lib/__tests__/sql/sqlCompletion.context.spec.ts b/apps/desktop/src/lib/__tests__/sql/sqlCompletion.context.spec.tsindex 35b83bec0c..347a8897e4 100644--- a/apps/desktop/src/lib/__tests__/sql/sqlCompletion.context.spec.ts+++ b/apps/desktop/src/lib/__tests__/sql/sqlCompletion.context.spec.ts@@ -484,6 +484,163 @@ describe("PostgreSQL sequence literal completion", () => {expect(items.some((item) => item.label === "order_seq")).toBe(false);});+ it("suggests Oracle sequences in SQL expressions and select lists", () => {+ const sql = "SELECT ord";+ const unqualifiedItems = buildSqlCompletionItems(sql, sql.length, {+ tables: [],+ objects: [{ name: "ORDER_SEQ", schema: "APP", type: "sequence" }],+ columnsByTable: new Map(),+ databaseType: "oracle",+ dialect: "oracle",+ currentSchema: "APP",+ });++ expect(unqualifiedItems).toEqual(+ expect.arrayContaining([+ expect.objectContaining({+ label: "ORDER_SEQ",+ type: "variable",+ detail: "sequence in APP",+ apply: "ORDER_SEQ",+ }),+ ]),+ );++ const qualifiedItems = buildSqlCompletionItems(sql, sql.length, {+ tables: [],+ objects: [{ name: "ORDER_SEQ", schema: "APP", type: "sequence" }],+ columnsByTable: new Map(),+ databaseType: "oracle",+ dialect: "oracle",+ });++ expect(qualifiedItems).toEqual(+ expect.arrayContaining([+ expect.objectContaining({+ label: "ORDER_SEQ",+ type: "variable",+ detail: "sequence in APP",+ apply: "APP.ORDER_SEQ",+ }),+ ]),+ );+ });++ it("suggests Oracle sequences under schema qualifier", () => {+ const sql = "SELECT app.ord";+ const items = buildSqlCompletionItems(sql, sql.length, {+ tables: [],+ objects: [{ name: "ORDER_SEQ", schema: "APP", type: "sequence" }],+ columnsByTable: new Map(),+ databaseType: "oracle",+ dialect: "oracle",+ });++ expect(items).toEqual(+ expect.arrayContaining([+ expect.objectContaining({+ label: "ORDER_SEQ",+ type: "variable",+ apply: "ORDER_SEQ",+ }),+ ]),+ );+ });++ it("suggests NEXTVAL and CURRVAL pseudo-columns for Oracle sequences", () => {+ const sql = "SELECT ORDER_SEQ.";+ const items = buildSqlCompletionItems(sql, sql.length, {+ tables: [],+ objects: [{ name: "ORDER_SEQ", schema: "APP", type: "sequence" }],+ columnsByTable: new Map(),+ databaseType: "oracle",+ dialect: "oracle",+ });++ expect(items).toEqual(+ expect.arrayContaining([+ expect.objectContaining({+ label: "NEXTVAL",+ type: "column",+ detail: "sequence pseudo-column",+ }),+ expect.objectContaining({+ label: "CURRVAL",+ type: "column",+ detail: "sequence pseudo-column",+ }),+ ]),+ );+ });++ it("suggests NEXTVAL and CURRVAL pseudo-columns for schema-qualified Oracle sequences", () => {+ const sql = "SELECT APP.ORDER_SEQ.";+ const items = buildSqlCompletionItems(sql, sql.length, {+ tables: [],+ objects: [{ name: "ORDER_SEQ", schema: "APP", type: "sequence" }],+ columnsByTable: new Map(),+ databaseType: "oracle",+ dialect: "oracle",+ });++ expect(items).toEqual(+ expect.arrayContaining([+ expect.objectContaining({+ label: "NEXTVAL",+ type: "column",+ detail: "sequence pseudo-column",+ }),+ expect.objectContaining({+ label: "CURRVAL",+ type: "column",+ detail: "sequence pseudo-column",+ }),+ ]),+ );+ });++ it("respects keyword case for Oracle sequence pseudo-columns", () => {+ const sql = "SELECT ORDER_SEQ.n";+ const items = buildSqlCompletionItems(sql, sql.length, {+ tables: [],+ objects: [{ name: "ORDER_SEQ", schema: "APP", type: "sequence" }],+ columnsByTable: new Map(),+ databaseType: "oracle",+ dialect: "oracle",+ keywordCase: "lower",+ });++ expect(items).toEqual(+ expect.arrayContaining([+ expect.objectContaining({+ label: "nextval",+ apply: "nextval",+ }),+ ]),+ );+ });++ it("suggests Oracle sequence pseudo-columns in INSERT VALUES clause", () => {+ const sql = "INSERT INTO orders (id, name) VALUES (ORDER_SEQ.";+ const items = buildSqlCompletionItems(sql, sql.length, {+ tables: [{ name: "orders", schema: "APP" }],+ objects: [{ name: "ORDER_SEQ", schema: "APP", type: "sequence" }],+ columnsByTable: new Map([["APP.orders", [{ name: "id" }, { name: "name" }]]]),+ databaseType: "oracle",+ dialect: "oracle",+ });++ expect(items).toEqual(+ expect.arrayContaining([+ expect.objectContaining({+ label: "NEXTVAL",+ type: "column",+ detail: "sequence pseudo-column",+ }),+ ]),+ );+ });+it.each([["SELECT 'order_", "postgres"],["SELECT nextval('order_", "mysql"],diff --git a/apps/desktop/src/lib/sql/sqlCompletion.ts b/apps/desktop/src/lib/sql/sqlCompletion.tsindex d9f45a59d4..c9d1eb3677 100644--- a/apps/desktop/src/lib/sql/sqlCompletion.ts+++ b/apps/desktop/src/lib/sql/sqlCompletion.ts@@ -1832,6 +1832,14 @@ class SqlCompletionProvider {this.items.push(...buildColumnItems(context, this.input.columnsByTable, this.dialect, this.databaseType, this.input.quoteIdentifiers));this.items.push(...buildSelectAllColumnItems(context, this.input.columnsByTable, this.t, this.dialect, this.databaseType));this.items.push(...buildInsertAllColumnItems(context, this.input.columnsByTable, this.t, this.dialect, this.input.keywordCase));+ if (isOracleLikeDatabase(this.databaseType) && context.qualifier && !completionQualifierIsReferencedTable(context)) {+ const profileObjects = driverProfileCompletionObjects(this.input.driverProfile, context);+ const allObjects = [...(this.input.objects ?? []), ...profileObjects];+ const hasKnownSequence = allObjects.some((object) => sequenceMatchesQualifier(object, context));+ if (hasKnownSequence || (!completionQualifierIsKnownTableOrSchema(context, completionTables, this.input.schemas) && (matchesPrefix("NEXTVAL", context.prefix) || matchesPrefix("CURRVAL", context.prefix)))) {+ this.items.push(...buildOracleSequencePseudoColumnItems(context.prefix, this.input.keywordCase, hasKnownSequence));+ }+ }}const emptyTableNameCompletion = !context.prefix && (context.suggestTables || context.exclusiveTableSuggestions);@@ -4453,8 +4461,14 @@ function buildObjectItems(context: SqlCompletionContext, objects: SqlCompletionOconst onlyProcedures = context.contextKind === "exec";const onlyFunctions = context.suggestColumns && context.referencedTables.length > 0 && !context.qualifier;const prioritizeOracleFunctions = isOracleCompletionDatabase(databaseType) && context.statementKind === "select";+ const allowOracleSequences = isOracleCompletionDatabase(databaseType) && !onlyProcedures;return objects- .filter((object) => object.type !== "sequence" && (!onlyProcedures || object.type === "procedure") && (!onlyFunctions || (object.type === "function" && object.name.toLowerCase().startsWith(context.prefix.toLowerCase()))) && objectMatchesCompletionContext(object, context))+ .filter((object) => {+ if (object.type === "sequence") {+ return allowOracleSequences && objectMatchesCompletionContext(object, context);+ }+ return (!onlyProcedures || object.type === "procedure") && (!onlyFunctions || (object.type === "function" && object.name.toLowerCase().startsWith(context.prefix.toLowerCase()))) && objectMatchesCompletionContext(object, context);+ }).map((object) => {const qualifiedByContext = objectIsQualifiedByContext(object, context);const objectInCurrentSchema = !!currentSchema && !!object.schema && normalizeIdentifierPart(object.schema) === normalizeIdentifierPart(currentSchema);@@ -4471,10 +4485,10 @@ function buildObjectItems(context: SqlCompletionContext, objects: SqlCompletionOconst baseDedupeKey = object.applyName || (isOracleCompletionDatabase(databaseType) && object.schema) ? applyName : undefined;return {label: object.name,- type: "function" as const,+ type: object.type === "sequence" ? ("variable" as const) : ("function" as const),detail,info: buildRoutineInfo(object),- apply: object.type === "trigger" || object.type === "package" ? applyName : buildRoutineApply(applyName, object.signature, includeParams),+ apply: object.type === "trigger" || object.type === "package" || object.type === "sequence" ? applyName : buildRoutineApply(applyName, object.signature, includeParams),boost: computeBoost(object.name, context.prefix) + typeBoost + schemaBoost,dedupeKey: signature ? `${baseDedupeKey ?? object.name}(${signature})` : baseDedupeKey,// Preserve exact routine matches before the capped candidate list is truncated.@@ -4539,6 +4553,7 @@ function buildRoutineInfo(object: SqlCompletionObject): string | undefined {function routineTypeBoost(type: SqlCompletionObject["type"], prioritizeFunctions: boolean): number {if (type === "package") return 1600;+ if (type === "sequence") return 1500;if (type === "function") return prioritizeFunctions ? 1800 : 900;return prioritizeFunctions ? 900 : 1800;}@@ -4551,6 +4566,55 @@ function completionQualifierIsReferencedTable(context: SqlCompletionContext): boreturn context.referencedTables.some((table) => referencedTableMatchesColumnQualifier(table, qualifier, qualifierLower, qualifiedTarget));}+function sequenceMatchesQualifier(object: SqlCompletionObject, context: SqlCompletionContext): boolean {+ if (object.type !== "sequence") return false;+ if (!context.qualifier) return false;+ const parts = context.qualifierParts?.length ? context.qualifierParts : context.qualifier.split(".").filter(Boolean);+ if (parts.length === 1) {+ return normalizeIdentifierPart(object.name) === normalizeIdentifierPart(parts[0]);+ }+ if (parts.length === 2) {+ const [schema, name] = parts;+ const schemaMatches = !object.schema || normalizeIdentifierPart(object.schema) === normalizeIdentifierPart(schema);+ return schemaMatches && normalizeIdentifierPart(object.name) === normalizeIdentifierPart(name);+ }+ return false;+}++function completionQualifierIsKnownTableOrSchema(context: SqlCompletionContext, tables: SqlCompletionTable[], schemas?: string[]): boolean {+ if (!context.qualifier) return false;+ const parts = context.qualifierParts?.length ? context.qualifierParts : context.qualifier.split(".").filter(Boolean);+ if (parts.length === 1) {+ const name = normalizeIdentifierPart(parts[0]);+ if (schemas?.some((s) => normalizeIdentifierPart(s) === name)) return true;+ if (tables.some((t) => normalizeIdentifierPart(t.name) === name)) return true;+ return false;+ }+ if (parts.length === 2) {+ const [schema, table] = parts;+ if (tables.some((t) => normalizeIdentifierPart(t.name) === normalizeIdentifierPart(table) && (!t.schema || normalizeIdentifierPart(t.schema) === normalizeIdentifierPart(schema)))) return true;+ return false;+ }+ return false;+}++function buildOracleSequencePseudoColumnItems(prefix: string, keywordCase?: SqlKeywordCase, hasKnownSequence = false): SqlCompletionItem[] {+ const pseudoColumns = ["NEXTVAL", "CURRVAL"] as const;+ return pseudoColumns+ .filter((col) => matchesPrefix(col, prefix))+ .map((col) => {+ const label = applySqlKeywordCase(col, keywordCase);+ const isNextVal = col === "NEXTVAL";+ return {+ label,+ type: "column" as const,+ detail: "sequence pseudo-column",+ apply: label,+ boost: computeBoost(col, prefix) + (hasKnownSequence ? (isNextVal ? 2200 : 2100) : isNextVal ? 1200 : 1100),+ };+ });+}+function objectIsQualifiedByContext(object: SqlCompletionObject, context: SqlCompletionContext): boolean {if (!context.qualifier || !object.parentName) return false;const qualifier = context.qualifier.toLowerCase();@@ -4562,6 +4626,13 @@ function objectIsQualifiedByContext(object: SqlCompletionObject, context: SqlComfunction objectMatchesCompletionContext(object: SqlCompletionObject, context: SqlCompletionContext): boolean {if (context.oracleTableFunctionContext && object.type !== "function") return false;+ if (object.type === "sequence") {+ if (context.qualifier) {+ const qualifier = context.qualifier.toLowerCase();+ return !!object.schema && object.schema.toLowerCase() === qualifier && matchesPrefix(object.name, context.prefix);+ }+ return matchesPrefix(object.name, context.prefix);+ }if (context.qualifier) {const qualifier = context.qualifier.toLowerCase();const qualifierParts = qualifier.split(".").filter(Boolean);diff --git a/apps/desktop/src/stores/__tests__/connectionStore.completion.spec.ts b/apps/desktop/src/stores/__tests__/connectionStore.completion.spec.tsindex 71c95d60b4..54b250d304 100644--- a/apps/desktop/src/stores/__tests__/connectionStore.completion.spec.ts+++ b/apps/desktop/src/stores/__tests__/connectionStore.completion.spec.ts@@ -1625,6 +1625,51 @@ describe("connectionStore completion assistant", () => {expect(objects).toEqual([expect.objectContaining({ name: "CALCULATE_BONUS", schema: "HR", type: "function", parentSchema: "HR", parentName: "PAYROLL", dataType: undefined, applyName: "HR.CALCULATE_BONUS", boost: 0 })]);});+ it("maps Oracle sequence objects from completion assistant", async () => {+ const completionAssistantSearch = vi.fn().mockResolvedValue({+ candidates: [{ name: "ORDER_SEQ", kind: "sequence", schema: "HR", data_type: "SEQUENCE" }],+ incomplete: false,+ fallback_used: false,+ });++ vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));+ vi.doMock("@/lib/backend/api", () => ({+ checkConnectionHealth: vi.fn().mockResolvedValue(undefined),+ completionAssistantSearch,+ listObjects: vi.fn().mockResolvedValue([]),+ }));++ const { useConnectionStore } = await import("@/stores/connectionStore");+ const store = useConnectionStore();+ store.connections = [oracleConnection()];+ store.connectedIds.add("oracle-1");++ const objects = await store.listCompletionObjects("oracle-1", "ORCL", "ORDER", 20, "HR", undefined, false, "APP", ["routine", "sequence"]);++ expect(completionAssistantSearch).toHaveBeenCalledWith(expect.objectContaining({ object_kinds: ["routine", "sequence"], mask: "ORDER", schema: "APP" }));+ expect(objects).toEqual([expect.objectContaining({ name: "ORDER_SEQ", schema: "HR", type: "sequence", dataType: undefined, applyName: "HR.ORDER_SEQ" })]);+ });++ it("maps Oracle sequence objects from listObjects in fallback path", async () => {+ const listCompletionObjects = vi.fn().mockResolvedValue([{ name: "ORDER_SEQ", object_type: "SEQUENCE", schema: "HR" }]);++ vi.doMock("@/lib/backend/tauriRuntime", () => ({ isTauriRuntime: () => false }));+ vi.doMock("@/lib/backend/api", () => ({+ checkConnectionHealth: vi.fn().mockResolvedValue(undefined),+ completionAssistantSearch: vi.fn().mockRejectedValue(new Error("assistant disabled")),+ listCompletionObjects,+ }));++ const { useConnectionStore } = await import("@/stores/connectionStore");+ const store = useConnectionStore();+ store.connections = [oracleConnection()];+ store.connectedIds.add("oracle-1");++ const objects = await store.listCompletionObjects("oracle-1", "ORCL", "ORDER", 20, "HR", undefined, false, "APP", ["routine", "sequence"]);++ expect(objects).toEqual([expect.objectContaining({ name: "ORDER_SEQ", schema: "HR", type: "sequence" })]);+ });+it("loads PostgreSQL routines by prefix and preserves return metadata", async () => {const completionAssistantSearch = vi.fn().mockResolvedValue({candidates: [{ name: "st_area", kind: "function", schema: "public", data_type: "double precision", comment: "Returns an area" }],diff --git a/apps/desktop/src/stores/connectionStore.ts b/apps/desktop/src/stores/connectionStore.tsindex db1a3388b5..9cc682afba 100644--- a/apps/desktop/src/stores/connectionStore.ts+++ b/apps/desktop/src/stores/connectionStore.ts@@ -8263,7 +8263,7 @@ export const useConnectionStore = defineStore("connection", () => {const candidateType = candidate.data_type?.toUpperCase();const type = candidate.kind === "procedure" ? "procedure" : candidate.kind === "function" ? "function" : candidate.kind === "sequence" ? "sequence" : candidate.kind === "object" && candidateType === "PACKAGE" ? "package" : null;if (!type) return null;- const dataType = candidate.data_type && !["FUNCTION", "PROCEDURE", "PACKAGE"].includes(candidateType ?? "") ? candidate.data_type : undefined;+ const dataType = candidate.data_type && !["FUNCTION", "PROCEDURE", "PACKAGE", "SEQUENCE"].includes(candidateType ?? "") ? candidate.data_type : undefined;return {name: candidate.name,schema: candidate.schema ?? undefined,@@ -9204,7 +9204,7 @@ export const useConnectionStore = defineStore("connection", () => {function toSqlCompletionObject(object: ObjectInfo): SqlCompletionObject | null {const objectType = object.object_type.toUpperCase();- const type = objectType.includes("PROCEDURE") ? "procedure" : objectType.includes("FUNCTION") ? "function" : objectType.includes("TRIGGER") ? "trigger" : objectType.includes("PACKAGE") ? "package" : null;+ const type = objectType.includes("PROCEDURE") ? "procedure" : objectType.includes("FUNCTION") ? "function" : objectType.includes("TRIGGER") ? "trigger" : objectType.includes("PACKAGE") ? "package" : objectType.includes("SEQUENCE") ? "sequence" : null;if (!type) return null;return {name: object.name,