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。

145 KB
Raw Blame
import { createPinia, setActivePinia } from "pinia";
import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
import { saveVirtualRowIdentifier } from "@/lib/table/virtualRowIdentifier";

const apiMocks = vi.hoisted(() => ({
  localStorageValues: new Map<string, string>(),
  executeMulti: vi.fn(),
  executeQuery: vi.fn(),
  beginManualTransaction: vi.fn(),
  executeInManualTransaction: vi.fn(),
  closeQuerySession: vi.fn().mockResolvedValue(false),
  closeClientConnectionSession: vi.fn().mockResolvedValue(false),
  cancelQuery: vi.fn(),
  analyzeEditableQueryEditability: vi.fn(),
  getColumns: vi.fn(),
  listIndexes: vi.fn(),
  listObjects: vi.fn(),
  listTables: vi.fn(),
  getConnectionConfig: vi.fn(),
  lookupLocalCompletionTables: vi.fn(),
  buildSortedQuerySql: vi.fn(),
  buildDataGridCountSql: vi.fn(),
  prepareQueryPaginationExecutionPlan: vi.fn(async (options: { sql: string }) => ({
    sqlToExecute: options.sql,
    pageSql: undefined,
    pageLimit: undefined,
    pageOffset: undefined,
    countSql: undefined,
    useAgentResultSession: false,
  })),
  editorSettings: {
    pageSize: 100,
    autoCalculateTotalRows: false,
    queryResultMaxRowsEnabled: true,
    queryResultMaxRows: 100_000,
  },
}));
const {
  localStorageValues,
  executeMulti,
  executeQuery,
  beginManualTransaction,
  executeInManualTransaction,
  closeQuerySession,
  closeClientConnectionSession,
  cancelQuery,
  analyzeEditableQueryEditability,
  getColumns,
  listIndexes,
  listObjects,
  listTables,
  getConnectionConfig,
  lookupLocalCompletionTables,
  buildSortedQuerySql,
  buildDataGridCountSql,
  prepareQueryPaginationExecutionPlan,
  editorSettings,
} = apiMocks;
vi.stubGlobal("localStorage", {
  getItem: (key: string) => localStorageValues.get(key) ?? null,
  setItem: (key: string, value: string) => localStorageValues.set(key, value),
  removeItem: (key: string) => localStorageValues.delete(key),
});

function deferred<T>() {
  let resolve!: (value: T) => void;
  const promise = new Promise<T>((done) => {
    resolve = done;
  });
  return { promise, resolve };
}

vi.mock("@/lib/backend/api", () => ({
  analyzeEditableQueryEditability: apiMocks.analyzeEditableQueryEditability,
  buildDataGridCountSql: apiMocks.buildDataGridCountSql,
  buildSortedQuerySql: apiMocks.buildSortedQuerySql,
  closeClientConnectionSession: apiMocks.closeClientConnectionSession,
  closeQuerySession: apiMocks.closeQuerySession,
  beginManualTransaction: apiMocks.beginManualTransaction,
  cancelQuery: apiMocks.cancelQuery,
  executeInManualTransaction: apiMocks.executeInManualTransaction,
  executeMulti: apiMocks.executeMulti,
  executeQuery: apiMocks.executeQuery,
  getColumns: apiMocks.getColumns,
  listIndexes: apiMocks.listIndexes,
  listObjects: apiMocks.listObjects,
  listTables: apiMocks.listTables,
  prepareQueryPaginationExecutionPlan: apiMocks.prepareQueryPaginationExecutionPlan,
  saveOpenTabsState: vi.fn().mockResolvedValue(undefined),
}));

vi.mock("@/stores/connectionStore", () => ({
  useConnectionStore: () => ({
    ensureConnected: vi.fn().mockResolvedValue(undefined),
    getConfig: apiMocks.getConnectionConfig,
    lookupLocalCompletionTables: apiMocks.lookupLocalCompletionTables,
    recordConnectionLostError: vi.fn(),
    // 与真实 store 一致:setTableMeta 写入 tableMeta 时记录连接元数据代次
    metadataGenerationFor: () => 0,
  }),
}));

vi.mock("@/stores/settingsStore", () => ({
  useSettingsStore: () => ({
    editorSettings: apiMocks.editorSettings,
  }),
}));

function queryAnalysis(sql: string) {
  const hidden = sql.includes("__DBX_PK_0");
  return {
    editable: true,
    analysis: {
      schema: undefined,
      tableName: "users",
      selectStar: false,
      columns: [{ sourceName: "name", resultName: "name", expression: "name" }, ...(hidden ? [{ sourceName: "id", resultName: "__DBX_PK_0", expression: "`id`" }] : [])],
    },
  };
}

