@quereus/quereus 0.1.0

package/dist/src/planner/analysis/const-pass.js

@@ -0,0 +1,200 @@
+/**
+ * Constant folding analysis for the Titan optimizer
+ *
+ * This module implements efficient single-pass constant folding:
+ * 1. Bottom-up classification: Assign ConstInfo to every node during post-order DFS
+ * 2. Top-down border detection: Identify const nodes whose parents are non-const
+ * 3. Replacement: Replace border nodes with appropriate literals
+ */
+import { PlanNode } from '../nodes/plan-node.js';
+import { PlanNodeType } from '../nodes/plan-node-type.js';
+import { LiteralNode } from '../nodes/scalar.js';
+import { createLogger } from '../../common/logger.js';
+const log = createLogger('optimizer:folding');
+/**
+ * Create a new constant folding context
+ */
+export function createConstFoldingContext(evaluateExpression) {
+    return {
+        constInfo: new Map(),
+        borderNodes: new Map(),
+        evaluateExpression
+    };
+}
+/**
+ * Perform complete single-pass constant folding on a plan tree
+ * This is the main entry point for efficient constant folding
+ */
+export function performConstantFolding(root, evaluateExpression) {
+    const ctx = createConstFoldingContext(evaluateExpression);
+    // Phase 1: Bottom-up classification
+    classifyConstants(root, ctx);
+    // Phase 2: Top-down border detection with dependency resolution
+    detectBorderNodes(root, ctx, new Set());
+    // Phase 3: Replace border nodes
+    return replaceBorderNodes(root, ctx);
+}
+/**
+ * Perform bottom-up constant classification on a plan tree
+ */
+export function classifyConstants(root, ctx) {
+    // Post-order DFS - classify children before parent
+    const children = root.getChildren();
+    for (const child of children) {
+        classifyConstants(child, ctx);
+    }
+    // Classify this node based on its type and children
+    const constInfo = classifyNode(root, ctx);
+    ctx.constInfo.set(root.id, constInfo);
+    log('Classified node %s (%s): %s', root.id, root.nodeType, constInfo.kind === 'const' ? `const` :
+        constInfo.kind === 'dep' ? `dep([${Array.from(constInfo.deps).join(',')}])` :
+            'non-const');
+}
+/**
+ * Classify a single node - works for ANY node type
+ */
+function classifyNode(node, ctx) {
+    // Rule 1: Any node with physical.constant === true
+    if (node.physical.constant) {
+        if ('getValue' in node) {
+            return { kind: 'const', node: node };
+        }
+        throw new Error(`Node ${node} is constant but does not implement getValue()`);
+    }
+    // Rule 2: ColumnReference → dep with {attrId}
+    if (node.nodeType === PlanNodeType.ColumnReference) {
+        const colRef = node; // ColumnReferenceNode
+        return { kind: 'dep', deps: new Set([colRef.attributeId]) };
+    }
+    // Rule 3: Any other node - check if functional and inspect children
+    if (!PlanNode.isFunctional(node.physical)) {
+        return { kind: 'non-const' };
+    }
+    // Inspect children (works for both scalar and relational children)
+    const childConstInfos = node.getChildren().map(child => {
+        const childInfo = ctx.constInfo.get(child.id);
+        if (!childInfo) {
+            throw new Error(`No ConstInfo found for child node ${child.id}`);
+        }
+        return childInfo;
+    });
+    // If all children are const → this node is const
+    if (childConstInfos.every(info => info.kind === 'const')) {
+        return { kind: 'const', node: node };
+    }
+    // If all children ∈ {const, dep} → dep with union of child deps
+    if (childConstInfos.every(info => info.kind === 'const' || info.kind === 'dep')) {
+        const allDeps = new Set();
+        for (const info of childConstInfos) {
+            if (info.kind === 'dep') {
+                for (const dep of info.deps) {
+                    allDeps.add(dep);
+                }
+            }
+        }
+        return { kind: 'dep', deps: allDeps };
+    }
+    // Otherwise → non-const
+    return { kind: 'non-const' };
+}
+/**
+ * Top-down border detection with dependency resolution
+ * A border node is:
+ * - A const node (always foldable)
+ * - A dep node whose dependencies are all resolved by known constant attributes
+ */
+function detectBorderNodes(node, ctx, knownConstAttrs = new Set()) {
+    const nodeInfo = ctx.constInfo.get(node.id);
+    // Check if this node is a border node
+    if (nodeInfo?.kind === 'const') {
+        // Const nodes are always border nodes
+        ctx.borderNodes.set(node.id, node);
+        log('Detected const border node: %s (%s)', node.id, node.nodeType);
+        // Don't recurse into const subtrees - they'll all be replaced
+        return;
+    }
+    else if (nodeInfo?.kind === 'dep') {
+        // Dep nodes become border nodes if all dependencies are resolved
+        if (isSubsetOf(nodeInfo.deps, knownConstAttrs)) {
+            ctx.borderNodes.set(node.id, node);
+            log('Detected resolved dep border node: %s (%s) - deps %s resolved by %s', node.id, node.nodeType, Array.from(nodeInfo.deps).join(','), Array.from(knownConstAttrs).join(','));
+            // Don't recurse - this entire subtree will be replaced
+            return;
+        }
+    }
+    // Update known constant attributes for this scope
+    const updatedKnownAttrs = new Set(knownConstAttrs);
+    // 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.getProducingExprs();
+        if (producingExprs) {
+            for (const [attrId, expr] of producingExprs) {
+                const exprInfo = ctx.constInfo.get(expr.id);
+                if (exprInfo?.kind === 'const') {
+                    // This expression produces a constant attribute
+                    updatedKnownAttrs.add(attrId);
+                    log('Node %s produces constant attribute %d', node.id, attrId);
+                }
+                else if (exprInfo?.kind === 'dep' && isSubsetOf(exprInfo.deps, knownConstAttrs)) {
+                    // This expression's dependencies are resolved, so it produces a constant
+                    updatedKnownAttrs.add(attrId);
+                    log('Node %s produces resolved constant attribute %d (was dep on %s)', node.id, attrId, Array.from(exprInfo.deps).join(','));
+                }
+            }
+        }
+    }
+    // Recurse to children with updated known constant attributes
+    for (const child of node.getChildren()) {
+        detectBorderNodes(child, ctx, updatedKnownAttrs);
+    }
+}
+/**
+ * Utility function to check if set A is a subset of set B
+ */
+function isSubsetOf(setA, setB) {
+    if (setA.size === 0)
+        return true; // Empty set is subset of everything
+    for (const elem of setA) {
+        if (!setB.has(elem)) {
+            return false;
+        }
+    }
+    return true;
+}
+/**
+ * Replace border nodes with appropriate literals
+ */
+function replaceBorderNodes(node, ctx) {
+    // If this node is a border node, replace it
+    if (ctx.borderNodes.has(node.id)) {
+        try {
+            const evaluatedValue = ctx.evaluateExpression(node);
+            // Choose replacement type based on node type
+            if (node.getType().typeClass === 'scalar') {
+                const literalExpr = { type: 'literal', value: evaluatedValue };
+                const replacement = new LiteralNode(node.scope, literalExpr);
+                log('Replaced scalar border node %s with LiteralNode', node.id);
+                return replacement;
+            }
+            else {
+                // Relational node - replace with TableLiteralNode
+                // TODO: Handle relational evaluation properly
+                log('Relational border node %s detected but not yet implemented', node.id);
+                return node;
+            }
+        }
+        catch (error) {
+            log('Failed to evaluate border node %s: %s', node.id, error);
+            return node;
+        }
+    }
+    // Recursively replace children
+    const children = node.getChildren();
+    const replacedChildren = children.map(child => replaceBorderNodes(child, ctx));
+    // If any children changed, create new node
+    if (replacedChildren.some((child, i) => child !== children[i])) {
+        return node.withChildren(replacedChildren);
+    }
+    return node;
+}
+//# sourceMappingURL=const-pass.js.map

