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
perf(search): batch column fetch and multi-table probe
Lan-zkc7c266c309f0
diff --git a/apps/desktop/src/components/search/DatabaseSearchPanel.vue b/apps/desktop/src/components/search/DatabaseSearchPanel.vueindex 1946d86b42..084c3a1286 100644--- a/apps/desktop/src/components/search/DatabaseSearchPanel.vue+++ b/apps/desktop/src/components/search/DatabaseSearchPanel.vue@@ -12,7 +12,10 @@ import { useConnectionStore } from "@/stores/connectionStore";import * as api from "@/lib/backend/api";import { buildDatabaseSearchSql, buildSearchResultWhere, findMatchedSearchColumns } from "@/lib/database/databaseSearch";import { databaseSearchBatchRange, databaseSearchNextBatchSize } from "@/lib/database/databaseSearchBatch";-import type { DatabaseSearchResultItem, DatabaseSearchScope, DatabaseSearchTableTask, DatabaseSearchTabState, DatabaseType, TableInfo } from "@/types/database";+import { fetchDatabaseSearchColumns, findSearchColumns, type DatabaseSearchColumnLite, type SearchColumnsByTable } from "@/lib/database/databaseSearchColumns";+import { nextProbeChunkEnd, probeTables } from "@/lib/database/databaseSearchProbe";+import { supportsBulkDatabaseSearch } from "@/lib/database/databaseSearchCapabilities";+import type { ColumnInfo, DatabaseSearchResultItem, DatabaseSearchScope, DatabaseSearchTableTask, DatabaseSearchTabState, DatabaseType, TableInfo } from "@/types/database";import { buildDatabaseStructureSearchSql, effectiveDatabaseSearchScope, runDatabaseStructureSearch, structureHitPreview, supportsDatabaseStructureSearchFromManifest } from "@/lib/database/databaseStructureSearch";import { usesDocumentStructureSearch, usesSqlCatalogStructureSearch } from "@/lib/database/databaseStructureSearchCapabilities";import type { NavigationTarget } from "@/composables/useNavigationTargets";@@ -60,6 +63,8 @@ const generalError = ref(props.initialState?.generalError ?? "");const currentExecutionId = ref("");const tableTasks = ref<DatabaseSearchTableTask[]>(props.initialState?.tableTasks ? [...props.initialState.tableTasks] : []);const nextTableIndex = ref(props.initialState?.nextTableIndex ?? 0);+// 批量取列结果(键小写)。不进持久化 tab state:组件存活期间复用,重建后为空走逐表回退。+const columnsByTable = ref<SearchColumnsByTable>(new Map());const activeKeyword = ref(props.initialState?.activeKeyword ?? "");const activePerTableLimit = ref(props.initialState?.activePerTableLimit ?? 20);let runId = 0;@@ -132,6 +137,7 @@ function resetSearchState() {currentExecutionId.value = "";tableTasks.value = [];nextTableIndex.value = 0;+ columnsByTable.value = new Map();activeKeyword.value = "";activePerTableLimit.value = 20;emitState();@@ -226,6 +232,8 @@ async function startSearch() {progressTotal.value = tableTasks.value.length;loadingTables.value = false;emitState();+ await loadBulkColumns(currentRun);+ if (currentRun !== runId || cancelled.value) return;await scanTableRange(currentRun, false);} catch (error: any) {if (currentRun === runId && !cancelled.value) {@@ -333,25 +341,125 @@ async function runStructureSearch(currentRun: number) {}}+/** 批量取列:按任务表涉及的 schema 各发一条目录查询,失败静默(空 Map → 逐表回退)。 */+async function loadBulkColumns(currentRun: number) {+ const databaseType = connection.value?.db_type;+ if (!databaseType || !supportsBulkDatabaseSearch(databaseType)) return;+ const schemas = [...new Set(tableTasks.value.map((task) => task.schema))];+ const merged: SearchColumnsByTable = new Map();+ for (const schema of schemas) {+ if (currentRun !== runId || cancelled.value) return;+ const executionId = makeExecutionId();+ currentExecutionId.value = executionId;+ const partial = await fetchDatabaseSearchColumns({+ databaseType,+ database: props.database,+ schema,+ executeQuery: (sql, runExecutionId) => api.executeQuery(props.connectionId, props.database, sql, undefined, runExecutionId),+ executionId,+ });+ if (currentExecutionId.value === executionId) currentExecutionId.value = "";+ if (currentRun !== runId || cancelled.value) return;+ partial.forEach((columns, key) => merged.set(key, columns));+ }+ columnsByTable.value = merged;+}+async function scanTableRange(currentRun: number, scanAllRemaining: boolean) {const range = databaseSearchBatchRange(nextTableIndex.value, tableTasks.value.length, scanAllRemaining);+ const databaseType = connection.value!.db_type;+ const probeReady = supportsBulkDatabaseSearch(databaseType) && columnsByTable.value.size > 0;+ // 每张任务的预取列(可能为 undefined——该表无目录信息,批内走逐表回退)+ const taskColumns = tableTasks.value.map((task) => findSearchColumns(columnsByTable.value, task.schema, props.database, task.table.name));+while (nextTableIndex.value < range.end) {if (currentRun !== runId || cancelled.value) break;- const task = tableTasks.value[nextTableIndex.value];- if (!task) break;- await searchTable(task, connection.value!.db_type, currentRun);+ const chunkStart = nextTableIndex.value;+ const chunkEnd = probeReady ? nextProbeChunkEnd(chunkStart, range.end, taskColumns, activeKeyword.value) : Math.min(chunkStart + 1, range.end);+ const chunk = tableTasks.value.slice(chunkStart, chunkEnd);+ if (!chunk.length) break;++ let hitChunkIndexes: Set<number> | undefined;+ if (probeReady) {+ hitChunkIndexes = await probeChunk(chunk, taskColumns.slice(chunkStart, chunkEnd), databaseType, currentRun);+ }if (currentRun !== runId || cancelled.value) break;- nextTableIndex.value += 1;- progressDone.value = nextTableIndex.value;- emitState();++ for (let offset = 0; offset < chunk.length; offset++) {+ if (currentRun !== runId || cancelled.value) break;+ const taskIndex = chunkStart + offset;+ const task = chunk[offset];+ const prefetched = taskColumns[taskIndex];+ // 探测路径下:未命中的表跳过取数;无目录信息的表恒走逐表+ if (hitChunkIndexes && prefetched && !hitChunkIndexes.has(taskIndex)) {+ // skip: 探测未命中+ } else {+ await searchTable(task, databaseType, currentRun, prefetched);+ }+ nextTableIndex.value = taskIndex + 1;+ progressDone.value = nextTableIndex.value;+ emitState();+ }}}-async function searchTable(task: DatabaseSearchTableTask, databaseType: DatabaseType, currentRun: number) {+/** 对一个探测批执行多表探测,返回命中表的全局下标集合;语句失败整批回退(全部视为待取数)。 */+async function probeChunk(chunk: DatabaseSearchTableTask[], chunkColumns: Array<DatabaseSearchColumnLite[] | undefined>, databaseType: DatabaseType, currentRun: number): Promise<Set<number>> {+ const chunkStart = nextTableIndex.value;+ const probeable: number[] = [];+ chunkColumns.forEach((columns, offset) => {+ if (columns?.length) probeable.push(offset);+ });++ if (!probeable.length) return new Set();++ const executionId = makeExecutionId();+ currentExecutionId.value = executionId;+ let hitProbeIndexes: Set<number>;+ try {+ hitProbeIndexes = await probeTables({+ databaseType,+ driverProfile: connection.value?.driver_profile,+ term: activeKeyword.value,+ limit: activePerTableLimit.value,+ tables: probeable.map((offset) => ({+ schema: chunk[offset].schema,+ tableName: chunk[offset].table.name,+ columns: chunkColumns[offset]!,+ })),+ executeQuery: (sql, runExecutionId) => api.executeQuery(props.connectionId, props.database, sql, undefined, runExecutionId),+ executionId,+ });+ } catch {+ // 探测批失败(单表权限/中途 DDL 等):整批回退逐表,错误重新隔离到单表+ hitProbeIndexes = new Set(probeable.map((_, index) => index));+ }+ if (currentExecutionId.value === executionId) currentExecutionId.value = "";+ if (currentRun !== runId || cancelled.value) return new Set();++ const hitTaskIndexes = new Set<number>();+ hitProbeIndexes.forEach((probeIndex) => {+ const offset = probeable[probeIndex];+ if (offset !== undefined) hitTaskIndexes.add(chunkStart + offset);+ });+ return hitTaskIndexes;+}++async function searchTable(task: DatabaseSearchTableTask, databaseType: DatabaseType, currentRun: number, prefetchedColumns?: DatabaseSearchColumnLite[]) {const tableLabel = task.schema ? `${task.schema}.${task.table.name}` : task.table.name;try {const schema = task.schema || props.database;- const columns = await api.getColumns(props.connectionId, props.database, schema, task.table.name);+ // 批量取列命中时跳过逐表 getColumns;数据搜索单表查询只消费这三个字段+ const columns: ColumnInfo[] = prefetchedColumns?.length+ ? prefetchedColumns.map((column) => ({+ name: column.name,+ data_type: column.data_type,+ is_primary_key: column.is_primary_key,+ is_nullable: false,+ column_default: null,+ extra: null,+ }))+ : await api.getColumns(props.connectionId, props.database, schema, task.table.name);const query = await buildDatabaseSearchSql({databaseType,driverProfile: connection.value?.driver_profile,diff --git a/apps/desktop/src/components/search/__tests__/DatabaseSearchPanel.flow.spec.ts b/apps/desktop/src/components/search/__tests__/DatabaseSearchPanel.flow.spec.tsnew file mode 100644index 0000000000..cc53ee14b9--- /dev/null+++ b/apps/desktop/src/components/search/__tests__/DatabaseSearchPanel.flow.spec.ts@@ -0,0 +1,261 @@+// @vitest-environment happy-dom++import { createApp, defineComponent, h, nextTick, ref, type App } from "vue";+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";+import { createPinia, setActivePinia } from "pinia";+import i18n from "@/i18n";+import * as api from "@/lib/backend/api";+import DatabaseSearchPanel from "@/components/search/DatabaseSearchPanel.vue";++vi.mock("@/lib/backend/api", () => ({+ listSchemas: vi.fn(),+ listTables: vi.fn(),+ getColumns: vi.fn(),+ executeQuery: vi.fn(),+ buildDatabaseSearchSql: vi.fn(),+ buildDatabaseSearchColumnsSql: vi.fn(),+ buildDatabaseSearchProbeSql: vi.fn(),+ buildSearchResultWhere: vi.fn(),+ cancelQuery: vi.fn(),+}));++const connectionConfig: { id: string; name: string; db_type: string; driver_profile: string | null } = {+ id: "conn-1",+ name: "test-conn",+ db_type: "dameng",+ driver_profile: null,+};++vi.mock("@/stores/connectionStore", () => ({+ useConnectionStore: () => ({+ getConfig: (id: string) => (connectionConfig.id === id ? connectionConfig : undefined),+ ensureConnected: vi.fn(async () => {}),+ }),+}));++vi.mock("@/components/ui/button", async () => {+ const { defineComponent, h } = await import("vue");+ return {+ Button: defineComponent({+ props: { disabled: Boolean, variant: String, size: String },+ emits: ["click"],+ setup(props, { slots, emit }) {+ return () => h("button", { disabled: props.disabled, onClick: (e: MouseEvent) => emit("click", e) }, slots.default?.());+ },+ }),+ };+});++vi.mock("@/components/ui/input", async () => {+ const { defineComponent, h } = await import("vue");+ return {+ Input: defineComponent({+ props: { modelValue: [String, Number], disabled: Boolean, placeholder: String, type: String },+ emits: ["update:modelValue", "keydown"],+ setup(props, { emit }) {+ return () =>+ h("input", {+ value: props.modelValue,+ disabled: props.disabled,+ placeholder: props.placeholder,+ type: props.type || "text",+ onInput: (e: any) => emit("update:modelValue", e.target.value),+ onKeydown: (e: any) => emit("keydown", e),+ });+ },+ }),+ };+});++vi.mock("@/components/ui/badge", async () => {+ const { defineComponent, h } = await import("vue");+ return {+ Badge: defineComponent({+ setup(_props, { slots }) {+ return () => h("span", slots.default?.());+ },+ }),+ };+});++vi.mock("@/components/ui/label", async () => {+ const { defineComponent, h } = await import("vue");+ return {+ Label: defineComponent({+ setup(_props, { slots }) {+ return () => h("label", slots.default?.());+ },+ }),+ };+});++vi.mock("@/components/ui/select", async () => {+ const { defineComponent, h } = await import("vue");+ const passthrough = defineComponent({+ setup(_props, { slots }) {+ return () => h("div", slots.default?.());+ },+ });+ return { Select: passthrough, SelectContent: passthrough, SelectItem: passthrough, SelectTrigger: passthrough, SelectValue: passthrough };+});++const mountedApps: App[] = [];++beforeEach(() => {+ setActivePinia(createPinia());+ connectionConfig.db_type = "dameng";+});++afterEach(() => {+ // 模块工厂里的 vi.fn 不受 restoreAllMocks 影响,必须显式清调用历史与实现+ vi.clearAllMocks();+ for (const app of mountedApps.splice(0)) app.unmount();+ document.body.innerHTML = "";+});++const TABLES = [+ { name: "USERS", table_type: "TABLE" },+ { name: "FILES", table_type: "TABLE" },+ { name: "V_ORDERS", table_type: "VIEW" },+];++const BULK_COLUMN_ROWS = {+ columns: ["table_name", "column_name", "data_type", "is_primary_key"],+ rows: [+ ["USERS", "ID", "NUMBER", 1],+ ["USERS", "EMAIL", "VARCHAR2", 0],+ ["FILES", "DATA", "BLOB", 0],+ ],+};++async function mountPanel() {+ vi.mocked(api.listTables).mockResolvedValue(TABLES as any);+ vi.mocked(api.getColumns).mockResolvedValue([]);+ vi.mocked(api.buildSearchResultWhere).mockResolvedValue('"ID" = 1');+ vi.mocked(api.buildDatabaseSearchSql).mockResolvedValue({ sql: "SELECT_USERS", searchableColumns: ["EMAIL"] });+ vi.mocked(api.buildDatabaseSearchColumnsSql).mockResolvedValue({ sql: "COLS_SQL" });+ vi.mocked(api.buildDatabaseSearchProbeSql).mockResolvedValue({ sql: "PROBE_SQL", includedIndices: [0] });++ const states: any[] = [];+ const panelRef = ref<any>(null);+ const container = document.createElement("div");+ document.body.append(container);+ const app = createApp(+ defineComponent({+ setup() {+ return () =>+ h(DatabaseSearchPanel, {+ ref: panelRef,+ connectionId: "conn-1",+ database: "shop",+ schema: "DLWEB",+ initialState: { keyword: "admin" },+ inDialog: true,+ "onUpdate:state": (state: any) => states.push(state),+ });+ },+ }),+ );+ app.use(i18n);+ mountedApps.push(app);+ app.mount(container);+ await nextTick();+ return { panelRef, states };+}++describe("DatabaseSearchPanel scan flow", () => {+ it("bulk path: one columns query + one probe, fetch rows only for hit tables", async () => {+ vi.mocked(api.executeQuery).mockImplementation(async (_conn: string, _db: string, sql: string) => {+ if (sql === "COLS_SQL") return BULK_COLUMN_ROWS as any;+ if (sql === "PROBE_SQL") return { columns: ["TABLE_LABEL", "HITS"], rows: [["t0", 2]] } as any;+ if (sql === "SELECT_USERS") return { columns: ["ID", "EMAIL"], rows: [[1, "[email protected]"]] } as any;+ throw new Error(`unexpected sql: ${sql}`);+ });++ const { panelRef, states } = await mountPanel();+ await panelRef.value.startSearch();+ await vi.waitFor(() => {+ expect(states.at(-1)?.progressDone).toBe(2);+ });++ // 批量取列:一条目录查询,零次逐表 getColumns+ expect(api.buildDatabaseSearchColumnsSql).toHaveBeenCalledTimes(1);+ expect(api.getColumns).not.toHaveBeenCalled();++ // 探测:两个任务表(视图已被排除),只有 USERS 命中并取数+ expect(api.buildDatabaseSearchProbeSql).toHaveBeenCalledTimes(1);+ const probeArg = vi.mocked(api.buildDatabaseSearchProbeSql).mock.calls[0][0];+ expect(probeArg.tables.map((t: any) => t.tableName)).toEqual(["USERS", "FILES"]);+ expect(api.buildDatabaseSearchSql).toHaveBeenCalledTimes(1);+ expect(vi.mocked(api.buildDatabaseSearchSql).mock.calls[0][0].tableName).toBe("USERS");+ // 预取列被传入单表查询(证明不再走 getColumns)+ expect(vi.mocked(api.buildDatabaseSearchSql).mock.calls[0][0].columns.map((c: any) => c.name)).toEqual(["ID", "EMAIL"]);++ // 结果与回表条件一致+ const finalState = states.at(-1);+ expect(finalState.results).toHaveLength(1);+ expect(finalState.results[0].tableName).toBe("USERS");+ expect(finalState.results[0].whereInput).toBe('"ID" = 1');+ expect(finalState.progressTotal).toBe(2);+ });++ it("probe failure falls back to per-table scan for the whole batch", async () => {+ vi.mocked(api.executeQuery).mockImplementation(async (_conn: string, _db: string, sql: string) => {+ if (sql === "COLS_SQL") return BULK_COLUMN_ROWS as any;+ if (sql === "PROBE_SQL") throw new Error("ORA-00942: table or view does not exist");+ if (sql === "SELECT_USERS") return { columns: ["ID", "EMAIL"], rows: [[1, "[email protected]"]] } as any;+ throw new Error(`unexpected sql: ${sql}`);+ });++ const { panelRef, states } = await mountPanel();+ await panelRef.value.startSearch();+ await vi.waitFor(() => {+ expect(states.at(-1)?.progressDone).toBe(2);+ });++ // 整批回退:两张表都执行了逐表取数查询,列信息仍来自批量 Map+ expect(api.buildDatabaseSearchSql).toHaveBeenCalledTimes(2);+ expect(vi.mocked(api.buildDatabaseSearchSql).mock.calls.map((c) => c[0].tableName)).toEqual(["USERS", "FILES"]);+ expect(api.getColumns).not.toHaveBeenCalled();+ // 失败被吞掉,不产生 generalError+ expect(states.at(-1)?.generalError).toBe("");+ });++ it("unsupported dialect silently falls back to per-table getColumns", async () => {+ connectionConfig.db_type = "sqlite";+ vi.mocked(api.getColumns).mockResolvedValue([{ name: "EMAIL", data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: false, extra: null }] as any);+ vi.mocked(api.executeQuery).mockImplementation(async (_conn: string, _db: string, sql: string) => {+ if (sql === "SELECT_USERS") return { columns: ["EMAIL"], rows: [["[email protected]"]] } as any;+ throw new Error(`unexpected sql: ${sql}`);+ });++ const { panelRef, states } = await mountPanel();+ await panelRef.value.startSearch();+ await vi.waitFor(() => {+ expect(states.at(-1)?.progressDone).toBe(2);+ });++ expect(api.buildDatabaseSearchColumnsSql).not.toHaveBeenCalled();+ expect(api.buildDatabaseSearchProbeSql).not.toHaveBeenCalled();+ expect(api.getColumns).toHaveBeenCalledTimes(2);+ expect(api.buildDatabaseSearchSql).toHaveBeenCalledTimes(2);+ });++ it("tables without probe hits advance progress without any fetch query", async () => {+ vi.mocked(api.executeQuery).mockImplementation(async (_conn: string, _db: string, sql: string) => {+ if (sql === "COLS_SQL") return BULK_COLUMN_ROWS as any;+ throw new Error(`unexpected sql: ${sql}`);+ });++ const { panelRef, states } = await mountPanel();+ // mountPanel 会设置默认探测 mock,这里在启动前覆盖为 null(全部无可搜列等价场景)+ vi.mocked(api.buildDatabaseSearchProbeSql).mockResolvedValue(null);+ await panelRef.value.startSearch();+ await vi.waitFor(() => {+ expect(states.at(-1)?.progressDone).toBe(2);+ });++ expect(api.buildDatabaseSearchSql).not.toHaveBeenCalled();+ expect(states.at(-1)?.results).toHaveLength(0);+ });+});diff --git a/apps/desktop/src/lib/backend/api.ts b/apps/desktop/src/lib/backend/api.tsindex 2a9f39b7ea..c67b84c96d 100644--- a/apps/desktop/src/lib/backend/api.ts+++ b/apps/desktop/src/lib/backend/api.ts@@ -304,6 +304,8 @@ export const buildCreateUserSql = forward("buildCreateUserSql");export const buildDroppedFilePreviewSql = forward("buildDroppedFilePreviewSql");export const buildTableSelectSql = forward("buildTableSelectSql");export const buildDatabaseSearchSql = forward("buildDatabaseSearchSql");+export const buildDatabaseSearchColumnsSql = forward("buildDatabaseSearchColumnsSql");+export const buildDatabaseSearchProbeSql = forward("buildDatabaseSearchProbeSql");export const buildDatabaseStructureSearchSql = forward("buildDatabaseStructureSearchSql");export const supportsDatabaseStructureSearch = forward("supportsDatabaseStructureSearch");export const buildSearchResultWhere = forward("buildSearchResultWhere");diff --git a/apps/desktop/src/lib/backend/http.ts b/apps/desktop/src/lib/backend/http.tsindex 9d813dfa49..299fd6bbb3 100644--- a/apps/desktop/src/lib/backend/http.ts+++ b/apps/desktop/src/lib/backend/http.ts@@ -1873,6 +1873,14 @@ export async function buildDatabaseSearchSql(options: DatabaseSearchSqlOptions):return post("/api/query/build-database-search-sql", { options });}+export async function buildDatabaseSearchColumnsSql(options: import("@/lib/database/databaseSearchColumns").DatabaseSearchColumnsSqlOptions): Promise<{ sql: string } | null> {+ return post("/api/query/build-database-search-columns-sql", { options });+}++export async function buildDatabaseSearchProbeSql(options: import("@/lib/database/databaseSearchProbe").DatabaseSearchProbeSqlOptions): Promise<{ sql: string; includedIndices: number[] } | null> {+ return post("/api/query/build-database-search-probe-sql", { options });+}+export async function buildDatabaseStructureSearchSql(options: DatabaseStructureSearchSqlOptions): Promise<DatabaseStructureSearchSql | null> {return post("/api/query/build-database-structure-search-sql", { options });}diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.tsindex 5cf2e62826..24c821b52d 100644--- a/apps/desktop/src/lib/backend/tauri.ts+++ b/apps/desktop/src/lib/backend/tauri.ts@@ -2310,6 +2310,14 @@ export async function buildDatabaseSearchSql(options: DatabaseSearchSqlOptions):return invoke("build_database_search_sql", { options });}+export async function buildDatabaseSearchColumnsSql(options: import("@/lib/database/databaseSearchColumns").DatabaseSearchColumnsSqlOptions): Promise<{ sql: string } | null> {+ return invoke("build_database_search_columns_sql", { options });+}++export async function buildDatabaseSearchProbeSql(options: import("@/lib/database/databaseSearchProbe").DatabaseSearchProbeSqlOptions): Promise<{ sql: string; includedIndices: number[] } | null> {+ return invoke("build_database_search_probe_sql", { options });+}+export async function buildDatabaseStructureSearchSql(options: DatabaseStructureSearchSqlOptions): Promise<DatabaseStructureSearchSql | null> {return invoke("build_database_structure_search_sql", { options });}diff --git a/apps/desktop/src/lib/database/__tests__/databaseSearchCapabilities.spec.ts b/apps/desktop/src/lib/database/__tests__/databaseSearchCapabilities.spec.tsnew file mode 100644index 0000000000..0e40f8a957--- /dev/null+++ b/apps/desktop/src/lib/database/__tests__/databaseSearchCapabilities.spec.ts@@ -0,0 +1,18 @@+import { describe, expect, it } from "vitest";+import { BULK_DATABASE_SEARCH_TYPES, supportsBulkDatabaseSearch } from "@/lib/database/databaseSearchCapabilities";++// 镜像 Rust database_search_columns_sql.rs / database_search_probe_sql.rs 的家族 match 臂:+// 两边同步修改时必须一并更新此快照,防止前端预判与后端判定漂移。+const RUST_BULK_SEARCH_FAMILIES = ["oracle", "oceanbase-oracle", "dameng", "mysql", "doris", "starrocks", "manticoresearch", "goldendb", "postgres", "kingbase", "highgo", "uxdb", "vastbase", "opengauss", "gaussdb", "kwdb", "yashandb", "oscar", "redshift", "sqlserver"];++describe("databaseSearchCapabilities", () => {+ it("mirrors the Rust bulk search family dispatch", () => {+ expect([...BULK_DATABASE_SEARCH_TYPES].sort()).toEqual([...RUST_BULK_SEARCH_FAMILIES].sort());+ });++ it("gates unsupported dialects", () => {+ expect(supportsBulkDatabaseSearch("dameng")).toBe(true);+ expect(supportsBulkDatabaseSearch("sqlite")).toBe(false);+ expect(supportsBulkDatabaseSearch(undefined)).toBe(false);+ });+});diff --git a/apps/desktop/src/lib/database/__tests__/databaseSearchColumns.spec.ts b/apps/desktop/src/lib/database/__tests__/databaseSearchColumns.spec.tsnew file mode 100644index 0000000000..f88542e41a--- /dev/null+++ b/apps/desktop/src/lib/database/__tests__/databaseSearchColumns.spec.ts@@ -0,0 +1,119 @@+import { afterEach, describe, expect, it, vi } from "vitest";+import * as api from "@/lib/backend/api.ts";+import { fetchDatabaseSearchColumns, findSearchColumns, searchColumnsTableKey } from "@/lib/database/databaseSearchColumns";++afterEach(() => {+ vi.restoreAllMocks();+});++function rowsResult(columns: string[], rows: unknown[][]) {+ return { columns, rows };+}++describe("databaseSearchColumns", () => {+ it("groups catalog rows by table with lowercase keys", async () => {+ const buildSpy = vi.spyOn(api, "buildDatabaseSearchColumnsSql").mockResolvedValue({ sql: "SELECT 1" });+ const executeQuery = vi.fn().mockResolvedValue(+ rowsResult(+ ["TABLE_NAME", "COLUMN_NAME", "DATA_TYPE", "IS_PRIMARY_KEY"],+ [+ ["USERS", "ID", "NUMBER", 1],+ ["USERS", "EMAIL", "VARCHAR2", 0],+ ["ORDERS", "ID", "NUMBER", 1],+ ],+ ),+ );++ const map = await fetchDatabaseSearchColumns({+ databaseType: "dameng",+ database: "app",+ schema: "DLWEB",+ executeQuery,+ executionId: "exec-1",+ });++ expect(buildSpy).toHaveBeenCalledWith({ databaseType: "dameng", database: "app", schema: "DLWEB" });+ const users = findSearchColumns(map, "DLWEB", "app", "USERS");+ expect(users).toHaveLength(2);+ expect(users?.[0]).toEqual({ name: "ID", data_type: "NUMBER", is_primary_key: true });+ expect(users?.[1]?.is_primary_key).toBe(false);+ expect(findSearchColumns(map, "dlweb", "app", "users")).toHaveLength(2);+ expect(findSearchColumns(map, "DLWEB", "app", "ORDERS")).toHaveLength(1);+ });++ it("normalizes primary key flag variants", async () => {+ vi.spyOn(api, "buildDatabaseSearchColumnsSql").mockResolvedValue({ sql: "SELECT 1" });+ const executeQuery = vi.fn().mockResolvedValue(+ rowsResult(+ ["table_name", "column_name", "data_type", "is_primary_key"],+ [+ ["t1", "a", "int", true],+ ["t1", "b", "int", false],+ ["t2", "a", "int", "1"],+ ["t2", "b", "int", "0"],+ ["t3", "a", "int", 1],+ ["t3", "b", "int", 0],+ ],+ ),+ );++ const map = await fetchDatabaseSearchColumns({ databaseType: "postgres", database: "app", executeQuery, executionId: "e" });+ const t1 = findSearchColumns(map, undefined, "app", "t1")!;+ const t2 = findSearchColumns(map, undefined, "app", "t2")!;+ const t3 = findSearchColumns(map, undefined, "app", "t3")!;+ expect(t1.map((c) => c.is_primary_key)).toEqual([true, false]);+ expect(t2.map((c) => c.is_primary_key)).toEqual([true, false]);+ expect(t3.map((c) => c.is_primary_key)).toEqual([true, false]);+ });++ it("returns empty map when builder yields no sql", async () => {+ const buildSpy = vi.spyOn(api, "buildDatabaseSearchColumnsSql").mockResolvedValue(null);+ const executeQuery = vi.fn();+ const map = await fetchDatabaseSearchColumns({ databaseType: "dameng", database: "app", executeQuery, executionId: "e" });+ expect(map.size).toBe(0);+ expect(buildSpy).toHaveBeenCalled();+ expect(executeQuery).not.toHaveBeenCalled();+ });++ it("returns empty map when the catalog result is truncated so callers fall back per-table", async () => {+ vi.spyOn(api, "buildDatabaseSearchColumnsSql").mockResolvedValue({ sql: "SELECT 1" });+ const executeQuery = vi.fn().mockResolvedValue({+ columns: ["TABLE_NAME", "COLUMN_NAME", "DATA_TYPE", "IS_PRIMARY_KEY"],+ rows: [+ ["USERS", "ID", "NUMBER", 1],+ ["USERS", "EMAIL", "VARCHAR2", 0],+ ],+ truncated: true,+ });++ const map = await fetchDatabaseSearchColumns({+ databaseType: "dameng",+ database: "app",+ schema: "DLWEB",+ executeQuery,+ executionId: "exec-1",+ });++ expect(map.size).toBe(0);+ });++ it("returns empty map when the catalog query fails", async () => {+ vi.spyOn(api, "buildDatabaseSearchColumnsSql").mockResolvedValue({ sql: "SELECT 1" });+ const executeQuery = vi.fn().mockRejectedValue(new Error("permission denied"));+ const map = await fetchDatabaseSearchColumns({ databaseType: "mysql", database: "app", executeQuery, executionId: "e" });+ expect(map.size).toBe(0);+ });++ it("skips bulk fetch for unsupported dialects without calling the builder", async () => {+ const buildSpy = vi.spyOn(api, "buildDatabaseSearchColumnsSql");+ const map = await fetchDatabaseSearchColumns({ databaseType: "sqlite", database: "app", executeQuery: vi.fn(), executionId: "e" });+ expect(map.size).toBe(0);+ expect(buildSpy).not.toHaveBeenCalled();+ });++ it("keys use schema when present and database otherwise", () => {+ expect(searchColumnsTableKey("public", "app", "Users")).toBe("public\nusers");+ expect(searchColumnsTableKey(undefined, "app", "Users")).toBe("app\nusers");+ expect(searchColumnsTableKey(" ", "app", "Users")).toBe("app\nusers");+ });+});diff --git a/apps/desktop/src/lib/database/__tests__/databaseSearchProbe.spec.ts b/apps/desktop/src/lib/database/__tests__/databaseSearchProbe.spec.tsnew file mode 100644index 0000000000..30f7829534--- /dev/null+++ b/apps/desktop/src/lib/database/__tests__/databaseSearchProbe.spec.ts@@ -0,0 +1,106 @@+import { afterEach, describe, expect, it, vi } from "vitest";+import * as api from "@/lib/backend/api.ts";+import type { DatabaseSearchColumnLite } from "@/lib/database/databaseSearchColumns";+import { countProbeConditions, DATABASE_SEARCH_PROBE_CONDITION_LIMIT, DATABASE_SEARCH_PROBE_TABLE_BATCH_SIZE, nextProbeChunkEnd, probeTables } from "@/lib/database/databaseSearchProbe";++afterEach(() => {+ vi.restoreAllMocks();+});++function col(name: string, data_type: string): DatabaseSearchColumnLite {+ return { name, data_type, is_primary_key: false };+}++describe("databaseSearchProbe", () => {+ it("counts text columns and numeric columns only for numeric terms", () => {+ const columns = [col("a", "varchar"), col("b", "int"), col("c", "text"), col("d", "decimal")];+ expect(countProbeConditions(columns, "alice")).toBe(2);+ expect(countProbeConditions(columns, "42")).toBe(4);+ expect(countProbeConditions([], "alice")).toBe(0);+ });++ it("caps chunks at the table batch size", () => {+ const tasks = Array.from({ length: 30 }, () => [col("a", "varchar")]);+ expect(nextProbeChunkEnd(0, tasks.length, tasks, "x")).toBe(DATABASE_SEARCH_PROBE_TABLE_BATCH_SIZE);+ expect(nextProbeChunkEnd(15, tasks.length, tasks, "x")).toBe(30);+ });++ it("splits before the table that would exceed the condition limit", () => {+ // 每表 60 条件:第 8 张起累计 480,第 9 张会到 540 > 500 → 批在第 8 张后切分+ const heavy = Array.from({ length: 60 }, (_, i) => col(`c${i}`, "varchar"));+ const tasks = Array.from({ length: 12 }, () => heavy);+ expect(nextProbeChunkEnd(0, tasks.length, tasks, "x")).toBe(8);++ // 无列信息的表按 0 条件计,不触顶+ const unknown = [heavy, undefined, heavy, undefined];+ expect(nextProbeChunkEnd(0, 4, unknown, "x")).toBe(4);+ });++ it("always takes at least one table even beyond the condition limit", () => {+ const huge = Array.from({ length: DATABASE_SEARCH_PROBE_CONDITION_LIMIT + 10 }, (_, i) => col(`c${i}`, "varchar"));+ expect(nextProbeChunkEnd(0, 3, [huge, huge, huge], "x")).toBe(1);+ });++ it("maps label rows back to hit table indexes via includedIndices", async () => {+ const buildSpy = vi.spyOn(api, "buildDatabaseSearchProbeSql").mockResolvedValue({+ sql: "SELECT 1",+ // 输入 3 张表,第 0、2 张进探测分支(t0、t1),第 1 张被剔除+ includedIndices: [0, 2],+ });+ const executeQuery = vi.fn().mockResolvedValue({+ columns: ["TABLE_LABEL", "HITS"],+ rows: [+ ["t0", 3],+ ["t1", 0],+ ["tX", 9],+ ],+ });++ const hits = await probeTables({+ databaseType: "dameng",+ term: "alice",+ limit: 20,+ tables: [+ { tableName: "a", columns: [col("x", "varchar2")] },+ { tableName: "b", columns: [col("x", "blob")] },+ { tableName: "c", columns: [col("y", "text")] },+ ],+ executeQuery,+ executionId: "e",+ });++ expect(buildSpy).toHaveBeenCalled();+ // t0 命中(hits=3)→ 输入下标 0;t1 未命中(hits=0);未知标签 tX 忽略;被剔除的输入下标 1 不出现+ expect([...hits]).toEqual([0]);+ expect(hits.has(1)).toBe(false);+ expect(hits.has(2)).toBe(false);+ });++ it("returns empty set when the builder yields no sql", async () => {+ vi.spyOn(api, "buildDatabaseSearchProbeSql").mockResolvedValue(null);+ const hits = await probeTables({+ databaseType: "mysql",+ term: "alice",+ limit: 20,+ tables: [{ tableName: "a", columns: [col("x", "varchar")] }],+ executeQuery: vi.fn(),+ executionId: "e",+ });+ expect(hits.size).toBe(0);+ });++ it("propagates statement failures so callers fall back per table", async () => {+ vi.spyOn(api, "buildDatabaseSearchProbeSql").mockResolvedValue({ sql: "SELECT 1", includedIndices: [0] });+ const executeQuery = vi.fn().mockRejectedValue(new Error("table dropped"));+ await expect(+ probeTables({+ databaseType: "mysql",+ term: "alice",+ limit: 20,+ tables: [{ tableName: "a", columns: [col("x", "varchar")] }],+ executeQuery,+ executionId: "e",+ }),+ ).rejects.toThrow("table dropped");+ });+});diff --git a/apps/desktop/src/lib/database/databaseSearch.ts b/apps/desktop/src/lib/database/databaseSearch.tsindex ba3c23091e..a77df280a7 100644--- a/apps/desktop/src/lib/database/databaseSearch.ts+++ b/apps/desktop/src/lib/database/databaseSearch.ts@@ -30,17 +30,20 @@ const NUMBER_TYPES = ["int", "serial", "number", "numeric", "decimal", "float",const SKIPPED_TYPES = ["blob", "binary", "bytea", "image", "geometry", "geography"];-function normalizedType(column: ColumnInfo): string {+/** 文本/数值列判定只读 data_type,兼容批量取列的最小列结构。 */+type SearchableColumn = Pick<ColumnInfo, "data_type">;++function normalizedType(column: SearchableColumn): string {return column.data_type.toLowerCase();}-export function isTextSearchColumn(column: ColumnInfo): boolean {+export function isTextSearchColumn(column: SearchableColumn): boolean {const type = normalizedType(column);if (SKIPPED_TYPES.some((skipped) => type.includes(skipped))) return false;return TEXT_TYPES.some((textType) => type.includes(textType));}-export function isNumericSearchColumn(column: ColumnInfo): boolean {+export function isNumericSearchColumn(column: SearchableColumn): boolean {const type = normalizedType(column);if (SKIPPED_TYPES.some((skipped) => type.includes(skipped))) return false;return NUMBER_TYPES.some((numberType) => type.includes(numberType));@@ -50,7 +53,7 @@ function cleanTerm(term: string): string {return term.trim();}-function parseNumericTerm(term: string): string | null {+export function parseNumericTerm(term: string): string | null {const trimmed = cleanTerm(term);if (!/^[+-]?(?:\d+|\d+\.\d+|\.\d+)$/.test(trimmed)) return null;return trimmed;diff --git a/apps/desktop/src/lib/database/databaseSearchCapabilities.ts b/apps/desktop/src/lib/database/databaseSearchCapabilities.tsnew file mode 100644index 0000000000..f552b89356--- /dev/null+++ b/apps/desktop/src/lib/database/databaseSearchCapabilities.ts@@ -0,0 +1,14 @@+import type { DatabaseType } from "@/types/database";++/**+ * 「在数据库中查找」批量路径(批量取列 + 多表探测)支持的方言,+ * 镜像 Rust `database_search_columns_sql` / `database_search_probe_sql`+ * 的家族判定;两处集合必须同步修改(有单测锁形状)。+ */+const BULK_DATABASE_SEARCH_TYPES = new Set<DatabaseType>(["oracle", "oceanbase-oracle", "dameng", "mysql", "doris", "starrocks", "manticoresearch", "goldendb", "postgres", "kingbase", "highgo", "uxdb", "vastbase", "opengauss", "gaussdb", "kwdb", "yashandb", "oscar", "redshift", "sqlserver"]);++export function supportsBulkDatabaseSearch(dbType?: DatabaseType): boolean {+ return !!dbType && BULK_DATABASE_SEARCH_TYPES.has(dbType);+}++export { BULK_DATABASE_SEARCH_TYPES };diff --git a/apps/desktop/src/lib/database/databaseSearchColumns.ts b/apps/desktop/src/lib/database/databaseSearchColumns.tsnew file mode 100644index 0000000000..09744d5edc--- /dev/null+++ b/apps/desktop/src/lib/database/databaseSearchColumns.ts@@ -0,0 +1,97 @@+import type { DatabaseType } from "@/types/database.ts";+import * as api from "@/lib/backend/api.ts";+import { supportsBulkDatabaseSearch } from "@/lib/database/databaseSearchCapabilities.ts";++/** 批量取列的最小列形状:数据搜索路径只消费 name / data_type / is_primary_key。 */+export interface DatabaseSearchColumnLite {+ name: string;+ data_type: string;+ is_primary_key: boolean;+}++export interface DatabaseSearchColumnsSqlOptions {+ databaseType?: DatabaseType;+ database: string;+ schema?: string;+}++/** (schema, 表名) → 列列表。键统一小写兜底:listTables 与目录行大小写偶有差异。 */+export type SearchColumnsByTable = Map<string, DatabaseSearchColumnLite[]>;++export function searchColumnsTableKey(schema: string | undefined, database: string, tableName: string): string {+ const owner = (schema && schema.trim()) || database;+ return `${owner.toLowerCase()}\n${tableName.toLowerCase()}`;+}++export function findSearchColumns(map: SearchColumnsByTable, schema: string | undefined, database: string, tableName: string): DatabaseSearchColumnLite[] | undefined {+ return map.get(searchColumnsTableKey(schema, database, tableName));+}++function isTruthyPrimaryKey(value: unknown): boolean {+ if (value === true) return true;+ if (typeof value === "number") return value !== 0;+ if (typeof value === "string") return value.trim().toLowerCase() === "1" || value.trim().toLowerCase() === "true";+ return false;+}++/**+ * 一次目录查询取回整个 schema 的列信息并按表分组。+ * 任何失败(方言不支持、目录视图不可见、执行出错)都返回空 Map,+ * 调用方对缺列的表逐表回退 getColumns——绝不抛错中断搜索。+ */+export async function fetchDatabaseSearchColumns(options: {+ databaseType?: DatabaseType;+ database: string;+ schema?: string;+ buildSql?: typeof api.buildDatabaseSearchColumnsSql;+ executeQuery: (sql: string, executionId: string) => Promise<{ columns: string[]; rows: unknown[][]; truncated?: boolean }>;+ executionId: string;+}): Promise<SearchColumnsByTable> {+ const map: SearchColumnsByTable = new Map();+ if (!supportsBulkDatabaseSearch(options.databaseType)) return map;++ try {+ const buildSql = options.buildSql ?? api.buildDatabaseSearchColumnsSql;+ const built = await buildSql({+ databaseType: options.databaseType,+ database: options.database,+ schema: options.schema,+ });+ if (!built?.sql) return map;++ const result = await options.executeQuery(built.sql, options.executionId);+ // The catalog query rides the backend's default row cap (10k). A truncation+ // can land mid-table, and a table seen with only part of its columns would+ // make the probe miss keywords in the dropped columns — silently skipping+ // that table. Drop the whole catalog instead: an empty map sends every+ // table down the per-table getColumns fallback, which is always complete.+ if (result.truncated) return map;+ const headerIndex = new Map<string, number>();+ result.columns.forEach((name, index) => headerIndex.set(name.toLowerCase(), index));+ const tableIndex = headerIndex.get("table_name");+ const columnIndex = headerIndex.get("column_name");+ const typeIndex = headerIndex.get("data_type");+ const primaryKeyIndex = headerIndex.get("is_primary_key");+ if (tableIndex === undefined || columnIndex === undefined || typeIndex === undefined) return map;++ for (const row of result.rows) {+ const tableName = String(row[tableIndex] ?? "").trim();+ const columnName = String(row[columnIndex] ?? "").trim();+ if (!tableName || !columnName) continue;+ const key = searchColumnsTableKey(options.schema, options.database, tableName);+ let columns = map.get(key);+ if (!columns) {+ columns = [];+ map.set(key, columns);+ }+ columns.push({+ name: columnName,+ data_type: String(row[typeIndex] ?? ""),+ is_primary_key: primaryKeyIndex !== undefined && isTruthyPrimaryKey(row[primaryKeyIndex]),+ });+ }+ } catch {+ // 目录查询失败——返回已收集部分,未命中的表由调用方逐表回退+ }+ return map;+}diff --git a/apps/desktop/src/lib/database/databaseSearchProbe.ts b/apps/desktop/src/lib/database/databaseSearchProbe.tsnew file mode 100644index 0000000000..8608be7e0c--- /dev/null+++ b/apps/desktop/src/lib/database/databaseSearchProbe.ts@@ -0,0 +1,95 @@+import type { DatabaseType } from "@/types/database.ts";+import * as api from "@/lib/backend/api.ts";+import { isNumericSearchColumn, isTextSearchColumn, parseNumericTerm } from "@/lib/database/databaseSearch.ts";+import type { DatabaseSearchColumnLite } from "@/lib/database/databaseSearchColumns.ts";++/** 单条探测语句最多合并的表数与条件数(双上限任一触顶切批,防巨型语句拖垮解析器)。 */+export const DATABASE_SEARCH_PROBE_TABLE_BATCH_SIZE = 20;+export const DATABASE_SEARCH_PROBE_CONDITION_LIMIT = 500;++export interface DatabaseSearchProbeSqlOptions {+ databaseType?: DatabaseType;+ driverProfile?: string;+ tables: Array<{+ schema?: string;+ tableName: string;+ columns: DatabaseSearchColumnLite[];+ }>;+ term: string;+ limit?: number;+}++export function countProbeConditions(columns: DatabaseSearchColumnLite[], term: string): number {+ const textCount = columns.filter(isTextSearchColumn).length;+ const numericCount = parseNumericTerm(term) ? columns.filter(isNumericSearchColumn).length : 0;+ return textCount + numericCount;+}++/**+ * 计算下一个探测批的结束下标(不含):从 nextIndex 起,受表数/条件数双上限约束;+ * 至少包含一张表,避免零条件批死循环(无列信息的表按 0 条件计,走批内逐表回退)。+ * tasks 直接传每张表的预取列数组(undefined = 无目录信息)。+ */+export function nextProbeChunkEnd(nextIndex: number, endIndex: number, tasks: Array<DatabaseSearchColumnLite[] | undefined>, term: string, options?: { tableBatchSize?: number; conditionLimit?: number }): number {+ const tableBatchSize = options?.tableBatchSize ?? DATABASE_SEARCH_PROBE_TABLE_BATCH_SIZE;+ const conditionLimit = options?.conditionLimit ?? DATABASE_SEARCH_PROBE_CONDITION_LIMIT;+ let end = Math.min(nextIndex, endIndex);+ let conditions = 0;+ let tables = 0;+ while (end < endIndex && tables < tableBatchSize) {+ const taskConditions = tasks[end] ? countProbeConditions(tasks[end]!, term) : 0;+ if (tables > 0 && conditions + taskConditions > conditionLimit) break;+ conditions += taskConditions;+ tables += 1;+ end += 1;+ }+ return Math.max(end, nextIndex + 1 <= endIndex ? nextIndex + 1 : nextIndex);+}++/**+ * 执行一条多表探测语句,返回命中的表下标集合(相对传入 tables)。+ * 语句失败向上抛出,由调用方将该批回退逐表路径。+ */+export async function probeTables(options: {+ databaseType?: DatabaseType;+ driverProfile?: string;+ term: string;+ limit: number;+ tables: DatabaseSearchProbeSqlOptions["tables"];+ buildSql?: typeof api.buildDatabaseSearchProbeSql;+ executeQuery: (sql: string, executionId: string) => Promise<{ columns: string[]; rows: unknown[][] }>;+ executionId: string;+}): Promise<Set<number>> {+ const buildSql = options.buildSql ?? api.buildDatabaseSearchProbeSql;+ const probe = await buildSql({+ databaseType: options.databaseType,+ driverProfile: options.driverProfile,+ tables: options.tables,+ term: options.term,+ limit: options.limit,+ });+ if (!probe?.sql) return new Set();++ const result = await options.executeQuery(probe.sql, options.executionId);+ const headerIndex = new Map<string, number>();+ result.columns.forEach((name, index) => headerIndex.set(name.toLowerCase(), index));+ const labelIndex = headerIndex.get("table_label");+ const hitsIndex = headerIndex.get("hits");+ if (labelIndex === undefined) return new Set();++ // includedIndices[k] 是第 k 个分支(t{k})对应的输入表下标+ const labelToIndex = new Map<string, number>();+ probe.includedIndices.forEach((tableIndex, branch) => {+ labelToIndex.set(`t${branch}`, tableIndex);+ });++ const hits = new Set<number>();+ for (const row of result.rows) {+ const label = String(row[labelIndex] ?? "").trim();+ const tableIndex = labelToIndex.get(label);+ if (tableIndex === undefined) continue;+ const hitCount = hitsIndex === undefined ? 1 : Number(row[hitsIndex] ?? 0);+ if (Number.isFinite(hitCount) && hitCount > 0) hits.add(tableIndex);+ }+ return hits;+}diff --git a/crates/dbx-core/src/lib.rs b/crates/dbx-core/src/lib.rsindex 718c2c9b15..b31aaba264 100644--- a/crates/dbx-core/src/lib.rs+++ b/crates/dbx-core/src/lib.rs@@ -44,6 +44,8 @@ pub use data::database_export;pub use dbx_drivers::database_capabilities;pub use dbx_sql::data_grid_extractors;pub use dbx_sql::data_grid_sql;+pub use dbx_sql::database_search_columns_sql;+pub use dbx_sql::database_search_probe_sql;pub use dbx_sql::database_search_sql;pub use dbx_sql::database_structure_search_sql;pub use dbx_types::database_manifest;diff --git a/crates/dbx-sql-data/src/database_search_columns_sql.rs b/crates/dbx-sql-data/src/database_search_columns_sql.rsnew file mode 100644index 0000000000..782f84670a--- /dev/null+++ b/crates/dbx-sql-data/src/database_search_columns_sql.rs@@ -0,0 +1,248 @@+use serde::{Deserialize, Serialize};++use crate::models::connection::DatabaseType;++/// 「在数据库中查找」的批量列信息查询:每个 schema 一条目录 SQL,+/// 一次取回该 schema 全部普通表的列名/类型/主键标记,替代逐表 getColumns 往返。+/// 行形状统一为 table_name / column_name / data_type / is_primary_key,+/// 主键来源以 LEFT JOIN 挂接——权限不足时主键标记缺失但列信息仍可用。+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct DatabaseSearchColumnsSqlOptions {+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub database_type: Option<DatabaseType>,+ pub database: String,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub schema: Option<String>,+}++#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct DatabaseSearchColumnsSql {+ pub sql: String,+}++pub fn build_database_search_columns_sql(options: DatabaseSearchColumnsSqlOptions) -> Option<DatabaseSearchColumnsSql> {+ let database_type = options.database_type?;+ let sql = match database_type {+ DatabaseType::Oracle | DatabaseType::OceanbaseOracle | DatabaseType::Dameng => {+ oracle_family_columns_sql(options.schema.as_deref(), &options.database)+ }+ DatabaseType::Mysql+ | DatabaseType::Doris+ | DatabaseType::StarRocks+ | DatabaseType::ManticoreSearch+ | DatabaseType::Goldendb => mysql_family_columns_sql(options.schema.as_deref(), &options.database),+ DatabaseType::Postgres+ | DatabaseType::Kingbase+ | DatabaseType::Highgo+ | DatabaseType::Uxdb+ | DatabaseType::Gbase8c+ | DatabaseType::Vastbase+ | DatabaseType::OpenGauss+ | DatabaseType::Gaussdb+ | DatabaseType::Kwdb+ | DatabaseType::Yashandb+ | DatabaseType::Oscar+ | DatabaseType::Redshift => postgres_family_columns_sql(options.schema.as_deref()),+ DatabaseType::SqlServer => sqlserver_columns_sql(options.schema.as_deref()),+ // 其余方言(含 SQLite 本地家族)不支持批量取列,调用方逐表回退 getColumns。+ _ => return None,+ };+ Some(DatabaseSearchColumnsSql { sql })+}++fn schema_or_database<'a>(schema: Option<&'a str>, database: &'a str) -> &'a str {+ schema.filter(|value| !value.trim().is_empty()).unwrap_or(database)+}++// Oracle 家族用带引号的小写别名,否则无引号别名会被统一大写。+fn oracle_family_columns_sql(schema: Option<&str>, database: &str) -> String {+ let owner = sql_string_literal(schema_or_database(schema, database));+ format!(+ "SELECT c.TABLE_NAME AS \"table_name\", c.COLUMN_NAME AS \"column_name\", c.DATA_TYPE AS \"data_type\" \+ , CASE WHEN pc.COLUMN_NAME IS NULL THEN 0 ELSE 1 END AS \"is_primary_key\" \+ FROM ALL_TAB_COLUMNS c \+ LEFT JOIN ( \+ SELECT cc.OWNER, cc.TABLE_NAME, cc.COLUMN_NAME \+ FROM ALL_CONSTRAINTS cn \+ JOIN ALL_CONS_COLUMNS cc ON cc.OWNER = cn.OWNER AND cc.TABLE_NAME = cn.TABLE_NAME AND cc.CONSTRAINT_NAME = cn.CONSTRAINT_NAME \+ WHERE cn.CONSTRAINT_TYPE = 'P' ) pc \+ ON pc.OWNER = c.OWNER AND pc.TABLE_NAME = c.TABLE_NAME AND pc.COLUMN_NAME = c.COLUMN_NAME \+ WHERE c.OWNER = {owner} \+ ORDER BY c.TABLE_NAME, c.COLUMN_ID"+ )+}++fn mysql_family_columns_sql(schema: Option<&str>, database: &str) -> String {+ let table_schema = sql_string_literal(schema_or_database(schema, database));+ format!(+ "SELECT c.TABLE_NAME AS table_name, c.COLUMN_NAME AS column_name, c.DATA_TYPE AS data_type \+ , CASE WHEN k.COLUMN_NAME IS NULL THEN 0 ELSE 1 END AS is_primary_key \+ FROM information_schema.COLUMNS c \+ LEFT JOIN information_schema.KEY_COLUMN_USAGE k \+ ON k.TABLE_SCHEMA = c.TABLE_SCHEMA AND k.TABLE_NAME = c.TABLE_NAME AND k.COLUMN_NAME = c.COLUMN_NAME \+ AND k.CONSTRAINT_NAME = 'PRIMARY' \+ WHERE c.TABLE_SCHEMA = {table_schema} \+ ORDER BY c.TABLE_NAME, c.ORDINAL_POSITION"+ )+}++// PG 家族走 pg_catalog(与结构搜索同路线):对 PG 系分支(Kingbase/OpenGauss 等)兼容性+// 优于 information_schema;data_type 取 t.typname 裸类型名,与逐表 getColumns 返回的类型+// 字符串在文本/数值列子串匹配上等价(varchar/character varying 均命中 "char")。+fn postgres_family_columns_sql(schema: Option<&str>) -> String {+ let schema_filter = match schema.filter(|value| !value.trim().is_empty()) {+ Some(schema) => format!("n.nspname = {}", sql_string_literal(schema)),+ None => "n.nspname NOT IN ('pg_catalog', 'information_schema')".to_string(),+ };+ format!(+ "SELECT c.relname AS table_name, a.attname AS column_name, t.typname AS data_type \+ , (pk.attnum IS NOT NULL) AS is_primary_key \+ FROM pg_catalog.pg_attribute a \+ JOIN pg_catalog.pg_class c ON c.oid = a.attrelid \+ JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace \+ JOIN pg_catalog.pg_type t ON t.oid = a.atttypid \+ LEFT JOIN ( \+ SELECT i.indrelid AS relid, a2.attnum AS attnum \+ FROM pg_catalog.pg_index i \+ JOIN pg_catalog.pg_attribute a2 ON a2.attrelid = i.indrelid AND a2.attnum = ANY(i.indkey) \+ WHERE i.indisprimary ) pk ON pk.relid = c.oid AND pk.attnum = a.attnum \+ WHERE a.attnum > 0 AND NOT a.attisdropped AND c.relkind IN ('r', 'p') \+ AND {schema_filter} \+ ORDER BY c.relname, a.attnum"+ )+}++fn sqlserver_columns_sql(schema: Option<&str>) -> String {+ let schema_filter = match schema.filter(|value| !value.trim().is_empty()) {+ Some(schema) => format!("c.TABLE_SCHEMA = {}", sql_string_literal(schema)),+ None => "c.TABLE_SCHEMA NOT IN ('sys', 'INFORMATION_SCHEMA')".to_string(),+ };+ format!(+ "SELECT c.TABLE_NAME AS table_name, c.COLUMN_NAME AS column_name, c.DATA_TYPE AS data_type \+ , CASE WHEN pk.COLUMN_NAME IS NULL THEN 0 ELSE 1 END AS is_primary_key \+ FROM INFORMATION_SCHEMA.COLUMNS c \+ LEFT JOIN ( \+ SELECT kcu.TABLE_SCHEMA, kcu.TABLE_NAME, kcu.COLUMN_NAME \+ FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc \+ JOIN INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu \+ ON kcu.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA AND kcu.CONSTRAINT_NAME = tc.CONSTRAINT_NAME \+ AND kcu.TABLE_SCHEMA = tc.TABLE_SCHEMA \+ WHERE tc.CONSTRAINT_TYPE = 'PRIMARY KEY' ) pk \+ ON pk.TABLE_SCHEMA = c.TABLE_SCHEMA AND pk.TABLE_NAME = c.TABLE_NAME AND pk.COLUMN_NAME = c.COLUMN_NAME \+ WHERE {schema_filter} \+ ORDER BY c.TABLE_NAME, c.ORDINAL_POSITION"+ )+}++fn sql_string_literal(value: &str) -> String {+ format!("'{}'", value.replace('\'', "''"))+}++#[cfg(test)]+mod tests {+ use super::*;++ #[test]+ fn oracle_family_uses_all_tab_columns_with_pk_join() {+ let query = build_database_search_columns_sql(DatabaseSearchColumnsSqlOptions {+ database_type: Some(DatabaseType::Dameng),+ database: "dlweb".to_string(),+ schema: Some("DLWEB".to_string()),+ })+ .unwrap();++ assert!(query.sql.contains("FROM ALL_TAB_COLUMNS c"));+ assert!(query.sql.contains("ALL_CONSTRAINTS cn"));+ assert!(query.sql.contains("cn.CONSTRAINT_TYPE = 'P'"));+ assert!(query.sql.contains("LEFT JOIN"));+ assert!(query.sql.contains("WHERE c.OWNER = 'DLWEB'"));+ // 带引号的小写别名保证 Oracle 驱动返回小写列头+ assert!(query.sql.contains("AS \"table_name\""));+ assert!(query.sql.contains("AS \"is_primary_key\""));+ assert!(query.sql.contains("ORDER BY c.TABLE_NAME, c.COLUMN_ID"));+ }++ #[test]+ fn oracle_family_falls_back_to_database_when_schema_missing() {+ let query = build_database_search_columns_sql(DatabaseSearchColumnsSqlOptions {+ database_type: Some(DatabaseType::Oracle),+ database: "APP".to_string(),+ schema: None,+ })+ .unwrap();+ assert!(query.sql.contains("WHERE c.OWNER = 'APP'"));+ }++ #[test]+ fn mysql_family_uses_information_schema_with_primary_key_usage() {+ let query = build_database_search_columns_sql(DatabaseSearchColumnsSqlOptions {+ database_type: Some(DatabaseType::Mysql),+ database: "shop".to_string(),+ schema: None,+ })+ .unwrap();++ assert!(query.sql.contains("FROM information_schema.COLUMNS c"));+ assert!(query.sql.contains("information_schema.KEY_COLUMN_USAGE k"));+ assert!(query.sql.contains("k.CONSTRAINT_NAME = 'PRIMARY'"));+ assert!(query.sql.contains("WHERE c.TABLE_SCHEMA = 'shop'"));+ // 复合主键:join 按列名对齐,多行主键列各自命中+ assert!(query.sql.contains("k.COLUMN_NAME = c.COLUMN_NAME"));+ assert!(query.sql.contains("ORDER BY c.TABLE_NAME, c.ORDINAL_POSITION"));+ }++ #[test]+ fn postgres_family_uses_pg_catalog_and_excludes_system_schemas_by_default() {+ let with_schema = build_database_search_columns_sql(DatabaseSearchColumnsSqlOptions {+ database_type: Some(DatabaseType::Postgres),+ database: "app".to_string(),+ schema: Some("public".to_string()),+ })+ .unwrap();+ assert!(with_schema.sql.contains("pg_catalog.pg_attribute a"));+ assert!(with_schema.sql.contains("i.indisprimary"));+ assert!(with_schema.sql.contains("n.nspname = 'public'"));+ assert!(with_schema.sql.contains("c.relkind IN ('r', 'p')"));++ let without_schema = build_database_search_columns_sql(DatabaseSearchColumnsSqlOptions {+ database_type: Some(DatabaseType::Postgres),+ database: "app".to_string(),+ schema: None,+ })+ .unwrap();+ assert!(without_schema.sql.contains("n.nspname NOT IN ('pg_catalog', 'information_schema')"));+ }++ #[test]+ fn sqlserver_excludes_system_schemas_when_schema_missing() {+ let query = build_database_search_columns_sql(DatabaseSearchColumnsSqlOptions {+ database_type: Some(DatabaseType::SqlServer),+ database: "master".to_string(),+ schema: None,+ })+ .unwrap();+ assert!(query.sql.contains("INFORMATION_SCHEMA.COLUMNS c"));+ assert!(query.sql.contains("tc.CONSTRAINT_TYPE = 'PRIMARY KEY'"));+ assert!(query.sql.contains("c.TABLE_SCHEMA NOT IN ('sys', 'INFORMATION_SCHEMA')"));++ let with_schema = build_database_search_columns_sql(DatabaseSearchColumnsSqlOptions {+ database_type: Some(DatabaseType::SqlServer),+ database: "master".to_string(),+ schema: Some("dbo".to_string()),+ })+ .unwrap();+ assert!(with_schema.sql.contains("c.TABLE_SCHEMA = 'dbo'"));+ }++ #[test]+ fn unsupported_dialects_return_none() {+ let options = DatabaseSearchColumnsSqlOptions {+ database_type: Some(DatabaseType::Sqlite),+ database: "local".to_string(),+ schema: None,+ };+ assert_eq!(build_database_search_columns_sql(options), None);+ }+}diff --git a/crates/dbx-sql-data/src/database_search_probe_sql.rs b/crates/dbx-sql-data/src/database_search_probe_sql.rsnew file mode 100644index 0000000000..7276672a9b--- /dev/null+++ b/crates/dbx-sql-data/src/database_search_probe_sql.rs@@ -0,0 +1,267 @@+use serde::{Deserialize, Serialize};++use crate::models::connection::DatabaseType;+use crate::sql_dialect::{+ firebird_rows_clause, pagination_strategy, qualified_table_name, PaginationContext, TablePaginationStrategy,+};++use crate::database_search_sql::{build_table_search_conditions, clamp_limit, DatabaseSearchColumn};++/// 多表探测查询:把一批表的搜索条件合并为一条 UNION ALL 语句,+/// 每个分支返回 (序号标签, 命中数)——分支内套与单表查询一致的 WHERE 条件和+/// 该方言的行数限额,COUNT 结果即"该表最多有 limit 条命中"。+/// 标签用分支序号 t0..tN 而非表名字面量,彻底绕开标识符转义;+/// included_indices[k] 是第 k 个分支对应的输入表下标。+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct DatabaseSearchProbeTable {+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub schema: Option<String>,+ pub table_name: String,+ #[serde(default)]+ pub columns: Vec<DatabaseSearchColumn>,+}++#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct DatabaseSearchProbeSqlOptions {+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub database_type: Option<DatabaseType>,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub driver_profile: Option<String>,+ #[serde(default)]+ pub tables: Vec<DatabaseSearchProbeTable>,+ pub term: String,+ #[serde(default, skip_serializing_if = "Option::is_none")]+ pub limit: Option<usize>,+}++#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct DatabaseSearchProbeSql {+ pub sql: String,+ pub included_indices: Vec<usize>,+}++pub fn build_database_search_probe_sql(options: DatabaseSearchProbeSqlOptions) -> Option<DatabaseSearchProbeSql> {+ let database_type = options.database_type;+ let driver_profile = options.driver_profile.as_deref();+ let limit = clamp_limit(options.limit);++ let mut branches = Vec::new();+ let mut included_indices = Vec::new();+ for (index, table) in options.tables.iter().enumerate() {+ // 无可搜列的表剔除出探测批,不中断其余表(进度由调用方按已处理推进)。+ let Some(conditions) =+ build_table_search_conditions(database_type, driver_profile, &table.columns, &options.term)+ else {+ continue;+ };+ let qualified = qualified_table_name(database_type, table.schema.as_deref(), &table.table_name);+ let label = format!("t{}", branches.len());+ branches.push(probe_branch_sql(database_type, &qualified, &conditions.where_clause, &label, limit));+ included_indices.push(index);+ }++ if branches.is_empty() {+ return None;+ }+ Some(DatabaseSearchProbeSql { sql: branches.join("\nUNION ALL\n"), included_indices })+}++fn probe_branch_sql(+ database_type: Option<DatabaseType>,+ qualified_table: &str,+ where_clause: &str,+ label: &str,+ limit: usize,+) -> String {+ let limited_inner = match pagination_strategy(database_type, PaginationContext::BoundedRead) {+ TablePaginationStrategy::SqlServerTop | TablePaginationStrategy::IrisTop => {+ format!("SELECT TOP {limit} 1 FROM {qualified_table} WHERE ({where_clause})")+ }+ TablePaginationStrategy::InformixFirst => {+ format!("SELECT FIRST {limit} 1 FROM {qualified_table} WHERE ({where_clause})")+ }+ TablePaginationStrategy::FirebirdRows => {+ format!("SELECT 1 FROM {qualified_table} WHERE ({where_clause}) {}", firebird_rows_clause(limit, 0))+ }+ TablePaginationStrategy::Db2FetchFirst | TablePaginationStrategy::FetchFirst => {+ format!("SELECT 1 FROM {qualified_table} WHERE ({where_clause}) FETCH FIRST {limit} ROWS ONLY")+ }+ TablePaginationStrategy::Rownum => {+ format!("SELECT 1 FROM {qualified_table} WHERE ({where_clause}) AND ROWNUM <= {limit}")+ }+ // 这些策略没有服务端限额可用,COUNT 会数完所有命中行——正确性不变,代价交给调用方批次控制。+ TablePaginationStrategy::AgentMaxRows+ | TablePaginationStrategy::QuestDbLimit+ | TablePaginationStrategy::LimitOffset+ | TablePaginationStrategy::Unbounded => {+ format!("SELECT 1 FROM {qualified_table} WHERE ({where_clause}) LIMIT {limit}")+ }+ };+ format!("SELECT '{label}' AS table_label, COUNT(*) AS hits FROM ({limited_inner}) probe_branch")+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::database_search_sql::build_database_search_sql;++ fn col(name: &str, data_type: &str, is_primary_key: bool) -> DatabaseSearchColumn {+ DatabaseSearchColumn { name: name.to_string(), data_type: data_type.to_string(), is_primary_key }+ }++ fn probe_table(schema: Option<&str>, table: &str, columns: Vec<DatabaseSearchColumn>) -> DatabaseSearchProbeTable {+ DatabaseSearchProbeTable { schema: schema.map(str::to_string), table_name: table.to_string(), columns }+ }++ fn probe_options(+ database_type: DatabaseType,+ tables: Vec<DatabaseSearchProbeTable>,+ ) -> DatabaseSearchProbeSqlOptions {+ DatabaseSearchProbeSqlOptions {+ database_type: Some(database_type),+ driver_profile: None,+ tables,+ term: "alice".to_string(),+ limit: Some(20),+ }+ }++ #[test]+ fn oracle_family_branch_uses_rownum_limited_subquery() {+ let probe = build_database_search_probe_sql(probe_options(+ DatabaseType::Dameng,+ vec![probe_table(Some("DLWEB"), "USERS", vec![col("NAME", "varchar2", false), col("PIC", "blob", false)])],+ ))+ .unwrap();++ assert_eq!(probe.included_indices, vec![0]);+ assert_eq!(+ probe.sql,+ "SELECT 't0' AS table_label, COUNT(*) AS hits FROM \+ (SELECT 1 FROM \"DLWEB\".\"USERS\" WHERE (LOWER(CAST(\"NAME\" AS TEXT)) LIKE '%alice%' ESCAPE '~') AND ROWNUM <= 20) probe_branch"+ );+ }++ #[test]+ fn mysql_family_branch_uses_limit_subquery() {+ let probe = build_database_search_probe_sql(probe_options(+ DatabaseType::Mysql,+ vec![+ probe_table(None, "users", vec![col("email", "varchar", false)]),+ probe_table(None, "orders", vec![col("note", "text", false)]),+ ],+ ))+ .unwrap();++ assert_eq!(probe.included_indices, vec![0, 1]);+ assert!(probe.sql.contains("FROM `users` WHERE"));+ assert!(probe.sql.contains("LIMIT 20"));+ assert_eq!(probe.sql.matches("UNION ALL").count(), 1);+ assert!(probe.sql.contains("'t0' AS table_label"));+ assert!(probe.sql.contains("'t1' AS table_label"));+ }++ #[test]+ fn sqlserver_branch_uses_top_subquery() {+ let probe = build_database_search_probe_sql(probe_options(+ DatabaseType::SqlServer,+ vec![probe_table(Some("dbo"), "users", vec![col("name", "nvarchar", false)])],+ ))+ .unwrap();+ assert!(probe.sql.contains("SELECT TOP 20 1 FROM [dbo].[users]"));+ }++ #[test]+ fn postgres_branch_uses_limit_subquery() {+ let probe = build_database_search_probe_sql(probe_options(+ DatabaseType::Postgres,+ vec![probe_table(Some("public"), "orders", vec![col("note", "text", false)])],+ ))+ .unwrap();+ assert!(probe.sql.contains("FROM \"public\".\"orders\""));+ assert!(probe.sql.contains("LIMIT 20) probe_branch"));+ }++ #[test]+ fn tables_without_searchable_columns_are_excluded_and_indices_preserved() {+ let probe = build_database_search_probe_sql(probe_options(+ DatabaseType::Mysql,+ vec![+ probe_table(None, "files", vec![col("payload", "blob", false)]),+ probe_table(None, "users", vec![col("email", "varchar", false)]),+ probe_table(None, "empty", vec![]),+ ],+ ))+ .unwrap();++ // 无可搜列表被剔除,included_indices 指向原输入下标+ assert_eq!(probe.included_indices, vec![1]);+ assert!(probe.sql.contains("'t0' AS table_label"));+ assert!(probe.sql.contains("FROM `users`"));+ assert!(!probe.sql.contains("`files`"));+ assert!(!probe.sql.contains("`empty`"));+ }++ #[test]+ fn empty_or_all_excluded_input_returns_none() {+ assert_eq!(+ build_database_search_probe_sql(DatabaseSearchProbeSqlOptions {+ database_type: Some(DatabaseType::Mysql),+ driver_profile: None,+ tables: vec![],+ term: "alice".to_string(),+ limit: Some(20),+ }),+ None+ );+ assert_eq!(+ build_database_search_probe_sql(probe_options(+ DatabaseType::Mysql,+ vec![probe_table(None, "files", vec![col("payload", "blob", false)])],+ )),+ None+ );+ }++ #[test]+ fn probe_branch_conditions_match_single_table_query_exactly() {+ let columns = vec![col("email", "varchar", false), col("id", "bigint", true)];++ let single = build_database_search_sql(crate::database_search_sql::DatabaseSearchSqlOptions {+ database_type: Some(DatabaseType::Dameng),+ driver_profile: None,+ schema: Some("DLWEB".to_string()),+ table_name: "USERS".to_string(),+ columns: columns.clone(),+ term: "alice".to_string(),+ limit: Some(20),+ })+ .unwrap();+ let probe = build_database_search_probe_sql(probe_options(+ DatabaseType::Dameng,+ vec![probe_table(Some("DLWEB"), "USERS", columns)],+ ))+ .unwrap();++ // 探测分支内的 WHERE 条件与单表查询完全一致(含数值词场景由共享拼装函数保证)+ let single_conds = single.sql.split(" WHERE (").nth(1).unwrap().split(")) WHERE ROWNUM").next().unwrap();+ assert!(probe.sql.contains(&format!("WHERE ({single_conds}) AND ROWNUM <= 20) probe_branch")));+ }++ #[test]+ fn numeric_term_adds_equality_predicates_in_probe_branches() {+ let probe = build_database_search_probe_sql(DatabaseSearchProbeSqlOptions {+ database_type: Some(DatabaseType::Mysql),+ driver_profile: None,+ tables: vec![probe_table(None, "orders", vec![col("id", "bigint", true), col("note", "text", false)])],+ term: "42".to_string(),+ limit: Some(20),+ })+ .unwrap();+ assert!(probe.sql.contains("`note`"));+ assert!(probe.sql.contains("`id` = 42"));+ }+}diff --git a/crates/dbx-sql-data/src/database_search_sql.rs b/crates/dbx-sql-data/src/database_search_sql.rsindex a2a4d2aaad..bb85cd295b 100644--- a/crates/dbx-sql-data/src/database_search_sql.rs+++ b/crates/dbx-sql-data/src/database_search_sql.rs@@ -75,42 +75,68 @@ pub fn is_numeric_search_column(column: &DatabaseSearchColumn) -> bool {NUMBER_TYPES.iter().any(|number_type| data_type.contains(number_type))}-pub fn build_database_search_sql(options: DatabaseSearchSqlOptions) -> Option<DatabaseSearchSql> {- let term = clean_term(&options.term);+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct TableSearchConditions {+ pub where_clause: String,+ pub searchable_columns: Vec<String>,+}++/// 单表搜索条件拼装:数据搜索单表查询与多表探测分支共用,+/// 保证两条路径对同一表同一关键词产出完全一致的 WHERE 条件。+pub fn build_table_search_conditions(+ database_type: Option<DatabaseType>,+ driver_profile: Option<&str>,+ columns: &[DatabaseSearchColumn],+ term: &str,+) -> Option<TableSearchConditions> {+ let term = clean_term(term);if term.is_empty() {return None;}- let text_columns: Vec<_> = options.columns.iter().filter(|column| is_text_search_column(column)).collect();+ let text_columns: Vec<_> = columns.iter().filter(|column| is_text_search_column(column)).collect();let numeric_term = parse_numeric_term(&term);let numeric_columns: Vec<_> = if numeric_term.is_some() {- options.columns.iter().filter(|column| is_numeric_search_column(column)).collect()+ columns.iter().filter(|column| is_numeric_search_column(column)).collect()} else {Vec::new()};let mut conditions = Vec::new();for column in &text_columns {- let identifier = quote_table_identifier(options.database_type, &column.name);- conditions.push(format!(- "{} LIKE {} ESCAPE '~'",- text_cast_expression(options.database_type, options.driver_profile.as_deref(), &identifier),- sql_string_literal(&like_pattern(&term))- ));+ let identifier = quote_table_identifier(database_type, &column.name);+ conditions.push(text_search_condition(database_type, driver_profile, column, &identifier, &term));}for column in &numeric_columns {- let identifier = quote_table_identifier(options.database_type, &column.name);+ let identifier = quote_table_identifier(database_type, &column.name);conditions.push(format!("{identifier} = {}", numeric_term.as_deref().unwrap_or_default()));}if conditions.is_empty() {return None;}+ Some(TableSearchConditions {+ where_clause: conditions.join(" OR "),+ searchable_columns: text_columns+ .iter()+ .chain(numeric_columns.iter())+ .map(|column| column.name.clone())+ .collect(),+ })+}++pub fn build_database_search_sql(options: DatabaseSearchSqlOptions) -> Option<DatabaseSearchSql> {+ let conditions = build_table_search_conditions(+ options.database_type,+ options.driver_profile.as_deref(),+ &options.columns,+ &options.term,+ )?;let table = qualified_table_name(options.database_type, options.schema.as_deref(), &options.table_name);- let where_clause = conditions.join(" OR ");+ let where_clause = conditions.where_clause;let limit = clamp_limit(options.limit);- let searchable_columns =- text_columns.iter().chain(numeric_columns.iter()).map(|column| column.name.clone()).collect();+ let searchable_columns = conditions.searchable_columns;let sql = match pagination_strategy(options.database_type, PaginationContext::BoundedRead) {TablePaginationStrategy::SqlServerTop => format!("SELECT TOP {limit} * FROM {table} WHERE ({where_clause})"),@@ -179,7 +205,7 @@ fn clean_term(term: &str) -> String {term.trim().to_string()}-fn clamp_limit(limit: Option<usize>) -> usize {+pub(crate) fn clamp_limit(limit: Option<usize>) -> usize {limit.unwrap_or(20).clamp(1, 100)}@@ -248,6 +274,35 @@ fn text_cast_expression(database_type: Option<DatabaseType>, driver_profile: Opt}}+/// Oracle 家族的 CLOB 列不能走 CAST AS VARCHAR2(4000):内容超 4000 字符时直接抛+/// ORA-22835(整表不可搜)。改用 DBMS_LOB.INSTR 全量搜索——不截断、不报错;+/// LOWER(CLOB) 返回 CLOB,INSTR 对 CLOB 直接可用。DM8/OB Oracle 模式均提供 DBMS_LOB。+/// INSTR 按字面子串匹配,与 LIKE '%term%' ESCAPE(通配符已被转义为字面量)语义一致。+fn is_oracle_family_clob(database_type: Option<DatabaseType>, data_type: &str) -> bool {+ matches!(database_type, Some(DatabaseType::Oracle | DatabaseType::OceanbaseOracle | DatabaseType::Dameng))+ && data_type.to_ascii_lowercase().contains("clob")+}++fn text_search_condition(+ database_type: Option<DatabaseType>,+ driver_profile: Option<&str>,+ column: &DatabaseSearchColumn,+ identifier: &str,+ term: &str,+) -> String {+ if is_oracle_family_clob(database_type, &column.data_type) {+ return format!(+ "DBMS_LOB.INSTR(LOWER({identifier}), {}) > 0",+ sql_string_literal(&clean_term(term).to_ascii_lowercase())+ );+ }+ format!(+ "{} LIKE {} ESCAPE '~'",+ text_cast_expression(database_type, driver_profile, identifier),+ sql_string_literal(&like_pattern(term))+ )+}+fn sql_value_literal(database_type: Option<DatabaseType>, column: &DatabaseSearchColumn, value: &Value) -> String {match value {Value::Null => "NULL".to_string(),@@ -281,6 +336,51 @@ mod tests {DatabaseSearchColumn { name: name.to_string(), data_type: data_type.to_string(), is_primary_key }}+ #[test]+ fn oracle_family_clob_columns_use_dbms_lob_instr() {+ let query = build_database_search_sql(DatabaseSearchSqlOptions {+ database_type: Some(DatabaseType::Oracle),+ driver_profile: None,+ schema: Some("ZOEDM".to_string()),+ table_name: "CLOSED_LOOP_VIEW_LOG".to_string(),+ columns: vec![col("ID", "number", true), col("TITLE", "varchar2", false), col("CONTENT", "clob", false)],+ term: "closed_loop".to_string(),+ limit: Some(20),+ })+ .unwrap();++ // CLOB 列走 DBMS_LOB.INSTR(全量、不抛 ORA-22835),varchar2 列保持 CAST+LIKE+ assert!(query.sql.contains("DBMS_LOB.INSTR(LOWER(\"CONTENT\"), 'closed_loop') > 0"));+ // LIKE 侧通配符照常转义(_ → ~_)+ assert!(query.sql.contains("LOWER(CAST(\"TITLE\" AS VARCHAR2(4000))) LIKE '%closed~_loop%' ESCAPE '~'"));++ // Dameng / OceanBase Oracle 同为 Oracle 家族+ let dameng = build_database_search_sql(DatabaseSearchSqlOptions {+ database_type: Some(DatabaseType::Dameng),+ driver_profile: None,+ schema: None,+ table_name: "t".to_string(),+ columns: vec![col("BODY", "clob", false)],+ term: "x".to_string(),+ limit: None,+ })+ .unwrap();+ assert!(dameng.sql.contains("DBMS_LOB.INSTR(LOWER(\"BODY\"), 'x') > 0"));++ // 其他方言的 clob/text 列不受影响,仍走 CAST+LIKE+ let mysql = build_database_search_sql(DatabaseSearchSqlOptions {+ database_type: Some(DatabaseType::Mysql),+ driver_profile: None,+ schema: None,+ table_name: "t".to_string(),+ columns: vec![col("body", "longtext", false)],+ term: "x".to_string(),+ limit: None,+ })+ .unwrap();+ assert!(mysql.sql.contains("LIKE '%x%'"));+ }+#[test]fn builds_table_search_query_over_text_columns() {let query = build_database_search_sql(DatabaseSearchSqlOptions {diff --git a/crates/dbx-sql-data/src/database_structure_search_sql.rs b/crates/dbx-sql-data/src/database_structure_search_sql.rsindex 41da857d6f..b2ba541829 100644--- a/crates/dbx-sql-data/src/database_structure_search_sql.rs+++ b/crates/dbx-sql-data/src/database_structure_search_sql.rs@@ -285,7 +285,7 @@ fn oracle_family_structure_search_sql(LEFT JOIN ALL_COL_COMMENTS m ON c.OWNER = m.OWNER AND c.TABLE_NAME = m.TABLE_NAME AND c.COLUMN_NAME = m.COLUMN_NAME \WHERE c.OWNER = {owner} \AND ({name_expr} LIKE LOWER({pattern}) ESCAPE '~' OR LOWER(COALESCE(m.COMMENTS, '')) LIKE LOWER({pattern}) ESCAPE '~') \- ORDER BY object_schema, object_name, column_name) WHERE ROWNUM <= {limit} \+ ORDER BY 1, 2, 3) WHERE ROWNUM <= {limit} \UNION ALL \SELECT * FROM ( \SELECT t.OWNER AS object_schema, t.TABLE_NAME AS object_name, CAST(NULL AS VARCHAR2(128)) AS column_name \@@ -293,8 +293,8 @@ fn oracle_family_structure_search_sql(FROM ALL_TAB_COMMENTS t \WHERE t.OWNER = {owner} \AND LOWER(COALESCE(t.COMMENTS, '')) LIKE LOWER({pattern}) ESCAPE '~' \- ORDER BY object_schema, object_name) WHERE ROWNUM <= {table_limit} \- ORDER BY object_schema, object_name, column_name) WHERE ROWNUM <= {total_limit}",+ ORDER BY 1, 2) WHERE ROWNUM <= {table_limit} \+ ORDER BY 1, 2, 3) WHERE ROWNUM <= {total_limit}",owner = owner_literal,name_expr = name_expr,pattern = pattern_literal,diff --git a/crates/dbx-sql-data/src/lib.rs b/crates/dbx-sql-data/src/lib.rsindex e052dd5789..517332da8b 100644--- a/crates/dbx-sql-data/src/lib.rs+++ b/crates/dbx-sql-data/src/lib.rs@@ -6,6 +6,8 @@ pub use dbx_types::{database_manifest, models, types};pub mod data_grid_extractors;pub mod data_grid_sql;+pub mod database_search_columns_sql;+pub mod database_search_probe_sql;pub mod database_search_sql;pub mod database_structure_search_sql;pub mod query_result_sql;diff --git a/crates/dbx-sql/src/lib.rs b/crates/dbx-sql/src/lib.rsindex f37c4f06e3..346c6c046a 100644--- a/crates/dbx-sql/src/lib.rs+++ b/crates/dbx-sql/src/lib.rs@@ -6,7 +6,8 @@ pub use dbx_sql_core::{value_literals,};pub use dbx_sql_data::{- data_grid_extractors, data_grid_sql, database_search_sql, database_structure_search_sql, query_result_sql,+ data_grid_extractors, data_grid_sql, database_search_columns_sql, database_search_probe_sql, database_search_sql,+ database_structure_search_sql, query_result_sql,};pub use dbx_sql_dialect::{dml_binding, postgres_index_key, sql_dialect};pub use dbx_sql_schema::{db_admin_sql, schema_diff, sql_parser, table_structure_sql};diff --git a/crates/dbx-web/src/main.rs b/crates/dbx-web/src/main.rsindex 18ebb79470..3c1e99398e 100644--- a/crates/dbx-web/src/main.rs+++ b/crates/dbx-web/src/main.rs@@ -867,6 +867,8 @@ async fn serve() -> Result<(), String> {.route("/query/build-create-user-sql", post(routes::query::build_create_user_sql)).route("/query/build-table-select-sql", post(routes::query::build_table_select_sql)).route("/query/build-database-search-sql", post(routes::query::build_database_search_sql))+ .route("/query/build-database-search-columns-sql", post(routes::query::build_database_search_columns_sql))+ .route("/query/build-database-search-probe-sql", post(routes::query::build_database_search_probe_sql)).route("/query/build-database-structure-search-sql", post(routes::query::build_database_structure_search_sql)).route("/query/supports-database-structure-search", post(routes::query::supports_database_structure_search)).route("/query/build-search-result-where", post(routes::query::build_search_result_where))diff --git a/crates/dbx-web/src/routes/query.rs b/crates/dbx-web/src/routes/query.rsindex e048dba300..bfc945197d 100644--- a/crates/dbx-web/src/routes/query.rs+++ b/crates/dbx-web/src/routes/query.rs@@ -152,6 +152,18 @@ pub struct BuildDatabaseStructureSearchSqlRequest {pub options: dbx_core::database_structure_search_sql::DatabaseStructureSearchSqlOptions,}+#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct BuildDatabaseSearchColumnsSqlRequest {+ pub options: dbx_core::database_search_columns_sql::DatabaseSearchColumnsSqlOptions,+}++#[derive(Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct BuildDatabaseSearchProbeSqlRequest {+ pub options: dbx_core::database_search_probe_sql::DatabaseSearchProbeSqlOptions,+}+#[derive(Deserialize)]#[serde(rename_all = "camelCase")]pub struct SupportsDatabaseStructureSearchRequest {@@ -1154,6 +1166,18 @@ pub async fn build_database_structure_search_sql(Json(dbx_core::database_structure_search_sql::build_database_structure_search_sql(req.options))}+pub async fn build_database_search_columns_sql(+ Json(req): Json<BuildDatabaseSearchColumnsSqlRequest>,+) -> Json<Option<dbx_core::database_search_columns_sql::DatabaseSearchColumnsSql>> {+ Json(dbx_core::database_search_columns_sql::build_database_search_columns_sql(req.options))+}++pub async fn build_database_search_probe_sql(+ Json(req): Json<BuildDatabaseSearchProbeSqlRequest>,+) -> Json<Option<dbx_core::database_search_probe_sql::DatabaseSearchProbeSql>> {+ Json(dbx_core::database_search_probe_sql::build_database_search_probe_sql(req.options))+}+pub async fn supports_database_structure_search(Json(req): Json<SupportsDatabaseStructureSearchRequest>) -> Json<bool> {Json(dbx_core::database_structure_search_sql::supports_database_structure_search(req.database_type,diff --git a/src-tauri/src/commands/query.rs b/src-tauri/src/commands/query.rsindex 31b11d1b49..abd0f5aa85 100644--- a/src-tauri/src/commands/query.rs+++ b/src-tauri/src/commands/query.rs@@ -704,6 +704,20 @@ pub fn build_database_structure_search_sql(Ok(dbx_core::database_structure_search_sql::build_database_structure_search_sql(options))}+#[tauri::command]+pub fn build_database_search_columns_sql(+ options: dbx_core::database_search_columns_sql::DatabaseSearchColumnsSqlOptions,+) -> Result<Option<dbx_core::database_search_columns_sql::DatabaseSearchColumnsSql>, String> {+ Ok(dbx_core::database_search_columns_sql::build_database_search_columns_sql(options))+}++#[tauri::command]+pub fn build_database_search_probe_sql(+ options: dbx_core::database_search_probe_sql::DatabaseSearchProbeSqlOptions,+) -> Result<Option<dbx_core::database_search_probe_sql::DatabaseSearchProbeSql>, String> {+ Ok(dbx_core::database_search_probe_sql::build_database_search_probe_sql(options))+}+#[tauri::command]pub fn supports_database_structure_search(database_type: Option<dbx_core::models::connection::DatabaseType>,diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rsindex 76c98ba42c..f37a8ebd46 100644--- a/src-tauri/src/lib.rs+++ b/src-tauri/src/lib.rs@@ -2365,6 +2365,8 @@ pub fn run() {commands::query::build_dropped_file_preview_sql,commands::query::build_table_select_sql,commands::query::build_database_search_sql,+ commands::query::build_database_search_columns_sql,+ commands::query::build_database_search_probe_sql,commands::query::build_database_structure_search_sql,commands::query::supports_database_structure_search,commands::query::build_search_result_where,