@quereus/quereus 0.7.2 → 0.7.4

package/src/planner/building/update.ts

@@ -1,331 +0,0 @@
-import type * as AST from '../../parser/ast.js';
-import type { PlanningContext } from '../planning-context.js';
-import { UpdateNode, type UpdateAssignment } from '../nodes/update-node.js';
-import { DmlExecutorNode } from '../nodes/dml-executor-node.js';
-import { buildTableReference } from './table.js';
-import { buildExpression } from './expression.js';
-import { PlanNode, type RelationalPlanNode, type ScalarPlanNode, type Attribute, type RowDescriptor } from '../nodes/plan-node.js';
-import { FilterNode } from '../nodes/filter.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-import { RegisteredScope } from '../scopes/registered.js';
-import { ColumnReferenceNode } from '../nodes/reference.js';
-import { SinkNode } from '../nodes/sink-node.js';
-import { ConstraintCheckNode } from '../nodes/constraint-check-node.js';
-import { RowOpFlag } from '../../schema/table.js';
-import { ReturningNode } from '../nodes/returning-node.js';
-import { buildOldNewRowDescriptors } from '../../util/row-descriptor.js';
-import { buildConstraintChecks } from './constraint-builder.js';
-
-export function buildUpdateStmt(
-  ctx: PlanningContext,
-  stmt: AST.UpdateStmt,
-): PlanNode {
-  const tableRetrieve = buildTableReference({ type: 'table', table: stmt.table }, ctx);
-	const tableReference = tableRetrieve.tableRef; // Extract the actual TableReferenceNode
-
-  // Process mutation context assignments if present
-  const mutationContextValues = new Map<string, ScalarPlanNode>();
-  const contextAttributes: Attribute[] = [];
-
-  if (stmt.contextValues && tableReference.tableSchema.mutationContext) {
-    // Create context attributes
-    tableReference.tableSchema.mutationContext.forEach((contextVar) => {
-      contextAttributes.push({
-        id: PlanNode.nextAttrId(),
-        name: contextVar.name,
-        type: {
-          typeClass: 'scalar' as const,
-          logicalType: contextVar.logicalType,
-          nullable: !contextVar.notNull,
-          isReadOnly: true
-        },
-        sourceRelation: `context.${tableReference.tableSchema.name}`
-      });
-    });
-
-    // Build context value expressions (evaluated in the base scope, before table scope)
-    stmt.contextValues.forEach((assignment) => {
-      const valueExpr = buildExpression(ctx, assignment.value) as ScalarPlanNode;
-      mutationContextValues.set(assignment.name, valueExpr);
-    });
-  }
-
-  // Plan the source of rows to update. This is typically the table itself, potentially filtered.
-  let sourceNode: RelationalPlanNode = buildTableReference({ type: 'table', table: stmt.table }, ctx);
-
-  // Create a new scope with the table columns registered for column resolution
-  const tableScope = new RegisteredScope(ctx.scope);
-  const sourceAttributes = sourceNode.getAttributes();
-  sourceNode.getType().columns.forEach((c, i) => {
-    const attr = sourceAttributes[i];
-    tableScope.registerSymbol(c.name.toLowerCase(), (exp, s) =>
-      new ColumnReferenceNode(s, exp as AST.ColumnExpr, c.type, attr.id, i));
-  });
-
-  // Create a new planning context with the updated scope for WHERE clause resolution
-  const updateCtx = { ...ctx, scope: tableScope };
-
-  // IMPORTANT: Build assignments FIRST to ensure parameter indices match SQL text order.
-  // SQL: UPDATE t SET col = ?1 WHERE id = ?2
-  // The SET clause parameters must be resolved before WHERE clause parameters.
-  const assignments: UpdateAssignment[] = stmt.assignments.map(assign => {
-    // TODO: Validate assign.column against tableReference.tableSchema
-    const targetColumn: AST.ColumnExpr = { type: 'column', name: assign.column, table: stmt.table.name, schema: stmt.table.schema };
-    return {
-      targetColumn, // Keep as AST for now, emitter can resolve index
-      value: buildExpression(updateCtx, assign.value),
-    };
-  });
-
-  // Now build the WHERE filter (parameters here get indices after SET clause parameters)
-  if (stmt.where) {
-    const filterExpression = buildExpression(updateCtx, stmt.where);
-    sourceNode = new FilterNode(updateCtx.scope, sourceNode, filterExpression);
-  }
-
-  // Create OLD/NEW attributes for UPDATE (used for both RETURNING and non-RETURNING paths)
-  const oldAttributes = tableReference.tableSchema.columns.map((col) => ({
-    id: PlanNode.nextAttrId(),
-    name: col.name,
-    type: {
-      typeClass: 'scalar' as const,
-      logicalType: col.logicalType,
-      nullable: !col.notNull,
-      isReadOnly: false
-    },
-    sourceRelation: `OLD.${tableReference.tableSchema.name}`
-  }));
-
-  const newAttributes = tableReference.tableSchema.columns.map((col) => ({
-    id: PlanNode.nextAttrId(),
-    name: col.name,
-    type: {
-      typeClass: 'scalar' as const,
-      logicalType: col.logicalType,
-      nullable: !col.notNull,
-      isReadOnly: false
-    },
-    sourceRelation: `NEW.${tableReference.tableSchema.name}`
-  }));
-
-  const { oldRowDescriptor, newRowDescriptor, flatRowDescriptor } = buildOldNewRowDescriptors(oldAttributes, newAttributes);
-
-  // Build context descriptor if we have context attributes
-  const contextDescriptor: RowDescriptor = contextAttributes.length > 0 ? [] : undefined as any;
-  if (contextDescriptor) {
-    contextAttributes.forEach((attr, index) => {
-      contextDescriptor[attr.id] = index;
-    });
-  }
-
-  // Build constraint checks at plan time
-  const constraintChecks = buildConstraintChecks(
-    updateCtx,
-    tableReference.tableSchema,
-    RowOpFlag.UPDATE,
-    oldAttributes,
-    newAttributes,
-    flatRowDescriptor,
-    contextAttributes
-  );
-
-  if (stmt.returning && stmt.returning.length > 0) {
-    // For RETURNING, create coordinated attribute IDs like we do for INSERT
-    const returningScope = new RegisteredScope(updateCtx.scope);
-
-    // Create consistent attribute IDs for all table columns (both NEW and OLD)
-    const newColumnAttributeIds: number[] = [];
-    const oldColumnAttributeIds: number[] = [];
-    newAttributes.forEach((attr, columnIndex) => {
-      newColumnAttributeIds[columnIndex] = attr.id;
-    });
-    oldAttributes.forEach((attr, columnIndex) => {
-      oldColumnAttributeIds[columnIndex] = attr.id;
-    });
-
-    tableReference.tableSchema.columns.forEach((tableColumn, columnIndex) => {
-      const newAttributeId = newAttributes[columnIndex].id;
-      const oldAttributeId = oldAttributes[columnIndex].id;
-
-      // Register the unqualified column name in the RETURNING scope (defaults to NEW values)
-      returningScope.registerSymbol(tableColumn.name.toLowerCase(), (exp, s) => {
-        return new ColumnReferenceNode(
-          s,
-          exp as AST.ColumnExpr,
-          {
-            typeClass: 'scalar',
-            logicalType: tableColumn.logicalType,
-            nullable: !tableColumn.notNull,
-            isReadOnly: false
-          },
-          newAttributeId,
-          columnIndex
-        );
-      });
-
-      // Also register the table-qualified form (table.column) - defaults to NEW values
-      const tblQualified = `${tableReference.tableSchema.name.toLowerCase()}.${tableColumn.name.toLowerCase()}`;
-      returningScope.registerSymbol(tblQualified, (exp, s) =>
-        new ColumnReferenceNode(
-          s,
-          exp as AST.ColumnExpr,
-          {
-            typeClass: 'scalar',
-            logicalType: tableColumn.logicalType,
-            nullable: !tableColumn.notNull,
-            isReadOnly: false
-          },
-          newAttributeId,
-          columnIndex
-        )
-      );
-
-      // Register NEW.column for UPDATE RETURNING (updated values)
-      returningScope.registerSymbol(`new.${tableColumn.name.toLowerCase()}`, (exp, s) =>
-        new ColumnReferenceNode(
-          s,
-          exp as AST.ColumnExpr,
-          {
-            typeClass: 'scalar',
-            logicalType: tableColumn.logicalType,
-            nullable: !tableColumn.notNull,
-            isReadOnly: false
-          },
-          newAttributeId,
-          columnIndex
-        )
-      );
-
-      // Register OLD.column for UPDATE RETURNING (original values)
-      returningScope.registerSymbol(`old.${tableColumn.name.toLowerCase()}`, (exp, s) =>
-        new ColumnReferenceNode(
-          s,
-          exp as AST.ColumnExpr,
-          {
-            typeClass: 'scalar',
-            logicalType: tableColumn.logicalType,
-            nullable: !tableColumn.notNull,
-            isReadOnly: false
-          },
-          oldAttributeId,
-          columnIndex
-        )
-      );
-    });
-
-    const returningProjections = stmt.returning.map(rc => {
-      // TODO: Support RETURNING *
-      if (rc.type === 'all') throw new QuereusError('RETURNING * not yet supported', StatusCode.UNSUPPORTED);
-
-      // Infer alias from column name if not explicitly provided
-      let alias = rc.alias;
-      if (!alias && rc.expr.type === 'column') {
-        // For qualified column references like NEW.id or OLD.id, normalize to lowercase
-        if (rc.expr.table) {
-          alias = `${rc.expr.table.toLowerCase()}.${rc.expr.name.toLowerCase()}`;
-        } else {
-          alias = rc.expr.name.toLowerCase();
-        }
-      }
-
-      const columnIndex = tableReference.tableSchema.columns.findIndex(col => col.name.toLowerCase() === (rc.expr.type === 'column' ? rc.expr.name.toLowerCase() : ''));
-      const projAttributeId = rc.expr.type === 'column' && columnIndex !== -1 ? newColumnAttributeIds[columnIndex] : undefined;
-
-      return {
-        node: buildExpression({ ...updateCtx, scope: returningScope }, rc.expr) as ScalarPlanNode,
-        alias: alias,
-        attributeId: projAttributeId
-      };
-    });
-
-    // Create UpdateNode with both row descriptors for RETURNING coordination
-    const updateNodeWithDescriptor = new UpdateNode(
-      updateCtx.scope,
-      tableReference,
-      assignments,
-      sourceNode,
-      stmt.onConflict,
-      oldRowDescriptor,
-      newRowDescriptor,
-      flatRowDescriptor,
-      mutationContextValues.size > 0 ? mutationContextValues : undefined,
-      contextAttributes.length > 0 ? contextAttributes : undefined,
-      contextDescriptor
-    );
-
-    // For returning, we still need to execute the update before projecting
-    // Always inject ConstraintCheckNode for UPDATE operations (provides required metadata)
-    const constraintCheckNode = new ConstraintCheckNode(
-      updateCtx.scope,
-      updateNodeWithDescriptor,
-      tableReference,
-      RowOpFlag.UPDATE,
-      oldRowDescriptor,
-      newRowDescriptor,
-      flatRowDescriptor,
-      constraintChecks,
-      mutationContextValues.size > 0 ? mutationContextValues : undefined,
-      contextAttributes.length > 0 ? contextAttributes : undefined,
-      contextDescriptor
-    );
-
-    const updateExecutorNode = new DmlExecutorNode(
-      updateCtx.scope,
-      constraintCheckNode,
-      tableReference,
-      'update',
-      undefined, // onConflict not used for UPDATE
-      mutationContextValues.size > 0 ? mutationContextValues : undefined,
-      contextAttributes.length > 0 ? contextAttributes : undefined,
-      contextDescriptor
-    );
-
-    // Return the RETURNING results from the executed update
-    return new ReturningNode(updateCtx.scope, updateExecutorNode, returningProjections);
-  }
-
-  // Step 1: Create UpdateNode that produces updated rows (but doesn't execute them)
-  // Create newRowDescriptor and oldRowDescriptor for constraint checking with NEW/OLD references
-  const updateNode = new UpdateNode(
-    updateCtx.scope,
-    tableReference,
-    assignments,
-    sourceNode,
-    stmt.onConflict,
-    oldRowDescriptor,
-    newRowDescriptor,
-    flatRowDescriptor,
-    mutationContextValues.size > 0 ? mutationContextValues : undefined,
-    contextAttributes.length > 0 ? contextAttributes : undefined,
-    contextDescriptor
-  );
-
-  // Step 2: inject constraint checking AFTER update row generation
-  const constraintCheckNode = new ConstraintCheckNode(
-    updateCtx.scope,
-    updateNode,
-    tableReference,
-    RowOpFlag.UPDATE,
-    oldRowDescriptor,
-    newRowDescriptor,
-    flatRowDescriptor,
-    constraintChecks,
-    mutationContextValues.size > 0 ? mutationContextValues : undefined,
-    contextAttributes.length > 0 ? contextAttributes : undefined,
-    contextDescriptor
-  );
-
-  const updateExecutorNode = new DmlExecutorNode(
-    updateCtx.scope,
-    constraintCheckNode,
-    tableReference,
-    'update',
-    undefined, // onConflict not used for UPDATE
-    mutationContextValues.size > 0 ? mutationContextValues : undefined,
-    contextAttributes.length > 0 ? contextAttributes : undefined,
-    contextDescriptor
-  );
-
-  return new SinkNode(updateCtx.scope, updateExecutorNode, 'update');
-}

