@quereus/quereus 0.7.3 → 0.7.4

package/src/planner/analysis/predicate-normalizer.ts

@@ -1,237 +0,0 @@
-import type { ScalarPlanNode } from '../nodes/plan-node.js';
-import { PlanNodeType } from '../nodes/plan-node-type.js';
-import { BinaryOpNode, UnaryOpNode, LiteralNode, BetweenNode } from '../nodes/scalar.js';
-import { ColumnReferenceNode } from '../nodes/reference.js';
-import { InNode } from '../nodes/subquery.js';
-import type * as AST from '../../parser/ast.js';
-
-/**
- * Normalize a predicate for push-down and constraint extraction.
- *
- * Transformations (conservative, no CNF/DNF expansion):
- * - Push NOT down (De Morgan) for AND/OR and double-negation elimination
- * - Invert simple comparisons under NOT (>, >=, <, <=)
- * - Canonicalize nested AND/OR by flattening binary trees
- * - Normalize child predicates recursively
- *
- * Notes:
- * - We intentionally do NOT distribute OR over AND (to avoid blow-ups)
- * - NOT of equality becomes "!="; extractor treats it as residual (acceptable)
- * - NOT of BETWEEN toggles the node's 'not' flag
- */
-export function normalizePredicate(expr: ScalarPlanNode): ScalarPlanNode {
-    return normalize(expr);
-}
-
-function normalize(node: ScalarPlanNode): ScalarPlanNode {
-    switch (node.nodeType) {
-        case PlanNodeType.UnaryOp: {
-            const u = node as UnaryOpNode;
-            if (u.expression.operator === 'NOT') {
-                return pushNotDown(u.operand);
-            }
-            // Recurse
-            const normalizedOperand = normalize(u.operand);
-            return normalizedOperand === u.operand
-                ? u
-                : new UnaryOpNode(u.scope, u.expression, normalizedOperand);
-        }
-        case PlanNodeType.BinaryOp: {
-            const b = node as BinaryOpNode;
-            const op = b.expression.operator;
-            if (op === 'AND' || op === 'OR') {
-                // Normalize children first
-                const left = normalize(b.left);
-                const right = normalize(b.right);
-                // Flatten nested same-op nodes
-                const parts = collectAssociative(op, [left, right]);
-                if (op === 'OR') {
-                    const collapsed = tryCollapseOrToIn(b.scope, parts);
-                    if (collapsed) return collapsed;
-                }
-                return rebuildAssociative(b.scope, op, parts, b.expression);
-            }
-            // Other binary ops: normalize children only
-            const nLeft = normalize(b.left);
-            const nRight = normalize(b.right);
-            if (nLeft === b.left && nRight === b.right) {
-                return b;
-            }
-            return new BinaryOpNode(b.scope, b.expression, nLeft, nRight);
-        }
-        case PlanNodeType.Between: {
-            // Normalize sub-expressions only
-            const bt = node as BetweenNode;
-            const nExpr = normalize(bt.expr);
-            const nLower = normalize(bt.lower);
-            const nUpper = normalize(bt.upper);
-            if (nExpr === bt.expr && nLower === bt.lower && nUpper === bt.upper) {
-                return bt;
-            }
-            return new BetweenNode(bt.scope, bt.expression, nExpr, nLower, nUpper);
-        }
-        default:
-            return node;
-    }
-}
-
-function pushNotDown(node: ScalarPlanNode): ScalarPlanNode {
-    // NOT over NOT
-    if (node.nodeType === PlanNodeType.UnaryOp) {
-        const u = node as UnaryOpNode;
-        if (u.expression.operator === 'NOT') {
-            return normalize(u.operand);
-        }
-        // NOT over other unary ops: leave as residual NOT(op)
-        const nOp = normalize(u.operand);
-        return nOp === u.operand ? new UnaryOpNode(u.scope, u.expression, nOp) : new UnaryOpNode(u.scope, u.expression, nOp);
-    }
-
-    if (node.nodeType === PlanNodeType.BinaryOp) {
-        const b = node as BinaryOpNode;
-        const op = b.expression.operator;
-        // De Morgan for boolean connectives
-        if (op === 'AND' || op === 'OR') {
-            const negLeft = pushNotDown(b.left);
-            const negRight = pushNotDown(b.right);
-            const flipped = op === 'AND' ? 'OR' : 'AND';
-            const expr: AST.BinaryExpr = { type: 'binary', operator: flipped, left: (b.expression.left as AST.Expression), right: (b.expression.right as AST.Expression) };
-            // Rebuild and normalize/flatten
-            const combined = rebuildAssociative(b.scope, flipped, [negLeft, negRight], expr);
-            return combined;
-        }
-
-        // Invert simple comparisons
-        const inverted = invertComparisonIfPossible(b);
-        if (inverted) {
-            return normalize(inverted);
-        }
-
-        // Otherwise, keep as NOT(binary) by wrapping a NOT
-        const normalizedLeft = normalize(b.left);
-        const normalizedRight = normalize(b.right);
-        const rebuilt = (normalizedLeft === b.left && normalizedRight === b.right)
-            ? b
-            : new BinaryOpNode(b.scope, b.expression, normalizedLeft, normalizedRight);
-        const notAst: AST.UnaryExpr = { type: 'unary', operator: 'NOT', expr: b.expression };
-        return new UnaryOpNode(b.scope, notAst, rebuilt);
-    }
-
-    if (node.nodeType === PlanNodeType.Between) {
-        // Toggle the NOT flag on BETWEEN
-        const bt = node as BetweenNode;
-        const ast: AST.BetweenExpr = { ...bt.expression, not: !bt.expression.not };
-        const nExpr = normalize(bt.expr);
-        const nLower = normalize(bt.lower);
-        const nUpper = normalize(bt.upper);
-        return new BetweenNode(bt.scope, ast, nExpr, nLower, nUpper);
-    }
-
-    // Generic fallback: NOT(expr) as unary
-    const notAst: AST.UnaryExpr = { type: 'unary', operator: 'NOT', expr: (node as any).expression };
-    return new UnaryOpNode((node as any).scope, notAst, normalize(node));
-}
-
-function collectAssociative(op: string, parts: ScalarPlanNode[]): ScalarPlanNode[] {
-    const result: ScalarPlanNode[] = [];
-    for (const p of parts) {
-        if (p.nodeType === PlanNodeType.BinaryOp) {
-            const b = p as BinaryOpNode;
-            if (b.expression.operator === op) {
-                result.push(...collectAssociative(op, [b.left, b.right]));
-                continue;
-            }
-        }
-        result.push(p);
-    }
-    return result;
-}
-
-function rebuildAssociative(scope: any, op: string, parts: ScalarPlanNode[], baseExpr: AST.BinaryExpr): ScalarPlanNode {
-    if (parts.length === 0) {
-        // Degenerate; shouldn't happen
-        return new LiteralNode(scope, { type: 'literal', value: 1 });
-    }
-    if (parts.length === 1) {
-        return parts[0];
-    }
-    // Left-associative rebuild
-    let acc = parts[0];
-    for (let i = 1; i < parts.length; i++) {
-        const right = parts[i];
-        const newAst: AST.BinaryExpr = { type: 'binary', operator: op, left: (acc as any).expression ?? baseExpr.left, right: (right as any).expression ?? baseExpr.right };
-        acc = new BinaryOpNode(scope, newAst, acc, right);
-    }
-    return acc;
-}
-
-function invertComparisonIfPossible(b: BinaryOpNode): ScalarPlanNode | null {
-    const op = b.expression.operator;
-    const flippedOp = flipComparison(op);
-    if (!flippedOp) {
-        return null;
-    }
-    const ast: AST.BinaryExpr = { type: 'binary', operator: flippedOp, left: b.expression.left, right: b.expression.right };
-    return new BinaryOpNode(b.scope, ast, b.left, b.right);
-}
-
-function flipComparison(op: string): string | null {
-    switch (op) {
-        case '>': return '<=';
-        case '>=': return '<';
-        case '<': return '>=';
-        case '<=': return '>';
-        case '=': return '!='; // extractor will treat as residual; acceptable
-        default: return null;
-    }
-}
-
-// Attempt to collapse OR of equalities into an IN list when:
-// - All disjuncts are of the form (col = literal)
-// - The same column is used
-// - Literal list is small (<= 32) to avoid large INs
-function tryCollapseOrToIn(scope: any, disjuncts: ScalarPlanNode[]): ScalarPlanNode | null {
-    const values: LiteralNode[] = [];
-    let column: ColumnReferenceNode | null = null;
-
-    for (const d of disjuncts) {
-        if (d.nodeType !== PlanNodeType.BinaryOp) return null;
-        const b = d as BinaryOpNode;
-        if (b.expression.operator !== '=') return null;
-
-        // Two patterns: col = lit OR lit = col
-        let col: ColumnReferenceNode | null = null;
-        let lit: LiteralNode | null = null;
-        if (b.left.nodeType === PlanNodeType.ColumnReference && b.right.nodeType === PlanNodeType.Literal) {
-            col = b.left as ColumnReferenceNode;
-            lit = b.right as LiteralNode;
-        } else if (b.left.nodeType === PlanNodeType.Literal && b.right.nodeType === PlanNodeType.ColumnReference) {
-            col = b.right as ColumnReferenceNode;
-            lit = b.left as LiteralNode;
-        } else {
-            return null;
-        }
-
-        if (!column) {
-            column = col;
-        } else if (column.attributeId !== col.attributeId) {
-            return null;
-        }
-
-        values.push(lit);
-        if (values.length > 32) return null; // avoid creating huge IN lists
-    }
-
-    if (!column || values.length === 0) return null;
-
-    // Build an InNode with constant values
-    const ast: AST.InExpr = {
-        type: 'in',
-        expr: (column as any).expression,
-        values: values.map(v => (v as any).expression)
-    };
-    const inNode = new InNode((column as any).scope, ast, column, undefined, values);
-    return inNode;
-}
-
-

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

