@lix-js/sdk 0.5.0-preview.1 → 0.5.0

package/dist/engine/preprocessor/sql-parser/parse.test.js

@@ -0,0 +1,1483 @@
+import { describe, expect, test } from "vitest";
+import { parse } from "./parse.js";
+import { identifier, } from "./nodes.js";
+const id = identifier;
+const lit = (value) => ({
+    node_kind: "literal",
+    value,
+});
+const parseStatements = (sql) => parse(sql);
+function parseSingleSegment(sql) {
+    const statements = parseStatements(sql);
+    if (statements.length !== 1) {
+        throw new Error("expected single statement");
+    }
+    const [statement] = statements;
+    if (!statement || statement.node_kind !== "segmented_statement") {
+        throw new Error("expected segmented statement");
+    }
+    if (statement.segments.length !== 1) {
+        throw new Error("expected single segment");
+    }
+    const [segment] = statement.segments;
+    if (!segment) {
+        throw new Error("missing segment");
+    }
+    return segment;
+}
+function parseSelectStatement(sql) {
+    const segment = parseSingleSegment(sql);
+    if (segment.node_kind !== "select_statement") {
+        throw new Error("expected select statement");
+    }
+    return segment;
+}
+function parseUpdateStatement(sql) {
+    const segment = parseSingleSegment(sql);
+    if (segment.node_kind !== "update_statement") {
+        throw new Error("expected update statement");
+    }
+    return segment;
+}
+function parseDeleteStatement(sql) {
+    const segment = parseSingleSegment(sql);
+    if (segment.node_kind !== "delete_statement") {
+        throw new Error("expected delete statement");
+    }
+    return segment;
+}
+function parseInsertStatement(sql) {
+    const segment = parseSingleSegment(sql);
+    if (segment.node_kind !== "insert_statement") {
+        throw new Error("expected insert statement");
+    }
+    return segment;
+}
+describe("parse", () => {
+    test("parses select star", () => {
+        const ast = parseSelectStatement("SELECT * FROM projects");
+        expect(ast).toMatchObject({
+            node_kind: "select_statement",
+            distinct: false,
+            projection: [{ node_kind: "select_star" }],
+            from_clauses: [
+                {
+                    node_kind: "from_clause",
+                    relation: {
+                        node_kind: "table_reference",
+                        name: { node_kind: "object_name", parts: [id("projects")] },
+                        alias: null,
+                    },
+                    joins: [],
+                },
+            ],
+            where_clause: null,
+            group_by: [],
+            order_by: [],
+            limit: null,
+            offset: null,
+            with_clause: null,
+        });
+    });
+    test("parses insert with on conflict do nothing", () => {
+        const ast = parseInsertStatement("INSERT INTO projects (id) VALUES ('a') ON CONFLICT DO NOTHING");
+        expect(ast.on_conflict).toMatchObject({
+            node_kind: "on_conflict_clause",
+            target: null,
+            action: { node_kind: "on_conflict_do_nothing" },
+        });
+    });
+    test("parses insert with on conflict do update", () => {
+        const ast = parseInsertStatement("INSERT INTO projects (id, name) VALUES ('a', 'A') ON CONFLICT(id) DO UPDATE SET name = excluded.name WHERE excluded.id = 'a'");
+        const clause = ast.on_conflict;
+        expect(clause).not.toBeNull();
+        expect(clause).toMatchObject({
+            node_kind: "on_conflict_clause",
+            target: {
+                node_kind: "on_conflict_target",
+                expressions: [
+                    {
+                        node_kind: "column_reference",
+                        path: [id("id")],
+                    },
+                ],
+                where: null,
+            },
+            action: {
+                node_kind: "on_conflict_do_update",
+                assignments: [
+                    {
+                        node_kind: "set_clause",
+                        column: {
+                            node_kind: "column_reference",
+                            path: [id("name")],
+                        },
+                        value: {
+                            node_kind: "column_reference",
+                            path: [id("excluded"), id("name")],
+                        },
+                    },
+                ],
+                where: {
+                    node_kind: "binary_expression",
+                    left: {
+                        node_kind: "column_reference",
+                        path: [id("excluded"), id("id")],
+                    },
+                    operator: "=",
+                    right: {
+                        node_kind: "literal",
+                        value: "a",
+                    },
+                },
+            },
+        });
+    });
+    test("parses insert default values", () => {
+        const ast = parseInsertStatement("INSERT INTO projects DEFAULT VALUES");
+        expect(ast).toMatchObject({
+            node_kind: "insert_statement",
+            target: { parts: [id("projects")] },
+            columns: [],
+            source: { node_kind: "insert_default_values" },
+        });
+    });
+    test("parses select with where and alias", () => {
+        const ast = parseSelectStatement("SELECT p.id AS project_id FROM projects AS p WHERE p.revision >= 1");
+        expect(ast).toMatchObject({
+            node_kind: "select_statement",
+            distinct: false,
+            projection: [
+                {
+                    node_kind: "select_expression",
+                    expression: {
+                        node_kind: "column_reference",
+                        path: [id("p"), id("id")],
+                    },
+                    alias: id("project_id"),
+                },
+            ],
+            from_clauses: [
+                {
+                    node_kind: "from_clause",
+                    relation: {
+                        node_kind: "table_reference",
+                        name: { node_kind: "object_name", parts: [id("projects")] },
+                        alias: id("p"),
+                    },
+                    joins: [],
+                },
+            ],
+            where_clause: {
+                node_kind: "binary_expression",
+                left: {
+                    node_kind: "column_reference",
+                    path: [id("p"), id("revision")],
+                },
+                operator: ">=",
+                right: { node_kind: "literal", value: 1 },
+            },
+            order_by: [],
+            group_by: [],
+            limit: null,
+            offset: null,
+            with_clause: null,
+        });
+    });
+    test("parses select literal without from clause", () => {
+        const ast = parseSelectStatement("SELECT 1 AS value");
+        expect(ast).toMatchObject({
+            node_kind: "select_statement",
+            distinct: false,
+            projection: [
+                {
+                    node_kind: "select_expression",
+                    expression: { node_kind: "literal", value: 1 },
+                    alias: id("value"),
+                },
+            ],
+            from_clauses: [],
+            where_clause: null,
+            group_by: [],
+            order_by: [],
+            limit: null,
+            offset: null,
+            with_clause: null,
+        });
+    });
+    test("parses qualified column without alias", () => {
+        const ast = parseSelectStatement("SELECT projects.id FROM projects");
+        expect(ast).toMatchObject({
+            node_kind: "select_statement",
+            distinct: false,
+            projection: [
+                {
+                    node_kind: "select_expression",
+                    expression: {
+                        node_kind: "column_reference",
+                        path: [id("projects"), id("id")],
+                    },
+                    alias: null,
+                },
+            ],
+            from_clauses: [
+                {
+                    node_kind: "from_clause",
+                    relation: {
+                        node_kind: "table_reference",
+                        name: { node_kind: "object_name", parts: [id("projects")] },
+                        alias: null,
+                    },
+                    joins: [],
+                },
+            ],
+            where_clause: null,
+            group_by: [],
+            order_by: [],
+            limit: null,
+            offset: null,
+            with_clause: null,
+        });
+    });
+    test("parses update with assignments", () => {
+        const ast = parseUpdateStatement("UPDATE projects SET name = 'new', revision = revision + 1 WHERE id = ?");
+        expect(ast).toMatchObject({
+            node_kind: "update_statement",
+            target: {
+                node_kind: "table_reference",
+                name: { node_kind: "object_name", parts: [id("projects")] },
+                alias: null,
+            },
+            assignments: [
+                {
+                    node_kind: "set_clause",
+                    column: {
+                        node_kind: "column_reference",
+                        path: [id("name")],
+                    },
+                    value: { node_kind: "literal", value: "new" },
+                },
+                {
+                    node_kind: "set_clause",
+                    column: {
+                        node_kind: "column_reference",
+                        path: [id("revision")],
+                    },
+                    value: {
+                        node_kind: "binary_expression",
+                        left: {
+                            node_kind: "column_reference",
+                            path: [id("revision")],
+                        },
+                        operator: "+",
+                        right: { node_kind: "literal", value: 1 },
+                    },
+                },
+            ],
+            where_clause: {
+                node_kind: "binary_expression",
+                left: {
+                    node_kind: "column_reference",
+                    path: [id("id")],
+                },
+                operator: "=",
+                right: {
+                    node_kind: "parameter",
+                    placeholder: "?",
+                    position: 0,
+                },
+            },
+        });
+    });
+    test("parses update with quoted identifiers and parameters", () => {
+        const ast = parseUpdateStatement('UPDATE "inlang_variant" SET "pattern" = ? WHERE "messageId" = ?');
+        expect(ast).toMatchObject({
+            node_kind: "update_statement",
+            target: {
+                node_kind: "table_reference",
+                name: {
+                    node_kind: "object_name",
+                    parts: [id("inlang_variant", true)],
+                },
+                alias: null,
+            },
+            assignments: [
+                {
+                    node_kind: "set_clause",
+                    column: {
+                        node_kind: "column_reference",
+                        path: [id("pattern", true)],
+                    },
+                    value: {
+                        node_kind: "parameter",
+                        placeholder: "?",
+                        position: 0,
+                    },
+                },
+            ],
+            where_clause: {
+                node_kind: "binary_expression",
+                left: {
+                    node_kind: "column_reference",
+                    path: [id("messageId", true)],
+                },
+                operator: "=",
+                right: {
+                    node_kind: "parameter",
+                    placeholder: "?",
+                    position: 1,
+                },
+            },
+        });
+    });
+    test("parses IN predicate", () => {
+        const ast = parseSelectStatement("SELECT * FROM projects WHERE id IN ('a', 'b')");
+        expect(ast.where_clause).toMatchObject({
+            node_kind: "in_list_expression",
+            operand: {
+                node_kind: "column_reference",
+                path: [id("id")],
+            },
+            items: [lit("a"), lit("b")],
+            negated: false,
+        });
+    });
+    test("parses limit and offset clauses", () => {
+        const ast = parseSelectStatement("SELECT id FROM projects ORDER BY created_at DESC LIMIT 5 OFFSET 10");
+        expect(ast.limit).toMatchObject({
+            node_kind: "literal",
+            value: 5,
+        });
+        expect(ast.offset).toMatchObject({
+            node_kind: "literal",
+            value: 10,
+        });
+    });
+    test("parses limit without offset", () => {
+        const ast = parseSelectStatement("SELECT * FROM files LIMIT 20");
+        expect(ast.limit).toMatchObject({
+            node_kind: "literal",
+            value: 20,
+        });
+        expect(ast.offset).toBeNull();
+    });
+    test("parses parameterised limit and offset", () => {
+        const ast = parseSelectStatement("SELECT * FROM logs LIMIT ? OFFSET ?2");
+        expect(ast.limit).toMatchObject({
+            node_kind: "parameter",
+            placeholder: "?",
+            position: 0,
+        });
+        expect(ast.offset).toMatchObject({
+            node_kind: "parameter",
+            placeholder: "?2",
+            position: 1,
+        });
+    });
+    test("assigns sequential positions after numbered placeholders", () => {
+        const ast = parseSelectStatement("SELECT * FROM logs WHERE owner_id = ?1 AND schema_key = ?");
+        const where = ast.where_clause;
+        if (!where || where.node_kind !== "binary_expression") {
+            throw new Error("expected binary expression");
+        }
+        const { left, right } = where;
+        if (left.node_kind !== "binary_expression") {
+            throw new Error("expected binary expression on left");
+        }
+        if (right.node_kind !== "binary_expression") {
+            throw new Error("expected binary expression on right");
+        }
+        const leftParam = left.right;
+        const rightParam = right.right;
+        if (leftParam.node_kind !== "parameter") {
+            throw new Error("expected parameter on left");
+        }
+        if (rightParam.node_kind !== "parameter") {
+            throw new Error("expected parameter on right");
+        }
+        expect(leftParam).toMatchObject({
+            node_kind: "parameter",
+            placeholder: "?1",
+            position: 0,
+        });
+        expect(rightParam).toMatchObject({
+            node_kind: "parameter",
+            placeholder: "?",
+            position: 1,
+        });
+    });
+    test("returns raw fragment for unsupported statement types", () => {
+        const sql = "CREATE TABLE projects(id TEXT)";
+        const statements = parseStatements(sql);
+        expect(statements).toHaveLength(1);
+        const [statement] = statements;
+        if (!statement || statement.node_kind !== "segmented_statement") {
+            throw new Error("expected segmented statement");
+        }
+        expect(statement.segments).toMatchObject([
+            {
+                node_kind: "raw_fragment",
+                sql_text: sql,
+            },
+        ]);
+    });
+    test("returns raw fragment when lexing fails", () => {
+        const sql = "???";
+        const statements = parseStatements(sql);
+        expect(statements).toHaveLength(1);
+        const [statement] = statements;
+        if (!statement || statement.node_kind !== "segmented_statement") {
+            throw new Error("expected segmented statement");
+        }
+        expect(statement.segments).toMatchObject([
+            {
+                node_kind: "raw_fragment",
+                sql_text: sql,
+            },
+        ]);
+    });
+    test("parses BETWEEN predicate", () => {
+        const ast = parseSelectStatement("SELECT * FROM projects WHERE revision BETWEEN 1 AND 5");
+        expect(ast.where_clause).toMatchObject({
+            node_kind: "between_expression",
+            operand: {
+                node_kind: "column_reference",
+                path: [id("revision")],
+            },
+            start: lit(1),
+            end: lit(5),
+            negated: false,
+        });
+    });
+    test("parses ORDER BY clause", () => {
+        const ast = parseSelectStatement("SELECT * FROM projects ORDER BY updated_at DESC, id");
+        expect(ast.order_by).toMatchObject([
+            {
+                node_kind: "order_by_item",
+                expression: {
+                    node_kind: "column_reference",
+                    path: [id("updated_at")],
+                },
+                direction: "desc",
+            },
+            {
+                node_kind: "order_by_item",
+                expression: {
+                    node_kind: "column_reference",
+                    path: [id("id")],
+                },
+                direction: null,
+            },
+        ]);
+    });
+    test("parses NOT predicate", () => {
+        const ast = parseSelectStatement("SELECT * FROM projects WHERE NOT (archived = 1)");
+        expect(ast.where_clause).toMatchObject({
+            node_kind: "unary_expression",
+            operator: "not",
+            operand: {
+                node_kind: "grouped_expression",
+                expression: {
+                    node_kind: "binary_expression",
+                    left: {
+                        node_kind: "column_reference",
+                        path: [id("archived")],
+                    },
+                    operator: "=",
+                    right: lit(1),
+                },
+            },
+        });
+    });
+    test("parses MATCH, GLOB, and REGEXP operators", () => {
+        const matchAst = parseSelectStatement("SELECT * FROM documents WHERE title MATCH 'fts query'");
+        expect(matchAst.where_clause).toMatchObject({
+            node_kind: "binary_expression",
+            left: {
+                node_kind: "column_reference",
+                path: [id("title")],
+            },
+            operator: "match",
+            right: lit("fts query"),
+        });
+        const globAst = parseSelectStatement("SELECT * FROM documents WHERE path GLOB '*.md'");
+        expect(globAst.where_clause).toMatchObject({
+            node_kind: "binary_expression",
+            left: {
+                node_kind: "column_reference",
+                path: [id("path")],
+            },
+            operator: "glob",
+            right: lit("*.md"),
+        });
+        const regexpAst = parseSelectStatement("SELECT * FROM documents WHERE body REGEXP 'foo.*'");
+        expect(regexpAst.where_clause).toMatchObject({
+            node_kind: "binary_expression",
+            left: {
+                node_kind: "column_reference",
+                path: [id("body")],
+            },
+            operator: "regexp",
+            right: lit("foo.*"),
+        });
+    });
+    test("parses delete", () => {
+        const ast = parseDeleteStatement("DELETE FROM projects WHERE projects.id = 'obsolete'");
+        expect(ast).toMatchObject({
+            node_kind: "delete_statement",
+            target: {
+                node_kind: "table_reference",
+                name: { node_kind: "object_name", parts: [id("projects")] },
+                alias: null,
+            },
+            where_clause: {
+                node_kind: "binary_expression",
+                left: {
+                    node_kind: "column_reference",
+                    path: [id("projects"), id("id")],
+                },
+                operator: "=",
+                right: { node_kind: "literal", value: "obsolete" },
+            },
+        });
+    });
+    test("parses insert with column list and multiple rows", () => {
+        const ast = parseInsertStatement("INSERT INTO projects (id, name) VALUES ('a', 'Project A'), ('b', ?)");
+        expect(ast).toMatchObject({
+            node_kind: "insert_statement",
+            target: {
+                node_kind: "object_name",
+                parts: [id("projects")],
+            },
+            columns: [id("id"), id("name")],
+            source: {
+                node_kind: "insert_values",
+                rows: [
+                    [lit("a"), lit("Project A")],
+                    [lit("b"), { node_kind: "parameter", placeholder: "?", position: 0 }],
+                ],
+            },
+            on_conflict: null,
+        });
+    });
+    test("parses function call expression inside update assignment", () => {
+        const ast = parseUpdateStatement("UPDATE key_value SET value = json_set(value, '$.foo', ?) WHERE key = ?");
+        expect(ast).toMatchObject({
+            node_kind: "update_statement",
+            target: {
+                node_kind: "table_reference",
+                name: { node_kind: "object_name", parts: [id("key_value")] },
+                alias: null,
+            },
+            assignments: [
+                {
+                    node_kind: "set_clause",
+                    column: {
+                        node_kind: "column_reference",
+                        path: [id("value")],
+                    },
+                    value: {
+                        node_kind: "function_call",
+                        name: id("json_set"),
+                        arguments: [
+                            {
+                                node_kind: "column_reference",
+                                path: [id("value")],
+                            },
+                            {
+                                node_kind: "literal",
+                                value: "$.foo",
+                            },
+                            {
+                                node_kind: "parameter",
+                                placeholder: "?",
+                                position: 0,
+                            },
+                        ],
+                        over: null,
+                    },
+                },
+            ],
+            where_clause: {
+                node_kind: "binary_expression",
+                left: {
+                    node_kind: "column_reference",
+                    path: [id("key")],
+                },
+                operator: "=",
+                right: {
+                    node_kind: "parameter",
+                    placeholder: "?",
+                    position: 1,
+                },
+            },
+        });
+    });
+    test("parses function call without arguments inside update assignment", () => {
+        const ast = parseUpdateStatement("UPDATE metrics SET touched_at = random() WHERE id = ?");
+        expect(ast).toMatchObject({
+            node_kind: "update_statement",
+            target: {
+                node_kind: "table_reference",
+                name: { node_kind: "object_name", parts: [id("metrics")] },
+                alias: null,
+            },
+            assignments: [
+                {
+                    node_kind: "set_clause",
+                    column: {
+                        node_kind: "column_reference",
+                        path: [id("touched_at")],
+                    },
+                    value: {
+                        node_kind: "function_call",
+                        name: id("random"),
+                        arguments: [],
+                        over: null,
+                    },
+                },
+            ],
+            where_clause: {
+                node_kind: "binary_expression",
+                left: {
+                    node_kind: "column_reference",
+                    path: [id("id")],
+                },
+                operator: "=",
+                right: {
+                    node_kind: "parameter",
+                    placeholder: "?",
+                    position: 0,
+                },
+            },
+        });
+    });
+    test("parses window function with partition and order", () => {
+        const ast = parseSelectStatement("SELECT ROW_NUMBER() OVER (PARTITION BY entity_id ORDER BY created_at) AS rn FROM change");
+        expect(ast).toMatchObject({
+            node_kind: "select_statement",
+            distinct: false,
+            projection: [
+                {
+                    node_kind: "select_expression",
+                    expression: {
+                        node_kind: "function_call",
+                        name: id("ROW_NUMBER"),
+                        arguments: [],
+                        over: {
+                            node_kind: "window_specification",
+                            name: null,
+                            partition_by: [
+                                {
+                                    node_kind: "column_reference",
+                                    path: [id("entity_id")],
+                                },
+                            ],
+                            order_by: [
+                                {
+                                    node_kind: "order_by_item",
+                                    expression: {
+                                        node_kind: "column_reference",
+                                        path: [id("created_at")],
+                                    },
+                                    direction: null,
+                                },
+                            ],
+                            frame: null,
+                        },
+                    },
+                    alias: id("rn"),
+                },
+            ],
+            from_clauses: [
+                {
+                    node_kind: "from_clause",
+                    relation: {
+                        node_kind: "table_reference",
+                        name: {
+                            node_kind: "object_name",
+                            parts: [id("change")],
+                        },
+                        alias: null,
+                    },
+                    joins: [],
+                },
+            ],
+            where_clause: null,
+            group_by: [],
+            order_by: [],
+            limit: null,
+            offset: null,
+            with_clause: null,
+        });
+    });
+    test("parses json arrow operators in projection", () => {
+        const ast = parseSelectStatement("SELECT value ->> '$.enabled' AS enabled FROM key_value");
+        expect(ast).toMatchObject({
+            node_kind: "select_statement",
+            projection: [
+                {
+                    expression: {
+                        node_kind: "binary_expression",
+                        operator: "->>",
+                        left: {
+                            node_kind: "column_reference",
+                            path: [id("value")],
+                        },
+                        right: {
+                            node_kind: "literal",
+                            value: "$.enabled",
+                        },
+                    },
+                    alias: id("enabled"),
+                },
+            ],
+            from_clauses: [
+                {
+                    relation: {
+                        node_kind: "table_reference",
+                        name: {
+                            node_kind: "object_name",
+                            parts: [id("key_value")],
+                        },
+                    },
+                },
+            ],
+        });
+    });
+    test("parses string concatenation operator", () => {
+        const ast = parseSelectStatement("SELECT '/' || name AS path FROM file_rows");
+        expect(ast.projection).toMatchObject([
+            {
+                expression: {
+                    node_kind: "binary_expression",
+                    operator: "||",
+                    left: {
+                        node_kind: "literal",
+                        value: "/",
+                    },
+                    right: {
+                        node_kind: "column_reference",
+                        path: [id("name")],
+                    },
+                },
+                alias: id("path"),
+            },
+        ]);
+    });
+    test("prioritises concatenation ahead of multiplication", () => {
+        const ast = parseSelectStatement("SELECT 1 || 2 * 3 AS value");
+        expect(ast.projection).toMatchObject([
+            {
+                expression: {
+                    node_kind: "binary_expression",
+                    operator: "*",
+                    left: {
+                        node_kind: "binary_expression",
+                        operator: "||",
+                        left: lit(1),
+                        right: lit(2),
+                    },
+                    right: lit(3),
+                },
+                alias: id("value"),
+            },
+        ]);
+    });
+    test("parses not exists predicate", () => {
+        const ast = parseSelectStatement("SELECT id FROM conversation_message_by_version AS m1 WHERE NOT EXISTS (SELECT 1 FROM conversation_message_by_version AS m2 WHERE m2.parent_id = m1.id)");
+        expect(ast).toMatchObject({
+            where_clause: {
+                node_kind: "unary_expression",
+                operator: "not",
+                operand: {
+                    node_kind: "exists_expression",
+                    statement: {
+                        node_kind: "select_statement",
+                    },
+                },
+            },
+        });
+    });
+    test("parses window function with frame bounds", () => {
+        const ast = parseSelectStatement("SELECT SUM(amount) OVER (PARTITION BY account ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) FROM ledger");
+        expect(ast).toMatchObject({
+            node_kind: "select_statement",
+            distinct: false,
+            projection: [
+                {
+                    node_kind: "select_expression",
+                    expression: {
+                        node_kind: "function_call",
+                        name: id("SUM"),
+                        arguments: [
+                            {
+                                node_kind: "column_reference",
+                                path: [id("amount")],
+                            },
+                        ],
+                        over: {
+                            node_kind: "window_specification",
+                            name: null,
+                            partition_by: [
+                                {
+                                    node_kind: "column_reference",
+                                    path: [id("account")],
+                                },
+                            ],
+                            order_by: [],
+                            frame: {
+                                node_kind: "window_frame",
+                                units: "rows",
+                                start: {
+                                    node_kind: "window_frame_bound",
+                                    type: "unbounded_preceding",
+                                    offset: null,
+                                },
+                                end: {
+                                    node_kind: "window_frame_bound",
+                                    type: "current_row",
+                                    offset: null,
+                                },
+                            },
+                        },
+                    },
+                    alias: null,
+                },
+            ],
+            from_clauses: [
+                {
+                    node_kind: "from_clause",
+                    relation: {
+                        node_kind: "table_reference",
+                        name: {
+                            node_kind: "object_name",
+                            parts: [id("ledger")],
+                        },
+                        alias: null,
+                    },
+                    joins: [],
+                },
+            ],
+            where_clause: null,
+            group_by: [],
+            order_by: [],
+            limit: null,
+            offset: null,
+            with_clause: null,
+        });
+    });
+    test("parses subqueries with no alias", () => {
+        const sql = `
+		SELECT * FROM (SELECT 1)
+		`;
+        const statements = parseStatements(sql);
+        expect(statements).toMatchObject([
+            {
+                node_kind: "segmented_statement",
+                segments: [
+                    {
+                        node_kind: "select_statement",
+                        from_clauses: [
+                            {
+                                relation: {
+                                    node_kind: "subquery",
+                                },
+                            },
+                        ],
+                    },
+                ],
+            },
+        ]);
+    });
+    test("handles count(*) in select projection", () => {
+        const ast = parseSelectStatement("SELECT COUNT(*) AS total FROM users");
+        expect(ast).toMatchObject({
+            node_kind: "select_statement",
+            projection: [
+                {
+                    node_kind: "select_expression",
+                    expression: {
+                        node_kind: "function_call",
+                        name: id("COUNT"),
+                        arguments: [{ node_kind: "all_columns" }],
+                        over: null,
+                    },
+                    alias: id("total"),
+                },
+            ],
+            from_clauses: [
+                {
+                    relation: {
+                        node_kind: "table_reference",
+                        name: { node_kind: "object_name", parts: [id("users")] },
+                    },
+                },
+            ],
+        });
+    });
+    test("parses recursive CTE with compound body", () => {
+        const sql = `
+WITH RECURSIVE
+  "foo" AS (
+    SELECT
+      "id",
+      "name",
+      0 AS "depth"
+    FROM "items"
+    WHERE "id" = 'root'
+
+    UNION ALL
+
+    SELECT
+      "child"."id",
+      "child"."name",
+      "foo"."depth" + 1 AS "depth"
+    FROM "items" AS "child"
+    JOIN "foo" ON "child"."parent_id" = "foo"."id"
+  )
+SELECT *
+FROM "foo";
+		`.trim();
+        const statements = parseStatements(sql);
+        expect(statements).toHaveLength(1);
+        const [statement] = statements;
+        if (!statement || statement.node_kind !== "segmented_statement") {
+            throw new Error("expected segmented statement");
+        }
+        const [segment] = statement.segments;
+        if (!segment || segment.node_kind !== "select_statement") {
+            throw new Error("expected select statement segment");
+        }
+        const select = segment;
+        const withClause = select.with_clause;
+        expect(withClause).not.toBeNull();
+        if (!withClause) {
+            throw new Error("missing with clause");
+        }
+        expect(withClause.recursive).toBe(true);
+        expect(withClause.ctes).toHaveLength(1);
+        const cte = withClause.ctes[0];
+        if (!cte) {
+            throw new Error("expected CTE definition");
+        }
+        const cteStatement = cte.statement;
+        if (!cteStatement || cteStatement.node_kind !== "compound_select") {
+            throw new Error("expected compound select in CTE");
+        }
+        expect(cteStatement.compounds).toHaveLength(1);
+        expect(cteStatement.first.with_clause).toBeNull();
+        expect(cteStatement.compounds[0]?.select.with_clause).toBeNull();
+    });
+    test("parses derived table that starts with WITH clause", () => {
+        const sql = `
+SELECT outer_table.id
+FROM (
+	WITH nested AS (
+		SELECT id
+		FROM base_table
+	)
+	SELECT id
+	FROM nested
+) AS outer_table
+		`.trim();
+        const statement = parseSelectStatement(sql);
+        const fromClause = statement.from_clauses[0];
+        if (!fromClause) {
+            throw new Error("expected FROM clause");
+        }
+        const relation = fromClause.relation;
+        if (!relation || relation.node_kind !== "subquery") {
+            throw new Error("expected derived table relation");
+        }
+        const subqueryStatement = relation.statement;
+        if (!subqueryStatement ||
+            subqueryStatement.node_kind !== "select_statement") {
+            throw new Error("expected select statement inside derived table");
+        }
+        const withClause = subqueryStatement.with_clause;
+        expect(withClause).not.toBeNull();
+        if (!withClause) {
+            throw new Error("expected with clause on derived table");
+        }
+        expect(withClause.recursive).toBe(false);
+        expect(withClause.ctes).toHaveLength(1);
+        const [cte] = withClause.ctes;
+        if (!cte) {
+            throw new Error("missing nested CTE definition");
+        }
+        expect(cte.statement.node_kind).toBe("select_statement");
+    });
+    test("parses scalar subquery expression with WITH clause", () => {
+        const sql = `
+SELECT (
+	WITH nested AS (
+		SELECT 1 AS depth
+	)
+	SELECT depth FROM nested
+) AS resolved_depth
+		`.trim();
+        const statement = parseSelectStatement(sql);
+        const projection = statement.projection[0];
+        if (!projection || projection.node_kind !== "select_expression") {
+            throw new Error("expected select expression in projection");
+        }
+        const expr = projection.expression;
+        if (!expr || expr.node_kind !== "subquery_expression") {
+            throw new Error("expected subquery expression");
+        }
+        const subqueryStatement = expr.statement;
+        if (!subqueryStatement ||
+            subqueryStatement.node_kind !== "select_statement") {
+            throw new Error("expected select statement inside scalar subquery");
+        }
+        const withClause = subqueryStatement.with_clause;
+        expect(withClause).not.toBeNull();
+        if (!withClause) {
+            throw new Error("expected with clause on scalar subquery");
+        }
+        expect(withClause.ctes).toHaveLength(1);
+    });
+    test("parses searched CASE expression", () => {
+        const sql = `
+	SELECT
+	  CASE
+	    WHEN foo.kind = 'alpha' THEN 'first'
+	    WHEN foo.kind = 'beta' THEN 'second'
+	    ELSE 'other'
+	  END AS kind_label
+	FROM foo
+		`.trim();
+        const statement = parseSelectStatement(sql);
+        const projection = statement.projection[0];
+        if (!projection || projection.node_kind !== "select_expression") {
+            throw new Error("expected select expression");
+        }
+        const expression = projection.expression;
+        expect(expression.node_kind).toBe("case_expression");
+        if (expression.node_kind !== "case_expression") {
+            throw new Error("expected case expression");
+        }
+        expect(expression.operand).toBeNull();
+        expect(expression.branches).toHaveLength(2);
+        expect(expression.branches[0]?.condition.node_kind).toBe("binary_expression");
+        expect(expression.branches[0]?.result.node_kind).toBe("literal");
+        expect(expression.branches[1]?.result.node_kind).toBe("literal");
+        expect(expression.else_result?.node_kind).toBe("literal");
+    });
+    test("parses simple CASE expression with operand", () => {
+        const sql = `
+SELECT
+  CASE foo.status
+    WHEN 'active' THEN 1
+    ELSE 0
+  END AS status_flag
+FROM foo
+		`.trim();
+        const statement = parseSelectStatement(sql);
+        const projection = statement.projection[0];
+        if (!projection || projection.node_kind !== "select_expression") {
+            throw new Error("expected select expression");
+        }
+        const expression = projection.expression;
+        expect(expression.node_kind).toBe("case_expression");
+        if (expression.node_kind !== "case_expression") {
+            throw new Error("expected case expression");
+        }
+        expect(expression.operand?.node_kind).toBe("column_reference");
+        expect(expression.branches).toHaveLength(1);
+        expect(expression.branches[0]?.condition.node_kind).toBe("literal");
+        expect(expression.branches[0]?.result.node_kind).toBe("literal");
+        expect(expression.else_result?.node_kind).toBe("literal");
+    });
+    test("parses select distinct with group by", () => {
+        const ast = parseSelectStatement("SELECT DISTINCT foo FROM bar GROUP BY foo");
+        expect(ast.distinct).toBe(true);
+        expect(ast.group_by).toHaveLength(1);
+        expect(ast.group_by[0]?.node_kind).toBe("column_reference");
+    });
+    test("parses union select", () => {
+        const segment = parseSingleSegment("SELECT id FROM foo UNION SELECT parent_id FROM bar");
+        expect(segment.node_kind).toBe("compound_select");
+        if (segment.node_kind !== "compound_select") {
+            throw new Error("expected compound select");
+        }
+        expect(segment.compounds).toHaveLength(1);
+    });
+    test("parses recursive union select", () => {
+        const sql = `
+SELECT commit_id, commit_id as root_commit_id, 0 as depth
+FROM requested_commits
+UNION
+SELECT ce.parent_id, r.root_commit_id, r.depth + 1
+FROM commit_edge_by_version ce
+JOIN reachable_commits_from_requested r ON ce.child_id = r.id
+WHERE ce.lixcol_version_id = 'global'
+`.trim();
+        const segment = parseSingleSegment(sql);
+        expect(segment.node_kind).toBe("compound_select");
+    });
+    test("parses multi-cte with union", () => {
+        const sql = `
+WITH head AS (
+  SELECT 1 AS value
+),
+chain AS (
+  SELECT value FROM head
+  UNION
+  SELECT value + 1 FROM head
+)
+SELECT * FROM chain
+`.trim();
+        const segment = parseSingleSegment(sql);
+        expect(segment.node_kind === "select_statement" ||
+            segment.node_kind === "compound_select").toBe(true);
+    });
+    test("segments parenthesised select with trailing clause", () => {
+        const sql = `(SELECT 1) LIMIT 1;`;
+        const statements = parseStatements(sql);
+        expect(statements).toHaveLength(1);
+        const [statement] = statements;
+        if (!statement || statement.node_kind !== "segmented_statement") {
+            throw new Error("expected segmented statement");
+        }
+        expect(statement.segments).toHaveLength(3);
+        const [prefix, select, suffix] = statement.segments;
+        if (!prefix || prefix.node_kind !== "raw_fragment") {
+            throw new Error("expected raw fragment prefix");
+        }
+        expect(prefix.sql_text).toBe("(");
+        if (!select || select.node_kind !== "select_statement") {
+            throw new Error("expected select statement segment");
+        }
+        expect(select.projection).toHaveLength(1);
+        if (!suffix || suffix.node_kind !== "raw_fragment") {
+            throw new Error("expected raw fragment suffix");
+        }
+        expect(suffix.sql_text).toBe(") LIMIT 1;");
+    });
+    test("handles mixed casing around UNION keyword", () => {
+        const sql = `
+SELECT * FROM foo
+uNiOn
+select bar FROM baz
+		`.trim();
+        const statements = parseStatements(sql);
+        expect(statements).toHaveLength(1);
+        const [statement] = statements;
+        if (!statement || statement.node_kind !== "segmented_statement") {
+            throw new Error("expected segmented statement");
+        }
+        expect(statement.segments).toHaveLength(1);
+        const [segment] = statement.segments;
+        if (!segment || segment.node_kind !== "compound_select") {
+            throw new Error("expected compound select segment");
+        }
+        const compound = segment;
+        expect(compound.compounds).toHaveLength(1);
+        expect(compound.compounds[0]?.operator).toBe("union");
+        const firstFrom = compound.first.from_clauses[0];
+        if (!firstFrom || firstFrom.relation.node_kind !== "table_reference") {
+            throw new Error("expected table reference");
+        }
+        const secondFrom = compound.compounds[0]?.select.from_clauses[0];
+        if (!secondFrom || secondFrom.relation.node_kind !== "table_reference") {
+            throw new Error("expected table reference");
+        }
+    });
+    test("parses compound selects with INTERSECT and EXCEPT", () => {
+        const sql = `
+SELECT id FROM t1
+INTERSECT
+SELECT id FROM t2
+EXCEPT
+SELECT id FROM t3
+		`.trim();
+        const statements = parseStatements(sql);
+        expect(statements).toHaveLength(1);
+        const [statement] = statements;
+        if (!statement || statement.node_kind !== "segmented_statement") {
+            throw new Error("expected segmented statement");
+        }
+        expect(statement.segments).toHaveLength(1);
+        const [segment] = statement.segments;
+        if (!segment || segment.node_kind !== "compound_select") {
+            throw new Error("expected compound select");
+        }
+        const compound = segment;
+        expect(compound.compounds).toHaveLength(2);
+        expect(compound.compounds[0]?.operator).toBe("intersect");
+        expect(compound.compounds[1]?.operator).toBe("except");
+    });
+    test("applies ORDER BY/LIMIT/OFFSET to compound", () => {
+        const sql = `
+SELECT id FROM t1
+UNION ALL
+SELECT id FROM t2
+ORDER BY id DESC
+LIMIT 5
+OFFSET 10
+		`.trim();
+        const statements = parseStatements(sql);
+        expect(statements).toHaveLength(1);
+        const [statement] = statements;
+        if (!statement || statement.node_kind !== "segmented_statement") {
+            throw new Error("expected segmented statement");
+        }
+        expect(statement.segments).toHaveLength(1);
+        const [segment] = statement.segments;
+        if (!segment || segment.node_kind !== "compound_select") {
+            throw new Error("expected compound select");
+        }
+        const compound = segment;
+        expect(compound.order_by).toHaveLength(1);
+        expect(compound.limit).not.toBeNull();
+        expect(compound.offset).not.toBeNull();
+        expect(compound.first.order_by).toMatchObject([]);
+        expect(compound.first.limit).toBeNull();
+        expect(compound.first.offset).toBeNull();
+    });
+    test("compound inside CTE parses into with clause", () => {
+        const sql = `
+WITH expr AS (
+  SELECT id FROM t1
+  UNION ALL
+  SELECT id FROM t2
+)
+SELECT * FROM expr;
+		`.trim();
+        const statements = parseStatements(sql);
+        expect(statements).toHaveLength(1);
+        const [statement] = statements;
+        if (!statement || statement.node_kind !== "segmented_statement") {
+            throw new Error("expected segmented statement");
+        }
+        const [segment] = statement.segments;
+        if (!segment || segment.node_kind !== "select_statement") {
+            throw new Error("expected select statement");
+        }
+        const select = segment;
+        const withClause = select.with_clause;
+        expect(withClause).not.toBeNull();
+        if (!withClause) {
+            throw new Error("missing with clause");
+        }
+        expect(withClause.recursive).toBe(false);
+        expect(withClause.ctes).toHaveLength(1);
+        const cte = withClause.ctes[0];
+        if (!cte) {
+            throw new Error("expected CTE definition");
+        }
+        expect(cte.columns).toMatchObject([]);
+        if (cte.statement.node_kind !== "compound_select") {
+            throw new Error("expected compound select inside CTE");
+        }
+        expect(cte.statement.compounds).toHaveLength(1);
+    });
+    test("parses recursive IN subquery with with clause", () => {
+        const sql = `
+SELECT c.id FROM commit AS c
+WHERE c.id IN (
+	WITH RECURSIVE ap(id, depth) AS (
+		SELECT id, 0 AS depth FROM commit WHERE id = 'root'
+		UNION ALL
+		SELECT parent_id, ap.depth + 1 FROM commit_edge JOIN ap ON commit_edge.child_id = ap.id
+	)
+	SELECT id FROM ap
+)
+LIMIT 1;
+		`.trim();
+        const statements = parseStatements(sql);
+        expect(statements).toHaveLength(1);
+        const [statement] = statements;
+        if (!statement || statement.node_kind !== "segmented_statement") {
+            throw new Error("expected segmented statement");
+        }
+        const [segment] = statement.segments;
+        if (!segment || segment.node_kind !== "select_statement") {
+            throw new Error("expected outer select statement");
+        }
+        const outerSelect = segment;
+        expect(outerSelect.with_clause).toBeNull();
+        const whereClause = outerSelect.where_clause;
+        if (!whereClause || whereClause.node_kind !== "in_list_expression") {
+            throw new Error("expected IN list expression");
+        }
+        expect(whereClause.items).toHaveLength(1);
+        const [subqueryItem] = whereClause.items;
+        if (!subqueryItem || subqueryItem.node_kind !== "subquery_expression") {
+            throw new Error("expected subquery expression inside IN");
+        }
+        const subquerySelect = subqueryItem.statement;
+        if (!subquerySelect || subquerySelect.node_kind !== "select_statement") {
+            throw new Error("expected select statement in subquery");
+        }
+        const subqueryWith = subquerySelect.with_clause;
+        expect(subqueryWith).not.toBeNull();
+        if (!subqueryWith) {
+            throw new Error("missing with clause on subquery");
+        }
+        expect(subqueryWith.recursive).toBe(true);
+        expect(subqueryWith.ctes).toHaveLength(1);
+        const cte = subqueryWith.ctes[0];
+        if (!cte) {
+            throw new Error("expected CTE definition");
+        }
+        const cteStatement = cte.statement;
+        if (!cteStatement || cteStatement.node_kind !== "compound_select") {
+            throw new Error("expected compound select in CTE");
+        }
+        expect(cteStatement.compounds).toHaveLength(1);
+        const collectedSelects = [
+            outerSelect,
+            subquerySelect,
+            cteStatement.first,
+            cteStatement.compounds[0].select,
+        ];
+        expect(collectedSelects.every((sel) => sel.node_kind === "select_statement")).toBe(true);
+    });
+    test("parses recursive IN subquery within join-heavy query", () => {
+        const sql = `
+select "commit"."id" from "commit"
+inner join "entity_label"
+  on "entity_label"."entity_id" = "commit"."id"
+  and "entity_label"."schema_key" = ?
+inner join "label"
+  on "label"."id" = "entity_label"."label_id"
+where "label"."name" = ?
+  and "commit".id IN (
+    WITH RECURSIVE ap(id, depth) AS (
+      SELECT id, 0 AS depth
+      FROM "commit"
+      WHERE id = '019a4aac-b3ca-740e-a498-f54da878beda'
+      UNION ALL
+      SELECT commit_edge.parent_id, ap.depth + 1
+      FROM commit_edge
+      JOIN ap ON commit_edge.child_id = ap.id
+      WHERE ap.depth < 1
+    )
+    -- Select based on the includeSelf flag
+    SELECT id FROM ap
+  )
+limit ?`;
+        const statements = parseStatements(sql);
+        expect(statements).toHaveLength(1);
+        const [statement] = statements;
+        if (!statement || statement.node_kind !== "segmented_statement") {
+            throw new Error("expected segmented statement");
+        }
+        const [segment] = statement.segments;
+        if (!segment || segment.node_kind !== "select_statement") {
+            throw new Error("expected root select statement");
+        }
+        expect(segment.with_clause).toBeNull();
+        const whereClause = segment.where_clause;
+        if (!whereClause || whereClause.node_kind !== "binary_expression") {
+            throw new Error("expected binary where clause");
+        }
+        const inExpression = whereClause.right.node_kind === "in_list_expression"
+            ? whereClause.right
+            : whereClause.left.node_kind === "in_list_expression"
+                ? whereClause.left
+                : null;
+        if (!inExpression) {
+            throw new Error("missing IN list expression in where clause");
+        }
+        expect(inExpression.items).toHaveLength(1);
+        const [subqueryItem] = inExpression.items;
+        if (!subqueryItem || subqueryItem.node_kind !== "subquery_expression") {
+            throw new Error("expected subquery expression within IN clause");
+        }
+        const subquerySelect = subqueryItem.statement;
+        if (!subquerySelect || subquerySelect.node_kind !== "select_statement") {
+            throw new Error("expected select statement inside IN clause");
+        }
+        const subqueryWith = subquerySelect.with_clause;
+        expect(subqueryWith).not.toBeNull();
+        if (!subqueryWith) {
+            throw new Error("missing with clause in IN subquery");
+        }
+        expect(subqueryWith.recursive).toBe(true);
+        expect(subqueryWith.ctes).toHaveLength(1);
+        const cte = subqueryWith.ctes[0];
+        if (!cte) {
+            throw new Error("expected CTE definition");
+        }
+        const cteStatement = cte.statement;
+        if (!cteStatement || cteStatement.node_kind !== "compound_select") {
+            throw new Error("expected compound select in recursive CTE");
+        }
+        expect(cteStatement.compounds).toHaveLength(1);
+    });
+    test("handles count(*) in select projection", () => {
+        const ast = parseSelectStatement("SELECT COUNT(*) AS total FROM users");
+        expect(ast).toMatchObject({
+            node_kind: "select_statement",
+            distinct: false,
+            projection: [
+                {
+                    node_kind: "select_expression",
+                    expression: {
+                        node_kind: "function_call",
+                        name: id("COUNT"),
+                        arguments: [
+                            {
+                                node_kind: "all_columns",
+                            },
+                        ],
+                        over: null,
+                    },
+                    alias: id("total"),
+                },
+            ],
+            from_clauses: [
+                {
+                    node_kind: "from_clause",
+                    relation: {
+                        node_kind: "table_reference",
+                        name: { node_kind: "object_name", parts: [id("users")] },
+                        alias: null,
+                    },
+                    joins: [],
+                },
+            ],
+        });
+    });
+});
+test("parses parameter predicate without operator", () => {
+    const ast = parseSelectStatement(`SELECT "key" FROM "key_value" WHERE ?`);
+    expect(ast).toMatchObject({
+        where_clause: {
+            node_kind: "parameter",
+            placeholder: "?",
+        },
+    });
+});
+test("parses nested derived tables", () => {
+    const ast = parseSelectStatement("SELECT * FROM ((SELECT 1 AS value) AS inner_table)");
+    expect(ast).toMatchObject({
+        node_kind: "select_statement",
+        from_clauses: [
+            {
+                relation: {
+                    node_kind: "subquery",
+                    alias: id("inner_table"),
+                    statement: {
+                        node_kind: "select_statement",
+                        projection: [
+                            {
+                                node_kind: "select_expression",
+                                expression: {
+                                    node_kind: "literal",
+                                    value: 1,
+                                },
+                                alias: id("value"),
+                            },
+                        ],
+                    },
+                },
+            },
+        ],
+    });
+});
+//# sourceMappingURL=parse.test.js.map