@quereus/quereus 0.2.1 → 0.4.5

package/src/planner/building/delete.ts

@@ -1,171 +1,214 @@
-import type * as AST from '../../parser/ast.js';
-import type { PlanningContext } from '../planning-context.js';
-import { DeleteNode } from '../nodes/delete-node.js';
-import { buildTableReference } from './table.js';
-import { buildExpression } from './expression.js';
-import { PlanNode, type RelationalPlanNode, type ScalarPlanNode } 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 { DmlExecutorNode } from '../nodes/dml-executor-node.js';
-import { buildConstraintChecks } from './constraint-builder.js';
-
-export function buildDeleteStmt(
-  ctx: PlanningContext,
-  stmt: AST.DeleteStmt,
-): PlanNode {
-  const tableReference = buildTableReference({ type: 'table', table: stmt.table }, ctx);
-
-  // Plan the source of rows to delete. 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 deleteCtx = { ...ctx, scope: tableScope };
-
-  if (stmt.where) {
-    const filterExpression = buildExpression(deleteCtx, stmt.where);
-    sourceNode = new FilterNode(deleteCtx.scope, sourceNode, filterExpression);
-  }
-
-  // Create OLD/NEW attributes for DELETE (OLD = actual values being deleted, NEW = all NULL)
-  const oldAttributes = tableReference.tableSchema.columns.map((col) => ({
-    id: PlanNode.nextAttrId(),
-    name: col.name,
-    type: {
-      typeClass: 'scalar' as const,
-      affinity: col.affinity,
-      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,
-      affinity: col.affinity,
-      nullable: true, // NEW values are always NULL for DELETE
-      isReadOnly: false
-    },
-    sourceRelation: `NEW.${tableReference.tableSchema.name}`
-  }));
-
-  const { oldRowDescriptor, newRowDescriptor, flatRowDescriptor } = buildOldNewRowDescriptors(oldAttributes, newAttributes);
-
-  // Build constraint checks at plan time
-  const constraintChecks = buildConstraintChecks(
-    deleteCtx,
-    tableReference.tableSchema,
-    RowOpFlag.DELETE,
-    oldAttributes,
-    newAttributes,
-    flatRowDescriptor
-  );
-
-  // Always inject ConstraintCheckNode for DELETE operations
-  const constraintCheckNode = new ConstraintCheckNode(
-    deleteCtx.scope,
-    sourceNode,
-    tableReference,
-    RowOpFlag.DELETE,
-    oldRowDescriptor,
-    newRowDescriptor,
-    flatRowDescriptor,
-    constraintChecks
-  );
-
-  const deleteNode = new DeleteNode(
-    deleteCtx.scope,
-    tableReference,
-    constraintCheckNode,
-    oldRowDescriptor,
-    flatRowDescriptor
-  );
-
-  // Add DML executor node to perform the actual database delete operations
-  const dmlExecutorNode = new DmlExecutorNode(
-    deleteCtx.scope,
-    deleteNode,
-    tableReference,
-    'delete'
-  );
-
-  const resultNode: RelationalPlanNode = dmlExecutorNode;
-
-  if (stmt.returning && stmt.returning.length > 0) {
-    // Create returning scope with OLD/NEW attribute access
-    const returningScope = new RegisteredScope(deleteCtx.scope);
-
-    // Register OLD.* symbols (actual values being deleted)
-    oldAttributes.forEach((attr, columnIndex) => {
-      const tableColumn = tableReference.tableSchema.columns[columnIndex];
-      returningScope.registerSymbol(`old.${tableColumn.name.toLowerCase()}`, (exp, s) =>
-        new ColumnReferenceNode(s, exp as AST.ColumnExpr, attr.type, attr.id, columnIndex)
-      );
-    });
-
-    // Register NEW.* symbols (always NULL for DELETE) and unqualified column names (default to OLD for DELETE)
-    newAttributes.forEach((attr, columnIndex) => {
-      const tableColumn = tableReference.tableSchema.columns[columnIndex];
-
-      // NEW.column (always NULL for DELETE)
-      returningScope.registerSymbol(`new.${tableColumn.name.toLowerCase()}`, (exp, s) =>
-        new ColumnReferenceNode(s, exp as AST.ColumnExpr, attr.type, attr.id, columnIndex)
-      );
-
-      // Unqualified column (defaults to OLD for DELETE)
-      const oldAttr = oldAttributes[columnIndex];
-      returningScope.registerSymbol(tableColumn.name.toLowerCase(), (exp, s) =>
-        new ColumnReferenceNode(s, exp as AST.ColumnExpr, oldAttr.type, oldAttr.id, columnIndex)
-      );
-
-      // Table-qualified form (table.column -> OLD for DELETE)
-      const tblQualified = `${tableReference.tableSchema.name.toLowerCase()}.${tableColumn.name.toLowerCase()}`;
-      returningScope.registerSymbol(tblQualified, (exp, s) =>
-        new ColumnReferenceNode(s, exp as AST.ColumnExpr, oldAttr.type, oldAttr.id, columnIndex)
-      );
-    });
-
-    // Build RETURNING projections in the OLD/NEW context
-    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 OLD.id, normalize to lowercase
-        alias = rc.expr.table
-					? `${rc.expr.table.toLowerCase()}.${rc.expr.name.toLowerCase()}`
-					: rc.expr.name.toLowerCase();
-      }
-
-      return {
-        node: buildExpression({ ...deleteCtx, scope: returningScope }, rc.expr) as ScalarPlanNode,
-        alias: alias
-      };
-    });
-
-    return new ReturningNode(deleteCtx.scope, dmlExecutorNode, returningProjections);
-  }
-
-	return new SinkNode(deleteCtx.scope, resultNode, 'delete');
-}
+import type * as AST from '../../parser/ast.js';
+import type { PlanningContext } from '../planning-context.js';
+import { DeleteNode } from '../nodes/delete-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 { DmlExecutorNode } from '../nodes/dml-executor-node.js';
+import { buildConstraintChecks } from './constraint-builder.js';
+
+export function buildDeleteStmt(
+  ctx: PlanningContext,
+  stmt: AST.DeleteStmt,
+): 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,
+          affinity: contextVar.affinity,
+          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 delete. This is typically the table itself, potentially filtered.
+  let sourceNode: RelationalPlanNode = tableRetrieve; // Use the RetrieveNode as source
+
+  // 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 deleteCtx = { ...ctx, scope: tableScope };
+
+  if (stmt.where) {
+    const filterExpression = buildExpression(deleteCtx, stmt.where);
+    sourceNode = new FilterNode(deleteCtx.scope, sourceNode, filterExpression);
+  }
+
+  // Create OLD/NEW attributes for DELETE (OLD = actual values being deleted, NEW = all NULL)
+  const oldAttributes = tableReference.tableSchema.columns.map((col: any) => ({
+    id: PlanNode.nextAttrId(),
+    name: col.name,
+    type: {
+      typeClass: 'scalar' as const,
+      affinity: col.affinity,
+      nullable: !col.notNull,
+      isReadOnly: false
+    },
+    sourceRelation: `OLD.${tableReference.tableSchema.name}`
+  }));
+
+  const newAttributes = tableReference.tableSchema.columns.map((col: any) => ({
+    id: PlanNode.nextAttrId(),
+    name: col.name,
+    type: {
+      typeClass: 'scalar' as const,
+      affinity: col.affinity,
+      nullable: true, // NEW values are always NULL for DELETE
+      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(
+    deleteCtx,
+    tableReference.tableSchema,
+    RowOpFlag.DELETE,
+    oldAttributes,
+    newAttributes,
+    flatRowDescriptor,
+    contextAttributes
+  );
+
+  // Always inject ConstraintCheckNode for DELETE operations
+  const constraintCheckNode = new ConstraintCheckNode(
+    deleteCtx.scope,
+    sourceNode,
+    tableReference,
+    RowOpFlag.DELETE,
+    oldRowDescriptor,
+    newRowDescriptor,
+    flatRowDescriptor,
+    constraintChecks,
+    mutationContextValues.size > 0 ? mutationContextValues : undefined,
+    contextAttributes.length > 0 ? contextAttributes : undefined,
+    contextDescriptor
+  );
+
+  const deleteNode = new DeleteNode(
+    deleteCtx.scope,
+    tableReference,
+    constraintCheckNode,
+    oldRowDescriptor,
+    flatRowDescriptor,
+    mutationContextValues.size > 0 ? mutationContextValues : undefined,
+    contextAttributes.length > 0 ? contextAttributes : undefined,
+    contextDescriptor
+  );
+
+  // Add DML executor node to perform the actual database delete operations
+  const dmlExecutorNode = new DmlExecutorNode(
+    deleteCtx.scope,
+    deleteNode,
+    tableReference,
+    'delete'
+  );
+
+  const resultNode: RelationalPlanNode = dmlExecutorNode;
+
+  if (stmt.returning && stmt.returning.length > 0) {
+    // Create returning scope with OLD/NEW attribute access
+    const returningScope = new RegisteredScope(deleteCtx.scope);
+
+    // Register OLD.* symbols (actual values being deleted)
+    oldAttributes.forEach((attr: any, columnIndex: any) => {
+      const tableColumn = tableReference.tableSchema.columns[columnIndex];
+      returningScope.registerSymbol(`old.${tableColumn.name.toLowerCase()}`, (exp, s) =>
+        new ColumnReferenceNode(s, exp as AST.ColumnExpr, attr.type, attr.id, columnIndex)
+      );
+    });
+
+    // Register NEW.* symbols (always NULL for DELETE) and unqualified column names (default to OLD for DELETE)
+    newAttributes.forEach((attr: any, columnIndex: any) => {
+      const tableColumn = tableReference.tableSchema.columns[columnIndex];
+
+      // NEW.column (always NULL for DELETE)
+      returningScope.registerSymbol(`new.${tableColumn.name.toLowerCase()}`, (exp, s) =>
+        new ColumnReferenceNode(s, exp as AST.ColumnExpr, attr.type, attr.id, columnIndex)
+      );
+
+      // Unqualified column (defaults to OLD for DELETE)
+      const oldAttr = oldAttributes[columnIndex];
+      returningScope.registerSymbol(tableColumn.name.toLowerCase(), (exp, s) =>
+        new ColumnReferenceNode(s, exp as AST.ColumnExpr, oldAttr.type, oldAttr.id, columnIndex)
+      );
+
+      // Table-qualified form (table.column -> OLD for DELETE)
+      const tblQualified = `${tableReference.tableSchema.name.toLowerCase()}.${tableColumn.name.toLowerCase()}`;
+      returningScope.registerSymbol(tblQualified, (exp, s) =>
+        new ColumnReferenceNode(s, exp as AST.ColumnExpr, oldAttr.type, oldAttr.id, columnIndex)
+      );
+    });
+
+    // Build RETURNING projections in the OLD/NEW context
+    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 OLD.id, normalize to lowercase
+        alias = rc.expr.table
+					? `${rc.expr.table.toLowerCase()}.${rc.expr.name.toLowerCase()}`
+					: rc.expr.name.toLowerCase();
+      }
+
+      return {
+        node: buildExpression({ ...deleteCtx, scope: returningScope }, rc.expr) as ScalarPlanNode,
+        alias: alias
+      };
+    });
+
+    return new ReturningNode(deleteCtx.scope, dmlExecutorNode, returningProjections);
+  }
+
+	return new SinkNode(deleteCtx.scope, resultNode, 'delete');
+}