@@ -1,49 +0,0 @@
-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 tableRetrieve = buildTableReference({ type: 'table', table: stmt.table }, ctx);
-  const tableReference = tableRetrieve.tableRef; // Extract the actual TableReferenceNode
-
-  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(
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        `Unknown ALTER TABLE action: ${(stmt.action as any).type}`,
-        StatusCode.INTERNAL
-      );
-  }
-}

package/src/planner/building/block.ts

@@ -1,93 +0,0 @@
-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 { buildCreateAssertionStmt } from './create-assertion.js';
-import { buildDropAssertionStmt } from './drop-assertion.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';
-import { buildDeclareSchemaStmt, buildDiffSchemaStmt, buildApplySchemaStmt, buildExplainSchemaStmt } from './declare-schema.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 'createAssertion':
-				return buildCreateAssertionStmt(ctx, stmt as AST.CreateAssertionStmt);
-			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);
-				} else if (stmt.objectType === 'assertion') {
-					return buildDropAssertionStmt(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);
-			case 'declareSchema':
-				return buildDeclareSchemaStmt(ctx, stmt as unknown as AST.DeclareSchemaStmt);
-			case 'diffSchema':
-				return buildDiffSchemaStmt(ctx, stmt as unknown as AST.DiffSchemaStmt);
-			case 'applySchema':
-				return buildApplySchemaStmt(ctx, stmt as unknown as AST.ApplySchemaStmt);
-			case 'explainSchema':
-				return buildExplainSchemaStmt(ctx, stmt as unknown as AST.ExplainSchemaStmt);
-			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/constraint-builder.ts

@@ -1,178 +0,0 @@
-import type { PlanningContext } from '../planning-context.js';
-import type { TableSchema, RowConstraintSchema } from '../../schema/table.js';
-import type { RowOpFlag } from '../../schema/table.js';
-import type { Attribute, RowDescriptor } from '../nodes/plan-node.js';
-import type { ConstraintCheck } from '../nodes/constraint-check-node.js';
-import { RegisteredScope } from '../scopes/registered.js';
-import { buildExpression } from './expression.js';
-import { PlanNodeType } from '../nodes/plan-node-type.js';
-import { ColumnReferenceNode } from '../nodes/reference.js';
-import type { ScalarPlanNode } from '../nodes/plan-node.js';
-import * as AST from '../../parser/ast.js';
-import { validateDeterministicConstraint } from '../validation/determinism-validator.js';
-
-/**
- * Determines if a constraint should be checked for the given operation
- */
-function shouldCheckConstraint(constraint: RowConstraintSchema, operation: RowOpFlag): boolean {
-  // Check if the current operation is in the constraint's operations bitmask
-  return (constraint.operations & operation) !== 0;
-}
-
-/**
- * Builds constraint check expressions at plan time.
- * This allows the optimizer to see and optimize constraint expressions.
- */
-export function buildConstraintChecks(
-  ctx: PlanningContext,
-  tableSchema: TableSchema,
-  operation: RowOpFlag,
-  oldAttributes: Attribute[],
-  newAttributes: Attribute[],
-  _flatRowDescriptor: RowDescriptor,
-  contextAttributes: Attribute[] = []
-): ConstraintCheck[] {
-  // Build attribute ID mappings for column registration
-  const newAttrIdByCol: Record<string, number> = {};
-  const oldAttrIdByCol: Record<string, number> = {};
-
-  newAttributes.forEach((attr, columnIndex) => {
-    if (columnIndex < tableSchema.columns.length) {
-      const column = tableSchema.columns[columnIndex];
-      newAttrIdByCol[column.name.toLowerCase()] = attr.id;
-    }
-  });
-
-  oldAttributes.forEach((attr, columnIndex) => {
-    if (columnIndex < tableSchema.columns.length) {
-      const column = tableSchema.columns[columnIndex];
-      oldAttrIdByCol[column.name.toLowerCase()] = attr.id;
-    }
-  });
-
-  // Filter constraints by operation
-  const applicableConstraints = tableSchema.checkConstraints
-    .filter(constraint => shouldCheckConstraint(constraint, operation));
-
-  // Build expression nodes for each constraint
-  return applicableConstraints.map(constraint => {
-    // Create scope with OLD/NEW column access for constraint evaluation
-    const constraintScope = new RegisteredScope(ctx.scope);
-
-    // Register mutation context variables FIRST (so they shadow column names if conflicts exist)
-    contextAttributes.forEach((attr, contextVarIndex) => {
-      if (contextVarIndex < (tableSchema.mutationContext?.length || 0)) {
-        const contextVar = tableSchema.mutationContext![contextVarIndex];
-        const varNameLower = contextVar.name.toLowerCase();
-
-        // Register both unqualified and qualified names
-        constraintScope.subscribeFactory(varNameLower, (exp, s) =>
-          new ColumnReferenceNode(s, exp as AST.ColumnExpr, attr.type, attr.id, contextVarIndex)
-        );
-        constraintScope.subscribeFactory(`context.${varNameLower}`, (exp, s) =>
-          new ColumnReferenceNode(s, exp as AST.ColumnExpr, attr.type, attr.id, contextVarIndex)
-        );
-      }
-    });
-
-    // Register column symbols (similar to current emitConstraintCheck logic)
-    tableSchema.columns.forEach((tableColumn, tableColIndex) => {
-      const colNameLower = tableColumn.name.toLowerCase();
-
-      // Register NEW.col and unqualified col (defaults to NEW for INSERT/UPDATE, OLD for DELETE)
-      const newAttrId = newAttrIdByCol[colNameLower];
-      if (newAttrId !== undefined) {
-        const newColumnType = {
-          typeClass: 'scalar' as const,
-          logicalType: tableColumn.logicalType,
-          nullable: !tableColumn.notNull,
-          isReadOnly: false
-        };
-
-        // NEW.column
-        constraintScope.registerSymbol(`new.${colNameLower}`, (exp, s) =>
-          new ColumnReferenceNode(s, exp as AST.ColumnExpr, newColumnType, newAttrId, tableColIndex));
-
-        // For INSERT/UPDATE, unqualified column defaults to NEW
-        if (operation === 1 || operation === 2) { // INSERT or UPDATE
-          constraintScope.registerSymbol(colNameLower, (exp, s) =>
-            new ColumnReferenceNode(s, exp as AST.ColumnExpr, newColumnType, newAttrId, tableColIndex));
-        }
-      }
-
-      // Register OLD.col
-      const oldAttrId = oldAttrIdByCol[colNameLower];
-      if (oldAttrId !== undefined) {
-        const oldColumnType = {
-          typeClass: 'scalar' as const,
-          logicalType: tableColumn.logicalType,
-          nullable: true, // OLD values can be NULL (especially for INSERT)
-          isReadOnly: false
-        };
-
-        // OLD.column
-        constraintScope.registerSymbol(`old.${colNameLower}`, (exp, s) =>
-          new ColumnReferenceNode(s, exp as AST.ColumnExpr, oldColumnType, oldAttrId, tableColIndex));
-
-        // For DELETE, unqualified column defaults to OLD
-        if (operation === 4) { // DELETE
-          constraintScope.registerSymbol(colNameLower, (exp, s) =>
-            new ColumnReferenceNode(s, exp as AST.ColumnExpr, oldColumnType, oldAttrId, tableColIndex));
-        }
-      }
-    });
-
-    // Build the constraint expression using the specialized scope
-    // Temporarily set the current schema to match the table's schema
-    // This ensures unqualified table references in CHECK constraints resolve correctly
-    const originalCurrentSchema = ctx.schemaManager.getCurrentSchemaName();
-    const needsSchemaSwitch = tableSchema.schemaName !== originalCurrentSchema;
-
-    if (needsSchemaSwitch) {
-      ctx.schemaManager.setCurrentSchema(tableSchema.schemaName);
-    }
-
-    try {
-      const expression = buildExpression(
-        { ...ctx, scope: constraintScope },
-        constraint.expr
-      ) as ScalarPlanNode;
-
-      // Validate that the constraint expression is deterministic
-      const constraintName = constraint.name ?? `_check_${tableSchema.name}`;
-      validateDeterministicConstraint(expression, constraintName, tableSchema.name);
-
-      // Heuristic: auto-defer if the expression contains a subquery
-      // or references a different relation via attribute bindings (NEW/OLD already localized).
-      const needsDeferred = containsSubquery(expression);
-
-      return {
-        constraint,
-        expression,
-        deferrable: needsDeferred,
-        initiallyDeferred: needsDeferred,
-        containsSubquery: needsDeferred
-      } satisfies ConstraintCheck;
-    } finally {
-      // Restore original schema context
-      if (needsSchemaSwitch) {
-        ctx.schemaManager.setCurrentSchema(originalCurrentSchema);
-      }
-    }
-  });
-}
-
-function containsSubquery(expr: ScalarPlanNode): boolean {
-  const stack: ScalarPlanNode[] = [expr];
-  while (stack.length) {
-    const n = stack.pop()!;
-    if (n.nodeType === PlanNodeType.ScalarSubquery || n.nodeType === PlanNodeType.Exists) {
-      return true;
-    }
-    for (const c of n.getChildren()) {
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
-      stack.push(c as any);
-    }
-  }
-  return false;
-}

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

@@ -1,7 +0,0 @@
-import type { PlanningContext } from '../planning-context.js';
-import type * as AST from '../../parser/ast.js';
-import { CreateAssertionNode } from '../nodes/create-assertion-node.js';
-
-export function buildCreateAssertionStmt(ctx: PlanningContext, stmt: AST.CreateAssertionStmt): CreateAssertionNode {
-	return new CreateAssertionNode(ctx.scope, stmt.name, stmt.check);
-}

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

@@ -1,29 +0,0 @@
-import type * as AST from '../../parser/ast.js';
-import type { PlanningContext } from '../planning-context.js';
-import { CreateViewNode } from '../nodes/create-view-node.js';
-import { createViewToString } from '../../util/ast-stringify.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
-	// Reconstruct it from the AST using the proper stringifier
-	const sql = createViewToString(stmt);
-
-	return new CreateViewNode(
-		ctx.scope,
-		viewName,
-		schemaName,
-		stmt.ifNotExists,
-		stmt.columns,
-		stmt.select,
-		sql
-	);
-}
-
-