package/src/planner/building/with.ts

@@ -1,180 +0,0 @@
-import type * as AST from '../../parser/ast.js';
-import type { PlanningContext } from '../planning-context.js';
-import { CTENode, type CTEPlanNode, type CTEScopeNode } from '../nodes/cte-node.js';
-import { RecursiveCTENode } from '../nodes/recursive-cte-node.js';
-import { InternalRecursiveCTERefNode } from '../nodes/internal-recursive-cte-ref-node.js';
-import { buildSelectStmt } from './select.js';
-import type { RelationalPlanNode } from '../nodes/plan-node.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-import { RegisteredScope } from '../scopes/registered.js';
-import { ColumnReferenceNode } from '../nodes/reference.js';
-
-/**
- * Builds plan nodes for Common Table Expressions (CTEs) within a WITH clause.
- * Returns a map of CTE names to their corresponding CTENode instances.
- */
-export function buildWithClause(
-	ctx: PlanningContext,
-	withClause: AST.WithClause
-): Map<string, CTEScopeNode> {
-	const cteNodes = new Map<string, CTEScopeNode>();
-
-	// Check for duplicate CTE names
-	const cteNames = new Set<string>();
-	for (const cte of withClause.ctes) {
-		const cteName = cte.name.toLowerCase();
-		if (cteNames.has(cteName)) {
-			throw new QuereusError(
-				`Duplicate CTE name '${cte.name}' in WITH clause`,
-				StatusCode.ERROR
-			);
-		}
-		cteNames.add(cteName);
-	}
-
-	// Build each CTE in order
-	// Note: For recursive CTEs, we may need to handle forward references
-	for (const cte of withClause.ctes) {
-		const cteNode = buildCommonTableExpr(ctx, cte, withClause.recursive, cteNodes, withClause.options) as CTEScopeNode;
-		cteNodes.set(cte.name.toLowerCase(), cteNode);
-	}
-
-	return cteNodes;
-}
-
-/**
- * Builds a plan node for a single Common Table Expression.
- */
-export function buildCommonTableExpr(
-	ctx: PlanningContext,
-	cte: AST.CommonTableExpr,
-	isRecursive: boolean,
-	existingCTEs: Map<string, CTEScopeNode>,
-	options?: AST.WithClauseOptions
-): CTEPlanNode {
-	// Create a context that includes previously defined CTEs in scope
-	// This allows later CTEs to reference earlier ones
-	const cteContext = { ...ctx };
-
-	// Add existing CTEs to the scope for forward references
-	const cteScope = new RegisteredScope(ctx.scope);
-	for (const [cteName, cteNode] of existingCTEs) {
-		const attributes = cteNode.getAttributes();
-		cteNode.getType().columns.forEach((col, i) => {
-			const attr = attributes[i];
-			// Register CTE columns with qualified names only to avoid conflicts with table columns
-			const qualifiedColumnName = `${cteName}.${col.name.toLowerCase()}`;
-			cteScope.registerSymbol(qualifiedColumnName, (exp, s) =>
-				new ColumnReferenceNode(s, exp as AST.ColumnExpr, col.type, attr.id, i));
-		});
-	}
-	cteContext.scope = cteScope;
-
-	// Check if this is a recursive CTE with UNION structure
-	if (isRecursive && cte.query.type === 'select' && cte.query.compound) {
-		return buildRecursiveCTE(cteContext, cte, options);
-	}
-
-	// For non-recursive CTEs or recursive CTEs without UNION structure
-	let query: RelationalPlanNode;
-
-	if (cte.query.type === 'select') {
-		query = buildSelectStmt(cteContext, cte.query) as RelationalPlanNode;
-	} else {
-		// CTE can also be INSERT, UPDATE, or DELETE statements
-		throw new QuereusError(
-			'Non-SELECT CTEs are not yet supported',
-			StatusCode.UNSUPPORTED
-		);
-	}
-
-	// Determine materialization strategy
-	let materializationHint = cte.materializationHint;
-	if (!materializationHint) {
-		// Default strategy: materialize if CTE is likely to be reused
-		// For now, we'll default to not materialized for simplicity
-		materializationHint = 'not_materialized';
-	}
-
-	return new CTENode(
-		ctx.scope,
-		cte.name,
-		cte.columns,
-		query,
-		materializationHint,
-		isRecursive
-	);
-}
-
-/**
- * Builds a recursive CTE node from a CTE with UNION structure.
- */
-function buildRecursiveCTE(
-	ctx: PlanningContext,
-	cte: AST.CommonTableExpr,
-	options?: AST.WithClauseOptions
-): RecursiveCTENode {
-	const selectStmt = cte.query as AST.SelectStmt;
-
-	// Validate recursive CTE structure - check for compound operation
-	if (!selectStmt.compound) {
-		throw new QuereusError(
-			`Recursive CTE '${cte.name}' must use UNION or UNION ALL`,
-			StatusCode.ERROR
-		);
-	}
-
-	// Extract base case (the main SELECT) and recursive case (the compound part)
-	const baseCaseStmt: AST.SelectStmt = {
-		...selectStmt,
-		compound: undefined
-	};
-
-	const recursiveCaseStmt = selectStmt.compound.select;
-	const isUnionAll = selectStmt.compound.op === 'unionAll';
-
-	// Build the base case query (without CTE self-reference)
-	const baseCaseQuery = buildSelectStmt(ctx, baseCaseStmt) as RelationalPlanNode;
-
-	// Determine materialization strategy (recursive CTEs should typically be materialized)
-	const materializationHint = cte.materializationHint || 'materialized';
-
-	// Create the final recursive CTE node first (so we have the tableDescriptor)
-	const recursiveCTENode = new RecursiveCTENode(
-		ctx.scope,
-		cte.name,
-		cte.columns,
-		baseCaseQuery,
-		baseCaseQuery, // Temporary - will be replaced with actual recursive case
-		isUnionAll,
-		materializationHint,
-		options?.maxRecursion
-	);
-
-		// For the recursive case, we need to create a special context where the CTE name
-	// references the working table (this will be handled at runtime)
-	const recursiveContext = { ...ctx };
-
-	// Create an internal recursive reference node that will look up the working table at runtime
-	const internalRefNode = new InternalRecursiveCTERefNode(
-		ctx.scope,
-		cte.name,
-		recursiveCTENode.getAttributes(),
-		recursiveCTENode.getType(),
-		recursiveCTENode.tableDescriptor
-	);
-
-	// Build the recursive case query with a simple replacement strategy
-	// We'll replace CTE references with the internal recursive reference during the FROM clause processing
-	const recursiveCteMap = new Map<string, CTEScopeNode>();
-	recursiveCteMap.set(cte.name.toLowerCase(), internalRefNode);
-
-	// Build the recursive case query
-	const recursiveCaseQuery = buildSelectStmt(recursiveContext, recursiveCaseStmt, recursiveCteMap) as RelationalPlanNode;
-
-	// Now update the recursive CTE node with the actual recursive case query
-	recursiveCTENode.setRecursiveCaseQuery(recursiveCaseQuery);
-
-	return recursiveCTENode;
-}

