import { describe, expect, it } from "vitest";
import { executionCandidateForMode } from "@/lib/sql/sqlExecutionTarget";
import { buildExecutionCandidates, currentExecutableStatementRange, executableStatementRanges, fullSqlRange, hasMultipleExecutionTargets, splitSqlStatementRanges, statementRangeAtCursor, supportsExecutionTargetPicker } from "@/lib/sql/sqlStatementRanges";

function indexOf(sql: string, needle: string, occurrence = 1): number {
  let from = 0;
  let idx = -1;
  for (let i = 0; i < occurrence; i += 1) {
    idx = sql.indexOf(needle, from);
    if (idx === -1) return -1;
    from = idx + needle.length;
  }
  return idx;
}

function rangeSqlTexts(ranges: Array<{ sql: string }>): string[] {
  return ranges.map((range) => range.sql.trim());
}

function candidateKinds(candidates: Array<{ kind: string }>): string[] {
  return candidates.map((candidate) => candidate.kind);
}

function candidateLabels(candidates: Array<{ label: string }>): string[] {
  return candidates.map((candidate) => candidate.label);
}

function candidateSummaries(candidates: Array<{ kind: string; sql: string }>): string[] {
  return candidates.map((candidate) => `${candidate.kind}:${candidate.sql.trim()}`);
}

const oraclePlSqlFixture = `DECLARE
  v_order_count NUMBER;
BEGIN
  SELECT COUNT(*) INTO v_order_count
  FROM "DBX_TEST"."ORDERS_10K";

  IF v_order_count = 0 THEN
    INSERT INTO "DBX_TEST"."STORES"
      ("ID", "STORE_CODE", "STORE_NAME", "CITY", "OPENED_AT")
    SELECT 10001, 'TEST_STORE_001', '测试门店', '上海', SYSDATE
    FROM DUAL
    WHERE NOT EXISTS (
      SELECT 1 FROM "DBX_TEST"."STORES" WHERE "ID" = 10001
    );

    INSERT INTO "DBX_TEST"."PRODUCTS"
      ("ID", "SKU", "PRODUCT_NAME", "CATEGORY", "PRICE")
    SELECT 10001, 'TEST_SKU_001', '测试商品', '测试分类', 99.90
    FROM DUAL
    WHERE NOT EXISTS (
      SELECT 1 FROM "DBX_TEST"."PRODUCTS" WHERE "ID" = 10001
    );

    INSERT INTO "DBX_TEST"."ORDERS_10K"
      ("ID", "ORDER_NO", "STORE_ID", "PRODUCT_ID", "CUSTOMER_NAME", "QUANTITY", "AMOUNT", "ORDER_STATUS", "CREATED_AT")
    SELECT 10001, 'TEST_ORDER_001', 10001, 10001, '测试客户', 2, 199.80, 'PAID', SYSDATE
    FROM DUAL
    WHERE NOT EXISTS (
      SELECT 1 FROM "DBX_TEST"."ORDERS_10K" WHERE "ORDER_NO" = 'TEST_ORDER_001'
    );

    COMMIT;
  END IF;
END;
/
SELECT 1;`;

const oracleIssue2405PlSql = `DECLARE
   PRE_TRD_DATE   INTEGER ;
BEGIN
   SELECT 1 + 2 INTO PRE_TRD_DATE FROM DUAL;
END;`;

const gaussDbNestedProcedure = `CREATE OR REPLACE PROCEDURE public.dbx_issue_4318()
AS
BEGIN
  BEGIN
    NULL;
  END;
  NULL;
END;`;

const gaussDbDollarQuotedFunctionScript = `DROP FUNCTION IF EXISTS dbx_issue_4572_tmp_md5_uuid;

CREATE OR REPLACE FUNCTION dbx_issue_4572_tmp_md5_uuid (v_str IN TEXT) RETURNS varchar(36) LANGUAGE PLPGSQL IMMUTABLE AS $function$
DECLARE
    str1 TEXT;
BEGIN
    str1 := md5(v_str);
    RETURN CAST(str1 AS varchar(36));
END$function$;

DROP FUNCTION IF EXISTS dbx_issue_4572_tmp_missing;`;

const gaussDbIssue4573Script = `CREATE OR REPLACE PROCEDURE createIndex (
  dbName IN VARCHAR(32),
  tableName IN VARCHAR(64),
  indexInfo IN VARCHAR(64),
  indexColumns IN VARCHAR(128)
) AS
DECLARE STMT TEXT;

DECLARE flag int;

BEGIN
SELECT
  count(*) INTO flag
FROM
  PG_CATALOG.PG_INDEXES
WHERE
  schemaname = dbName
  AND TABLENAME = tableName
  AND INDEXNAME = indexInfo;

IF flag = 0 THEN STMT := 'CREATE INDEX ' || indexInfo || ' ON ' || dbName || '.' || tableName || '(' || indexColumns || ')';

EXECUTE STMT;

END IF;

END;

SELECT 1 AS after_procedure;
SELECT 2 AS final_statement;`;

const xuguProgrammableObjectFixtures = [
  `CREATE OR REPLACE PROCEDURE dbx_xugu_procedure AS
  v_value INTEGER;
BEGIN
  v_value := 1;
END;`,
  `CREATE PROCEDURE dbx_xugu_procedure_without_replace AS
  v_value INTEGER;
BEGIN
  v_value := 1;
END;`,
  `CREATE OR REPLACE FUNCTION dbx_xugu_function RETURN INTEGER AS
BEGIN
  RETURN 1;
END;`,
  `CREATE FUNCTION dbx_xugu_function_without_replace RETURN INTEGER AS
BEGIN
  RETURN 1;
END;`,
  `CREATE OR REPLACE TRIGGER dbx_xugu_trigger
BEFORE INSERT ON dbx_xugu_events
FOR EACH ROW
BEGIN
  NULL;
END;`,
  `CREATE TRIGGER dbx_xugu_trigger_without_replace
BEFORE INSERT ON dbx_xugu_events
FOR EACH ROW
BEGIN
  NULL;
END;`,
  `CREATE OR REPLACE PACKAGE BODY dbx_xugu_package AS
  PROCEDURE ping AS
  BEGIN
    NULL;
  END ping;
END dbx_xugu_package;`,
  `CREATE PACKAGE BODY dbx_xugu_package_without_replace AS
  PROCEDURE ping AS
  BEGIN
    NULL;
  END ping;
END dbx_xugu_package_without_replace;`,
  `CREATE OR REPLACE FORCE PACKAGE BODY dbx_xugu_force_package AS
  PROCEDURE ping AS
  BEGIN
    NULL;
  END ping;
END dbx_xugu_force_package;`,
  `CREATE OR REPLACE NOFORCE PACKAGE BODY dbx_xugu_noforce_package AS
  PROCEDURE ping AS
  BEGIN
    NULL;
  END ping;
END dbx_xugu_noforce_package;`,
  `CREATE OR REPLACE TYPE BODY dbx_xugu_type AS
  MEMBER PROCEDURE ping IS
  BEGIN
    NULL;
  END;
END;`,
  `CREATE TYPE BODY dbx_xugu_type_without_replace AS
  MEMBER PROCEDURE ping IS
  BEGIN
    NULL;
  END;
END;`,
];

const mysqlRoutineFixture = `CREATE PROCEDURE p()
BEGIN
  SELECT 1;
  IF 1 = 1 THEN
    SELECT 'ok';
  END IF;
END;
SELECT 2;`;

const mysqlRoutineWithLoopsFixture = `CREATE PROCEDURE p_loop()
BEGIN
  WHILE 1 = 0 DO
    SELECT 'while; still body';
  END WHILE;
  REPEAT
    SELECT 'repeat; still body';
  UNTIL 1 = 1 END REPEAT;
END;
SELECT 2;`;

const mysqlDelimitedRoutineFixture = `DELIMITER //
CREATE PROCEDURE sp_insert_random_users(IN p_count INT)
BEGIN
  DECLARE i INT DEFAULT 0;
  DECLARE v_name VARCHAR(32);

  WHILE i < p_count DO
    SET v_name = CONCAT('user_', i);
    INSERT INTO t_user (username) VALUES (v_name);
    SET i = i + 1;
  END WHILE;
END //
DELIMITER ;

CALL sp_insert_random_users(100);`;

const sapHanaDoBlockFixture = `DO
BEGIN
  SELECT 1 AS "Result" FROM DUMMY;
END;
SELECT 2 FROM DUMMY;`;

