@quereus/quereus 0.2.1 → 0.4.0

package/src/parser/visitor.ts

@@ -52,6 +52,7 @@ export function traverseAst(node: AST.AstNode | undefined, callbacks: AstVisitor
 	// Call specific visitor if defined
 	const specificVisitorKey = `visit${node.type.charAt(0).toUpperCase() + node.type.slice(1)}` as keyof AstVisitorCallbacks;
 	if (callbacks[specificVisitorKey]) {
+		// eslint-disable-next-line @typescript-eslint/no-explicit-any
 		const specificVisitor = callbacks[specificVisitorKey] as (n: any) => void | boolean;
 		const result = specificVisitor(node);
 		if (result !== false) return; // Stop if specific visitor returns false

package/src/planner/analysis/binding-collector.ts

@@ -0,0 +1,83 @@
+import type { PlanNode, ScalarPlanNode } from '../nodes/plan-node.js';
+import { isRelationalNode } from '../nodes/plan-node.js';
+import { PlanNodeType } from '../nodes/plan-node-type.js';
+import type { TableReferenceNode, ColumnReferenceNode } from '../nodes/reference.js';
+
+function buildAttrIdSet(tableRef: TableReferenceNode): Set<number> {
+	const set = new Set<number>();
+	for (const attr of tableRef.getAttributes()) set.add(attr.id);
+	return set;
+}
+
+export function collectBindingsInExpr(expr: ScalarPlanNode, tableRef: TableReferenceNode): ScalarPlanNode[] {
+	const targetAttrIds = buildAttrIdSet(tableRef);
+	const result: ScalarPlanNode[] = [];
+
+	function walkScalar(node: ScalarPlanNode): void {
+		// Parameter bindings
+		if (node.nodeType === PlanNodeType.ParameterReference) {
+			result.push(node);
+			return;
+		}
+		// Correlated column refs (not produced by tableRef)
+		if (node.nodeType === PlanNodeType.ColumnReference) {
+			const col = node as unknown as ColumnReferenceNode;
+			if (!targetAttrIds.has(col.attributeId)) {
+				result.push(node);
+				return;
+			}
+		}
+		// Recurse into scalar children
+		for (const child of node.getChildren()) {
+			// child here should also be scalar nodes
+			walkScalar(child as unknown as ScalarPlanNode);
+		}
+	}
+
+	walkScalar(expr);
+	return dedupeById(result);
+}
+
+export function collectBindingsInPlan(plan: PlanNode, tableRef: TableReferenceNode): ScalarPlanNode[] {
+	const targetAttrIds = buildAttrIdSet(tableRef);
+	const result: ScalarPlanNode[] = [];
+
+	function walk(node: PlanNode): void {
+		if (!isRelationalNode(node)) {
+			// Scalar node
+			const scalar = node as unknown as ScalarPlanNode;
+			if (scalar.nodeType === PlanNodeType.ParameterReference) {
+				result.push(scalar);
+				return;
+			}
+			if (scalar.nodeType === PlanNodeType.ColumnReference) {
+				const col = scalar as unknown as ColumnReferenceNode;
+				if (!targetAttrIds.has(col.attributeId)) {
+					result.push(scalar);
+					return;
+				}
+			}
+		}
+		// Recurse into all children (relational and scalar)
+		for (const child of node.getChildren()) {
+			walk(child);
+		}
+	}
+
+	walk(plan);
+	return dedupeById(result);
+}
+
+function dedupeById(nodes: ScalarPlanNode[]): ScalarPlanNode[] {
+	const seen = new Set<string>();
+	const out: ScalarPlanNode[] = [];
+	for (const n of nodes) {
+		if (!seen.has(n.id)) {
+			seen.add(n.id);
+			out.push(n);
+		}
+	}
+	return out;
+}
+
+

package/src/planner/analysis/const-evaluator.ts

@@ -37,7 +37,7 @@ export function createRuntimeExpressionEvaluator(db: Database): (expr: PlanNode)
 			// No row context is needed since we only evaluate constant expressions
 			const runtimeCtx: RuntimeContext = {
 				db,
-				stmt: null, // No statement context needed for constants
+				stmt: undefined,
 				params: {}, // No parameters needed for constants
 				context: new Map(), // No row context needed
 				tableContexts: new Map(), // No table contexts needed for constants

package/src/planner/analysis/const-pass.ts

@@ -13,6 +13,7 @@ import { type SqlValue, type MaybePromise, OutputValue } from '../../common/type
 import { LiteralNode } from '../nodes/scalar.js';
 import { createLogger } from '../../common/logger.js';
 import type { ScalarType } from '../../common/datatype.js';
+import { ColumnReferenceNode } from '../nodes/reference.js';
 
 const log = createLogger('optimizer:folding');
 
@@ -114,7 +115,7 @@ function classifyNode(node: PlanNode, ctx: ConstFoldingContext): ConstInfo {
 
 	// Rule 2: ColumnReference → dep with {attrId}
 	if (node.nodeType === PlanNodeType.ColumnReference) {
-		const colRef = node as any; // ColumnReferenceNode
+		const colRef = node as ColumnReferenceNode
 		return { kind: 'dep', deps: new Set([colRef.attributeId]) };
 	}
 
@@ -195,7 +196,7 @@ function detectBorderNodes(
 
 	// If this is a relational node that produces expressions, check what new constants it introduces
 	if (node.getType().typeClass === 'relation' && 'getProducingExprs' in node) {
-		const producingExprs = (node as any).getProducingExprs();
+		const producingExprs = node.getProducingExprs!();
 
 		if (producingExprs) {
 			for (const [attrId, expr] of producingExprs) {