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

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

@@ -0,0 +1,1503 @@
+import { identifier } from "./nodes.js";
+import { parseCst, parserInstance } from "./cst.js";
+const BaseVisitor = parserInstance.getBaseCstVisitorConstructorWithDefaults();
+class ToAstVisitor extends BaseVisitor {
+    constructor() {
+        super();
+        this.validateVisitor();
+    }
+    select_statement(ctx) {
+        const select = ctx.select?.[0];
+        if (select) {
+            return this.visit(select);
+        }
+        const insert = ctx.insert?.[0];
+        if (insert) {
+            return this.visit(insert);
+        }
+        const update = ctx.update?.[0];
+        if (update) {
+            return this.visit(update);
+        }
+        const del = ctx.delete?.[0];
+        if (del) {
+            return this.visit(del);
+        }
+        throw new Error("statement missing recognized root");
+    }
+    select_compound(ctx) {
+        const coreNodes = ctx.cores ?? [];
+        if (coreNodes.length === 0) {
+            throw new Error("compound select requires at least one core");
+        }
+        const selectNodes = coreNodes.map((core) => this.visit(core));
+        const withClause = ctx.with_clause?.[0]
+            ? this.visit(ctx.with_clause[0])
+            : null;
+        const orderByItems = ctx.order_by?.[0]
+            ? this.visit(ctx.order_by[0])
+            : [];
+        const limitNode = ctx.limit?.[0]
+            ? this.visit(ctx.limit[0])
+            : null;
+        const offsetNode = ctx.offset?.[0]
+            ? this.visit(ctx.offset[0])
+            : null;
+        const operatorNodes = ctx.operators ?? [];
+        if (operatorNodes.length === 0) {
+            const single = { ...selectNodes[0] };
+            return {
+                ...single,
+                order_by: orderByItems,
+                limit: limitNode,
+                offset: offsetNode,
+                with_clause: withClause,
+            };
+        }
+        if (operatorNodes.length !== selectNodes.length - 1) {
+            throw new Error("compound select operator mismatch");
+        }
+        const compounds = selectNodes.slice(1).map((select, index) => {
+            const op = this.visit(operatorNodes[index]);
+            return {
+                operator: op,
+                select,
+            };
+        });
+        const first = { ...selectNodes[0] };
+        first.order_by = [];
+        first.limit = null;
+        first.offset = null;
+        return {
+            node_kind: "compound_select",
+            first,
+            compounds,
+            order_by: orderByItems,
+            limit: limitNode,
+            offset: offsetNode,
+            with_clause: withClause,
+        };
+    }
+    select_core(ctx) {
+        const selectList = ctx.select_list?.[0];
+        if (!selectList) {
+            throw new Error("select list is missing");
+        }
+        const projection = this.visit(selectList);
+        const fromNode = ctx.from?.[0];
+        const fromClauses = [];
+        if (fromNode) {
+            const relation = this.visit(fromNode);
+            const joins = ctx.joins?.map((join) => this.visit(join)) ?? [];
+            fromClauses.push({
+                node_kind: "from_clause",
+                relation,
+                joins,
+            });
+        }
+        const whereNode = ctx.where_clause?.[0];
+        const whereClause = whereNode
+            ? this.visit(whereNode)
+            : null;
+        const groupBy = ctx.group_by?.map((node) => this.visit(node)) ?? [];
+        return {
+            node_kind: "select_statement",
+            distinct: Boolean(ctx.distinct?.length),
+            projection,
+            from_clauses: fromClauses,
+            where_clause: whereClause,
+            group_by: groupBy,
+            order_by: [],
+            limit: null,
+            offset: null,
+            with_clause: null,
+        };
+    }
+    with_clause(ctx) {
+        const expressions = ctx.ctes?.map((cte) => this.visit(cte));
+        return {
+            node_kind: "with_clause",
+            recursive: Boolean(ctx.recursive?.length),
+            ctes: expressions ?? [],
+        };
+    }
+    common_table_expression(ctx) {
+        const name = this.visit(ctx.name[0]);
+        const columns = ctx.columns?.map((column) => this.visit(column));
+        const statement = this.visit(ctx.statement[0]);
+        return {
+            node_kind: "common_table_expression",
+            name,
+            columns: columns ?? [],
+            statement,
+        };
+    }
+    compound_operator(ctx) {
+        if (ctx.Union?.length) {
+            return ctx.All?.length ? "union_by_version" : "union";
+        }
+        if (ctx.Intersect?.length) {
+            return "intersect";
+        }
+        if (ctx.Except?.length) {
+            return "except";
+        }
+        throw new Error("unrecognised compound operator");
+    }
+    insert_statement(ctx) {
+        const tableNode = ctx.table?.[0];
+        if (!tableNode) {
+            throw new Error("insert statement missing target table");
+        }
+        const target = this.visit(tableNode);
+        const columnNodes = ctx.columns?.map((column) => this.visit(column)) ?? [];
+        const hasDefaultValues = (ctx.default_keyword?.length ?? 0) > 0;
+        let source;
+        if (hasDefaultValues) {
+            source = { node_kind: "insert_default_values" };
+        }
+        else {
+            const valuesListNode = ctx.rows?.[0];
+            if (!valuesListNode) {
+                throw new Error("insert statement missing values list");
+            }
+            const rowNodes = this.visit(valuesListNode);
+            source = {
+                node_kind: "insert_values",
+                rows: rowNodes,
+            };
+        }
+        const conflictNode = ctx.conflict?.[0];
+        const onConflict = conflictNode
+            ? this.visit(conflictNode)
+            : null;
+        return {
+            node_kind: "insert_statement",
+            target,
+            columns: columnNodes,
+            source,
+            on_conflict: onConflict,
+        };
+    }
+    on_conflict_clause(ctx) {
+        const expressionNodes = ctx.target_expressions ?? [];
+        const expressions = expressionNodes.map((node) => this.visit(node));
+        const targetWhereNode = ctx.target_where?.[0];
+        const targetWhere = targetWhereNode
+            ? this.visit(targetWhereNode)
+            : null;
+        const target = expressions.length > 0 || targetWhere
+            ? {
+                node_kind: "on_conflict_target",
+                expressions,
+                where: targetWhere,
+            }
+            : null;
+        let action;
+        if (ctx.do_nothing?.length) {
+            action = { node_kind: "on_conflict_do_nothing" };
+        }
+        else {
+            const assignmentNodes = ctx.assignments ?? [];
+            const assignments = assignmentNodes.map((node) => this.visit(node));
+            if (assignments.length === 0) {
+                throw new Error("ON CONFLICT DO UPDATE requires assignments");
+            }
+            const actionWhereNode = ctx.action_where?.[0];
+            const actionWhere = actionWhereNode
+                ? this.visit(actionWhereNode)
+                : null;
+            action = {
+                node_kind: "on_conflict_do_update",
+                assignments,
+                where: actionWhere,
+            };
+        }
+        return {
+            node_kind: "on_conflict_clause",
+            target,
+            action,
+        };
+    }
+    limit_clause(ctx) {
+        const expressionNode = ctx.value?.[0];
+        if (!expressionNode) {
+            throw new Error("limit clause missing value");
+        }
+        return this.visit(expressionNode);
+    }
+    offset_clause(ctx) {
+        const expressionNode = ctx.value?.[0];
+        if (!expressionNode) {
+            throw new Error("offset clause missing value");
+        }
+        return this.visit(expressionNode);
+    }
+    select_list(ctx) {
+        const items = ctx.items ?? [];
+        if (items.length === 0) {
+            throw new Error("select list is missing");
+        }
+        return items.map((item) => this.visit(item));
+    }
+    select_item(ctx) {
+        if (ctx.star?.[0]) {
+            const star = { node_kind: "select_star" };
+            return star;
+        }
+        if (ctx.qualifiedStar?.[0]) {
+            const qualifiers = ctx.qualifier?.map((node) => this.visit(node)) ?? [];
+            const qualified = {
+                node_kind: "select_qualified_star",
+                qualifier: qualifiers,
+            };
+            return qualified;
+        }
+        const expressionNode = ctx.expression?.[0];
+        if (!expressionNode) {
+            throw new Error("select item missing expression");
+        }
+        const expression = this.visit(expressionNode);
+        const aliasNode = ctx.alias?.[0];
+        const alias = aliasNode ? this.visit(aliasNode) : null;
+        return {
+            node_kind: "select_expression",
+            expression,
+            alias,
+        };
+    }
+    table_reference(ctx) {
+        const nestedNode = ctx.nested?.[0];
+        if (nestedNode) {
+            const relation = this.visit(nestedNode);
+            const aliasToken = ctx.alias?.[0] ?? null;
+            if (!aliasToken) {
+                return relation;
+            }
+            const aliasIdentifier = this.visit(aliasToken);
+            if (relation.node_kind === "table_reference") {
+                return {
+                    ...relation,
+                    alias: aliasIdentifier,
+                };
+            }
+            if (relation.node_kind === "subquery") {
+                return {
+                    ...relation,
+                    alias: aliasIdentifier,
+                };
+            }
+            return relation;
+        }
+        const selectNode = ctx.select?.[0];
+        if (selectNode) {
+            const aliasToken = ctx.alias?.[0] ?? null;
+            const alias = aliasToken
+                ? this.visit(aliasToken)
+                : null;
+            const statement = this.visit(selectNode);
+            const subquery = {
+                node_kind: "subquery",
+                statement,
+                alias,
+            };
+            return subquery;
+        }
+        const tableNode = ctx.table?.[0];
+        if (!tableNode) {
+            throw new Error("table reference is missing");
+        }
+        const name = this.visit(tableNode);
+        const aliasNode = ctx.alias?.[0];
+        const alias = aliasNode ? this.visit(aliasNode) : null;
+        const tableRef = {
+            node_kind: "table_reference",
+            name,
+            alias,
+        };
+        return tableRef;
+    }
+    table_name(ctx) {
+        const parts = ctx.parts?.map((node) => this.visit(node)) ?? [];
+        if (parts.length === 0) {
+            throw new Error("table name is missing");
+        }
+        return {
+            node_kind: "object_name",
+            parts,
+        };
+    }
+    join_clause(ctx) {
+        const tableNode = ctx.table?.[0];
+        if (!tableNode) {
+            throw new Error("join clause is missing table reference");
+        }
+        const relation = this.visit(tableNode);
+        const joinTypeToken = ctx.join_type?.[0];
+        const joinType = joinTypeToken
+            ? normalizeJoinType(joinTypeToken.image)
+            : "inner";
+        const onNode = ctx.on_expression?.[0];
+        const onExpression = onNode ? this.visit(onNode) : null;
+        return {
+            node_kind: "join_clause",
+            join_type: joinType,
+            relation,
+            on_expression: onExpression,
+        };
+    }
+    where_clause(ctx) {
+        const expression = ctx.expression?.[0];
+        if (!expression) {
+            throw new Error("where clause is empty");
+        }
+        return this.visit(expression);
+    }
+    or_expression(ctx) {
+        const operands = ctx.operands?.map((operand) => this.visit(operand)) ??
+            [];
+        if (operands.length === 0) {
+            throw new Error("logical expression missing operands");
+        }
+        return foldBinaryExpression("or", operands);
+    }
+    and_expression(ctx) {
+        const operands = ctx.operands?.map((operand) => this.visit(operand)) ??
+            [];
+        if (operands.length === 0) {
+            throw new Error("logical expression missing operands");
+        }
+        return foldBinaryExpression("and", operands);
+    }
+    atomic_predicate(ctx) {
+        if (ctx.unary_not?.[0]) {
+            const inner = ctx.negated?.[0];
+            if (!inner) {
+                throw new Error("not predicate missing operand");
+            }
+            const expression = this.visit(inner);
+            return createUnaryExpression("not", expression);
+        }
+        if (ctx.exists?.[0]) {
+            const subqueryNode = ctx
+                .exists_subquery?.[0];
+            if (!subqueryNode) {
+                throw new Error("exists predicate missing subquery");
+            }
+            const statement = this.visit(subqueryNode);
+            return createExistsExpression(statement);
+        }
+        const leftExpressionNode = ctx.left_expression?.[0];
+        if (leftExpressionNode) {
+            const leftOperand = this.visit(leftExpressionNode);
+            const comparisonOperatorNode = ctx.comparison_operator?.[0];
+            if (comparisonOperatorNode) {
+                const comparisonValueNode = ctx.comparison_value?.[0];
+                if (!comparisonValueNode) {
+                    throw new Error("comparison predicate missing right operand");
+                }
+                const operator = this.visit(comparisonOperatorNode);
+                const rightOperand = this.visit(comparisonValueNode);
+                return createBinaryExpression(leftOperand, operator, rightOperand);
+            }
+            const betweenStartNode = ctx.between_start?.[0];
+            const betweenEndNode = ctx.between_end?.[0];
+            if (betweenStartNode && betweenEndNode) {
+                const start = this.visit(betweenStartNode);
+                const end = this.visit(betweenEndNode);
+                return createBetweenExpression(leftOperand, start, end, false);
+            }
+            const inListNode = ctx.in_list?.[0];
+            if (inListNode) {
+                const listItems = this.visit(inListNode);
+                return createInListExpression(leftOperand, listItems, Boolean(ctx.in_not?.length));
+            }
+            const inSubqueryNode = ctx.in_subquery?.[0];
+            if (inSubqueryNode) {
+                const statement = this.visit(inSubqueryNode);
+                const subqueryExpression = {
+                    node_kind: "subquery_expression",
+                    statement,
+                };
+                return createInListExpression(leftOperand, [subqueryExpression], Boolean(ctx.in_not?.length));
+            }
+            const likePatternNode = ctx.like_pattern?.[0];
+            if (likePatternNode) {
+                const pattern = this.visit(likePatternNode);
+                const operator = ctx.like_not?.length
+                    ? "not_like"
+                    : "like";
+                return createBinaryExpression(leftOperand, operator, pattern);
+            }
+            if (ctx.is_operator?.length) {
+                const operator = ctx.is_not?.length ? "is_not" : "is";
+                const nullLiteral = createLiteralNode(null);
+                return createBinaryExpression(leftOperand, operator, nullLiteral);
+            }
+            return leftOperand;
+        }
+        const inner = ctx.inner?.[0];
+        if (!inner) {
+            throw new Error("predicate is neither comparison nor grouped expression");
+        }
+        const expression = this.visit(inner);
+        return expression.node_kind === "grouped_expression"
+            ? expression
+            : {
+                node_kind: "grouped_expression",
+                expression,
+            };
+    }
+    additive_expression(ctx) {
+        const operands = ctx.operands?.map((operand) => this.visit(operand)) ??
+            [];
+        if (operands.length === 0) {
+            throw new Error("additive expression missing operands");
+        }
+        const operators = ctx.operators ?? [];
+        let current = operands[0];
+        for (let index = 0; index < operators.length; index += 1) {
+            const operatorToken = operators[index];
+            const operator = mapArithmeticOperator(operatorToken.image);
+            const right = operands[index + 1];
+            current = createBinaryExpression(current, operator, right);
+        }
+        return current;
+    }
+    expression(ctx) {
+        const node = ctx.expression?.[0];
+        if (!node) {
+            throw new Error("expression node missing");
+        }
+        return this.visit(node);
+    }
+    multiplicative_expression(ctx) {
+        const operands = ctx.operands?.map((operand) => this.visit(operand)) ??
+            [];
+        if (operands.length === 0) {
+            throw new Error("multiplicative expression missing operands");
+        }
+        const operators = ctx.operators ?? [];
+        let current = operands[0];
+        for (let index = 0; index < operators.length; index += 1) {
+            const operatorToken = operators[index];
+            const operator = mapArithmeticOperator(operatorToken.image);
+            const right = operands[index + 1];
+            current = createBinaryExpression(current, operator, right);
+        }
+        return current;
+    }
+    concatenation_expression(ctx) {
+        const operands = ctx.operands?.map((operand) => this.visit(operand)) ??
+            [];
+        if (operands.length === 0) {
+            throw new Error("concatenation expression missing operands");
+        }
+        const operators = ctx.operators ?? [];
+        let current = operands[0];
+        for (let index = 0; index < operators.length; index += 1) {
+            const operatorToken = operators[index];
+            const operator = mapArithmeticOperator(operatorToken.image);
+            const right = operands[index + 1];
+            current = createBinaryExpression(current, operator, right);
+        }
+        return current;
+    }
+    unary_expression(ctx) {
+        const operandNode = ctx.operand?.[0];
+        if (!operandNode) {
+            throw new Error("unary expression missing operand");
+        }
+        const operand = this.visit(operandNode);
+        const operatorToken = ctx.unaryOperator?.[0];
+        if (!operatorToken) {
+            return operand;
+        }
+        const image = operatorToken.image.toLowerCase();
+        let unaryOperator;
+        if (image === "-") {
+            unaryOperator = "minus";
+        }
+        else if (image === "not") {
+            unaryOperator = "not";
+        }
+        else {
+            throw new Error("unsupported unary operator");
+        }
+        return createUnaryExpression(unaryOperator, operand);
+    }
+    primary_expression(ctx) {
+        const parameter = ctx.parameter?.[0];
+        if (parameter) {
+            const parameterNode = {
+                node_kind: "parameter",
+                placeholder: parameter.image ?? "?",
+                position: -1,
+            };
+            return parameterNode;
+        }
+        const stringLiteral = ctx.string?.[0];
+        if (stringLiteral?.image) {
+            return createLiteralNode(normalizeStringLiteral(stringLiteral.image));
+        }
+        const numberLiteral = ctx.number?.[0];
+        if (numberLiteral?.image) {
+            return createLiteralNode(Number(numberLiteral.image));
+        }
+        const nullLiteral = ctx.nullLiteral?.[0];
+        if (nullLiteral) {
+            return createLiteralNode(null);
+        }
+        const caseExpression = ctx.caseExpression?.[0];
+        if (caseExpression) {
+            return this.visit(caseExpression);
+        }
+        const callIdentifier = ctx.callIdentifier?.[0];
+        if (callIdentifier?.image) {
+            let args = [];
+            const starToken = ctx.callStar?.[0];
+            if (starToken) {
+                args = [{ node_kind: "all_columns" }];
+            }
+            else {
+                args =
+                    ctx.callArguments?.map((argument) => this.visit(argument)) ?? [];
+            }
+            const overClause = ctx.overClause?.[0];
+            const over = overClause
+                ? this.visit(overClause)
+                : null;
+            const functionCall = {
+                node_kind: "function_call",
+                name: identifier(callIdentifier.image),
+                arguments: args,
+                over,
+            };
+            return functionCall;
+        }
+        const reference = ctx.reference?.[0];
+        if (reference) {
+            return this.visit(reference);
+        }
+        const subselect = ctx.subselect?.[0];
+        if (subselect) {
+            const statement = this.visit(subselect);
+            return {
+                node_kind: "subquery_expression",
+                statement,
+            };
+        }
+        const inner = ctx.inner?.[0];
+        if (!inner) {
+            throw new Error("primary expression is empty");
+        }
+        const expression = this.visit(inner);
+        if (expression.node_kind === "grouped_expression") {
+            return expression;
+        }
+        const grouped = {
+            node_kind: "grouped_expression",
+            expression,
+        };
+        return grouped;
+    }
+    over_clause(ctx) {
+        const nameToken = ctx.windowName?.[0];
+        if (nameToken?.image) {
+            return {
+                node_kind: "window_reference",
+                name: identifier(nameToken.image),
+            };
+        }
+        const specNode = ctx.windowSpec?.[0];
+        if (specNode) {
+            return this.visit(specNode);
+        }
+        return {
+            node_kind: "window_specification",
+            name: null,
+            partition_by: [],
+            order_by: [],
+            frame: null,
+        };
+    }
+    window_specification(ctx) {
+        const nameNode = ctx.name?.[0];
+        const name = nameNode ? this.visit(nameNode) : null;
+        const partitionExpressions = ctx.partitionBy?.map((node) => this.visit(node)) ?? [];
+        const orderNodes = ctx.orderBy?.[0]
+            ? this.visit(ctx.orderBy[0])
+            : [];
+        const frameNode = ctx.frame?.[0]
+            ? this.visit(ctx.frame[0])
+            : null;
+        return {
+            node_kind: "window_specification",
+            name,
+            partition_by: partitionExpressions,
+            order_by: orderNodes,
+            frame: frameNode,
+        };
+    }
+    window_frame(ctx) {
+        const unitToken = ctx.units[0];
+        const unitImage = unitToken?.image?.toLowerCase() ?? "";
+        const units = unitImage === "range"
+            ? "range"
+            : unitImage === "groups"
+                ? "groups"
+                : "rows";
+        const startNode = ctx.start?.[0];
+        if (!startNode) {
+            throw new Error("window frame requires a starting bound");
+        }
+        const start = this.visit(startNode);
+        const endNode = ctx.end?.[0];
+        const end = endNode ? this.visit(endNode) : null;
+        return {
+            node_kind: "window_frame",
+            units,
+            start,
+            end,
+        };
+    }
+    window_frame_bound(ctx) {
+        const directionToken = ctx.direction?.[0];
+        if (ctx.unbounded?.length) {
+            if (!directionToken?.image) {
+                throw new Error("UNBOUNDED bound requires direction");
+            }
+            const direction = directionToken.image.toLowerCase();
+            return {
+                node_kind: "window_frame_bound",
+                type: direction === "following"
+                    ? "unbounded_following"
+                    : "unbounded_preceding",
+                offset: null,
+            };
+        }
+        if (ctx.current?.length) {
+            return {
+                node_kind: "window_frame_bound",
+                type: "current_row",
+                offset: null,
+            };
+        }
+        const offsetNode = ctx.offset?.[0];
+        if (!offsetNode || !directionToken?.image) {
+            throw new Error("window frame bound requires offset and direction");
+        }
+        const direction = directionToken.image.toLowerCase();
+        const offset = this.visit(offsetNode);
+        return {
+            node_kind: "window_frame_bound",
+            type: direction === "following" ? "following" : "preceding",
+            offset,
+        };
+    }
+    case_expression(ctx) {
+        const operandNode = ctx.operand?.[0];
+        const operand = operandNode
+            ? this.visit(operandNode)
+            : null;
+        const conditions = ctx.when_condition?.map((node) => this.visit(node)) ??
+            ctx.when_value?.map((node) => this.visit(node)) ??
+            [];
+        const results = ctx.then_expression?.map((node) => this.visit(node)) ??
+            [];
+        if (conditions.length !== results.length) {
+            throw new Error("CASE expression requires matching WHEN and THEN clauses");
+        }
+        const branches = conditions.map((condition, index) => ({
+            condition,
+            result: results[index],
+        }));
+        const elseNode = ctx.else_expression?.[0];
+        const elseExpression = elseNode
+            ? this.visit(elseNode)
+            : null;
+        return {
+            node_kind: "case_expression",
+            operand,
+            branches,
+            else_result: elseExpression,
+        };
+    }
+    column_reference(ctx) {
+        const parts = ctx.parts?.map((part) => this.visit(part)) ?? [];
+        if (parts.length === 0) {
+            throw new Error("column reference is missing");
+        }
+        if (parts.length === 1 || parts.length === 2) {
+            return {
+                node_kind: "column_reference",
+                path: parts,
+            };
+        }
+        throw new Error("column references with nested paths are not supported yet");
+    }
+    assignment_item(ctx) {
+        const columnNode = ctx.column?.[0];
+        if (!columnNode) {
+            throw new Error("assignment missing column");
+        }
+        const valueNode = ctx.value?.[0];
+        if (!valueNode) {
+            throw new Error("assignment missing value");
+        }
+        const column = this.visit(columnNode);
+        const value = this.visit(valueNode);
+        return {
+            node_kind: "set_clause",
+            column,
+            value,
+        };
+    }
+    update_statement(ctx) {
+        const tableNode = ctx.table?.[0];
+        if (!tableNode) {
+            throw new Error("update statement missing table reference");
+        }
+        const targetRelation = this.visit(tableNode);
+        if (targetRelation.node_kind !== "table_reference") {
+            throw new Error("update statement requires a base table reference");
+        }
+        const assignments = ctx.assignments?.map((assignment) => this.visit(assignment)) ?? [];
+        if (assignments.length === 0) {
+            throw new Error("update statement missing assignments");
+        }
+        const whereNode = ctx.where_clause?.[0];
+        const whereClause = whereNode
+            ? this.visit(whereNode)
+            : null;
+        return {
+            node_kind: "update_statement",
+            target: targetRelation,
+            assignments,
+            where_clause: whereClause,
+        };
+    }
+    delete_statement(ctx) {
+        const tableNode = ctx.table?.[0];
+        if (!tableNode) {
+            throw new Error("delete statement missing table reference");
+        }
+        const targetRelation = this.visit(tableNode);
+        if (targetRelation.node_kind !== "table_reference") {
+            throw new Error("delete statement requires a base table reference");
+        }
+        const whereNode = ctx.where_clause?.[0];
+        const whereClause = whereNode
+            ? this.visit(whereNode)
+            : null;
+        return {
+            node_kind: "delete_statement",
+            target: targetRelation,
+            where_clause: whereClause,
+        };
+    }
+    expression_list(ctx) {
+        return ctx.items?.map((item) => this.visit(item)) ?? [];
+    }
+    values_list(ctx) {
+        const rows = ctx.rows ?? [];
+        if (rows.length === 0) {
+            throw new Error("values list is empty");
+        }
+        return rows.map((row) => this.visit(row));
+    }
+    values_clause(ctx) {
+        const valuesNode = ctx.values?.[0];
+        if (!valuesNode) {
+            throw new Error("values clause missing expressions");
+        }
+        return this.visit(valuesNode);
+    }
+    order_by_clause(ctx) {
+        return ctx.items?.map((item) => this.visit(item)) ?? [];
+    }
+    order_by_item(ctx) {
+        const expressionNode = ctx.expression?.[0];
+        if (!expressionNode) {
+            throw new Error("order by item missing expression");
+        }
+        const expression = this.visit(expressionNode);
+        const directionToken = ctx.direction?.[0];
+        const direction = directionToken
+            ? normalizeOrderDirection(directionToken.image)
+            : null;
+        return {
+            node_kind: "order_by_item",
+            expression,
+            direction,
+        };
+    }
+    comparison_operator(ctx) {
+        const token = ctx.operator?.[0];
+        if (!token) {
+            throw new Error("comparison operator token missing");
+        }
+        return mapComparisonOperator(token.image);
+    }
+    identifier(ctx) {
+        const token = ctx.Identifier?.[0] ?? ctx.QuotedIdentifier?.[0];
+        if (!token?.image) {
+            throw new Error("identifier token missing");
+        }
+        const isQuoted = token.tokenType?.name === "QuotedIdentifier";
+        const value = isQuoted
+            ? token.image.slice(1, -1).replace(/""/g, '"')
+            : token.image;
+        return {
+            node_kind: "identifier",
+            value,
+            quoted: isQuoted,
+        };
+    }
+}
+const visitor = new ToAstVisitor();
+function createLiteralNode(value) {
+    return {
+        node_kind: "literal",
+        value,
+    };
+}
+function createBinaryExpression(left, operator, right) {
+    return {
+        node_kind: "binary_expression",
+        left,
+        operator,
+        right,
+    };
+}
+function foldBinaryExpression(operator, operands) {
+    let current = operands[0];
+    for (let index = 1; index < operands.length; index += 1) {
+        current = createBinaryExpression(current, operator, operands[index]);
+    }
+    return current;
+}
+function createInListExpression(operand, items, negated) {
+    return {
+        node_kind: "in_list_expression",
+        operand,
+        items,
+        negated,
+    };
+}
+function createExistsExpression(statement) {
+    return {
+        node_kind: "exists_expression",
+        statement,
+    };
+}
+function createBetweenExpression(operand, start, end, negated) {
+    return {
+        node_kind: "between_expression",
+        operand,
+        start,
+        end,
+        negated,
+    };
+}
+function createUnaryExpression(operator, operand) {
+    return {
+        node_kind: "unary_expression",
+        operator,
+        operand,
+    };
+}
+function mapArithmeticOperator(image) {
+    switch (image) {
+        case "||":
+        case "+":
+        case "-":
+        case "*":
+        case "/":
+        case "%":
+        case "->":
+        case "->>":
+            return image;
+        default:
+            throw new Error(`unsupported arithmetic operator '${image}'`);
+    }
+}
+function mapComparisonOperator(image) {
+    switch (image) {
+        case "=":
+        case "!=":
+        case "<>":
+        case ">":
+        case ">=":
+        case "<":
+        case "<=":
+            return image;
+    }
+    const keyword = image.toLowerCase();
+    if (keyword === "match" || keyword === "glob" || keyword === "regexp") {
+        return keyword;
+    }
+    throw new Error(`unsupported comparison operator '${image}'`);
+}
+function normalizeJoinType(value) {
+    switch (value.toLowerCase()) {
+        case "inner":
+            return "inner";
+        case "left":
+            return "left";
+        case "right":
+            return "right";
+        case "full":
+            return "full";
+        default:
+            return "inner";
+    }
+}
+function normalizeOrderDirection(value) {
+    const normalized = value.toLowerCase();
+    if (normalized === "asc" || normalized === "desc") {
+        return normalized;
+    }
+    throw new Error(`unsupported order by direction '${value}'`);
+}
+function normalizeStringLiteral(image) {
+    const inner = image.slice(1, -1);
+    return inner.replace(/''/g, "'");
+}
+function toStatementNode(root) {
+    return visitor.visit(root);
+}
+function assignParameterPositions(statement) {
+    const state = { nextSequential: 0 };
+    assignPositionsInStatement(statement, state);
+    return statement;
+}
+function resolveParameterPosition(placeholder, state) {
+    if (isSequentialPlaceholder(placeholder)) {
+        const position = state.nextSequential;
+        state.nextSequential += 1;
+        return position;
+    }
+    const numericMatch = placeholder.match(/^\?(\d+)$/);
+    if (numericMatch) {
+        const numeric = Number(numericMatch[1]) - 1;
+        if (Number.isInteger(numeric) && numeric >= 0) {
+            if (numeric + 1 > state.nextSequential) {
+                state.nextSequential = numeric + 1;
+            }
+            return numeric;
+        }
+    }
+    // Fall back to sequential ordering for unsupported placeholder formats.
+    const position = state.nextSequential;
+    state.nextSequential += 1;
+    return position;
+}
+function isSequentialPlaceholder(placeholder) {
+    if (placeholder === "" || placeholder === "?") {
+        return true;
+    }
+    if (placeholder.startsWith("?")) {
+        const rest = placeholder.slice(1);
+        return rest.length === 0 || /\D/.test(rest);
+    }
+    return true;
+}
+function countSequentialPlaceholders(sql) {
+    let count = 0;
+    let index = 0;
+    let inSingle = false;
+    let inDouble = false;
+    let inBracket = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    const advance = (step = 1) => {
+        index += step;
+    };
+    while (index < sql.length) {
+        const ch = sql[index];
+        const next = sql[index + 1];
+        if (inLineComment) {
+            if (ch === "\n") {
+                inLineComment = false;
+            }
+            advance();
+            continue;
+        }
+        if (inBlockComment) {
+            if (ch === "*" && next === "/") {
+                inBlockComment = false;
+                advance(2);
+                continue;
+            }
+            advance();
+            continue;
+        }
+        if (!inSingle && !inDouble && !inBracket) {
+            if (ch === "-" && next === "-") {
+                inLineComment = true;
+                advance(2);
+                continue;
+            }
+            if (ch === "/" && next === "*") {
+                inBlockComment = true;
+                advance(2);
+                continue;
+            }
+        }
+        if (!inDouble && !inBracket && ch === "'") {
+            if (inSingle && next === "'") {
+                advance(2);
+                continue;
+            }
+            inSingle = !inSingle;
+            advance();
+            continue;
+        }
+        if (!inSingle && !inBracket && ch === '"') {
+            if (inDouble && next === '"') {
+                advance(2);
+                continue;
+            }
+            inDouble = !inDouble;
+            advance();
+            continue;
+        }
+        if (!inSingle && !inDouble && ch === "[" && !inBracket) {
+            inBracket = true;
+            advance();
+            continue;
+        }
+        if (inBracket) {
+            if (ch === "]") {
+                inBracket = false;
+            }
+            advance();
+            continue;
+        }
+        if (!inSingle && !inDouble && !inBracket && ch === "?") {
+            let j = index + 1;
+            while (j < sql.length && /\d/.test(sql[j])) {
+                j += 1;
+            }
+            if (j === index + 1) {
+                count += 1;
+                advance();
+                continue;
+            }
+            index = j;
+            continue;
+        }
+        advance();
+    }
+    return count;
+}
+function assignPositionsInStatement(statement, state) {
+    switch (statement.node_kind) {
+        case "select_statement":
+            assignPositionsInSelect(statement, state);
+            break;
+        case "compound_select":
+            assignPositionsInCompound(statement, state);
+            break;
+        case "insert_statement":
+            assignPositionsInInsert(statement, state);
+            break;
+        case "update_statement":
+            assignPositionsInUpdate(statement, state);
+            break;
+        case "delete_statement":
+            assignPositionsInDelete(statement, state);
+            break;
+        default:
+            break;
+    }
+}
+function assignPositionsInSelect(select, state) {
+    if (select.with_clause) {
+        assignPositionsInWithClause(select.with_clause, state);
+    }
+    for (const item of select.projection) {
+        assignPositionsInSelectItem(item, state);
+    }
+    for (const clause of select.from_clauses) {
+        assignPositionsInFromClause(clause, state);
+    }
+    assignPositionsInExpressionOrFragment(select.where_clause, state);
+    for (const order of select.order_by) {
+        assignPositionsInExpression(order.expression, state);
+    }
+    assignPositionsInExpressionOrFragment(select.limit, state);
+    assignPositionsInExpressionOrFragment(select.offset, state);
+}
+function assignPositionsInCompound(compound, state) {
+    if (compound.with_clause) {
+        assignPositionsInWithClause(compound.with_clause, state);
+    }
+    assignPositionsInSelect(compound.first, state);
+    for (const branch of compound.compounds) {
+        assignPositionsInSelect(branch.select, state);
+    }
+    for (const item of compound.order_by) {
+        assignPositionsInExpression(item.expression, state);
+    }
+    assignPositionsInExpressionOrFragment(compound.limit, state);
+    assignPositionsInExpressionOrFragment(compound.offset, state);
+}
+function assignPositionsInWithClause(withClause, state) {
+    for (const cte of withClause.ctes) {
+        assignPositionsInStatement(cte.statement, state);
+    }
+}
+function assignPositionsInSelectItem(item, state) {
+    if (item.node_kind === "select_expression") {
+        assignPositionsInExpression(item.expression, state);
+    }
+}
+function assignPositionsInFromClause(clause, state) {
+    assignPositionsInRelation(clause.relation, state);
+    for (const join of clause.joins) {
+        assignPositionsInJoin(join, state);
+    }
+}
+function assignPositionsInJoin(join, state) {
+    assignPositionsInRelation(join.relation, state);
+    assignPositionsInExpressionOrFragment(join.on_expression, state);
+}
+function assignPositionsInRelation(relation, state) {
+    switch (relation.node_kind) {
+        case "subquery":
+            assignPositionsInStatement(relation.statement, state);
+            break;
+        case "raw_fragment":
+            state.nextSequential += countSequentialPlaceholders(relation.sql_text);
+            break;
+        default:
+            break;
+    }
+}
+function assignPositionsInInsert(statement, state) {
+    assignPositionsInInsertSource(statement.source, state);
+}
+function assignPositionsInInsertSource(source, state) {
+    if (source.node_kind === "insert_default_values") {
+        return;
+    }
+    for (const row of source.rows) {
+        for (const expression of row) {
+            assignPositionsInExpression(expression, state);
+        }
+    }
+}
+function assignPositionsInUpdate(statement, state) {
+    for (const clause of statement.assignments) {
+        assignPositionsInExpression(clause.value, state);
+    }
+    assignPositionsInExpressionOrFragment(statement.where_clause, state);
+}
+function assignPositionsInDelete(statement, state) {
+    assignPositionsInExpressionOrFragment(statement.where_clause, state);
+}
+function assignPositionsInExpressionOrFragment(expression, state) {
+    if (!expression) {
+        return;
+    }
+    if ("sql_text" in expression) {
+        state.nextSequential += countSequentialPlaceholders(expression.sql_text);
+        return;
+    }
+    assignPositionsInExpression(expression, state);
+}
+function assignPositionsInExpression(expression, state) {
+    switch (expression.node_kind) {
+        case "parameter":
+            assignPositionToParameter(expression, state);
+            break;
+        case "grouped_expression":
+            assignPositionsInExpression(expression.expression, state);
+            break;
+        case "binary_expression":
+            assignPositionsInExpression(expression.left, state);
+            assignPositionsInExpression(expression.right, state);
+            break;
+        case "unary_expression":
+            assignPositionsInExpression(expression.operand, state);
+            break;
+        case "in_list_expression":
+            assignPositionsInExpression(expression.operand, state);
+            for (const item of expression.items) {
+                assignPositionsInExpression(item, state);
+            }
+            break;
+        case "between_expression":
+            assignPositionsInExpression(expression.operand, state);
+            assignPositionsInExpression(expression.start, state);
+            assignPositionsInExpression(expression.end, state);
+            break;
+        case "function_call":
+            for (const argument of expression.arguments) {
+                if (argument.node_kind === "all_columns") {
+                    continue;
+                }
+                assignPositionsInExpression(argument, state);
+            }
+            break;
+        case "subquery_expression":
+            assignPositionsInStatement(expression.statement, state);
+            break;
+        case "raw_fragment":
+            state.nextSequential += countSequentialPlaceholders(expression.sql_text);
+            break;
+        default:
+            break;
+    }
+}
+function assignPositionToParameter(parameter, state) {
+    const position = resolveParameterPosition(parameter.placeholder ?? "?", state);
+    parameter.position =
+        position;
+}
+/**
+ * Parses SQL text into one or more segmented statements, falling back to raw
+ * fragments when the grammar cannot represent portions of the input.
+ *
+ * @example
+ * ```ts
+ * const [statement] = parse("SELECT 1");
+ * ```
+ */
+export function parse(sql) {
+    const program = parseWithGrammar(sql);
+    if (program.length > 0) {
+        return program;
+    }
+    const segmentedFallback = parseWithSegmentation(sql);
+    if (segmentedFallback.length > 0) {
+        return segmentedFallback;
+    }
+    return [createSegmentedStatement([createRawFragment(sql)])];
+}
+export { parseCst } from "./cst.js";
+function parseWithGrammar(sql) {
+    const root = parseCst(sql);
+    if (!root) {
+        return [];
+    }
+    const statement = toStatementNode(root);
+    return [createSegmentedStatement([statement])];
+}
+function parseWithSegmentation(sql) {
+    const segments = segmentSelectStatements(sql);
+    if (!segments) {
+        return [];
+    }
+    return [createSegmentedStatement(segments)];
+}
+function createSegmentedStatement(segments) {
+    const state = { nextSequential: 0 };
+    assignPositionsInSegments(segments, state);
+    return {
+        node_kind: "segmented_statement",
+        segments,
+    };
+}
+export function normalizeSegmentedStatement(statement) {
+    const segments = [...statement.segments];
+    const state = { nextSequential: 0 };
+    assignPositionsInSegments(segments, state);
+    return {
+        ...statement,
+        segments,
+    };
+}
+export function normalizeSegmentedStatements(statements) {
+    return statements.map((statement) => normalizeSegmentedStatement(statement));
+}
+function assignPositionsInSegments(segments, state) {
+    for (const segment of segments) {
+        if (segment.node_kind === "raw_fragment") {
+            state.nextSequential += countSequentialPlaceholders(segment.sql_text);
+            continue;
+        }
+        assignPositionsInStatement(segment, state);
+    }
+}
+/**
+ * Extracts SELECT statements that appear within parenthesised regions while
+ * preserving surrounding fragments as raw nodes.
+ */
+function segmentSelectStatements(sql) {
+    const segments = [];
+    let cursor = 0;
+    let depth = 0;
+    let inSingleQuotedString = false;
+    for (let index = 0; index < sql.length; index += 1) {
+        const ch = sql[index];
+        if (inSingleQuotedString) {
+            if (ch === "'") {
+                const next = sql[index + 1];
+                if (next === "'") {
+                    index += 1;
+                    continue;
+                }
+                inSingleQuotedString = false;
+            }
+            continue;
+        }
+        if (ch === "'") {
+            inSingleQuotedString = true;
+            continue;
+        }
+        if (ch === "(") {
+            depth += 1;
+            continue;
+        }
+        if (ch === ")") {
+            if (depth > 0) {
+                depth -= 1;
+            }
+            continue;
+        }
+        const isSelectKeyword = isKeywordAt(sql, index, "select");
+        if (!isSelectKeyword || !isIdentifierBoundary(sql, index - 1)) {
+            continue;
+        }
+        const interstitial = sql.slice(cursor, index).trim().toLowerCase();
+        const isAfterUnion = /(?:^|\s)union(?:\s+all)?$/.test(interstitial);
+        if (!(depth > 0 || segments.length === 0 || isAfterUnion)) {
+            continue;
+        }
+        {
+            const endIndex = findSelectBoundary(sql, index, depth);
+            if (endIndex === null || endIndex <= index) {
+                return null;
+            }
+            if (index > cursor) {
+                const fragmentSql = sql.slice(cursor, index);
+                if (fragmentSql.length > 0) {
+                    segments.push(createRawFragment(fragmentSql));
+                }
+            }
+            const selectSql = sql.slice(index, endIndex);
+            const parsed = parseSimpleStatement(selectSql);
+            if (!parsed || parsed.node_kind !== "select_statement") {
+                return null;
+            }
+            segments.push(parsed);
+            cursor = endIndex;
+            index = endIndex - 1;
+        }
+    }
+    if (segments.length === 0) {
+        return null;
+    }
+    if (cursor < sql.length) {
+        const trailing = sql.slice(cursor);
+        if (trailing.length > 0) {
+            segments.push(createRawFragment(trailing));
+        }
+    }
+    return segments;
+}
+function parseSimpleStatement(sql) {
+    const root = parseCst(sql);
+    if (!root) {
+        return null;
+    }
+    return toStatementNode(root);
+}
+/**
+ * Locates the end of a SELECT segment, stopping at UNION keywords or the
+ * closing parenthesis that owns the statement.
+ *
+ * @example
+ * ```ts
+ * const end = findSelectBoundary("SELECT 1 UNION SELECT 2", 0, 0);
+ * ```
+ */
+function findSelectBoundary(sql, startIndex, startDepth) {
+    let depth = startDepth;
+    let inSingleQuotedString = false;
+    for (let index = startIndex; index < sql.length; index += 1) {
+        const ch = sql[index];
+        if (inSingleQuotedString) {
+            if (ch === "'") {
+                const next = sql[index + 1];
+                if (next === "'") {
+                    index += 1;
+                    continue;
+                }
+                inSingleQuotedString = false;
+            }
+            continue;
+        }
+        if (ch === "'") {
+            inSingleQuotedString = true;
+            continue;
+        }
+        if (ch === "(") {
+            depth += 1;
+            continue;
+        }
+        if (ch === ")") {
+            depth -= 1;
+            if (depth < startDepth) {
+                return index;
+            }
+            continue;
+        }
+        if (depth === startDepth && isKeywordAt(sql, index, "union")) {
+            return index;
+        }
+    }
+    return sql.length;
+}
+/**
+ * Checks whether the given keyword appears at the specified index.
+ *
+ * @example
+ * ```ts
+ * isKeywordAt("UNION", 0, "union") === true;
+ * ```
+ */
+function isKeywordAt(sql, index, keyword) {
+    if (index < 0) {
+        return false;
+    }
+    const remaining = sql.length - index;
+    if (remaining < keyword.length) {
+        return false;
+    }
+    const candidate = sql.slice(index, index + keyword.length).toLowerCase();
+    return candidate === keyword;
+}
+/**
+ * Determines whether the character at a position can precede an identifier.
+ *
+ * @example
+ * ```ts
+ * isIdentifierBoundary(" SELECT", 0) === true;
+ * ```
+ */
+function isIdentifierBoundary(sql, index) {
+    if (index < 0) {
+        return true;
+    }
+    const ch = sql[index];
+    return !/[a-zA-Z0-9_]/.test(ch);
+}
+/**
+ * Wraps SQL text in a raw fragment node.
+ *
+ * @example
+ * ```ts
+ * const fragment = createRawFragment("UNSUPPORTED()");
+ * ```
+ */
+function createRawFragment(sql) {
+    return {
+        node_kind: "raw_fragment",
+        sql_text: sql,
+    };
+}
+//# sourceMappingURL=parse.js.map