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。

3.2 KB
Raw Blame
import type { ColumnInfo, DatabaseType } from "@/types/database.ts";
import * as api from "@/lib/backend/api.ts";

export interface DatabaseSearchSqlOptions {
  databaseType?: DatabaseType;
  driverProfile?: string;
  schema?: string;
  tableName: string;
  columns: ColumnInfo[];
  term: string;
  limit?: number;
}

export interface DatabaseSearchSql {
  sql: string;
  searchableColumns: string[];
}

export interface SearchResultWhereOptions {
  databaseType?: DatabaseType;
  columns: ColumnInfo[];
  resultColumns: string[];
  row: unknown[];
  matchedColumns?: string[];
}

const TEXT_TYPES = ["char", "text", "clob", "varchar", "nvarchar", "nchar", "uuid", "uniqueidentifier", "enum"];

const NUMBER_TYPES = ["int", "serial", "number", "numeric", "decimal", "float", "double", "real", "money"];

const SKIPPED_TYPES = ["blob", "binary", "bytea", "image", "geometry", "geography"];

/** 文本/数值列判定只读 data_type,兼容批量取列的最小列结构。 */
type SearchableColumn = Pick<ColumnInfo, "data_type">;

function normalizedType(column: SearchableColumn): string {
  return column.data_type.toLowerCase();
}

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: SearchableColumn): boolean {
  const type = normalizedType(column);
  if (SKIPPED_TYPES.some((skipped) => type.includes(skipped))) return false;
  return NUMBER_TYPES.some((numberType) => type.includes(numberType));
}

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

export function parseNumericTerm(term: string): string | null {
  const trimmed = cleanTerm(term);
  if (!/^[+-]?(?:\d+|\d+\.\d+|\.\d+)$/.test(trimmed)) return null;
  return trimmed;
}

export async function buildDatabaseSearchSql(options: DatabaseSearchSqlOptions): Promise<DatabaseSearchSql | null> {
  return api.buildDatabaseSearchSql(options);
}

function columnByName(columns: ColumnInfo[], name: string): ColumnInfo | undefined {
  return columns.find((column) => column.name.toLowerCase() === name.toLowerCase());
}

export function findMatchedSearchColumns(resultColumns: string[], row: unknown[], columns: ColumnInfo[], term: string): string[] {
  const query = cleanTerm(term).toLowerCase();
  const numericTerm = parseNumericTerm(term);
  if (!query) return [];

  const matches: string[] = [];
  resultColumns.forEach((columnName, index) => {
    const value = row[index];
    if (value === null || value === undefined) return;
    const column = columnByName(columns, columnName);
    if (!column || (!isTextSearchColumn(column) && !isNumericSearchColumn(column))) return;

    if (isNumericSearchColumn(column) && numericTerm && String(value).trim() === numericTerm) {
      matches.push(columnName);
      return;
    }

    if (isTextSearchColumn(column) && String(value).toLowerCase().includes(query)) {
      matches.push(columnName);
    }
  });
  return matches;
}

export async function buildSearchResultWhere(options: SearchResultWhereOptions): Promise<string> {
  return api.buildSearchResultWhere(options);
}