package/src/planner/building/drop-assertion.ts

@@ -0,0 +1,11 @@
+import type { PlanningContext } from '../planning-context.js';
+import type * as AST from '../../parser/ast.js';
+import { DropAssertionNode } from '../nodes/drop-assertion-node.js';
+
+export function buildDropAssertionStmt(ctx: PlanningContext, stmt: AST.DropStmt): DropAssertionNode {
+	if (stmt.objectType !== 'assertion') {
+		throw new Error('Expected DROP ASSERTION statement');
+	}
+
+	return new DropAssertionNode(ctx.scope, stmt.name.name, stmt.ifExists);
+}

package/src/planner/building/expression.ts

@@ -199,6 +199,7 @@ export function buildExpression(ctx: PlanningContext, expr: AST.Expression, allo
 		}
 
 		default:
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
       throw new QuereusError(`Expression type '${(expr as any).type}' not yet supported in buildExpression.`, StatusCode.UNSUPPORTED, undefined, expr.loc?.start.line, expr.loc?.start.column);
   }
 }

package/src/planner/building/function-call.ts

@@ -9,13 +9,14 @@ import { isAggregateFunctionSchema } from '../../schema/function.js';
 import { buildExpression } from "./expression.js";
 import { ScalarFunctionCallNode } from "../nodes/function.js";
 import { resolveFunctionSchema } from "./schema-resolution.js";