package/src/planner/building/ddl.ts

@@ -1,24 +0,0 @@
-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/declare-schema.ts

@@ -1,22 +0,0 @@
-import type * as AST from '../../parser/ast.js';
-import type { PlanningContext } from '../planning-context.js';
-import type { PlanNode } from '../nodes/plan-node.js';
-import { DeclareSchemaNode, DiffSchemaNode, ApplySchemaNode, ExplainSchemaNode } from '../nodes/declarative-schema.js';
-
-export function buildDeclareSchemaStmt(ctx: PlanningContext, stmt: AST.DeclareSchemaStmt): PlanNode {
-	return new DeclareSchemaNode(ctx.scope, stmt);
-}
-
-export function buildDiffSchemaStmt(ctx: PlanningContext, stmt: AST.DiffSchemaStmt): PlanNode {
-	return new DiffSchemaNode(ctx.scope, stmt);
-}
-
-export function buildApplySchemaStmt(ctx: PlanningContext, stmt: AST.ApplySchemaStmt): PlanNode {
-	return new ApplySchemaNode(ctx.scope, stmt);
-}
-
-export function buildExplainSchemaStmt(ctx: PlanningContext, stmt: AST.ExplainSchemaStmt): PlanNode {
-	return new ExplainSchemaNode(ctx.scope, stmt);
-}
-
-