@quereus/quereus 0.1.0

package/src/planner/analysis/constraint-extractor.ts

@@ -0,0 +1,277 @@
+/**
+ * Constraint extraction utilities for predicate analysis and VTab.xBestIndex
+ * Converts scalar expressions into constraints that can be pushed down to virtual tables
+ */
+
+import type { ScalarPlanNode } from '../nodes/plan-node.js';
+import { PlanNodeType } from '../nodes/plan-node-type.js';
+import type { ColumnReferenceNode } from '../nodes/reference.js';
+import type { SqlValue } from '../../common/types.js';
+import { LiteralNode } from '../nodes/scalar.js';
+
+/**
+ * Constraint operators that can be pushed down to virtual tables
+ */
+export type ConstraintOp = '=' | '>' | '>=' | '<' | '<=' | 'MATCH' | 'LIKE' | 'GLOB' | 'IS NULL' | 'IS NOT NULL';
+
+/**
+ * A constraint extracted from a predicate expression
+ */
+export interface PredicateConstraint {
+	/** Index of the column in the table schema */
+	columnIndex: number;
+	/** Attribute ID of the column reference */
+	attributeId: number;
+	/** Constraint operator */
+	op: ConstraintOp;
+	/** Constant value for the constraint (if applicable) */
+	value?: SqlValue;
+	/** Whether this constraint can be used by the virtual table */
+	usable: boolean;
+	/** Original expression node for debugging */
+	sourceExpression: ScalarPlanNode;
+}
+
+/**
+ * Result of constraint extraction
+ */
+export interface ConstraintExtractionResult {
+	/** Extracted constraints */
+	constraints: PredicateConstraint[];
+	/** Residual predicate that couldn't be converted to constraints */
+	residualPredicate?: ScalarPlanNode;
+}
+
+/**
+ * Extract constraints from a scalar predicate expression
+ * Currently handles simple binary comparisons and basic boolean logic
+ */
+export function extractConstraints(
+	predicate: ScalarPlanNode,
+	columnAttributeToIndex?: Map<number, number>
+): ConstraintExtractionResult {
+	const constraints: PredicateConstraint[] = [];
+	const residualExpressions: ScalarPlanNode[] = [];
+
+	// Start extraction process
+	extractFromExpression(predicate, constraints, residualExpressions, columnAttributeToIndex);
+
+	// Build residual predicate from unmatched expressions
+	let residualPredicate: ScalarPlanNode | undefined;
+	if (residualExpressions.length === 1) {
+		residualPredicate = residualExpressions[0];
+	} else if (residualExpressions.length > 1) {
+		// For now, combine with AND - more sophisticated logic can be added later
+		residualPredicate = combineWithAnd(residualExpressions);
+	}
+
+	return {
+		constraints,
+		residualPredicate
+	};
+}
+
+/**
+ * Recursively extract constraints from an expression
+ */
+function extractFromExpression(
+	expr: ScalarPlanNode,
+	constraints: PredicateConstraint[],
+	residual: ScalarPlanNode[],
+	columnAttributeToIndex?: Map<number, number>
+): void {
+	// Handle AND expressions - recurse on both sides
+	if (isAndExpression(expr)) {
+		const children = getBinaryExpressionChildren(expr);
+		if (children) {
+			extractFromExpression(children.left, constraints, residual, columnAttributeToIndex);
+			extractFromExpression(children.right, constraints, residual, columnAttributeToIndex);
+			return;
+		}
+	}
+
+	// Try to extract constraint from binary comparison
+	const constraint = extractBinaryConstraint(expr, columnAttributeToIndex);
+	if (constraint) {
+		constraints.push(constraint);
+	} else {
+		// Cannot convert to constraint - add to residual
+		residual.push(expr);
+	}
+}
+
+/**
+ * Extract constraint from binary comparison expression
+ */
+function extractBinaryConstraint(
+	expr: ScalarPlanNode,
+	columnAttributeToIndex?: Map<number, number>
+): PredicateConstraint | null {
+	const binaryInfo = getBinaryComparisonInfo(expr);
+	if (!binaryInfo) {
+		return null;
+	}
+
+	const { left, right, op } = binaryInfo;
+
+	// Try column-constant pattern (column op constant)
+	let columnRef: ColumnReferenceNode | null = null;
+	let constant: SqlValue | undefined;
+	let constraintOp = op;
+
+	if (isColumnReference(left) && isLiteralConstant(right)) {
+		columnRef = left;
+		constant = getLiteralValue(right);
+	} else if (isLiteralConstant(left) && isColumnReference(right)) {
+		// Reverse pattern (constant op column) - flip operator
+		columnRef = right;
+		constant = getLiteralValue(left);
+		constraintOp = flipOperator(op);
+	}
+
+	if (!columnRef) {
+		return null;
+	}
+
+	// Map attribute ID to column index if mapping provided
+	let columnIndex = -1;
+	if (columnAttributeToIndex) {
+		const mappedIndex = columnAttributeToIndex.get(columnRef.attributeId);
+		if (mappedIndex !== undefined) {
+			columnIndex = mappedIndex;
+		}
+	}
+
+	return {
+		columnIndex,
+		attributeId: columnRef.attributeId,
+		op: constraintOp,
+		value: constant,
+		usable: columnIndex >= 0, // Only usable if we can map to column index
+		sourceExpression: expr
+	};
+}
+
+/**
+ * Get information about binary comparison expressions
+ */
+function getBinaryComparisonInfo(expr: ScalarPlanNode): {
+	left: ScalarPlanNode;
+	right: ScalarPlanNode;
+	op: ConstraintOp;
+} | null {
+	// This is a simplified version - real implementation would need to handle
+	// the actual binary expression node structure
+	if (expr.nodeType === PlanNodeType.BinaryOp) {
+		// Extract from actual binary expression node
+		// This would need to be implemented based on the actual BinaryOpNode structure
+		// For now, return null as placeholder
+		return null;
+	}
+	return null;
+}
+
+/**
+ * Check if expression is an AND operation
+ */
+function isAndExpression(expr: ScalarPlanNode): boolean {
+	// Simplified check - would need actual implementation
+	return expr.nodeType === PlanNodeType.BinaryOp;
+}
+
+/**
+ * Get children of binary expression
+ */
+function getBinaryExpressionChildren(_expr: ScalarPlanNode): {
+	left: ScalarPlanNode;
+	right: ScalarPlanNode;
+} | null {
+	// Simplified - would need actual implementation
+	return null;
+}
+
+/**
+ * Check if node is a column reference
+ */
+function isColumnReference(node: ScalarPlanNode): node is ColumnReferenceNode {
+	return node.nodeType === PlanNodeType.ColumnReference;
+}
+
+/**
+ * Check if node is a literal constant
+ */
+function isLiteralConstant(node: ScalarPlanNode): node is LiteralNode {
+	return node.nodeType === PlanNodeType.Literal;
+}
+
+/**
+ * Get literal value from literal node
+ */
+function getLiteralValue(_node: ScalarPlanNode): SqlValue {
+	// Simplified - would need actual implementation
+	return null;
+}
+
+/**
+ * Flip comparison operator for reversed operand order
+ */
+function flipOperator(op: ConstraintOp): ConstraintOp {
+	switch (op) {
+		case '<': return '>';
+		case '<=': return '>=';
+		case '>': return '<';
+		case '>=': return '<=';
+		case '=': return '=';
+		default: return op;
+	}
+}
+
+/**
+ * Combine multiple expressions with AND logic
+ */
+function combineWithAnd(expressions: ScalarPlanNode[]): ScalarPlanNode {
+	// This would need to create an actual AND expression node
+	// For now, return the first expression as placeholder
+	return expressions[0];
+}
+
+/**
+ * Create a residual filter predicate from constraints that weren't handled
+ * This allows creating a filter function that can be applied at runtime
+ */
+export function createResidualFilter(
+	originalPredicate: ScalarPlanNode,
+	handledConstraints: PredicateConstraint[]
+): ((row: any) => boolean) | undefined {
+	// If all constraints were handled, no residual filter needed
+	if (handledConstraints.length === 0) {
+		// Return a simple function that evaluates the original predicate
+		// This is a placeholder - real implementation would need to compile the predicate
+		return (_row: any) => true;
+	}
+
+	// For now, return undefined to indicate no residual filter
+	// Real implementation would create a runtime-evaluable filter function
+	return undefined;
+}
+
+/**
+ * Utility to map table schema columns to attribute IDs
+ * Used when extracting constraints for specific tables
+ */
+export function createColumnMapping(
+	tableColumns: Array<{ name: string }>,
+	nodeAttributes: Array<{ id: number; name: string }>
+): Map<number, number> {
+	const mapping = new Map<number, number>();
+
+	// Simple name-based mapping
+	for (const attr of nodeAttributes) {
+		const columnIndex = tableColumns.findIndex(col => col.name === attr.name);
+		if (columnIndex >= 0) {
+			mapping.set(attr.id, columnIndex);
+		}
+	}
+
+	return mapping;
+}