+import { CapabilityDetectors } from '../framework/characteristics.js';
 
 export function buildFunctionCall(ctx: PlanningContext, expr: AST.FunctionExpr, allowAggregates: boolean): ScalarPlanNode {
 	// In HAVING context, check if this function matches an existing aggregate
 	if (ctx.aggregates && ctx.aggregates.length > 0) {
 		// Try to find a matching aggregate
 		for (const agg of ctx.aggregates) {
-			if (agg.expression instanceof AggregateFunctionCallNode) {
+			if (CapabilityDetectors.isAggregateFunction(agg.expression)) {
 				const aggFuncNode = agg.expression as AggregateFunctionCallNode;
 				// Check if function name matches and argument count matches
 				if (aggFuncNode.functionName.toLowerCase() === expr.name.toLowerCase() &&
@@ -26,13 +27,13 @@ export function buildFunctionCall(ctx: PlanningContext, expr: AST.FunctionExpr,
 						const exprArg = expr.args[i];
 						const aggArg = aggFuncNode.args[i];
 						// Simple check: if both are column references, check names match
-						if (exprArg.type === 'column' && (aggArg as any).expression?.type === 'column') {
-							if (exprArg.name.toLowerCase() !== (aggArg as any).expression.name.toLowerCase()) {
+						if (exprArg.type === 'column' && aggArg.expression?.type === 'column') {
+							if (exprArg.name.toLowerCase() !== aggArg.expression.name.toLowerCase()) {
 								argsMatch = false;
 								break;
 							}
-						} else if (exprArg.type === 'literal' && (aggArg as any).expression?.type === 'literal') {
-							if (exprArg.value !== (aggArg as any).expression.value) {
+						} else if (exprArg.type === 'literal' && aggArg.expression?.type === 'literal') {
+							if (exprArg.value !== aggArg.expression.value) {
 								argsMatch = false;
 								break;
 							}