@quereus/quereus 0.1.0

package/dist/src/planner/nodes/scan.js

@@ -0,0 +1,78 @@
+import { PlanNodeType } from './plan-node-type.js';
+import { PlanNode } from './plan-node.js';
+import { TableReferenceNode } from './reference.js';
+import { Cached } from '../../util/cached.js';
+import { quereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+/**
+ * Represents a table scan operation (full or filtered).
+ * This is a physical node that accesses actual table data.
+ */
+export class TableScanNode extends PlanNode {
+    source;
+    filterInfo;
+    nodeType = PlanNodeType.TableScan;
+    outputType;
+    constructor(scope, source, filterInfo, estimatedCostOverride) {
+        super(scope, estimatedCostOverride ?? filterInfo.indexInfoOutput.estimatedCost);
+        this.source = source;
+        this.filterInfo = filterInfo;
+        this.outputType = new Cached(() => this.source.getType());
+    }
+    getType() {
+        return this.outputType.value;
+    }
+    getAttributes() {
+        // Table scans produce the same attributes as their source table reference
+        return this.source.getAttributes();
+    }
+    getChildren() {
+        return [this.source];
+    }
+    getRelations() {
+        return [this.source];
+    }
+    withChildren(newChildren) {
+        if (newChildren.length !== 1) {
+            quereusError(`TableScanNode expects 1 child, got ${newChildren.length}`, StatusCode.INTERNAL);
+        }
+        const [newSource] = newChildren;
+        // Type check - TableScanNode specifically needs a TableReferenceNode
+        if (!(newSource instanceof TableReferenceNode)) {
+            quereusError('TableScanNode: child must be a TableReferenceNode', StatusCode.INTERNAL);
+        }
+        // Return same instance if nothing changed
+        if (newSource === this.source) {
+            return this;
+        }
+        // Create new instance preserving attributes (scan preserves table attributes)
+        return new TableScanNode(this.scope, newSource, this.filterInfo);
+    }
+    get estimatedRows() {
+        return Number(this.filterInfo.indexInfoOutput.estimatedRows);
+    }
+    computePhysical() {
+        const tableType = this.source.getType();
+        return {
+            estimatedRows: this.estimatedRows,
+            // Table scans preserve the logical keys from the table schema
+            uniqueKeys: tableType.keys.map(key => key.map(colRef => colRef.index)),
+        };
+    }
+    toString() {
+        return `SCAN ${this.source.tableSchema.name}`;
+    }
+    getLogicalAttributes() {
+        return {
+            table: this.source.tableSchema.name,
+            schema: this.source.tableSchema.schemaName,
+            filterInfo: {
+                usableIndex: this.filterInfo.indexInfoOutput.idxStr,
+                matchedClauses: this.filterInfo.indexInfoOutput.aConstraintUsage?.length || 0,
+                estimatedCost: this.filterInfo.indexInfoOutput.estimatedCost,
+                estimatedRows: this.filterInfo.indexInfoOutput.estimatedRows
+            }
+        };
+    }
+}
+//# sourceMappingURL=scan.js.map

package/dist/src/planner/nodes/scan.js.map

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

package/dist/src/planner/nodes/sequencing-node.d.ts

@@ -0,0 +1,25 @@
+import { PlanNodeType } from './plan-node-type.js';
+import { PlanNode, type Attribute, type RelationalPlanNode, type UnaryRelationalNode } from './plan-node.js';
+import type { RelationType } from '../../common/datatype.js';
+import type { Scope } from '../scopes/scope.js';
+/**
+ * Represents a sequencing operation that adds a row number column to convert bags to sets.
+ * This ensures uniqueness for operations that require set semantics.
+ * The added column is typically projected away after use and not visible to the user.
+ */
+export declare class SequencingNode extends PlanNode implements UnaryRelationalNode {
+    readonly source: RelationalPlanNode;
+    readonly sequenceColumnName: string;
+    readonly nodeType = PlanNodeType.Sequencing;
+    private outputTypeCache;
+    constructor(scope: Scope, source: RelationalPlanNode, sequenceColumnName?: string, estimatedCostOverride?: number);
+    getType(): RelationType;
+    getAttributes(): Attribute[];
+    getChildren(): readonly [RelationalPlanNode];
+    getRelations(): readonly [RelationalPlanNode];
+    withChildren(newChildren: readonly PlanNode[]): PlanNode;
+    get estimatedRows(): number | undefined;
+    toString(): string;
+    getLogicalAttributes(): Record<string, unknown>;
+}
+//# sourceMappingURL=sequencing-node.d.ts.map

package/dist/src/planner/nodes/sequencing-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sequencing-node.d.ts","sourceRoot":"","sources":["../../../../src/planner/nodes/sequencing-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,KAAK,SAAS,EAAE,KAAK,kBAAkB,EAAE,KAAK,mBAAmB,EAAE,MAAM,gBAAgB,CAAC;AAC7G,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAIhD;;;;GAIG;AACH,qBAAa,cAAe,SAAQ,QAAS,YAAW,mBAAmB;aAOzD,MAAM,EAAE,kBAAkB;aAC1B,kBAAkB,EAAE,MAAM;IAP3C,SAAkB,QAAQ,2BAA2B;IAErD,OAAO,CAAC,eAAe,CAAuB;gBAG7C,KAAK,EAAE,KAAK,EACI,MAAM,EAAE,kBAAkB,EAC1B,kBAAkB,GAAE,MAAoB,EACxD,qBAAqB,CAAC,EAAE,MAAM;IAmC/B,OAAO,IAAI,YAAY;IAIvB,aAAa,IAAI,SAAS,EAAE;IAK5B,WAAW,IAAI,SAAS,CAAC,kBAAkB,CAAC;IAI5C,YAAY,IAAI,SAAS,CAAC,kBAAkB,CAAC;IAI7C,YAAY,CAAC,WAAW,EAAE,SAAS,QAAQ,EAAE,GAAG,QAAQ;IAyBxD,IAAI,aAAa,IAAI,MAAM,GAAG,SAAS,CAEtC;IAEQ,QAAQ,IAAI,MAAM;IAIlB,oBAAoB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAMxD"}

package/dist/src/planner/nodes/sequencing-node.js

@@ -0,0 +1,88 @@
+import { PlanNodeType } from './plan-node-type.js';
+import { PlanNode } from './plan-node.js';
+import { Cached } from '../../util/cached.js';
+import { SqlDataType } from '../../common/types.js';
+/**
+ * Represents a sequencing operation that adds a row number column to convert bags to sets.
+ * This ensures uniqueness for operations that require set semantics.
+ * The added column is typically projected away after use and not visible to the user.
+ */
+export class SequencingNode extends PlanNode {
+    source;
+    sequenceColumnName;
+    nodeType = PlanNodeType.Sequencing;
+    outputTypeCache;
+    constructor(scope, source, sequenceColumnName = '__row_seq', estimatedCostOverride) {
+        super(scope, estimatedCostOverride);
+        this.source = source;
+        this.sequenceColumnName = sequenceColumnName;
+        this.outputTypeCache = new Cached(() => {
+            const sourceType = this.source.getType();
+            // Add a sequence column to make this a set
+            const sequenceColumn = {
+                name: this.sequenceColumnName,
+                type: {
+                    typeClass: 'scalar',
+                    affinity: SqlDataType.INTEGER,
+                    nullable: false,
+                    isReadOnly: true
+                },
+                generated: true
+            };
+            // Create a unique key based on all columns including the sequence
+            // This guarantees the result is a set
+            const allColumnsKey = sourceType.columns.map((_, index) => ({ index }))
+                .concat([{ index: sourceType.columns.length }]); // Include sequence column
+            return {
+                typeClass: 'relation',
+                isReadOnly: sourceType.isReadOnly,
+                isSet: true, // This operation guarantees set semantics
+                columns: [...sourceType.columns, sequenceColumn],
+                keys: [allColumnsKey], // All columns including sequence form a unique key
+                rowConstraints: sourceType.rowConstraints,
+            };
+        });
+    }
+    getType() {
+        return this.outputTypeCache.value;
+    }
+    getAttributes() {
+        // Sort preserves the same attributes as its source
+        return this.source.getAttributes();
+    }
+    getChildren() {
+        return [this.source];
+    }
+    getRelations() {
+        return [this.source];
+    }
+    withChildren(newChildren) {
+        if (newChildren.length !== 1) {
+            throw new Error(`SequencingNode expects 1 child, got ${newChildren.length}`);
+        }
+        const [newSource] = newChildren;
+        // Type check
+        if (!('getAttributes' in newSource) || typeof newSource.getAttributes !== 'function') {
+            throw new Error('SequencingNode: child must be a RelationalPlanNode');
+        }
+        // Return same instance if nothing changed
+        if (newSource === this.source) {
+            return this;
+        }
+        // Create new instance preserving attributes (sequencing preserves source attributes)
+        return new SequencingNode(this.scope, newSource, this.sequenceColumnName);
+    }
+    get estimatedRows() {
+        return this.source.estimatedRows; // Sequencing doesn't change row count
+    }
+    toString() {
+        return `SEQUENCE ADD ${this.sequenceColumnName}`;
+    }
+    getLogicalAttributes() {
+        return {
+            sequenceColumn: this.sequenceColumnName,
+            purpose: 'Convert bag to set by adding unique row sequence'
+        };
+    }
+}
+//# sourceMappingURL=sequencing-node.js.map

package/dist/src/planner/nodes/sequencing-node.js.map

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

package/dist/src/planner/nodes/set-operation-node.d.ts

@@ -0,0 +1,21 @@
+import { PlanNode } from './plan-node.js';
+import type { RelationalPlanNode, Attribute, BinaryRelationalNode } from './plan-node.js';
+import type { RelationType } from '../../common/datatype.js';
+import { PlanNodeType } from './plan-node-type.js';
+import type { Scope } from '../scopes/scope.js';
+export declare class SetOperationNode extends PlanNode implements BinaryRelationalNode {
+    readonly left: RelationalPlanNode;
+    readonly right: RelationalPlanNode;
+    readonly op: 'union' | 'unionAll' | 'intersect' | 'except';
+    readonly nodeType = PlanNodeType.SetOperation;
+    private attributesCache;
+    constructor(scope: Scope, left: RelationalPlanNode, right: RelationalPlanNode, op: 'union' | 'unionAll' | 'intersect' | 'except');
+    private buildAttributes;
+    getAttributes(): Attribute[];
+    getType(): RelationType;
+    getChildren(): readonly PlanNode[];
+    getRelations(): readonly [RelationalPlanNode, RelationalPlanNode];
+    withChildren(newChildren: readonly PlanNode[]): PlanNode;
+    toString(): string;
+}
+//# sourceMappingURL=set-operation-node.d.ts.map

package/dist/src/planner/nodes/set-operation-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"set-operation-node.d.ts","sourceRoot":"","sources":["../../../../src/planner/nodes/set-operation-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAC1C,OAAO,KAAK,EAAE,kBAAkB,EAAE,SAAS,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AAC1F,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAKhD,qBAAa,gBAAiB,SAAQ,QAAS,YAAW,oBAAoB;aAM1D,IAAI,EAAE,kBAAkB;aACxB,KAAK,EAAE,kBAAkB;aACzB,EAAE,EAAE,OAAO,GAAG,UAAU,GAAG,WAAW,GAAG,QAAQ;IAPnE,QAAQ,CAAC,QAAQ,6BAA6B;IAC9C,OAAO,CAAC,eAAe,CAAsB;gBAG3C,KAAK,EAAE,KAAK,EACI,IAAI,EAAE,kBAAkB,EACxB,KAAK,EAAE,kBAAkB,EACzB,EAAE,EAAE,OAAO,GAAG,UAAU,GAAG,WAAW,GAAG,QAAQ;IAanE,OAAO,CAAC,eAAe;IAOvB,aAAa,IAAI,SAAS,EAAE;IAI5B,OAAO,IAAI,YAAY;IAKvB,WAAW,IAAI,SAAS,QAAQ,EAAE;IAIlC,YAAY,IAAI,SAAS,CAAC,kBAAkB,EAAE,kBAAkB,CAAC;IAIjE,YAAY,CAAC,WAAW,EAAE,SAAS,QAAQ,EAAE,GAAG,QAAQ;IA6B/C,QAAQ,IAAI,MAAM;CAG5B"}

package/dist/src/planner/nodes/set-operation-node.js

@@ -0,0 +1,68 @@
+import { PlanNode } from './plan-node.js';
+import { PlanNodeType } from './plan-node-type.js';
+import { Cached } from '../../util/cached.js';
+import { quereusError, QuereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+export class SetOperationNode extends PlanNode {
+    left;
+    right;
+    op;
+    nodeType = PlanNodeType.SetOperation;
+    attributesCache;
+    constructor(scope, left, right, op) {
+        super(scope, left.getTotalCost() + right.getTotalCost());
+        this.left = left;
+        this.right = right;
+        this.op = op;
+        // Validate column counts
+        const leftCols = left.getType().columns;
+        const rightCols = right.getType().columns;
+        if (leftCols.length !== rightCols.length) {
+            throw new QuereusError(`SET operation column count mismatch: left has ${leftCols.length}, right has ${rightCols.length}`, StatusCode.ERROR);
+        }
+        // TODO: optionally check type compatibility (affinity)
+        this.attributesCache = new Cached(() => this.buildAttributes());
+    }
+    buildAttributes() {
+        const leftAttrs = this.left.getAttributes();
+        // Preserve left child's attributes directly to avoid any mapping issues
+        // This ensures ORDER BY expressions can resolve to the same attribute IDs
+        return leftAttrs;
+    }
+    getAttributes() {
+        return this.attributesCache.value;
+    }
+    getType() {
+        const leftType = this.left.getType();
+        return { ...leftType, isSet: true };
+    }
+    getChildren() {
+        return [this.left, this.right];
+    }
+    getRelations() {
+        return [this.left, this.right];
+    }
+    withChildren(newChildren) {
+        if (newChildren.length !== 2) {
+            quereusError(`SetOperationNode expects 2 children, got ${newChildren.length}`, StatusCode.INTERNAL);
+        }
+        const [newLeft, newRight] = newChildren;
+        // Type check
+        if (!('getAttributes' in newLeft) || typeof newLeft.getAttributes !== 'function') {
+            quereusError('SetOperationNode: first child must be a RelationalPlanNode', StatusCode.INTERNAL);
+        }
+        if (!('getAttributes' in newRight) || typeof newRight.getAttributes !== 'function') {
+            quereusError('SetOperationNode: second child must be a RelationalPlanNode', StatusCode.INTERNAL);
+        }
+        // Return same instance if nothing changed
+        if (newLeft === this.left && newRight === this.right) {
+            return this;
+        }
+        // Create new instance preserving attributes (set operation preserves left child's attributes)
+        return new SetOperationNode(this.scope, newLeft, newRight, this.op);
+    }
+    toString() {
+        return `${this.op.toUpperCase()}(${this.left.id}, ${this.right.id})`;
+    }
+}
+//# sourceMappingURL=set-operation-node.js.map

package/dist/src/planner/nodes/set-operation-node.js.map

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

package/dist/src/planner/nodes/single-row.d.ts

@@ -0,0 +1,24 @@
+import { PlanNodeType } from './plan-node-type.js';
+import { PlanNode, type ZeroAryRelationalNode, type Attribute, PhysicalProperties } from './plan-node.js';
+import type { RelationType } from '../../common/datatype.js';
+/**
+ * A dummy relational node that produces a single row with no columns.
+ * Used as a source for SELECT statements without a FROM clause.
+ */
+export declare class SingleRowNode extends PlanNode implements ZeroAryRelationalNode {
+    readonly nodeType = PlanNodeType.SingleRow;
+    private static readonly singleInstance;
+    private readonly outputType;
+    private constructor();
+    static get instance(): SingleRowNode;
+    getType(): RelationType;
+    getAttributes(): Attribute[];
+    getChildren(): readonly [];
+    getRelations(): readonly [];
+    withChildren(newChildren: readonly PlanNode[]): PlanNode;
+    get estimatedRows(): number;
+    toString(): string;
+    getLogicalAttributes(): Record<string, unknown>;
+    computePhysical(): Partial<PhysicalProperties>;
+}
+//# sourceMappingURL=single-row.d.ts.map

package/dist/src/planner/nodes/single-row.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-row.d.ts","sourceRoot":"","sources":["../../../../src/planner/nodes/single-row.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,KAAK,qBAAqB,EAAE,KAAK,SAAS,EAAE,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AAC1G,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAI7D;;;GAGG;AACH,qBAAa,aAAc,SAAQ,QAAS,YAAW,qBAAqB;IAC1E,SAAkB,QAAQ,0BAA0B;IAEpD,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAA0C;IAEhF,OAAO,CAAC,QAAQ,CAAC,UAAU,CAOzB;IAEF,OAAO;IAIP,WAAkB,QAAQ,IAAI,aAAa,CAE1C;IAED,OAAO,IAAI,YAAY;IAIvB,aAAa,IAAI,SAAS,EAAE;IAK5B,WAAW,IAAI,SAAS,EAAE;IAI3B,YAAY,IAAI,SAAS,EAAE;IAI1B,YAAY,CAAC,WAAW,EAAE,SAAS,QAAQ,EAAE,GAAG,QAAQ;IAOxD,IAAI,aAAa,IAAI,MAAM,CAE1B;IAEQ,QAAQ,IAAI,MAAM;IAIlB,oBAAoB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAQhD,eAAe,IAAI,OAAO,CAAC,kBAAkB,CAAC;CAOvD"}

package/dist/src/planner/nodes/single-row.js

@@ -0,0 +1,65 @@
+import { PlanNodeType } from './plan-node-type.js';
+import { PlanNode } from './plan-node.js';
+import { EmptyScope } from '../scopes/empty.js';
+/**
+ * A dummy relational node that produces a single row with no columns.
+ * Used as a source for SELECT statements without a FROM clause.
+ */
+export class SingleRowNode extends PlanNode {
+    nodeType = PlanNodeType.SingleRow;
+    static singleInstance = new SingleRowNode(EmptyScope.instance); // HACK: null scope for singleton
+    outputType = {
+        typeClass: 'relation',
+        isReadOnly: true,
+        isSet: true, // Single row is always a set
+        columns: [],
+        keys: [[]], // Represents a relation that can have at most one row
+        rowConstraints: [],
+    };
+    constructor(scope) {
+        super(scope, 0.01); // Low cost - no IO
+    }
+    static get instance() {
+        return SingleRowNode.singleInstance;
+    }
+    getType() {
+        return this.outputType;
+    }
+    getAttributes() {
+        // Single row node has no columns, so no attributes
+        return [];
+    }
+    getChildren() {
+        return [];
+    }
+    getRelations() {
+        return [];
+    }
+    withChildren(newChildren) {
+        if (newChildren.length !== 0) {
+            throw new Error(`SingleRowNode expects 0 children, got ${newChildren.length}`);
+        }
+        return this; // No children, so no change
+    }
+    get estimatedRows() {
+        return 1;
+    }
+    toString() {
+        return `dual`;
+    }
+    getLogicalAttributes() {
+        return {
+            description: 'Single row with no columns (dual table)',
+            numRows: 1,
+            numColumns: 0,
+        };
+    }
+    computePhysical() {
+        return {
+            estimatedRows: 1,
+            uniqueKeys: [[]],
+            constant: true,
+        };
+    }
+}
+//# sourceMappingURL=single-row.js.map

package/dist/src/planner/nodes/single-row.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"single-row.js","sourceRoot":"","sources":["../../../../src/planner/nodes/single-row.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAkE,MAAM,gBAAgB,CAAC;AAE1G,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAGhD;;;GAGG;AACH,MAAM,OAAO,aAAc,SAAQ,QAAQ;IACvB,QAAQ,GAAG,YAAY,CAAC,SAAS,CAAC;IAE5C,MAAM,CAAU,cAAc,GAAG,IAAI,aAAa,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,CAAC,iCAAiC;IAEjG,UAAU,GAAiB;QAC1C,SAAS,EAAE,UAAU;QACrB,UAAU,EAAE,IAAI;QAChB,KAAK,EAAE,IAAI,EAAE,6BAA6B;QAC1C,OAAO,EAAE,EAAE;QACX,IAAI,EAAE,CAAC,EAAE,CAAC,EAAE,sDAAsD;QAClE,cAAc,EAAE,EAAE;KACnB,CAAC;IAEF,YAAoB,KAAY;QAC9B,KAAK,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC,CAAC,mBAAmB;IACzC,CAAC;IAEM,MAAM,KAAK,QAAQ;QACxB,OAAO,aAAa,CAAC,cAAc,CAAC;IACtC,CAAC;IAED,OAAO;QACL,OAAO,IAAI,CAAC,UAAU,CAAC;IACzB,CAAC;IAED,aAAa;QACX,mDAAmD;QACnD,OAAO,EAAE,CAAC;IACZ,CAAC;IAED,WAAW;QACT,OAAO,EAAE,CAAC;IACZ,CAAC;IAEF,YAAY;QACX,OAAO,EAAE,CAAC;IACX,CAAC;IAEA,YAAY,CAAC,WAAgC;QAC3C,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC7B,MAAM,IAAI,KAAK,CAAC,yCAAyC,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC;QACjF,CAAC;QACD,OAAO,IAAI,CAAC,CAAC,4BAA4B;IAC3C,CAAC;IAED,IAAI,aAAa;QACf,OAAO,CAAC,CAAC;IACX,CAAC;IAEQ,QAAQ;QACf,OAAO,MAAM,CAAC;IAChB,CAAC;IAEQ,oBAAoB;QAC3B,OAAO;YACL,WAAW,EAAE,yCAAyC;YACtD,OAAO,EAAE,CAAC;YACV,UAAU,EAAE,CAAC;SACd,CAAC;IACJ,CAAC;IAEO,eAAe;QACvB,OAAO;YACN,aAAa,EAAE,CAAC;YAChB,UAAU,EAAE,CAAC,EAAE,CAAC;YAChB,QAAQ,EAAE,IAAI;SACd,CAAC;IACH,CAAC"}

package/dist/src/planner/nodes/sink-node.d.ts

@@ -0,0 +1,25 @@
+import { PlanNodeType } from './plan-node-type.js';
+import { PlanNode, type RelationalPlanNode } from './plan-node.js';
+import type { ScalarType } from '../../common/datatype.js';
+import type { Scope } from '../scopes/scope.js';
+/**
+ * A sink node that consumes an async iterable for side effects.
+ * Returns the number of rows affected.
+ */
+export declare class SinkNode extends PlanNode {
+    readonly source: RelationalPlanNode;
+    /** Describes the operation for information purposes */
+    readonly operation: string;
+    readonly nodeType = PlanNodeType.Sink;
+    constructor(scope: Scope, source: RelationalPlanNode, 
+    /** Describes the operation for information purposes */
+    operation: string);
+    getType(): ScalarType;
+    getChildren(): readonly PlanNode[];
+    withChildren(newChildren: readonly PlanNode[]): PlanNode;
+    getRelations(): readonly [RelationalPlanNode];
+    get estimatedRows(): number;
+    toString(): string;
+    getLogicalAttributes(): Record<string, unknown>;
+}
+//# sourceMappingURL=sink-node.d.ts.map

package/dist/src/planner/nodes/sink-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sink-node.d.ts","sourceRoot":"","sources":["../../../../src/planner/nodes/sink-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,KAAK,kBAAkB,EAAE,MAAM,gBAAgB,CAAC;AACnE,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,0BAA0B,CAAC;AAC3D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAGhD;;;GAGG;AACH,qBAAa,QAAS,SAAQ,QAAQ;aAKpB,MAAM,EAAE,kBAAkB;IAC1C,uDAAuD;aACvC,SAAS,EAAE,MAAM;IANlC,SAAkB,QAAQ,qBAAqB;gBAG9C,KAAK,EAAE,KAAK,EACI,MAAM,EAAE,kBAAkB;IAC1C,uDAAuD;IACvC,SAAS,EAAE,MAAM;IAKlC,OAAO,IAAI,UAAU;IAUrB,WAAW,IAAI,SAAS,QAAQ,EAAE;IAIlC,YAAY,CAAC,WAAW,EAAE,SAAS,QAAQ,EAAE,GAAG,QAAQ;IAOxD,YAAY,IAAI,SAAS,CAAC,kBAAkB,CAAC;IAI7C,IAAI,aAAa,IAAI,MAAM,CAE1B;IAEQ,QAAQ,IAAI,MAAM;IAIlB,oBAAoB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;CAKxD"}

package/dist/src/planner/nodes/sink-node.js

@@ -0,0 +1,52 @@
+import { PlanNodeType } from './plan-node-type.js';
+import { PlanNode } from './plan-node.js';
+import { SqlDataType } from '../../common/types.js';
+/**
+ * A sink node that consumes an async iterable for side effects.
+ * Returns the number of rows affected.
+ */
+export class SinkNode extends PlanNode {
+    source;
+    operation;
+    nodeType = PlanNodeType.Sink;
+    constructor(scope, source, 
+    /** Describes the operation for information purposes */
+    operation) {
+        super(scope, source.getTotalCost() + 0.1); // Minimal cost for consuming
+        this.source = source;
+        this.operation = operation;
+    }
+    getType() {
+        // Return a single-column relation with the row count
+        return {
+            typeClass: 'scalar',
+            isReadOnly: true,
+            affinity: SqlDataType.INTEGER,
+            nullable: false
+        };
+    }
+    getChildren() {
+        return [];
+    }
+    withChildren(newChildren) {
+        if (newChildren.length !== 0) {
+            throw new Error(`SinkNode expects 0 children, got ${newChildren.length}`);
+        }
+        return this; // No children in getChildren(), source is accessed via getRelations()
+    }
+    getRelations() {
+        return [this.source];
+    }
+    get estimatedRows() {
+        return 1;
+    }
+    toString() {
+        return `SINK (${this.operation})`;
+    }
+    getLogicalAttributes() {
+        return {
+            sourceType: this.source.nodeType
+        };
+    }
+}
+//# sourceMappingURL=sink-node.js.map

package/dist/src/planner/nodes/sink-node.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sink-node.js","sourceRoot":"","sources":["../../../../src/planner/nodes/sink-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAA2B,MAAM,gBAAgB,CAAC;AAGnE,OAAO,EAAE,WAAW,EAAE,MAAM,uBAAuB,CAAC;AAEpD;;;GAGG;AACH,MAAM,OAAO,QAAS,SAAQ,QAAQ;IAKpB;IAEA;IANC,QAAQ,GAAG,YAAY,CAAC,IAAI,CAAC;IAE/C,YACC,KAAY,EACI,MAA0B;IAC1C,uDAAuD;IACvC,SAAiB;QAEjC,KAAK,CAAC,KAAK,EAAE,MAAM,CAAC,YAAY,EAAE,GAAG,GAAG,CAAC,CAAC,CAAC,6BAA6B;QAJxD,WAAM,GAAN,MAAM,CAAoB;QAE1B,cAAS,GAAT,SAAS,CAAQ;IAGlC,CAAC;IAED,OAAO;QACN,qDAAqD;QACrD,OAAO;YACN,SAAS,EAAE,QAAQ;YACnB,UAAU,EAAE,IAAI;YAChB,QAAQ,EAAE,WAAW,CAAC,OAAO;YAC7B,QAAQ,EAAE,KAAK;SACf,CAAC;IACH,CAAC;IAED,WAAW;QACV,OAAO,EAAE,CAAC;IACX,CAAC;IAED,YAAY,CAAC,WAAgC;QAC5C,IAAI,WAAW,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9B,MAAM,IAAI,KAAK,CAAC,oCAAoC,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC;QAC3E,CAAC;QACD,OAAO,IAAI,CAAC,CAAC,sEAAsE;IACpF,CAAC;IAED,YAAY;QACX,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACtB,CAAC;IAED,IAAI,aAAa;QAChB,OAAO,CAAC,CAAC;IACV,CAAC;IAEQ,QAAQ;QAChB,OAAO,SAAS,IAAI,CAAC,SAAS,GAAG,CAAC;IACnC,CAAC;IAEQ,oBAAoB;QAC5B,OAAO;YACN,UAAU,EAAE,IAAI,CAAC,MAAM,CAAC,QAAQ;SAChC,CAAC;IACH,CAAC;CACD"}

package/dist/src/planner/nodes/sort.d.ts

@@ -0,0 +1,37 @@
+import { PlanNodeType } from './plan-node-type.js';
+import { PlanNode, type RelationalPlanNode, type ScalarPlanNode, type UnaryRelationalNode, type PhysicalProperties, type Attribute } from './plan-node.js';
+import type { RelationType } from '../../common/datatype.js';
+import type { Scope } from '../scopes/scope.js';
+/**
+ * Represents a sort key for ordering results
+ */
+export interface SortKey {
+    /** The expression to sort by */
+    expression: ScalarPlanNode;
+    /** Sort direction */
+    direction: 'asc' | 'desc';
+    /** How to handle nulls */
+    nulls?: 'first' | 'last';
+}
+/**
+ * Represents a sort operation (ORDER BY clause).
+ * It takes an input relation and sort keys,
+ * and outputs rows sorted according to the keys.
+ * This is a physical operation that materializes and sorts rows.
+ */
+export declare class SortNode extends PlanNode implements UnaryRelationalNode {
+    readonly source: RelationalPlanNode;
+    readonly sortKeys: readonly SortKey[];
+    readonly nodeType = PlanNodeType.Sort;
+    constructor(scope: Scope, source: RelationalPlanNode, sortKeys: readonly SortKey[], estimatedCostOverride?: number);
+    getType(): RelationType;
+    getAttributes(): Attribute[];
+    getChildren(): readonly PlanNode[];
+    getRelations(): readonly [RelationalPlanNode];
+    get estimatedRows(): number | undefined;
+    computePhysical(childrenPhysical: PhysicalProperties[]): Partial<PhysicalProperties>;
+    toString(): string;
+    getLogicalAttributes(): Record<string, unknown>;
+    withChildren(newChildren: readonly PlanNode[]): PlanNode;
+}
+//# sourceMappingURL=sort.d.ts.map

package/dist/src/planner/nodes/sort.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sort.d.ts","sourceRoot":"","sources":["../../../../src/planner/nodes/sort.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,QAAQ,EAAE,KAAK,kBAAkB,EAAE,KAAK,cAAc,EAAE,KAAK,mBAAmB,EAAE,KAAK,kBAAkB,EAAE,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAC3J,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAC7D,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,oBAAoB,CAAC;AAMhD;;GAEG;AACH,MAAM,WAAW,OAAO;IACvB,gCAAgC;IAChC,UAAU,EAAE,cAAc,CAAC;IAC3B,qBAAqB;IACrB,SAAS,EAAE,KAAK,GAAG,MAAM,CAAC;IAC1B,0BAA0B;IAC1B,KAAK,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;CACzB;AAED;;;;;GAKG;AACH,qBAAa,QAAS,SAAQ,QAAS,YAAW,mBAAmB;aAKnD,MAAM,EAAE,kBAAkB;aAC1B,QAAQ,EAAE,SAAS,OAAO,EAAE;IAL7C,SAAkB,QAAQ,qBAAqB;gBAG9C,KAAK,EAAE,KAAK,EACI,MAAM,EAAE,kBAAkB,EAC1B,QAAQ,EAAE,SAAS,OAAO,EAAE,EAC5C,qBAAqB,CAAC,EAAE,MAAM;IAW/B,OAAO,IAAI,YAAY;IAKvB,aAAa,IAAI,SAAS,EAAE;IAK5B,WAAW,IAAI,SAAS,QAAQ,EAAE;IAKlC,YAAY,IAAI,SAAS,CAAC,kBAAkB,CAAC;IAI7C,IAAI,aAAa,IAAI,MAAM,GAAG,SAAS,CAGtC;IAED,eAAe,CAAC,gBAAgB,EAAE,kBAAkB,EAAE,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAgB3E,QAAQ,IAAI,MAAM;IAOlB,oBAAoB,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;IAUxD,YAAY,CAAC,WAAW,EAAE,SAAS,QAAQ,EAAE,GAAG,QAAQ;CAkCxD"}

package/dist/src/planner/nodes/sort.js

@@ -0,0 +1,97 @@
+import { PlanNodeType } from './plan-node-type.js';
+import { PlanNode } from './plan-node.js';
+import { formatSortKey } from '../../util/plan-formatter.js';
+import { quereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+import { extractOrderingFromSortKeys } from '../framework/physical-utils.js';
+/**
+ * Represents a sort operation (ORDER BY clause).
+ * It takes an input relation and sort keys,
+ * and outputs rows sorted according to the keys.
+ * This is a physical operation that materializes and sorts rows.
+ */
+export class SortNode extends PlanNode {
+    source;
+    sortKeys;
+    nodeType = PlanNodeType.Sort;
+    constructor(scope, source, sortKeys, estimatedCostOverride) {
+        // Cost: cost of source + cost of sorting (O(n log n) * cost of evaluating sort expressions)
+        // This is a simplified cost model - a more sophisticated one would consider the actual data size
+        const sourceRows = source.estimatedRows ?? 1000;
+        const sortCost = sourceRows * Math.log2(sourceRows + 1);
+        const keyCost = sortKeys.reduce((sum, key) => sum + key.expression.getTotalCost(), 0);
+        super(scope, estimatedCostOverride ?? (source.getTotalCost() + sortCost * keyCost));
+        this.source = source;
+        this.sortKeys = sortKeys;
+    }
+    getType() {
+        // Sort preserves the type of the source relation
+        return this.source.getType();
+    }
+    getAttributes() {
+        // Sort preserves the same attributes as its source
+        return this.source.getAttributes();
+    }
+    getChildren() {
+        // Return source first, then all sort key expressions
+        return [this.source, ...this.sortKeys.map(key => key.expression)];
+    }
+    getRelations() {
+        return [this.source];
+    }
+    get estimatedRows() {
+        // Sort doesn't change the number of rows
+        return this.source.estimatedRows;
+    }
+    computePhysical(childrenPhysical) {
+        const sourcePhysical = childrenPhysical[0]; // Source is first relation
+        const sourceAttributes = this.source.getAttributes();
+        // Extract ordering from sort keys if they are trivial column references
+        const ordering = extractOrderingFromSortKeys(this.sortKeys, sourceAttributes);
+        return {
+            estimatedRows: this.estimatedRows,
+            // Only set ordering if we can extract it from trivial column references
+            ordering,
+            // Preserve unique keys from source
+            uniqueKeys: sourcePhysical?.uniqueKeys,
+        };
+    }
+    toString() {
+        const keyDescriptions = this.sortKeys.map(key => formatSortKey(key.expression, key.direction, key.nulls)).join(', ');
+        return `ORDER BY ${keyDescriptions}`;
+    }
+    getLogicalAttributes() {
+        return {
+            sortKeys: this.sortKeys.map(key => ({
+                expression: key.expression.toString(),
+                direction: key.direction,
+                nulls: key.nulls
+            }))
+        };
+    }
+    withChildren(newChildren) {
+        if (newChildren.length !== 1 + this.sortKeys.length) {
+            quereusError(`SortNode expects ${1 + this.sortKeys.length} children, got ${newChildren.length}`, StatusCode.INTERNAL);
+        }
+        const [newSource, ...newSortExpressions] = newChildren;
+        // Type check
+        if (!('getAttributes' in newSource) || typeof newSource.getAttributes !== 'function') {
+            quereusError('SortNode: first child must be a RelationalPlanNode', StatusCode.INTERNAL);
+        }
+        // Check if anything changed
+        const sourceChanged = newSource !== this.source;
+        const sortExpressionsChanged = newSortExpressions.some((expr, i) => expr !== this.sortKeys[i].expression);
+        if (!sourceChanged && !sortExpressionsChanged) {
+            return this;
+        }
+        // Build new sort keys array
+        const newSortKeys = newSortExpressions.map((expr, i) => ({
+            expression: expr,
+            direction: this.sortKeys[i].direction,
+            nulls: this.sortKeys[i].nulls
+        }));
+        // Create new instance preserving attributes (sort preserves source attributes)
+        return new SortNode(this.scope, newSource, newSortKeys);
+    }
+}
+//# sourceMappingURL=sort.js.map