package/dist/src/planner/analysis/const-pass.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"const-pass.js","sourceRoot":"","sources":["../../../../src/planner/analysis/const-pass.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,57 @@
+/**
+ * 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 type { SqlValue } from '../../common/types.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 declare function extractConstraints(predicate: ScalarPlanNode, columnAttributeToIndex?: Map<number, number>): ConstraintExtractionResult;
+/**
+ * Create a residual filter predicate from constraints that weren't handled
+ * This allows creating a filter function that can be applied at runtime
+ */
+export declare function createResidualFilter(originalPredicate: ScalarPlanNode, handledConstraints: PredicateConstraint[]): ((row: any) => boolean) | undefined;
+/**
+ * Utility to map table schema columns to attribute IDs
+ * Used when extracting constraints for specific tables
+ */
+export declare function createColumnMapping(tableColumns: Array<{
+    name: string;
+}>, nodeAttributes: Array<{
+    id: number;
+    name: string;
+}>): Map<number, number>;
+//# sourceMappingURL=constraint-extractor.d.ts.map

package/dist/src/planner/analysis/constraint-extractor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraint-extractor.d.ts","sourceRoot":"","sources":["../../../../src/planner/analysis/constraint-extractor.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAG5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAGtD;;GAEG;AACH,MAAM,MAAM,YAAY,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,GAAG,GAAG,IAAI,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,SAAS,GAAG,aAAa,CAAC;AAEjH;;GAEG;AACH,MAAM,WAAW,mBAAmB;IACnC,8CAA8C;IAC9C,WAAW,EAAE,MAAM,CAAC;IACpB,2CAA2C;IAC3C,WAAW,EAAE,MAAM,CAAC;IACpB,0BAA0B;IAC1B,EAAE,EAAE,YAAY,CAAC;IACjB,wDAAwD;IACxD,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,+DAA+D;IAC/D,MAAM,EAAE,OAAO,CAAC;IAChB,6CAA6C;IAC7C,gBAAgB,EAAE,cAAc,CAAC;CACjC;AAED;;GAEG;AACH,MAAM,WAAW,0BAA0B;IAC1C,4BAA4B;IAC5B,WAAW,EAAE,mBAAmB,EAAE,CAAC;IACnC,mEAAmE;IACnE,iBAAiB,CAAC,EAAE,cAAc,CAAC;CACnC;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CACjC,SAAS,EAAE,cAAc,EACzB,sBAAsB,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAC1C,0BAA0B,CAoB5B;AAsKD;;;GAGG;AACH,wBAAgB,oBAAoB,CACnC,iBAAiB,EAAE,cAAc,EACjC,kBAAkB,EAAE,mBAAmB,EAAE,GACvC,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,SAAS,CAWrC;AAED;;;GAGG;AACH,wBAAgB,mBAAmB,CAClC,YAAY,EAAE,KAAK,CAAC;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,EACrC,cAAc,EAAE,KAAK,CAAC;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,GACjD,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAYrB"}

package/dist/src/planner/analysis/constraint-extractor.js

@@ -0,0 +1,193 @@
+/**
+ * Constraint extraction utilities for predicate analysis and VTab.xBestIndex
+ * Converts scalar expressions into constraints that can be pushed down to virtual tables
+ */
+import { PlanNodeType } from '../nodes/plan-node-type.js';
+/**
+ * Extract constraints from a scalar predicate expression
+ * Currently handles simple binary comparisons and basic boolean logic
+ */
+export function extractConstraints(predicate, columnAttributeToIndex) {
+    const constraints = [];
+    const residualExpressions = [];
+    // Start extraction process
+    extractFromExpression(predicate, constraints, residualExpressions, columnAttributeToIndex);
+    // Build residual predicate from unmatched expressions
+    let residualPredicate;
+    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, constraints, residual, columnAttributeToIndex) {
+    // 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, columnAttributeToIndex) {
+    const binaryInfo = getBinaryComparisonInfo(expr);
+    if (!binaryInfo) {
+        return null;
+    }
+    const { left, right, op } = binaryInfo;
+    // Try column-constant pattern (column op constant)
+    let columnRef = null;
+    let constant;
+    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) {
+    // 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) {
+    // Simplified check - would need actual implementation
+    return expr.nodeType === PlanNodeType.BinaryOp;
+}
+/**
+ * Get children of binary expression
+ */
+function getBinaryExpressionChildren(_expr) {
+    // Simplified - would need actual implementation
+    return null;
+}
+/**
+ * Check if node is a column reference
+ */
+function isColumnReference(node) {
+    return node.nodeType === PlanNodeType.ColumnReference;
+}
+/**
+ * Check if node is a literal constant
+ */
+function isLiteralConstant(node) {
+    return node.nodeType === PlanNodeType.Literal;
+}
+/**
+ * Get literal value from literal node
+ */
+function getLiteralValue(_node) {
+    // Simplified - would need actual implementation
+    return null;
+}
+/**
+ * Flip comparison operator for reversed operand order
+ */
+function flipOperator(op) {
+    switch (op) {
+        case '<': return '>';
+        case '<=': return '>=';
+        case '>': return '<';
+        case '>=': return '<=';
+        case '=': return '=';
+        default: return op;
+    }
+}
+/**
+ * Combine multiple expressions with AND logic
+ */
+function combineWithAnd(expressions) {
+    // 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, handledConstraints) {
+    // 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) => 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, nodeAttributes) {
+    const mapping = new Map();
+    // 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;
+}
+//# sourceMappingURL=constraint-extractor.js.map

package/dist/src/planner/analysis/constraint-extractor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"constraint-extractor.js","sourceRoot":"","sources":["../../../../src/planner/analysis/constraint-extractor.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,5 @@
+import type * as AST from '../../parser/ast.js';
+import type { PlanningContext } from '../planning-context.js';
+import type { VoidNode } from '../nodes/plan-node.js';
+export declare function buildAlterTableStmt(ctx: PlanningContext, stmt: AST.AlterTableStmt): VoidNode;
+//# sourceMappingURL=alter-table.d.ts.map

package/dist/src/planner/building/alter-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"alter-table.d.ts","sourceRoot":"","sources":["../../../../src/planner/building/alter-table.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAK9D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AAEtD,wBAAgB,mBAAmB,CACjC,GAAG,EAAE,eAAe,EACpB,IAAI,EAAE,GAAG,CAAC,cAAc,GACvB,QAAQ,CAmCV"}

package/dist/src/planner/building/alter-table.js

@@ -0,0 +1,26 @@
+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';
+export function buildAlterTableStmt(ctx, stmt) {
+    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.type}`, StatusCode.INTERNAL);
+    }
+}
+//# sourceMappingURL=alter-table.js.map

package/dist/src/planner/building/alter-table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"alter-table.js","sourceRoot":"","sources":["../../../../src/planner/building/alter-table.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,iBAAiB,EAAE,MAAM,iCAAiC,CAAC;AACpE,OAAO,EAAE,mBAAmB,EAAE,MAAM,YAAY,CAAC;AACjD,OAAO,EAAE,YAAY,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AAGnD,MAAM,UAAU,mBAAmB,CACjC,GAAoB,EACpB,IAAwB;IAExB,MAAM,cAAc,GAAG,mBAAmB,CAAC,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,EAAE,GAAG,CAAC,CAAC;IAEtF,QAAQ,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC;QACzB,KAAK,eAAe,CAAC,CAAC,CAAC;YACrB,gFAAgF;YAChF,MAAM,UAAU,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU,CAAC,UAAU,IAAI,CAAC,QAAQ,EAAC,QAAQ,CAAC,CAAC;YAE5E,MAAM,qBAAqB,GAAG;gBAC5B,GAAG,IAAI,CAAC,MAAM,CAAC,UAAU;gBACzB,UAAU;aACX,CAAC;YAEF,OAAO,IAAI,iBAAiB,CAC1B,GAAG,CAAC,KAAK,EACT,cAAc,EACd,qBAAqB,CACtB,CAAC;QACN,CAAC;QAEC,KAAK,aAAa,CAAC;QACnB,KAAK,cAAc,CAAC;QACpB,KAAK,WAAW,CAAC;QACjB,KAAK,YAAY;YACf,MAAM,IAAI,YAAY,CACpB,eAAe,IAAI,CAAC,MAAM,CAAC,IAAI,yBAAyB,EACxD,UAAU,CAAC,WAAW,CACvB,CAAC;QAEJ;YACE,MAAM,IAAI,YAAY,CACpB,+BAAgC,IAAI,CAAC,MAAc,CAAC,IAAI,EAAE,EAC1D,UAAU,CAAC,QAAQ,CACpB,CAAC;IACN,CAAC;AACH,CAAC"}

package/dist/src/planner/building/block.d.ts

@@ -0,0 +1,5 @@
+import { BlockNode } from '../nodes/block.js';
+import * as AST from '../../parser/ast.js';
+import type { PlanningContext } from '../planning-context.js';
+export declare function buildBlock(ctx: PlanningContext, statements: AST.Statement[]): BlockNode;
+//# sourceMappingURL=block.d.ts.map

package/dist/src/planner/building/block.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block.d.ts","sourceRoot":"","sources":["../../../../src/planner/building/block.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AAC9C,OAAO,KAAK,GAAG,MAAM,qBAAqB,CAAC;AAG3C,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAgB9D,wBAAgB,UAAU,CAAC,GAAG,EAAE,eAAe,EAAE,UAAU,EAAE,GAAG,CAAC,SAAS,EAAE,GAAG,SAAS,CAuDvF"}

package/dist/src/planner/building/block.js

@@ -0,0 +1,68 @@
+import { BlockNode } from '../nodes/block.js';
+import { buildSelectStmt } from './select.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, statements) {
+    const plannedStatements = statements.map((stmt) => {
+        switch (stmt.type) {
+            case 'select':
+                // buildSelectStmt returns a BatchNode, which is a PlanNode.
+                return buildSelectStmt(ctx, stmt);
+            case 'createTable':
+                return buildCreateTableStmt(ctx, stmt);
+            case 'createIndex':
+                return buildCreateIndexStmt(ctx, stmt);
+            case 'createView':
+                return buildCreateViewStmt(ctx, stmt);
+            case 'drop':
+                if (stmt.objectType === 'table') {
+                    return buildDropTableStmt(ctx, stmt);
+                }
+                else if (stmt.objectType === 'view') {
+                    return buildDropViewStmt(ctx, stmt);
+                }
+                break;
+            case 'insert':
+                return buildInsertStmt(ctx, stmt);
+            case 'update':
+                return buildUpdateStmt(ctx, stmt);
+            case 'delete':
+                return buildDeleteStmt(ctx, stmt);
+            case 'begin':
+                return buildBeginStmt(ctx, stmt);
+            case 'commit':
+                return buildCommitStmt(ctx, stmt);
+            case 'rollback':
+                return buildRollbackStmt(ctx, stmt);
+            case 'savepoint':
+                return buildSavepointStmt(ctx, stmt);
+            case 'release':
+                return buildReleaseStmt(ctx, stmt);
+            case 'pragma':
+                return buildPragmaStmt(ctx, stmt);
+            case 'alterTable':
+                return buildAlterTableStmt(ctx, stmt);
+            case 'values':
+                return buildValuesStmt(ctx, stmt);
+            default:
+                // Throw an exception for unsupported statement types
+                quereusError(`Unsupported statement type: ${stmt.type}`, StatusCode.UNSUPPORTED, undefined, stmt);
+        }
+    }).filter(p => p !== undefined); // 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 });
+}
+//# sourceMappingURL=block.js.map

package/dist/src/planner/building/block.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"block.js","sourceRoot":"","sources":["../../../../src/planner/building/block.ts"],"names":[],"mappings":"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"}

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

@@ -0,0 +1,8 @@
+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 declare function buildCreateViewStmt(ctx: PlanningContext, stmt: AST.CreateViewStmt): CreateViewNode;
+//# sourceMappingURL=create-view.d.ts.map

package/dist/src/planner/building/create-view.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"create-view.d.ts","sourceRoot":"","sources":["../../../../src/planner/building/create-view.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,GAAG,MAAM,qBAAqB,CAAC;AAChD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAC9D,OAAO,EAAE,cAAc,EAAE,MAAM,8BAA8B,CAAC;AAE9D;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,eAAe,EAAE,IAAI,EAAE,GAAG,CAAC,cAAc,GAAG,cAAc,CAmBlG"}