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

package/src/engine/preprocessor/steps/expand-sql-views.ts

@@ -1,1167 +0,0 @@
-import type {
-	SegmentedStatementNode,
-	CompoundSelectNode,
-	SelectStatementNode,
-	SelectItemNode,
-	StatementNode,
-	StatementSegmentNode,
-	TableReferenceNode,
-	SubqueryNode,
-	WithClauseNode,
-	CommonTableExpressionNode,
-	IdentifierNode,
-	ExpressionNode,
-	RawFragmentNode,
-} from "../sql-parser/nodes.js";
-import { identifier } from "../sql-parser/nodes.js";
-import {
-	getColumnName,
-	getIdentifierValue,
-	normalizeIdentifierValue,
-} from "../sql-parser/ast-helpers.js";
-import { visitStatement, type AstVisitor } from "../sql-parser/visitor.js";
-import { parse, normalizeSegmentedStatement } from "../sql-parser/parse.js";
-import type { PreprocessorStep, PreprocessorTraceEntry } from "../types.js";
-import {
-	collectTableColumnUsage,
-	resolveRelationAlias,
-	type ColumnUsageSummary,
-	type TableColumnUsageMap,
-} from "../sql-parser/column-usage.js";
-
-type ViewDefinition = {
-	readonly name: string;
-	readonly sql: string;
-	readonly normalized: string;
-};
-
-type ExpandState = {
-	readonly stack: string[];
-	readonly expandedViews: string[];
-};
-
-/**
- * Inlines SQLite views referenced in statements by expanding their SELECT
- * bodies into subqueries. Expansion is limited to selectable views and relies
- * on the v3 parser to convert the stored SQL into the AST representation.
- *
- * @example
- * ```ts
- * const rewritten = expandSqlViews({ node, getSqlViews });
- * ```
- */
-export const expandSqlViews: PreprocessorStep = (context) => {
-	const sqlViews = context.getSqlViews?.();
-	if (!sqlViews || sqlViews.size === 0) {
-		return context.statements;
-	}
-
-	const viewMap = buildViewMap(sqlViews);
-	if (viewMap.size === 0) {
-		return context.statements;
-	}
-
-	let anyChanges = false;
-	const rewrittenStatements = context.statements.map((statement) => {
-		const result = expandSegmentedStatement(statement, viewMap, context.trace);
-		if (result !== statement) {
-			anyChanges = true;
-		}
-		return result;
-	});
-
-	return anyChanges ? rewrittenStatements : context.statements;
-};
-
-function expandSegmentedStatement(
-	statement: SegmentedStatementNode,
-	views: Map<string, ViewDefinition>,
-	trace: PreprocessorTraceEntry[] | undefined
-): SegmentedStatementNode {
-	let expandedViewNames: string[] = [];
-	const updatedSegments: StatementSegmentNode[] = statement.segments.map(
-		(segment) => {
-			if (segment.node_kind === "select_statement") {
-				const usage = collectTableColumnUsage(segment);
-				const state: ExpandState = {
-					stack: [],
-					expandedViews: [],
-				};
-
-				const expanded = expandStatementNode(segment, views, state, usage);
-				if (state.expandedViews.length === 0) {
-					return segment;
-				}
-
-				expandedViewNames = expandedViewNames.concat(state.expandedViews);
-				return expanded;
-			}
-
-			if (segment.node_kind === "compound_select") {
-				const expanded = expandCompoundSelect(segment, views);
-				if (expanded.viewNames.length === 0) {
-					return segment;
-				}
-				expandedViewNames = expandedViewNames.concat(expanded.viewNames);
-				return expanded.node;
-			}
-
-			return segment;
-		}
-	);
-
-	if (expandedViewNames.length === 0) {
-		return statement;
-	}
-
-	if (trace) {
-		pushTrace(trace, expandedViewNames);
-	}
-
-	return normalizeSegmentedStatement({
-		...statement,
-		segments: updatedSegments,
-	});
-}
-
-function expandCompoundSelect(
-	statement: CompoundSelectNode,
-	views: Map<string, ViewDefinition>
-): { node: CompoundSelectNode; viewNames: string[] } {
-	let viewNames: string[] = [];
-
-	const firstState: ExpandState = { stack: [], expandedViews: [] };
-	const firstUsage = collectTableColumnUsage(statement.first);
-	const expandedFirst = expandStatementNode(
-		statement.first,
-		views,
-		firstState,
-		firstUsage
-	) as SelectStatementNode;
-	viewNames = viewNames.concat(firstState.expandedViews);
-
-	const expandedBranches = statement.compounds.map((branch) => {
-		const branchState: ExpandState = { stack: [], expandedViews: [] };
-		const branchUsage = collectTableColumnUsage(branch.select);
-		const expandedSelect = expandStatementNode(
-			branch.select,
-			views,
-			branchState,
-			branchUsage
-		) as SelectStatementNode;
-		if (branchState.expandedViews.length === 0) {
-			return branch;
-		}
-		viewNames = viewNames.concat(branchState.expandedViews);
-		return {
-			...branch,
-			select: expandedSelect,
-		};
-	});
-
-	if (viewNames.length === 0) {
-		return { node: statement, viewNames };
-	}
-
-	return {
-		node: {
-			...statement,
-			first: expandedFirst,
-			compounds: expandedBranches,
-		},
-		viewNames,
-	};
-}
-
-function buildViewMap(
-	source: Map<string, string>
-): Map<string, ViewDefinition> {
-	const map = new Map<string, ViewDefinition>();
-	for (const [name, sql] of source) {
-		const normalized = normalizeIdentifierValue(name);
-		map.set(normalized, { name, sql, normalized });
-	}
-	return map;
-}
-
-function expandStatementNode(
-	statement: StatementNode,
-	views: Map<string, ViewDefinition>,
-	state: ExpandState,
-	usage: TableColumnUsageMap
-): StatementNode {
-	return visitStatement(
-		statement,
-		createVisitor(views, state, usage, statement)
-	);
-}
-
-function createVisitor(
-	views: Map<string, ViewDefinition>,
-	state: ExpandState,
-	rootUsage: TableColumnUsageMap,
-	rootStatement: StatementNode
-): AstVisitor {
-	const usageCache = new WeakMap<SelectStatementNode, TableColumnUsageMap>();
-	if (rootStatement.node_kind === "select_statement") {
-		usageCache.set(rootStatement, rootUsage);
-	}
-	const selectStack: SelectStatementNode[] = [];
-	return {
-		select_statement(node) {
-			selectStack.push(node);
-		},
-		select_statement_exit() {
-			selectStack.pop();
-		},
-		table_reference(node) {
-			const match = matchView(node, views);
-			if (!match) {
-				return;
-			}
-
-			const currentSelect =
-				selectStack[selectStack.length - 1] ??
-				(rootStatement.node_kind === "select_statement" ? rootStatement : null);
-			let currentUsage: TableColumnUsageMap;
-			if (currentSelect) {
-				currentUsage =
-					usageCache.get(currentSelect) ??
-					(currentSelect === rootStatement &&
-					rootStatement.node_kind === "select_statement"
-						? rootUsage
-						: undefined) ??
-					collectTableColumnUsage(currentSelect);
-				usageCache.set(currentSelect, currentUsage);
-			} else {
-				currentUsage = rootUsage;
-			}
-			if (!currentUsage) {
-				currentUsage = new Map<string, ColumnUsageSummary>();
-			}
-			const aliasKey =
-				resolveRelationAlias(node) ?? normalizeIdentifierValue(match.name);
-			const requirements = currentUsage.get(aliasKey);
-
-			const expanded = expandView(match, views, state, requirements);
-			if (!expanded) {
-				return;
-			}
-
-			state.expandedViews.push(match.name);
-			const alias = node.alias ?? identifier(match.name);
-			const subquery: SubqueryNode = {
-				node_kind: "subquery",
-				statement: expanded,
-				alias,
-			};
-			return subquery;
-		},
-	};
-}
-
-function matchView(
-	node: TableReferenceNode,
-	views: Map<string, ViewDefinition>
-): ViewDefinition | null {
-	const parts = node.name.parts;
-	if (parts.length === 0) {
-		return null;
-	}
-	const last = parts[parts.length - 1];
-	if (!last) {
-		return null;
-	}
-	const normalized = normalizeIdentifierValue(last.value);
-	return views.get(normalized) ?? null;
-}
-
-function expandView(
-	view: ViewDefinition,
-	views: Map<string, ViewDefinition>,
-	state: ExpandState,
-	requirements: ColumnUsageSummary | undefined
-): SelectStatementNode | CompoundSelectNode | null {
-	if (state.stack.includes(view.normalized)) {
-		return null;
-	}
-
-	state.stack.push(view.normalized);
-	try {
-		const parsedStatements = parse(view.sql);
-		const directStatement = getSingleSelectableStatement(parsedStatements);
-		if (directStatement) {
-			const pruned = pruneExpandedStatement(directStatement, requirements);
-			return expandSelectableStatement(pruned, views, state);
-		}
-
-		const body = extractViewBody(view.sql);
-		const sanitized = stripSqlComments(body);
-		const withParsed = splitWithClause(sanitized);
-		if (!withParsed) {
-			return null;
-		}
-
-		const ctes: CommonTableExpressionNode[] = [];
-		for (const cte of withParsed.ctes) {
-			const parsedCte = parseSingleSelectableStatement(cte.statementSql);
-			if (!parsedCte) {
-				return null;
-			}
-			const expandedCte = expandSelectableStatement(parsedCte, views, state);
-			if (!expandedCte || !isSelectableStatement(expandedCte)) {
-				return null;
-			}
-			ctes.push({
-				node_kind: "common_table_expression",
-				name: createIdentifierNode(cte.name),
-				columns: cte.columns.map(createIdentifierNode),
-				statement: expandedCte,
-			});
-		}
-
-		const mainStatement = parseSingleSelectableStatement(withParsed.remainder);
-		if (!mainStatement) {
-			return null;
-		}
-		const expandedMain = expandSelectableStatement(mainStatement, views, state);
-		if (!expandedMain || !isSelectableStatement(expandedMain)) {
-			return null;
-		}
-
-		const statementWithWithClause =
-			ctes.length === 0 && !withParsed.recursive
-				? expandedMain
-				: attachWithClause(expandedMain, {
-						node_kind: "with_clause",
-						recursive: withParsed.recursive,
-						ctes,
-					});
-		if (!statementWithWithClause) {
-			return null;
-		}
-		const pruned = pruneExpandedStatement(
-			statementWithWithClause,
-			requirements
-		);
-		return expandSelectableStatement(pruned, views, state);
-	} finally {
-		state.stack.pop();
-	}
-}
-
-function expandSelectableStatement(
-	statement: SelectStatementNode | CompoundSelectNode,
-	views: Map<string, ViewDefinition>,
-	state: ExpandState
-): SelectStatementNode | CompoundSelectNode | null {
-	if (statement.node_kind === "select_statement") {
-		const usage = collectTableColumnUsage(statement);
-		const expanded = expandStatementNode(statement, views, state, usage);
-		return isSelectableStatement(expanded) ? expanded : null;
-	}
-	const expandedCompound = expandCompoundSelect(statement, views);
-	return expandedCompound.node;
-}
-
-function pushTrace(
-	trace: PreprocessorTraceEntry[] | undefined,
-	views: readonly string[]
-): void {
-	if (!trace) {
-		return;
-	}
-	trace.push({
-		step: "expand_sql_views",
-		payload: {
-			count: views.length,
-			views: views.slice(),
-		},
-	});
-}
-
-function getSingleSelectableStatement(
-	statements: readonly SegmentedStatementNode[]
-): SelectStatementNode | CompoundSelectNode | null {
-	if (statements.length !== 1) {
-		return null;
-	}
-	const [segmented] = statements;
-	if (!segmented || segmented.node_kind !== "segmented_statement") {
-		return null;
-	}
-
-	const statementSegments = segmented.segments.filter(
-		(segment): segment is StatementNode => segment.node_kind !== "raw_fragment"
-	);
-	if (statementSegments.length !== 1) {
-		return null;
-	}
-
-	const [single] = statementSegments;
-	if (!single || !isSelectableStatement(single)) {
-		return null;
-	}
-	return single;
-}
-
-function isSelectableStatement(
-	statement: StatementNode
-): statement is SelectStatementNode | CompoundSelectNode {
-	return (
-		statement.node_kind === "select_statement" ||
-		statement.node_kind === "compound_select"
-	);
-}
-
-function parseSingleSelectableStatement(
-	sql: string
-): SelectStatementNode | CompoundSelectNode | null {
-	const trimmed = stripSqlComments(sql).trim();
-	if (trimmed === "") {
-		return null;
-	}
-	const statements = parse(trimmed);
-	return getSingleSelectableStatement(statements);
-}
-
-function attachWithClause(
-	statement: SelectStatementNode | CompoundSelectNode,
-	withClause: WithClauseNode
-): SelectStatementNode | CompoundSelectNode {
-	if (statement.node_kind === "select_statement") {
-		const existing = statement.with_clause;
-		if (!existing) {
-			return {
-				...statement,
-				with_clause: withClause,
-			};
-		}
-		return {
-			...statement,
-			with_clause: mergeWithClauses(withClause, existing),
-		};
-	}
-
-	const existing = statement.with_clause;
-	if (!existing) {
-		return {
-			...statement,
-			with_clause: withClause,
-		};
-	}
-	return {
-		...statement,
-		with_clause: mergeWithClauses(withClause, existing),
-	};
-}
-
-function pruneExpandedStatement(
-	statement: SelectStatementNode | CompoundSelectNode,
-	requirements: ColumnUsageSummary | undefined
-): SelectStatementNode | CompoundSelectNode {
-	if (!requirements || requirements.requiresAllColumns) {
-		return statement;
-	}
-	if (requirements.columns.size === 0) {
-		return statement;
-	}
-	if (statement.node_kind === "select_statement") {
-		return pruneSelectStatement(statement, requirements);
-	}
-	return statement;
-}
-
-function pruneSelectStatement(
-	statement: SelectStatementNode,
-	requirements: ColumnUsageSummary
-): SelectStatementNode {
-	let current = statement;
-	const prunedProjection = pruneSelectProjection(current, requirements);
-	let changed = prunedProjection !== current;
-	current = prunedProjection;
-	const prunedJoins = pruneUnusedLeftJoins(current);
-	if (prunedJoins !== current) {
-		changed = true;
-		current = prunedJoins;
-	}
-	const prunedWithClause = pruneUnusedCommonTableExpressions(current);
-	if (prunedWithClause !== current) {
-		changed = true;
-		current = prunedWithClause;
-	}
-	return changed ? current : statement;
-}
-
-function pruneSelectProjection(
-	statement: SelectStatementNode,
-	requirements: ColumnUsageSummary
-): SelectStatementNode {
-	if (statement.distinct) {
-		return statement;
-	}
-	const neededColumns = requirements.columns;
-	let changed = false;
-	const filtered = statement.projection.filter((item) => {
-		if (item.node_kind !== "select_expression") {
-			return true;
-		}
-		const column = extractProjectedColumnName(item);
-		if (!column) {
-			return true;
-		}
-		if (!neededColumns.has(column)) {
-			changed = true;
-			return false;
-		}
-		return neededColumns.has(column);
-	});
-	if (!changed || filtered.length === 0) {
-		return statement;
-	}
-	return {
-		...statement,
-		projection: filtered,
-	};
-}
-
-function pruneUnusedLeftJoins(
-	select: SelectStatementNode
-): SelectStatementNode {
-	if (!canPruneUnusedLeftJoins(select)) {
-		return select;
-	}
-	if (select.from_clauses.length === 0) {
-		return select;
-	}
-	let changed = false;
-	const rewrittenFrom = select.from_clauses.map((clause, clauseIndex) => {
-		if (clause.joins.length === 0) {
-			return clause;
-		}
-		const filteredJoins = clause.joins.filter((join, joinIndex) => {
-			if (join.join_type !== "left") {
-				return true;
-			}
-			if (join.relation.node_kind === "raw_fragment") {
-				return true;
-			}
-			const alias = resolveRelationAlias(join.relation);
-			if (!alias) {
-				return true;
-			}
-			if (aliasReferencedOutsideJoin(select, clauseIndex, joinIndex, alias)) {
-				return true;
-			}
-			changed = true;
-			return false;
-		});
-		if (filteredJoins.length === clause.joins.length) {
-			return clause;
-		}
-		return {
-			...clause,
-			joins: filteredJoins,
-		};
-	});
-	if (!changed) {
-		return select;
-	}
-	return {
-		...select,
-		from_clauses: rewrittenFrom,
-	};
-}
-
-function canPruneUnusedLeftJoins(select: SelectStatementNode): boolean {
-	if (select.distinct) {
-		return false;
-	}
-	if (select.group_by.length > 0) {
-		return false;
-	}
-	return isDirectColumnProjection(select);
-}
-
-function isDirectColumnProjection(select: SelectStatementNode): boolean {
-	if (select.projection.length === 0) {
-		return false;
-	}
-	return select.projection.every(
-		(item) =>
-			item.node_kind === "select_expression" &&
-			isAllowedProjectionExpression(item.expression)
-	);
-}
-
-function isAllowedProjectionExpression(
-	expression: ExpressionNode | RawFragmentNode
-): boolean {
-	if ("sql_text" in expression) {
-		return false;
-	}
-	switch (expression.node_kind) {
-		case "column_reference":
-			return true;
-		case "function_call": {
-			const functionName = normalizeIdentifierValue(expression.name.value);
-			return functionName === "json_extract";
-		}
-		default:
-			return false;
-	}
-}
-
-function aliasReferencedOutsideJoin(
-	select: SelectStatementNode,
-	clauseIndex: number,
-	joinIndex: number,
-	alias: string
-): boolean {
-	const strippedSelect: SelectStatementNode = {
-		...select,
-		from_clauses: select.from_clauses.map((clause, currentClauseIndex) => {
-			if (currentClauseIndex !== clauseIndex) {
-				return clause;
-			}
-			return {
-				...clause,
-				joins: clause.joins.map((join, currentJoinIndex) => {
-					if (currentJoinIndex !== joinIndex) {
-						return join;
-					}
-					if (!join.on_expression) {
-						return join;
-					}
-					return {
-						...join,
-						on_expression: null,
-					};
-				}),
-			};
-		}),
-	};
-	const usage = collectTableColumnUsage(strippedSelect);
-	const summary = usage.get(alias);
-	return !!summary && (summary.requiresAllColumns || summary.columns.size > 0);
-}
-
-function pruneUnusedCommonTableExpressions(
-	select: SelectStatementNode
-): SelectStatementNode {
-	const withClause = select.with_clause;
-	if (!withClause || withClause.ctes.length === 0) {
-		return select;
-	}
-	const cteNames = withClause.ctes
-		.map((cte) => normalizeIdentifierValue(cte.name.value))
-		.filter((name): name is string => Boolean(name));
-	if (cteNames.length === 0) {
-		return select;
-	}
-	const targetNames = new Set(cteNames);
-	const dependencyMap = new Map<string, Set<string>>();
-	const rootReferences = collectReferencedCtes(select, targetNames);
-	if (rootReferences.hasRawReferences) {
-		return select;
-	}
-	dependencyMap.set("__root__", rootReferences.references);
-	for (const cte of withClause.ctes) {
-		const normalized = normalizeIdentifierValue(cte.name.value);
-		if (!normalized) {
-			continue;
-		}
-		const references = collectReferencedCtes(cte.statement, targetNames);
-		if (references.hasRawReferences) {
-			return select;
-		}
-		dependencyMap.set(normalized, references.references);
-	}
-
-	const needed = new Set<string>();
-	const queue: string[] = Array.from(dependencyMap.get("__root__") ?? []);
-	while (queue.length > 0) {
-		const current = queue.pop();
-		if (!current || needed.has(current)) {
-			continue;
-		}
-		needed.add(current);
-		const deps = dependencyMap.get(current);
-		if (!deps) {
-			continue;
-		}
-		for (const dep of deps) {
-			queue.push(dep);
-		}
-	}
-
-	if (needed.size === targetNames.size) {
-		return select;
-	}
-	if (needed.size === 0) {
-		return {
-			...select,
-			with_clause: null,
-		};
-	}
-	const filteredCtes = withClause.ctes.filter((cte) => {
-		const normalized = normalizeIdentifierValue(cte.name.value);
-		if (!normalized) {
-			return true;
-		}
-		return needed.has(normalized);
-	});
-	if (filteredCtes.length === withClause.ctes.length) {
-		return select;
-	}
-	return {
-		...select,
-		with_clause:
-			filteredCtes.length === 0
-				? null
-				: {
-						...withClause,
-						ctes: filteredCtes,
-					},
-	};
-}
-
-function collectReferencedCtes(
-	statement: SelectStatementNode | CompoundSelectNode,
-	targetNames: ReadonlySet<string>
-): { references: Set<string>; hasRawReferences: boolean } {
-	const references = new Set<string>();
-	let hasRawReferences = false;
-	const visitor: AstVisitor = {
-		table_reference(node) {
-			const normalized = normalizeObjectName(node.name);
-			if (normalized && targetNames.has(normalized)) {
-				references.add(normalized);
-			}
-			return node;
-		},
-		raw_fragment() {
-			hasRawReferences = true;
-		},
-	};
-	visitStatement(statement, visitor);
-	return { references, hasRawReferences };
-}
-
-function normalizeObjectName(
-	object: TableReferenceNode["name"]
-): string | null {
-	const last = object.parts[object.parts.length - 1];
-	if (!last) {
-		return null;
-	}
-	return normalizeIdentifierValue(last.value);
-}
-
-function extractProjectedColumnName(
-	item: Extract<SelectItemNode, { node_kind: "select_expression" }>
-): string | null {
-	const aliasValue = getIdentifierValue(item.alias);
-	if (aliasValue) {
-		return aliasValue;
-	}
-	const expression = item.expression;
-	if ("sql_text" in expression) {
-		return null;
-	}
-	if (expression.node_kind !== "column_reference") {
-		return null;
-	}
-	return getColumnName(expression);
-}
-
-function mergeWithClauses(
-	primary: WithClauseNode,
-	secondary: WithClauseNode
-): WithClauseNode {
-	return {
-		node_kind: "with_clause",
-		recursive: primary.recursive || secondary.recursive,
-		ctes: [...primary.ctes, ...secondary.ctes],
-	};
-}
-
-type ParsedIdentifier = {
-	readonly value: string;
-	readonly quoted: boolean;
-};
-
-type IdentifierParseResult = ParsedIdentifier & {
-	readonly end: number;
-};
-
-type ParsedCte = {
-	readonly name: ParsedIdentifier;
-	readonly columns: readonly ParsedIdentifier[];
-	readonly statementSql: string;
-};
-
-type ParsedWithClause = {
-	readonly recursive: boolean;
-	readonly ctes: readonly ParsedCte[];
-	readonly remainder: string;
-};
-
-function createIdentifierNode(parsed: ParsedIdentifier): IdentifierNode {
-	return identifier(parsed.value, parsed.quoted);
-}
-
-function extractViewBody(sql: string): string {
-	const match = sql.match(
-		/^\s*CREATE\s+VIEW\s+(?:IF\s+NOT\s+EXISTS\s+)?["\w\.]+\s+AS\s+/i
-	);
-	if (!match) {
-		return sql;
-	}
-	return sql.slice(match[0]?.length ?? 0);
-}
-
-function stripSqlComments(sql: string): string {
-	let result = "";
-	let index = 0;
-	while (index < sql.length) {
-		const char = sql[index]!;
-		const next = sql[index + 1];
-
-		if (char === "-" && next === "-") {
-			index = skipLineComment(sql, index + 2);
-			continue;
-		}
-
-		if (char === "/" && next === "*") {
-			index = skipBlockComment(sql, index + 2);
-			continue;
-		}
-
-		if (char === "'") {
-			const end = skipSingleQuotedString(sql, index);
-			result += sql.slice(index, end);
-			index = end;
-			continue;
-		}
-
-		if (char === '"') {
-			const end = skipDoubleQuotedIdentifier(sql, index);
-			result += sql.slice(index, end);
-			index = end;
-			continue;
-		}
-
-		result += char;
-		index += 1;
-	}
-	return result;
-}
-
-function splitWithClause(sql: string): ParsedWithClause | null {
-	let index = skipWhitespaceAndComments(sql, 0);
-	if (!startsWithKeyword(sql, index, "WITH")) {
-		return null;
-	}
-	index += 4;
-	index = skipWhitespaceAndComments(sql, index);
-
-	let recursive = false;
-	if (startsWithKeyword(sql, index, "RECURSIVE")) {
-		recursive = true;
-		index += 9;
-		index = skipWhitespaceAndComments(sql, index);
-	}
-
-	const ctes: ParsedCte[] = [];
-	while (index < sql.length) {
-		index = skipWhitespaceAndComments(sql, index);
-		const identifierResult = readIdentifier(sql, index);
-		if (!identifierResult) {
-			return null;
-		}
-		index = identifierResult.end;
-
-		index = skipWhitespaceAndComments(sql, index);
-		let columns: ParsedIdentifier[] = [];
-		if (sql[index] === "(") {
-			const { content, end } = readParenthesizedContent(sql, index);
-			columns = parseColumnList(content);
-			index = end;
-		}
-
-		index = skipWhitespaceAndComments(sql, index);
-		if (!startsWithKeyword(sql, index, "AS")) {
-			return null;
-		}
-		index += 2;
-		index = skipWhitespaceAndComments(sql, index);
-		if (sql[index] !== "(") {
-			return null;
-		}
-
-		const { content, end } = readParenthesizedContent(sql, index);
-		ctes.push({
-			name: {
-				value: identifierResult.value,
-				quoted: identifierResult.quoted,
-			},
-			columns,
-			statementSql: content.trim(),
-		});
-		index = end;
-		index = skipWhitespaceAndComments(sql, index);
-
-		if (sql[index] === ",") {
-			index += 1;
-			continue;
-		}
-
-		break;
-	}
-
-	const remainder = sql.slice(index).trimStart();
-	return {
-		recursive,
-		ctes,
-		remainder,
-	};
-}
-
-function skipWhitespaceAndComments(sql: string, start: number): number {
-	let index = start;
-	while (index < sql.length) {
-		const char = sql[index]!;
-		const next = sql[index + 1];
-
-		if (isWhitespaceChar(char)) {
-			index += 1;
-			continue;
-		}
-
-		if (char === "-" && next === "-") {
-			index = skipLineComment(sql, index + 2);
-			continue;
-		}
-
-		if (char === "/" && next === "*") {
-			index = skipBlockComment(sql, index + 2);
-			continue;
-		}
-
-		break;
-	}
-	return index;
-}
-
-function skipLineComment(sql: string, start: number): number {
-	let index = start;
-	while (index < sql.length) {
-		const char = sql[index]!;
-		if (char === "\n" || char === "\r") {
-			return index + 1;
-		}
-		index += 1;
-	}
-	return index;
-}
-
-function skipBlockComment(sql: string, start: number): number {
-	let index = start;
-	while (index < sql.length - 1) {
-		if (sql[index] === "*" && sql[index + 1] === "/") {
-			return index + 2;
-		}
-		index += 1;
-	}
-	return sql.length;
-}
-
-function skipSingleQuotedString(sql: string, start: number): number {
-	let index = start + 1;
-	while (index < sql.length) {
-		const char = sql[index]!;
-		if (char === "'") {
-			if (sql[index + 1] === "'") {
-				index += 2;
-				continue;
-			}
-			return index + 1;
-		}
-		index += 1;
-	}
-	return sql.length;
-}
-
-function skipDoubleQuotedIdentifier(sql: string, start: number): number {
-	let index = start + 1;
-	while (index < sql.length) {
-		const char = sql[index]!;
-		if (char === '"') {
-			if (sql[index + 1] === '"') {
-				index += 2;
-				continue;
-			}
-			return index + 1;
-		}
-		index += 1;
-	}
-	return sql.length;
-}
-
-function readParenthesizedContent(
-	sql: string,
-	start: number
-): { content: string; end: number } {
-	if (sql[start] !== "(") {
-		throw new Error("readParenthesizedContent expects '(' at start");
-	}
-
-	let index = start + 1;
-	let depth = 1;
-	const begin = index;
-
-	while (index < sql.length && depth > 0) {
-		const char = sql[index]!;
-		const next = sql[index + 1];
-
-		if (char === "'") {
-			index = skipSingleQuotedString(sql, index);
-			continue;
-		}
-
-		if (char === '"') {
-			index = skipDoubleQuotedIdentifier(sql, index);
-			continue;
-		}
-
-		if (char === "-" && next === "-") {
-			index = skipLineComment(sql, index + 2);
-			continue;
-		}
-
-		if (char === "/" && next === "*") {
-			index = skipBlockComment(sql, index + 2);
-			continue;
-		}
-
-		if (char === "(") {
-			depth += 1;
-			index += 1;
-			continue;
-		}
-
-		if (char === ")") {
-			depth -= 1;
-			index += 1;
-			continue;
-		}
-
-		index += 1;
-	}
-
-	if (depth !== 0) {
-		throw new Error("unterminated parenthesised content in view SQL");
-	}
-
-	const content = sql.slice(begin, index - 1);
-	return { content, end: index };
-}
-
-function readIdentifier(
-	sql: string,
-	start: number
-): IdentifierParseResult | null {
-	if (start >= sql.length) {
-		return null;
-	}
-
-	const first = sql[start]!;
-	if (first === '"') {
-		const end = skipDoubleQuotedIdentifier(sql, start);
-		const value = sql.slice(start + 1, end - 1).replace(/""/g, '"');
-		return {
-			value,
-			quoted: true,
-			end,
-		};
-	}
-
-	if (!isIdentifierStart(first)) {
-		return null;
-	}
-
-	let index = start + 1;
-	while (index < sql.length && isIdentifierPart(sql[index]!)) {
-		index += 1;
-	}
-
-	return {
-		value: sql.slice(start, index),
-		quoted: false,
-		end: index,
-	};
-}
-
-function parseColumnList(content: string): ParsedIdentifier[] {
-	const columns: ParsedIdentifier[] = [];
-	let index = 0;
-
-	while (index < content.length) {
-		index = skipWhitespace(content, index);
-		if (index >= content.length) {
-			break;
-		}
-		const identifierResult = readIdentifier(content, index);
-		if (!identifierResult) {
-			break;
-		}
-		columns.push({
-			value: identifierResult.value,
-			quoted: identifierResult.quoted,
-		});
-		index = identifierResult.end;
-		index = skipWhitespace(content, index);
-		if (content[index] === ",") {
-			index += 1;
-		}
-	}
-
-	return columns;
-}
-
-function skipWhitespace(sql: string, start: number): number {
-	let index = start;
-	while (index < sql.length && isWhitespaceChar(sql[index]!)) {
-		index += 1;
-	}
-	return index;
-}
-
-function isIdentifierStart(char: string): boolean {
-	return /[A-Za-z_]/.test(char);
-}
-
-function isIdentifierPart(char: string | undefined): boolean {
-	return char ? /[A-Za-z0-9_]/.test(char) : false;
-}
-
-function isWhitespaceChar(char: string): boolean {
-	return /\s/.test(char);
-}
-
-function startsWithKeyword(
-	sql: string,
-	start: number,
-	keyword: string
-): boolean {
-	const slice = sql.slice(start, start + keyword.length);
-	if (slice.length !== keyword.length) {
-		return false;
-	}
-	if (slice.toLowerCase() !== keyword.toLowerCase()) {
-		return false;
-	}
-	const next = sql[start + keyword.length];
-	return !isIdentifierPart(next);
-}