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。

7.5 KB
Raw Blame
import type { DatabaseType } from "@/types/database";
import type { ColumnInfo } from "@/types/database";
import * as api from "@/lib/backend/api.ts";
import { supportsDatabaseStructureSearch as supportsDatabaseStructureSearchCapability, usesDocumentStructureSearch, usesSqlCatalogStructureSearch } from "@/lib/database/databaseStructureSearchCapabilities";

export type DatabaseSearchScope = "data" | "structure";

export interface DatabaseStructureSearchSqlOptions {
  databaseType?: DatabaseType;
  driverProfile?: string;
  database: string;
  schema?: string;
  term: string;
  limit?: number;
}

export interface DatabaseStructureSearchSql {
  sql: string;
}

export interface DatabaseStructureSearchHit {
  schema?: string;
  tableName: string;
  tableType?: string;
  /** 字段级命中的列名;表注释命中(表级结果行)时为 undefined。 */
  columnName?: string;
  columnComment?: string;
  /** 表自身注释的命中内容,仅当 matchedIn 含 "tableComment" 时有值。 */
  tableComment?: string;
  matchedIn: Array<"name" | "comment" | "tableComment">;
}

export interface DatabaseStructureSearchOptions {
  connectionId: string;
  databaseType: DatabaseType;
  driverProfile?: string;
  database: string;
  schema?: string;
  term: string;
  limit?: number;
  executionId: string;
  shouldAbort?: () => boolean;
  listTables: (schema?: string) => Promise<Array<{ name: string; table_type: string }>>;
  getColumns: (schema: string, tableName: string) => Promise<ColumnInfo[]>;
  executeQuery: (sql: string, executionId: string) => Promise<{ columns: string[]; rows: unknown[][] }>;
}

function cleanTerm(term: string): string {
  return term.trim();
}

function termMatches(haystack: string | null | undefined, needle: string): boolean {
  if (!haystack) return false;
  return haystack.toLowerCase().includes(needle.toLowerCase());
}

function normalizeRow(columns: string[], row: unknown[]): Record<string, unknown> {
  const record: Record<string, unknown> = {};
  columns.forEach((column, index) => {
    record[column.toLowerCase()] = row[index];
  });
  return record;
}

function asString(value: unknown): string {
  if (value === null || value === undefined) return "";
  return String(value);
}

export function mapStructureSearchRows(columns: string[], rows: unknown[][], term: string): DatabaseStructureSearchHit[] {
  const query = cleanTerm(term);
  if (!query) return [];
  const hits: DatabaseStructureSearchHit[] = [];
  for (const row of rows) {
    const record = normalizeRow(columns, row);
    const schema = asString(record.object_schema) || undefined;
    const tableName = asString(record.object_name);
    const tableType = asString(record.object_type) || undefined;
    const columnName = asString(record.column_name);
    const columnComment = asString(record.column_comment) || undefined;
    const tableComment = asString(record.table_comment) || undefined;
    if (!tableName) continue;
    const matchedIn: Array<"name" | "comment" | "tableComment"> = [];
    if (columnName && termMatches(columnName, query)) matchedIn.push("name");
    if (columnComment && termMatches(columnComment, query)) matchedIn.push("comment");
    // 表注释命中是表级结果行:column_name 为空,只有 table_comment 参与匹配。
    if (tableComment && termMatches(tableComment, query)) matchedIn.push("tableComment");
    if (!matchedIn.length) continue;
    hits.push({
      schema,
      tableName,
      tableType,
      columnName: columnName || undefined,
      columnComment,
      tableComment,
      matchedIn,
    });
  }
  return hits;
}

export function structureHitPreview(hit: DatabaseStructureSearchHit): string {
  const parts: string[] = [];
  if (hit.matchedIn.includes("name") && hit.columnName) parts.push(hit.columnName);
  if (hit.matchedIn.includes("comment") && hit.columnComment) {
    parts.push(truncateComment(hit.columnComment));
  }
  if (hit.matchedIn.includes("tableComment") && hit.tableComment) {
    parts.push(truncateComment(hit.tableComment));
  }
  return parts.join(" · ") || hit.columnName || "";
}

function truncateComment(comment: string): string {
  const normalized = comment.replace(/\s+/g, " ").trim();
  return normalized.length > 90 ? `${normalized.slice(0, 90)}...` : normalized;
}

export async function buildDatabaseStructureSearchSql(options: DatabaseStructureSearchSqlOptions): Promise<DatabaseStructureSearchSql | null> {
  return api.buildDatabaseStructureSearchSql(options);
}

export async function supportsDatabaseStructureSearchBackend(databaseType?: DatabaseType, driverProfile?: string): Promise<boolean> {
  return api.supportsDatabaseStructureSearch(databaseType, driverProfile);
}

export async function runSqlCatalogStructureSearch(options: DatabaseStructureSearchOptions): Promise<DatabaseStructureSearchHit[]> {
  if (options.shouldAbort?.()) return [];
  const query = await buildDatabaseStructureSearchSql({
    databaseType: options.databaseType,
    driverProfile: options.driverProfile,
    database: options.database,
    schema: options.schema,
    term: options.term,
    limit: options.limit,
  });
  if (!query?.sql || options.shouldAbort?.()) return [];
  const result = await options.executeQuery(query.sql, options.executionId);
  if (options.shouldAbort?.()) return [];
  return mapStructureSearchRows(result.columns, result.rows, options.term);
}

async function runDocumentStructureSearch(options: DatabaseStructureSearchOptions): Promise<DatabaseStructureSearchHit[]> {
  const query = cleanTerm(options.term);
  if (!query || options.shouldAbort?.()) return [];
  const limit = Math.min(5000, Math.max(1, options.limit ?? 200));
  const hits: DatabaseStructureSearchHit[] = [];
  const tables = await options.listTables(options.schema);
  for (const table of tables) {
    if (options.shouldAbort?.()) return hits;
    if (hits.length >= limit) break;
    const schema = options.schema || options.database;
    let columns: ColumnInfo[] = [];
    try {
      columns = await options.getColumns(schema, table.name);
    } catch {
      continue;
    }
    for (const column of columns) {
      const matchedIn: Array<"name" | "comment"> = [];
      if (termMatches(column.name, query)) matchedIn.push("name");
      const comment = column.comment ?? undefined;
      if (termMatches(comment, query)) matchedIn.push("comment");
      if (!matchedIn.length) continue;
      hits.push({
        schema: options.schema,
        tableName: table.name,
        tableType: table.table_type,
        columnName: column.name,
        columnComment: comment,
        matchedIn,
      });
      if (hits.length >= limit) break;
    }
  }
  return hits;
}

export async function runDatabaseStructureSearch(options: DatabaseStructureSearchOptions): Promise<DatabaseStructureSearchHit[]> {
  if (usesSqlCatalogStructureSearch(options.databaseType)) {
    return runSqlCatalogStructureSearch(options);
  }
  if (usesDocumentStructureSearch(options.databaseType)) {
    return runDocumentStructureSearch(options);
  }
  return [];
}

export function effectiveDatabaseSearchScope(requested: DatabaseSearchScope, dbType?: DatabaseType, driverProfile?: string | null): DatabaseSearchScope {
  if (requested !== "structure") return "data";
  if (!supportsDatabaseStructureSearchCapability(dbType, driverProfile)) return "data";
  return "structure";
}

/** Sync guard for UI; mirrors backend catalog support for SQL engines and known document engines. */
export function supportsDatabaseStructureSearchFromManifest(dbType?: DatabaseType, driverProfile?: string | null): boolean {
  return supportsDatabaseStructureSearchCapability(dbType, driverProfile);
}