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(jdbc): expose routine parameter metadata

t8y2320e37aa425a
diff --git a/apps/desktop/src/components/objects/ObjectSourceDialog.vue b/apps/desktop/src/components/objects/ObjectSourceDialog.vue
index 184c6039a5..c954578dff 100644
--- a/apps/desktop/src/components/objects/ObjectSourceDialog.vue
+++ b/apps/desktop/src/components/objects/ObjectSourceDialog.vue
@@ -9,7 +9,7 @@ import { copyToClipboard } from "@/lib/common/clipboard";
import { formatSqlForDisplay, type SqlFormatDialect } from "@/lib/sql/sqlFormatter";
import { buildEditableObjectSource, buildExecutableObjectSourceStatements, executeObjectSourceSave, formatObjectSourceSaveError, resolveObjectSourceEditDraft } from "@/lib/table/objectSourceEditor";
import { loadObjectSourceWithRoutineFallback } from "@/lib/table/objectSourceLoad";
-import { xuguRoutineMetadataFromDefinition, type XuguRoutineMetadata } from "@/lib/table/routineParameters";
+import { jdbcRoutineMetadata, xuguRoutineMetadataFromDefinition, type RoutineMetadata } from "@/lib/table/routineParameters";
import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
import * as api from "@/lib/backend/api";
import QueryEditor from "@/components/editor/QueryEditor.vue";
@@ -57,7 +57,7 @@ const editing = ref(false);
const sourceEditable = ref(true);
const error = ref("");
const saveError = ref("");
-const routineMetadata = ref<XuguRoutineMetadata | null>(null);
+const routineMetadata = ref<RoutineMetadata | null>(null);
/** May differ from props.objectType after PROCEDURE/FUNCTION/PACKAGE fallback resolution. */
const resolvedObjectType = ref<ObjectSourceKind>(props.objectType);
let loadSerial = 0;
@@ -111,7 +111,8 @@ async function loadSource(nextEditing = props.initialEditing && canEdit.value) {
});
if (serial !== loadSerial) return;
resolvedObjectType.value = resolvedType;
- routineMetadata.value = props.databaseType === "xugu" && (resolvedType === "PROCEDURE" || resolvedType === "FUNCTION") ? xuguRoutineMetadataFromDefinition(result.source) : null;
+ const isRoutine = resolvedType === "PROCEDURE" || resolvedType === "FUNCTION";
+ routineMetadata.value = !isRoutine ? null : result.routine_parameters !== undefined ? jdbcRoutineMetadata(result.routine_parameters) : target.databaseType === "xugu" ? xuguRoutineMetadataFromDefinition(result.source) : null;
sourceEditable.value = editableAllowed;
const displaySource = resolvedType === "SEQUENCE" ? result.source : editable;
const formatted = await formatSqlForDisplay(displaySource, target.formatDialect ?? target.dialect, settingsStore.editorSettings.sqlFormatter);
@@ -259,6 +260,7 @@ function closeDialog() {
<div v-else class="flex min-h-0 flex-col gap-3 overflow-hidden">
<RoutineMetadataPanel v-if="hasRoutineMetadata && routineMetadata" :parameters="routineMetadata.parameters" :return-type="routineMetadata.returnType" />
<QueryEditor
+ v-if="content || !hasRoutineMetadata"
:key="`${props.connectionId}:${props.database}:${props.schema || ''}:${props.name}:${props.objectType}`"
:model-value="content"
class="object-source-dialog-editor min-h-0 flex-1 overflow-hidden rounded border"
diff --git a/apps/desktop/src/components/objects/RoutineMetadataPanel.vue b/apps/desktop/src/components/objects/RoutineMetadataPanel.vue
index a9d734f781..ad28aef823 100644
--- a/apps/desktop/src/components/objects/RoutineMetadataPanel.vue
+++ b/apps/desktop/src/components/objects/RoutineMetadataPanel.vue
@@ -1,18 +1,26 @@
<script setup lang="ts">
+import { computed } from "vue";
import { useI18n } from "vue-i18n";
import type { RoutineParameter } from "@/lib/table/routineExecutionSql";
-defineProps<{
+const props = defineProps<{
parameters: RoutineParameter[];
returnType?: string;
}>();
const { t } = useI18n();
+const showNullable = computed(() => props.parameters.some((parameter) => parameter.nullable !== undefined && parameter.nullable !== null));
function defaultLabel(parameter: RoutineParameter): string {
if (!parameter.hasDefault) return "-";
return parameter.defaultValue?.trim() || "DEFAULT";
}
+
+function nullableLabel(parameter: RoutineParameter): string {
+ if (parameter.nullable === true) return t("structureEditor.nullable");
+ if (parameter.nullable === false) return t("structureEditor.notNull");
+ return "-";
+}
</script>
<template>
@@ -21,17 +29,25 @@ function defaultLabel(parameter: RoutineParameter): string {
<span class="font-semibold text-muted-foreground">RETURN</span>
<span class="font-mono">{{ returnType }}</span>
</div>
- <div v-if="parameters.length" class="min-w-[620px]">
- <div class="grid grid-cols-[minmax(140px,1.2fr)_minmax(150px,1.3fr)_80px_minmax(150px,1.3fr)] border-b bg-muted px-3 py-2 text-xs font-medium text-muted-foreground">
+ <div v-if="parameters.length" :class="showNullable ? 'min-w-[720px]' : 'min-w-[620px]'">
+ <div class="grid border-b bg-muted px-3 py-2 text-xs font-medium text-muted-foreground" :class="showNullable ? 'grid-cols-[minmax(140px,1.2fr)_minmax(150px,1.3fr)_80px_100px_minmax(150px,1.3fr)]' : 'grid-cols-[minmax(140px,1.2fr)_minmax(150px,1.3fr)_80px_minmax(150px,1.3fr)]'">
<div>{{ t("contextMenu.parameterName") }}</div>
<div>{{ t("contextMenu.parameterType") }}</div>
<div>{{ t("contextMenu.parameterMode") }}</div>
+ <div v-if="showNullable">{{ t("structureEditor.nullable") }}</div>
<div>{{ t("contextMenu.parameterDefault") }}</div>
</div>
- <div v-for="parameter in parameters" :key="`${parameter.ordinal}:${parameter.name}`" class="grid grid-cols-[minmax(140px,1.2fr)_minmax(150px,1.3fr)_80px_minmax(150px,1.3fr)] gap-2 border-b px-3 py-2 text-xs last:border-b-0" data-routine-parameter>
+ <div
+ v-for="parameter in parameters"
+ :key="`${parameter.ordinal}:${parameter.name}`"
+ class="grid gap-2 border-b px-3 py-2 text-xs last:border-b-0"
+ :class="showNullable ? 'grid-cols-[minmax(140px,1.2fr)_minmax(150px,1.3fr)_80px_100px_minmax(150px,1.3fr)]' : 'grid-cols-[minmax(140px,1.2fr)_minmax(150px,1.3fr)_80px_minmax(150px,1.3fr)]'"
+ data-routine-parameter
+ >
<div class="truncate font-medium" :title="parameter.name">{{ parameter.name }}</div>
<div class="truncate font-mono text-muted-foreground" :title="parameter.dataType">{{ parameter.dataType }}</div>
<div class="text-muted-foreground">{{ parameter.mode }}</div>
+ <div v-if="showNullable" class="text-muted-foreground" data-routine-nullable>{{ nullableLabel(parameter) }}</div>
<div class="truncate font-mono text-muted-foreground" :title="defaultLabel(parameter)">
{{ defaultLabel(parameter) }}
</div>
diff --git a/apps/desktop/src/components/objects/__tests__/ObjectSourceDialog.jdbcRoutineMetadata.spec.ts b/apps/desktop/src/components/objects/__tests__/ObjectSourceDialog.jdbcRoutineMetadata.spec.ts
new file mode 100644
index 0000000000..722585863c
--- /dev/null
+++ b/apps/desktop/src/components/objects/__tests__/ObjectSourceDialog.jdbcRoutineMetadata.spec.ts
@@ -0,0 +1,111 @@
+// @vitest-environment happy-dom
+
+import { createApp, defineComponent, h, type App } from "vue";
+import { createPinia, setActivePinia } from "pinia";
+import { createI18n } from "vue-i18n";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { useConnectionStore } from "@/stores/connectionStore";
+import ObjectSourceDialog from "@/components/objects/ObjectSourceDialog.vue";
+
+const mocks = vi.hoisted(() => ({
+ getObjectSource: vi.fn(),
+ buildEditableObjectSource: vi.fn(),
+}));
+
+vi.mock("@/lib/backend/api", async (importOriginal) => ({
+ ...(await importOriginal<typeof import("@/lib/backend/api")>()),
+ ...mocks,
+}));
+vi.mock("@/components/editor/QueryEditor.vue", () => ({
+ default: defineComponent({
+ name: "QueryEditorStub",
+ props: { modelValue: { type: String, default: "" } },
+ template: "<div data-query-editor-stub>{{ modelValue }}</div>",
+ }),
+}));
+
+const mountedApps: Array<{ app: App; host: HTMLElement }> = [];
+
+afterEach(() => {
+ for (const { app, host } of mountedApps.splice(0)) {
+ app.unmount();
+ host.remove();
+ }
+ vi.restoreAllMocks();
+ Object.values(mocks).forEach((mock) => mock.mockReset());
+});
+
+async function mountDialog() {
+ const pinia = createPinia();
+ setActivePinia(pinia);
+ const connectionStore = useConnectionStore();
+ vi.spyOn(connectionStore, "ensureConnected").mockResolvedValue(undefined);
+ const host = document.createElement("div");
+ document.body.append(host);
+ const app = createApp({
+ render: () =>
+ h(ObjectSourceDialog, {
+ open: true,
+ connectionId: "jdbc-1",
+ database: "catalog1",
+ schema: "APP",
+ name: "calculate_total",
+ objectType: "FUNCTION",
+ databaseType: "jdbc",
+ dialect: "mysql",
+ }),
+ });
+ app.use(pinia);
+ app.use(createI18n({ legacy: false, locale: "en", messages: { en: {} }, missingWarn: false, fallbackWarn: false }));
+ app.mount(host);
+ mountedApps.push({ app, host });
+ return host;
+}
+
+describe("ObjectSourceDialog generic JDBC routine metadata", () => {
+ it("renders a source-less function as read-only structured metadata", async () => {
+ mocks.getObjectSource.mockResolvedValue({
+ name: "calculate_total",
+ object_type: "FUNCTION",
+ schema: "APP",
+ source: "",
+ editable: false,
+ routine_parameters: [
+ { name: "result", mode: "OUT", jdbc_type: 12, type_name: "VARCHAR", length: 32, nullable: true, ordinal: 2 },
+ { name: "RETURN", mode: "RETURN", jdbc_type: 3, type_name: "DECIMAL", precision: 12, scale: 2, ordinal: 0 },
+ { name: "amount", mode: "IN", jdbc_type: 3, type_name: "DECIMAL", precision: 10, scale: 2, nullable: false, ordinal: 1 },
+ ],
+ });
+ mocks.buildEditableObjectSource.mockResolvedValue("");
+
+ await mountDialog();
+ await vi.waitFor(() => expect(document.querySelectorAll("[data-routine-parameter]")).toHaveLength(2));
+
+ expect(document.querySelector("[data-routine-return-type]")?.textContent).toContain("DECIMAL(12,2)");
+ const rows = [...document.querySelectorAll("[data-routine-parameter]")];
+ expect(rows[0].textContent).toContain("amount");
+ expect(rows[0].textContent).toContain("DECIMAL(10,2)");
+ expect(rows[1].textContent).toContain("VARCHAR(32)");
+ expect(document.querySelector("[data-query-editor-stub]")).toBeNull();
+ expect(document.body.textContent).not.toContain("Object source is not supported");
+ expect(mocks.getObjectSource).toHaveBeenCalledTimes(1);
+ expect([...document.querySelectorAll("button")].some((button) => button.textContent?.trim() === "contextMenu.editView")).toBe(false);
+ });
+
+ it("keeps a legacy source payload without the optional field on the existing preview path", async () => {
+ mocks.getObjectSource.mockResolvedValue({
+ name: "calculate_total",
+ object_type: "FUNCTION",
+ schema: "APP",
+ source: "CREATE FUNCTION calculate_total() RETURNS INTEGER RETURN 1",
+ editable: false,
+ });
+ mocks.buildEditableObjectSource.mockResolvedValue("CREATE FUNCTION calculate_total() RETURNS INTEGER RETURN 1");
+
+ await mountDialog();
+ await vi.waitFor(() => expect(document.querySelector("[data-query-editor-stub]")).not.toBeNull());
+
+ expect(document.querySelector("[data-routine-metadata]")).toBeNull();
+ expect(document.querySelector("[data-query-editor-stub]")?.textContent).toContain("CREATE FUNCTION");
+ });
+});
diff --git a/apps/desktop/src/components/objects/__tests__/RoutineMetadataPanel.spec.ts b/apps/desktop/src/components/objects/__tests__/RoutineMetadataPanel.spec.ts
index b492012fd8..e69cb7d6a5 100644
--- a/apps/desktop/src/components/objects/__tests__/RoutineMetadataPanel.spec.ts
+++ b/apps/desktop/src/components/objects/__tests__/RoutineMetadataPanel.spec.ts
@@ -50,4 +50,22 @@ describe("RoutineMetadataPanel", () => {
expect(host.querySelector("[data-routine-return-type]")?.textContent).toContain("INTEGER");
expect(host.querySelectorAll("[data-routine-parameter]")).toHaveLength(0);
});
+
+ it("renders known JDBC nullability without changing legacy parameter rows", () => {
+ const host = document.createElement("div");
+ document.body.append(host);
+ const app = createApp(RoutineMetadataPanel, {
+ parameters: [
+ { name: "required_id", dataType: "BIGINT", mode: "IN", ordinal: 1, nullable: false },
+ { name: "optional_note", dataType: "VARCHAR(64)", mode: "OUT", ordinal: 2, nullable: true },
+ { name: "unknown", dataType: "OTHER", mode: "UNKNOWN", ordinal: 3, nullable: null },
+ ],
+ });
+ app.use(i18n);
+ app.mount(host);
+ mountedApps.push({ app, host });
+
+ const nullability = [...host.querySelectorAll("[data-routine-nullable]")].map((cell) => cell.textContent?.trim());
+ expect(nullability).toEqual(["Not null", "Nullable", "-"]);
+ });
});
diff --git a/apps/desktop/src/lib/table/__tests__/objectSourceLoad.spec.ts b/apps/desktop/src/lib/table/__tests__/objectSourceLoad.spec.ts
index db82b52375..0edf96de50 100644
--- a/apps/desktop/src/lib/table/__tests__/objectSourceLoad.spec.ts
+++ b/apps/desktop/src/lib/table/__tests__/objectSourceLoad.spec.ts
@@ -1,5 +1,6 @@
import { describe, expect, it, vi } from "vitest";
import { loadEditableObjectSourceForEditor, loadObjectSourceWithRoutineFallback } from "@/lib/table/objectSourceLoad";
+import { jdbcRoutineMetadata } from "@/lib/table/routineParameters";
import type { ObjectSource } from "@/types/database";
function source(text: string): ObjectSource {
@@ -26,6 +27,38 @@ describe("loadObjectSourceWithRoutineFallback", () => {
expect(getObjectSource).toHaveBeenCalledTimes(2);
expect(getObjectSource.mock.calls[1][4]).toBe("FUNCTION");
});
+
+ it("keeps a source-less routine response when structured metadata is present", async () => {
+ const getObjectSource = vi.fn().mockResolvedValue({ ...source(""), editable: false, routine_parameters: [] });
+ const result = await loadObjectSourceWithRoutineFallback(getObjectSource, "c1", "catalog", "APP", "P1", "PROCEDURE");
+
+ expect(result.objectType).toBe("PROCEDURE");
+ expect(result.source.routine_parameters).toEqual([]);
+ expect(getObjectSource).toHaveBeenCalledTimes(1);
+ });
+});
+
+describe("jdbcRoutineMetadata", () => {
+ it("keeps legacy payloads optional and normalizes sorted JDBC display metadata", () => {
+ expect(jdbcRoutineMetadata(undefined)).toBeNull();
+ expect(
+ jdbcRoutineMetadata([
+ { name: "p_note", mode: "OUT", jdbc_type: 12, type_name: "VARCHAR", length: 64, nullable: true, ordinal: 3 },
+ { name: null, mode: "RETURN", jdbc_type: 3, type_name: "DECIMAL", precision: 12, scale: 3, ordinal: 0 },
+ { name: "p_id", mode: "IN", jdbc_type: -5, type_name: "BIGINT", nullable: false, ordinal: 1 },
+ { name: null, mode: "INOUT", jdbc_type: null, type_name: null, nullable: null, ordinal: 2 },
+ { name: "p_unknown", mode: "UNKNOWN" },
+ ]),
+ ).toEqual({
+ returnType: "DECIMAL(12,3)",
+ parameters: [
+ { name: "p_id", dataType: "BIGINT", mode: "IN", ordinal: 1, hasDefault: false, nullable: false },
+ { name: "arg2", dataType: "UNKNOWN", mode: "INOUT", ordinal: 2, hasDefault: false, nullable: null },
+ { name: "p_note", dataType: "VARCHAR(64)", mode: "OUT", ordinal: 3, hasDefault: false, nullable: true },
+ { name: "p_unknown", dataType: "UNKNOWN", mode: "UNKNOWN", ordinal: 4, hasDefault: false, nullable: undefined },
+ ],
+ });
+ });
});
describe("loadEditableObjectSourceForEditor", () => {
diff --git a/apps/desktop/src/lib/table/objectSourceLoad.ts b/apps/desktop/src/lib/table/objectSourceLoad.ts
index 35fbd63f8b..d644fa52eb 100644
--- a/apps/desktop/src/lib/table/objectSourceLoad.ts
+++ b/apps/desktop/src/lib/table/objectSourceLoad.ts
@@ -19,7 +19,7 @@ export async function loadObjectSourceWithRoutineFallback(
relationName?: string,
): Promise<{ source: ObjectSource; objectType: ObjectSourceKind }> {
const primary = await getObjectSource(connectionId, database, schema, name, objectType, signature, relationName);
- if (primary.source?.trim()) {
+ if (primary.source?.trim() || primary.routine_parameters !== undefined) {
return { source: primary, objectType };
}
@@ -28,7 +28,7 @@ export async function loadObjectSourceWithRoutineFallback(
for (const fallbackType of fallbacks) {
try {
const alternate = await getObjectSource(connectionId, database, schema, name, fallbackType, signature, relationName);
- if (alternate.source?.trim()) {
+ if (alternate.source?.trim() || alternate.routine_parameters !== undefined) {
return { source: alternate, objectType: fallbackType };
}
} catch {
diff --git a/apps/desktop/src/lib/table/routineExecutionSql.ts b/apps/desktop/src/lib/table/routineExecutionSql.ts
index bfe90726b1..9d1872351b 100644
--- a/apps/desktop/src/lib/table/routineExecutionSql.ts
+++ b/apps/desktop/src/lib/table/routineExecutionSql.ts
@@ -17,6 +17,7 @@ export interface RoutineParameter {
ordinal: number;
hasDefault?: boolean;
defaultValue?: string | null;
+ nullable?: boolean | null;
}
export interface RoutineParameterValue extends RoutineParameter {
diff --git a/apps/desktop/src/lib/table/routineParameters.ts b/apps/desktop/src/lib/table/routineParameters.ts
index 9a8df67866..b844a99cbc 100644
--- a/apps/desktop/src/lib/table/routineParameters.ts
+++ b/apps/desktop/src/lib/table/routineParameters.ts
@@ -1,5 +1,5 @@
import * as api from "@/lib/backend/api";
-import type { DatabaseType, QueryResult } from "@/types/database";
+import type { DatabaseType, QueryResult, RoutineParameterMetadata } from "@/types/database";
import type { RoutineParameter, RoutineParameterMode } from "@/lib/table/routineExecutionSql";
export interface LoadRoutineParametersOptions {
@@ -142,12 +142,72 @@ ORDER BY SEQUENCE;`.trim();
return null;
}
-export interface XuguRoutineMetadata {
+export interface RoutineMetadata {
kind?: "PROCEDURE" | "FUNCTION";
parameters: RoutineParameter[];
returnType?: string;
}
+export type XuguRoutineMetadata = RoutineMetadata;
+
+/** Convert optional generic-JDBC wire metadata into the existing read-only panel model. */
+export function jdbcRoutineMetadata(parameters: RoutineParameterMetadata[] | undefined): RoutineMetadata | null {
+ if (parameters === undefined) return null;
+
+ const ordered = parameters
+ .map((parameter, index) => ({ parameter, index }))
+ .sort((left, right) => routineMetadataOrdinal(left.parameter) - routineMetadataOrdinal(right.parameter) || left.index - right.index)
+ .map(({ parameter }) => parameter);
+ const returnParameter = ordered.find((parameter) => parameter.mode === "RETURN");
+ return {
+ parameters: ordered
+ .filter((parameter) => parameter.mode !== "RETURN")
+ .map((parameter, index) => ({
+ name: parameter.name?.trim() || `arg${positiveRoutineOrdinal(parameter.ordinal) ?? index + 1}`,
+ dataType: jdbcRoutineParameterType(parameter),
+ mode: parameter.mode,
+ ordinal: positiveRoutineOrdinal(parameter.ordinal) ?? index + 1,
+ hasDefault: false,
+ nullable: parameter.nullable,
+ })),
+ returnType: returnParameter ? jdbcRoutineParameterType(returnParameter) : undefined,
+ };
+}
+
+function routineMetadataOrdinal(parameter: RoutineParameterMetadata): number {
+ return typeof parameter.ordinal === "number" && Number.isFinite(parameter.ordinal) ? parameter.ordinal : Number.MAX_SAFE_INTEGER;
+}
+
+function positiveRoutineOrdinal(ordinal: number | null | undefined): number | undefined {
+ return typeof ordinal === "number" && Number.isFinite(ordinal) && ordinal > 0 ? ordinal : undefined;
+}
+
+function jdbcRoutineParameterType(parameter: RoutineParameterMetadata): string {
+ const typeName = parameter.type_name?.trim() || (typeof parameter.jdbc_type === "number" ? `JDBC ${parameter.jdbc_type}` : "UNKNOWN");
+ if (/\([^)]*\)\s*$/.test(typeName)) return typeName;
+
+ const jdbcType = parameter.jdbc_type;
+ const precision = positiveMetadataSize(parameter.precision);
+ const length = positiveMetadataSize(parameter.length);
+ const scale = typeof parameter.scale === "number" && Number.isFinite(parameter.scale) && parameter.scale >= 0 ? parameter.scale : undefined;
+ if (jdbcType === 2 || jdbcType === 3) {
+ if (precision === undefined) return typeName;
+ return scale === undefined ? `${typeName}(${precision})` : `${typeName}(${precision},${scale})`;
+ }
+ if (jdbcType === 92 || jdbcType === 93 || jdbcType === 2013 || jdbcType === 2014) {
+ return scale === undefined ? typeName : `${typeName}(${scale})`;
+ }
+ if (jdbcType === 1 || jdbcType === 12 || jdbcType === -1 || jdbcType === -15 || jdbcType === -9 || jdbcType === -16 || jdbcType === -2 || jdbcType === -3 || jdbcType === -4) {
+ const size = length ?? precision;
+ return size === undefined ? typeName : `${typeName}(${size})`;
+ }
+ return typeName;
+}
+
+function positiveMetadataSize(value: number | null | undefined): number | undefined {
+ return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : undefined;
+}
+
interface XuguRoutineToken {
kind: "word" | "quoted-identifier" | "string" | "symbol";
text: string;
diff --git a/apps/desktop/src/types/database.ts b/apps/desktop/src/types/database.ts
index 4ad80df760..70415937c9 100644
--- a/apps/desktop/src/types/database.ts
+++ b/apps/desktop/src/types/database.ts
@@ -1024,12 +1024,28 @@ export interface ObjectStatistics {
export type ObjectSourceKind = "VIEW" | "MATERIALIZED_VIEW" | "PROCEDURE" | "FUNCTION" | "TRIGGER" | "EVENT" | "SEQUENCE" | "SYNONYM" | "JOB" | "PACKAGE" | "PACKAGE_BODY" | "TYPE" | "TYPE_BODY";
+export type RoutineParameterMetadataMode = "IN" | "OUT" | "INOUT" | "RETURN" | "UNKNOWN";
+
+export interface RoutineParameterMetadata {
+ name?: string | null;
+ mode: RoutineParameterMetadataMode;
+ jdbc_type?: number | null;
+ type_name?: string | null;
+ precision?: number | null;
+ length?: number | null;
+ scale?: number | null;
+ nullable?: boolean | null;
+ ordinal?: number | null;
+}
+
export interface ObjectSource {
name: string;
object_type: ObjectSourceKind;
schema?: string | null;
source: string;
editable?: boolean;
+ /** Optional structured metadata exposed by generic JDBC sidecars. */
+ routine_parameters?: RoutineParameterMetadata[];
}
export interface MysqlEventInfo {
diff --git a/crates/dbx-core/src/data/transfer.rs b/crates/dbx-core/src/data/transfer.rs
index 32d1ed754d..e51a73a129 100644
--- a/crates/dbx-core/src/data/transfer.rs
+++ b/crates/dbx-core/src/data/transfer.rs
@@ -8125,6 +8125,7 @@ async fn get_postgres_schema_object_sources_for_transfer(
schema: Some(schema.to_string()),
source,
editable: None,
+ routine_parameters: None,
});
}
for row in execute_on_pool(state, pool_key, &routines_sql).await?.rows {
@@ -8144,6 +8145,7 @@ async fn get_postgres_schema_object_sources_for_transfer(
schema: Some(schema.to_string()),
source,
editable: None,
+ routine_parameters: None,
});
}
@@ -13545,6 +13547,7 @@ CREATE TABLE "Other"."prefix""Source"."NAME" ("ID" INT);"#;
schema: Some("public".into()),
source: "SELECT 1".into(),
editable: None,
+ routine_parameters: None,
},
db::ObjectSource {
name: "v2".into(),
@@ -13552,6 +13555,7 @@ CREATE TABLE "Other"."prefix""Source"."NAME" ("ID" INT);"#;
schema: Some("public".into()),
source: "SELECT 2".into(),
editable: None,
+ routine_parameters: None,
},
];
let selection =
diff --git a/crates/dbx-core/src/schema/mod.rs b/crates/dbx-core/src/schema/mod.rs
index 29348b7b89..957e801bf8 100644
--- a/crates/dbx-core/src/schema/mod.rs
+++ b/crates/dbx-core/src/schema/mod.rs
@@ -4480,6 +4480,7 @@ done
schema: None,
source: "CREATE EVENT event_daily_sync ON SCHEDULE EVERY 1 DAY DO SELECT 1".to_string(),
editable: None,
+ routine_parameters: None,
});
assert_eq!(source.editable, Some(false));
@@ -10810,6 +10811,7 @@ async fn get_object_source_once(
schema: if schema.is_empty() { None } else { Some(schema.to_string()) },
source,
editable: None,
+ routine_parameters: None,
});
}
let result: db::ObjectSource = session
@@ -10868,6 +10870,7 @@ async fn get_object_source_once(
schema: if schema.is_empty() { None } else { Some(schema.to_string()) },
source,
editable: None,
+ routine_parameters: None,
});
}
None => String::new(),
@@ -10993,6 +10996,7 @@ async fn get_object_source_once(
schema: if schema.is_empty() { None } else { Some(schema.to_string()) },
source,
editable,
+ routine_parameters: None,
})
}
diff --git a/crates/dbx-drivers/src/db/cloudflare_d1/mod.rs b/crates/dbx-drivers/src/db/cloudflare_d1/mod.rs
index 994c31ee24..0f3b3a08ea 100644
--- a/crates/dbx-drivers/src/db/cloudflare_d1/mod.rs
+++ b/crates/dbx-drivers/src/db/cloudflare_d1/mod.rs
@@ -292,7 +292,14 @@ pub async fn object_source(
)
.await?,
)?;
- Ok(ObjectSource { name: name.to_string(), object_type: object_type.clone(), schema: None, source, editable: None })
+ Ok(ObjectSource {
+ name: name.to_string(),
+ object_type: object_type.clone(),
+ schema: None,
+ source,
+ editable: None,
+ routine_parameters: None,
+ })
}
pub async fn execute_query_with_max_rows(
diff --git a/crates/dbx-drivers/src/db/rqlite_driver.rs b/crates/dbx-drivers/src/db/rqlite_driver.rs
index cfe2fe917f..85113fe502 100644
--- a/crates/dbx-drivers/src/db/rqlite_driver.rs
+++ b/crates/dbx-drivers/src/db/rqlite_driver.rs
@@ -286,7 +286,14 @@ pub async fn object_source(
)
.await?,
)?;
- Ok(ObjectSource { name: name.to_string(), object_type: object_type.clone(), schema: None, source, editable: None })
+ Ok(ObjectSource {
+ name: name.to_string(),
+ object_type: object_type.clone(),
+ schema: None,
+ source,
+ editable: None,
+ routine_parameters: None,
+ })
}
pub async fn execute_query(client: &RqliteClient, sql: &str) -> Result<QueryResult, String> {
diff --git a/crates/dbx-drivers/src/db/turso_driver.rs b/crates/dbx-drivers/src/db/turso_driver.rs
index 64cbd8f8ff..748fa7ecc9 100644
--- a/crates/dbx-drivers/src/db/turso_driver.rs
+++ b/crates/dbx-drivers/src/db/turso_driver.rs
@@ -328,7 +328,14 @@ pub async fn object_source(
)
.await?,
)?;
- Ok(ObjectSource { name: name.to_string(), object_type: object_type.clone(), schema: None, source, editable: None })
+ Ok(ObjectSource {
+ name: name.to_string(),
+ object_type: object_type.clone(),
+ schema: None,
+ source,
+ editable: None,
+ routine_parameters: None,
+ })
}
pub async fn execute_query(client: &TursoClient, sql: &str) -> Result<QueryResult, String> {
diff --git a/crates/dbx-types/src/types.rs b/crates/dbx-types/src/types.rs
index ddd46a8af7..fbcbac5ba6 100644
--- a/crates/dbx-types/src/types.rs
+++ b/crates/dbx-types/src/types.rs
@@ -222,6 +222,37 @@ pub enum ObjectSourceKind {
TypeBody,
}
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+pub enum RoutineParameterMode {
+ In,
+ Out,
+ Inout,
+ Return,
+ Unknown,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]
+pub struct RoutineParameterMetadata {
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub name: Option<String>,
+ pub mode: RoutineParameterMode,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub jdbc_type: Option<i32>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub type_name: Option<String>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub precision: Option<i32>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub length: Option<i32>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub scale: Option<i32>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub nullable: Option<bool>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub ordinal: Option<i32>,
+}
+
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ObjectSource {
pub name: String,
@@ -230,6 +261,8 @@ pub struct ObjectSource {
pub source: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub editable: Option<bool>,
+ #[serde(default, skip_serializing_if = "Option::is_none")]
+ pub routine_parameters: Option<Vec<RoutineParameterMetadata>>,
}
/// Provenance for structured metadata fields that are optional in [`ColumnInfo`].
@@ -1078,7 +1111,8 @@ pub struct CustomTypeDetails {
mod tests {
use super::{
is_opaque_aggregate_state_type, CompletionAssistantCandidate, CompletionAssistantCandidateKind, ObjectInfo,
- ObjectSourceKind, QueryMessage, SpatialColumn, SpatialColumnBuilder, TableInfo,
+ ObjectSource, ObjectSourceKind, QueryMessage, RoutineParameterMode, SpatialColumn, SpatialColumnBuilder,
+ TableInfo,
};
#[test]
@@ -1277,6 +1311,46 @@ mod tests {
assert_eq!(serde_json::to_string(&kind).unwrap(), "\"JOB\"");
}
+ #[test]
+ fn object_source_accepts_legacy_payload_without_routine_parameters() {
+ let source: ObjectSource = serde_json::from_value(serde_json::json!({
+ "name": "legacy_proc",
+ "object_type": "PROCEDURE",
+ "schema": "APP",
+ "source": "CREATE PROCEDURE legacy_proc() BEGIN END"
+ }))
+ .unwrap();
+
+ assert!(source.routine_parameters.is_none());
+ assert!(serde_json::to_value(source).unwrap().get("routine_parameters").is_none());
+ }
+
+ #[test]
+ fn object_source_preserves_optional_jdbc_routine_parameters() {
+ let source: ObjectSource = serde_json::from_value(serde_json::json!({
+ "name": "calculate_total",
+ "object_type": "FUNCTION",
+ "schema": "APP",
+ "source": "",
+ "editable": false,
+ "routine_parameters": [{
+ "name": "RETURN",
+ "mode": "RETURN",
+ "jdbc_type": 3,
+ "type_name": "DECIMAL",
+ "precision": 12,
+ "scale": 2,
+ "ordinal": 0
+ }]
+ }))
+ .unwrap();
+
+ let parameters = source.routine_parameters.as_ref().unwrap();
+ assert_eq!(parameters[0].mode, RoutineParameterMode::Return);
+ assert_eq!(parameters[0].precision, Some(12));
+ assert_eq!(serde_json::to_value(source).unwrap()["routine_parameters"][0]["mode"], "RETURN");
+ }
+
#[test]
fn completion_candidate_kind_accepts_uppercase_agent_wire_values() {
for (wire_value, expected) in [
diff --git a/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java b/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java
index fade6bb10a..54caf380ba 100644
--- a/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java
+++ b/plugins/jdbc/src/main/java/app/dbx/jdbc/DbxJdbcPlugin.java
@@ -4374,9 +4374,158 @@ public final class DbxJdbcPlugin {
return genericTableObjectSource(connection, database, schema, name);
}
+ String normalizedType = normalizeObjectType(objectType);
+ if (!isSybaseConnection(connection) && ("PROCEDURE".equals(normalizedType) || "FUNCTION".equals(normalizedType))) {
+ return genericRoutineObjectSource(connection, conn, database, schema, name, normalizedType);
+ }
+
throw new SQLException("Object source is not supported by this JDBC driver");
}
+ /**
+ * Generic JDBC does not define a routine DDL API. Return the structured
+ * parameter metadata that it does define and leave source empty/read-only.
+ * Drivers are allowed to omit or reject this optional metadata; that must
+ * not turn opening an already-listed routine into a fatal error.
+ */
+ private static JsonNode genericRoutineObjectSource(
+ JsonNode connection,
+ Connection conn,
+ String database,
+ String schema,
+ String name,
+ String objectType
+ ) {
+ ObjectNode item = MAPPER.createObjectNode();
+ item.put("name", name);
+ item.put("object_type", objectType);
+ putNullable(item, "schema", emptyToNull(schema));
+ item.put("source", "");
+ item.put("editable", false);
+
+ try {
+ DatabaseMetaData meta = conn.getMetaData();
+ JdbcDriverQuirks quirks = driverQuirks(connection);
+ String catalog = metadataCatalog(database, quirks);
+ String schemaPattern = escapeJdbcMetadataPattern(meta, resolveSchemaPattern(meta, database, schema, quirks));
+ String routineName = escapeJdbcMetadataPattern(meta, stripRoutineSignature(name));
+ ResultSet columns = "PROCEDURE".equals(objectType)
+ ? meta.getProcedureColumns(catalog, schemaPattern, routineName, "%")
+ : meta.getFunctionColumns(catalog, schemaPattern, routineName, "%");
+ if (columns == null) {
+ return item;
+ }
+ try (columns) {
+ List<ObjectNode> parameters = new ArrayList<>();
+ while (columns.next()) {
+ parameters.add(genericRoutineParameter(columns, "PROCEDURE".equals(objectType)));
+ }
+ parameters.sort((left, right) -> {
+ JsonNode leftOrdinal = left.get("ordinal");
+ JsonNode rightOrdinal = right.get("ordinal");
+ int leftValue = leftOrdinal == null ? Integer.MAX_VALUE : leftOrdinal.asInt();
+ int rightValue = rightOrdinal == null ? Integer.MAX_VALUE : rightOrdinal.asInt();
+ return Integer.compare(leftValue, rightValue);
+ });
+ ArrayNode result = MAPPER.createArrayNode();
+ result.addAll(parameters);
+ item.set("routine_parameters", result);
+ }
+ } catch (SQLException | AbstractMethodError | UnsupportedOperationException ignored) {
+ // Parameter metadata is optional. The empty read-only source still
+ // lets the details dialog open when a driver does not implement it.
+ }
+ return item;
+ }
+
+ private static ObjectNode genericRoutineParameter(ResultSet columns, boolean procedure) {
+ ObjectNode parameter = MAPPER.createObjectNode();
+ Integer columnType = metadataInteger(columns, "COLUMN_TYPE");
+ String mode = routineParameterMode(columnType, procedure);
+ String name = metadataString(columns, "COLUMN_NAME");
+ if ((name == null || name.isBlank()) && "RETURN".equals(mode)) {
+ name = "RETURN";
+ }
+ putNullable(parameter, "name", name);
+ parameter.put("mode", mode);
+ putOptionalInt(parameter, "jdbc_type", metadataInteger(columns, "DATA_TYPE"));
+ putNullable(parameter, "type_name", metadataString(columns, "TYPE_NAME"));
+ putOptionalInt(parameter, "precision", metadataInteger(columns, "PRECISION"));
+ putOptionalInt(parameter, "length", metadataInteger(columns, "LENGTH"));
+ putOptionalInt(parameter, "scale", metadataInteger(columns, "SCALE"));
+ Integer nullable = metadataInteger(columns, "NULLABLE");
+ if (nullable != null && nullable != DatabaseMetaData.procedureNullableUnknown) {
+ parameter.put("nullable", nullable != DatabaseMetaData.procedureNoNulls);
+ }
+ putOptionalInt(parameter, "ordinal", metadataInteger(columns, "ORDINAL_POSITION"));
+ return parameter;
+ }
+
+ private static String routineParameterMode(Integer columnType, boolean procedure) {
+ if (columnType == null) {
+ return "UNKNOWN";
+ }
+ if (procedure) {
+ return switch (columnType) {
+ case DatabaseMetaData.procedureColumnIn -> "IN";
+ case DatabaseMetaData.procedureColumnInOut -> "INOUT";
+ case DatabaseMetaData.procedureColumnOut -> "OUT";
+ case DatabaseMetaData.procedureColumnReturn -> "RETURN";
+ default -> "UNKNOWN";
+ };
+ }
+ return switch (columnType) {
+ case DatabaseMetaData.functionColumnIn -> "IN";
+ case DatabaseMetaData.functionColumnInOut -> "INOUT";
+ case DatabaseMetaData.functionColumnOut -> "OUT";
+ case DatabaseMetaData.functionReturn -> "RETURN";
+ default -> "UNKNOWN";
+ };
+ }
+
+ private static String metadataString(ResultSet result, String column) {
+ try {
+ return result.getString(column);
+ } catch (SQLException | AbstractMethodError | UnsupportedOperationException ignored) {
+ return null;
+ }
+ }
+
+ private static Integer metadataInteger(ResultSet result, String column) {
+ try {
+ Object value = result.getObject(column);
+ if (value instanceof Number number) {
+ return number.intValue();
+ }
+ if (value instanceof String text && !text.isBlank()) {
+ return Integer.valueOf(text.trim());
+ }
+ } catch (SQLException | AbstractMethodError | UnsupportedOperationException | NumberFormatException ignored) {
+ }
+ return null;
+ }
+
+ private static String escapeJdbcMetadataPattern(DatabaseMetaData meta, String value) {
+ if (value == null) {
+ return null;
+ }
+ try {
+ String escape = meta.getSearchStringEscape();
+ if (escape == null || escape.isEmpty()) {
+ return value;
+ }
+ return value.replace(escape, escape + escape).replace("%", escape + "%").replace("_", escape + "_");
+ } catch (SQLException | AbstractMethodError | UnsupportedOperationException ignored) {
+ return value;
+ }
+ }
+
+ private static void putOptionalInt(ObjectNode node, String field, Integer value) {
+ if (value != null) {
+ node.put(field, value);
+ }
+ }
+
private static JsonNode sybaseViewObjectSource(
JsonNode connection,
Connection conn,
diff --git a/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java b/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java
index 751d1aa4b0..1302667d01 100644
--- a/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java
+++ b/plugins/jdbc/src/test/java/app/dbx/jdbc/DbxJdbcPluginTest.java
@@ -4682,6 +4682,122 @@ final class DbxJdbcPluginTest {
return value == null ? "<null>" : String.valueOf(value);
}
+ private static final class RoutineColumnsDriver implements Driver {
+ private final String urlPrefix;
+ private final List<String> calls;
+ private final boolean unsupported;
+
+ private RoutineColumnsDriver(String urlPrefix, List<String> calls, boolean unsupported) {
+ this.urlPrefix = urlPrefix;
+ this.calls = calls;
+ this.unsupported = unsupported;
+ }
+
+ @Override
+ public Connection connect(String url, Properties info) {
+ return acceptsURL(url) ? routineColumnsConnection(calls, unsupported) : null;
+ }
+
+ @Override
+ public boolean acceptsURL(String url) {
+ return url != null && url.startsWith(urlPrefix);
+ }
+
+ @Override
+ public DriverPropertyInfo[] getPropertyInfo(String url, Properties info) {
+ return new DriverPropertyInfo[0];
+ }
+
+ @Override
+ public int getMajorVersion() {
+ return 1;
+ }
+
+ @Override
+ public int getMinorVersion() {
+ return 0;
+ }
+
+ @Override
+ public boolean jdbcCompliant() {
+ return false;
+ }
+
+ @Override
+ public java.util.logging.Logger getParentLogger() {
+ return java.util.logging.Logger.getGlobal();
+ }
+ }
+
+ private static Connection routineColumnsConnection(List<String> calls, boolean unsupported) {
+ DatabaseMetaData metadata = (DatabaseMetaData) Proxy.newProxyInstance(
+ DbxJdbcPluginTest.class.getClassLoader(),
+ new Class<?>[] { DatabaseMetaData.class },
+ (proxy, method, args) -> {
+ if ("getSearchStringEscape".equals(method.getName())) {
+ return "\\";
+ }
+ if ("getProcedureColumns".equals(method.getName())) {
+ calls.add("getProcedureColumns:" + metadataArgument(args[0]) + ":" + metadataArgument(args[1])
+ + ":" + metadataArgument(args[2]) + ":" + metadataArgument(args[3]));
+ if (unsupported) {
+ throw new SQLFeatureNotSupportedException("routine columns unavailable");
+ }
+ return rowsResultSet(
+ new String[] {
+ "COLUMN_NAME", "COLUMN_TYPE", "DATA_TYPE", "TYPE_NAME", "LENGTH",
+ "NULLABLE", "SCALE", "PRECISION", "ORDINAL_POSITION"
+ },
+ new Object[][] {
+ { "p_out", DatabaseMetaData.procedureColumnOut, Types.VARCHAR, "VARCHAR", 80,
+ DatabaseMetaData.procedureNullable, null, null, 3 },
+ { null, DatabaseMetaData.procedureColumnReturn, Types.INTEGER, "INTEGER", 4,
+ DatabaseMetaData.procedureNullableUnknown, 0, 10, 0 },
+ { "p_id", DatabaseMetaData.procedureColumnIn, Types.BIGINT, "BIGINT", 8,
+ DatabaseMetaData.procedureNoNulls, 0, 19, 1 },
+ { null, DatabaseMetaData.procedureColumnInOut, Types.DECIMAL, "DECIMAL", 16,
+ DatabaseMetaData.procedureNullable, 3, 12, 2 },
+ { "p_mystery", null, null, null, null, null, null, null, null }
+ }
+ );
+ }
+ if ("getFunctionColumns".equals(method.getName())) {
+ calls.add("getFunctionColumns:" + metadataArgument(args[0]) + ":" + metadataArgument(args[1])
+ + ":" + metadataArgument(args[2]) + ":" + metadataArgument(args[3]));
+ if (unsupported) {
+ throw new SQLFeatureNotSupportedException("routine columns unavailable");
+ }
+ return rowsResultSet(
+ new String[] {
+ "COLUMN_NAME", "COLUMN_TYPE", "DATA_TYPE", "TYPE_NAME", "LENGTH",
+ "NULLABLE", "SCALE", "PRECISION", "ORDINAL_POSITION"
+ },
+ new Object[][] {
+ { "answer", DatabaseMetaData.functionColumnOut, Types.INTEGER, "INTEGER", 4,
+ DatabaseMetaData.functionNullable, 0, 10, 2 },
+ { null, DatabaseMetaData.functionReturn, Types.NUMERIC, "NUMERIC", 16,
+ DatabaseMetaData.functionNullableUnknown, 2, 15, 0 },
+ { "value", DatabaseMetaData.functionColumnIn, Types.INTEGER, "INTEGER", 4,
+ DatabaseMetaData.functionNoNulls, 0, 10, 1 }
+ }
+ );
+ }
+ return defaultValue(method.getReturnType());
+ }
+ );
+ return (Connection) Proxy.newProxyInstance(
+ DbxJdbcPluginTest.class.getClassLoader(),
+ new Class<?>[] { Connection.class },
+ (proxy, method, args) -> switch (method.getName()) {
+ case "getMetaData" -> metadata;
+ case "isClosed" -> false;
+ case "isValid" -> true;
+ case "close", "setCatalog", "setSchema" -> null;
+ default -> defaultValue(method.getReturnType());
+ }
+ );
+ }
+
private static void closeAndDeregister(String connection, Driver driver) throws Exception {
try {
request("close", """
@@ -5725,6 +5841,147 @@ final class DbxJdbcPluginTest {
""".formatted(targetUrl));
}
+ @Test
+ void getObjectSourceReturnsSortedProcedureMetadataWithoutInventingSource() throws Exception {
+ List<String> calls = new ArrayList<>();
+ String url = "jdbc:dbx-routine-columns-procedure:";
+ Driver driver = new RoutineColumnsDriver(url, calls, false);
+ DriverManager.registerDriver(driver);
+ String connection = """
+ { "connection_string": "%sdemo" }
+ """.formatted(url);
+ try {
+ JsonNode response = request("getObjectSource", """
+ {
+ "connection": %s,
+ "database": "catalog1",
+ "schema": "APP",
+ "name": "process_order",
+ "object_type": "PROCEDURE"
+ }
+ """.formatted(connection));
+
+ assertFalse(response.has("error"), response.toString());
+ JsonNode result = response.path("result");
+ assertEquals("", result.path("source").asText());
+ assertFalse(result.path("editable").asBoolean(true));
+ assertEquals(List.of("getProcedureColumns:catalog1:APP:process\\_order:%"), calls);
+ JsonNode parameters = result.path("routine_parameters");
+ assertEquals(5, parameters.size());
+ assertEquals("RETURN", parameters.path(0).path("name").asText());
+ assertEquals("RETURN", parameters.path(0).path("mode").asText());
+ assertEquals(0, parameters.path(0).path("ordinal").asInt());
+ assertFalse(parameters.path(0).has("nullable"));
+ assertEquals("p_id", parameters.path(1).path("name").asText());
+ assertEquals("IN", parameters.path(1).path("mode").asText());
+ assertEquals(Types.BIGINT, parameters.path(1).path("jdbc_type").asInt());
+ assertEquals(19, parameters.path(1).path("precision").asInt());
+ assertFalse(parameters.path(1).path("nullable").asBoolean(true));
+ assertTrue(parameters.path(2).path("name").isNull());
+ assertEquals("INOUT", parameters.path(2).path("mode").asText());
+ assertEquals(3, parameters.path(2).path("scale").asInt());
+ assertTrue(parameters.path(2).path("nullable").asBoolean());
+ assertEquals("OUT", parameters.path(3).path("mode").asText());
+ assertEquals(80, parameters.path(3).path("length").asInt());
+ assertEquals("UNKNOWN", parameters.path(4).path("mode").asText());
+ assertFalse(parameters.path(4).has("ordinal"));
+ assertFalse(parameters.path(4).has("jdbc_type"));
+ } finally {
+ closeAndDeregister(connection, driver);
+ }
+ }
+
+ @Test
+ void getObjectSourceUsesFunctionColumnConstants() throws Exception {
+ List<String> calls = new ArrayList<>();
+ String url = "jdbc:dbx-routine-columns-function:";
+ Driver driver = new RoutineColumnsDriver(url, calls, false);
+ DriverManager.registerDriver(driver);
+ String connection = """
+ { "connection_string": "%sdemo" }
+ """.formatted(url);
+ try {
+ JsonNode response = request("getObjectSource", """
+ {
+ "connection": %s,
+ "database": "catalog1",
+ "schema": "APP",
+ "name": "calculate_total",
+ "object_type": "FUNCTION"
+ }
+ """.formatted(connection));
+
+ assertFalse(response.has("error"), response.toString());
+ assertEquals(List.of("getFunctionColumns:catalog1:APP:calculate\\_total:%"), calls);
+ JsonNode parameters = response.path("result").path("routine_parameters");
+ assertEquals("RETURN", parameters.path(0).path("mode").asText());
+ assertEquals("IN", parameters.path(1).path("mode").asText());
+ assertEquals("OUT", parameters.path(2).path("mode").asText());
+ } finally {
+ closeAndDeregister(connection, driver);
+ }
+ }
+
+ @Test
+ void getObjectSourceKeepsRoutineDetailsAvailableWhenColumnMetadataIsUnsupported() throws Exception {
+ List<String> calls = new ArrayList<>();
+ String url = "jdbc:dbx-routine-columns-unsupported:";
+ Driver driver = new RoutineColumnsDriver(url, calls, true);
+ DriverManager.registerDriver(driver);
+ String connection = """
+ { "connection_string": "%sdemo" }
+ """.formatted(url);
+ try {
+ JsonNode response = request("getObjectSource", """
+ {
+ "connection": %s,
+ "database": "catalog1",
+ "schema": "APP",
+ "name": "legacy_proc",
+ "object_type": "PROCEDURE"
+ }
+ """.formatted(connection));
+
+ assertFalse(response.has("error"), response.toString());
+ assertEquals("", response.path("result").path("source").asText());
+ assertFalse(response.path("result").path("editable").asBoolean(true));
+ assertFalse(response.path("result").has("routine_parameters"));
+ assertEquals(List.of("getProcedureColumns:catalog1:APP:legacy\\_proc:%"), calls);
+ } finally {
+ closeAndDeregister(connection, driver);
+ }
+ }
+
+ @Test
+ void getObjectSourceKeepsSybaseRoutineBehaviorUnchanged() throws Exception {
+ List<String> calls = new ArrayList<>();
+ String url = "jdbc:sybase:Tds:sybase-routine-unsupported-test:5000";
+ Driver driver = new SybaseViewSourceDriver(url, calls);
+ DriverManager.registerDriver(driver);
+ String connection = """
+ { "connection_string": "%s" }
+ """.formatted(url);
+ try {
+ JsonNode response = request("getObjectSource", """
+ {
+ "connection": %s,
+ "database": "appdb",
+ "schema": "dbo",
+ "name": "legacy_proc",
+ "object_type": "PROCEDURE"
+ }
+ """.formatted(connection));
+
+ assertEquals(
+ "Object source is not supported by this JDBC driver",
+ response.path("error").path("message").asText()
+ );
+ assertTrue(calls.isEmpty());
+ } finally {
+ closeAndDeregister(connection, driver);
+ }
+ }
+
@Test
void getObjectSourceKeepsUnsupportedObjectTypesOnPlainJdbcDrivers() throws Exception {
JsonNode response = request("getObjectSource", """