package/src/planner/building/alter-table.ts

@@ -0,0 +1,47 @@
+import type * as AST from '../../parser/ast.js';
+import type { PlanningContext } from '../planning-context.js';
+import { AddConstraintNode } from '../nodes/add-constraint-node.js';
+import { buildTableReference } from './table.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+import type { VoidNode } from '../nodes/plan-node.js';
+
+export function buildAlterTableStmt(
+  ctx: PlanningContext,
+  stmt: AST.AlterTableStmt,
+): VoidNode {
+  const tableReference = buildTableReference({ type: 'table', table: stmt.table }, ctx);
+
+  switch (stmt.action.type) {
+    case 'addConstraint': {
+      // Convert RowOp[] (e.g., ['insert','update']) to bitmask understood by runtime.
+      const operations = stmt.action.constraint.operations ?? ['insert','update'];
+
+      const constraintWithBitmask = {
+        ...stmt.action.constraint,
+        operations
+      };
+
+      return new AddConstraintNode(
+        ctx.scope,
+        tableReference,
+        constraintWithBitmask
+      );
+		}
+
+    case 'renameTable':
+    case 'renameColumn':
+    case 'addColumn':
+    case 'dropColumn':
+      throw new QuereusError(
+        `ALTER TABLE ${stmt.action.type} is not yet implemented`,
+        StatusCode.UNSUPPORTED
+      );
+
+    default:
+      throw new QuereusError(
+        `Unknown ALTER TABLE action: ${(stmt.action as any).type}`,
+        StatusCode.INTERNAL
+      );
+  }
+}

