@lix-js/sdk 0.5.1 → 0.6.0-preview.1

package/src/engine/preprocessor/sql-parser/parse.test.ts

@@ -1,1646 +0,0 @@
-import { describe, expect, test } from "vitest";
-import { parse } from "./parse.js";
-import {
-	identifier,
-	type RawFragmentNode,
-	type CompoundSelectNode,
-	type SelectStatementNode,
-} from "./nodes.js";
-
-const id = identifier;
-const lit = (value: string | number | boolean | null) => ({
-	node_kind: "literal" as const,
-	value,
-});
-
-const parseStatements = (sql: string) => parse(sql);
-
-function parseSingleSegment(sql: string) {
-	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: string) {
-	const segment = parseSingleSegment(sql);
-	if (segment.node_kind !== "select_statement") {
-		throw new Error("expected select statement");
-	}
-	return segment;
-}
-
-function parseUpdateStatement(sql: string) {
-	const segment = parseSingleSegment(sql);
-	if (segment.node_kind !== "update_statement") {
-		throw new Error("expected update statement");
-	}
-	return segment;
-}
-
-function parseDeleteStatement(sql: string) {
-	const segment = parseSingleSegment(sql);
-	if (segment.node_kind !== "delete_statement") {
-		throw new Error("expected delete statement");
-	}
-	return segment;
-}
-
-function parseInsertStatement(sql: string) {
-	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 as CompoundSelectNode;
-		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 as CompoundSelectNode;
-		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 as CompoundSelectNode;
-		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: SelectStatementNode[] = [
-			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"),
-							},
-						],
-					},
-				},
-			},
-		],
-	});
-});