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

package/src/engine/preprocessor/sql-parser/visitor.ts

@@ -0,0 +1,1403 @@
+import type {
+	BetweenExpressionNode,
+	BinaryExpressionNode,
+	ColumnReferenceNode,
+	DeleteStatementNode,
+	FunctionCallExpressionNode,
+	FunctionCallArgumentNode,
+	AllColumnsNode,
+	InsertStatementNode,
+	InsertValuesNode,
+	OnConflictActionNode,
+	OnConflictClauseNode,
+	OnConflictDoNothingNode,
+	OnConflictDoUpdateNode,
+	OnConflictTargetNode,
+	ExpressionNode,
+	FromClauseNode,
+	GroupedExpressionNode,
+	IdentifierNode,
+	InListExpressionNode,
+	JoinClauseNode,
+	LiteralNode,
+	ObjectNameNode,
+	OrderByItemNode,
+	ParameterExpressionNode,
+	RawFragmentNode,
+	SelectExpressionNode,
+	SelectItemNode,
+	SelectQualifiedStarNode,
+	SelectStarNode,
+	SelectStatementNode,
+	CompoundSelectNode,
+	SegmentedStatementNode,
+	SetClauseNode,
+	SqlNode,
+	StatementSegmentNode,
+	StatementNode,
+	SubqueryNode,
+	SubqueryExpressionNode,
+	TableReferenceNode,
+	UnaryExpressionNode,
+	UpdateStatementNode,
+	WithClauseNode,
+	CommonTableExpressionNode,
+	CaseExpressionNode,
+	CaseWhenNode,
+	WindowSpecificationNode,
+	WindowReferenceNode,
+	WindowFrameNode,
+	WindowFrameBoundNode,
+	ExistsExpressionNode,
+} from "./nodes.js";
+
+export type VisitContext = {
+	readonly parent: SqlNode | null;
+	readonly property: string | null;
+	readonly index?: number;
+};
+
+type NodeKindMap = {
+	readonly raw_fragment: RawFragmentNode;
+	readonly select_statement: SelectStatementNode;
+	readonly compound_select: CompoundSelectNode;
+	readonly insert_statement: InsertStatementNode;
+	readonly update_statement: UpdateStatementNode;
+	readonly delete_statement: DeleteStatementNode;
+	readonly on_conflict_clause: OnConflictClauseNode;
+	readonly on_conflict_target: OnConflictTargetNode;
+	readonly on_conflict_do_nothing: OnConflictDoNothingNode;
+	readonly on_conflict_do_update: OnConflictDoUpdateNode;
+	readonly function_call: FunctionCallExpressionNode;
+	readonly with_clause: WithClauseNode;
+	readonly common_table_expression: CommonTableExpressionNode;
+	readonly segmented_statement: SegmentedStatementNode;
+	readonly select_star: SelectStarNode;
+	readonly select_qualified_star: SelectQualifiedStarNode;
+	readonly select_expression: SelectExpressionNode;
+	readonly from_clause: FromClauseNode;
+	readonly join_clause: JoinClauseNode;
+	readonly table_reference: TableReferenceNode;
+	readonly subquery: SubqueryNode;
+	readonly subquery_expression: SubqueryExpressionNode;
+	readonly order_by_item: OrderByItemNode;
+	readonly set_clause: SetClauseNode;
+	readonly column_reference: ColumnReferenceNode;
+	readonly literal: LiteralNode;
+	readonly parameter: ParameterExpressionNode;
+	readonly grouped_expression: GroupedExpressionNode;
+	readonly binary_expression: BinaryExpressionNode;
+	readonly unary_expression: UnaryExpressionNode;
+	readonly in_list_expression: InListExpressionNode;
+	readonly between_expression: BetweenExpressionNode;
+	readonly case_expression: CaseExpressionNode;
+	readonly exists_expression: ExistsExpressionNode;
+	readonly identifier: IdentifierNode;
+	readonly object_name: ObjectNameNode;
+	readonly insert_values: InsertValuesNode;
+	readonly window_specification: WindowSpecificationNode;
+	readonly window_reference: WindowReferenceNode;
+	readonly window_frame: WindowFrameNode;
+	readonly window_frame_bound: WindowFrameBoundNode;
+	readonly all_columns: AllColumnsNode;
+};
+
+type NodeKind = keyof NodeKindMap;
+
+type NodeTransformResult<T extends SqlNode> = SqlNode | T | void;
+
+export type AstVisitor = {
+	readonly enter?: (node: SqlNode, context: VisitContext) => SqlNode | void;
+	readonly exit?: (node: SqlNode, context: VisitContext) => SqlNode | void;
+} & {
+	readonly [K in NodeKind]?: (
+		node: NodeKindMap[K],
+		context: VisitContext
+	) => NodeTransformResult<NodeKindMap[K]>;
+} & {
+	readonly [K in NodeKind as `${K}_exit`]?: (
+		node: NodeKindMap[K],
+		context: VisitContext
+	) => NodeTransformResult<NodeKindMap[K]>;
+};
+
+/**
+ * Traverses and optionally transforms a statement node.
+ *
+ * @example
+ * ```ts
+ * const rewritten = visitStatement(statement, visitor);
+ * ```
+ */
+export function visitStatement<T extends StatementNode>(
+	statement: T,
+	visitor: AstVisitor
+): T {
+	return visitNode(statement, visitor, {
+		parent: null,
+		property: null,
+	}) as T;
+}
+
+/**
+ * Specialised helper for visiting select statements.
+ *
+ * @example
+ * ```ts
+ * const rewritten = visitSelectStatement(select, visitor);
+ * ```
+ */
+export function visitSelectStatement(
+	statement: SelectStatementNode,
+	visitor: AstVisitor
+): SelectStatementNode {
+	return visitStatement(statement, visitor) as SelectStatementNode;
+}
+
+function visitNode<T extends SqlNode>(
+	node: T,
+	visitor: AstVisitor,
+	context: VisitContext
+): T {
+	let current: SqlNode = applyEnterHandlers(node, visitor, context);
+	current = traverseNode(current, visitor, context);
+	current = applyExitHandlers(current, visitor, context);
+	return current as T;
+}
+
+function applyEnterHandlers(
+	node: SqlNode,
+	visitor: AstVisitor,
+	context: VisitContext
+): SqlNode {
+	let current: SqlNode = node;
+	const genericResult = visitor.enter?.(current, context);
+	if (genericResult) {
+		current = genericResult;
+	}
+	const specific = getHandler(visitor, current.node_kind);
+	if (specific) {
+		const result = specific(current, context);
+		if (result) {
+			current = result;
+		}
+	}
+	return current;
+}
+
+function applyExitHandlers(
+	node: SqlNode,
+	visitor: AstVisitor,
+	context: VisitContext
+): SqlNode {
+	let current: SqlNode = node;
+	const specific = getExitHandler(visitor, current.node_kind);
+	if (specific) {
+		const result = specific(current, context);
+		if (result) {
+			current = result;
+		}
+	}
+	const genericResult = visitor.exit?.(current, context);
+	if (genericResult) {
+		current = genericResult;
+	}
+	return current;
+}
+
+function getHandler(
+	visitor: AstVisitor,
+	kind: string
+): ((node: SqlNode, context: VisitContext) => SqlNode | void) | undefined {
+	return (
+		visitor as Record<
+			string,
+			((node: SqlNode, context: VisitContext) => SqlNode | void) | undefined
+		>
+	)[kind];
+}
+
+function getExitHandler(
+	visitor: AstVisitor,
+	kind: string
+): ((node: SqlNode, context: VisitContext) => SqlNode | void) | undefined {
+	return (
+		visitor as Record<
+			string,
+			((node: SqlNode, context: VisitContext) => SqlNode | void) | undefined
+		>
+	)[`${kind}_exit`];
+}
+
+function traverseNode(
+	node: SqlNode,
+	visitor: AstVisitor,
+	context: VisitContext
+): SqlNode {
+	switch (node.node_kind) {
+		case "segmented_statement":
+			return traverseSegmentedStatement(
+				node as SegmentedStatementNode,
+				visitor
+			);
+		case "compound_select":
+			return traverseCompoundSelect(node as CompoundSelectNode, visitor);
+		case "select_statement":
+			return traverseSelectStatement(node as SelectStatementNode, visitor);
+		case "with_clause":
+			return traverseWithClause(node as WithClauseNode, visitor);
+		case "common_table_expression":
+			return traverseCommonTableExpression(
+				node as CommonTableExpressionNode,
+				visitor
+			);
+		case "insert_statement":
+			return traverseInsertStatement(node as InsertStatementNode, visitor);
+		case "on_conflict_clause":
+			return traverseOnConflictClause(node as OnConflictClauseNode, visitor);
+		case "on_conflict_target":
+			return traverseOnConflictTarget(node as OnConflictTargetNode, visitor);
+		case "on_conflict_do_update":
+			return traverseOnConflictDoUpdate(
+				node as OnConflictDoUpdateNode,
+				visitor
+			);
+		case "on_conflict_do_nothing":
+			return node;
+		case "update_statement":
+			return traverseUpdateStatement(node as UpdateStatementNode, visitor);
+		case "delete_statement":
+			return traverseDeleteStatement(node as DeleteStatementNode, visitor);
+		case "from_clause":
+			return traverseFromClause(node as FromClauseNode, visitor);
+		case "join_clause":
+			return traverseJoinClause(node as JoinClauseNode, visitor);
+		case "table_reference":
+			return traverseTableReference(node as TableReferenceNode, visitor);
+		case "subquery":
+			return traverseSubquery(node as SubqueryNode, visitor);
+		case "subquery_expression":
+			return traverseSubqueryExpression(
+				node as SubqueryExpressionNode,
+				visitor
+			);
+		case "order_by_item":
+			return traverseOrderByItem(node as OrderByItemNode, visitor);
+		case "set_clause":
+			return traverseSetClause(node as SetClauseNode, visitor);
+		case "select_expression":
+			return traverseSelectExpression(node as SelectExpressionNode, visitor);
+		case "select_qualified_star":
+			return traverseSelectQualifiedStar(
+				node as SelectQualifiedStarNode,
+				visitor
+			);
+		case "column_reference":
+			return traverseColumnReference(node as ColumnReferenceNode, visitor);
+		case "grouped_expression":
+			return traverseGroupedExpression(node as GroupedExpressionNode, visitor);
+		case "binary_expression":
+			return traverseBinaryExpression(node as BinaryExpressionNode, visitor);
+		case "unary_expression":
+			return traverseUnaryExpression(node as UnaryExpressionNode, visitor);
+		case "in_list_expression":
+			return traverseInListExpression(node as InListExpressionNode, visitor);
+		case "between_expression":
+			return traverseBetweenExpression(node as BetweenExpressionNode, visitor);
+		case "case_expression":
+			return traverseCaseExpression(node as CaseExpressionNode, visitor);
+		case "exists_expression":
+			return traverseExistsExpression(node as ExistsExpressionNode, visitor);
+		case "function_call":
+			return traverseFunctionCall(node as FunctionCallExpressionNode, visitor);
+		case "insert_values":
+			return traverseInsertValues(node as InsertValuesNode, visitor);
+		case "object_name":
+			return traverseObjectName(node as ObjectNameNode, visitor);
+		case "window_specification":
+			return traverseWindowSpecification(
+				node as WindowSpecificationNode,
+				visitor
+			);
+		case "window_frame":
+			return traverseWindowFrame(node as WindowFrameNode, visitor);
+		case "window_frame_bound":
+			return traverseWindowFrameBound(node as WindowFrameBoundNode, visitor);
+		case "window_reference":
+			return traverseWindowReference(node as WindowReferenceNode, visitor);
+		case "select_star":
+		case "literal":
+		case "parameter":
+		case "identifier":
+		case "raw_fragment":
+		case "all_columns":
+			return node;
+		default:
+			return node;
+	}
+}
+
+/**
+ * Visits each segment in a statement sequence.
+ *
+ * @example
+ * ```ts
+ * const rewritten = traverseStatementSequence(node, visitor);
+ * ```
+ */
+function traverseSegmentedStatement(
+	node: SegmentedStatementNode,
+	visitor: AstVisitor
+): SegmentedStatementNode {
+	const segments = visitArray(node.segments, node, "segments", visitor);
+	if (segments === node.segments) {
+		return node;
+	}
+	return {
+		...node,
+		segments: segments as readonly StatementSegmentNode[],
+	};
+}
+
+function traverseCompoundSelect(
+	node: CompoundSelectNode,
+	visitor: AstVisitor
+): CompoundSelectNode {
+	let changed = false;
+
+	const withClause = visitOptional(
+		node.with_clause,
+		node,
+		"with_clause",
+		visitor
+	);
+	if (withClause !== node.with_clause) {
+		changed = true;
+	}
+
+	const first = visitNode(node.first, visitor, {
+		parent: node,
+		property: "first",
+	}) as SelectStatementNode;
+	if (first !== node.first) {
+		changed = true;
+	}
+
+	const compounds = node.compounds.map((branch, index) => {
+		const visited = visitNode(branch.select, visitor, {
+			parent: node,
+			property: "compounds",
+			index,
+		}) as SelectStatementNode;
+		if (visited !== branch.select) {
+			changed = true;
+			return {
+				...branch,
+				select: visited,
+			};
+		}
+		return branch;
+	});
+
+	if (!changed) {
+		return node;
+	}
+
+	return {
+		...node,
+		first,
+		compounds,
+		with_clause: withClause as WithClauseNode | null,
+	};
+}
+
+function traverseSelectStatement(
+	node: SelectStatementNode,
+	visitor: AstVisitor
+): SelectStatementNode {
+	let changed = false;
+
+	const withClause = visitOptional(
+		node.with_clause,
+		node,
+		"with_clause",
+		visitor
+	);
+	if (withClause !== node.with_clause) {
+		changed = true;
+	}
+
+	const projection = visitArray(node.projection, node, "projection", visitor);
+	if (projection !== node.projection) {
+		changed = true;
+	}
+
+	const fromClauses = visitArray(
+		node.from_clauses,
+		node,
+		"from_clauses",
+		visitor
+	);
+	if (fromClauses !== node.from_clauses) {
+		changed = true;
+	}
+
+	const whereClause = visitOptional(
+		node.where_clause,
+		node,
+		"where_clause",
+		visitor
+	);
+	if (whereClause !== node.where_clause) {
+		changed = true;
+	}
+
+	const groupBy = visitArray(node.group_by, node, "group_by", visitor);
+	if (groupBy !== node.group_by) {
+		changed = true;
+	}
+
+	const orderBy = visitArray(node.order_by, node, "order_by", visitor);
+	if (orderBy !== node.order_by) {
+		changed = true;
+	}
+
+	const limit = visitOptional(node.limit, node, "limit", visitor);
+	if (limit !== node.limit) {
+		changed = true;
+	}
+
+	const offset = visitOptional(node.offset, node, "offset", visitor);
+	if (offset !== node.offset) {
+		changed = true;
+	}
+
+	if (!changed) {
+		return node;
+	}
+
+	return {
+		...node,
+		projection: projection as readonly SelectItemNode[],
+		from_clauses: fromClauses as readonly FromClauseNode[],
+		where_clause: whereClause as ExpressionNode | RawFragmentNode | null,
+		group_by: groupBy as readonly ExpressionNode[],
+		order_by: orderBy as readonly OrderByItemNode[],
+		limit: limit as ExpressionNode | RawFragmentNode | null,
+		offset: offset as ExpressionNode | RawFragmentNode | null,
+		with_clause: withClause as WithClauseNode | null,
+	};
+}
+
+function traverseWithClause(
+	node: WithClauseNode,
+	visitor: AstVisitor
+): WithClauseNode {
+	const ctes = visitArray(node.ctes, node, "ctes", visitor);
+	if (ctes === node.ctes) {
+		return node;
+	}
+	return {
+		...node,
+		ctes: ctes as readonly CommonTableExpressionNode[],
+	};
+}
+
+function traverseCommonTableExpression(
+	node: CommonTableExpressionNode,
+	visitor: AstVisitor
+): CommonTableExpressionNode {
+	let changed = false;
+	const name = visitNode(node.name, visitor, createContext(node, "name"));
+	if (name !== node.name) {
+		changed = true;
+	}
+	const columns = visitArray(node.columns, node, "columns", visitor);
+	if (columns !== node.columns) {
+		changed = true;
+	}
+	const statement = visitNode(
+		node.statement,
+		visitor,
+		createContext(node, "statement")
+	);
+	if (statement !== node.statement) {
+		changed = true;
+	}
+	if (!changed) {
+		return node;
+	}
+	return {
+		...node,
+		name: name as IdentifierNode,
+		columns: columns as readonly IdentifierNode[],
+		statement: statement as SelectStatementNode | CompoundSelectNode,
+	};
+}
+
+function traverseInsertStatement(
+	node: InsertStatementNode,
+	visitor: AstVisitor
+): InsertStatementNode {
+	let changed = false;
+
+	const target = visitNode(node.target, visitor, createContext(node, "target"));
+	if (target !== node.target) {
+		changed = true;
+	}
+
+	const columns = visitArray(node.columns, node, "columns", visitor);
+	if (columns !== node.columns) {
+		changed = true;
+	}
+
+	const source = visitNode(node.source, visitor, createContext(node, "source"));
+	if (source !== node.source) {
+		changed = true;
+	}
+
+	const onConflict = visitOptional(
+		node.on_conflict,
+		node,
+		"on_conflict",
+		visitor
+	);
+	if (onConflict !== node.on_conflict) {
+		changed = true;
+	}
+
+	if (!changed) {
+		return node;
+	}
+
+	return {
+		...node,
+		target: target as ObjectNameNode,
+		columns: columns as readonly IdentifierNode[],
+		source: source as InsertValuesNode,
+		on_conflict: onConflict as OnConflictClauseNode | null,
+	};
+}
+
+function traverseOnConflictClause(
+	node: OnConflictClauseNode,
+	visitor: AstVisitor
+): OnConflictClauseNode {
+	let changed = false;
+
+	const target = visitOptional(node.target, node, "target", visitor);
+	if (target !== node.target) {
+		changed = true;
+	}
+
+	const action = visitNode(node.action, visitor, createContext(node, "action"));
+	if (action !== node.action) {
+		changed = true;
+	}
+
+	if (!changed) {
+		return node;
+	}
+
+	return {
+		...node,
+		target: target as OnConflictTargetNode | null,
+		action: action as OnConflictActionNode,
+	};
+}
+
+function traverseOnConflictTarget(
+	node: OnConflictTargetNode,
+	visitor: AstVisitor
+): OnConflictTargetNode {
+	let changed = false;
+
+	const expressions = visitArray(
+		node.expressions,
+		node,
+		"expressions",
+		visitor
+	);
+	if (expressions !== node.expressions) {
+		changed = true;
+	}
+
+	const whereClause = visitOptional(node.where, node, "where", visitor);
+	if (whereClause !== node.where) {
+		changed = true;
+	}
+
+	if (!changed) {
+		return node;
+	}
+
+	return {
+		...node,
+		expressions: expressions as readonly (ExpressionNode | RawFragmentNode)[],
+		where: whereClause as ExpressionNode | RawFragmentNode | null,
+	};
+}
+
+function traverseOnConflictDoUpdate(
+	node: OnConflictDoUpdateNode,
+	visitor: AstVisitor
+): OnConflictDoUpdateNode {
+	let changed = false;
+
+	const assignments = visitArray(
+		node.assignments,
+		node,
+		"assignments",
+		visitor
+	);
+	if (assignments !== node.assignments) {
+		changed = true;
+	}
+
+	const whereClause = visitOptional(node.where, node, "where", visitor);
+	if (whereClause !== node.where) {
+		changed = true;
+	}
+
+	if (!changed) {
+		return node;
+	}
+
+	return {
+		...node,
+		assignments: assignments as readonly SetClauseNode[],
+		where: whereClause as ExpressionNode | RawFragmentNode | null,
+	};
+}
+
+function traverseUpdateStatement(
+	node: UpdateStatementNode,
+	visitor: AstVisitor
+): UpdateStatementNode {
+	let changed = false;
+
+	const target = visitNode(node.target, visitor, createContext(node, "target"));
+	if (target !== node.target) {
+		changed = true;
+	}
+
+	const assignments = visitArray(
+		node.assignments,
+		node,
+		"assignments",
+		visitor
+	);
+	if (assignments !== node.assignments) {
+		changed = true;
+	}
+
+	const whereClause = visitOptional(
+		node.where_clause,
+		node,
+		"where_clause",
+		visitor
+	);
+	if (whereClause !== node.where_clause) {
+		changed = true;
+	}
+
+	if (!changed) {
+		return node;
+	}
+
+	return {
+		...node,
+		target: target as TableReferenceNode,
+		assignments: assignments as readonly SetClauseNode[],
+		where_clause: whereClause as ExpressionNode | RawFragmentNode | null,
+	};
+}
+
+function traverseDeleteStatement(
+	node: DeleteStatementNode,
+	visitor: AstVisitor
+): DeleteStatementNode {
+	let changed = false;
+	const target = visitNode(node.target, visitor, createContext(node, "target"));
+	if (target !== node.target) {
+		changed = true;
+	}
+	const whereClause = visitOptional(
+		node.where_clause,
+		node,
+		"where_clause",
+		visitor
+	);
+	if (whereClause !== node.where_clause) {
+		changed = true;
+	}
+	if (!changed) {
+		return node;
+	}
+	return {
+		...node,
+		target: target as TableReferenceNode,
+		where_clause: whereClause as ExpressionNode | RawFragmentNode | null,
+	};
+}
+
+function traverseInsertValues(
+	node: InsertValuesNode,
+	visitor: AstVisitor
+): InsertValuesNode {
+	let changed = false;
+	const rows: (readonly ExpressionNode[])[] = [];
+
+	for (let rowIndex = 0; rowIndex < node.rows.length; rowIndex += 1) {
+		const row = node.rows[rowIndex]!;
+		let rowChanged = false;
+		const nextRow: ExpressionNode[] = [];
+
+		for (let valueIndex = 0; valueIndex < row.length; valueIndex += 1) {
+			const value = row[valueIndex]!;
+			const nextValue = visitNode(
+				value,
+				visitor,
+				createContext(node, `rows.${rowIndex}`, valueIndex)
+			) as ExpressionNode;
+			if (nextValue !== value) {
+				rowChanged = true;
+			}
+			nextRow.push(nextValue);
+		}
+
+		if (rowChanged) {
+			changed = true;
+			rows.push(nextRow);
+		} else {
+			rows.push(row);
+		}
+	}
+
+	if (!changed) {
+		return node;
+	}
+
+	return {
+		...node,
+		rows: rows as readonly (readonly ExpressionNode[])[],
+	};
+}
+
+function traverseFromClause(
+	node: FromClauseNode,
+	visitor: AstVisitor
+): FromClauseNode {
+	let changed = false;
+	const relation = visitNode(
+		node.relation,
+		visitor,
+		createContext(node, "relation")
+	);
+	if (relation !== node.relation) {
+		changed = true;
+	}
+	const joins = visitArray(node.joins, node, "joins", visitor);
+	if (joins !== node.joins) {
+		changed = true;
+	}
+	if (!changed) {
+		return node;
+	}
+	return {
+		...node,
+		relation: relation as typeof node.relation,
+		joins: joins as readonly JoinClauseNode[],
+	};
+}
+
+function traverseJoinClause(
+	node: JoinClauseNode,
+	visitor: AstVisitor
+): JoinClauseNode {
+	let changed = false;
+	const relation = visitNode(
+		node.relation,
+		visitor,
+		createContext(node, "relation")
+	);
+	if (relation !== node.relation) {
+		changed = true;
+	}
+	const onExpression = visitOptional(
+		node.on_expression,
+		node,
+		"on_expression",
+		visitor
+	);
+	if (onExpression !== node.on_expression) {
+		changed = true;
+	}
+	if (!changed) {
+		return node;
+	}
+	return {
+		...node,
+		relation: relation as typeof node.relation,
+		on_expression: onExpression as ExpressionNode | RawFragmentNode | null,
+	};
+}
+
+function traverseTableReference(
+	node: TableReferenceNode,
+	visitor: AstVisitor
+): TableReferenceNode {
+	let changed = false;
+	const name = visitNode(node.name, visitor, createContext(node, "name"));
+	if (name !== node.name) {
+		changed = true;
+	}
+	const alias = visitOptional(node.alias, node, "alias", visitor);
+	if (alias !== node.alias) {
+		changed = true;
+	}
+	if (!changed) {
+		return node;
+	}
+	return {
+		...node,
+		name: name as ObjectNameNode,
+		alias: alias as IdentifierNode | null,
+	};
+}
+
+function traverseSubquery(
+	node: SubqueryNode,
+	visitor: AstVisitor
+): SubqueryNode {
+	let changed = false;
+	const statement = visitNode(
+		node.statement,
+		visitor,
+		createContext(node, "statement")
+	);
+	if (statement !== node.statement) {
+		changed = true;
+	}
+	const alias = visitOptional(node.alias, node, "alias", visitor);
+	if (alias !== node.alias) {
+		changed = true;
+	}
+	if (!changed) {
+		return node;
+	}
+	return {
+		...node,
+		statement: statement as SelectStatementNode | CompoundSelectNode,
+		alias: alias as IdentifierNode | null,
+	};
+}
+
+function traverseSubqueryExpression(
+	node: SubqueryExpressionNode,
+	visitor: AstVisitor
+): SubqueryExpressionNode {
+	const statement = visitNode(
+		node.statement,
+		visitor,
+		createContext(node, "statement")
+	) as SelectStatementNode | CompoundSelectNode;
+	if (statement === node.statement) {
+		return node;
+	}
+	return {
+		...node,
+		statement,
+	};
+}
+
+function traverseExistsExpression(
+	node: ExistsExpressionNode,
+	visitor: AstVisitor
+): ExistsExpressionNode {
+	const statement = visitNode(
+		node.statement,
+		visitor,
+		createContext(node, "statement")
+	) as SelectStatementNode | CompoundSelectNode;
+	if (statement === node.statement) {
+		return node;
+	}
+	return {
+		...node,
+		statement,
+	};
+}
+
+function traverseOrderByItem(
+	node: OrderByItemNode,
+	visitor: AstVisitor
+): OrderByItemNode {
+	const expression = visitNode(
+		node.expression,
+		visitor,
+		createContext(node, "expression")
+	);
+	if (expression === node.expression) {
+		return node;
+	}
+	return {
+		...node,
+		expression: expression as ExpressionNode,
+	};
+}
+
+function traverseFunctionCall(
+	node: FunctionCallExpressionNode,
+	visitor: AstVisitor
+): FunctionCallExpressionNode {
+	let changed = false;
+	const name = visitNode(node.name, visitor, createContext(node, "name"));
+	if (name !== node.name) {
+		changed = true;
+	}
+	const args: FunctionCallArgumentNode[] = [];
+	let argsChanged = false;
+	for (let index = 0; index < node.arguments.length; index += 1) {
+		const argument = node.arguments[index]!;
+		if (argument.node_kind === "all_columns") {
+			args.push(argument);
+			continue;
+		}
+		const nextArgument = visitNode(
+			argument,
+			visitor,
+			createContext(node, "arguments", index)
+		) as ExpressionNode;
+		if (nextArgument !== argument) {
+			argsChanged = true;
+		}
+		args.push(nextArgument as FunctionCallArgumentNode);
+	}
+	if (argsChanged) {
+		changed = true;
+	}
+	const over = visitOptional(node.over, node, "over", visitor);
+	if (over !== node.over) {
+		changed = true;
+	}
+	if (!changed) {
+		return node;
+	}
+	return {
+		...node,
+		name: name as IdentifierNode,
+		arguments: args as readonly FunctionCallArgumentNode[],
+		over: over as WindowSpecificationNode | WindowReferenceNode | null,
+	};
+}
+
+function traverseWindowSpecification(
+	spec: WindowSpecificationNode,
+	visitor: AstVisitor
+): WindowSpecificationNode {
+	let changed = false;
+	const name = visitOptional(spec.name, spec, "name", visitor);
+	if (name !== spec.name) {
+		changed = true;
+	}
+	const partitionBy = visitArray(
+		spec.partition_by,
+		spec,
+		"partition_by",
+		visitor
+	);
+	if (partitionBy !== spec.partition_by) {
+		changed = true;
+	}
+	const orderBy = visitArray(spec.order_by, spec, "order_by", visitor);
+	if (orderBy !== spec.order_by) {
+		changed = true;
+	}
+	const frame = visitOptional(spec.frame, spec, "frame", visitor);
+	if (frame !== spec.frame) {
+		changed = true;
+	}
+	if (!changed) {
+		return spec;
+	}
+	return {
+		...spec,
+		name: name as IdentifierNode | null,
+		partition_by: partitionBy as readonly ExpressionNode[],
+		order_by: orderBy as readonly OrderByItemNode[],
+		frame: frame as WindowFrameNode | null,
+	};
+}
+
+function traverseWindowFrame(
+	frame: WindowFrameNode,
+	visitor: AstVisitor
+): WindowFrameNode {
+	let changed = false;
+	const start = visitNode(frame.start, visitor, createContext(frame, "start"));
+	if (start !== frame.start) {
+		changed = true;
+	}
+	const end = visitOptional(frame.end, frame, "end", visitor);
+	if (end !== frame.end) {
+		changed = true;
+	}
+	if (!changed) {
+		return frame;
+	}
+	return {
+		...frame,
+		start: start as WindowFrameBoundNode,
+		end: end as WindowFrameBoundNode | null,
+	};
+}
+
+function traverseWindowFrameBound(
+	bound: WindowFrameBoundNode,
+	visitor: AstVisitor
+): WindowFrameBoundNode {
+	if (!bound.offset) {
+		return bound;
+	}
+	const offset = visitNode(
+		bound.offset,
+		visitor,
+		createContext(bound, "offset")
+	) as ExpressionNode;
+	if (offset === bound.offset) {
+		return bound;
+	}
+	return {
+		...bound,
+		offset,
+	};
+}
+
+function traverseWindowReference(
+	reference: WindowReferenceNode,
+	visitor: AstVisitor
+): WindowReferenceNode {
+	const name = visitNode(
+		reference.name,
+		visitor,
+		createContext(reference, "name")
+	) as IdentifierNode;
+	if (name === reference.name) {
+		return reference;
+	}
+	return {
+		...reference,
+		name,
+	};
+}
+
+function traverseSetClause(
+	node: SetClauseNode,
+	visitor: AstVisitor
+): SetClauseNode {
+	let changed = false;
+	const column = visitNode(node.column, visitor, createContext(node, "column"));
+	if (column !== node.column) {
+		changed = true;
+	}
+	const value = visitNode(node.value, visitor, createContext(node, "value"));
+	if (value !== node.value) {
+		changed = true;
+	}
+	if (!changed) {
+		return node;
+	}
+	return {
+		...node,
+		column: column as ColumnReferenceNode,
+		value: value as ExpressionNode,
+	};
+}
+
+function traverseSelectExpression(
+	node: SelectExpressionNode,
+	visitor: AstVisitor
+): SelectExpressionNode {
+	let changed = false;
+	const expression = visitNode(
+		node.expression,
+		visitor,
+		createContext(node, "expression")
+	);
+	if (expression !== node.expression) {
+		changed = true;
+	}
+	const alias = visitOptional(node.alias, node, "alias", visitor);
+	if (alias !== node.alias) {
+		changed = true;
+	}
+	if (!changed) {
+		return node;
+	}
+	return {
+		...node,
+		expression: expression as ExpressionNode,
+		alias: alias as IdentifierNode | null,
+	};
+}
+
+function traverseSelectQualifiedStar(
+	node: SelectQualifiedStarNode,
+	visitor: AstVisitor
+): SelectQualifiedStarNode {
+	const qualifier = visitArray(node.qualifier, node, "qualifier", visitor);
+	if (qualifier === node.qualifier) {
+		return node;
+	}
+	return {
+		...node,
+		qualifier: qualifier as readonly IdentifierNode[],
+	};
+}
+
+function traverseColumnReference(
+	node: ColumnReferenceNode,
+	visitor: AstVisitor
+): ColumnReferenceNode {
+	const path = visitArray(node.path, node, "path", visitor);
+	if (path === node.path) {
+		return node;
+	}
+	return {
+		...node,
+		path: path as readonly IdentifierNode[],
+	};
+}
+
+function traverseGroupedExpression(
+	node: GroupedExpressionNode,
+	visitor: AstVisitor
+): GroupedExpressionNode {
+	const expression = visitNode(
+		node.expression,
+		visitor,
+		createContext(node, "expression")
+	);
+	if (expression === node.expression) {
+		return node;
+	}
+	return {
+		...node,
+		expression: expression as ExpressionNode,
+	};
+}
+
+function traverseBinaryExpression(
+	node: BinaryExpressionNode,
+	visitor: AstVisitor
+): BinaryExpressionNode {
+	let changed = false;
+	const left = visitNode(node.left, visitor, createContext(node, "left"));
+	if (left !== node.left) {
+		changed = true;
+	}
+	const right = visitNode(node.right, visitor, createContext(node, "right"));
+	if (right !== node.right) {
+		changed = true;
+	}
+	if (!changed) {
+		return node;
+	}
+	return {
+		...node,
+		left: left as ExpressionNode,
+		right: right as ExpressionNode,
+	};
+}
+
+function traverseUnaryExpression(
+	node: UnaryExpressionNode,
+	visitor: AstVisitor
+): UnaryExpressionNode {
+	const operand = visitNode(
+		node.operand,
+		visitor,
+		createContext(node, "operand")
+	);
+	if (operand === node.operand) {
+		return node;
+	}
+	return {
+		...node,
+		operand: operand as ExpressionNode,
+	};
+}
+
+function traverseInListExpression(
+	node: InListExpressionNode,
+	visitor: AstVisitor
+): InListExpressionNode {
+	let changed = false;
+	const operand = visitNode(
+		node.operand,
+		visitor,
+		createContext(node, "operand")
+	);
+	if (operand !== node.operand) {
+		changed = true;
+	}
+	const items = visitArray(node.items, node, "items", visitor);
+	if (items !== node.items) {
+		changed = true;
+	}
+	if (!changed) {
+		return node;
+	}
+	return {
+		...node,
+		operand: operand as ExpressionNode,
+		items: items as readonly ExpressionNode[],
+	};
+}
+
+function traverseBetweenExpression(
+	node: BetweenExpressionNode,
+	visitor: AstVisitor
+): BetweenExpressionNode {
+	let changed = false;
+	const operand = visitNode(
+		node.operand,
+		visitor,
+		createContext(node, "operand")
+	);
+	if (operand !== node.operand) {
+		changed = true;
+	}
+	const start = visitNode(node.start, visitor, createContext(node, "start"));
+	if (start !== node.start) {
+		changed = true;
+	}
+	const end = visitNode(node.end, visitor, createContext(node, "end"));
+	if (end !== node.end) {
+		changed = true;
+	}
+	if (!changed) {
+		return node;
+	}
+	return {
+		...node,
+		operand: operand as ExpressionNode,
+		start: start as ExpressionNode,
+		end: end as ExpressionNode,
+	};
+}
+
+function traverseCaseExpression(
+	node: CaseExpressionNode,
+	visitor: AstVisitor
+): CaseExpressionNode {
+	let changed = false;
+	const operand = node.operand
+		? visitNode(node.operand, visitor, createContext(node, "operand"))
+		: null;
+	if (operand !== node.operand) {
+		changed = true;
+	}
+
+	const branchResults: CaseWhenNode[] = [];
+	for (let index = 0; index < node.branches.length; index += 1) {
+		const branch = node.branches[index]!;
+		const condition = visitNode(
+			branch.condition,
+			visitor,
+			createContext(node, "branch_condition", index)
+		) as ExpressionNode;
+		const result = visitNode(
+			branch.result,
+			visitor,
+			createContext(node, "branch_result", index)
+		) as ExpressionNode;
+		if (condition !== branch.condition || result !== branch.result) {
+			changed = true;
+		}
+		branchResults.push({
+			condition,
+			result,
+		});
+	}
+
+	const elseResult = node.else_result
+		? (visitNode(
+				node.else_result,
+				visitor,
+				createContext(node, "else_result")
+			) as ExpressionNode)
+		: null;
+	if (elseResult !== node.else_result) {
+		changed = true;
+	}
+
+	if (!changed) {
+		return node;
+	}
+
+	return {
+		...node,
+		operand: operand as ExpressionNode | null,
+		branches: branchResults,
+		else_result: elseResult as ExpressionNode | null,
+	};
+}
+
+function traverseObjectName(
+	node: ObjectNameNode,
+	visitor: AstVisitor
+): ObjectNameNode {
+	const parts = visitArray(node.parts, node, "parts", visitor);
+	if (parts === node.parts) {
+		return node;
+	}
+	return {
+		...node,
+		parts: parts as readonly IdentifierNode[],
+	};
+}
+
+function visitOptional<T extends SqlNode | null>(
+	child: T,
+	parent: SqlNode,
+	property: string,
+	visitor: AstVisitor
+): T {
+	if (child === null) {
+		return child;
+	}
+	return visitNode(child, visitor, createContext(parent, property)) as T;
+}
+
+function visitArray<T extends SqlNode>(
+	items: readonly T[],
+	parent: SqlNode,
+	property: string,
+	visitor: AstVisitor
+): readonly T[] {
+	let changed = false;
+	const result: T[] = [];
+	for (let index = 0; index < items.length; index += 1) {
+		const item = items[index]!;
+		const next = visitNode(
+			item,
+			visitor,
+			createContext(parent, property, index)
+		) as T;
+		if (next !== item) {
+			changed = true;
+		}
+		result.push(next);
+	}
+	return changed ? (result as readonly T[]) : items;
+}
+
+function createContext(
+	parent: SqlNode,
+	property: string,
+	index?: number
+): VisitContext {
+	return { parent, property, index };
+}