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 { describe, expect, it } from "vitest";
import { encodeSqlServerLinkedSchema } from "@/lib/database/sqlServerLinkedServers";
import { qualifiedTableName, qualifyTableReferencesInSql, quoteTableDataIdentifier, quoteTableIdentifier, quoteTableIdentifierIfNeeded, requiresEagerTableMetadataForDataOpen, tableMetaWithoutOptionalDatabaseQualifier } from "@/lib/table/tableSelectSql";
describe("qualifiedTableName — Doris/StarRocks multi-catalog", () => {
it("prefixes external catalog for Doris (no schema)", () => {
expect(qualifiedTableName({ databaseType: "doris", catalog: "iceberg_catalog", tableName: "orders" })).toBe("`iceberg_catalog`.`orders`");
});
it("prefixes external catalog for Doris (with schema)", () => {
expect(qualifiedTableName({ databaseType: "doris", catalog: "iceberg_catalog", schema: "sales", tableName: "orders" })).toBe("`iceberg_catalog`.`sales`.`orders`");
});
it("prefixes external catalog for StarRocks", () => {
expect(qualifiedTableName({ databaseType: "starrocks", catalog: "hive_catalog", tableName: "orders" })).toBe("`hive_catalog`.`orders`");
});
it("treats the internal catalog as no catalog", () => {
expect(qualifiedTableName({ databaseType: "doris", catalog: "internal", tableName: "orders" })).toBe("`orders`");
});
it("omits the catalog for non-Doris engines", () => {
// MySQL has no 3-part catalog naming; the catalog must be ignored.
expect(qualifiedTableName({ databaseType: "mysql", catalog: "iceberg_catalog", tableName: "orders" })).toBe("`orders`");
});
it("escapes embedded backticks in catalog and table identifiers", () => {
expect(qualifiedTableName({ databaseType: "doris", catalog: "a`b", schema: "c`d", tableName: "e`f" })).toBe("`a``b`.`c``d`.`e``f`");
});
});
describe("qualifiedTableName — optional database qualification", () => {
it("keeps MySQL table references unchanged unless enabled", () => {
expect(qualifiedTableName({ databaseType: "mysql", database: "analytics", tableName: "events" })).toBe("`events`");
expect(qualifiedTableName({ databaseType: "mysql", database: "analytics", tableName: "events", includeDatabaseName: true })).toBe("`analytics`.`events`");
});
it("uses the dialect's identifier quoting for database-qualified names", () => {
expect(qualifiedTableName({ databaseType: "clickhouse", database: "a`b", tableName: "c`d", includeDatabaseName: true })).toBe("`a``b`.`c``d`");
});
it("uses MySQL-compatible quoting for GoldenDB", () => {
expect(qualifiedTableName({ databaseType: "goldendb", database: "a`b", tableName: "c`d", includeDatabaseName: true })).toBe("`a``b`.`c``d`");
});
});
describe("qualifiedTableName — SQL Server three-part names", () => {
it("prefixes the database ahead of the schema once enabled", () => {
expect(qualifiedTableName({ databaseType: "sqlserver", database: "dbx", schema: "dbo", tableName: "gen_table" })).toBe("[dbo].[gen_table]");
expect(qualifiedTableName({ databaseType: "sqlserver", database: "dbx", schema: "dbo", tableName: "gen_table", includeDatabaseName: true })).toBe("[dbx].[dbo].[gen_table]");
});
it("keeps the schema-only form when the database is unknown", () => {
expect(qualifiedTableName({ databaseType: "sqlserver", database: "dbx", schema: "dbo", tableName: "gen_table", includeDatabaseName: true, quoteIdentifiers: false })).toBe("dbx.dbo.gen_table");
expect(qualifiedTableName({ databaseType: "sqlserver", schema: "dbo", tableName: "gen_table", includeDatabaseName: true })).toBe("[dbo].[gen_table]");
expect(qualifiedTableName({ databaseType: "sqlserver", database: "dbx", tableName: "gen_table", includeDatabaseName: true })).toBe("[gen_table]");
});
it("never stacks the local database on a linked-server schema", () => {
const schema = encodeSqlServerLinkedSchema({ server: "ERP", catalog: "Finance", schema: "dbo" });
expect(qualifiedTableName({ databaseType: "sqlserver", database: "dbx", schema, tableName: "orders", includeDatabaseName: true })).toBe("[ERP].[Finance].[dbo].[orders]");
});
});
describe("qualifyTableReferencesInSql", () => {
it("qualifies FROM and JOIN sources while preserving aliases", () => {
expect(
qualifyTableReferencesInSql("SELECT * FROM apis AS ap JOIN users AS u ON u.id = ap.user_id", {
databaseType: "mysql",
database: "aaa",
includeDatabaseName: true,
}),
).toBe("SELECT * FROM `aaa`.`apis` AS ap JOIN `aaa`.`users` AS u ON u.id = ap.user_id");
});
it("qualifies every source in a multi-line LEFT JOIN query", () => {
const sql = "SELECT `u`.`id`, `g`.`group_name`\nFROM `users` AS `u`\nLEFT JOIN `group_users` AS `gu` ON `gu`.`user_id` = `u`.`id`\nLEFT JOIN `groups` AS `g` ON `g`.`id` = `gu`.`group_id`\nLEFT JOIN `user_roles` AS `ur` ON `ur`.`user_id` = `u`.`id`";
const result = qualifyTableReferencesInSql(sql, { databaseType: "mysql", database: "aaa", includeDatabaseName: true });
expect(result).toContain("FROM `aaa`.`users` AS `u`");
expect(result).toContain("LEFT JOIN `aaa`.`group_users` AS `gu`");
expect(result).toContain("LEFT JOIN `aaa`.`groups` AS `g`");
expect(result).toContain("LEFT JOIN `aaa`.`user_roles` AS `ur`");
});
it("leaves already-qualified sources unchanged", () => {
const options = { databaseType: "mysql" as const, database: "aaa", includeDatabaseName: true };
expect(qualifyTableReferencesInSql("SELECT * FROM `aaa`.`apis`", options)).toBe("SELECT * FROM `aaa`.`apis`");
});
it("qualifies physical tables inside CTEs but never CTE references", () => {
const sql = "WITH users AS (SELECT * FROM archived_users)\nSELECT * FROM users";
expect(qualifyTableReferencesInSql(sql, { databaseType: "mysql", database: "aaa", includeDatabaseName: true })).toBe("WITH users AS (SELECT * FROM `aaa`.`archived_users`)\nSELECT * FROM users");
});
it("preserves CTE references when the statement has a trailing semicolon", () => {
const sql = "WITH users AS (SELECT * FROM archived_users) SELECT * FROM users;";
expect(qualifyTableReferencesInSql(sql, { databaseType: "mysql", database: "aaa", includeDatabaseName: true })).toBe("WITH users AS (SELECT * FROM `aaa`.`archived_users`) SELECT * FROM users;");
});
it("keeps CTE visibility scoped to each statement", () => {
const sql = "WITH users AS (SELECT * FROM archived_users) SELECT * FROM users; WITH roles AS (SELECT * FROM archived_roles) SELECT * FROM roles;";
expect(qualifyTableReferencesInSql(sql, { databaseType: "mysql", database: "aaa", includeDatabaseName: true })).toBe("WITH users AS (SELECT * FROM `aaa`.`archived_users`) SELECT * FROM users; WITH roles AS (SELECT * FROM `aaa`.`archived_roles`) SELECT * FROM roles;");
});
it("does not treat a later CTE name as visible inside an earlier CTE", () => {
const sql = "WITH first AS (SELECT * FROM second), second AS (SELECT * FROM archived_users) SELECT * FROM first";
expect(qualifyTableReferencesInSql(sql, { databaseType: "mysql", database: "aaa", includeDatabaseName: true })).toBe("WITH first AS (SELECT * FROM `aaa`.`second`), second AS (SELECT * FROM `aaa`.`archived_users`) SELECT * FROM first");
});
it("does not leak a nested CTE name into the outer query", () => {
const sql = "SELECT * FROM (WITH users AS (SELECT * FROM archived_users) SELECT * FROM users) nested JOIN users ON 1 = 1";
expect(qualifyTableReferencesInSql(sql, { databaseType: "mysql", database: "aaa", includeDatabaseName: true })).toBe("SELECT * FROM (WITH users AS (SELECT * FROM `aaa`.`archived_users`) SELECT * FROM users) nested JOIN `aaa`.`users` ON 1 = 1");
});
it("keeps outer CTEs visible inside nested WITH queries", () => {
const sql = "WITH users AS (SELECT * FROM archived_users) SELECT * FROM (WITH roles AS (SELECT * FROM users) SELECT * FROM roles) nested";
expect(qualifyTableReferencesInSql(sql, { databaseType: "mysql", database: "aaa", includeDatabaseName: true })).toBe("WITH users AS (SELECT * FROM `aaa`.`archived_users`) SELECT * FROM (WITH roles AS (SELECT * FROM users) SELECT * FROM roles) nested");
});
it("does not let a nested CTE suppress an earlier outer physical table", () => {
const sql = "SELECT * FROM users WHERE EXISTS (WITH users AS (SELECT * FROM archived_users) SELECT * FROM users)";
expect(qualifyTableReferencesInSql(sql, { databaseType: "mysql", database: "aaa", includeDatabaseName: true })).toBe("SELECT * FROM `aaa`.`users` WHERE EXISTS (WITH users AS (SELECT * FROM `aaa`.`archived_users`) SELECT * FROM users)");
});
it("does not rewrite FROM and JOIN text inside literals or comments", () => {
const sql = "SELECT 'FROM users JOIN groups' AS note\nFROM users -- JOIN groups";
expect(qualifyTableReferencesInSql(sql, { databaseType: "mysql", database: "aaa", includeDatabaseName: true })).toBe("SELECT 'FROM users JOIN groups' AS note\nFROM `aaa`.`users` -- JOIN groups");
});
it("uses GoldenDB's MySQL-compatible identifier quoting", () => {
expect(qualifyTableReferencesInSql("SELECT * FROM users", { databaseType: "goldendb", database: "aaa", includeDatabaseName: true })).toBe("SELECT * FROM `aaa`.`users`");
});
});
describe("qualifyTableReferencesInSql — SQL Server three-part names (#9262)", () => {
const options = { databaseType: "sqlserver" as const, database: "dbx", includeDatabaseName: true };
it("prefixes the database ahead of the schema already named", () => {
expect(qualifyTableReferencesInSql("SELECT TOP (100) * FROM [dbo].[gen_table]", options)).toBe("SELECT TOP (100) * FROM [dbx].[dbo].[gen_table]");
});
it("qualifies every FROM/JOIN source while keeping aliases", () => {
expect(qualifyTableReferencesInSql("SELECT * FROM [dbo].[orders] AS o JOIN [sales].[items] AS i ON i.order_id = o.id", options)).toBe("SELECT * FROM [dbx].[dbo].[orders] AS o JOIN [dbx].[sales].[items] AS i ON i.order_id = o.id");
});
it("handles unquoted and spaced qualifiers", () => {
expect(qualifyTableReferencesInSql("SELECT * FROM dbo.gen_table", options)).toBe("SELECT * FROM [dbx].dbo.gen_table");
});
it("leaves already database-qualified and three-part names alone", () => {
expect(qualifyTableReferencesInSql("SELECT * FROM [other].[dbo].[gen_table]", options)).toBe("SELECT * FROM [other].[dbo].[gen_table]");
expect(qualifyTableReferencesInSql("SELECT * FROM [dbx_test].[dbo].[gen_table]", options)).toBe("SELECT * FROM [dbx_test].[dbo].[gen_table]");
});
it("leaves schema-less names alone because `db.table` is not a SQL Server reference", () => {
expect(qualifyTableReferencesInSql("SELECT * FROM [gen_table]", options)).toBe("SELECT * FROM [gen_table]");
expect(qualifyTableReferencesInSql("SELECT * FROM [dbx]..[gen_table]", options)).toBe("SELECT * FROM [dbx]..[gen_table]");
});
it("skips CTEs and stays inert when the setting is off", () => {
expect(qualifyTableReferencesInSql("WITH cte AS (SELECT * FROM [dbo].[gen_table]) SELECT * FROM cte", options)).toBe("WITH cte AS (SELECT * FROM [dbx].[dbo].[gen_table]) SELECT * FROM cte");
expect(qualifyTableReferencesInSql("SELECT * FROM [dbo].[gen_table]", { ...options, includeDatabaseName: false })).toBe("SELECT * FROM [dbo].[gen_table]");
});
});
describe("qualifiedTableName — SQLite attached databases", () => {
it("qualifies tables with the attached database alias", () => {
expect(qualifiedTableName({ databaseType: "sqlite", schema: "analytics", tableName: "events" })).toBe('"analytics"."events"');
});
});
describe("qualifiedTableName — SQL Server linked servers", () => {
it("retains required brackets when optional quoting is disabled", () => {
const schema = encodeSqlServerLinkedSchema({ server: "REMOTE SERVER", catalog: "sales", schema: "dbo" });
expect(qualifiedTableName({ databaseType: "sqlserver", schema, tableName: "order", quoteIdentifiers: false })).toBe("[REMOTE SERVER].sales.dbo.[order]");
});
});
describe("qualifiedTableName — PostgreSQL family schema qualifier (#13235)", () => {
it("qualifies a table outside the connection's default schema even with includeDatabaseName off", () => {
expect(qualifiedTableName({ databaseType: "postgres", identifierQuote: '"', schema: "analytics", tableName: "users", includeDatabaseName: false, defaultSchema: "public" })).toBe("analytics.users");
expect(qualifiedTableName({ databaseType: "opengauss", identifierQuote: '"', schema: "public", tableName: "t", includeDatabaseName: false, defaultSchema: "$user" })).toBe("public.t");
expect(qualifiedTableName({ databaseType: "kingbase", identifierQuote: '"', schema: "audit", tableName: "events", includeDatabaseName: false, defaultSchema: "public" })).toBe('"audit"."events"');
});
it("keeps the bare name for the default schema and when the default schema is unknown (#9110)", () => {
expect(qualifiedTableName({ databaseType: "postgres", identifierQuote: '"', schema: "public", tableName: "users", includeDatabaseName: false, defaultSchema: "public" })).toBe("users");
expect(qualifiedTableName({ databaseType: "postgres", identifierQuote: '"', schema: "analytics", tableName: "users", includeDatabaseName: false })).toBe("users");
expect(qualifiedTableName({ databaseType: "postgres", identifierQuote: '"', tableName: "users", includeDatabaseName: false, defaultSchema: "public" })).toBe("users");
});
});
describe("qualifiedTableName — schema-aware JDBC profiles", () => {
it("qualifies Phoenix tables without forcing identifier quotes", () => {
expect(qualifiedTableName({ databaseType: "jdbc", driverProfile: "phoenix", schema: "DEMO", tableName: "STUDENT" })).toBe("DEMO.STUDENT");
});
it("uses the driver-reported quote for Phoenix special identifiers", () => {
expect(qualifiedTableName({ databaseType: "jdbc", driverProfile: "phoenix", identifierQuote: '"', schema: "MY_SCHEMA", tableName: "ORDER" })).toBe('"MY_SCHEMA"."ORDER"');
});
it("keeps an unscoped JDBC table unqualified", () => {
expect(qualifiedTableName({ databaseType: "jdbc", driverProfile: "phoenix", tableName: "STUDENT" })).toBe("STUDENT");
});
});
describe("qualifiedTableName — includeDatabaseName on quoted-identifier paths (#9110)", () => {
it("drops the schema qualifier for JDBC-reported Postgres-family connections", () => {
expect(qualifiedTableName({ databaseType: "postgres", identifierQuote: '"', schema: "public", tableName: "Users", includeDatabaseName: false })).toBe('"Users"');
});
it("keeps the schema qualifier by default for quoted-identifier connections", () => {
expect(qualifiedTableName({ databaseType: "postgres", identifierQuote: '"', schema: "public", tableName: "Users" })).toBe('public."Users"');
});
it("drops the schema qualifier for kingbase JDBC connections", () => {
expect(qualifiedTableName({ databaseType: "kingbase", identifierQuote: '"', schema: "app", tableName: "orders", includeDatabaseName: false })).toBe('"orders"');
});
it("drops the schema qualifier for generic JDBC profiles that qualify schemas", () => {
expect(qualifiedTableName({ databaseType: "jdbc", driverProfile: "phoenix", identifierQuote: '"', schema: "MY_SCHEMA", tableName: "ORDER", includeDatabaseName: false })).toBe('"ORDER"');
});
it("drops the schema qualifier for native Informix connections", () => {
expect(qualifiedTableName({ databaseType: "informix", identifierQuote: "", schema: "gbasedbt", tableName: "connection_smoke", includeDatabaseName: false })).toBe("connection_smoke");
});
it("keeps the qualifier for databases that require fully qualified names", () => {
expect(qualifiedTableName({ databaseType: "sqlserver", schema: "dbo", tableName: "users", includeDatabaseName: false })).toBe("[dbo].[users]");
});
});
describe("tableMetaWithoutOptionalDatabaseQualifier — copy extractors (#9326)", () => {
const mysqlMeta = { schema: "analytics", database: "analytics", tableName: "events" };
it("strips MySQL schema/database when includeDatabaseName is false", () => {
expect(tableMetaWithoutOptionalDatabaseQualifier(mysqlMeta, "mysql", false)).toEqual({ schema: undefined, database: undefined, tableName: "events" });
});
it("keeps MySQL schema when includeDatabaseName is true or unset", () => {
expect(tableMetaWithoutOptionalDatabaseQualifier(mysqlMeta, "mysql", true)).toBe(mysqlMeta);
expect(tableMetaWithoutOptionalDatabaseQualifier(mysqlMeta, "mysql")).toBe(mysqlMeta);
});
it("keeps schema for dialects that require fully qualified names", () => {
expect(tableMetaWithoutOptionalDatabaseQualifier({ schema: "dbo", tableName: "users" }, "sqlserver", false)).toEqual({ schema: "dbo", tableName: "users" });
});
it("matches SELECT-template dropsSchemaQualifier for Oracle/Postgres", () => {
// Same rule as #9110: when the setting is off, optional schema prefixes are
// dropped so the active connection schema applies.
expect(tableMetaWithoutOptionalDatabaseQualifier({ schema: "SCOTT", tableName: "EMP" }, "oracle", false)).toEqual({ schema: undefined, tableName: "EMP" });
expect(tableMetaWithoutOptionalDatabaseQualifier({ schema: "public", tableName: "users" }, "postgres", false)).toEqual({ schema: undefined, tableName: "users" });
});
it("covers the copy-SQL dialects reported in #11195", () => {
// Dameng exposes schemas as databases; a copied INSERT/UPDATE must still be
// able to opt into the schema prefix, so the qualifier only drops when the
// extractor option is off.
const damengMeta = { schema: "SYSDBA", tableName: "PEOPLE" };
expect(tableMetaWithoutOptionalDatabaseQualifier(damengMeta, "dameng", false)).toEqual({ schema: undefined, tableName: "PEOPLE" });
expect(tableMetaWithoutOptionalDatabaseQualifier(damengMeta, "dameng", true)).toBe(damengMeta);
// MySQL family and ClickHouse address tables as database.table.
const clickhouseMeta = { database: "analytics", tableName: "events" };
expect(tableMetaWithoutOptionalDatabaseQualifier(clickhouseMeta, "clickhouse", false)).toEqual({ database: undefined, tableName: "events" });
expect(tableMetaWithoutOptionalDatabaseQualifier(clickhouseMeta, "clickhouse", true)).toBe(clickhouseMeta);
expect(tableMetaWithoutOptionalDatabaseQualifier({ database: "appdb", tableName: "people" }, "goldendb", false)).toEqual({ database: undefined, tableName: "people" });
});
it("returns undefined tableMeta unchanged", () => {
expect(tableMetaWithoutOptionalDatabaseQualifier(undefined, "mysql", false)).toBeUndefined();
});
it("keeps qualifiers for Doris/StarRocks external catalogs", () => {
// External-catalog tables are only addressable as catalog.database.table,
// mirroring the SELECT-template rule in qualifiedTableName.
const externalCatalogMeta = { catalog: "ext", database: "db", tableName: "t" };
expect(tableMetaWithoutOptionalDatabaseQualifier(externalCatalogMeta, "doris", false)).toBe(externalCatalogMeta);
expect(tableMetaWithoutOptionalDatabaseQualifier(externalCatalogMeta, "starrocks", false)).toBe(externalCatalogMeta);
});
it("still strips the internal-catalog database qualifier", () => {
expect(tableMetaWithoutOptionalDatabaseQualifier({ catalog: "internal", database: "db", tableName: "t" }, "doris", false)).toEqual({ catalog: "internal", schema: undefined, database: undefined, tableName: "t" });
});
});
describe("qualifiedTableName — GBase 8s", () => {
it("omits the metadata owner for GBase 8s table data", () => {
expect(qualifiedTableName({ databaseType: "informix", driverProfile: "gbase8s", identifierQuote: "", schema: "gbasedbt", tableName: "connection_smoke" })).toBe("connection_smoke");
expect(qualifiedTableName({ databaseType: "gbase8s", identifierQuote: "", schema: "gbasedbt", tableName: "connection_smoke" })).toBe("connection_smoke");
expect(quoteTableDataIdentifier("informix", "connection_smoke", "")).toBe("connection_smoke");
expect(quoteTableDataIdentifier("gbase8s", "connection_smoke", "")).toBe("connection_smoke");
});
it("keeps native Informix owner qualification", () => {
expect(qualifiedTableName({ databaseType: "informix", identifierQuote: "", schema: "gbasedbt", tableName: "connection_smoke" })).toBe("gbasedbt.connection_smoke");
});
});
describe("quoteTableIdentifier", () => {
it("keeps only required quotes when identifier quoting is disabled", () => {
expect(quoteTableIdentifierIfNeeded("oracle", "DBX_TEST")).toBe("DBX_TEST");
expect(quoteTableIdentifierIfNeeded("oracle", "Order")).toBe('"Order"');
expect(quoteTableIdentifierIfNeeded("oracle", "ORDER")).toBe('"ORDER"');
expect(quoteTableIdentifierIfNeeded("oceanbase-oracle", "DBX_TEST")).toBe("DBX_TEST");
expect(quoteTableIdentifierIfNeeded("oceanbase-oracle", "Order")).toBe('"Order"');
expect(quoteTableIdentifierIfNeeded("oceanbase-oracle", "order_id")).toBe('"order_id"');
expect(quoteTableIdentifierIfNeeded("oceanbase-oracle", "ORDER")).toBe('"ORDER"');
expect(quoteTableIdentifierIfNeeded("dameng", "DBX_TEST")).toBe("DBX_TEST");
expect(quoteTableIdentifierIfNeeded("dameng", "order detail")).toBe('"order detail"');
expect(quoteTableIdentifierIfNeeded("postgres", "dbx_test")).toBe("dbx_test");
expect(quoteTableIdentifierIfNeeded("postgres", "Order")).toBe('"Order"');
expect(quoteTableIdentifierIfNeeded("mysql", "dbx_test")).toBe("dbx_test");
expect(quoteTableIdentifierIfNeeded("mysql", "order")).toBe("`order`");
expect(quoteTableIdentifierIfNeeded("clickhouse", "dbx_test")).toBe("dbx_test");
expect(quoteTableIdentifierIfNeeded("clickhouse", "Order_Test")).toBe("Order_Test");
expect(quoteTableIdentifierIfNeeded("clickhouse", "order")).toBe("`order`");
expect(quoteTableIdentifierIfNeeded("clickhouse", "prewhere")).toBe("`prewhere`");
expect(quoteTableIdentifierIfNeeded("clickhouse", "姓名")).toBe("`姓名`");
expect(quoteTableIdentifierIfNeeded("clickhouse", "时间")).toBe("`时间`");
expect(quoteTableIdentifierIfNeeded("clickhouse", "col$1")).toBe("`col$1`");
});
it("uses a JDBC driver's reported quote for required identifiers", () => {
expect(quoteTableIdentifierIfNeeded("jdbc", "student", '"')).toBe("student");
expect(quoteTableIdentifierIfNeeded("jdbc", "Order", '"')).toBe('"Order"');
expect(quoteTableIdentifierIfNeeded("jdbc", "order detail", "`")).toBe("`order detail`");
});
it("backtick-quotes mysql identifiers", () => {
expect(quoteTableIdentifier("mysql", "orders")).toBe("`orders`");
});
it("backtick-quotes Kyuubi identifiers", () => {
expect(quoteTableIdentifier("kyuubi", "order`items")).toBe("`order``items`");
});
it("backtick-quotes Databricks identifiers", () => {
expect(quoteTableIdentifier("databricks", "order`items")).toBe("`order``items`");
expect(quoteTableDataIdentifier("databricks", "order`items")).toBe("`order``items`");
expect(qualifiedTableName({ databaseType: "databricks", schema: "sales", tableName: "ads_veeva_target_customer_df" })).toBe("`sales`.`ads_veeva_target_customer_df`");
});
it("uses BigQuery quoted identifiers and escape sequences", () => {
expect(quoteTableIdentifier("bigquery", "order")).toBe("`order`");
expect(quoteTableIdentifier("bigquery", "a`b")).toBe("`a\\`b`");
});
it("never quotes Salesforce SOQL identifiers", () => {
// SOQL has no delimited identifiers and reads `"` as a string literal, so the
// grid's ORDER BY / filter must send object and field API names bare — the
// quoted form the backend used to produce failed with MALFORMED_QUERY.
expect(quoteTableIdentifier("salesforce", "Account")).toBe("Account");
expect(quoteTableIdentifier("salesforce", "First_Name__c")).toBe("First_Name__c");
expect(quoteTableDataIdentifier("salesforce", "Account")).toBe("Account");
// An org is a single scope: no schema or database qualifier.
expect(qualifiedTableName({ databaseType: "salesforce", schema: "sales", database: "org", tableName: "Account" })).toBe("Account");
});
it("awaits table metadata before building Salesforce data-preview SQL", () => {
// Without a column list the backend falls back to `FIELDS(ALL)`, which the org
// only accepts with LIMIT 200 or less, so the describe has to land first.
expect(requiresEagerTableMetadataForDataOpen("salesforce")).toBe(true);
expect(requiresEagerTableMetadataForDataOpen("mysql")).toBe(true);
expect(requiresEagerTableMetadataForDataOpen("postgres")).toBe(true);
expect(requiresEagerTableMetadataForDataOpen("oracle")).toBe(true);
expect(requiresEagerTableMetadataForDataOpen("nebula")).toBe(true);
expect(requiresEagerTableMetadataForDataOpen("neo4j")).toBe(true);
// Drivers whose preview works from `SELECT *` keep loading metadata lazily.
expect(requiresEagerTableMetadataForDataOpen("sqlite")).toBe(false);
expect(requiresEagerTableMetadataForDataOpen(undefined)).toBe(false);
});
it("backtick-quotes Cloud Spanner GoogleSQL identifiers by default", () => {
expect(quoteTableIdentifier("spanner", "order")).toBe("`order`");
expect(quoteTableIdentifier("spanner", "a`b")).toBe("`a\\`b`");
});
it("uses the connection-reported quote for Cloud Spanner table-data identifiers", () => {
// GoogleSQL dialect: the agent reports a backtick.
expect(quoteTableDataIdentifier("spanner", "order", "`")).toBe("`order`");
// PostgreSQL dialect: the agent reports a double quote.
expect(quoteTableDataIdentifier("spanner", "MixedCase", '"')).toBe('"MixedCase"');
});
it("keeps Cloud Spanner GoogleSQL names single-segment and qualifies PostgreSQL-dialect names", () => {
// GoogleSQL user schema is the empty string; a two-part name would be a syntax error.
expect(qualifiedTableName({ databaseType: "spanner", schema: "", tableName: "singers", identifierQuote: "`" })).toBe("`singers`");
expect(qualifiedTableName({ databaseType: "spanner", schema: "public", tableName: "singers", identifierQuote: '"' })).toBe('"public"."singers"');
// No reported quote: fall back to the GoogleSQL default.
expect(qualifiedTableName({ databaseType: "spanner", tableName: "singers" })).toBe("`singers`");
});
it("never qualifies a Cloud Spanner table with the resource path", () => {
// The sidebar SQL template path collapses `node.schema || node.database`, and for Spanner the
// database is the resource path, which is not a schema and is not valid inside a table name.
const resourcePath = "projects/p/instances/i/databases/db";
expect(qualifiedTableName({ databaseType: "spanner", schema: resourcePath, database: resourcePath, tableName: "singers", identifierQuote: "`" })).toBe("`singers`");
expect(qualifiedTableName({ databaseType: "spanner", schema: resourcePath, database: resourcePath, tableName: "singers", identifierQuote: '"' })).toBe('"singers"');
expect(qualifiedTableName({ databaseType: "spanner", schema: resourcePath, tableName: "singers" })).toBe("`singers`");
});
it("keeps the Cloud Spanner schema qualifier even before the connection quote loads", () => {
// The quote is fetched asynchronously after connect and can be missing, so the
// branch is unconditional: a named schema must never lose its qualifier.
expect(qualifiedTableName({ databaseType: "spanner", schema: "analytics", tableName: "singers" })).toBe("`analytics`.`singers`");
expect(qualifiedTableName({ databaseType: "spanner", schema: " ", tableName: "singers" })).toBe("`singers`");
});
it("bracket-quotes sqlserver identifiers", () => {
expect(quoteTableIdentifier("sqlserver", "orders")).toBe("[orders]");
});
it("uses the connection-reported quote for Kingbase table-data identifiers", () => {
expect(quoteTableDataIdentifier("kingbase", "order", "`")).toBe("`order`");
expect(quoteTableDataIdentifier("kingbase", "MixedCase", '"')).toBe('"MixedCase"');
expect(quoteTableDataIdentifier("kingbase", "order detail", "`")).toBe("`order detail`");
});
it("selectively quotes GaussDB JDBC identifiers with the driver-reported quote", () => {
expect(quoteTableDataIdentifier("gaussdb", "table_01", '"')).toBe("table_01");
expect(quoteTableDataIdentifier("gaussdb", "MixedCase", '"')).toBe('"MixedCase"');
expect(quoteTableDataIdentifier("gaussdb", "order", '"')).toBe('"order"');
expect(quoteTableDataIdentifier("gaussdb", "order detail", '"')).toBe('"order detail"');
expect(quoteTableDataIdentifier("gaussdb", 'already"quoted', '"')).toBe('"already""quoted"');
expect(quoteTableDataIdentifier("gaussdb", '"AlreadyQuoted"', '"')).toBe('"AlreadyQuoted"');
expect(quoteTableDataIdentifier("gaussdb", "table_01", "`")).toBe("table_01");
expect(quoteTableDataIdentifier("gaussdb", "MixedCase", "`")).toBe("`MixedCase`");
expect(quoteTableDataIdentifier("gaussdb", "order", "`")).toBe("`order`");
expect(quoteTableDataIdentifier("gaussdb", "order detail", "`")).toBe("`order detail`");
expect(quoteTableDataIdentifier("gaussdb", "already`quoted", "`")).toBe("`already``quoted`");
expect(quoteTableDataIdentifier("gaussdb", "`AlreadyQuoted`", "`")).toBe("`AlreadyQuoted`");
});
it("uses detected GaussDB compatibility quotes through PostgreSQL-compatible JDBC dialects", () => {
for (const databaseType of ["postgres", "opengauss"] as const) {
expect(quoteTableDataIdentifier(databaseType, "table_01", "`")).toBe("table_01");
expect(quoteTableDataIdentifier(databaseType, "MixedCase", "`")).toBe("`MixedCase`");
expect(quoteTableDataIdentifier(databaseType, "order", "`")).toBe("`order`");
expect(quoteTableDataIdentifier(databaseType, "order detail", "`")).toBe("`order detail`");
expect(quoteTableDataIdentifier(databaseType, "`AlreadyQuoted`", "`")).toBe("`AlreadyQuoted`");
expect(quoteTableDataIdentifier(databaseType, "MixedCase", '"')).toBe('"MixedCase"');
}
});
it("preserves native GaussDB and openGauss quoting behavior", () => {
expect(quoteTableDataIdentifier("gaussdb", "table_01")).toBe('"table_01"');
expect(quoteTableDataIdentifier("gaussdb", "MixedCase")).toBe('"MixedCase"');
expect(quoteTableDataIdentifier("gaussdb", '"AlreadyQuoted"')).toBe('"AlreadyQuoted"');
expect(quoteTableDataIdentifier("opengauss", "table_01")).toBe('"table_01"');
expect(quoteTableDataIdentifier("opengauss", "MixedCase")).toBe('"MixedCase"');
expect(quoteTableDataIdentifier("opengauss", '"AlreadyQuoted"')).toBe('"AlreadyQuoted"');
});
it("escapes Kingbase identifiers without maintaining a reserved-word list", () => {
expect(quoteTableDataIdentifier("kingbase", "ANALYZE", "`")).toBe("`ANALYZE`");
expect(quoteTableDataIdentifier("kingbase", "AUTHORIZATION", '"')).toBe('"AUTHORIZATION"');
expect(quoteTableDataIdentifier("kingbase", "COLLATE", "`")).toBe("`COLLATE`");
expect(quoteTableDataIdentifier("kingbase", "a`b", "`")).toBe("`a``b`");
});
});