describe("splitSqlStatementRanges", () => {
  it("splits multiple top-level statements", () => {
    const sql = "SELECT 1;\nSELECT 2;\nSELECT 3;";
    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["SELECT 1", "SELECT 2", "SELECT 3"]);
  });

  it("keeps a trailing statement without a semicolon", () => {
    const sql = "SELECT 1;\nSELECT 2";
    const ranges = splitSqlStatementRanges(sql);
    expect(rangeSqlTexts(ranges)).toEqual(["SELECT 1", "SELECT 2"]);
  });

  it("ignores semicolons inside single-quoted strings", () => {
    const sql = "INSERT INTO t VALUES ('a;b;c');\nSELECT 1";
    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["INSERT INTO t VALUES ('a;b;c')", "SELECT 1"]);
  });

  it("handles doubled single quotes as escaped quotes", () => {
    const sql = "SELECT 'it''s; ok';\nSELECT 2";
    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["SELECT 'it''s; ok'", "SELECT 2"]);
  });

  it("ignores semicolons inside double-quoted identifiers", () => {
    const sql = 'SELECT "a;b";\nSELECT 2';
    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(['SELECT "a;b"', "SELECT 2"]);
  });

  it("ignores semicolons inside backtick identifiers (MySQL)", () => {
    const sql = "SELECT `a;b`;\nSELECT 2";
    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["SELECT `a;b`", "SELECT 2"]);
  });

  it("ignores semicolons inside bracket identifiers (SQL Server)", () => {
    const sql = "SELECT [a;b];\nSELECT 2";
    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["SELECT [a;b]", "SELECT 2"]);
  });

  it("ignores semicolons in line comments", () => {
    const sql = "SELECT 1 -- a; b\n;\nSELECT 2";
    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["SELECT 1", "SELECT 2"]);
  });

  it("ignores semicolons in hash line comments", () => {
    const sql = "SELECT 1 # a; b\n;\nSELECT 2";
    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["SELECT 1", "SELECT 2"]);
  });

  it("keeps SQL Server temporary table names instead of treating them as hash comments", () => {
    const sql = "DROP TABLE IF EXISTS #Temp;\nSELECT * FROM ##GlobalTemp;";
    expect(rangeSqlTexts(splitSqlStatementRanges(sql, "sqlserver"))).toEqual(["DROP TABLE IF EXISTS #Temp", "SELECT * FROM ##GlobalTemp"]);
  });

  it("keeps MyBatis placeholders instead of treating them as hash comments", () => {
    const sql = "SELECT * FROM yd_org_decla_detail WHERE clr_ym = #{ym};\nSELECT 2";
    expect(rangeSqlTexts(splitSqlStatementRanges(sql, "kingbase"))).toEqual(["SELECT * FROM yd_org_decla_detail WHERE clr_ym = #{ym}", "SELECT 2"]);
  });

  it("treats malformed or disabled MyBatis prefixes as hash comments", () => {
    expect(rangeSqlTexts(splitSqlStatementRanges("SELECT 1; #{1ym};\nSELECT 2", "kingbase"))).toEqual(["SELECT 1", "SELECT 2"]);
    expect(rangeSqlTexts(splitSqlStatementRanges("SELECT 1; #{ym};\nSELECT 2", "kingbase", { enabledSyntaxes: ["shell"] }))).toEqual(["SELECT 1", "SELECT 2"]);
  });

  it("ignores semicolons in block comments", () => {
    const sql = "SELECT /* a; b */ 1;\nSELECT 2";
    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["SELECT /* a; b */ 1", "SELECT 2"]);
  });

  it("handles Postgres dollar quoting", () => {
    const sql = "SELECT $$ a; b $$;\nSELECT 2";
    expect(rangeSqlTexts(splitSqlStatementRanges(sql))).toEqual(["SELECT $$ a; b $$", "SELECT 2"]);
  });

  it("skips MySQL delimiter commands and empty custom delimiter statements", () => {
    const sql = "select COUNT(1) FROM your_table;\ndelimiter ;;\nselect COUNT(1) FROM your_table;\n\n;;\ndelimiter ;";
    expect(rangeSqlTexts(splitSqlStatementRanges(sql, "mysql"))).toEqual(["select COUNT(1) FROM your_table", "select COUNT(1) FROM your_table;"]);
  });

  it("keeps MySQL routine blocks together without delimiter commands", () => {
    const ranges = splitSqlStatementRanges(mysqlRoutineFixture, "mysql");
    expect(rangeSqlTexts(ranges)).toEqual([mysqlRoutineFixture.slice(0, mysqlRoutineFixture.indexOf("\nSELECT 2;")).replace(/;$/, "").trim(), "SELECT 2"]);
    expect(ranges[0].sql).toContain("SELECT 1;");
    expect(ranges[0].sql).toContain("END IF;");
    expect(ranges[0].sql).not.toMatch(/END;$/);
  });

  it("does not merge regular MySQL transaction statements as routine blocks", () => {
    const sql = "BEGIN; INSERT INTO t VALUES (1); COMMIT;";
    expect(rangeSqlTexts(splitSqlStatementRanges(sql, "mysql"))).toEqual(["BEGIN", "INSERT INTO t VALUES (1)", "COMMIT"]);
  });

  it("treats SQL Server GO lines as batch delimiters", () => {
    const sql = "SELECT 1\nGO\nSELECT 2;\n  GO 2\nSELECT 3";
    expect(rangeSqlTexts(splitSqlStatementRanges(sql, "sqlserver"))).toEqual(["SELECT 1", "SELECT 2", "SELECT 3"]);
  });

  it("does not treat GO inside strings or comments as a SQL Server batch delimiter", () => {
    const sql = "SELECT 'GO'\n-- GO\nSELECT 2\nGO\nSELECT 3";
    expect(rangeSqlTexts(splitSqlStatementRanges(sql, "sqlserver"))).toEqual(["SELECT 'GO'\n-- GO\nSELECT 2", "SELECT 3"]);
  });

  it("keeps Oracle PL/SQL blocks together and treats slash lines as delimiters", () => {
    const ranges = splitSqlStatementRanges(oraclePlSqlFixture, "oracle");
    expect(rangeSqlTexts(ranges)).toEqual([oraclePlSqlFixture.slice(0, oraclePlSqlFixture.indexOf("\n/")), "SELECT 1"]);
    expect(ranges[0].sql).toContain("v_order_count NUMBER;");
    expect(ranges[0].sql).toContain("END;");
    expect(ranges[0].sql).not.toContain("\n/");
  });

  it("keeps issue #2405 Oracle PL/SQL block together without a slash delimiter", () => {
    expect(rangeSqlTexts(splitSqlStatementRanges(oracleIssue2405PlSql, "oracle"))).toEqual([oracleIssue2405PlSql]);
  });

  it("splits large Dameng package bodies without repeated prefix parsing", () => {
    const body = Array.from({ length: 3000 }, (_, index) => `    v_value := v_value + ${index % 10};`).join("\n");
    const packageBody = `CREATE OR REPLACE PACKAGE BODY app.big_pkg AS
  PROCEDURE run IS
    v_value NUMBER := 0;
  BEGIN
${body}
  END run;
END big_pkg;`;
    const sql = `${packageBody}\n/\nSELECT 1;`;
    const startedAt = performance.now();
    const ranges = splitSqlStatementRanges(sql, "dameng");
    const elapsedMs = performance.now() - startedAt;

    expect(rangeSqlTexts(ranges)).toEqual([packageBody, "SELECT 1"]);
    expect(elapsedMs).toBeLessThan(1000);
  });

  it("keeps nested GaussDB procedure blocks together", () => {
    expect(rangeSqlTexts(splitSqlStatementRanges(gaussDbNestedProcedure, "gaussdb"))).toEqual([gaussDbNestedProcedure]);
  });

  it("separates GaussDB dollar-quoted functions from surrounding statements", () => {
    const ranges = splitSqlStatementRanges(gaussDbDollarQuotedFunctionScript, "gaussdb");
    expect(rangeSqlTexts(ranges)).toEqual([
      "DROP FUNCTION IF EXISTS dbx_issue_4572_tmp_md5_uuid",
      gaussDbDollarQuotedFunctionScript.slice(gaussDbDollarQuotedFunctionScript.indexOf("CREATE"), gaussDbDollarQuotedFunctionScript.lastIndexOf(";\n\nDROP")),
      "DROP FUNCTION IF EXISTS dbx_issue_4572_tmp_missing",
    ]);
  });

  it("separates the issue #4573 GaussDB procedure from following statements", () => {
    expect(rangeSqlTexts(splitSqlStatementRanges(gaussDbIssue4573Script, "gaussdb"))).toEqual([gaussDbIssue4573Script.slice(0, gaussDbIssue4573Script.indexOf("\n\nSELECT 1")), "SELECT 1 AS after_procedure", "SELECT 2 AS final_statement"]);
  });

  it("keeps Xugu programmable object DDL together and retains its terminator", () => {
    for (const sql of xuguProgrammableObjectFixtures) {
      const ranges = splitSqlStatementRanges(`${sql}\nSELECT 1;`, "xugu");
      expect(rangeSqlTexts(ranges)).toEqual([sql, "SELECT 1"]);
      expect(ranges[0].sql.trimEnd()).toMatch(/END(?:\s+\w+)?;$/);
    }
  });

  it("splits Xugu package specification without a slash before following SQL", () => {
    const packageSpec = `CREATE OR REPLACE PACKAGE pkg_utils AS
  FUNCTION get_version RETURN VARCHAR2;
  PROCEDURE log_message(msg VARCHAR2);
END pkg_utils;`;
    const forcePackageSpec = `CREATE OR REPLACE FORCE PACKAGE pkg_utils AS
  PROCEDURE ping;
END pkg_utils;`;
    const packageSpecWithoutReplace = `CREATE PACKAGE pkg_utils_without_replace AS
  PROCEDURE ping;
END pkg_utils_without_replace;`;

    expect(rangeSqlTexts(splitSqlStatementRanges(`${packageSpec}\nSELECT 1;`, "xugu"))).toEqual([packageSpec, "SELECT 1"]);
    expect(rangeSqlTexts(splitSqlStatementRanges(`${packageSpec}\n/\nSELECT 1;`, "xugu"))).toEqual([packageSpec, "SELECT 1"]);
    expect(rangeSqlTexts(splitSqlStatementRanges(`${forcePackageSpec}\nSELECT 1;`, "xugu"))).toEqual([forcePackageSpec, "SELECT 1"]);
    expect(rangeSqlTexts(splitSqlStatementRanges(`${packageSpecWithoutReplace}\nSELECT 1;`, "xugu"))).toEqual([packageSpecWithoutReplace, "SELECT 1"]);
  });

  it("splits plain CREATE TYPE AS OBJECT on semicolon without waiting for END", () => {
    const sql = "CREATE OR REPLACE TYPE address_t AS OBJECT (id INT);\nSELECT 1;";
    expect(rangeSqlTexts(splitSqlStatementRanges(sql, "xugu"))).toEqual(["CREATE OR REPLACE TYPE address_t AS OBJECT (id INT)", "SELECT 1"]);
    expect(rangeSqlTexts(splitSqlStatementRanges("CREATE TYPE address_t_without_replace AS OBJECT (id INT);\nSELECT 1;", "xugu"))).toEqual(["CREATE TYPE address_t_without_replace AS OBJECT (id INT)", "SELECT 1"]);
  });

  it("keeps Oracle-style CASE expressions inside Xugu and Oracle routines", () => {
    const routine = `CREATE OR REPLACE FUNCTION dbx_case_expr RETURN NUMBER AS
BEGIN
  RETURN CASE WHEN 1 = 1 THEN CASE WHEN 2 = 2 THEN 1 ELSE 2 END ELSE 0 END;
END;`;
    const caseStatementRoutine = `CREATE OR REPLACE PROCEDURE dbx_case_statement AS
BEGIN
  CASE WHEN 1 = 1 THEN NULL; ELSE NULL; END CASE;
END;`;

    for (const database of ["xugu", "oracle"] as const) {
      expect(rangeSqlTexts(splitSqlStatementRanges(`${routine}\nSELECT 1;`, database))).toEqual([routine, "SELECT 1"]);
      expect(rangeSqlTexts(splitSqlStatementRanges(`${caseStatementRoutine}\nSELECT 1;`, database))).toEqual([caseStatementRoutine, "SELECT 1"]);
    }
  });

  it("keeps SAP HANA DO blocks together", () => {
    const ranges = splitSqlStatementRanges(sapHanaDoBlockFixture, "saphana");

    expect(rangeSqlTexts(ranges)).toEqual([sapHanaDoBlockFixture.slice(0, sapHanaDoBlockFixture.indexOf("\nSELECT 2")), "SELECT 2 FROM DUMMY"]);
    expect(ranges[0].sql).toContain('SELECT 1 AS "Result" FROM DUMMY;');
    expect(ranges[0].sql).toContain("END;");
  });
});

