diff --git a/packages/app-tests/connectionUrlPlaceholder.test.ts b/packages/app-tests/connectionUrlPlaceholder.test.ts
deleted file mode 100644
index 24b8b8f102..0000000000
--- a/packages/app-tests/connectionUrlPlaceholder.test.ts
+++ /dev/null
@@ -1,61 +0,0 @@
-import { test } from "vitest";
-import assert from "node:assert/strict";
-import { connectionUrlPlaceholder } from "../../apps/desktop/src/lib/connectionPresentation.ts";
-
-const expected: Record<string, string> = {
-  mysql: "mysql://user:password@host:port/database",
-  doris: "mysql://user:password@host:port/database",
-  starrocks: "mysql://user:password@host:port/database",
-  manticoresearch: "mysql://user:password@host:port/database",
-  postgres: "postgresql://user:password@host:port/database",
-  gaussdb: "postgresql://user:password@host:port/database",
-  kwdb: "postgresql://user:password@host:port/database",
-  redshift: "postgresql://user:password@host:port/database",
-  redis: "redis://:password@host:port/0",
-  sqlite: "sqlite:///absolute/path/to/database.db",
-  rqlite: "http://user:password@host:4001",
-  duckdb: "duckdb:///absolute/path/to/database.duckdb",
-  access: "jdbc:ucanaccess:///absolute/path/to/database.accdb",
-  mongodb: "mongodb://user:password@host:port/database",
-  clickhouse: "clickhouse://user:password@host:port/database",
-  sqlserver: "mssql://user:password@host:port/database",
-  oracle: "oracle://user:password@host:port/service_name",
-  elasticsearch: "http://user:password@host:port",
-  dameng: "dm://user:password@host:port",
-  tdengine: "tdengine://user:password@host:6041/database",
-  xugu: "xugu://user:password@host:5138/database",
-  iotdb: "iotdb://user:password@host:6667/root.test",
-  bigquery: "bigquery://https://www.googleapis.com/bigquery/v2:443/project-id",
-  jdbc: "jdbc:mysql://host:3306/database",
-};
-
-for (const [dbType, placeholder] of Object.entries(expected)) {
-  test(`returns correct placeholder for ${dbType}`, () => {
-    assert.equal(connectionUrlPlaceholder(dbType as any), placeholder);
-  });
-}
-
-test("falls back to postgresql placeholder for unknown type", () => {
-  assert.equal(connectionUrlPlaceholder("unknown" as any), "postgresql://user:password@host:port/database");
-});
-
-test("mysql-family types share the same placeholder", () => {
-  const mysql = connectionUrlPlaceholder("mysql");
-  assert.equal(connectionUrlPlaceholder("doris"), mysql);
-  assert.equal(connectionUrlPlaceholder("starrocks"), mysql);
-  assert.equal(connectionUrlPlaceholder("manticoresearch"), mysql);
-});
-
-test("postgres-family types share the same placeholder", () => {
-  const postgres = connectionUrlPlaceholder("postgres");
-  assert.equal(connectionUrlPlaceholder("gaussdb"), postgres);
-  assert.equal(connectionUrlPlaceholder("kwdb"), postgres);
-  assert.equal(connectionUrlPlaceholder("redshift"), postgres);
-});
-
-test("each placeholder starts with the expected scheme", () => {
-  for (const [dbType, placeholder] of Object.entries(expected)) {
-    const scheme = placeholder.split("://")[0];
-    assert.ok(scheme.length > 0, `${dbType} placeholder should have a scheme`);
-  }
-});
diff --git a/packages/app-tests/connectionVisibleDatabases.test.ts b/packages/app-tests/connectionVisibleDatabases.test.ts
index 5a67afb164..26c851ae79 100644
--- a/packages/app-tests/connectionVisibleDatabases.test.ts
+++ b/packages/app-tests/connectionVisibleDatabases.test.ts
@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { test } from "vitest";
-import { buildDraftVisibleDatabasesConnectionId, connectionCanChooseVisibleDatabases, visibleDatabaseSelectionIsStale, initialVisibleDatabaseSelection } from "../../apps/desktop/src/lib/connectionVisibleDatabases.ts";
+import { buildDraftVisibleDatabasesConnectionId, visibleDatabaseSelectionIsStale, initialVisibleDatabaseSelection } from "../../apps/desktop/src/lib/connectionVisibleDatabases.ts";
 import type { ConnectionConfig } from "../../apps/desktop/src/types/database.ts";
 
 function config(overrides: Partial<ConnectionConfig> = {}): ConnectionConfig {
@@ -40,15 +40,6 @@ test("draft visible database connection ids are namespaced", () => {
   assert.equal(buildDraftVisibleDatabasesConnectionId("abc"), "__visible_draft_abc");
 });
 
-test("visible databases can be chosen for catalog-like connections only", () => {
-  assert.equal(connectionCanChooseVisibleDatabases({ db_type: "mysql" }), true);
-  assert.equal(connectionCanChooseVisibleDatabases({ db_type: "redis" }), true);
-  assert.equal(connectionCanChooseVisibleDatabases({ db_type: "mongodb" }), true);
-  assert.equal(connectionCanChooseVisibleDatabases({ db_type: "oracle" }), true);
-  assert.equal(connectionCanChooseVisibleDatabases({ db_type: "elasticsearch" }), false);
-  assert.equal(connectionCanChooseVisibleDatabases({ db_type: "etcd" }), false);
-});
-
 test("initial selection uses configured visible databases when available", () => {
   assert.deepEqual(initialVisibleDatabaseSelection(["app", "analytics", "billing"], ["billing", "missing"]), ["billing"]);
 });
diff --git a/packages/app-tests/databaseCapabilities.test.ts b/packages/app-tests/databaseCapabilities.test.ts
deleted file mode 100644
index 866001c105..0000000000
--- a/packages/app-tests/databaseCapabilities.test.ts
+++ /dev/null
@@ -1,333 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "vitest";
-import {
-  SCHEMA_AWARE_TYPES,
-  TREE_SCHEMA_TYPES,
-  databaseProductCapabilities,
-  databaseSupportLevel,
-  databaseObjectTreeNodeSchema,
-  databaseObjectTreeQuerySchema,
-  getDatabaseCapability,
-  manifestDatabaseTypes,
-  sidebarObjectKindsForDatabase,
-  supportsDatabaseCreation,
-  supportsDatabaseSearch,
-  supportsDriverManagement,
-  supportsFieldLineage,
-  supportsObjectBrowser,
-  supportsObjectBrowserTreeNode,
-  supportsSchemaDiagram,
-  supportsSqlFileExecution,
-  supportsTableImport,
-  supportsTableTruncate,
-  supportsTableStructureEditing,
-  supportsTransfer,
-  usesDatabaseObjectTreeMode,
-  usesPostgresLikeStructureCopy,
-  usesTreeSchemaMode,
-} from "../../apps/desktop/src/lib/databaseCapabilities.ts";
-
-test("treats Trino catalogs as schema tree roots", () => {
-  assert.equal(TREE_SCHEMA_TYPES.has("trino"), true);
-});
-
-test("treats DB2 databases as schema tree roots", () => {
-  assert.equal(TREE_SCHEMA_TYPES.has("db2"), true);
-  assert.equal(usesTreeSchemaMode("db2"), true);
-});
-
-test("treats TDengine databases as schema tree roots and agent driver databases", () => {
-  assert.equal(TREE_SCHEMA_TYPES.has("tdengine"), true);
-  assert.equal(SCHEMA_AWARE_TYPES.has("tdengine"), true);
-  assert.equal(supportsDriverManagement("tdengine"), true);
-});
-
-test("treats XuguDB as a schema-aware agent driver database", () => {
-  assert.equal(TREE_SCHEMA_TYPES.has("xugu"), true);
-  assert.equal(SCHEMA_AWARE_TYPES.has("xugu"), true);
-  assert.equal(supportsDatabaseSearch("xugu"), true);
-  assert.equal(supportsDriverManagement("xugu"), true);
-});
-
-test("treats IoTDB as a schema-aware agent driver database", () => {
-  assert.equal(TREE_SCHEMA_TYPES.has("iotdb"), true);
-  assert.equal(SCHEMA_AWARE_TYPES.has("iotdb"), true);
-  assert.equal(supportsDatabaseSearch("iotdb"), true);
-  assert.equal(supportsDriverManagement("iotdb"), true);
-});
-
-test("treats Access as a local single-database agent driver", () => {
-  assert.equal(SCHEMA_AWARE_TYPES.has("access"), false);
-  assert.equal(supportsDriverManagement("access"), true);
-  assert.equal(supportsDatabaseSearch("access"), true);
-  assert.equal(supportsTableImport("access"), true);
-});
-
-test("exposes the extended JDBC agent ecosystem through driver management", () => {
-  for (const dbType of ["databricks", "saphana", "teradata", "vertica", "firebird", "exasol", "opengauss", "oceanbase-oracle", "gbase", "questdb"] as const) {
-    assert.equal(supportsDriverManagement(dbType), true, `${dbType} should be agent-managed`);
-    assert.equal(supportsDatabaseSearch(dbType), true, `${dbType} should support database search`);
-  }
-
-  assert.equal(SCHEMA_AWARE_TYPES.has("databricks"), true);
-  assert.equal(SCHEMA_AWARE_TYPES.has("opengauss"), true);
-  assert.equal(SCHEMA_AWARE_TYPES.has("oceanbase-oracle"), true);
-  assert.equal(SCHEMA_AWARE_TYPES.has("firebird"), false);
-});
-
-test("describes schema tree mode through the capability helper", () => {
-  assert.equal(usesTreeSchemaMode("trino"), true);
-  assert.equal(usesTreeSchemaMode("h2"), true);
-  assert.equal(usesTreeSchemaMode("mysql"), false);
-  assert.equal(usesTreeSchemaMode(undefined), false);
-});
-
-test("generic JDBC database nodes list objects directly under catalogs", () => {
-  assert.equal(TREE_SCHEMA_TYPES.has("jdbc"), true);
-  assert.equal(usesDatabaseObjectTreeMode("jdbc"), true);
-  assert.equal(databaseObjectTreeQuerySchema("jdbc", "test"), "");
-  assert.equal(databaseObjectTreeNodeSchema("jdbc", "test"), undefined);
-  assert.equal(databaseObjectTreeQuerySchema("jdbc", "test", "dataeye_starpony"), "");
-  assert.equal(databaseObjectTreeNodeSchema("jdbc", "test", "dataeye_starpony"), undefined);
-});
-
-test("schema tree databases still use database nodes as default schema context", () => {
-  assert.equal(usesDatabaseObjectTreeMode("postgres"), false);
-  assert.equal(databaseObjectTreeQuerySchema("postgres", "app"), "app");
-  assert.equal(databaseObjectTreeNodeSchema("postgres", "app"), "app");
-});
-
-test("treats Trino tables as schema-qualified SQL targets", () => {
-  assert.equal(SCHEMA_AWARE_TYPES.has("trino"), true);
-});
-
-test("describes table editing capabilities for special database engines", () => {
-  assert.deepEqual(getDatabaseCapability("hive").tableData, {
-    insert: true,
-    updateRequiresPrimaryKey: false,
-    deleteRequiresPrimaryKey: false,
-    keylessRowPredicate: true,
-    requiresTransactionalTableForExistingRows: true,
-    transaction: false,
-  });
-
-  assert.deepEqual(getDatabaseCapability("dameng").tableData, {
-    insert: true,
-    updateRequiresPrimaryKey: false,
-    deleteRequiresPrimaryKey: false,
-    keylessRowPredicate: true,
-    requiresTransactionalTableForExistingRows: false,
-    transaction: true,
-  });
-
-  assert.deepEqual(getDatabaseCapability("trino").tableData, {
-    insert: true,
-    updateRequiresPrimaryKey: true,
-    deleteRequiresPrimaryKey: true,
-    keylessRowPredicate: false,
-    requiresTransactionalTableForExistingRows: false,
-    transaction: false,
-  });
-
-  assert.deepEqual(getDatabaseCapability("manticoresearch").tableData, {
-    insert: true,
-    updateRequiresPrimaryKey: false,
-    deleteRequiresPrimaryKey: false,
-    keylessRowPredicate: true,
-    requiresTransactionalTableForExistingRows: false,
-    transaction: false,
-  });
-
-  assert.deepEqual(getDatabaseCapability("jdbc").tableData, {
-    insert: false,
-    updateRequiresPrimaryKey: true,
-    deleteRequiresPrimaryKey: true,
-    keylessRowPredicate: false,
-    requiresTransactionalTableForExistingRows: false,
-    transaction: false,
-  });
-
-  assert.deepEqual(getDatabaseCapability("yashandb").tableData, {
-    insert: true,
-    updateRequiresPrimaryKey: false,
-    deleteRequiresPrimaryKey: false,
-    keylessRowPredicate: true,
-    requiresTransactionalTableForExistingRows: false,
-    transaction: true,
-  });
-
-  assert.equal(getDatabaseCapability("oracle").syntheticKey, "oracle-rowid");
-  assert.equal(getDatabaseCapability("neo4j").syntheticKey, "neo4j-element-id");
-});
-
-test("uses Navicat-style table editing defaults for updateable SQL table engines", () => {
-  assert.deepEqual(getDatabaseCapability("postgres").tableData, {
-    insert: true,
-    updateRequiresPrimaryKey: false,
-    deleteRequiresPrimaryKey: false,
-    keylessRowPredicate: true,
-    requiresTransactionalTableForExistingRows: false,
-    transaction: true,
-  });
-  assert.deepEqual(getDatabaseCapability("mysql").tableData, {
-    insert: true,
-    updateRequiresPrimaryKey: false,
-    deleteRequiresPrimaryKey: false,
-    keylessRowPredicate: true,
-    requiresTransactionalTableForExistingRows: false,
-    transaction: true,
-  });
-  assert.deepEqual(getDatabaseCapability("sqlite").tableData, {
-    insert: true,
-    updateRequiresPrimaryKey: false,
-    deleteRequiresPrimaryKey: false,
-    keylessRowPredicate: true,
-    requiresTransactionalTableForExistingRows: false,
-    transaction: true,
-  });
-  assert.deepEqual(getDatabaseCapability("rqlite").tableData, {
-    insert: true,
-    updateRequiresPrimaryKey: false,
-    deleteRequiresPrimaryKey: false,
-    keylessRowPredicate: true,
-    requiresTransactionalTableForExistingRows: false,
-    transaction: true,
-  });
-  assert.deepEqual(getDatabaseCapability("kwdb").tableData, {
-    insert: true,
-    updateRequiresPrimaryKey: false,
-    deleteRequiresPrimaryKey: false,
-    keylessRowPredicate: true,
-    requiresTransactionalTableForExistingRows: false,
-    transaction: true,
-  });
-  assert.deepEqual(getDatabaseCapability("databend").tableData, {
-    insert: true,
-    updateRequiresPrimaryKey: false,
-    deleteRequiresPrimaryKey: false,
-    keylessRowPredicate: true,
-    requiresTransactionalTableForExistingRows: false,
-    transaction: true,
-  });
-});
-
-test("keeps conservative table editing defaults for unknown database types", () => {
-  assert.deepEqual(getDatabaseCapability(undefined).tableData, {
-    insert: false,
-    updateRequiresPrimaryKey: true,
-    deleteRequiresPrimaryKey: true,
-    keylessRowPredicate: false,
-    requiresTransactionalTableForExistingRows: false,
-    transaction: true,
-  });
-});
-
-test("describes feature support through capability helpers", () => {
-  assert.equal(supportsSqlFileExecution("mysql"), true);
-  assert.equal(supportsSqlFileExecution("redis"), false);
-  assert.equal(supportsSchemaDiagram("oracle"), true);
-  assert.equal(supportsSchemaDiagram("trino"), false);
-  assert.equal(supportsDatabaseSearch("neo4j"), true);
-  assert.equal(supportsDatabaseSearch("redis"), false);
-  assert.equal(supportsTableImport("duckdb"), true);
-  assert.equal(supportsTableImport("hive"), false);
-  assert.equal(supportsTableStructureEditing("postgres"), true);
-  assert.equal(supportsTableStructureEditing("duckdb"), true);
-  assert.equal(supportsTableStructureEditing("oracle"), true);
-  assert.equal(supportsTableStructureEditing("dameng"), true);
-  assert.equal(supportsTableStructureEditing("gaussdb"), true);
-  assert.equal(supportsTableStructureEditing("kwdb"), true);
-  assert.equal(supportsTableStructureEditing("opengauss"), true);
-  assert.equal(supportsTableStructureEditing("redshift"), true);
-  assert.equal(supportsTableStructureEditing("clickhouse"), true);
-  assert.equal(supportsTableStructureEditing("gbase"), true);
-  assert.equal(supportsTableStructureEditing("informix"), true);
-  assert.equal(supportsTableStructureEditing("rqlite"), true);
-  assert.equal(supportsTableStructureEditing("mongodb"), false);
-  assert.equal(supportsTableStructureEditing("manticoresearch"), true);
-  assert.equal(supportsDatabaseCreation("clickhouse"), true);
-  assert.equal(supportsDatabaseCreation("manticoresearch"), false);
-  assert.equal(supportsDatabaseCreation("sqlite"), false);
-  assert.equal(supportsFieldLineage("gaussdb"), true);
-  assert.equal(supportsFieldLineage("kwdb"), true);
-  assert.equal(supportsFieldLineage("trino"), false);
-  assert.equal(supportsTransfer("duckdb"), true);
-  assert.equal(supportsTransfer("hive"), true);
-  assert.equal(supportsTransfer("mongodb"), true);
-  assert.equal(supportsTransfer("manticoresearch"), false);
-  assert.equal(supportsDriverManagement("oracle"), true);
-  assert.equal(supportsDriverManagement("mysql"), false);
-  assert.equal(supportsDriverManagement("manticoresearch"), false);
-  assert.equal(supportsDriverManagement("kwdb"), false);
-  assert.equal(usesPostgresLikeStructureCopy("gaussdb"), true);
-  assert.equal(usesPostgresLikeStructureCopy("kwdb"), true);
-  assert.equal(usesPostgresLikeStructureCopy("mysql"), false);
-  assert.equal(supportsObjectBrowser("mysql"), true);
-  assert.equal(supportsObjectBrowser("manticoresearch"), false);
-  assert.equal(supportsObjectBrowser("mongodb"), false);
-  assert.equal(supportsTableTruncate("mysql"), true);
-  assert.equal(supportsTableTruncate("manticoresearch"), false);
-  assert.equal(supportsTableTruncate("duckdb"), false);
-  assert.equal(supportsTableTruncate("rqlite"), false);
-});
-
-test("loads product support levels and capabilities from the driver manifest", () => {
-  assert.equal(manifestDatabaseTypes().includes("mysql"), true);
-  assert.equal(databaseSupportLevel("mysql"), "operate");
-  assert.equal(databaseSupportLevel("manticoresearch"), "operate");
-  assert.equal(databaseSupportLevel("jdbc"), "browse");
-  assert.equal(databaseSupportLevel("redis"), "connect");
-
-  assert.deepEqual(
-    {
-      metadataBrowse: databaseProductCapabilities("jdbc").metadataBrowse,
-      objectBrowser: databaseProductCapabilities("jdbc").objectBrowser,
-      tableStructureEdit: databaseProductCapabilities("jdbc").tableStructureEdit,
-      userAdmin: databaseProductCapabilities("jdbc").userAdmin,
-    },
-    {
-      metadataBrowse: true,
-      objectBrowser: true,
-      tableStructureEdit: false,
-      userAdmin: false,
-    },
-  );
-
-  assert.deepEqual(
-    {
-      queryExecution: databaseProductCapabilities("manticoresearch").queryExecution,
-      metadataBrowse: databaseProductCapabilities("manticoresearch").metadataBrowse,
-      objectBrowser: databaseProductCapabilities("manticoresearch").objectBrowser,
-      tableDataEdit: databaseProductCapabilities("manticoresearch").tableDataEdit,
-      tableStructureEdit: databaseProductCapabilities("manticoresearch").tableStructureEdit,
-      sqlFileExecution: databaseProductCapabilities("manticoresearch").sqlFileExecution,
-      userAdmin: databaseProductCapabilities("manticoresearch").userAdmin,
-    },
-    {
-      queryExecution: true,
-      metadataBrowse: true,
-      objectBrowser: false,
-      tableDataEdit: true,
-      tableStructureEdit: true,
-      sqlFileExecution: true,
-      userAdmin: false,
-    },
-  );
-});
-
-test("object browser entry follows database tree shape", () => {
-  assert.equal(supportsObjectBrowserTreeNode("postgres", "database"), false);
-  assert.equal(supportsObjectBrowserTreeNode("postgres", "schema"), true);
-  assert.equal(supportsObjectBrowserTreeNode("sqlserver", "database"), true);
-  assert.equal(supportsObjectBrowserTreeNode("sqlserver", "schema"), true);
-  assert.equal(supportsObjectBrowserTreeNode("mysql", "database"), true);
-  assert.equal(supportsObjectBrowserTreeNode("jdbc", "database"), true);
-  assert.equal(supportsObjectBrowserTreeNode("mongodb", "database"), false);
-});
-
-test("sidebar object capability registry describes object groups by database type", () => {
-  assert.deepEqual(sidebarObjectKindsForDatabase("databend"), ["TABLE", "VIEW", "PROCEDURE"]);
-  assert.deepEqual(sidebarObjectKindsForDatabase("manticoresearch"), ["TABLE", "FUNCTION"]);
-  assert.deepEqual(sidebarObjectKindsForDatabase("postgres"), ["TABLE", "VIEW", "PROCEDURE", "FUNCTION", "SEQUENCE"]);
-  assert.deepEqual(sidebarObjectKindsForDatabase("oracle"), ["TABLE", "VIEW", "PROCEDURE", "FUNCTION", "PACKAGE", "PACKAGE_BODY"]);
-});
diff --git a/packages/app-tests/databaseUserAdmin.test.ts b/packages/app-tests/databaseUserAdmin.test.ts
index 2dabc81a2f..4053871aaf 100644
--- a/packages/app-tests/databaseUserAdmin.test.ts
+++ b/packages/app-tests/databaseUserAdmin.test.ts
@@ -23,7 +23,7 @@ import {
   quoteMySqlIdentifier,
   quoteMySqlString,
   quotePostgresIdentifier,
-  supportsDatabaseUserAdmin,
+
   usersFromMySqlGranteeResult,
   usersFromMySqlUserResult,
   usersFromPostgresRolesResult,
@@ -39,15 +39,6 @@ function result(columns: string[], rows: QueryResult["rows"]): QueryResult {
   };
 }
 
-test("detects supported user administration dialects", () => {
-  assert.equal(supportsDatabaseUserAdmin("mysql"), true);
-  assert.equal(supportsDatabaseUserAdmin("goldendb"), true);
-  assert.equal(supportsDatabaseUserAdmin("postgres"), true);
-  assert.equal(supportsDatabaseUserAdmin("opengauss"), true);
-  assert.equal(supportsDatabaseUserAdmin("sqlserver"), false);
-  assert.equal(supportsDatabaseUserAdmin(undefined), false);
-});
-
 test("quotes MySQL account parts and identifiers", () => {
   assert.equal(quoteMySqlString("app'user\\"), "'app''user\\\\'");
   assert.equal(quoteMySqlIdentifier("tenant`01"), "`tenant``01`");
diff --git a/packages/app-tests/tableStructureCapabilities.test.ts b/packages/app-tests/tableStructureCapabilities.test.ts
deleted file mode 100644
index 5b87bae73c..0000000000
--- a/packages/app-tests/tableStructureCapabilities.test.ts
+++ /dev/null
@@ -1,160 +0,0 @@
-import assert from "node:assert/strict";
-import { test } from "vitest";
-import { canAddTableStructureColumn, canEditTableStructure, getTableStructureCapabilities } from "../../apps/desktop/src/lib/tableStructureCapabilities.ts";
-
-test("sqlite-family and duckdb do not support table comments", () => {
-  for (const dbType of ["sqlite", "rqlite", "duckdb"] as const) {
-    const caps = getTableStructureCapabilities(dbType);
-    assert.equal(caps.comment, false, `${dbType} should not support comments`);
-    assert.equal(caps.createTable, true, `${dbType} should still support creating tables`);
-  }
-});
-
-test("postgres-like databases expose safe structure editing capabilities", () => {
-  for (const dbType of ["postgres", "gaussdb", "kwdb", "opengauss", "highgo", "vastbase", "kingbase"] as const) {
-    const caps = getTableStructureCapabilities(dbType);
-    assert.equal(caps.dialect, "postgres", `${dbType} should reuse postgres DDL`);
-    assert.equal(caps.createTable, true, `${dbType} should create tables`);
-    assert.equal(caps.addColumn, true, `${dbType} should add columns`);
-    assert.equal(caps.dropColumn, true, `${dbType} should drop columns`);
-    assert.equal(caps.renameColumn, true, `${dbType} should rename columns`);
-    assert.equal(caps.alterExistingColumn, true, `${dbType} should edit existing columns`);
-    assert.equal(caps.comment, true, `${dbType} should support comments`);
-    assert.equal(caps.createIndex, true, `${dbType} should create indexes`);
-    assert.equal(caps.dropIndex, true, `${dbType} should drop indexes`);
-    assert.equal(caps.rebuildIndex, true, `${dbType} should rebuild indexes`);
-    assert.equal(caps.indexFilter, true, `${dbType} should support filtered indexes`);
-    assert.equal(canEditTableStructure(dbType), true);
-  }
-});
-
-test("mysql-like databases expose index rebuild and type capabilities", () => {
-  for (const dbType of ["mysql", "doris", "starrocks", "goldendb", "sundb"] as const) {
-    const caps = getTableStructureCapabilities(dbType);
-    assert.equal(caps.dialect, "mysql", `${dbType} should reuse mysql DDL`);
-    assert.equal(caps.createIndex, true);
-    assert.equal(caps.dropIndex, true);
-    assert.equal(caps.rebuildIndex, true);
-    assert.equal(caps.indexType, true);
-    assert.equal(caps.reorderColumn, true);
-    assert.equal(canEditTableStructure(dbType), true);
-  }
-});
-
-test("gbase 8a exposes limited mysql-compatible structure editing capabilities", () => {
-  const caps = getTableStructureCapabilities("gbase");
-  assert.equal(caps.dialect, "mysql");
-  assert.equal(caps.createTable, true);
-  assert.equal(caps.addColumn, true);
-  assert.equal(caps.dropColumn, true);
-  assert.equal(caps.renameColumn, true);
-  assert.equal(caps.alterExistingColumn, false);
-  assert.equal(caps.createIndex, false);
-  assert.equal(caps.dropIndex, false);
-  assert.equal(caps.rebuildIndex, false);
-  assert.equal(caps.comment, false);
-  assert.equal(canEditTableStructure("gbase"), true);
-});
-
-test("redshift reuses postgres column DDL but keeps indexes disabled", () => {
-  const caps = getTableStructureCapabilities("redshift");
-  assert.equal(caps.dialect, "postgres");
-  assert.equal(caps.createTable, true);
-  assert.equal(caps.addColumn, true);
-  assert.equal(caps.dropColumn, true);
-  assert.equal(caps.renameColumn, true);
-  assert.equal(caps.alterExistingColumn, true);
-  assert.equal(caps.comment, true);
-  assert.equal(caps.createIndex, false);
-  assert.equal(caps.dropIndex, false);
-  assert.equal(caps.rebuildIndex, false);
-  assert.equal(caps.indexFilter, false);
-  assert.equal(canEditTableStructure("redshift"), true);
-});
-
-test("oracle-like databases expose oracle-compatible structure editing capabilities", () => {
-  for (const dbType of ["oracle", "dameng", "oceanbase-oracle"] as const) {
-    const caps = getTableStructureCapabilities(dbType);
-    assert.equal(caps.dialect, "oracle", `${dbType} should reuse oracle DDL`);
-    assert.equal(caps.createTable, true);
-    assert.equal(caps.addColumn, true);
-    assert.equal(caps.dropColumn, true);
-    assert.equal(caps.renameColumn, true);
-    assert.equal(caps.alterExistingColumn, true);
-    assert.equal(caps.comment, true);
-    assert.equal(caps.createIndex, true);
-    assert.equal(caps.dropIndex, true);
-    assert.equal(caps.rebuildIndex, true);
-    assert.equal(caps.reorderColumn, false);
-    assert.equal(canEditTableStructure(dbType), true);
-  }
-});
-
-test("limited analytic engines can open the editor for supported operations only", () => {
-  const clickhouse = getTableStructureCapabilities("clickhouse");
-  assert.equal(clickhouse.dialect, "clickhouse");
-  assert.equal(clickhouse.createTable, true);
-  assert.equal(clickhouse.addColumn, true);
-  assert.equal(clickhouse.dropColumn, true);
-  assert.equal(clickhouse.renameColumn, true);
-  assert.equal(clickhouse.alterExistingColumn, true);
-  assert.equal(clickhouse.alterType, true);
-  assert.equal(clickhouse.alterNullability, true);
-  assert.equal(clickhouse.alterDefault, true);
-  assert.equal(clickhouse.reorderColumn, true);
-  assert.equal(clickhouse.comment, true);
-  assert.equal(clickhouse.createIndex, false);
-  assert.equal(clickhouse.rebuildIndex, false);
-  assert.equal(canEditTableStructure("clickhouse"), true);
-});
-
-test("manticore search can open the editor for limited table structure changes", () => {
-  const caps = getTableStructureCapabilities("manticoresearch");
-  assert.equal(caps.dialect, "mysql");
-  assert.equal(caps.createTable, true);
-  assert.equal(caps.addColumn, true);
-  assert.equal(caps.dropColumn, true);
-  assert.equal(caps.renameColumn, false);
-  assert.equal(caps.alterExistingColumn, false);
-  assert.equal(caps.createIndex, false);
-  assert.equal(caps.dropIndex, false);
-  assert.equal(canEditTableStructure("manticoresearch"), true);
-  assert.equal(canAddTableStructureColumn("manticoresearch", true), true);
-  assert.equal(canAddTableStructureColumn("manticoresearch", false), true);
-});
-
-test("manticore search keeps generic index DDL disabled", () => {
-  const caps = getTableStructureCapabilities("manticoresearch");
-  assert.equal(caps.createIndex, false);
-  assert.equal(caps.dropIndex, false);
-  assert.equal(caps.rebuildIndex, false);
-  assert.equal(caps.indexType, false);
-  assert.equal(caps.indexInclude, false);
-  assert.equal(caps.indexFilter, false);
-  assert.equal(caps.indexComment, false);
-});
-
-test("informix exposes conservative structure editing capabilities", () => {
-  const caps = getTableStructureCapabilities("informix");
-  assert.equal(caps.dialect, "informix");
-  assert.equal(caps.createTable, true);
-  assert.equal(caps.addColumn, true);
-  assert.equal(caps.dropColumn, true);
-  assert.equal(caps.renameColumn, true);
-  assert.equal(caps.alterExistingColumn, true);
-  assert.equal(caps.comment, false);
-  assert.equal(caps.createIndex, true);
-  assert.equal(caps.dropIndex, true);
-  assert.equal(caps.rebuildIndex, true);
-  assert.equal(caps.indexType, false);
-  assert.equal(caps.alterPrimaryKey, false);
-  assert.equal(canEditTableStructure("informix"), true);
-});
-
-test("unsupported non-relational databases do not open the structure editor", () => {
-  for (const dbType of ["redis", "mongodb", "elasticsearch", "neo4j", undefined] as const) {
-    const caps = getTableStructureCapabilities(dbType);
-    assert.equal(caps.dialect, "unsupported");
-    assert.equal(canEditTableStructure(dbType), false);
-  }
-});