package/src/planner/cache/correlation-detector.ts

@@ -1,83 +0,0 @@
-/**
- * Utility to detect correlated subqueries
- * A subquery is correlated if it references columns from outer query scopes
- */
-
-import { isRelationalNode, type PlanNode, type RelationalPlanNode } from '../nodes/plan-node.js';
-import { PlanNodeType } from '../nodes/plan-node-type.js';
-import type { ColumnReferenceNode } from '../nodes/reference.js';
-
-/**
- * Detects if a subquery is correlated by checking if it references any attributes
- * that are not defined within its own scope.
- */
-export function isCorrelatedSubquery(subqueryNode: RelationalPlanNode): boolean {
-	// Collect all attributes defined within the subquery
-	const definedAttributes = new Set<number>();
-	collectDefinedAttributes(subqueryNode, definedAttributes);
-
-	// Check if any column references use attributes not defined within the subquery
-	return hasExternalReferences(subqueryNode, definedAttributes);
-}
-
-/**
- * Recursively collect all attributes defined by relational nodes within a subtree
- */
-function collectDefinedAttributes(node: PlanNode, definedAttributes: Set<number>): void {
-	// If this is a relational node, add its attributes
-	const isRelational = isRelationalNode(node);
-	if (isRelational) {
-		const attributes = node.getAttributes();
-		for (const attr of attributes) {
-			definedAttributes.add(attr.id);
-		}
-	}
-
-	// Recursively process all children
-	const children = node.getChildren();
-	for (const child of children) {
-		collectDefinedAttributes(child, definedAttributes);
-	}
-
-	// Also process relational children if any
-	if (isRelational) {
-		const relations = node.getRelations();
-		for (const relation of relations) {
-			collectDefinedAttributes(relation, definedAttributes);
-		}
-	}
-}
-
-/**
- * Check if the subtree contains any column references to attributes not in the defined set
- */
-function hasExternalReferences(node: PlanNode, definedAttributes: Set<number>): boolean {
-	// Check if this is a column reference
-	if (node.nodeType === PlanNodeType.ColumnReference) {
-		const colRef = node as ColumnReferenceNode;
-		// If the referenced attribute is not defined within the subquery, it's an external reference
-		if (!definedAttributes.has(colRef.attributeId)) {
-			return true; // Found a correlated reference
-		}
-	}
-
-	// Check all children
-	const children = node.getChildren();
-	for (const child of children) {
-		if (hasExternalReferences(child, definedAttributes)) {
-			return true;
-		}
-	}
-
-	// Also check relational children if any
-	if (isRelationalNode(node)) {
-		const relations = node.getRelations();
-		for (const relation of relations) {
-			if (hasExternalReferences(relation, definedAttributes)) {
-				return true;
-			}
-		}
-	}
-
-	return false;
-}