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
import type { ConnectionConfig, DatabaseType } from "@/types/database";
import { connectionUsesConnectionRootSchemaMode, effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
type VisibleDatabaseConnection = Partial<ConnectionConfig>;
type SystemNameRules = {
exact?: ReadonlySet<string>;
prefixes?: readonly string[];
contains?: readonly string[];
};
type SchemaFilterOptions = {
showSystemSchemas?: boolean;
};
function schemaFilterShowSystemSchemas(connection: Partial<Pick<ConnectionConfig, "show_system_schemas">> | undefined, options?: SchemaFilterOptions): boolean {
return options?.showSystemSchemas ?? connection?.show_system_schemas === true;
}
const SYSTEM_DATABASE_RULES: Partial<Record<DatabaseType, ReadonlySet<string>>> = {
mysql: new Set(["information_schema", "mysql", "performance_schema", "sys"]),
doris: new Set(["information_schema", "mysql", "performance_schema", "sys"]),
starrocks: new Set(["information_schema", "mysql", "performance_schema", "sys"]),
manticoresearch: new Set(["information_schema", "mysql", "performance_schema", "sys"]),
goldendb: new Set(["information_schema", "mysql", "performance_schema", "sys"]),
gbase: new Set(["information_schema", "mysql", "performance_schema", "sys"]),
postgres: new Set(["template0", "template1"]),
gaussdb: new Set(["template0", "template1"]),
kwdb: new Set(["template0", "template1"]),
opengauss: new Set(["template0", "template1"]),
questdb: new Set(["template0", "template1"]),
kingbase: new Set(["template0", "template1"]),
highgo: new Set(["template0", "template1"]),
uxdb: new Set(["template0", "template1"]),
vastbase: new Set(["template0", "template1"]),
redshift: new Set(["template0", "template1"]),
clickhouse: new Set(["information_schema", "system"]),
tdengine: new Set(["information_schema", "performance_schema"]),
sqlserver: new Set(["master", "model", "msdb", "tempdb"]),
mongodb: new Set(["admin", "config", "local"]),
oracle: new Set([
"anonymous",
"appqossys",
"audsys",
"ctxsys",
"dbsnmp",
"dvf",
"dvsys",
"exfsys",
"flows_files",
"gsmadmin_internal",
"mddata",
"mdsys",
"mgmt_view",
"olapsys",
"orddata",
"ordplugins",
"ordsys",
"outln",
"owbsys",
"remote_scheduler_agent",
"si_informtn_schema",
"sys",
"sysback",
"sysdg",
"syskm",
"system",
"wmsys",
"xdb",
"xs$null",
]),
dameng: new Set(["_sys_statistics", "ctisys", "dba", "sys", "sys_dba", "sys_phm", "sysauditor", "sysdba", "sysdbo", "syssso", "system"]),
saphana: new Set(["_sys_afl", "_sys_bi", "_sys_bic", "_sys_repo", "_sys_statistics", "sys"]),
cassandra: new Set(["system", "system_auth", "system_distributed", "system_schema", "system_traces", "system_views", "system_virtual_schema"]),
neo4j: new Set(["system"]),
snowflake: new Set(["snowflake", "snowflake_sample_data"]),
};
const POSTGRES_LIKE_SYSTEM_SCHEMA_RULES: SystemNameRules = {
exact: new Set(["information_schema", "pg_catalog", "pg_toast"]),
prefixes: ["pg_temp_", "pg_toast_temp_"],
};
const ORACLE_SYSTEM_SCHEMA_NAMES = new Set([
"anonymous",
"appqossys",
"audsys",
"ctxsys",
"dbsnmp",
"dvf",
"dvsys",
"exfsys",
"flows_files",
"gsmadmin_internal",
"mddata",
"mdsys",
"mgmt_view",
"olapsys",
"orddata",
"ordplugins",
"ordsys",
"outln",
"owbsys",
"remote_scheduler_agent",
"si_informtn_schema",
"sys",
"sysback",
"sysdg",
"syskm",
"system",
"wmsys",
"xdb",
"xs$null",
]);
const OCEANBASE_ORACLE_SYSTEM_SCHEMA_NAMES = new Set([...ORACLE_SYSTEM_SCHEMA_NAMES, "apex_public_user", "dbsfwuser", "dgpdb_int", "dip", "ggsys", "gsmcatuser", "gsmrootuser", "gsmuser", "lbacsys", "ojvmsys", "ops$oracle", "oracle_ocm", "pdbadmin", "sysbackup", "sysman", "sysrac"]);
const SYSTEM_SCHEMA_RULES: Partial<Record<DatabaseType, SystemNameRules>> = {
oracle: {
exact: ORACLE_SYSTEM_SCHEMA_NAMES,
},
"oceanbase-oracle": {
exact: OCEANBASE_ORACLE_SYSTEM_SCHEMA_NAMES,
prefixes: ["apex_", "flows_"],
contains: ["$"],
},
dameng: {
exact: new Set(["_sys_statistics", "ctisys", "dba", "sys", "sys_dba", "sys_phm", "sysauditor", "sysdba", "sysdbo", "syssso", "system"]),
},
postgres: POSTGRES_LIKE_SYSTEM_SCHEMA_RULES,
gaussdb: {
exact: new Set(["blockchain", "coverage", "cstore", "db4ai", "dbe_perf", "dbe_pldebugger", "dbe_pldeveloper", "dbe_sql_util", "information_schema", "pg_catalog", "pg_toast", "pkg_service", "snapshot", "sqladvisor", "xmltype"]),
prefixes: ["pg_temp_", "pg_toast_temp_", "dbe_"],
},
kwdb: POSTGRES_LIKE_SYSTEM_SCHEMA_RULES,
opengauss: {
exact: new Set(["blockchain", "coverage", "cstore", "db4ai", "dbe_perf", "dbe_pldebugger", "dbe_pldeveloper", "dbe_sql_util", "information_schema", "pg_catalog", "pg_toast", "pkg_service", "snapshot", "sqladvisor", "xmltype"]),
prefixes: ["pg_temp_", "pg_toast_temp_", "dbe_"],
},
questdb: POSTGRES_LIKE_SYSTEM_SCHEMA_RULES,
kingbase: {
exact: new Set(["anon", "dbms_job", "dbms_scheduler", "dbms_sql", "information_schema", "kdb_schedule", "perf", "pg_bitmapindex", "pg_catalog", "pg_toast", "src_restrict", "sys", "sys_catalog", "sys_hm", "sysaudit", "sysmac", "wmsys"]),
prefixes: ["dbms_", "pg_temp_", "pg_toast_temp_", "sys_temp_", "sys_toast_temp_", "xlog_"],
},
highgo: POSTGRES_LIKE_SYSTEM_SCHEMA_RULES,
vastbase: POSTGRES_LIKE_SYSTEM_SCHEMA_RULES,
};
export function visibleDatabaseFilterIsEnabled(visibleDatabases: string[] | undefined): boolean {
return Array.isArray(visibleDatabases);
}
/**
* 匹配全部库名的通配符。用于把“显示全部(含系统库)”持久化成动态过滤条件:
* 未配置筛选时系统库默认隐藏,而显式库名快照又会让之后新建的库无法自动出现。
*/
export const MATCH_ALL_VISIBLE_DATABASE_PATTERN = "%";
const visibleDatabasePatternRegExpCache = new Map<string, RegExp>();
/** SQL LIKE 语义:`%` 匹配任意字符序列、`_` 匹配单个字符,其余按字面匹配(区分大小写)。 */
export function visibleDatabasePatternRegExp(pattern: string): RegExp {
const trimmed = pattern.trim();
const cached = visibleDatabasePatternRegExpCache.get(trimmed);
if (cached) return cached;
let source = "";
for (const ch of trimmed) {
if (ch === "%") source += "[\\s\\S]*";
else if (ch === "_") source += "[\\s\\S]";
else source += ch.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
}
const regExp = new RegExp(`^${source}$`);
if (visibleDatabasePatternRegExpCache.size > 256) visibleDatabasePatternRegExpCache.clear();
visibleDatabasePatternRegExpCache.set(trimmed, regExp);
return regExp;
}
export function visibleDatabasePatternsAreEnabled(patterns: string[] | undefined): boolean {
return Array.isArray(patterns) && patterns.some((pattern) => pattern.trim() !== "");
}
/** 解析用户输入的模式列表:逗号/分号/换行分隔,去空白、去重。 */
export function parseVisibleDatabasePatternsInput(value: string): string[] {
const seen = new Set<string>();
const patterns: string[] = [];
for (const part of value.split(/[\n,,;;]+/)) {
const pattern = part.trim();
if (!pattern || seen.has(pattern)) continue;
seen.add(pattern);
patterns.push(pattern);
}
return patterns;
}
export function databaseNameMatchesVisiblePatterns(name: string, patterns: string[] | undefined): boolean {
if (!visibleDatabasePatternsAreEnabled(patterns)) return false;
return patterns!.some((pattern) => visibleDatabasePatternRegExp(pattern).test(name));
}
export function canSaveVisibleDatabaseSelection(selectedNames: string[]): boolean {
return selectedNames.length > 0;
}
export function filterVisibleDatabaseNames(databaseNames: string[], visibleDatabases: string[] | undefined, visibleDatabasePatterns?: string[]): string[] {
const exactEnabled = visibleDatabaseFilterIsEnabled(visibleDatabases);
if (!exactEnabled && !visibleDatabasePatternsAreEnabled(visibleDatabasePatterns)) return databaseNames;
// 显式勾选与模式取并集:模式对新建的数据库持续生效(#7164)
const visible = exactEnabled ? new Set(visibleDatabases) : undefined;
return databaseNames.filter((name) => visible?.has(name) || databaseNameMatchesVisiblePatterns(name, visibleDatabasePatterns));
}
export function normalizeVisibleDatabaseSelection(selectedNames: string[], databaseNames: string[]): string[] {
const available = new Set(databaseNames);
const seen = new Set<string>();
return selectedNames.filter((name) => {
if (!available.has(name) || seen.has(name)) return false;
seen.add(name);
return true;
});
}
export function isSystemDatabaseName(databaseType: DatabaseType | undefined, databaseName: string): boolean {
if (!databaseType) return false;
return SYSTEM_DATABASE_RULES[databaseType]?.has(databaseName.toLowerCase()) ?? false;
}
export function isSystemSchemaName(databaseType: DatabaseType | undefined, schemaName: string): boolean {
if (!databaseType) return false;
const normalized = schemaName.toLowerCase();
const rules = SYSTEM_SCHEMA_RULES[databaseType];
if (!rules) return false;
if (rules.exact?.has(normalized)) return true;
if (rules.prefixes?.some((prefix) => normalized.startsWith(prefix))) return true;
return rules.contains?.some((part) => normalized.includes(part)) ?? false;
}
export function filterDatabaseNamesForConnection(databaseNames: string[], connection: VisibleDatabaseConnection | undefined): string[] {
const visibleDatabases = connection?.visible_databases;
const visibleDatabasePatterns = connection?.visible_database_patterns;
if (visibleDatabaseFilterIsEnabled(visibleDatabases) || visibleDatabasePatternsAreEnabled(visibleDatabasePatterns)) {
return filterVisibleDatabaseNames(databaseNames, visibleDatabases, visibleDatabasePatterns);
}
return filterDatabaseNamesForVisiblePicker(databaseNames, connection);
}
export function filterDatabaseNamesForVisiblePicker(databaseNames: string[], connection: VisibleDatabaseConnection | undefined): string[] {
if (connection?.db_type === "gbase8s") {
return databaseNames;
}
return databaseNames.filter((name) => !isSystemDatabaseName(effectiveDatabaseTypeForConnection(connection), name));
}
export function filterSchemaNamesForVisiblePicker(schemaNames: string[], connection: VisibleDatabaseConnection | undefined, options?: SchemaFilterOptions): string[] {
if (schemaFilterShowSystemSchemas(connection, options)) return schemaNames;
const currentSchema = connection?.username?.trim().toLowerCase();
// OceanBase Oracle logins embed the tenant in the username ("user@tenant");
// the schema equals the user part, so keep the login schema visible in both
// forms instead of hiding it behind a system-schema name (#8145).
const currentUserPart = currentSchema?.split("@")[0];
const databaseType = effectiveDatabaseTypeForConnection(connection);
return schemaNames.filter((name) => {
const normalized = name.toLowerCase();
return normalized === currentSchema || normalized === currentUserPart || !isSystemSchemaName(databaseType, name);
});
}
export function connectionUsesVisibleSchemaFilter(connection: VisibleDatabaseConnection | undefined): boolean {
return connectionUsesConnectionRootSchemaMode(connection);
}
export function visibleSchemaFilterIsEnabled(visibleSchemas: Record<string, string[]> | undefined, database: string): boolean {
return Array.isArray(visibleSchemas?.[database]);
}
export function filterSchemaNamesForConnection(schemaNames: string[], connection: VisibleDatabaseConnection | undefined, database: string, options?: SchemaFilterOptions): string[] {
const visibleSchemas = connection?.visible_schemas;
// Single-database connections persist their schema filter under the empty
// database key while the editor toolbar addresses the same bucket with its
// "_" single-db sentinel; normalize so the strict checkbox filter still
// applies to the schema picker (#8145).
const filterDatabase = database === "_" ? "" : database;
if (!visibleSchemaFilterIsEnabled(visibleSchemas, filterDatabase)) {
const visibleDatabases = connection?.visible_databases;
const visibleDatabasePatterns = connection?.visible_database_patterns;
if (connectionUsesVisibleSchemaFilter(connection) && (visibleDatabaseFilterIsEnabled(visibleDatabases) || visibleDatabasePatternsAreEnabled(visibleDatabasePatterns))) {
return filterVisibleDatabaseNames(schemaNames, visibleDatabases, visibleDatabasePatterns);
}
return filterSchemaNamesForVisiblePicker(schemaNames, connection, options);
}
const visible = new Set(visibleSchemas![filterDatabase]);
return schemaNames.filter((name) => visible.has(name));
}
export function normalizeVisibleSchemaSelection(selectedNames: string[], schemaNames: string[]): string[] {
const available = new Set(schemaNames);
const seen = new Set<string>();
return selectedNames.filter((name) => {
if (!available.has(name) || seen.has(name)) return false;
seen.add(name);
return true;
});
}
const DRAFT_VISIBLE_SCHEMAS_PREFIX = "__visible_schema_draft_";
export function buildDraftVisibleSchemasConnectionId(seed: string): string {
return `${DRAFT_VISIBLE_SCHEMAS_PREFIX}${seed}`;
}
/** 可见 schema 选择器用的临时连接:只存在于弹窗交互期间,不是用户保存的连接。 */
export function isDraftVisibleSchemasConnectionId(connectionId: string): boolean {
return connectionId.startsWith(DRAFT_VISIBLE_SCHEMAS_PREFIX);
}