package/src/planner/building/block.ts

@@ -0,0 +1,78 @@
+import { BlockNode } from '../nodes/block.js';
+import * as AST from '../../parser/ast.js';
+import type { PlanNode } from '../nodes/plan-node.js';
+import { buildSelectStmt } from './select.js';
+import type { PlanningContext } from '../planning-context.js';
+import { buildCreateTableStmt } from './ddl.js';
+import { buildCreateIndexStmt } from './ddl.js';
+import { buildDropTableStmt } from './drop-table.js';
+import { buildCreateViewStmt } from './create-view.js';
+import { buildDropViewStmt } from './drop-view.js';
+import { buildInsertStmt } from './insert.js';
+import { buildUpdateStmt } from './update.js';
+import { buildDeleteStmt } from './delete.js';
+import { buildAlterTableStmt } from './alter-table.js';
+import { buildBeginStmt, buildCommitStmt, buildRollbackStmt, buildSavepointStmt, buildReleaseStmt } from './transaction.js';
+import { buildPragmaStmt } from './pragma.js';
+import { buildValuesStmt } from './select.js';
+import { quereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+
+export function buildBlock(ctx: PlanningContext, statements: AST.Statement[]): BlockNode {
+	const plannedStatements = statements.map((stmt) => {
+		switch (stmt.type) {
+			case 'select':
+				// buildSelectStmt returns a BatchNode, which is a PlanNode.
+				return buildSelectStmt(ctx, stmt as AST.SelectStmt);
+			case 'createTable':
+				return buildCreateTableStmt(ctx, stmt as AST.CreateTableStmt);
+			case 'createIndex':
+				return buildCreateIndexStmt(ctx, stmt as AST.CreateIndexStmt);
+			case 'createView':
+				return buildCreateViewStmt(ctx, stmt as AST.CreateViewStmt);
+			case 'drop':
+				if (stmt.objectType === 'table') {
+					return buildDropTableStmt(ctx, stmt as AST.DropStmt);
+				} else if (stmt.objectType === 'view') {
+					return buildDropViewStmt(ctx, stmt as AST.DropStmt);
+				}
+				break;
+			case 'insert':
+				return buildInsertStmt(ctx, stmt as AST.InsertStmt);
+			case 'update':
+				return buildUpdateStmt(ctx, stmt as AST.UpdateStmt);
+			case 'delete':
+				return buildDeleteStmt(ctx, stmt as AST.DeleteStmt);
+			case 'begin':
+				return buildBeginStmt(ctx, stmt as AST.BeginStmt);
+			case 'commit':
+				return buildCommitStmt(ctx, stmt as AST.CommitStmt);
+			case 'rollback':
+				return buildRollbackStmt(ctx, stmt as AST.RollbackStmt);
+			case 'savepoint':
+				return buildSavepointStmt(ctx, stmt as AST.SavepointStmt);
+			case 'release':
+				return buildReleaseStmt(ctx, stmt as AST.ReleaseStmt);
+			case 'pragma':
+				return buildPragmaStmt(ctx, stmt as AST.PragmaStmt);
+			case 'alterTable':
+				return buildAlterTableStmt(ctx, stmt as AST.AlterTableStmt);
+			case 'values':
+				return buildValuesStmt(ctx, stmt as AST.ValuesStmt);
+			default:
+				// Throw an exception for unsupported statement types
+				quereusError(
+					`Unsupported statement type: ${(stmt as AST.Statement).type}`,
+					StatusCode.UNSUPPORTED,
+					undefined,
+					stmt
+				);
+		}
+	}).filter(p => p !== undefined) as PlanNode[]; // Ensure we only have valid PlanNodes and cast
+
+    // The final BatchNode for the entire batch.
+    // Its scope is batchParameterScope, and it contains all successfully planned statements.
+	return new BlockNode(ctx.scope, plannedStatements, { ...ctx.parameters });
+}
+
+

package/src/planner/building/create-view.ts

@@ -0,0 +1,56 @@
+import type * as AST from '../../parser/ast.js';
+import type { PlanningContext } from '../planning-context.js';
+import { CreateViewNode } from '../nodes/create-view-node.js';
+
+/**
+ * Builds a plan node for CREATE VIEW statements.
+ */
+export function buildCreateViewStmt(ctx: PlanningContext, stmt: AST.CreateViewStmt): CreateViewNode {
+	// Extract schema and view name
+	const schemaName = stmt.view.schema || 'main';
+	const viewName = stmt.view.name;
+
+	// The original SQL text is needed for the view definition
+	// For now, we'll reconstruct it from the AST
+	// In a full implementation, this should be preserved from the original input
+	const sql = reconstructViewSQL(stmt);
+
+	return new CreateViewNode(
+		ctx.scope,
+		viewName,
+		schemaName,
+		stmt.ifNotExists,
+		stmt.columns,
+		stmt.select,
+		sql
+	);
+}
+
+/**
+ * Reconstructs the original SQL text for a CREATE VIEW statement.
+ * This is a simplified version - in production, the original text should be preserved.
+ */
+function reconstructViewSQL(stmt: AST.CreateViewStmt): string {
+	let sql = 'CREATE VIEW ';
+
+	if (stmt.ifNotExists) {
+		sql += 'IF NOT EXISTS ';
+	}
+
+	if (stmt.view.schema) {
+		sql += `${stmt.view.schema}.`;
+	}
+	sql += stmt.view.name;
+
+	if (stmt.columns && stmt.columns.length > 0) {
+		sql += ` (${stmt.columns.join(', ')})`;
+	}
+
+	sql += ' AS ';
+
+	// For now, just add a placeholder for the SELECT statement
+	// In a full implementation, this would reconstruct the full SELECT
+	sql += '(SELECT statement)';
+
+	return sql;
+}

package/src/planner/building/ddl.ts

@@ -0,0 +1,24 @@
+import type * as AST from '../../parser/ast.js';
+import type { PlanningContext } from '../planning-context.js';
+import { CreateTableNode } from '../nodes/create-table-node.js';
+import { CreateIndexNode } from '../nodes/create-index-node.js';
+
+export function buildCreateTableStmt(
+  context: PlanningContext,
+  stmt: AST.CreateTableStmt,
+): CreateTableNode {
+  return new CreateTableNode(
+    context.scope,
+    stmt,
+  );
+}
+
+export function buildCreateIndexStmt(
+	context: PlanningContext,
+	stmt: AST.CreateIndexStmt
+): CreateIndexNode {
+	return new CreateIndexNode(
+		context.scope,
+		stmt
+	);
+}

package/src/planner/building/delete.ts

@@ -0,0 +1,158 @@
+import type * as AST from '../../parser/ast.js';
+import type { PlanningContext } from '../planning-context.js';
+import { DeleteNode } from '../nodes/delete-node.js';
+import { buildTableReference, buildTableScan } 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 { RowOp } 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';
+
+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 = buildTableScan({ 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);
+
+  // Always inject ConstraintCheckNode for DELETE operations
+  const constraintCheckNode = new ConstraintCheckNode(
+    deleteCtx.scope,
+    sourceNode,
+    tableReference,
+    RowOp.DELETE,
+    oldRowDescriptor,
+    newRowDescriptor
+  );
+
+  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');
+}

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

@@ -0,0 +1,13 @@
+import type * as AST from '../../parser/ast.js';
+import type { PlanningContext } from '../planning-context.js';
+import { DropTableNode } from '../nodes/drop-table-node.js';
+
+export function buildDropTableStmt(
+  ctx: PlanningContext,
+  stmt: AST.DropStmt,
+): DropTableNode {
+  return new DropTableNode(
+    ctx.scope,
+    stmt,
+  );
+}

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

@@ -0,0 +1,19 @@
+import type * as AST from '../../parser/ast.js';
+import type { PlanningContext } from '../planning-context.js';
+import { DropViewNode } from '../nodes/drop-view-node.js';
+
+/**
+ * Builds a plan node for DROP VIEW statements.
+ */
+export function buildDropViewStmt(ctx: PlanningContext, stmt: AST.DropStmt): DropViewNode {
+	// Extract schema and view name
+	const schemaName = stmt.name.schema || 'main';
+	const viewName = stmt.name.name;
+
+	return new DropViewNode(
+		ctx.scope,
+		viewName,
+		schemaName,
+		stmt.ifExists
+	);
+}