describe("statementRangeAtCursor", () => {
  it("splits Elasticsearch REST requests without semicolons", () => {
    const sql = `# node information
GET /_nodes/stats/jvm?pretty

// search orders
POST /orders/_search
{
  "query": { "match_all": {} }
}

HEAD /orders`;

    for (const databaseType of ["elasticsearch", "easysearch"] as const) {
      expect(rangeSqlTexts(splitSqlStatementRanges(sql, databaseType))).toEqual(["GET /_nodes/stats/jvm?pretty", 'POST /orders/_search\n{\n  "query": { "match_all": {} }\n}', "HEAD /orders"]);
      expect(hasMultipleExecutionTargets(sql, databaseType)).toBe(true);
    }
  });

  it("targets the Elasticsearch request following a comment", () => {
    const sql = "# JVM statistics\nGET /_nodes/stats/jvm?pretty\n\nGET /_cluster/health";

    expect(statementRangeAtCursor(sql, indexOf(sql, "JVM"), "elasticsearch")?.sql).toBe("GET /_nodes/stats/jvm?pretty");
    expect(statementRangeAtCursor(sql, indexOf(sql, "cluster"), "elasticsearch")?.sql).toBe("GET /_cluster/health");
  });

  it("splits and targets Elasticsearch requests after block comments", () => {
    const sql = `/* node information
   including JVM details */
GET /_nodes/stats/jvm?pretty

/* cluster information */
GET /_cluster/health`;

    expect(rangeSqlTexts(splitSqlStatementRanges(sql, "elasticsearch"))).toEqual(["GET /_nodes/stats/jvm?pretty", "GET /_cluster/health"]);
    expect(statementRangeAtCursor(sql, indexOf(sql, "JVM details"), "elasticsearch")?.sql).toBe("GET /_nodes/stats/jvm?pretty");
    expect(statementRangeAtCursor(sql, indexOf(sql, "cluster information"), "elasticsearch")?.sql).toBe("GET /_cluster/health");
  });

  it("ignores request-looking lines inside Elasticsearch block comments", () => {
    const sql = `GET /_cluster/health

/* disabled cleanup
DELETE /important-index
*/
GET /_cat/indices`;

    expect(rangeSqlTexts(splitSqlStatementRanges(sql, "elasticsearch"))).toEqual(["GET /_cluster/health", "GET /_cat/indices"]);
    expect(statementRangeAtCursor(sql, indexOf(sql, "important-index"), "elasticsearch")?.sql).toBe("GET /_cat/indices");
  });

  it("returns the first statement when the cursor is inside it", () => {
    const sql = "SELECT 1;\nSELECT 2;";
    const pos = indexOf(sql, "1");
    const range = statementRangeAtCursor(sql, pos);
    expect(range?.sql.trim()).toBe("SELECT 1");
  });

  it("returns the second statement when the cursor is inside it", () => {
    const sql = "SELECT 1;\nSELECT 2;";
    const pos = indexOf(sql, "2");
    const range = statementRangeAtCursor(sql, pos);
    expect(range?.sql.trim()).toBe("SELECT 2");
  });

  it("returns the statement when the cursor is in indentation before it", () => {
    const sql = "SELECT 1;\n    SELECT 2;";
    const indentationPos = sql.indexOf("    SELECT 2") + 2;
    const range = statementRangeAtCursor(sql, indentationPos);
    expect(range?.sql.trim()).toBe("SELECT 2");
  });

  it("returns the previous statement when the cursor is in same-line whitespace after its semicolon", () => {
    const sql = "SELECT 1;   SELECT 2;";
    const gapPos = sql.indexOf(";") + 2;
    const range = statementRangeAtCursor(sql, gapPos);
    expect(range?.sql.trim()).toBe("SELECT 1");
  });

  it("returns the previous statement when the cursor is just after its semicolon before a later statement", () => {
    const sql = "SELECT *\nFROM system_dept;\n\nSELECT *\nFROM sys;";
    const gapPos = sql.indexOf(";") + 1;
    const range = statementRangeAtCursor(sql, gapPos);
    expect(range?.sql.trim()).toBe("SELECT *\nFROM system_dept");
  });

  it("keeps a semicolon-line-end cursor on the current multi-line statement", () => {
    const sql = "SELECT *\nFROM system_dept;";
    const gapPos = sql.indexOf(";") + 1;
    const range = statementRangeAtCursor(sql, gapPos);
    expect(range?.sql.trim()).toBe("SELECT *\nFROM system_dept");
  });

  it("keeps a standalone next-line semicolon cursor on the current multi-line statement", () => {
    const sql = "SELECT *\nFROM system_dept\n;\n\nSELECT * FROM sys;";
    const delimiterPos = sql.indexOf(";");

    expect(statementRangeAtCursor(sql, delimiterPos)?.sql.trim()).toBe("SELECT *\nFROM system_dept");
    expect(statementRangeAtCursor(sql, delimiterPos + 1)?.sql.trim()).toBe("SELECT *\nFROM system_dept");
  });

  it("assigns a standalone trailing semicolon to the final soft statement", () => {
    const sql = "SELECT * FROM `t_0001`\nSELECT * FROM `t_0001` LIMIT 1\n;";
    const delimiterPos = sql.lastIndexOf(";");

    expect(statementRangeAtCursor(sql, delimiterPos, "mysql")?.sql).toBe("SELECT * FROM `t_0001` LIMIT 1");
    expect(statementRangeAtCursor(sql, delimiterPos + 1, "mysql")?.sql).toBe("SELECT * FROM `t_0001` LIMIT 1");
  });

  it("returns the next same-line statement when the cursor is inside it", () => {
    const sql = "SELECT 1;   SELECT 2;";
    const pos = indexOf(sql, "SELECT 2") + 1;
    const range = statementRangeAtCursor(sql, pos);
    expect(range?.sql.trim()).toBe("SELECT 2");
  });

  it("returns a statement even without a trailing semicolon", () => {
    const sql = "SELECT 1";
    const pos = indexOf(sql, "1");
    const range = statementRangeAtCursor(sql, pos);
    expect(range?.sql.trim()).toBe("SELECT 1");
  });

  it("stops at the next top-level statement start when the cursor statement has no semicolon", () => {
    const sql = "SELECT 1\nSELECT 2;\nSELECT 3;";
    const range = statementRangeAtCursor(sql, indexOf(sql, "1"));
    expect(range?.sql.trim()).toBe("SELECT 1");
  });

  it("returns the later top-level statement when earlier statements are missing semicolons", () => {
    const sql = "SELECT 1\nSELECT 2;\nSELECT 3;";
    const range = statementRangeAtCursor(sql, indexOf(sql, "2"));
    expect(range?.sql.trim()).toBe("SELECT 2");
  });

  it("keeps newline set-operation SELECT operands with the cursor statement", () => {
    const sql = "select * from tbA\nunion\nselect * from tbB";
    const expected = "select * from tbA\nunion\nselect * from tbB";

    expect(statementRangeAtCursor(sql, indexOf(sql, "tbA"))?.sql.trim()).toBe(expected);
    expect(statementRangeAtCursor(sql, indexOf(sql, "tbB"))?.sql.trim()).toBe(expected);
  });

  it("keeps newline set-operation operands with ALL modifiers together", () => {
    const sql = "select * from tbA\nunion all\nselect * from tbB\nSELECT * FROM logs;";
    const range = statementRangeAtCursor(sql, indexOf(sql, "tbA"));

    expect(range?.sql.trim()).toBe("select * from tbA\nunion all\nselect * from tbB");
  });

  it("keeps a multi-line select together when continuation lines do not start statements", () => {
    const sql = "SELECT id,\n  name\nFROM users\nWHERE active = 1\nSELECT * FROM logs;";
    const range = statementRangeAtCursor(sql, indexOf(sql, "name"));
    expect(range?.sql.trim()).toBe("SELECT id,\n  name\nFROM users\nWHERE active = 1");
  });

  it("keeps a CTE main query with its WITH statement", () => {
    const sql = "WITH active_users AS (\n  SELECT * FROM users\n)\nSELECT * FROM active_users\nSELECT * FROM logs;";
    const range = statementRangeAtCursor(sql, indexOf(sql, "active_users", 2));
    expect(range?.sql.trim()).toBe("WITH active_users AS (\n  SELECT * FROM users\n)\nSELECT * FROM active_users");
  });

  it("keeps update assignments with the UPDATE statement", () => {
    const sql = "UPDATE users\nSET name = 'a'\nWHERE id = 1\nSELECT * FROM users;";
    const range = statementRangeAtCursor(sql, indexOf(sql, "name"));
    expect(range?.sql.trim()).toBe("UPDATE users\nSET name = 'a'\nWHERE id = 1");
  });

  it("keeps MySQL ALTER TABLE column comments with the column definition", () => {
    const sql =
      "ALTER TABLE `yb_course_order`\n  ADD COLUMN `audit_status` tinyint(4) DEFAULT NULL\n    COMMENT '审核状态：0-待审核，1-已通过，2-已拒绝',\n  ADD COLUMN `close_reason` varchar(30) DEFAULT NULL\n    COMMENT '关闭原因：timeout-超时关闭，cancel-取消关闭，refund-退款关闭',\n  ADD COLUMN `paid_completion_time` datetime DEFAULT NULL\n    COMMENT '订单完成支付(付清)时间 首次全额支付完成时记录，全部退款后不重置';";

    expect(statementRangeAtCursor(sql, indexOf(sql, "ALTER"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(statementRangeAtCursor(sql, indexOf(sql, "close_reason"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
  });

  it("keeps MySQL CREATE TABLE options with table comments", () => {
    const sql = `CREATE TABLE test_1 (
  id bigint NOT NULL AUTO_INCREMENT COMMENT '主键id',
  deleted tinyint NOT NULL DEFAULT 0 COMMENT '删除标志(0:有效 1：无效)',
  locked tinyint NOT NULL DEFAULT 0 COMMENT '是否锁定(0.否,1.是)',
  version int NOT NULL DEFAULT 0 COMMENT '版本号',
  creatorId bigint DEFAULT NULL COMMENT '创建人ID',
  createBy varchar(100) DEFAULT NULL COMMENT '创建人名称',
  createdTime timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  updaterId bigint DEFAULT NULL COMMENT '修改人ID',
  updatedBy varchar(100) DEFAULT NULL COMMENT '修改人名称',
  updatedTime timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '最后更新时间',
  PRIMARY KEY (id)
)
ENGINE = INNODB,
CHARACTER SET utf8mb4,
COLLATE utf8mb4_general_ci,
COMMENT = '测试';`;

    expect(statementRangeAtCursor(sql, indexOf(sql, "CREATE"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(statementRangeAtCursor(sql, indexOf(sql, "COMMENT ="), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
    expect(statementRangeAtCursor(sql, indexOf(sql, "COMMENT ="))?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql))).toEqual([sql.slice(0, -1)]);
  });

  it("keeps MySQL CREATE TABLE comments without equals as table options", () => {
    const sql = "CREATE TABLE test_2 (\n  id bigint NOT NULL\n)\nCOMMENT '测试';";

    expect(statementRangeAtCursor(sql, indexOf(sql, "COMMENT"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
    expect(statementRangeAtCursor(sql, indexOf(sql, "COMMENT"))?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql))).toEqual([sql.slice(0, -1)]);
  });

  it("does not merge standard COMMENT ON statements into preceding CREATE TABLE statements", () => {
    const sql = "CREATE TABLE users (id int)\nCOMMENT ON TABLE users IS 'Users';";

    expect(rangeSqlTexts(executableStatementRanges(sql, "postgres"))).toEqual(["CREATE TABLE users (id int)", "COMMENT ON TABLE users IS 'Users'"]);
    expect(rangeSqlTexts(executableStatementRanges(sql))).toEqual(["CREATE TABLE users (id int)", "COMMENT ON TABLE users IS 'Users'"]);
  });

  it("keeps a line-start comment column inside a select projection", () => {
    const sql = "SELECT\n  id,\n  comment,\n  created_at\nFROM project_info\nWHERE deleted = 0;";

    expect(statementRangeAtCursor(sql, indexOf(sql, "comment"))?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql))).toEqual([sql.slice(0, -1)]);
  });

  it("keeps MySQL ALTER TABLE drop column clauses with the statement", () => {
    const sql = "ALTER TABLE t\n  DROP COLUMN a,\n  DROP COLUMN b;";

    expect(statementRangeAtCursor(sql, indexOf(sql, "ALTER"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(statementRangeAtCursor(sql, indexOf(sql, "DROP COLUMN b"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
  });

  it("keeps MySQL ALTER TABLE alter column clauses with the statement", () => {
    const sql = "ALTER TABLE t\n  ALTER COLUMN name SET NOT NULL;";

    expect(statementRangeAtCursor(sql, indexOf(sql, "ALTER"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(statementRangeAtCursor(sql, indexOf(sql, "ALTER COLUMN"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
  });

  it("keeps MySQL ALTER TABLE truncate partition clauses with the statement", () => {
    const sql = "ALTER TABLE ems.r_r_curve_e_hour\nTRUNCATE PARTITION p202602, p202603, p202604, p202605, p202606;";

    expect(statementRangeAtCursor(sql, indexOf(sql, "ALTER"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(statementRangeAtCursor(sql, indexOf(sql, "TRUNCATE"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
  });

  it("keeps MySQL truncate partition clauses when comments separate ALTER TABLE", () => {
    const sql = "ALTER /* online ddl */ TABLE t\nTRUNCATE PARTITION p0;";

    expect(statementRangeAtCursor(sql, indexOf(sql, "TRUNCATE"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
  });

  it("keeps MySQL truncate partition clauses when comments precede PARTITION", () => {
    const sql = "ALTER TABLE t\nTRUNCATE /* keep */ PARTITION p0;";

    expect(statementRangeAtCursor(sql, indexOf(sql, "TRUNCATE"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
  });

  it("keeps standalone truncate table statements separate from preceding alter statements", () => {
    const sql = "ALTER TABLE events ADD COLUMN source varchar(100)\nTRUNCATE TABLE events;";

    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual(["ALTER TABLE events ADD COLUMN source varchar(100)", "TRUNCATE TABLE events"]);
    expect(rangeSqlTexts(executableStatementRanges(sql, "postgres"))).toEqual(["ALTER TABLE events ADD COLUMN source varchar(100)", "TRUNCATE TABLE events"]);
  });

  it("keeps issue #4045 ClickHouse ALTER TABLE UPDATE mutation together", () => {
    const sql = `ALTER TABLE m2_db.history_data5
UPDATE value = 14.06
WHERE uuid IN (
    SELECT uuid
    FROM m2_db.pt_uuid_mapping
    WHERE point_id = 'TEST_Location_1_L2_METER_2_AE_DIFF_H'
)
AND ts = toDateTime('2026-07-15 12:00:00');`;

    expect(statementRangeAtCursor(sql, indexOf(sql, "ALTER"), "clickhouse")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(statementRangeAtCursor(sql, indexOf(sql, "UPDATE"), "clickhouse")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "clickhouse"))).toEqual([sql.slice(0, -1)]);
  });

  it("keeps a simple ClickHouse ALTER TABLE UPDATE mutation together", () => {
    const sql = "ALTER TABLE `events` ON CLUSTER 'analytics'\nUPDATE value = 1\nWHERE id = 42;";

    expect(statementRangeAtCursor(sql, indexOf(sql, "UPDATE"), "clickhouse")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "clickhouse"))).toEqual([sql.slice(0, -1)]);
  });

  it("separates statements after a ClickHouse ALTER TABLE UPDATE mutation", () => {
    const mutation = "ALTER TABLE events\nUPDATE value = 1\nWHERE id = 42";
    const sql = `${mutation};\nSELECT * FROM events;\nUPDATE audit SET processed = 1;`;

    expect(rangeSqlTexts(executableStatementRanges(sql, "clickhouse"))).toEqual([mutation, "SELECT * FROM events", "UPDATE audit SET processed = 1"]);
  });

  it("does not merge independent UPDATE statements into other ALTER statements", () => {
    const otherDatabaseSql = "ALTER TABLE events\nUPDATE audit SET processed = 1;";
    const clickHouseSql = "ALTER TABLE events ADD COLUMN source String\nUPDATE audit SET processed = 1;";

    expect(rangeSqlTexts(executableStatementRanges(otherDatabaseSql, "postgres"))).toEqual(["ALTER TABLE events", "UPDATE audit SET processed = 1"]);
    expect(rangeSqlTexts(executableStatementRanges(otherDatabaseSql, "mysql"))).toEqual(["ALTER TABLE events", "UPDATE audit SET processed = 1"]);
    expect(rangeSqlTexts(executableStatementRanges(clickHouseSql, "clickhouse"))).toEqual(["ALTER TABLE events ADD COLUMN source String", "UPDATE audit SET processed = 1"]);
  });

  it("keeps insert-select with the INSERT statement", () => {
    const sql = "INSERT INTO archived_users (id, name)\nSELECT id, name FROM users\nUPDATE users SET archived = 1;";
    const range = statementRangeAtCursor(sql, indexOf(sql, "archived_users"));
    expect(range?.sql.trim()).toBe("INSERT INTO archived_users (id, name)\nSELECT id, name FROM users");
  });

  it("keeps explain target SQL with the EXPLAIN statement", () => {
    const sql = "EXPLAIN\nSELECT * FROM users\nSELECT * FROM logs;";
    const range = statementRangeAtCursor(sql, indexOf(sql, "EXPLAIN"));
    expect(range?.sql.trim()).toBe("EXPLAIN\nSELECT * FROM users");
  });

  it("keeps issue #3567 EXPLAIN options and CTE target as one statement", () => {
    const sql = "explain (analyze,buffers)\nwith tmp as(select* from test.tt)\nselect * from tmp;";

    expect(statementRangeAtCursor(sql, indexOf(sql, "explain"), "postgres")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(statementRangeAtCursor(sql, indexOf(sql, "select * from tmp"), "postgres")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "postgres"))).toEqual([sql.slice(0, -1)]);
    expect(rangeSqlTexts(executableStatementRanges(sql))).toEqual([sql.slice(0, -1)]);
  });

  it("keeps EXPLAIN ANALYZE with a CTE main query as one statement", () => {
    const sql = "explain analyze\nwith tmp as (select 1)\nselect * from tmp;";

    expect(statementRangeAtCursor(sql, indexOf(sql, "explain"), "postgres")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "postgres"))).toEqual([sql.slice(0, -1)]);
  });

  it("keeps a plain EXPLAIN CTE target as one statement without merging later queries", () => {
    const sql = "EXPLAIN\nWITH tmp AS (SELECT 1)\nSELECT * FROM tmp\nSELECT * FROM logs;";
    const expected = "EXPLAIN\nWITH tmp AS (SELECT 1)\nSELECT * FROM tmp";

    expect(statementRangeAtCursor(sql, indexOf(sql, "EXPLAIN"))?.sql.trim()).toBe(expected);
    expect(rangeSqlTexts(executableStatementRanges(sql))).toEqual([expected, "SELECT * FROM logs"]);
  });

  it("does not merge a query after an inline EXPLAIN options CTE statement", () => {
    const sql = "EXPLAIN (ANALYZE) WITH tmp AS (SELECT 1)\nSELECT * FROM tmp\nSELECT 2;";
    const expected = "EXPLAIN (ANALYZE) WITH tmp AS (SELECT 1)\nSELECT * FROM tmp";

    expect(statementRangeAtCursor(sql, indexOf(sql, "EXPLAIN"), "postgres")?.sql.trim()).toBe(expected);
    expect(rangeSqlTexts(executableStatementRanges(sql, "postgres"))).toEqual([expected, "SELECT 2"]);
  });

  it("keeps EXPLAIN options CTE UPDATE assignments as one statement", () => {
    const sql = "EXPLAIN (ANALYZE)\nWITH tmp AS (SELECT 1)\nUPDATE t\nSET x = 1;";

    expect(statementRangeAtCursor(sql, indexOf(sql, "SET"), "postgres")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "postgres"))).toEqual([sql.slice(0, -1)]);
  });

  it("keeps CTE INSERT ... SELECT with the WITH statement", () => {
    const sql = "WITH tmp AS (SELECT 1)\nINSERT INTO t (id)\nSELECT * FROM tmp;";

    expect(statementRangeAtCursor(sql, indexOf(sql, "INSERT"))?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql))).toEqual([sql.slice(0, -1)]);
  });

  it("does not merge a query after a CTE INSERT ... SELECT statement", () => {
    const sql = "WITH tmp AS (SELECT 1)\nINSERT INTO t (id)\nSELECT * FROM tmp\nSELECT 2;";
    const expected = "WITH tmp AS (SELECT 1)\nINSERT INTO t (id)\nSELECT * FROM tmp";

    expect(statementRangeAtCursor(sql, indexOf(sql, "INSERT"))?.sql.trim()).toBe(expected);
    expect(rangeSqlTexts(executableStatementRanges(sql))).toEqual([expected, "SELECT 2"]);
  });

  it("does not merge a query after an INSERT with a CTE source query", () => {
    const sql = "INSERT INTO t (id)\nWITH tmp AS (SELECT 1)\nSELECT * FROM tmp\nSELECT 2;";
    const expected = "INSERT INTO t (id)\nWITH tmp AS (SELECT 1)\nSELECT * FROM tmp";

    expect(statementRangeAtCursor(sql, indexOf(sql, "INSERT"))?.sql.trim()).toBe(expected);
    expect(rangeSqlTexts(executableStatementRanges(sql))).toEqual([expected, "SELECT 2"]);
  });

  it("skips block comments inside EXPLAIN options when resolving the target", () => {
    const sql = "EXPLAIN (ANALYZE /* ) */) UPDATE t\nSET x = 1;";

    expect(statementRangeAtCursor(sql, indexOf(sql, "SET"), "postgres")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "postgres"))).toEqual([sql.slice(0, -1)]);
  });

  it("recovers later statements from an unclosed EXPLAIN option list", () => {
    const sql = "EXPLAIN (ANALYZE\nSELECT 1\nSELECT 2;";
    const explainSql = "EXPLAIN (ANALYZE\nSELECT 1";

    expect(statementRangeAtCursor(sql, indexOf(sql, "EXPLAIN"), "postgres")?.sql.trim()).toBe(explainSql);
    expect(statementRangeAtCursor(sql, indexOf(sql, "SELECT 2"), "postgres")?.sql.trim()).toBe("SELECT 2");
    expect(rangeSqlTexts(executableStatementRanges(sql, "postgres"))).toEqual([explainSql, "SELECT 2"]);
  });

  it("does not treat a DESCRIBE subquery paren as EXPLAIN options", () => {
    const sql = "DESCRIBE (SELECT 1)\nSELECT 2;";

    expect(statementRangeAtCursor(sql, indexOf(sql, "DESCRIBE"), "clickhouse")?.sql.trim()).toBe("DESCRIBE (SELECT 1)");
    expect(rangeSqlTexts(executableStatementRanges(sql, "clickhouse"))).toEqual(["DESCRIBE (SELECT 1)", "SELECT 2"]);
    expect(rangeSqlTexts(executableStatementRanges(sql))).toEqual(["DESCRIBE (SELECT 1)", "SELECT 2"]);
  });

  it("keeps MySQL DESC UPDATE joins as one statement", () => {
    const sql = "desc update  test_orders a\njoin test_users b\non a.id=b.id \nset a.name = '张三'\nwhere b.id > 10;";
    expect(statementRangeAtCursor(sql, indexOf(sql, "desc"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(statementRangeAtCursor(sql, indexOf(sql, "set"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
  });

  it("keeps MySQL EXPLAIN UPDATE assignments as one statement", () => {
    const sql = "EXPLAIN UPDATE test_orders a\nJOIN test_users b ON a.id=b.id\nSET a.name = '张三'\nWHERE b.id > 10;";
    expect(statementRangeAtCursor(sql, indexOf(sql, "SET"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
  });

  it("keeps MySQL REPLACE function calls inside UPDATE assignments", () => {
    const sql = `UPDATE ecm_archive_prepare_pool
SET
  request_json =
    REPLACE(
      request_json,
      '"paperFlag":null',
      '"paperFlag":false'
    ),
  process_flag = 0
WHERE request_json LIKE '%"paperFlag":null%';`;

    expect(statementRangeAtCursor(sql, indexOf(sql, "REPLACE"), "mysql")?.sql.trim()).toBe(sql.slice(0, -1));
    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual([sql.slice(0, -1)]);
  });

  it("does not merge a plain MySQL DESC table statement with the next query", () => {
    const sql = "DESC users\nSELECT * FROM users;";
    expect(statementRangeAtCursor(sql, indexOf(sql, "DESC"), "mysql")?.sql.trim()).toBe("DESC users");
    expect(statementRangeAtCursor(sql, indexOf(sql, "SELECT"), "mysql")?.sql.trim()).toBe("SELECT * FROM users");
    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual(["DESC users", "SELECT * FROM users"]);
  });

  it("does not include comments between soft statement blocks", () => {
    const sql = "SELECT 1\n-- explain the next query\n/* still next query notes */\nSELECT 2;";
    const range = statementRangeAtCursor(sql, indexOf(sql, "1"));
    expect(range?.sql.trim()).toBe("SELECT 1");
  });

  it("detects a soft statement start after a leading block comment on the same line", () => {
    const sql = "SELECT 1\n/* next */ SELECT 2;";
    const range = statementRangeAtCursor(sql, indexOf(sql, "2"));
    expect(range?.sql.trim()).toBe("SELECT 2");
  });

  it("uses database-specific soft statement keywords", () => {
    const sql = "SELECT 1\nDO $$ BEGIN RAISE NOTICE 'x'; END $$;";
    expect(statementRangeAtCursor(sql, indexOf(sql, "1"))?.sql.trim()).toBe("SELECT 1\nDO $$ BEGIN RAISE NOTICE 'x'; END $$");
    expect(statementRangeAtCursor(sql, indexOf(sql, "1"), "postgres")?.sql.trim()).toBe("SELECT 1");
    expect(statementRangeAtCursor(sql, indexOf(sql, "DO"), "postgres")?.sql.trim()).toBe("DO $$ BEGIN RAISE NOTICE 'x'; END $$");
  });

  it("returns null when the cursor is on a blank line", () => {
    const sql = "SELECT 1;\n\nSELECT 2;";
    const blankLinePos = sql.indexOf("\n") + 1;
    expect(statementRangeAtCursor(sql, blankLinePos)).toBeNull();
  });

  it("returns null for an empty document", () => {
    expect(statementRangeAtCursor("", 0)).toBeNull();
  });

  it("does not treat comment semicolons as delimiters", () => {
    const sql = "SELECT 1; -- drop; this\nSELECT 2;";
    const pos = indexOf(sql, "2");
    expect(statementRangeAtCursor(sql, pos)?.sql.trim()).toBe("SELECT 2");
  });

  it("exposes offsets aligned to the statement body", () => {
    const sql = "  SELECT 1;\nSELECT 2;";
    const range = statementRangeAtCursor(sql, indexOf(sql, "1"));
    expect(range?.from).toBe(2);
    expect(range?.sql).toBe("SELECT 1");
  });

  it("skips MySQL delimiter commands when resolving the cursor statement", () => {
    const sql = "select COUNT(1) FROM your_table;\ndelimiter ;;\nselect COUNT(1) FROM your_table;\n\n;;\ndelimiter ;";
    expect(statementRangeAtCursor(sql, indexOf(sql, "COUNT", 2), "mysql")?.sql.trim()).toBe("select COUNT(1) FROM your_table;");
    expect(statementRangeAtCursor(sql, indexOf(sql, "delimiter"), "mysql")).toBeNull();
  });

  it("returns the full MySQL routine block for cursors inside nested statements", () => {
    const range = statementRangeAtCursor(mysqlRoutineFixture, indexOf(mysqlRoutineFixture, "ok"), "mysql");
    expect(range?.sql.trim()).toBe(mysqlRoutineFixture.slice(0, mysqlRoutineFixture.indexOf("\nSELECT 2;")).replace(/;$/, "").trim());
  });

  it("returns null on SQL Server GO batch delimiter lines", () => {
    const sql = "SELECT 1\nGO\nSELECT 2";
    expect(statementRangeAtCursor(sql, indexOf(sql, "GO"), "sqlserver")).toBeNull();
  });

  it("returns the current SQL Server batch around GO delimiters", () => {
    const sql = "SELECT 1\nGO\nSELECT 2\nGO\nSELECT 3";
    expect(statementRangeAtCursor(sql, indexOf(sql, "1"), "sqlserver")?.sql.trim()).toBe("SELECT 1");
    expect(statementRangeAtCursor(sql, indexOf(sql, "2"), "sqlserver")?.sql.trim()).toBe("SELECT 2");
    expect(statementRangeAtCursor(sql, indexOf(sql, "3"), "sqlserver")?.sql.trim()).toBe("SELECT 3");
  });

  it("returns the full Oracle PL/SQL block for cursors inside nested statements", () => {
    const range = statementRangeAtCursor(oraclePlSqlFixture, indexOf(oraclePlSqlFixture, "ORDERS_10K", 2), "oracle");
    expect(range?.sql.trim()).toBe(oraclePlSqlFixture.slice(0, oraclePlSqlFixture.indexOf("\n/")));
  });

  it("returns the full issue #2405 Oracle PL/SQL block for cursors inside the block", () => {
    for (const cursor of [indexOf(oracleIssue2405PlSql, "PRE_TRD_DATE"), indexOf(oracleIssue2405PlSql, "SELECT 1 + 2"), indexOf(oracleIssue2405PlSql, "END;")]) {
      expect(statementRangeAtCursor(oracleIssue2405PlSql, cursor, "oracle")?.sql.trim()).toBe(oracleIssue2405PlSql);
    }
  });

  it("returns the full GaussDB procedure for cursors after a nested block", () => {
    const outerNull = indexOf(gaussDbNestedProcedure, "NULL;", 2);
    expect(statementRangeAtCursor(gaussDbNestedProcedure, outerNull, "gaussdb")?.sql.trim()).toBe(gaussDbNestedProcedure);
  });

  it("returns only the issue #4573 GaussDB procedure for a gutter cursor", () => {
    const expected = gaussDbIssue4573Script.slice(0, gaussDbIssue4573Script.indexOf("\n\nSELECT 1"));
    expect(statementRangeAtCursor(gaussDbIssue4573Script, indexOf(gaussDbIssue4573Script, "count(*)"), "gaussdb")?.sql.trim()).toBe(expected);
  });

  it("returns the full SAP HANA DO block for cursors inside nested statements", () => {
    const range = statementRangeAtCursor(sapHanaDoBlockFixture, indexOf(sapHanaDoBlockFixture, "Result"), "saphana");

    expect(range?.sql.trim()).toBe(sapHanaDoBlockFixture.slice(0, sapHanaDoBlockFixture.indexOf("\nSELECT 2")));
  });
});

describe("executableStatementRanges", () => {
  it("returns statement ranges starting only at statement starts", () => {
    const sql = "SELECT *\nFROM users\nWHERE active = 1;\nSELECT 2;";
    const ranges = executableStatementRanges(sql);
    expect(rangeSqlTexts(ranges)).toEqual(["SELECT *\nFROM users\nWHERE active = 1", "SELECT 2"]);
    expect(ranges.map((range) => range.from)).toEqual([0, sql.indexOf("SELECT 2")]);
  });

  it("returns Redis executable command lines", () => {
    const sql = "GET user:1\n# comment\n  DEL user:2  ";
    const ranges = executableStatementRanges(sql, "redis");
    expect(rangeSqlTexts(ranges)).toEqual(["GET user:1", "DEL user:2"]);
    expect(ranges.map((range) => range.from)).toEqual([0, sql.indexOf("DEL")]);
  });

  it("keeps MySQL REPLACE INTO as an executable statement start", () => {
    const sql = "SELECT 1\nREPLACE INTO users (id, name) VALUES (1, 'a');";
    expect(rangeSqlTexts(executableStatementRanges(sql, "mysql"))).toEqual(["SELECT 1", "REPLACE INTO users (id, name) VALUES (1, 'a')"]);
  });

  it("returns MongoDB command ranges for newline-separated shell commands", () => {
    const sql = 'use archive\ndb.users.find({ status: "open" })\n  .limit(5)';
    const ranges = executableStatementRanges(sql, "mongodb");

    expect(rangeSqlTexts(ranges)).toEqual(["use archive", 'db.users.find({ status: "open" })\n  .limit(5)']);
    expect(ranges.map((range) => range.from)).toEqual([0, sql.indexOf("db.users.find")]);
  });

  it("does not split executable Oracle PL/SQL ranges at inner statement starts", () => {
    expect(rangeSqlTexts(executableStatementRanges(oraclePlSqlFixture, "oracle"))).toEqual([oraclePlSqlFixture.slice(0, oraclePlSqlFixture.indexOf("\n/")), "SELECT 1"]);
  });

  it("returns the issue #2405 Oracle PL/SQL block as one executable range", () => {
    expect(rangeSqlTexts(executableStatementRanges(oracleIssue2405PlSql, "oracle"))).toEqual([oracleIssue2405PlSql]);
  });

  it("does not split executable MySQL routine ranges at inner statements", () => {
    expect(rangeSqlTexts(executableStatementRanges(mysqlRoutineFixture, "mysql"))).toEqual([mysqlRoutineFixture.slice(0, mysqlRoutineFixture.indexOf("\nSELECT 2;")).replace(/;$/, "").trim(), "SELECT 2"]);
  });

  it("does not split executable MySQL routine ranges at WHILE and REPEAT endings", () => {
    expect(rangeSqlTexts(executableStatementRanges(mysqlRoutineWithLoopsFixture, "mysql"))).toEqual([mysqlRoutineWithLoopsFixture.slice(0, mysqlRoutineWithLoopsFixture.indexOf("\nSELECT 2;")).replace(/;$/, "").trim(), "SELECT 2"]);
  });

  it("does not expose run targets for statements inside a delimited MySQL routine", () => {
    expect(rangeSqlTexts(executableStatementRanges(mysqlDelimitedRoutineFixture, "mysql"))).toEqual([mysqlDelimitedRoutineFixture.slice(mysqlDelimitedRoutineFixture.indexOf("CREATE PROCEDURE"), mysqlDelimitedRoutineFixture.indexOf(" //\nDELIMITER")), "CALL sp_insert_random_users(100)"]);
  });

  it("does not split executable SAP HANA DO ranges at inner statements", () => {
    expect(rangeSqlTexts(executableStatementRanges(sapHanaDoBlockFixture, "saphana"))).toEqual([sapHanaDoBlockFixture.slice(0, sapHanaDoBlockFixture.indexOf("\nSELECT 2")), "SELECT 2 FROM DUMMY"]);
  });

  it("returns executable SQL Server batches without GO delimiter lines", () => {
    expect(rangeSqlTexts(executableStatementRanges("SELECT 1\nGO\nSELECT 2;", "sqlserver"))).toEqual(["SELECT 1", "SELECT 2"]);
  });
});

describe("currentExecutableStatementRange", () => {
  it("uses the current SQL statement range for multi-line DDL", () => {
    const sql = "ALTER TABLE `yb_course_order`\n  ADD COLUMN `audit_status` tinyint(4) DEFAULT NULL\n    COMMENT '审核状态：0-待审核，1-已通过，2-已拒绝',\n  ADD COLUMN `close_reason` varchar(30) DEFAULT NULL\n    COMMENT '关闭原因：timeout-超时关闭，cancel-取消关闭，refund-退款关闭';\nSELECT 1;";

    expect(currentExecutableStatementRange(sql, indexOf(sql, "close_reason"), "mysql")?.sql.trim()).toBe(sql.slice(0, sql.indexOf(";\nSELECT")));
  });

  it("returns null on blank and pure comment lines", () => {
    const sql = "SELECT 1;\n-- comment\n\nSELECT 2;";

    expect(currentExecutableStatementRange(sql, indexOf(sql, "comment"), "mysql")).toBeNull();
    expect(currentExecutableStatementRange(sql, sql.indexOf("\n\n") + 1, "mysql")).toBeNull();
  });

  it("uses the current Redis command line", () => {
    const sql = "GET user:1\n  DEL user:2\n# comment";

    expect(currentExecutableStatementRange(sql, indexOf(sql, "DEL"), "redis")?.sql).toBe("DEL user:2");
    expect(currentExecutableStatementRange(sql, indexOf(sql, "comment"), "redis")).toBeNull();
  });

  it("uses the current MongoDB command range", () => {
    const sql = 'db.users.find({})\n\ndb.getCollection("audit.logs").countDocuments({})';

    expect(currentExecutableStatementRange(sql, indexOf(sql, "users"), "mongodb")?.sql).toBe("db.users.find({})");
    expect(currentExecutableStatementRange(sql, indexOf(sql, "audit.logs"), "mongodb")?.sql).toBe('db.getCollection("audit.logs").countDocuments({})');
  });
});

describe("fullSqlRange", () => {
  it("returns the trimmed full document", () => {
    const sql = "  SELECT 1;  \n";
    const range = fullSqlRange(sql);
    expect(range?.sql).toBe("SELECT 1;");
  });

  it("returns null for an empty/whitespace document", () => {
    expect(fullSqlRange("   \n  ")).toBeNull();
  });
});

describe("buildExecutionCandidates", () => {
  it("returns a single candidate when only the cursor statement exists", () => {
    const sql = "SELECT 1";
    const candidates = buildExecutionCandidates(sql, indexOf(sql, "1"));
    expect(candidates).toHaveLength(1);
    expect(candidates[0].kind).toBe("all");
  });

  it("returns current + all in order for multiple statements", () => {
    const sql = "SELECT 1;\nSELECT 2;";
    const candidates = buildExecutionCandidates(sql, indexOf(sql, "2"));
    expect(candidateKinds(candidates)).toEqual(["cursor", "all"]);
  });

  it("preserves leading optimizer hints in current statement candidates", () => {
    const hintedSql = "/*+ SET(polar_csi.enable_query on) SET(polar_csi.cost_threshold 0)*/\nselect count(1) from xxx";
    const sql = `select 1;\n${hintedSql};`;
    const candidates = buildExecutionCandidates(sql, indexOf(sql, "count"), "postgres");

    expect(candidates[0].sql).toBe(hintedSql);
  });

  it("uses the cursor statement for the first candidate when there is no selection", () => {
    const sql = "SELECT *\nFROM users\nWHERE active = 1";
    const candidates = buildExecutionCandidates(sql, indexOf(sql, "users"));
    expect(candidates).toHaveLength(1);
    expect(candidates[0].kind).toBe("all");
  });

  it("uses the whole set-operation statement for cursor execution candidates", () => {
    const sql = "select * from tbA\nunion\nselect * from tbB\nSELECT * FROM logs;";
    const candidates = buildExecutionCandidates(sql, indexOf(sql, "tbA"));

    expect(candidateSummaries(candidates)).toEqual(["cursor:select * from tbA\nunion\nselect * from tbB", "all:select * from tbA\nunion\nselect * from tbB\nSELECT * FROM logs;"]);
  });

  it("uses the current command line for Redis cursor candidates", () => {
    const sql = "GET user:1\nDEL user:2\nHGETALL user:3";
    const candidates = buildExecutionCandidates(sql, indexOf(sql, "user:2"), "redis");
    expect(candidateSummaries(candidates)).toEqual(["cursor:DEL user:2", "all:GET user:1\nDEL user:2\nHGETALL user:3"]);
    expect(candidateLabels(candidates)).toEqual(["currentCommand", "allCommands"]);
  });

  it("returns only all for Redis when the cursor is on a comment line", () => {
    const sql = "GET user:1\n# comment\nDEL user:2";
    const candidates = buildExecutionCandidates(sql, indexOf(sql, "comment"), "redis");
    expect(candidateSummaries(candidates)).toEqual(["all:GET user:1\n# comment\nDEL user:2"]);
  });

  it("returns current + all when the cursor is in indentation before a statement", () => {
    const sql = "SELECT 1;\n    SELECT 2;";
    const indentationPos = sql.indexOf("    SELECT 2") + 2;
    const candidates = buildExecutionCandidates(sql, indentationPos);
    expect(candidateSummaries(candidates)).toEqual(["cursor:SELECT 2", "all:SELECT 1;\n    SELECT 2;"]);
    expect(candidateLabels(candidates)).toEqual(["currentStatement", "allStatements"]);
  });

  it("keeps a MySQL FORCE INDEX query current when its semicolon is on the next line", () => {
    const firstStatement = `SELECT count(*)
FROM cus_loan_status_copy1 t2
LEFT JOIN case_allocation_details_copy1 t4 FORCE INDEX(idx_debt_case_number)
  ON t2.caseno = t4.debt_case_number
WHERE t2.product_name = '12345'
;`;
    const sql = `${firstStatement}\n\nSELECT count(*) FROM cus_loan_status_copy1;`;
    const candidates = buildExecutionCandidates(sql, indexOf(sql, "12345"), "mysql");

    expect(candidateKinds(candidates)).toEqual(["cursor", "all"]);
    expect(executionCandidateForMode(candidates, "current")?.sql.trim()).toBe(firstStatement.replace(/\n;$/, ""));
  });

  it("uses the current statement when the cursor is immediately after its semicolon before a blank line", () => {
    const sql = "select 1;\n\nselect 2;";
    const cursorAfterFirstSemicolon = sql.indexOf(";") + 1;
    const candidates = buildExecutionCandidates(sql, cursorAfterFirstSemicolon);
    expect(candidateSummaries(candidates)).toEqual(["cursor:select 1", "all:select 1;\n\nselect 2;"]);
  });

  it("uses the final soft statement when the cursor follows trailing EOF whitespace", () => {
    const sql = "SELECT 1\nSELECT 2 ";
    const candidates = buildExecutionCandidates(sql, sql.length);
    expect(candidateSummaries(candidates)).toEqual(["cursor:SELECT 2", "all:SELECT 1\nSELECT 2"]);
  });

  it("uses the final soft statement when the cursor is on a standalone trailing semicolon", () => {
    const sql = "SELECT * FROM `t_0001`\nSELECT * FROM `t_0001` LIMIT 1\n;";
    const candidates = buildExecutionCandidates(sql, sql.lastIndexOf(";"), "mysql");

    expect(candidateSummaries(candidates)).toEqual(["cursor:SELECT * FROM `t_0001` LIMIT 1", "all:SELECT * FROM `t_0001`\nSELECT * FROM `t_0001` LIMIT 1\n;"]);
  });

  it("dedupes when the cursor statement equals the full document", () => {
    const sql = "SELECT 1;";
    const candidates = buildExecutionCandidates(sql, indexOf(sql, "1"));
    expect(candidates).toHaveLength(1);
    expect(candidates[0].kind).toBe("all");
  });

  it("returns only 'all' when the cursor is on a blank line", () => {
    const sql = "SELECT 1;\n\nSELECT 2;";
    const candidates = buildExecutionCandidates(sql, sql.indexOf("\n") + 1);
    expect(candidateKinds(candidates)).toEqual(["all"]);
    expect(candidates[0].supportedKinds).toEqual(["all"]);
    expect(executionCandidateForMode(candidates, "current")).toBeNull();
    expect(executionCandidateForMode(candidates, "all")).toBe(candidates[0]);
  });

  it("marks a deduplicated single-statement candidate as both current and all", () => {
    const sql = "SELECT 1;";
    const candidates = buildExecutionCandidates(sql, indexOf(sql, "1"));

    expect(candidates[0].supportedKinds).toEqual(["cursor", "all"]);
  });

  it("returns no candidates for an empty document", () => {
    expect(buildExecutionCandidates("", 0)).toEqual([]);
  });

  it("returns only 'all' when the cursor has no statement but the document has SQL", () => {
    // Cursor past the end on a trailing blank line.
    const sql = "SELECT 1;\nSELECT 2;\n";
    const candidates = buildExecutionCandidates(sql, sql.length);
    expect(candidateKinds(candidates)).toEqual(["all"]);
  });

  it("uses the MySQL statement body for delimiter scripts", () => {
    const sql = "select COUNT(1) FROM your_table;\ndelimiter ;;\nselect COUNT(1) FROM your_table;\n\n;;\ndelimiter ;";
    const candidates = buildExecutionCandidates(sql, indexOf(sql, "COUNT", 2), "mysql");
    expect(candidateSummaries(candidates)).toEqual(["cursor:select COUNT(1) FROM your_table;", "all:select COUNT(1) FROM your_table;\ndelimiter ;;\nselect COUNT(1) FROM your_table;\n\n;;\ndelimiter ;"]);
  });

  it("uses the current SQL Server batch for cursor candidates", () => {
    const sql = "SELECT 1\nGO\nSELECT 2;";
    const candidates = buildExecutionCandidates(sql, indexOf(sql, "2"), "sqlserver");
    expect(candidateSummaries(candidates)).toEqual(["cursor:SELECT 2", "all:SELECT 1\nGO\nSELECT 2;"]);
  });
});

describe("hasMultipleExecutionTargets", () => {
  it("returns false for a single SQL statement", () => {
    expect(hasMultipleExecutionTargets("SELECT 1;")).toBe(false);
  });

  it("returns true for multiple SQL statements", () => {
    expect(hasMultipleExecutionTargets("SELECT 1;\nSELECT 2;")).toBe(true);
  });

  it("ignores comments when counting SQL statements", () => {
    expect(hasMultipleExecutionTargets("-- check one thing\nSELECT 1;")).toBe(false);
  });

  it("counts executable Redis command lines", () => {
    expect(hasMultipleExecutionTargets("GET user:1", "redis")).toBe(false);
    expect(hasMultipleExecutionTargets("GET user:1\n# comment\nDEL user:2", "redis")).toBe(true);
  });

  it("counts MySQL delimiter scripts by executable statements", () => {
    const sql = "select COUNT(1) FROM your_table;\ndelimiter ;;\nselect COUNT(1) FROM your_table;\n\n;;\ndelimiter ;";
    expect(hasMultipleExecutionTargets(sql, "mysql")).toBe(true);
  });

  it("counts MySQL routine blocks without delimiter by executable statements", () => {
    expect(hasMultipleExecutionTargets(mysqlRoutineFixture, "mysql")).toBe(true);
  });

  it("counts SQL Server GO batches as multiple execution targets", () => {
    expect(hasMultipleExecutionTargets("SELECT 1\nGO\nSELECT 2", "sqlserver")).toBe(true);
  });

  it("does not show multiple targets for MySQL DESC UPDATE joins", () => {
    const sql = "desc update  test_orders a\njoin test_users b\non a.id=b.id \nset a.name = '张三'\nwhere b.id > 10;";
    expect(hasMultipleExecutionTargets(sql, "mysql")).toBe(false);
  });
});

describe("supportsExecutionTargetPicker", () => {
  it("enables the picker for SQL database connections, Redis, and Elasticsearch", () => {
    expect(supportsExecutionTargetPicker("mysql")).toBe(true);
    expect(supportsExecutionTargetPicker("postgres")).toBe(true);
    expect(supportsExecutionTargetPicker("sqlserver")).toBe(true);
    expect(supportsExecutionTargetPicker("sqlite")).toBe(true);
    expect(supportsExecutionTargetPicker("jdbc")).toBe(true);
    expect(supportsExecutionTargetPicker("redis")).toBe(true);
    expect(supportsExecutionTargetPicker("mongodb")).toBe(false);
    expect(supportsExecutionTargetPicker("elasticsearch")).toBe(true);
    expect(supportsExecutionTargetPicker("easysearch")).toBe(true);
    expect(supportsExecutionTargetPicker("qdrant")).toBe(false);
    expect(supportsExecutionTargetPicker("milvus")).toBe(false);
    expect(supportsExecutionTargetPicker("weaviate")).toBe(false);
    expect(supportsExecutionTargetPicker("chromadb")).toBe(false);
    expect(supportsExecutionTargetPicker("etcd")).toBe(false);
    expect(supportsExecutionTargetPicker("zookeeper")).toBe(false);
    expect(supportsExecutionTargetPicker("mq")).toBe(false);
    expect(supportsExecutionTargetPicker("neo4j")).toBe(false);
    expect(supportsExecutionTargetPicker(undefined)).toBe(false);
  });
});