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。

30.3 KB
Raw Blame
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`");
  });
});