describe("queryStore hidden primary key editing", () => {
  beforeEach(async () => {
    vi.clearAllMocks();
    closeQuerySession.mockResolvedValue(false);
    closeClientConnectionSession.mockResolvedValue(false);
    localStorageValues.clear();
    const { clearTableMetadataCache } = await import("@/lib/metadata/tableMetadataCache");
    clearTableMetadataCache();
    setActivePinia(createPinia());
    getConnectionConfig.mockReturnValue({ id: "mysql-1", name: "MySQL", db_type: "mysql", database: "app", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "name", data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    listIndexes.mockResolvedValue([]);
    listObjects.mockResolvedValue([]);
    listTables.mockResolvedValue([]);
    lookupLocalCompletionTables.mockReturnValue([]);
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => queryAnalysis(sql));
    buildSortedQuerySql.mockImplementation(async (options) => ({ ok: true, sql: `${options.originalSql} ORDER BY ${options.column} ${options.direction.toUpperCase()}` }));
    buildDataGridCountSql.mockResolvedValue("SELECT COUNT(*) FROM `users`");
    prepareQueryPaginationExecutionPlan.mockImplementation(async (options) => ({
      sqlToExecute: options.sql,
      pageSql: undefined,
      pageLimit: undefined,
      pageOffset: undefined,
      countSql: undefined,
      useAgentResultSession: false,
    }));
    editorSettings.pageSize = 100;
    editorSettings.autoCalculateTotalRows = false;
    editorSettings.queryResultMaxRowsEnabled = true;
    editorSettings.queryResultMaxRows = 100_000;
    executeQuery.mockResolvedValue({
      columns: ["row_count"],
      rows: [[0]],
      affected_rows: 0,
      execution_time_ms: 1,
    });
    cancelQuery.mockResolvedValue(false);
    executeMulti.mockResolvedValue([
      {
        columns: ["name", "__DBX_PK_0"],
        rows: [["Alice", 7]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);
    beginManualTransaction.mockResolvedValue("txn-1");
    executeInManualTransaction.mockResolvedValue([
      {
        columns: ["name", "__DBX_PK_0"],
        rows: [["Alice", 7]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);
  });

  afterEach(() => {
    expect(listObjects).not.toHaveBeenCalled();
  });

  it("executes and hides an omitted primary key while retaining its source mapping", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "Query");

    await store.executeTabSql(tabId, "SELECT name FROM users");

    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "app", "SELECT name, `id` AS `__DBX_PK_0` FROM users", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.result?.hidden_column_indexes).toEqual([1]);
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["name", "id"]));
    expect(tab.queryAnalysis).toBeDefined();
    expect(tab.queryAnalysis?.allowInsert).toBe(false);
    expect(tab.queryEditabilityReason).toBeUndefined();
  }, 10_000);

  it("falls back to the original SQL for non-Oracle databases when editability metadata exceeds the preflight budget", async () => {
    // 慢元数据:列/索引加载永不在预算内返回,触发对所有数据库统一施加的 1s preflight 预算超时。
    // 泛化前仅 Oracle/Xugu 有此预算,MySQL 等会被慢元数据阻塞到结果显示。
    getColumns.mockReturnValue(deferred<never[]>().promise);
    listIndexes.mockReturnValue(deferred<never[]>().promise);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "Query");

    await store.executeTabSql(tabId, "SELECT name FROM users");

    // 预算超时后先出结果:执行原始 SQL、未注入隐藏主键(可编辑能力随后台加载补齐)。
    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "app", "SELECT name FROM users", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
  }, 10_000);

  it.each((["dameng", "jdbc"] as const).flatMap((dbType) => [true, false].flatMap((autoCommit) => [true, false].map((returnsPrimaryKey) => ({ dbType, autoCommit, returnsPrimaryKey })))))(
    "dispatches cold Dameng SQL before metadata with $dbType, autoCommit=$autoCommit, returnsPrimaryKey=$returnsPrimaryKey",
    async ({ dbType, autoCommit, returnsPrimaryKey }) => {
      const columnsGate = deferred<Awaited<ReturnType<typeof getColumns>>>();
      const resultGate = deferred<Awaited<ReturnType<typeof executeMulti>>>();
      getConnectionConfig.mockReturnValue({ id: "dameng-1", name: "Dameng", db_type: dbType, driver_profile: "dameng", database: "SYSDBA", query_timeout_secs: 30 });
      const columns = [
        { name: "ID", data_type: "INT", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
        { name: "NAME", data_type: "VARCHAR(50)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
      ];
      const resultColumns = returnsPrimaryKey ? ["ID", "NAME"] : ["NAME"];
      const sql = `SELECT ${resultColumns.join(", ")} FROM APP.USERS`;
      analyzeEditableQueryEditability.mockResolvedValue({
        editable: true,
        analysis: { schema: "APP", tableName: "USERS", selectStar: false, columns: resultColumns.map((name) => ({ sourceName: name, resultName: name, expression: name })) },
      });
      getColumns.mockReturnValue(columnsGate.promise);
      executeMulti.mockReturnValue(resultGate.promise);
      executeInManualTransaction.mockReturnValue(resultGate.promise);

      const { useQueryStore } = await import("@/stores/queryStore");
      const store = useQueryStore();
      const tabId = store.createTab("dameng-1", "SYSDBA", "Query");
      store.setAutoCommit(tabId, autoCommit);
      const tab = store.tabs.find((item) => item.id === tabId)!;
      const execution = store.executeTabSql(tabId, sql);
      const dispatch = autoCommit ? executeMulti : executeInManualTransaction;
      await vi.waitFor(() => expect(dispatch).toHaveBeenCalledOnce());
      expect(dispatch.mock.calls[0]?.[autoCommit ? 2 : 1]).toBe(sql);
      expect(getColumns).not.toHaveBeenCalled();
      expect(listIndexes).not.toHaveBeenCalled();

      resultGate.resolve([{ columns: resultColumns, rows: [returnsPrimaryKey ? [1, "Alice"] : ["Alice"]], affected_rows: 0, execution_time_ms: 1 }]);
      await execution;
      expect(tab.isExecuting).toBe(false);
      expect(tab.result?.columns).toEqual(resultColumns);
      expect(tab.queryAnalysis).toBeUndefined();
      await vi.waitFor(() => expect(getColumns).toHaveBeenCalledOnce());

      columnsGate.resolve(columns);
      await vi.waitFor(() => expect(tab.tableMeta?.primaryKeys).toEqual(["ID"]));
      expect(tab.result?.columns).toEqual(resultColumns);
      if (returnsPrimaryKey) {
        expect(tab.queryAnalysis).toBeDefined();
        expect(tab.queryEditabilityReason).toBeUndefined();
      } else {
        expect(tab.queryAnalysis).toBeUndefined();
        expect(tab.queryEditabilityReason).toBe("primary-key-not-returned");
      }
    },
  );

  it("does not apply delayed Dameng metadata to a newer result", async () => {
    const firstColumns = deferred<Awaited<ReturnType<typeof getColumns>>>();
    const columns = [
      { name: "ID", data_type: "INT", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "NAME", data_type: "VARCHAR(50)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ];
    getConnectionConfig.mockReturnValue({ id: "dameng-1", name: "Dameng", db_type: "dameng", database: "SYSDBA", query_timeout_secs: 30 });
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => ({
      editable: true,
      analysis: { schema: "APP", tableName: sql.includes("ARCHIVE") ? "ARCHIVE" : "USERS", selectStar: false, columns: ["ID", "NAME"].map((name) => ({ sourceName: name, resultName: name, expression: name })) },
    }));
    getColumns.mockImplementation((_connectionId: string, _database: string, _schema: string, table: string) => (table === "USERS" ? firstColumns.promise : Promise.resolve(columns)));
    executeMulti.mockResolvedValueOnce([{ columns: ["ID", "NAME"], rows: [[1, "Alice"]], affected_rows: 0, execution_time_ms: 1 }]);
    executeMulti.mockResolvedValueOnce([{ columns: ["ID", "NAME"], rows: [[2, "Bob"]], affected_rows: 0, execution_time_ms: 1 }]);
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("dameng-1", "SYSDBA", "Query");
    store.setAutoCommit(tabId, true);
    const tab = store.tabs.find((item) => item.id === tabId)!;

    await store.executeTabSql(tabId, "SELECT ID, NAME FROM APP.USERS");
    await vi.waitFor(() => expect(getColumns).toHaveBeenCalledOnce());
    await store.executeTabSql(tabId, "SELECT ID, NAME FROM APP.ARCHIVE");
    await vi.waitFor(() => expect(tab.tableMeta?.tableName).toBe("ARCHIVE"));
    const newerMetadata = tab.tableMeta;

    firstColumns.resolve(columns);
    const { loadTableMetadata } = await import("@/lib/metadata/tableMetadataCache");
    await loadTableMetadata({ connectionId: "dameng-1", database: "SYSDBA", schema: "APP", tableName: "USERS", databaseType: "dameng" });
    expect(tab.tableMeta).toBe(newerMetadata);
    expect(tab.tableMeta?.tableName).toBe("ARCHIVE");
    expect(tab.result?.rows).toEqual([[2, "Bob"]]);
    expect(tab.queryEditabilityReason).toBeUndefined();
  });

  it("keeps a successful Dameng result available when background metadata fails", async () => {
    getConnectionConfig.mockReturnValue({ id: "dameng-1", name: "Dameng", db_type: "dameng", database: "SYSDBA", query_timeout_secs: 30 });
    getColumns.mockRejectedValue(new Error("dictionary unavailable"));
    executeMulti.mockResolvedValue([{ columns: ["name"], rows: [["Alice"]], affected_rows: 0, execution_time_ms: 1 }]);
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("dameng-1", "SYSDBA", "Query");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "SELECT name FROM users");
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.queryEditabilityReason).toBe("metadata-unavailable"));
    expect(tab.isExecuting).toBe(false);
    expect(tab.error).toBeUndefined();
    expect(tab.result?.rows).toEqual([["Alice"]]);
    expect(tab.queryAnalysis).toBeUndefined();
  });

  it("appends the cached hidden primary key for Dameng tables whose columns keep the created case", async () => {
    // #10233: Dameng keeps the case an unquoted identifier was created with, so the
    // server reports `name` while the Oracle-family dialect handling folds the SQL
    // token to `NAME`. The binding has to survive that mismatch, otherwise the result
    // stays read-only even though the table has a primary key.
    getConnectionConfig.mockReturnValue({ id: "dameng-1", name: "Dameng", db_type: "dameng", database: "SYSDBA", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "id", data_type: "INT", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "name", data_type: "VARCHAR(50)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    // Mirror what the analyzer reports for this dialect: the user's unquoted token
    // keeps its spelling and quoting flag (the store then folds it, like the real
    // Oracle-family path), while the hidden key dbx appends is quoted as `"id"`.
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => ({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "users",
        selectStar: false,
        columns: [{ sourceName: "name", sourceNameQuoted: false, resultName: "name", expression: "name" }, ...(sql.includes("__DBX_PK_0") ? [{ sourceName: "id", sourceNameQuoted: true, resultName: "__DBX_PK_0", expression: '"id"' }] : [])],
      },
    }));

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("dameng-1", "SYSDBA", "Query");
    executeMulti.mockResolvedValueOnce([{ columns: ["name"], rows: [["Alice"]], affected_rows: 0, execution_time_ms: 1 }]);

    await store.executeTabSql(tabId, "SELECT name FROM users");
    expect(executeMulti).toHaveBeenCalledWith("dameng-1", "SYSDBA", "SELECT name FROM users", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    await vi.waitFor(() => expect(store.tabs.find((item) => item.id === tabId)?.queryEditabilityReason).toBe("primary-key-not-returned"));

    await store.executeTabSql(tabId, "SELECT name FROM users");

    expect(executeMulti).toHaveBeenLastCalledWith("dameng-1", "SYSDBA", 'SELECT name, "id" AS "__DBX_PK_0" FROM users', undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.result?.hidden_column_indexes).toEqual([1]);
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["name", "id"]));
    expect(tab.queryEditabilityReason).toBeUndefined();
  }, 10_000);

  it("keeps MySQL expression columns read-only without disabling direct columns", async () => {
    const sql = "SELECT id, status, extra->>'$.mode' mode, extra->>'$.template' tmpl FROM items";
    getColumns.mockResolvedValue([
      { name: "id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "status", data_type: "varchar", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
      { name: "extra", data_type: "json", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "items",
        selectStar: false,
        columns: [
          { sourceName: "id", resultName: "id", expression: "id" },
          { sourceName: "status", resultName: "status", expression: "status" },
          { sourceName: undefined, resultName: "mode", expression: "extra->>'$.mode'" },
          { sourceName: undefined, resultName: "tmpl", expression: "extra->>'$.template'" },
        ],
      },
    });
    executeMulti.mockResolvedValue([{ columns: ["id", "status", "mode", "tmpl"], rows: [[1, "ok", "fast", "base"]], affected_rows: 0, execution_time_ms: 1 }]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "Query");

    await store.executeTabSql(tabId, sql);

    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["id", "status", undefined, undefined]));
    expect(tab.queryEditabilityReason).toBeUndefined();
    expect(getColumns).toHaveBeenCalledTimes(1);
    expect(listObjects).not.toHaveBeenCalled();
  });

  it("starts a qualified MySQL star query before slow column metadata finishes", async () => {
    const columnsGate = deferred<Awaited<ReturnType<typeof getColumns>>>();
    getColumns.mockReturnValue(columnsGate.promise);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "sys_dept",
        selectStar: true,
        columns: [],
      },
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["dept_id", "dept_name"],
        rows: [[1, "Headquarters"]],
        affected_rows: 0,
        execution_time_ms: 12,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "Query");

    const execution = store.executeTabSql(tabId, "SELECT sys_dept.* FROM sys_dept");
    await vi.waitFor(() => expect(executeMulti).toHaveBeenCalled());
    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "app", "SELECT sys_dept.* FROM sys_dept", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));

    columnsGate.resolve([
      { name: "dept_id", data_type: "bigint", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "dept_name", data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    await execution;
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.tableMeta?.tableName).toBe("sys_dept"));
  });

  it("loads metadata from the connection default database when the query tab database is empty", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "", "Query");

    await store.executeTabSql(tabId, "SELECT name FROM users");

    expect(getColumns).toHaveBeenCalledWith("mysql-1", "app", "app", "users", undefined);
    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "", "SELECT name, `id` AS `__DBX_PK_0` FROM users", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["name", "id"]));
    expect(tab.tableMeta?.database).toBe("app");
    expect(tab.queryEditabilityReason).toBeUndefined();
  });

  it("keeps insert disabled when a MySQL table has a physical primary key named like DBX ROWID", async () => {
    getColumns.mockResolvedValue([
      { name: "__DBX_ROWID", data_type: "varchar", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "name", data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => ({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "users",
        selectStar: false,
        columns: [{ sourceName: "name", resultName: "name", expression: "name" }, ...(sql.includes("__DBX_PK_0") ? [{ sourceName: "__DBX_ROWID", resultName: "__DBX_PK_0", expression: "`__DBX_ROWID`" }] : [])],
      },
    }));

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "Query");

    await store.executeTabSql(tabId, "SELECT name FROM users");

    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["name", "__DBX_ROWID"]));
    expect(tab.queryAnalysis?.allowInsert).toBe(false);
  });

  it("uses the connection default database for SQL library tabs without a saved database", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.openSavedSql({
      id: "saved-1",
      connectionId: "mysql-1",
      name: "users.sql",
      database: "",
      sql: "SELECT name FROM users",
      createdAt: "2026-07-21T00:00:00.000Z",
      updatedAt: "2026-07-21T00:00:00.000Z",
    });

    await store.executeTabSql(tabId, "SELECT name FROM users");

    expect(getColumns).toHaveBeenCalledWith("mysql-1", "app", "app", "users", undefined);
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["name", "id"]));
    expect(tab.queryEditabilityReason).toBeUndefined();
  });

  it("preserves JDBC catalog metadata lookup when the tab uses the connection default database", async () => {
    getConnectionConfig.mockReturnValue({ id: "jdbc-1", name: "JDBC MySQL", db_type: "jdbc", connection_string: "jdbc:mysql://localhost:3306/app", database: "app", query_timeout_secs: 30 });
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("jdbc-1", "", "Query");

    await store.executeTabSql(tabId, "SELECT name FROM users");

    expect(getColumns).toHaveBeenCalledWith("jdbc-1", "app", "", "users", undefined);
    expect(executeMulti).toHaveBeenCalledWith("jdbc-1", "", "SELECT name, `id` AS `__DBX_PK_0` FROM users", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["name", "id"]));
    expect(tab.queryEditabilityReason).toBeUndefined();
  });

  it("starts a MySQL JDBC star query before slow column metadata finishes", async () => {
    const columnsGate = deferred<Awaited<ReturnType<typeof getColumns>>>();
    getConnectionConfig.mockReturnValue({ id: "jdbc-1", name: "JDBC MySQL", db_type: "jdbc", connection_string: "jdbc:mysql://localhost:3306/app", database: "app", query_timeout_secs: 30 });
    getColumns.mockReturnValue(columnsGate.promise);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "sys_dept",
        selectStar: true,
        columns: [],
      },
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["dept_id", "dept_name"],
        rows: [[1, "Headquarters"]],
        affected_rows: 0,
        execution_time_ms: 12,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("jdbc-1", "", "Query");

    const execution = store.executeTabSql(tabId, "SELECT * FROM sys_dept");
    await vi.waitFor(() => expect(executeMulti).toHaveBeenCalled());
    expect(executeMulti).toHaveBeenCalledWith("jdbc-1", "", "SELECT * FROM sys_dept", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));

    columnsGate.resolve([
      { name: "dept_id", data_type: "bigint", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "dept_name", data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    await execution;
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.tableMeta?.tableName).toBe("sys_dept"));
  });

  it("keeps an explicitly selected database instead of falling back to the connection default", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "analytics", "Query");

    await store.executeTabSql(tabId, "SELECT name FROM users");

    expect(getColumns).toHaveBeenCalledWith("mysql-1", "analytics", "analytics", "users", undefined);
    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "analytics", "SELECT name, `id` AS `__DBX_PK_0` FROM users", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
  });

  it("loads metadata from a MySQL cross-database qualified source", async () => {
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => {
      const hidden = sql.includes("__DBX_PK_0");
      return {
        editable: true,
        analysis: {
          schema: "reporting",
          tableName: "users",
          selectStar: false,
          columns: [{ sourceName: "name", resultName: "name", expression: "name" }, ...(hidden ? [{ sourceName: "id", resultName: "__DBX_PK_0", expression: "`id`" }] : [])],
        },
      };
    });
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "Query");

    await store.executeTabSql(tabId, "SELECT name FROM reporting.users");

    expect(getColumns).toHaveBeenCalledWith("mysql-1", "app", "reporting", "users", undefined);
    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "app", "SELECT name, `id` AS `__DBX_PK_0` FROM reporting.users", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["name", "id"]));
    expect(tab.tableMeta?.database).toBe("app");
    expect(tab.tableMeta?.schema).toBe("reporting");
  });

  it("executes a constant projection without waiting for Oracle table metadata", async () => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([{ name: "DUMMY", data_type: "VARCHAR2(1)", is_nullable: true, column_default: null, is_primary_key: false, extra: null }]);
    listIndexes.mockResolvedValue([]);
    listTables.mockReturnValue(new Promise(() => undefined));
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "DUAL",
        selectStar: false,
        columns: [{ resultName: "1", expression: "1" }],
      },
    });
    const result = [{ columns: ["1"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 }];
    const executionGate = deferred<typeof result>();
    executeMulti.mockReturnValue(executionGate.promise);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    store.setAutoCommit(tabId, true);
    const sql = "SELECT 1 FROM DUAL";

    const execution = store.executeTabSql(tabId, sql);
    await vi.waitFor(() => expect(executeMulti).toHaveBeenCalled(), { timeout: 250 });

    expect(executeMulti).toHaveBeenCalledWith("oracle-1", "ORCL", sql, undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    expect(getColumns).not.toHaveBeenCalled();
    expect(listIndexes).not.toHaveBeenCalled();
    expect(listTables).not.toHaveBeenCalled();

    executionGate.resolve(result);
    await execution;
  });

  it("uses a hidden Oracle ROWID to keep keyless base-table query results editable", async () => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
      { name: "PLATFORM", data_type: "VARCHAR2(100)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    lookupLocalCompletionTables.mockReturnValue([
      { name: "TT_PLATFORM_CARS", type: "view", schema: "REPORTING" },
      { name: "TT_PLATFORM_CARS", type: "table", schema: "SH_SMCVDMS_OVERSEAS_DRSSITB" },
    ]);
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => {
      const hidden = sql.includes("__DBX_PK_0");
      return {
        editable: true,
        analysis: {
          schema: "SH_SMCVDMS_OVERSEAS_DRSSITB",
          tableName: "TT_PLATFORM_CARS",
          tableAlias: "t",
          selectStar: !hidden,
          columns: hidden
            ? [
                { star: true, sourceQualifier: "t", sourceKey: "t:0", resultName: "*", expression: "t.*" },
                { resultName: "__DBX_PK_0", expression: "ROWIDTOCHAR(ROWID)" },
              ]
            : [],
        },
      };
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["ID", "PLATFORM", "__DBX_PK_0"],
        rows: [[72, "轻卡", "AAAPr9AAEAAAACXAAA"]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    // Exercise the explicit auto-commit execute-multi path.
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "SELECT t.* FROM SH_SMCVDMS_OVERSEAS_DRSSITB.TT_PLATFORM_CARS t WHERE t.PLATFORM = '轻卡'");

    expect(executeMulti).toHaveBeenCalledWith("oracle-1", "ORCL", "SELECT t.*, ROWIDTOCHAR(ROWID) AS \"__DBX_PK_0\" FROM SH_SMCVDMS_OVERSEAS_DRSSITB.TT_PLATFORM_CARS t WHERE t.PLATFORM = '轻卡'", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    expect(lookupLocalCompletionTables).toHaveBeenCalledWith("oracle-1", "ORCL", "TT_PLATFORM_CARS", 20, "SH_SMCVDMS_OVERSEAS_DRSSITB", undefined);
    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.result?.hidden_column_indexes).toEqual([2]);
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["ID", "PLATFORM", "__DBX_ROWID"]));
    expect(tab.tableMeta?.primaryKeys).toEqual(["__DBX_ROWID"]);
    expect(tab.queryAnalysis).toBeDefined();
    expect(tab.queryAnalysis?.allowInsert).not.toBe(false);
    expect(tab.queryEditabilityReason).toBeUndefined();
  });

  it.each([
    { databaseType: "mysql" as const, suffix: "/* GROUP BY name HAVING COUNT(*) > 1 */" },
    { databaseType: "mysql" as const, suffix: "-- GROUP BY name" },
    { databaseType: "mysql" as const, suffix: "WHERE name = 'GROUP BY name HAVING COUNT(*)'" },
    { databaseType: "mysql" as const, suffix: "WHERE id IN (SELECT user_id FROM orders GROUP BY user_id HAVING COUNT(*) > 1)" },
    { databaseType: "oracle" as const, suffix: "/* GROUP BY name HAVING COUNT(*) > 1 */" },
    { databaseType: "oracle" as const, suffix: "-- GROUP BY name" },
    { databaseType: "oracle" as const, suffix: "WHERE name = 'GROUP BY name HAVING COUNT(*)'" },
    { databaseType: "oracle" as const, suffix: "WHERE id IN (SELECT user_id FROM orders GROUP BY user_id HAVING COUNT(*) > 1)" },
  ])("keeps omitted-key editing for $databaseType with nonstructural grouping text: $suffix", async ({ databaseType, suffix }) => {
    const connectionId = `${databaseType}-1`;
    const database = databaseType === "oracle" ? "ORCL" : "app";
    getConnectionConfig.mockReturnValue({ id: connectionId, name: databaseType, db_type: databaseType, database, query_timeout_secs: 30 });
    const { analyzeEditableQueryEditability: analyzeSqlEditability } = await import("@/lib/sql/sqlAnalysis");
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => analyzeSqlEditability(sql));
    const hiddenKey = databaseType === "oracle" ? '"id" AS "__DBX_PK_0"' : "`id` AS `__DBX_PK_0`";
    executeMulti.mockResolvedValue([{ columns: ["name", "__DBX_PK_0"], rows: [["Alice", 7]], affected_rows: 0, execution_time_ms: 1 }]);
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab(connectionId, database, "Query");
    store.setAutoCommit(tabId, true);
    const sql = `SELECT name FROM users ${suffix}`;

    for (let execution = 0; execution < 2; execution++) {
      await store.executeTabSql(tabId, sql);
      expect(executeMulti).toHaveBeenLastCalledWith(connectionId, database, `SELECT name, ${hiddenKey} FROM users ${suffix}`, undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
      const tab = store.tabs.find((item) => item.id === tabId)!;
      await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["name", "id"]));
      expect(tab.queryAnalysis).toBeDefined();
      expect(tab.queryEditabilityReason).toBeUndefined();
      expect(tab.result?.hidden_column_indexes).toEqual([1]);
    }
  });

  it("keeps hidden-key editing for quoted grouping identifiers", async () => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "id", data_type: "NUMBER", is_nullable: false, is_primary_key: true },
      { name: "GROUP", data_type: "VARCHAR2", is_nullable: true, is_primary_key: false },
      { name: "HAVING", data_type: "VARCHAR2", is_nullable: true, is_primary_key: false },
      { name: "name", data_type: "VARCHAR2", is_nullable: true, is_primary_key: false },
    ]);
    const { analyzeEditableQueryEditability: analyzeSqlEditability } = await import("@/lib/sql/sqlAnalysis");
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => analyzeSqlEditability(sql));
    executeMulti.mockResolvedValue([{ columns: ["GROUP", "HAVING", "name", "__DBX_PK_0"], rows: [["a", "b", "Alice", 7]], affected_rows: 0, execution_time_ms: 1 }]);
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, 'SELECT "GROUP", "HAVING", name FROM users');
    expect(executeMulti.mock.calls.at(-1)?.[2]).toContain('"id" AS "__DBX_PK_0"');
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["GROUP", "HAVING", "name", "id"]));
    expect(tab.queryAnalysis).toBeDefined();
    expect(tab.queryEditabilityReason).toBeUndefined();
  });

  it("keeps keyless Oracle ROWID editing when comments mention grouping", async () => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", default_schema: "APP", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([{ name: "NAME", data_type: "VARCHAR2", is_nullable: true, is_primary_key: false }]);
    lookupLocalCompletionTables.mockReturnValue([{ name: "USERS", schema: "APP", type: "table" }]);
    const { analyzeEditableQueryEditability: analyzeSqlEditability } = await import("@/lib/sql/sqlAnalysis");
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => analyzeSqlEditability(sql));
    executeMulti.mockResolvedValue([{ columns: ["NAME", "__DBX_PK_0"], rows: [["Alice", "rowid-1"]], affected_rows: 0, execution_time_ms: 1 }]);
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "SELECT NAME FROM APP.USERS /* GROUP BY NAME HAVING COUNT(*) > 1 */");
    expect(executeMulti.mock.calls.at(-1)?.[2]).toContain('ROWIDTOCHAR(ROWID) AS "__DBX_PK_0"');
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["NAME", "__DBX_ROWID"]));
    expect(tab.tableMeta?.primaryKeys).toEqual(["__DBX_ROWID"]);
    expect(tab.queryAnalysis).toBeDefined();
    expect(tab.queryEditabilityReason).toBeUndefined();
  });

  it.each([
    { databaseType: "mysql" as const, returnedKey: false },
    { databaseType: "mysql" as const, returnedKey: true },
    { databaseType: "oracle" as const, returnedKey: false },
    { databaseType: "oracle" as const, returnedKey: true },
  ])("keeps scalar-subquery projections editable for $databaseType with returnedKey=$returnedKey", async ({ databaseType, returnedKey }) => {
    const connectionId = `${databaseType}-1`;
    const database = databaseType === "oracle" ? "ORCL" : "app";
    getConnectionConfig.mockReturnValue({ id: connectionId, name: databaseType, db_type: databaseType, database, query_timeout_secs: 30 });
    const { analyzeEditableQueryEditability: analyzeSqlEditability } = await import("@/lib/sql/sqlAnalysis");
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => analyzeSqlEditability(sql));
    const columns = returnedKey ? ["id", "name", "total"] : ["name", "total", "__DBX_PK_0"];
    const rows = returnedKey ? [[7, "Alice", 2]] : [["Alice", 2, 7]];
    executeMulti.mockResolvedValue([{ columns, rows, affected_rows: 0, execution_time_ms: 1 }]);
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab(connectionId, database, "Query");
    store.setAutoCommit(tabId, true);
    const sql = `SELECT ${returnedKey ? "u.id, " : ""}u.name, (SELECT COUNT(*) FROM orders o WHERE o.user_id = u.id) AS total FROM users u`;

    await store.executeTabSql(tabId, sql);
    if (returnedKey) {
      expect(executeMulti).toHaveBeenLastCalledWith(connectionId, database, sql, undefined, expect.any(String), expect.any(Object));
    } else {
      expect(executeMulti.mock.calls.at(-1)?.[2]).toContain("__DBX_PK_0");
    }
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(returnedKey ? ["id", "name", undefined] : ["name", undefined, "id"]));
    expect(tab.queryAnalysis).toBeDefined();
    expect(tab.queryEditabilityReason).toBeUndefined();
    expect(tab.queryAnalysis?.columns.find((column) => column.resultName === "total")?.sourceName).toBeUndefined();
  });

  it.each(["SELECT name FROM users GROUP BY name", "SELECT name FROM users HAVING COUNT(*) > 1", "SELECT COALESCE(SUM(id), 0) AS total FROM users", "SELECT name FROM users UNION SELECT name FROM archived_users"])("keeps structural grouping and set queries read-only: %s", async (sql) => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    const { analyzeEditableQueryEditability: analyzeSqlEditability } = await import("@/lib/sql/sqlAnalysis");
    analyzeEditableQueryEditability.mockImplementation(async (query: string) => analyzeSqlEditability(query));
    executeMulti.mockResolvedValue([{ columns: ["name"], rows: [["Alice"]], affected_rows: 0, execution_time_ms: 1 }]);
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, sql);
    expect(executeMulti).toHaveBeenLastCalledWith("oracle-1", "ORCL", sql, undefined, expect.any(String), expect.any(Object));
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.queryEditabilityReason).toBe(sql.includes("UNION") ? "set-operation" : "aggregation"));
    expect(tab.queryAnalysis).toBeUndefined();
    expect(tab.result?.hidden_column_indexes).toBeUndefined();
  });

  it("never rewrites an Oracle GROUP BY query with hidden ROWID", async () => {
    getConnectionConfig.mockReturnValue({
      id: "oracle-1",
      name: "Oracle",
      db_type: "oracle",
      database: "ORCL",
      query_timeout_secs: 30,
    });
    getColumns.mockResolvedValue([
      { name: "P_ID", type_name: "VARCHAR2", nullable: true },
      { name: "SUBJECT", type_name: "VARCHAR2", nullable: true },
      { name: "CREATE_TIME", type_name: "DATE", nullable: true },
    ]);
    listTables.mockResolvedValue([{ name: "RECORD", table_type: "TABLE" }]);
    listIndexes.mockResolvedValue([]);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: false,
      reason: "aggregation",
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["P_ID", "SUBJECT", "CNT_NUM"],
        rows: [["123214512", "邮件提醒", 1]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    store.setAutoCommit(tabId, true);

    const sql = `SELECT 
  R.P_ID, 
  R.SUBJECT, 
  COUNT(0) AS CNT_NUM
  FROM COMMON.RECORD R
 WHERE R.CREATE_TIME >= SYSDATE - INTERVAL '1' DAY
   AND R.SUBJECT = '邮件提醒'
   AND R.P_ID = '123214512'
 GROUP BY R.P_ID, R.SUBJECT`;

    // Execute first time (populates metadata cache)
    await store.executeTabSql(tabId, sql);
    expect(executeMulti).toHaveBeenLastCalledWith("oracle-1", "ORCL", sql, undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));

    // Execute second time (cache hit within 30s)
    await store.executeTabSql(tabId, sql);
    expect(executeMulti).toHaveBeenLastCalledWith("oracle-1", "ORCL", sql, undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    expect(executeMulti).not.toHaveBeenCalledWith("oracle-1", "ORCL", expect.stringContaining("ROWIDTOCHAR"), undefined, expect.any(String), expect.any(Object));

    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.result?.hidden_column_indexes).toBeUndefined();
  });

  it.each([
    {
      connection: { id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 },
      label: "native Oracle",
    },
    {
      connection: { id: "oracle-jdbc-1", name: "Oracle JDBC", db_type: "jdbc", connection_string: "jdbc:oracle:thin:@//localhost:1521/ORCL", database: "ORCL", query_timeout_secs: 30 },
      label: "Oracle-inferred JDBC",
    },
  ])("uses a physical primary index for $label star projections when column flags omit it", async ({ connection }) => {
    getConnectionConfig.mockReturnValue(connection);
    getColumns.mockResolvedValue([
      { name: "OFFER_RELA_ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
      { name: "ORI_OFFER_ID", data_type: "NUMBER", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    listIndexes.mockResolvedValue([{ name: "PK_OFFER_RELA", columns: ["OFFER_RELA_ID"], is_unique: true, is_primary: true }]);
    lookupLocalCompletionTables.mockReturnValue([{ name: "OFFER_RELA", type: "table", schema: "APP" }]);

    const projections = [
      {
        sql: "SELECT T.* FROM APP.OFFER_RELA t",
        analysisColumns: [],
        resultColumns: ["OFFER_RELA_ID", "ORI_OFFER_ID"],
        sourceColumns: undefined,
        selectStar: true,
      },
      {
        sql: "SELECT T.*, T.ROWID FROM APP.OFFER_RELA t",
        analysisColumns: [
          { star: true, sourceQualifier: "T", sourceKey: "t:0", resultName: "*", expression: "T.*" },
          { sourceName: "ROWID", sourceNameQuoted: false, sourceQualifier: "T", sourceKey: "t:0", resultName: "ROWID", expression: "T.ROWID" },
        ],
        resultColumns: ["OFFER_RELA_ID", "ORI_OFFER_ID", "ROWID"],
        sourceColumns: ["OFFER_RELA_ID", "ORI_OFFER_ID", undefined],
        selectStar: false,
      },
    ];

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();

    for (const projection of projections) {
      analyzeEditableQueryEditability.mockResolvedValue({
        editable: true,
        analysis: {
          schema: "APP",
          tableName: "OFFER_RELA",
          tableAlias: "t",
          selectStar: projection.selectStar,
          columns: projection.analysisColumns,
        },
      });
      executeMulti.mockResolvedValue([
        {
          columns: projection.resultColumns,
          rows: [],
          affected_rows: 0,
          execution_time_ms: 1,
        },
      ]);

      const tabId = store.createTab(connection.id, "ORCL", "Query");
      store.setAutoCommit(tabId, true);
      await store.executeTabSql(tabId, projection.sql);

      expect(executeMulti).toHaveBeenLastCalledWith(connection.id, "ORCL", projection.sql, undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
      const tab = store.tabs.find((item) => item.id === tabId)!;
      if (projection.sourceColumns) {
        await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(projection.sourceColumns));
      } else {
        expect(tab.querySourceColumns).toBeUndefined();
      }
      await vi.waitFor(() => expect(tab.tableMeta?.primaryKeys).toEqual(["OFFER_RELA_ID"]));
      expect(tab.queryAnalysis).toBeDefined();
      expect(tab.queryEditabilityReason).toBeUndefined();
    }
  });

  it("uses a qualified Oracle ROWID from a joined query as the synthetic row key", async () => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockImplementation(async (_connectionId: string, _database: string, _schema: string, tableName: string) =>
      tableName === "USERS"
        ? [
            { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
            { name: "NAME", data_type: "VARCHAR2(100)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
          ]
        : [{ name: "LABEL", data_type: "VARCHAR2(100)", is_nullable: true, column_default: null, is_primary_key: false, extra: null }],
    );
    lookupLocalCompletionTables.mockReturnValue([
      { name: "USERS", type: "table", schema: "APP" },
      { name: "ORDERS", type: "table", schema: "APP" },
    ]);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: "APP",
        tableName: "USERS",
        selectStar: false,
        sources: [
          { key: "t:0", schema: "APP", tableName: "USERS", alias: "t" },
          { key: "o:1", schema: "APP", tableName: "ORDERS", alias: "o" },
        ],
        columns: [
          { sourceName: "ROWID", sourceQualifier: "t", sourceKey: "t:0", resultName: "ROWID", expression: "t.ROWID" },
          { sourceName: "NAME", sourceQualifier: "t", sourceKey: "t:0", resultName: "NAME", expression: "t.NAME" },
          { sourceName: "LABEL", sourceQualifier: "o", sourceKey: "o:1", resultName: "LABEL", expression: "o.LABEL" },
        ],
      },
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["ROWID", "NAME", "LABEL"],
        rows: [["AAAPr9AAEAAAACXAAA", "Alice", "Order"]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "SELECT t.ROWID, t.NAME, o.LABEL FROM APP.USERS t LEFT JOIN APP.ORDERS o ON o.USER_ID = t.ID");

    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.result?.columns).toEqual(["ROWID", "NAME", "LABEL"]));
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["__DBX_ROWID", "NAME", undefined]), { timeout: 5000 });
    expect(tab.tableMeta?.primaryKeys).toEqual(["__DBX_ROWID"]);
    expect(tab.queryAnalysis).toBeDefined();
    expect(tab.queryEditabilityReason).toBeUndefined();
  }, 10_000);

  it.each([
    {
      connection: { id: "oracle-1", name: "Oracle", db_type: "oracle", database: "XE", query_timeout_secs: 30 },
      label: "native Oracle",
    },
    {
      connection: { id: "oracle-jdbc-1", name: "Oracle JDBC", db_type: "jdbc", connection_string: "jdbc:oracle:thin:@//localhost:1521/XE", database: "XE", query_timeout_secs: 30 },
      label: "Oracle-inferred JDBC",
    },
  ])("edits an unqualified lowercase query through the folded current-schema table for $label", async ({ connection }) => {
    getConnectionConfig.mockReturnValue(connection);
    getColumns.mockResolvedValue([
      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "NAME", data_type: "VARCHAR2(100)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    listIndexes.mockResolvedValue([]);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "imp_t",
        selectStar: true,
        columns: [],
      },
    });
    executeMulti.mockResolvedValue([{ columns: ["ID", "NAME"], rows: [[1, "Alice"]], affected_rows: 0, execution_time_ms: 1 }]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab(connection.id, "XE", "Query");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "select * from imp_t");

    // The service name must not leak into the metadata schema, and the stored
    // table spelling has to fold to uppercase so the generated UPDATE quotes
    // the object Oracle actually resolved for the unqualified SELECT.
    expect(getColumns).toHaveBeenCalledWith(connection.id, "XE", "", "IMP_T", undefined);
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.tableMeta?.tableName).toBe("IMP_T"));
    expect(tab.tableMeta?.schema).toBeUndefined();
    expect(tab.queryEditabilityReason).toBeUndefined();
  });

  it("keeps an unqualified lowercase MySQL JDBC query on its unfolded table name", async () => {
    getConnectionConfig.mockReturnValue({ id: "jdbc-mysql-1", name: "MySQL JDBC", db_type: "jdbc", connection_string: "jdbc:mysql://localhost:3306/app", database: "app", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "name", data_type: "varchar(64)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "users",
        selectStar: true,
        columns: [],
      },
    });
    executeMulti.mockResolvedValue([{ columns: ["id", "name"], rows: [[1, "Alice"]], affected_rows: 0, execution_time_ms: 1 }]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("jdbc-mysql-1", "app", "Query");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "select * from users");

    expect(getColumns).toHaveBeenCalledWith("jdbc-mysql-1", "app", "", "users", undefined);
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.tableMeta?.tableName).toBe("users"));
    expect(tab.tableMeta?.schema).toBeUndefined();
    expect(tab.queryEditabilityReason).toBeUndefined();
  });

  it("uses the configured current schema to keep an unqualified Oracle base-table query editable", async () => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", default_schema: "APP", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
      { name: "NAME", data_type: "VARCHAR2(100)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    lookupLocalCompletionTables.mockReturnValue([
      { name: "CUSTOMERS", type: "view", schema: "REPORTING" },
      { name: "CUSTOMERS", type: "table", schema: "APP" },
    ]);
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => {
      const hidden = sql.includes("__DBX_PK_0");
      return {
        editable: true,
        analysis: {
          schema: undefined,
          tableName: "CUSTOMERS",
          selectStar: !hidden,
          columns: hidden
            ? [
                { star: true, sourceKey: "CUSTOMERS:0", resultName: "*", expression: "*" },
                { resultName: "__DBX_PK_0", expression: "ROWIDTOCHAR(ROWID)" },
              ]
            : [],
        },
      };
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["ID", "NAME", "__DBX_PK_0"],
        rows: [[1, "Alice", "AAAPr9AAEAAAACXAAA"]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "SELECT * FROM CUSTOMERS");

    expect(executeMulti).toHaveBeenCalledWith("oracle-1", "ORCL", 'SELECT CUSTOMERS.*, ROWIDTOCHAR(ROWID) AS "__DBX_PK_0" FROM CUSTOMERS', undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    expect(lookupLocalCompletionTables).toHaveBeenCalledWith("oracle-1", "ORCL", "CUSTOMERS", 20, "APP", undefined);
    expect(store.tabs.find((item) => item.id === tabId)?.result?.hidden_column_indexes).toEqual([2]);
  });

  it("executes an unqualified Oracle query without enumerating objects when its type is unknown", async () => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
      { name: "NAME", data_type: "VARCHAR2(100)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    listTables.mockReturnValue(new Promise(() => undefined));
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "CUSTOMER_VIEW",
        selectStar: true,
        columns: [],
      },
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["ID", "NAME"],
        rows: [[1, "Alice"]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    store.setAutoCommit(tabId, true);

    const execution = store.executeTabSql(tabId, "SELECT * FROM CUSTOMER_VIEW");
    await vi.waitFor(() => expect(executeMulti).toHaveBeenCalled(), { timeout: 250 });
    await execution;

    expect(listTables).not.toHaveBeenCalled();
    expect(executeMulti).toHaveBeenCalledWith("oracle-1", "ORCL", "SELECT * FROM CUSTOMER_VIEW", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.result?.hidden_column_indexes).toBeUndefined();
    await vi.waitFor(() => expect(tab.queryEditabilityReason).toBe("no-primary-key"));
    expect(tab.queryAnalysis).toBeUndefined();
  });

  it("does not check Oracle ROWID eligibility when query metadata returns no columns", async () => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([]);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "aa",
        selectStar: true,
        columns: [],
      },
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["Error"],
        rows: [["ORA-00942: table or view does not exist"]],
        affected_rows: 0,
        execution_time_ms: 1,
        execution_error: true,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    // Exercise the explicit auto-commit execute-multi path.
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "SELECT * FROM aa");

    expect(getColumns).toHaveBeenCalledWith("oracle-1", "ORCL", "", "AA", undefined);
    expect(listIndexes).toHaveBeenCalledWith("oracle-1", "ORCL", "", "AA", undefined);
    expect(listObjects).not.toHaveBeenCalled();
    expect(executeMulti).toHaveBeenCalledWith("oracle-1", "ORCL", "SELECT * FROM aa", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
  });

  it("executes an Oracle cache-miss query without waiting for object discovery", async () => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ncdb", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
      { name: "PRODUCT_NAME", data_type: "VARCHAR2(100)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    listIndexes.mockResolvedValue([]);
    listObjects.mockReturnValue(new Promise(() => undefined));
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "VITF_PRODUCT_INFOOA",
        selectStar: true,
        columns: [],
      },
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["ID", "PRODUCT_NAME"],
        rows: [],
        affected_rows: 0,
        execution_time_ms: 473,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ncdb", "Query");
    store.setAutoCommit(tabId, true);
    const sql = "SELECT * FROM VITF_PRODUCT_INFOOA WHERE PK_MATERIAL IN ('1', '2')";

    const execution = store.executeTabSql(tabId, sql);
    await vi.waitFor(() => expect(executeMulti).toHaveBeenCalledWith("oracle-1", "ncdb", sql, undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 })), { timeout: 1000 });
    await execution;

    expect(lookupLocalCompletionTables).not.toHaveBeenCalled();
  });

  it("starts an Oracle primary-key star query before slow column metadata finishes", async () => {
    const columnsGate = deferred<Awaited<ReturnType<typeof getColumns>>>();
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockReturnValue(columnsGate.promise);
    listIndexes.mockResolvedValue([{ name: "PK_WIDE_TABLE", columns: ["ID"], is_unique: true, is_primary: true }]);
    analyzeEditableQueryEditability.mockImplementation(async () => ({
      editable: true,
      analysis: {
        schema: "APP",
        tableName: "WIDE_TABLE",
        tableAlias: "t",
        selectStar: true,
        columns: [],
      },
    }));
    executeMulti.mockResolvedValue([
      {
        columns: ["ID", "NAME"],
        rows: [[1, "Alice"]],
        affected_rows: 0,
        execution_time_ms: 312,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    // Exercise the explicit auto-commit execute-multi path.
    store.setAutoCommit(tabId, true);

    const execution = store.executeTabSql(tabId, "SELECT t.* FROM APP.WIDE_TABLE t");
    await vi.waitFor(() => expect(executeMulti).toHaveBeenCalled());
    expect(executeMulti).toHaveBeenCalledWith("oracle-1", "ORCL", "SELECT t.* FROM APP.WIDE_TABLE t", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    expect(executeMulti.mock.calls[0]?.[5]).not.toHaveProperty("tableDataPreview");

    columnsGate.resolve([
      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "NAME", data_type: "VARCHAR2(100)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    await execution;
  });

  it.each([
    ["oracle", true],
    ["oracle", false],
    ["xugu", true],
    ["xugu", false],
  ] as const)("starts a %s query (star=%s) when synonym columns are slow and indexes return no key", async (databaseType, selectStar) => {
    const columnsGate = deferred<Awaited<ReturnType<typeof getColumns>>>();
    getConnectionConfig.mockReturnValue({ id: "synonym-1", name: "Synonym", db_type: databaseType, database: "APP", query_timeout_secs: 30 });
    getColumns.mockReturnValue(columnsGate.promise);
    listIndexes.mockResolvedValue([]);
    analyzeEditableQueryEditability.mockImplementation(async () => ({
      editable: true,
      analysis: {
        schema: "APP",
        tableName: "ORDERS_ALIAS",
        selectStar,
        columns: selectStar ? [] : [{ sourceName: "NAME", resultName: "NAME" }],
      },
    }));
    executeMulti.mockResolvedValue([
      {
        columns: selectStar ? ["ID", "NAME"] : ["NAME"],
        rows: selectStar ? [[1, "Alice"]] : [["Alice"]],
        affected_rows: 0,
        execution_time_ms: 18,
      },
    ]);
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("synonym-1", "APP", "Query");
    store.setAutoCommit(tabId, true);
    vi.useFakeTimers();
    const sql = `SELECT ${selectStar ? "*" : "NAME"} FROM APP.ORDERS_ALIAS`;
    const execution = store.executeTabSql(tabId, sql);
    try {
      await vi.waitFor(() => expect(getColumns).toHaveBeenCalledOnce());
      expect(executeMulti).not.toHaveBeenCalled();
      await vi.advanceTimersByTimeAsync(1_000);
      expect(executeMulti).toHaveBeenCalledOnce();
      expect(executeMulti.mock.calls[0]?.[2]).toBe(sql);
      await execution;
      expect(store.tabs.find((tab) => tab.id === tabId)?.result?.rows).toEqual(selectStar ? [[1, "Alice"]] : [["Alice"]]);

      columnsGate.resolve([
        { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
        { name: "NAME", data_type: "VARCHAR2(100)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
      ]);
      const { getCachedTableMetadata } = await import("@/lib/metadata/tableMetadataCache");
      await vi.waitFor(() => expect(getCachedTableMetadata({ connectionId: "synonym-1", database: "APP", schema: "APP", tableName: "ORDERS_ALIAS", databaseType })?.metadata.columns).toHaveLength(2));
      expect(getColumns).toHaveBeenCalledOnce();
      expect(listIndexes).toHaveBeenCalledOnce();
    } finally {
      columnsGate.resolve([]);
      await execution;
      await vi.runAllTimersAsync();
      vi.useRealTimers();
    }
  });

  it("shares one Oracle preflight deadline between slow indexes and pending columns", async () => {
    const columnsGate = deferred<Awaited<ReturnType<typeof getColumns>>>();
    const indexesGate = deferred<Awaited<ReturnType<typeof listIndexes>>>();
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "APP", query_timeout_secs: 30 });
    getColumns.mockReturnValue(columnsGate.promise);
    listIndexes.mockReturnValue(indexesGate.promise);
    analyzeEditableQueryEditability.mockImplementation(async () => ({ editable: true, analysis: { schema: "APP", tableName: "ORDERS_ALIAS", selectStar: true, columns: [] } }));
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "APP", "Query");
    store.setAutoCommit(tabId, true);
    vi.useFakeTimers();
    const execution = store.executeTabSql(tabId, "SELECT * FROM APP.ORDERS_ALIAS");
    try {
      await vi.waitFor(() => expect(listIndexes).toHaveBeenCalledOnce());
      await vi.advanceTimersByTimeAsync(500);
      indexesGate.resolve([]);
      await vi.advanceTimersByTimeAsync(500);
      expect(executeMulti).toHaveBeenCalledOnce();
      await execution;
    } finally {
      indexesGate.resolve([]);
      columnsGate.resolve([]);
      await execution;
      await vi.runAllTimersAsync();
      vi.useRealTimers();
    }
  });

  it("starts an Oracle star query when index metadata exceeds the preflight budget", async () => {
    vi.useFakeTimers();
    const columnsGate = deferred<Awaited<ReturnType<typeof getColumns>>>();
    const indexesGate = deferred<Awaited<ReturnType<typeof listIndexes>>>();
    try {
      getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
      getColumns.mockReturnValue(columnsGate.promise);
      listIndexes.mockReturnValue(indexesGate.promise);
      analyzeEditableQueryEditability.mockImplementation(async () => ({
        editable: true,
        analysis: {
          schema: "APP",
          tableName: "SLOW_METADATA_TABLE",
          selectStar: true,
          columns: [],
        },
      }));
      executeMulti.mockResolvedValue([
        {
          columns: ["ID", "NAME"],
          rows: [[1, "Alice"]],
          affected_rows: 0,
          execution_time_ms: 12,
        },
      ]);

      const { useQueryStore } = await import("@/stores/queryStore");
      const store = useQueryStore();
      const tabId = store.createTab("oracle-1", "ORCL", "Query");
      store.setAutoCommit(tabId, true);

      const execution = store.executeTabSql(tabId, "SELECT * FROM APP.SLOW_METADATA_TABLE");
      await vi.waitFor(() => expect(listIndexes).toHaveBeenCalledOnce());
      expect(executeMulti).not.toHaveBeenCalled();

      await vi.advanceTimersByTimeAsync(1_000);
      await vi.waitFor(() => expect(executeMulti).toHaveBeenCalledOnce());
      expect(executeMulti).toHaveBeenCalledWith("oracle-1", "ORCL", "SELECT * FROM APP.SLOW_METADATA_TABLE", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
      await execution;

      indexesGate.resolve([{ name: "PK_SLOW_METADATA_TABLE", columns: ["ID"], is_unique: true, is_primary: true }]);
      columnsGate.resolve([
        { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
        { name: "NAME", data_type: "VARCHAR2(100)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
      ]);
      await vi.waitFor(() => expect(store.tabs.find((item) => item.id === tabId)?.tableMeta?.primaryKeys).toEqual(["ID"]));

      await store.executeTabSql(tabId, "SELECT * FROM APP.SLOW_METADATA_TABLE");
      expect(executeMulti).toHaveBeenCalledTimes(2);
      expect(listIndexes).toHaveBeenCalledOnce();
      expect(getColumns).toHaveBeenCalledOnce();
    } finally {
      indexesGate.resolve([{ name: "PK_SLOW_METADATA_TABLE", columns: ["ID"], is_unique: true, is_primary: true }]);
      columnsGate.resolve([
        { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
        { name: "NAME", data_type: "VARCHAR2(100)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
      ]);
      await vi.runAllTimersAsync();
      vi.useRealTimers();
    }
  });

  it("waits for first-run Oracle XMLTYPE metadata before manual transaction execution", async () => {
    const columnsGate = deferred<Awaited<ReturnType<typeof getColumns>>>();
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockReturnValue(columnsGate.promise);
    listIndexes.mockResolvedValue([{ name: "PK_WIDE_TABLE", columns: ["ID"], is_unique: true, is_primary: true }]);
    lookupLocalCompletionTables.mockReturnValue([{ name: "WIDE_TABLE", type: "table", schema: "APP" }]);
    analyzeEditableQueryEditability.mockImplementation(async () => ({
      editable: true,
      analysis: {
        schema: "APP",
        tableName: "WIDE_TABLE",
        tableAlias: "t",
        selectStar: true,
        columns: [],
      },
    }));
    executeInManualTransaction.mockResolvedValue([
      {
        columns: ["ID", "PAYLOAD"],
        rows: [[1, "<XMLTYPE>"]],
        affected_rows: 0,
        execution_time_ms: 1,
        large_value_cells: [{ row_index: 0, column_index: 1, original_bytes: 81920 }],
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    // Tabs default to auto-commit; exercise the explicit manual-transaction path.
    store.setAutoCommit(tabId, false);
    const execution = store.executeTabSql(tabId, "SELECT t.* FROM APP.WIDE_TABLE t");

    await vi.waitFor(() => expect(listIndexes).toHaveBeenCalled());
    expect(executeInManualTransaction).not.toHaveBeenCalled();

    columnsGate.resolve([
      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "PAYLOAD", data_type: "SYS.XMLTYPE", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    await execution;

    expect(beginManualTransaction).toHaveBeenCalledWith("oracle-1", "ORCL", undefined, undefined);
    expect(executeInManualTransaction).toHaveBeenCalledWith("txn-1", "SELECT t.* FROM APP.WIDE_TABLE t", "ORCL", undefined, expect.any(Number), true, undefined, undefined, "SELECT t.* FROM APP.WIDE_TABLE t");
    expect(store.tabs.find((tab) => tab.id === tabId)?.result?.large_value_cells).toEqual([{ row_index: 0, column_index: 1, original_bytes: 81920 }]);
  });

  it.each(["oracle", "oceanbase-oracle"])("continues the %s cursor for page 2 in a manual transaction", async (databaseType) => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: databaseType, database: "ORCL", query_timeout_secs: 30 });
    analyzeEditableQueryEditability.mockResolvedValue({ editable: false, reason: "complex-query" });
    prepareQueryPaginationExecutionPlan.mockImplementation(async (options) => ({
      sqlToExecute: options.sql,
      pageSql: databaseType === "oceanbase-oracle" ? undefined : options.sql,
      pageLimit: options.pagination.limit,
      pageOffset: options.pagination.offset,
      countSql: undefined,
      useAgentResultSession: true,
    }));
    executeInManualTransaction
      .mockResolvedValueOnce([
        {
          columns: ["ID"],
          rows: Array.from({ length: 100 }, (_, index) => [index + 1]),
          affected_rows: 0,
          execution_time_ms: 1,
          session_id: "oracle-go-1",
          has_more: true,
        },
      ])
      .mockResolvedValueOnce([
        {
          columns: ["ID"],
          rows: Array.from({ length: 100 }, (_, index) => [index + 101]),
          affected_rows: 0,
          execution_time_ms: 1,
          has_more: false,
        },
      ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    // Tabs default to auto-commit; exercise the explicit manual-transaction path.
    store.setAutoCommit(tabId, false);
    const sql = "SELECT ID FROM APP.EVENTS ORDER BY ID";

    await store.executeTabSql(tabId, sql);
    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.autoCommit).toBe(false);
    expect(executeInManualTransaction).toHaveBeenNthCalledWith(1, "txn-1", sql, "ORCL", undefined, expect.any(Number), false, 100, undefined, sql);
    expect(tab.result?.rows).toHaveLength(100);

    await store.executeTabSql(tabId, sql, {
      resultBaseSql: sql,
      pagination: { limit: 100, offset: 100, sessionId: "oracle-go-1" },
      appendResult: { maxRows: 10_000 },
      preserveResultDuringExecution: true,
      preserveTotalRowCountDuringExecution: true,
      replaceActiveResultInGroup: true,
    });

    expect(executeInManualTransaction).toHaveBeenNthCalledWith(2, "txn-1", sql, "ORCL", undefined, expect.any(Number), false, 100, "oracle-go-1", undefined);
    expect(tab.result?.rows).toHaveLength(200);
    expect(tab.result?.rows[100]).toEqual([101]);
  });

  it("advances an Elasticsearch cursor without replacing the displayed page", async () => {
    getConnectionConfig.mockReturnValue({ id: "elasticsearch-1", name: "Elasticsearch", db_type: "elasticsearch", query_timeout_secs: 30 });
    analyzeEditableQueryEditability.mockResolvedValue({ editable: false, reason: "complex-query" });
    prepareQueryPaginationExecutionPlan.mockImplementation(async (options) => ({
      sqlToExecute: options.sql,
      pageSql: options.sql,
      pageLimit: options.pagination.limit,
      pageOffset: options.pagination.offset,
      countSql: undefined,
      useAgentResultSession: true,
    }));
    executeMulti
      .mockResolvedValueOnce([
        {
          columns: ["message"],
          rows: [["page-1"]],
          affected_rows: 20_000,
          execution_time_ms: 1,
          session_id: "cursor-1",
          has_more: true,
        },
      ])
      .mockResolvedValueOnce([
        {
          columns: ["message"],
          rows: [["page-2"]],
          affected_rows: 20_000,
          execution_time_ms: 1,
          session_id: "cursor-2",
          has_more: true,
        },
      ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("elasticsearch-1", "", "Query");
    const sql = "SELECT * FROM `dbx-app-logs-v1` AS dalv";

    await store.executeTabSql(tabId, sql, { pagination: { limit: 100, offset: 0 } });
    const tab = store.tabs.find((item) => item.id === tabId)!;
    const displayedResult = tab.result;

    await store.executeTabSql(tabId, sql, {
      resultBaseSql: sql,
      pagination: { limit: 100, offset: 100, sessionId: "cursor-1", clientSessionId: tab.resultClientSessionId },
      preserveResultDuringExecution: true,
      preserveTotalRowCountDuringExecution: true,
      replaceActiveResultInGroup: true,
      retainDisplayedResult: true,
    });

    expect(tab.result).toBe(displayedResult);
    expect(tab.result?.rows).toEqual([["page-1"]]);
    expect(tab.resultPageOffset).toBe(0);
    expect(tab.resultSessionId).toBe("cursor-2");
  });

  it("does not start an Oracle manual transaction after cancellation during metadata loading", async () => {
    const columnsGate = deferred<Awaited<ReturnType<typeof getColumns>>>();
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockReturnValue(columnsGate.promise);
    listIndexes.mockResolvedValue([{ name: "PK_WIDE_TABLE", columns: ["ID"], is_unique: true, is_primary: true }]);
    lookupLocalCompletionTables.mockReturnValue([{ name: "WIDE_TABLE", type: "table", schema: "APP" }]);
    analyzeEditableQueryEditability.mockImplementation(async () => ({
      editable: true,
      analysis: {
        schema: "APP",
        tableName: "WIDE_TABLE",
        tableAlias: "t",
        selectStar: true,
        columns: [],
      },
    }));

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    // Tabs default to auto-commit; exercise the explicit manual-transaction path.
    store.setAutoCommit(tabId, false);
    const execution = store.executeTabSql(tabId, "SELECT t.* FROM APP.WIDE_TABLE t");

    await vi.waitFor(() => expect(listIndexes).toHaveBeenCalled());
    await expect(store.cancelTabExecution(tabId)).resolves.toBe(false);

    columnsGate.resolve([
      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "PAYLOAD", data_type: "SYS.XMLTYPE", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    await expect(execution).resolves.toBe(false);

    expect(cancelQuery).toHaveBeenCalledWith(expect.any(String));
    expect(beginManualTransaction).not.toHaveBeenCalled();
    expect(executeInManualTransaction).not.toHaveBeenCalled();
    expect(store.tabs.find((tab) => tab.id === tabId)).toMatchObject({
      isExecuting: false,
      isCancelling: false,
      executionId: undefined,
    });
    expect(store.tabs.find((tab) => tab.id === tabId)?.txnSessionId).toBeUndefined();
  });

  it("keeps manual non-Oracle queries out of table-data preview mode", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "Query");
    store.setAutoCommit(tabId, false);

    await store.executeTabSql(tabId, "SELECT name FROM users");

    // MySQL is a sticky proven-read-only dialect (#9018): the call now ends
    // with the user-facing classification SQL (9th argument), but still opts
    // out of table-data preview. Every slot stays asserted — the spec's mocks
    // are fixed, so database/schema/row-limit/cursor args must not drift.
    expect(executeInManualTransaction).toHaveBeenCalledWith("txn-1", "SELECT name, `id` AS `__DBX_PK_0` FROM users", "app", undefined, 100000, false, undefined, undefined, "SELECT name FROM users");
  });

  it("keeps a keyless Oracle query editable when its WHERE clause reads another table", async () => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
      { name: "CUSTOMER_NO", data_type: "NUMBER", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    lookupLocalCompletionTables.mockReturnValue([{ name: "PLATFORM_CARS", type: "table", schema: "APP" }]);
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => {
      const hidden = sql.includes("__DBX_PK_0");
      return {
        editable: true,
        analysis: {
          schema: "APP",
          tableName: "PLATFORM_CARS",
          tableAlias: "t",
          selectStar: !hidden,
          columns: hidden
            ? [
                { star: true, sourceQualifier: "t", sourceKey: "t:0", resultName: "*", expression: "t.*" },
                { resultName: "__DBX_PK_0", expression: "ROWIDTOCHAR(ROWID)" },
              ]
            : [],
        },
      };
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["ID", "CUSTOMER_NO", "__DBX_PK_0"],
        rows: [[72, 2100196, "AAAPr9AAEAAAACXAAA"]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const sql = "SELECT t.* FROM APP.PLATFORM_CARS t WHERE t.CUSTOMER_NO IN (SELECT c.CUSTOMER_NO FROM APP.CUSTOMERS c WHERE c.ENABLED = 1)";
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    // Exercise the explicit auto-commit execute-multi path.
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, sql);

    expect(executeMulti).toHaveBeenCalledWith(
      "oracle-1",
      "ORCL",
      'SELECT t.*, ROWIDTOCHAR(ROWID) AS "__DBX_PK_0" FROM APP.PLATFORM_CARS t WHERE t.CUSTOMER_NO IN (SELECT c.CUSTOMER_NO FROM APP.CUSTOMERS c WHERE c.ENABLED = 1)',
      undefined,
      expect.any(String),
      expect.objectContaining({ timeoutSecs: 30 }),
    );
    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.result?.hidden_column_indexes).toEqual([2]);
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["ID", "CUSTOMER_NO", "__DBX_ROWID"]));
    expect(tab.queryAnalysis).toBeDefined();
    expect(tab.queryAnalysis?.allowInsertDelete).not.toBe(false);
    expect(tab.queryEditabilityReason).toBeUndefined();
  });

  it("does not inject Oracle ROWID into keyless view queries", async () => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
      { name: "PLATFORM", data_type: "VARCHAR2(100)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    listIndexes.mockResolvedValue([]);
    lookupLocalCompletionTables.mockReturnValue([{ name: "PLATFORM_VIEW", type: "view", schema: "APP" }]);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: "APP",
        tableName: "PLATFORM_VIEW",
        selectStar: true,
        columns: [],
      },
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["ID", "PLATFORM"],
        rows: [[72, "轻卡"]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    // Exercise the explicit auto-commit execute-multi path.
    store.setAutoCommit(tabId, true);
    const tab = store.tabs.find((item) => item.id === tabId)!;

    await store.executeTabSql(tabId, "SELECT * FROM APP.PLATFORM_VIEW");

    expect(executeMulti).toHaveBeenCalledWith("oracle-1", "ORCL", "SELECT * FROM APP.PLATFORM_VIEW", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    expect(lookupLocalCompletionTables).toHaveBeenCalledWith("oracle-1", "ORCL", "PLATFORM_VIEW", 20, "APP", undefined);
    expect(tab.result?.hidden_column_indexes).toBeUndefined();
  });

  it.each([
    { sourceSchema: undefined, synonym: true },
    { sourceSchema: "ExplicitOwner", synonym: true },
    { sourceSchema: undefined, synonym: false },
  ])("keeps OceanBase current schema separate from explicit source schema $sourceSchema with synonym=$synonym", async ({ sourceSchema, synonym }) => {
    getConnectionConfig.mockReturnValue({ id: "ob-1", name: "OceanBase", db_type: "oceanbase-oracle", database: "service", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([{ name: "ItemId", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: true, extra: null, ...(synonym ? { resolved_schema: "TargetOwner", resolved_table: "Items", resolved_object_type: "TABLE" } : {}) }]);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: sourceSchema,
        schemaQuoted: true,
        tableName: "ItemsAlias",
        tableNameQuoted: true,
        selectStar: false,
        columns: [{ sourceName: "ItemId", sourceNameQuoted: true, resultName: "ItemId", expression: '"ItemId"' }],
      },
    });
    executeMulti.mockResolvedValue([{ columns: ["ItemId"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 }]);
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("ob-1", "service", "Query", "query", "SelectedOwner");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, sourceSchema ? 'SELECT "ItemId" FROM "ExplicitOwner"."ItemsAlias"' : 'SELECT "ItemId" FROM "ItemsAlias"');

    if (sourceSchema) expect(getColumns).toHaveBeenCalledWith("ob-1", "service", "ExplicitOwner", "ItemsAlias", undefined);
    else expect(getColumns).toHaveBeenCalledWith("ob-1", "service", "", "ItemsAlias", undefined, undefined, "SelectedOwner");
    expect(listIndexes).toHaveBeenCalledWith("ob-1", "service", synonym ? "TargetOwner" : "SelectedOwner", synonym ? "Items" : "ItemsAlias", undefined);
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.tableMeta).toMatchObject({ schema: synonym ? "TargetOwner" : "SelectedOwner", tableName: synonym ? "Items" : "ItemsAlias" }));
    if (synonym) expect(tab.tableMeta?.tableType).toBe("TABLE");
    expect(tab.queryAnalysis?.tableName).toBe("ItemsAlias");
  });

  it.each(["VIEW", undefined])("does not treat a synonym target of type %s as an Oracle base table", async (objectType) => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([{ name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: false, extra: null, resolved_schema: "TargetOwner", resolved_table: "ActualItems", resolved_object_type: objectType }]);
    lookupLocalCompletionTables.mockReturnValue([{ name: "ITEMS_ALIAS", type: "table", schema: "APP" }]);
    analyzeEditableQueryEditability.mockResolvedValue({ editable: true, analysis: { schema: "APP", tableName: "ITEMS_ALIAS", selectStar: true, columns: [] } });
    executeMulti.mockResolvedValue([{ columns: ["ID"], rows: [[1]], affected_rows: 0, execution_time_ms: 1 }]);
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "SELECT * FROM APP.ITEMS_ALIAS");

    expect(executeMulti).toHaveBeenCalledWith("oracle-1", "ORCL", "SELECT * FROM APP.ITEMS_ALIAS", undefined, expect.any(String), expect.any(Object));
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.result?.columns).toEqual(["ID"]));
    expect(tab.result?.hidden_column_indexes).toBeUndefined();
    expect(tab.queryAnalysis).toBeUndefined();
  });

  it.each(["CLOB", "XMLTYPE", "SYS.XMLTYPE"])("enables deferred Oracle %s values only when a base-table query has a stable key", async (dataType) => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "PAYLOAD", data_type: dataType, is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    lookupLocalCompletionTables.mockReturnValue([{ name: "DOCUMENTS", type: "table", schema: "APP" }]);
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => ({
      editable: true,
      analysis: {
        schema: "APP",
        tableName: "DOCUMENTS",
        selectStar: false,
        columns: [{ sourceName: "PAYLOAD", resultName: "PAYLOAD", expression: "PAYLOAD" }, ...(sql.includes("__DBX_PK_0") ? [{ sourceName: "ID", resultName: "__DBX_PK_0", expression: '"ID"' }] : [])],
      },
    }));
    executeMulti.mockResolvedValue([{ columns: ["PAYLOAD", "__DBX_PK_0"], rows: [["<CLOB>", 1]], affected_rows: 0, execution_time_ms: 1 }]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "SELECT PAYLOAD FROM APP.DOCUMENTS");

    expect(executeMulti).toHaveBeenCalledWith("oracle-1", "ORCL", 'SELECT PAYLOAD, "ID" AS "__DBX_PK_0" FROM APP.DOCUMENTS', undefined, expect.any(String), expect.objectContaining({ tableDataPreview: true, timeoutSecs: 30 }));
  });

  it("defers DB2 BLOB materialization for a non-null unique-index star query", async () => {
    getConnectionConfig.mockReturnValue({ id: "db2-1", name: "DB2", db_type: "db2", database: "MAXIMO", query_timeout_secs: 60 });
    getColumns.mockResolvedValue([
      { name: "MAFAPPDATAID", data_type: "BIGINT", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
      { name: "APP", data_type: "BLOB", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    listIndexes.mockResolvedValue([{ name: "MAFAPPDATA_UQ", columns: ["MAFAPPDATAID"], is_unique: true, is_primary: false }]);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "MAFAPPDATA",
        tableAlias: "mf",
        selectStar: true,
        columns: [],
      },
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["MAFAPPDATAID", "APP"],
        rows: [[1, "<BLOB>"]],
        affected_rows: 0,
        execution_time_ms: 57,
        large_value_cells: [{ row_index: 0, column_index: 1, original_bytes: 64 * 1024 * 1024 }],
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("db2-1", "MAXIMO", "Query", "query", "MAXIMO");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "select * from MAFAPPDATA mf");

    expect(executeMulti).toHaveBeenCalledWith("db2-1", "MAXIMO", "select * from MAFAPPDATA mf", "MAXIMO", expect.any(String), expect.objectContaining({ tableDataPreview: true, timeoutSecs: 60 }));
    expect(store.tabs.find((tab) => tab.id === tabId)?.result?.large_value_cells).toEqual([{ row_index: 0, column_index: 1, original_bytes: 64 * 1024 * 1024 }]);
  });

  it("defers DB2 BLOB materialization through a persisted virtual unique key", async () => {
    getConnectionConfig.mockReturnValue({ id: "db2-1", name: "DB2", db_type: "db2", database: "MAXIMO", query_timeout_secs: 60 });
    const columns = [
      { name: "MAFAPPDATAID", data_type: "BIGINT", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
      { name: "APP", data_type: "BLOB", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ];
    getColumns.mockResolvedValue(columns);
    listIndexes.mockResolvedValue([]);
    expect(saveVirtualRowIdentifier({ connectionId: "db2-1", database: "MAXIMO", schema: "MAXIMO", tableName: "MAFAPPDATA" }, ["MAFAPPDATAID"], columns)).toBe(true);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "MAFAPPDATA",
        tableAlias: "mf",
        selectStar: true,
        columns: [],
      },
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["MAFAPPDATAID", "APP"],
        rows: [[1, "<BLOB>"]],
        affected_rows: 0,
        execution_time_ms: 57,
        large_value_cells: [{ row_index: 0, column_index: 1, original_bytes: 64 * 1024 * 1024 }],
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("db2-1", "MAXIMO", "Query", "query", "MAXIMO");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "select * from MAFAPPDATA mf");

    expect(executeMulti).toHaveBeenCalledWith("db2-1", "MAXIMO", "select * from MAFAPPDATA mf", "MAXIMO", expect.any(String), expect.objectContaining({ tableDataPreview: true, timeoutSecs: 60 }));
    await vi.waitFor(() => expect(store.tabs.find((tab) => tab.id === tabId)?.tableMeta?.virtualPrimaryKeys).toEqual(["MAFAPPDATAID"]));
  });

  it("keeps deferred DB2 LOB handling disabled without a stable key", async () => {
    getConnectionConfig.mockReturnValue({ id: "db2-1", name: "DB2", db_type: "db2", database: "MAXIMO", query_timeout_secs: 60 });
    getColumns.mockResolvedValue([{ name: "APP", data_type: "BLOB", is_nullable: true, column_default: null, is_primary_key: false, extra: null }]);
    listIndexes.mockResolvedValue([]);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "MAFAPPDATA",
        tableAlias: "mf",
        selectStar: true,
        columns: [],
      },
    });
    executeMulti.mockResolvedValue([{ columns: ["APP"], rows: [["0x01"]], affected_rows: 0, execution_time_ms: 1 }]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("db2-1", "MAXIMO", "Query", "query", "MAXIMO");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "select * from MAFAPPDATA mf");

    expect(executeMulti).toHaveBeenCalledOnce();
    expect(executeMulti.mock.calls[0]?.[5]).not.toHaveProperty("tableDataPreview");
  });

  it("keeps deferred Oracle LOBs disabled for views", async () => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
      { name: "PAYLOAD", data_type: "CLOB", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    listIndexes.mockResolvedValue([]);
    lookupLocalCompletionTables.mockReturnValue([{ name: "DOCUMENT_VIEW", type: "view", schema: "APP" }]);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: "APP",
        tableName: "DOCUMENT_VIEW",
        selectStar: true,
        columns: [],
      },
    });
    executeMulti.mockResolvedValue([{ columns: ["ID", "PAYLOAD"], rows: [[1, "value"]], affected_rows: 0, execution_time_ms: 1 }]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "SELECT * FROM APP.DOCUMENT_VIEW");

    expect(executeMulti).toHaveBeenCalledOnce();
    expect(executeMulti.mock.calls[0]?.[5]).not.toHaveProperty("tableDataPreview");
  });

  it("keeps deferred Oracle LOBs disabled when a keyless source has no safe ROWID path", async () => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
      { name: "PAYLOAD", data_type: "CLOB", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    listIndexes.mockResolvedValue([]);
    lookupLocalCompletionTables.mockReturnValue([]);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "DOCUMENTS",
        selectStar: true,
        columns: [],
      },
    });
    executeMulti.mockResolvedValue([{ columns: ["ID", "PAYLOAD"], rows: [[1, "value"]], affected_rows: 0, execution_time_ms: 1 }]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "SELECT * FROM DOCUMENTS");

    expect(executeMulti).toHaveBeenCalledOnce();
    expect(executeMulti.mock.calls[0]?.[5]).not.toHaveProperty("tableDataPreview");
  });

  it("does not request deferred Oracle LOB handling for ordinary non-LOB queries", async () => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "NAME", data_type: "VARCHAR2(100)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    lookupLocalCompletionTables.mockReturnValue([{ name: "CUSTOMERS", type: "table", schema: "APP" }]);
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => ({
      editable: true,
      analysis: {
        schema: "APP",
        tableName: "CUSTOMERS",
        selectStar: false,
        columns: [{ sourceName: "NAME", resultName: "NAME", expression: "NAME" }, ...(sql.includes("__DBX_PK_0") ? [{ sourceName: "ID", resultName: "__DBX_PK_0", expression: '"ID"' }] : [])],
      },
    }));
    executeMulti.mockResolvedValue([{ columns: ["NAME", "__DBX_PK_0"], rows: [["Alice", 1]], affected_rows: 0, execution_time_ms: 1 }]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "SELECT NAME FROM APP.CUSTOMERS");

    expect(executeMulti).toHaveBeenCalledOnce();
    expect(executeMulti.mock.calls[0]?.[5]).not.toHaveProperty("tableDataPreview");
  });

  it.each([
    ["only a foreign owner is cached", [{ name: "CUSTOMERS", type: "table", schema: "APP" }]],
    [
      "multiple owners are cached",
      [
        { name: "CUSTOMERS", type: "table", schema: "APP" },
        { name: "CUSTOMERS", type: "table", schema: "REPORTING" },
      ],
    ],
  ])("does not infer the current schema when %s", async (_caseName, cachedTables) => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "ORCL", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
      { name: "NAME", data_type: "VARCHAR2(100)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    lookupLocalCompletionTables.mockReturnValue(cachedTables);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "CUSTOMERS",
        selectStar: true,
        columns: [],
      },
    });
    executeMulti.mockResolvedValue([{ columns: ["ID", "NAME"], rows: [[1, "Alice"]], affected_rows: 0, execution_time_ms: 1 }]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "ORCL", "Query");
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "SELECT * FROM CUSTOMERS");

    expect(executeMulti).toHaveBeenCalledWith("oracle-1", "ORCL", "SELECT * FROM CUSTOMERS", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    expect(lookupLocalCompletionTables).not.toHaveBeenCalled();
    expect(store.tabs.find((item) => item.id === tabId)?.result?.hidden_column_indexes).toBeUndefined();
  });

  it("keeps hidden primary keys and editability after database sorting", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "Query");

    await store.executeTabSql(tabId, "SELECT name FROM users", {
      resultBaseSql: "SELECT name FROM users",
      querySort: {
        resultColumns: ["name"],
        columnIndex: 0,
        column: "name",
        direction: "asc",
      },
    });

    expect(buildSortedQuerySql).toHaveBeenCalledWith({
      originalSql: "SELECT name, `id` AS `__DBX_PK_0` FROM users",
      databaseType: "mysql",
      resultColumns: ["name", "__DBX_PK_0"],
      columnIndex: 0,
      column: "name",
      direction: "asc",
      tieBreakerColumnIndexes: [1],
    });
    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "app", "SELECT name, `id` AS `__DBX_PK_0` FROM users ORDER BY name ASC", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.result?.hidden_column_indexes).toEqual([1]);
    expect(tab.resultSortedSql).toBe("SELECT name, `id` AS `__DBX_PK_0` FROM users ORDER BY name ASC");
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["name", "id"]));
    expect(tab.queryAnalysis).toBeDefined();

    await store.executeTabSql(tabId, "SELECT name FROM users", {
      resultBaseSql: "SELECT name FROM users",
      resultSortedSql: tab.resultSortedSql,
      querySort: {
        resultColumns: ["name"],
        columnIndex: 0,
        column: "name",
        direction: "asc",
      },
      pagination: { offset: 100, limit: 100 },
    });

    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["name", "id"]));
    expect(tab.queryEditabilityReason).toBeUndefined();
    expect(tab.result?.hidden_column_indexes).toEqual([1]);
  });

  it("clears result sorting when the editor SQL is executed again", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "Query");
    const tab = store.tabs.find((item) => item.id === tabId)!;
    tab.resultSortColumn = "name";
    tab.resultSortColumnIndex = 0;
    tab.resultSortDirection = "desc";
    tab.resultSortMode = "database";
    tab.resultSortedSql = "SELECT name FROM users ORDER BY name DESC";

    await store.executeCurrentSql("SELECT name FROM users");

    expect(tab.resultSortColumn).toBeUndefined();
    expect(tab.resultSortColumnIndex).toBeUndefined();
    expect(tab.resultSortDirection).toBeUndefined();
    expect(tab.resultSortMode).toBeUndefined();
    expect(tab.resultSortedSql).toBeUndefined();
    expect(executeMulti).toHaveBeenLastCalledWith("mysql-1", "app", "SELECT name, `id` AS `__DBX_PK_0` FROM users", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
  });

  it("preserves the original query behavior when the primary key is already returned", async () => {
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "users",
        selectStar: false,
        columns: [
          { sourceName: "id", resultName: "id", expression: "id" },
          { sourceName: "name", resultName: "name", expression: "name" },
        ],
      },
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["id", "name"],
        rows: [[7, "Alice"]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "Query");

    await store.executeTabSql(tabId, "SELECT id, name FROM users");

    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "app", "SELECT id, name FROM users", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.result?.hidden_column_indexes).toBeUndefined();
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["id", "name"]));
    expect(tab.queryAnalysis?.allowInsert).toBeUndefined();
    expect(tab.queryEditabilityReason).toBeUndefined();
  });

  it("loads unqualified Oracle metadata from the login schema instead of the service name", async () => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "XEPDB1", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "ID", data_type: "NUMBER", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "NAME", data_type: "VARCHAR2", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => {
      const hidden = sql.includes("__DBX_PK_0");
      return {
        editable: true,
        analysis: {
          schema: undefined,
          tableName: "DBX_HIDDEN_PK_EDIT_TEST",
          selectStar: false,
          columns: [{ sourceName: "NAME", resultName: "NAME", expression: "NAME" }, ...(hidden ? [{ sourceName: "ID", resultName: "__DBX_PK_0", expression: '"ID"' }] : [])],
        },
      };
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["NAME", "__DBX_PK_0"],
        rows: [["Alice", 7]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "XEPDB1", "Query");
    // Exercise the explicit auto-commit execute-multi path.
    store.setAutoCommit(tabId, true);

    await store.executeTabSql(tabId, "SELECT NAME FROM DBX_HIDDEN_PK_EDIT_TEST");

    expect(getColumns).toHaveBeenCalledWith("oracle-1", "XEPDB1", "", "DBX_HIDDEN_PK_EDIT_TEST", undefined);
    expect(executeMulti).toHaveBeenCalledWith("oracle-1", "XEPDB1", 'SELECT NAME, "ID" AS "__DBX_PK_0" FROM DBX_HIDDEN_PK_EDIT_TEST', undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.result?.hidden_column_indexes).toEqual([1]);
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["NAME", "ID"]));
    expect(tab.queryAnalysis).toBeDefined();
    expect(tab.queryAnalysis?.allowInsert).toBe(false);
    expect(tab.queryEditabilityReason).toBeUndefined();
  });

  it("keeps SQL Server updates unqualified when the SELECT source is unqualified", async () => {
    getConnectionConfig.mockReturnValue({ id: "sqlserver-1", name: "SQL Server 2008", db_type: "sqlserver", database: "cdc", query_timeout_secs: 30 });
    getColumns.mockResolvedValue([
      { name: "id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "a4", data_type: "nvarchar(100)", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "yb_ty_qtxx",
        selectStar: true,
        columns: [{ sourceName: undefined, star: true, resultName: "*", expression: "*" }],
      },
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["id", "a4"],
        rows: [[1, "德谷胰岛素利拉鲁肽"]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("sqlserver-1", "cdc", "Query", "query", "cdc");

    await store.executeTabSql(tabId, "select * from yb_ty_qtxx where a4 like N'%德谷胰岛素利拉鲁%'");

    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.tableMeta).toBeDefined());
    expect(getColumns).toHaveBeenCalledWith("sqlserver-1", "cdc", "", "yb_ty_qtxx", undefined);
    expect(tab.tableMeta?.database).toBe("cdc");
    expect(tab.tableMeta?.schema).toBeUndefined();
  });

  it("preserves an explicitly qualified SQL Server update source", async () => {
    getConnectionConfig.mockReturnValue({ id: "sqlserver-1", name: "SQL Server 2008", db_type: "sqlserver", database: "cdc", query_timeout_secs: 30 });
    analyzeEditableQueryEditability.mockResolvedValue({
      editable: true,
      analysis: {
        schema: "sales",
        tableName: "yb_ty_qtxx",
        selectStar: true,
        columns: [{ sourceName: undefined, star: true, resultName: "*", expression: "*" }],
      },
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["id", "a4"],
        rows: [[1, "德谷胰岛素利拉鲁肽"]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("sqlserver-1", "cdc", "Query", "query", "cdc");

    await store.executeTabSql(tabId, "select * from sales.yb_ty_qtxx");

    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.tableMeta).toBeDefined());
    expect(getColumns).toHaveBeenCalledWith("sqlserver-1", "cdc", "sales", "yb_ty_qtxx", undefined);
    expect(tab.tableMeta?.database).toBe("cdc");
    expect(tab.tableMeta?.schema).toBe("sales");
  });

  it("appends only the missing part of a composite primary key", async () => {
    getColumns.mockResolvedValue([
      { name: "tenant_id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "item_id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "name", data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => {
      const hidden = sql.includes("__DBX_PK_0");
      return {
        editable: true,
        analysis: {
          schema: undefined,
          tableName: "items",
          selectStar: false,
          columns: [{ sourceName: "tenant_id", resultName: "tenant_id", expression: "tenant_id" }, { sourceName: "name", resultName: "name", expression: "name" }, ...(hidden ? [{ sourceName: "item_id", resultName: "__DBX_PK_0", expression: "`item_id`" }] : [])],
        },
      };
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["tenant_id", "name", "__DBX_PK_0"],
        rows: [[3, "Alice", 7]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "Query");

    await store.executeTabSql(tabId, "SELECT tenant_id, name FROM items");

    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "app", "SELECT tenant_id, name, `item_id` AS `__DBX_PK_0` FROM items", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.result?.hidden_column_indexes).toEqual([2]);
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["tenant_id", "name", "item_id"]));
  });

  it("executes the original SQL when metadata loading fails", async () => {
    getColumns.mockRejectedValue(new Error("metadata unavailable"));
    executeMulti.mockResolvedValue([
      {
        columns: ["name"],
        rows: [["Alice"]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "Query");

    await store.executeTabSql(tabId, "SELECT name FROM users");

    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "app", "SELECT name FROM users", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.queryEditabilityReason).toBe("metadata-unavailable"));
    expect(tab.result?.hidden_column_indexes).toBeUndefined();
  });

  it("injects a non-null unique index when the table has no declared primary key", async () => {
    getColumns.mockResolvedValue([
      { name: "email", data_type: "varchar", is_nullable: false, column_default: null, is_primary_key: false, extra: null },
      { name: "name", data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    listIndexes.mockResolvedValue([{ name: "uq_users_email", columns: ["email"], is_unique: true, is_primary: false }]);
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => ({
      editable: true,
      analysis: {
        schema: undefined,
        tableName: "users",
        selectStar: false,
        columns: [{ sourceName: "name", resultName: "name", expression: "name" }, ...(sql.includes("__DBX_PK_0") ? [{ sourceName: "email", resultName: "__DBX_PK_0", expression: "`email`" }] : [])],
      },
    }));
    executeMulti.mockResolvedValue([
      {
        columns: ["name", "__DBX_PK_0"],
        rows: [["Alice", "[email protected]"]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "Query");

    await store.executeTabSql(tabId, "SELECT name FROM users");

    expect(executeMulti).toHaveBeenCalledWith("mysql-1", "app", "SELECT name, `email` AS `__DBX_PK_0` FROM users", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 }));
    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.result?.hidden_column_indexes).toEqual([1]);
    await vi.waitFor(() => expect(tab.querySourceColumns).toEqual(["name", "email"]));
    expect(tab.queryEditabilityReason).toBeUndefined();
  });

  it("hides returned internal keys but remains read-only when another hidden key is missing", async () => {
    getColumns.mockResolvedValue([
      { name: "tenant_id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "item_id", data_type: "int", is_nullable: false, column_default: null, is_primary_key: true, extra: null },
      { name: "name", data_type: "varchar", is_nullable: true, column_default: null, is_primary_key: false, extra: null },
    ]);
    analyzeEditableQueryEditability.mockImplementation(async (sql: string) => {
      const hidden = sql.includes("__DBX_PK_0");
      return {
        editable: true,
        analysis: {
          schema: undefined,
          tableName: "items",
          selectStar: false,
          columns: [
            { sourceName: "name", resultName: "name", expression: "name" },
            ...(hidden
              ? [
                  { sourceName: "tenant_id", resultName: "__DBX_PK_0", expression: "`tenant_id`" },
                  { sourceName: "item_id", resultName: "__DBX_PK_1", expression: "`item_id`" },
                ]
              : []),
          ],
        },
      };
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["name", "__DBX_PK_1"],
        rows: [["Alice", 7]],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "Query");

    await store.executeTabSql(tabId, "SELECT name FROM items");

    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.result?.hidden_column_indexes).toEqual([1]);
    await vi.waitFor(() => expect(tab.queryEditabilityReason).toBe("primary-key-not-returned"));
    expect(tab.queryAnalysis).toBeUndefined();
  });

  it.each([
    { manual: false, tailRows: 0 },
    { manual: false, tailRows: 1 },
    { manual: false, tailRows: 4 },
    { manual: true, tailRows: 0 },
    { manual: true, tailRows: 1 },
    { manual: true, tailRows: 4 },
  ])("accounts for appended rows once (manual=$manual, tail=$tailRows)", async ({ manual, tailRows }) => {
    editorSettings.queryResultMaxRows = 10;
    analyzeEditableQueryEditability.mockResolvedValue({ editable: false });
    prepareQueryPaginationExecutionPlan.mockImplementation(async (options) => ({
      sqlToExecute: options.sql,
      pageSql: options.sql,
      pageLimit: options.pagination.limit,
      pageOffset: options.pagination.offset,
      countSql: undefined,
      useAgentResultSession: false,
    }));
    const page = (offset: number, count: number) => ({ columns: ["id"], rows: Array.from({ length: count }, (_, index) => [offset + index]), has_more: false, affected_rows: 0, execution_time_ms: 1 });
    const execute = manual ? executeInManualTransaction : executeMulti;
    execute.mockResolvedValueOnce([page(0, 6)]).mockResolvedValueOnce([page(6, tailRows)]);
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const id = store.createTab("mysql-1", "app", "Query");
    const tab = store.tabs.find((item) => item.id === id)!;
    if (manual) {
      tab.autoCommit = false;
      tab.txnSessionId = "source-transaction";
    }
    await store.executeTabSql(id, "SELECT id FROM items", { pagination: { limit: 6, offset: 0 } });
    await store.executeTabSql(id, "SELECT id FROM items", {
      pagination: { limit: 4, offset: 6 },
      preserveResultDuringExecution: true,
      appendResult: { maxRows: 10 },
    });
    expect(tab.result?.rows).toHaveLength(6 + tailRows);
    expect(tab.result?.truncated === true).toBe(tailRows === 4);
    expect(tab.resultExecutedPageOffset).toBe(6);
    expect(tab.resultPageOffset).toBe(0);
    if (tailRows < 4) {
      expect((await store.fetchTabResultForExport(id, undefined, true))?.rows).toEqual(tab.result?.rows);
      expect(execute).toHaveBeenCalledTimes(2);
    }
    if (manual) expect(tab.txnSessionId).toBe("source-transaction");
  });

  it("removes the generated row number before appending OceanBase Oracle pages", async () => {
    const sql = "SELECT LEVEL AS N FROM DUAL CONNECT BY LEVEL <= 4";
    getConnectionConfig.mockReturnValue({ id: "ob-1", name: "OceanBase", db_type: "oceanbase-oracle", database: "app" });
    analyzeEditableQueryEditability.mockResolvedValue({ editable: false });
    prepareQueryPaginationExecutionPlan.mockImplementation(async (options) => ({
      sqlToExecute: options.sql,
      pageSql: options.sql,
      pageLimit: options.pagination.limit,
      pageOffset: options.pagination.offset,
      countSql: undefined,
      useAgentResultSession: false,
      paginationRowNumberColumn: options.pagination.offset > 0 ? "__dbx_row_num" : undefined,
    }));
    executeMulti.mockResolvedValueOnce([{ columns: ["N"], rows: [[1], [2]], affected_rows: 0, execution_time_ms: 1 }]).mockResolvedValueOnce([
      {
        columns: ["N", "__dbx_row_num"],
        rows: [
          [3, 3],
          [4, 4],
        ],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("ob-1", "app", "Query");
    await store.executeTabSql(tabId, sql, { pagination: { limit: 2, offset: 0 } });
    await store.executeTabSql(tabId, sql, {
      pagination: { limit: 2, offset: 2 },
      preserveResultDuringExecution: true,
      appendResult: { maxRows: 10 },
    });
    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.result?.columns).toEqual(["N"]);
    expect(tab.result?.rows).toEqual([[1], [2], [3], [4]]);

    prepareQueryPaginationExecutionPlan.mockImplementation(async (options) => ({
      sqlToExecute: options.sql,
      pageSql: options.sql,
      pageLimit: 2,
      pageOffset: options.pagination.offset,
      countSql: undefined,
      useAgentResultSession: false,
      paginationRowNumberColumn: options.pagination.offset > 0 ? "__dbx_row_num" : undefined,
    }));
    executeMulti
      .mockResolvedValueOnce([{ columns: ["N"], rows: [[1], [2]], affected_rows: 0, execution_time_ms: 1 }])
      .mockResolvedValueOnce([
        {
          columns: ["N", "__dbx_row_num"],
          rows: [
            [3, 3],
            [4, 4],
          ],
          affected_rows: 0,
          execution_time_ms: 1,
        },
      ])
      .mockResolvedValueOnce([{ columns: ["N", "__dbx_row_num"], rows: [], affected_rows: 0, execution_time_ms: 1 }]);
    const exported = await store.fetchTabResultForExport(tabId);
    expect(exported?.columns).toEqual(["N"]);
    expect(exported?.rows).toEqual([[1], [2], [3], [4]]);
  });

  it("records the returned row count when a page is known to be incomplete without count sql", async () => {
    prepareQueryPaginationExecutionPlan.mockResolvedValue({
      sqlToExecute: "SELECT name FROM users LIMIT 100 OFFSET 0",
      pageSql: "SELECT name FROM users LIMIT 100 OFFSET 0",
      pageLimit: 100,
      pageOffset: 0,
      countSql: undefined,
      useAgentResultSession: false,
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["name"],
        rows: Array.from({ length: 42 }, (_, index) => [`user-${index}`]),
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "Query");

    await store.executeTabSql(tabId, "SELECT name FROM users");

    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.resultTotalRowCount).toBe(42);
    expect(tab.resultTotalRowCountLoading).toBe(false);
    expect(executeQuery).not.toHaveBeenCalled();
  });

  it("does not treat an empty later page as the total row count", async () => {
    prepareQueryPaginationExecutionPlan.mockResolvedValue({
      sqlToExecute: "SELECT name FROM users LIMIT 100 OFFSET 200",
      pageSql: "SELECT name FROM users LIMIT 100 OFFSET 200",
      pageLimit: 100,
      pageOffset: 200,
      countSql: undefined,
      useAgentResultSession: false,
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["name"],
        rows: [],
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "Query");

    await store.executeTabSql(tabId, "SELECT name FROM users");

    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.resultTotalRowCount).toBeUndefined();
    expect(tab.resultTotalRowCountLoading).toBe(false);
    expect(executeQuery).not.toHaveBeenCalled();
  });

  it("automatically counts table data totals when the setting is enabled", async () => {
    editorSettings.autoCalculateTotalRows = true;
    executeMulti.mockResolvedValue([
      {
        columns: ["id", "name"],
        rows: Array.from({ length: 100 }, (_, index) => [index + 1, `user-${index + 1}`]),
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);
    executeQuery.mockResolvedValue({
      columns: ["row_count"],
      rows: [[123]],
      affected_rows: 0,
      execution_time_ms: 1,
    });

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("mysql-1", "app", "users", "data", "public");
    store.setTableMeta(tabId, {
      schema: "public",
      tableName: "users",
      columns: [
        { name: "id", data_type: "int", is_nullable: false, is_primary_key: true, column_default: null, extra: null },
        { name: "name", data_type: "varchar", is_nullable: true, is_primary_key: false, column_default: null, extra: null },
      ],
      primaryKeys: ["id"],
    });

    await store.executeTabSql(tabId, "SELECT id, name FROM users LIMIT 100", {
      pagination: { limit: 100, offset: 0 },
    });

    expect(buildDataGridCountSql).toHaveBeenCalledWith({
      databaseType: "mysql",
      identifierQuote: undefined,
      catalog: undefined,
      database: "app",
      schema: "public",
      tableName: "users",
      whereInput: undefined,
    });
    await vi.waitFor(() => expect(executeQuery).toHaveBeenCalledWith("mysql-1", "app", "SELECT COUNT(*) FROM `users`", undefined, expect.any(String), expect.objectContaining({ timeoutSecs: 30 })));
    const tab = store.tabs.find((item) => item.id === tabId)!;
    await vi.waitFor(() => expect(tab.resultTotalRowCount).toBe(123));
    expect(tab.resultTotalRowCountLoading).toBe(false);
  });

  it.each([
    ["disabled by default", undefined, undefined],
    ["explicitly enabled", { gaussdbCountQueryDop: 8 }, "/*+ set(query_dop 8) */"],
  ])("keeps GaussDB count parallelism %s", async (_label, externalConfig, expectedCountHint) => {
    editorSettings.autoCalculateTotalRows = true;
    getConnectionConfig.mockReturnValue({
      id: "gaussdb-1",
      name: "GaussDB",
      db_type: "gaussdb",
      database: "app",
      query_timeout_secs: 30,
      external_config: externalConfig,
    });
    executeMulti.mockResolvedValue([
      {
        columns: ["id", "name"],
        rows: Array.from({ length: 100 }, (_, index) => [index + 1, `user-${index + 1}`]),
        affected_rows: 0,
        execution_time_ms: 1,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("gaussdb-1", "app", "users", "data", "public");
    store.setTableMeta(tabId, {
      schema: "public",
      tableName: "users",
      columns: [
        { name: "id", data_type: "int", is_nullable: false, is_primary_key: true, column_default: null, extra: null },
        { name: "name", data_type: "varchar", is_nullable: true, is_primary_key: false, column_default: null, extra: null },
      ],
      primaryKeys: ["id"],
    });

    await store.executeTabSql(tabId, "SELECT id, name FROM users LIMIT 100", {
      pagination: { limit: 100, offset: 0 },
    });

    await vi.waitFor(() =>
      expect(buildDataGridCountSql).toHaveBeenCalledWith({
        databaseType: "gaussdb",
        identifierQuote: undefined,
        catalog: undefined,
        database: "app",
        schema: "public",
        tableName: "users",
        whereInput: undefined,
        countHint: expectedCountHint,
      }),
    );
  });

  it.each([
    ["disabled by default", undefined, undefined],
    ["explicitly enabled", { gaussdbCountQueryDop: 8 }, "/*+ set(query_dop 8) */"],
  ])("passes the GaussDB query_dop hint to query-result count and page planning %s", async (_label, externalConfig, expectedHint) => {
    getConnectionConfig.mockReturnValue({
      id: "gaussdb-1",
      name: "GaussDB",
      db_type: "gaussdb",
      database: "app",
      query_timeout_secs: 30,
      external_config: externalConfig,
    });
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("gaussdb-1", "app", "Query");

    await store.executeTabSql(tabId, "SELECT id, name FROM users", {
      pagination: { limit: 100, offset: 0 },
    });

    expect(prepareQueryPaginationExecutionPlan).toHaveBeenCalledWith(
      expect.objectContaining({
        databaseType: "gaussdb",
        queryBaseSql: "SELECT id, name FROM users",
        executionHint: expectedHint,
      }),
    );
  });

  it.each([
    [true, 100_000],
    [false, 100_000],
    [true, 2455],
    [false, 2455],
  ] as const)("keeps Oracle last-page and previous-page rows correct with autoCommit=%s, maxRows=%s (#13173)", async (autoCommit, maxRows) => {
    editorSettings.queryResultMaxRows = maxRows;
    getConnectionConfig.mockReturnValue({ id: "oracle-1", name: "Oracle", db_type: "oracle", database: "XE", query_timeout_secs: 30 });
    analyzeEditableQueryEditability.mockResolvedValue({ editable: false, reason: "complex-query" });
    prepareQueryPaginationExecutionPlan.mockImplementation(async (options) => ({
      sqlToExecute: options.sql,
      pageLimit: options.pagination.limit,
      pageOffset: options.pagination.offset,
      useAgentResultSession: true,
    }));
    const rows = Array.from({ length: 2473 }, (_, index) => [index + 1]);
    const total = Math.min(rows.length, maxRows);
    let position = 0;
    const readPage = (maxRows: number, pageSize?: number, sessionId?: string) => {
      if (!sessionId) position = 0;
      const pageRows = rows.slice(position, Math.min(position + (pageSize ?? maxRows), maxRows));
      position += pageRows.length;
      const hasMore = !!pageSize && position < Math.min(rows.length, maxRows);
      return [{ columns: ["ID"], rows: pageRows, affected_rows: 0, execution_time_ms: 1, has_more: hasMore, session_id: hasMore ? "oracle-cursor" : undefined, manual_transaction_proven_read_only: sessionId ? undefined : true }];
    };
    executeMulti.mockImplementation(async (_connection, _database, _sql, _schema, _execution, options) => readPage(options.maxRows, options.pageSize, options.resultSessionId));
    executeInManualTransaction.mockImplementation(async (_txn, _sql, _database, _schema, maxRows, _preview, pageSize, sessionId) => readPage(maxRows, pageSize, sessionId));
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("oracle-1", "XE", "Query");
    store.setAutoCommit(tabId, autoCommit);
    const tab = store.tabs.find((item) => item.id === tabId)!;
    const sql = "WITH a AS (SELECT id FROM events) SELECT a.* FROM a ORDER BY id";
    const loadPage = (offset: number, sessionId?: string) =>
      store.executeTabSql(tabId, sql, {
        pagination: { limit: 200, offset, sessionId },
        preserveResultDuringExecution: true,
        preserveTotalRowCountDuringExecution: true,
      });
    await loadPage(0);
    expect(tab.result?.rows).toEqual(rows.slice(0, 200));
    await loadPage(200, tab.resultSessionId);
    expect(tab.result?.rows).toEqual(rows.slice(200, 400));
    tab.resultTotalRowCount = 2473;

    await loadPage(2400);
    expect(tab.result?.rows).toEqual(rows.slice(2400, total));
    expect(tab.resultPageOffset).toBe(2400);
    expect(tab.resultTotalRowCount).toBe(total);
    expect(tab.result?.has_more).toBe(false);

    await loadPage(2200);
    expect(tab.result?.rows).toEqual(rows.slice(2200, 2400));
    expect(tab.resultPageOffset).toBe(2200);
    expect(tab.result?.has_more).toBe(true);
    if (!autoCommit) expect(tab.result?.manual_transaction_session_id).toBe("txn-1");
    await loadPage(2400, tab.resultSessionId);
    expect(tab.result?.rows).toEqual(rows.slice(2400, total));
    expect(tab.resultTotalRowCount).toBe(total);
    expect(tab.autoCommit).toBe(autoCommit);
    if (!autoCommit) {
      expect(executeMulti).not.toHaveBeenCalled();
      expect(beginManualTransaction).toHaveBeenCalledTimes(1);
      expect(executeInManualTransaction.mock.calls.every((call) => call[0] === "txn-1")).toBe(true);
      expect(executeInManualTransaction.mock.calls.every((call) => call[4] === maxRows)).toBe(true);
      expect(tab.txnPossiblyDirty).not.toBe(true);
    }
  });

  it.each(["fetch error", "missing cursor"])("closes the manual replay cursor after a %s without switching connections", async (failure) => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", db_type: "oracle", database: "XE" });
    analyzeEditableQueryEditability.mockResolvedValue({ editable: false });
    prepareQueryPaginationExecutionPlan.mockResolvedValue({ sqlToExecute: "SELECT * FROM events", pageLimit: 2, pageOffset: 4, useAgentResultSession: true });
    executeInManualTransaction.mockResolvedValueOnce([{ columns: ["ID"], rows: [[1], [2]], affected_rows: 0, execution_time_ms: 1, has_more: true, session_id: "cursor-1", manual_transaction_proven_read_only: true }]);
    if (failure === "fetch error") executeInManualTransaction.mockRejectedValueOnce(new Error("Cursor fetch failed"));
    else executeInManualTransaction.mockResolvedValueOnce([{ columns: ["ID"], rows: [], affected_rows: 0, execution_time_ms: 1, has_more: true }]);
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const id = store.createTab("oracle-1", "XE", "Query");
    store.setAutoCommit(id, false);

    await store.executeTabSql(id, "SELECT * FROM events", { pagination: { limit: 2, offset: 4 } });

    expect(executeInManualTransaction).toHaveBeenCalledTimes(2);
    expect(closeQuerySession).toHaveBeenCalledWith("oracle-1", "XE", "cursor-1", undefined, undefined, "txn-1");
    expect(executeMulti).not.toHaveBeenCalled();
    expect(store.tabs.find((tab) => tab.id === id)?.result?.execution_error).toBe(true);
  });

  it.each([
    [1, "cancel"],
    [3, "cancel"],
    [3, "supersede"],
  ] as const)("closes the returned manual cursor when page %s is interrupted by %s", async (interruptAt, interruption) => {
    getConnectionConfig.mockReturnValue({ id: "oracle-1", db_type: "oracle", database: "XE" });
    analyzeEditableQueryEditability.mockResolvedValue({ editable: false });
    prepareQueryPaginationExecutionPlan.mockResolvedValue({ sqlToExecute: "SELECT * FROM events", pageLimit: 2, pageOffset: 4, useAgentResultSession: true });
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const id = store.createTab("oracle-1", "XE", "Query");
    store.setAutoCommit(id, false);
    const tab = store.tabs.find((item) => item.id === id)!;
    let calls = 0;
    executeInManualTransaction.mockImplementation(async () => {
      calls += 1;
      if (calls === interruptAt) {
        if (interruption === "cancel") tab.cancelRequestCount = (tab.cancelRequestCount ?? 0) + 1;
        else tab.executionId = "replacement-execution";
      }
      return [{ columns: ["ID"], rows: [[calls * 2 - 1], [calls * 2]], affected_rows: 0, execution_time_ms: 1, has_more: true, session_id: `cursor-${calls}`, manual_transaction_proven_read_only: calls === 1 ? true : undefined }];
    });

    await store.executeTabSql(id, "SELECT * FROM events", { pagination: { limit: 2, offset: 4 } });

    expect(executeInManualTransaction).toHaveBeenCalledTimes(interruptAt);
    expect(closeQuerySession).toHaveBeenCalledWith("oracle-1", "XE", `cursor-${interruptAt}`, undefined, undefined, "txn-1");
    expect(executeMulti).not.toHaveBeenCalled();
    expect(tab.result?.rows).not.toEqual([[5], [6]]);
  });

  it("closes retained manual cursors by their original transaction even when their IDs match", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const id = store.createTab("oracle-1", "XE", "Query");
    const tab = store.tabs.find((item) => item.id === id)!;
    tab.txnSessionId = "newest-txn";
    const result = (owner: string) => ({ columns: ["ID"], rows: [[1]], affected_rows: 0, execution_time_ms: 1, session_id: "cursor-1", manual_transaction_session_id: owner });
    tab.result = result("txn-current-result");
    tab.resultSessionId = "cursor-1";
    tab.resultClientSessionId = id;
    tab.resultRuns = [{ id: "old-run", title: "Old result", sequence: 1, sql: "SELECT * FROM events", createdAt: 0, result: result("txn-old-result"), resultSessionId: "cursor-1", resultClientSessionId: id }];

    await store.clearQueryResults(id);

    expect(closeQuerySession.mock.calls).toEqual([
      ["oracle-1", "XE", "cursor-1", undefined, undefined, "txn-current-result"],
      ["oracle-1", "XE", "cursor-1", undefined, undefined, "txn-old-result"],
    ]);
    expect(closeClientConnectionSession).not.toHaveBeenCalled();
    expect(tab.txnSessionId).toBe("newest-txn");
  });

  it("does not clear a replacement cursor while the old transaction's close is pending", async () => {
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const id = store.createTab("oracle-1", "XE", "Query");
    const tab = store.tabs.find((item) => item.id === id)!;
    tab.result = { columns: ["ID"], rows: [[1]], affected_rows: 0, execution_time_ms: 1, session_id: "cursor-1", manual_transaction_session_id: "old-txn" };
    tab.resultSessionId = "cursor-1";
    const pendingClose = deferred<boolean>();
    closeQuerySession.mockReturnValueOnce(pendingClose.promise);
    const clearing = store.clearQueryResults(id);
    tab.result = { columns: ["ID"], rows: [[2]], affected_rows: 0, execution_time_ms: 1, session_id: "cursor-1", manual_transaction_session_id: "new-txn" };
    tab.resultSessionId = "cursor-1";
    tab.resultClientSessionId = id;
    pendingClose.resolve(true);
    await clearing;

    expect(tab.resultSessionId).toBe("cursor-1");
    expect(tab.resultClientSessionId).toBe(id);
    expect(tab.result.manual_transaction_session_id).toBe("new-txn");
    expect(tab.result.session_id).toBe("cursor-1");
    expect(closeQuerySession).toHaveBeenCalledWith("oracle-1", "XE", "cursor-1", undefined, undefined, "old-txn");
  });

  it("advances an OceanBase duplicate projection cursor through an offset jump and next page", async () => {
    getConnectionConfig.mockReturnValue({ id: "ob-1", name: "OceanBase", db_type: "oceanbase-oracle", database: "app", query_timeout_secs: 30 });
    analyzeEditableQueryEditability.mockResolvedValue({ editable: false, reason: "complex-query" });
    prepareQueryPaginationExecutionPlan.mockImplementation(async (options) => ({
      sqlToExecute: options.sql,
      pageSql: undefined,
      pageLimit: options.pagination.limit,
      pageOffset: options.pagination.offset,
      countSql: undefined,
      useAgentResultSession: true,
    }));
    let row = 0;
    executeMulti.mockImplementation(async () => [
      {
        columns: ["NAME", "NAME"],
        rows: Array.from({ length: 2 }, () => [++row, row]),
        affected_rows: 0,
        execution_time_ms: 1,
        session_id: "ob-cursor",
        has_more: row < 8,
      },
    ]);
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("ob-1", "app", "Query");
    const sql = "SELECT a.name, a.* FROM people a ORDER BY a.id";
    await store.executeTabSql(tabId, sql, { pagination: { limit: 2, offset: 4 } });
    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(tab.result?.rows).toEqual([
      [5, 5],
      [6, 6],
    ]);
    expect(executeMulti).toHaveBeenCalledTimes(3);
    expect(executeMulti.mock.calls[0]![5]).toEqual(expect.objectContaining({ pageSize: 2, fetchSize: 2, resultSessionId: undefined }));
    expect(executeMulti.mock.calls[0]![5].maxRows).toBeGreaterThan(2);
    expect(executeMulti.mock.calls[1]![5].resultSessionId).toBe("ob-cursor");
    await store.executeTabSql(tabId, sql, { pagination: { limit: 2, offset: 6, sessionId: "ob-cursor" } });
    expect(executeMulti).toHaveBeenCalledTimes(4);
    expect(executeMulti.mock.calls[3]![2]).toBe(sql);
    expect(tab.result?.rows).toEqual([
      [7, 7],
      [8, 8],
    ]);
    expect(tab.result?.columns).toEqual(["NAME", "NAME"]);
  });

  it.each(["SELECT * FROM events", "SELECT t.* FROM events t"])("preserves a real __dbx_row_num column across OceanBase wildcard pages: %s", async (sql) => {
    getConnectionConfig.mockReturnValue({ id: "ob-1", name: "OceanBase", db_type: "oceanbase-oracle", database: "app", query_timeout_secs: 30 });
    analyzeEditableQueryEditability.mockResolvedValue({ editable: false, reason: "complex-query" });
    prepareQueryPaginationExecutionPlan.mockImplementation(async (options) => ({
      sqlToExecute: options.sql,
      pageLimit: options.pagination.limit,
      pageOffset: options.pagination.offset,
      useAgentResultSession: true,
    }));
    let row = 0;
    executeMulti.mockImplementation(async () => [
      {
        columns: ["ID", "__dbx_row_num"],
        rows: Array.from({ length: 2 }, () => [++row, `user-${row}`]),
        affected_rows: 0,
        execution_time_ms: 1,
        session_id: "ob-star-cursor",
        has_more: row < 6,
      },
    ]);
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("ob-1", "app", "Query");
    for (const offset of [0, 2, 4]) {
      await store.executeTabSql(tabId, sql, { pagination: { limit: 2, offset, sessionId: offset ? "ob-star-cursor" : undefined } });
      const result = store.tabs.find((item) => item.id === tabId)!.result;
      expect(result?.columns).toEqual(["ID", "__dbx_row_num"]);
      expect(result?.rows).toEqual([
        [offset + 1, `user-${offset + 1}`],
        [offset + 2, `user-${offset + 2}`],
      ]);
    }
    expect(executeMulti).toHaveBeenCalledTimes(3);
    for (const [index, call] of executeMulti.mock.calls.entries()) {
      expect(call[2]).toBe(sql);
      expect(call[5]).toEqual(expect.objectContaining({ pageSize: 2, fetchSize: 2, resultSessionId: index ? "ob-star-cursor" : undefined }));
    }
  });

  it("does not execute an OceanBase offset plan rejected without a cursor", async () => {
    getConnectionConfig.mockReturnValue({ id: "ob-1", name: "OceanBase", db_type: "oceanbase-oracle", database: "app", query_timeout_secs: 30 });
    analyzeEditableQueryEditability.mockResolvedValue({ editable: false, reason: "complex-query" });
    prepareQueryPaginationExecutionPlan.mockImplementation(async () => ({
      sqlToExecute: "",
      pageSql: undefined,
      pageLimit: undefined,
      pageOffset: undefined,
      countSql: undefined,
      useAgentResultSession: false,
      paginationError: "This query requires an Agent result session for offset pagination",
    }));
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("ob-1", "app", "Query");
    await store.executeTabSql(tabId, "SELECT name, name FROM people", { pagination: { limit: 2, offset: 4 } });
    expect(store.tabs.find((item) => item.id === tabId)?.result?.execution_error).toBe(true);
    expect(executeMulti).not.toHaveBeenCalled();
    expect(executeInManualTransaction).not.toHaveBeenCalled();
  });

  it("rejects a fresh OceanBase manual-transaction offset instead of repeating the first page", async () => {
    getConnectionConfig.mockReturnValue({ id: "ob-1", name: "OceanBase", db_type: "oceanbase-oracle", database: "app", query_timeout_secs: 30 });
    analyzeEditableQueryEditability.mockResolvedValue({ editable: false, reason: "complex-query" });
    prepareQueryPaginationExecutionPlan.mockImplementation(async (options) => ({
      sqlToExecute: options.sql,
      pageSql: undefined,
      pageLimit: options.pagination.limit,
      pageOffset: options.pagination.offset,
      countSql: undefined,
      useAgentResultSession: true,
    }));
    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("ob-1", "app", "Query");
    store.setAutoCommit(tabId, false);
    await store.executeTabSql(tabId, "SELECT name, name FROM people", { pagination: { limit: 2, offset: 4 } });
    expect(store.tabs.find((item) => item.id === tabId)?.result?.execution_error).toBe(true);
    expect(executeMulti).not.toHaveBeenCalled();
    expect(executeInManualTransaction).not.toHaveBeenCalled();
  });

  it("stops appending when a SQL Server query has no bounded next-page plan", async () => {
    getConnectionConfig.mockReturnValue({ id: "sqlserver-1", name: "SQL Server", db_type: "sqlserver", database: "app", query_timeout_secs: 30 });
    analyzeEditableQueryEditability.mockResolvedValue({ editable: false, reason: "complex-query" });
    const rows = Array.from({ length: 28 }, (_, index) => [index + 1]);
    executeMulti.mockResolvedValueOnce([
      {
        columns: ["id"],
        rows,
        affected_rows: 28,
        execution_time_ms: 1,
        has_more: true,
      },
    ]);

    const { useQueryStore } = await import("@/stores/queryStore");
    const store = useQueryStore();
    const tabId = store.createTab("sqlserver-1", "app", "Query");
    const sql = "SELECT a.id, b.* FROM orders a JOIN order_details b ON b.order_id = a.id";

    await store.executeTabSql(tabId, sql);
    expect(executeMulti).toHaveBeenCalledTimes(1);

    await store.executeTabSql(tabId, sql, {
      resultBaseSql: sql,
      pagination: { limit: 25, offset: 28 },
      appendResult: { maxRows: 10_000 },
      preserveResultDuringExecution: true,
      preserveTotalRowCountDuringExecution: true,
      replaceActiveResultInGroup: true,
    });

    const tab = store.tabs.find((item) => item.id === tabId)!;
    expect(executeMulti).toHaveBeenCalledTimes(1);
    expect(tab.result?.rows).toEqual(rows);
    expect(tab.result?.has_more).toBe(false);
  });
});