@quereus/quereus 0.2.1 → 0.4.0

package/src/planner/nodes/project-node.ts

@@ -3,11 +3,14 @@ import { PlanNode, type RelationalPlanNode, type UnaryRelationalNode, type Scala
 import type { RelationType } from '../../common/datatype.js';
 import type { Scope } from '../scopes/scope.js';
 import { Cached } from '../../util/cached.js';
+import { projectKeys } from '../util/key-utils.js';
 import { expressionToString } from '../../util/ast-stringify.js';
 import { formatProjection } from '../../util/plan-formatter.js';
 import { ColumnReferenceNode } from './reference.js';
 import { quereusError } from '../../common/errors.js';
 import { StatusCode } from '../../common/types.js';
+import { ProjectionCapable } from '../framework/characteristics.js';
+import type { PhysicalProperties } from './plan-node.js';
 
 export interface Projection {
 	node: ScalarPlanNode;
@@ -20,11 +23,11 @@ export interface Projection {
  * Represents a projection operation (SELECT list) without DISTINCT.
  * It takes an input relation and outputs a new relation with specified columns/expressions.
  */
-export class ProjectNode extends PlanNode implements UnaryRelationalNode {
+export class ProjectNode extends PlanNode implements UnaryRelationalNode, ProjectionCapable {
 	override readonly nodeType = PlanNodeType.Project;
 
 	private outputTypeCache: Cached<RelationType>;
-	private attributesCache: Cached<Attribute[]>;
+	private attributesCache: Cached<readonly Attribute[]>;
 
 	constructor(
 		scope: Scope,
@@ -32,7 +35,7 @@ export class ProjectNode extends PlanNode implements UnaryRelationalNode {
 		public readonly projections: ReadonlyArray<Projection>,
 		estimatedCostOverride?: number,
 		/** Optional predefined attributes for preserving IDs during optimization */
-		predefinedAttributes?: Attribute[],
+		predefinedAttributes?: readonly Attribute[],
 		/** Whether to preserve input columns in the output (default: true) */
 		public readonly preserveInputColumns: boolean = true
 	) {
@@ -83,11 +86,21 @@ export class ProjectNode extends PlanNode implements UnaryRelationalNode {
 				isReadOnly: sourceType.isReadOnly,
 				isSet: sourceType.isSet,
 				columns,
-				// TODO: Infer keys based on DISTINCT and projection's effect on input keys
-				keys: [],
+				keys: (() => {
+					// Build source->output index map for simple column references
+					const map = new Map<number, number>();
+					this.projections.forEach((proj, outIdx) => {
+						if (proj.node instanceof ColumnReferenceNode) {
+							const colRef = proj.node as ColumnReferenceNode;
+							const srcIndex = this.source.getAttributes().findIndex(a => a.id === colRef.attributeId);
+							if (srcIndex >= 0) map.set(srcIndex, outIdx);
+						}
+					});
+					return projectKeys(sourceType.keys, map);
+				})(),
 				// TODO: propagate row constraints that don't have projected off columns
 				rowConstraints: [],
-			} as RelationType;
+			} satisfies RelationType;
 		});
 
 		this.attributesCache = new Cached(() => {
@@ -149,11 +162,41 @@ export class ProjectNode extends PlanNode implements UnaryRelationalNode {
 		});
 	}
 
+	computePhysical(childrenPhysical: PhysicalProperties[]): Partial<PhysicalProperties> {
+		const sourcePhysical = childrenPhysical[0];
+		// Build mapping from source index -> projected index for ColumnReferences
+		const map = new Map<number, number>();
+		const sourceAttrs = this.source.getAttributes();
+		this.projections.forEach((proj, outIdx) => {
+			if (proj.node instanceof ColumnReferenceNode) {
+				const colRef = proj.node as ColumnReferenceNode;
+				const srcIndex = sourceAttrs.findIndex(a => a.id === colRef.attributeId);
+				if (srcIndex >= 0) map.set(srcIndex, outIdx);
+			}
+		});
+		const uniqueKeys = (sourcePhysical?.uniqueKeys || [])
+			.map(key => {
+				const projected: number[] = [];
+				for (const col of key) {
+					const outIdx = map.get(col);
+					if (outIdx === undefined) return null;
+					projected.push(outIdx);
+				}
+				return projected;
+			})
+			.filter((k): k is number[] => k !== null);
+		return {
+			estimatedRows: this.source.estimatedRows,
+			ordering: sourcePhysical?.ordering,
+			uniqueKeys,
+		};
+	}
+
 	getType(): RelationType {
 		return this.outputTypeCache.value;
 	}
 
-	getAttributes(): Attribute[] {
+	getAttributes(): readonly Attribute[] {
 		return this.attributesCache.value;
 	}
 
@@ -193,6 +236,8 @@ export class ProjectNode extends PlanNode implements UnaryRelationalNode {
 
 	override getLogicalAttributes(): Record<string, unknown> {
 		return {
+			projectionCount: this.projections.length,
+			uniqueKeys: this.getType().keys.map(k => k.map(ref => ref.index)),
 			projections: this.projections.map(p => ({
 				expression: expressionToString(p.node.expression),
 				alias: p.alias
@@ -240,4 +285,53 @@ export class ProjectNode extends PlanNode implements UnaryRelationalNode {
 			this.preserveInputColumns // Preserve the flag
 		);
 	}
+
+	// ProjectionCapable interface implementation
+	getProjections(): readonly { node: ScalarPlanNode; alias: string; attributeId: number }[] {
+		const attributes = this.getAttributes();
+		return this.projections.map((proj, index) => ({
+			node: proj.node,
+			alias: proj.alias || attributes[index].name,
+			attributeId: attributes[index].id
+		}));
+	}
+
+	withProjections(projections: readonly { node: ScalarPlanNode; alias: string; attributeId: number }[]): PlanNode {
+		// Convert to internal Projection format
+		const newProjections = projections.map(proj => ({
+			node: proj.node,
+			alias: proj.alias,
+			attributeId: proj.attributeId
+		}));
+
+		// Check if anything changed
+		const changed = newProjections.length !== this.projections.length ||
+			newProjections.some((proj, i) =>
+				proj.node !== this.projections[i].node ||
+				proj.alias !== this.projections[i].alias ||
+				proj.attributeId !== this.projections[i].attributeId
+			);
+
+		if (!changed) {
+			return this;
+		}
+
+		// Create predefined attributes from the new projections
+		const predefinedAttributes = projections.map(proj => ({
+			id: proj.attributeId,
+			name: proj.alias,
+			type: proj.node.getType(),
+			sourceRelation: `${this.nodeType}:${this.id}`,
+			relationName: 'projection'
+		}));
+
+		return new ProjectNode(
+			this.scope,
+			this.source,
+			newProjections,
+			undefined, // estimatedCostOverride
+			predefinedAttributes,
+			this.preserveInputColumns
+		);
+	}
 }

package/src/planner/nodes/recursive-cte-node.ts

@@ -3,13 +3,13 @@ import type { RelationType } from '../../common/datatype.js';
 import { PlanNodeType } from './plan-node-type.js';
 import type { Scope } from '../scopes/scope.js';
 import { Cached } from '../../util/cached.js';
-import type { CTEPlanNode } from './cte-node.js';
+import type { CTEPlanNode, CTEScopeNode } from './cte-node.js';
 
 /**
  * Plan node for Recursive Common Table Expressions.
  * This handles the special structure of recursive CTEs with base and recursive cases.
  */
-export class RecursiveCTENode extends PlanNode implements CTEPlanNode {
+export class RecursiveCTENode extends PlanNode implements CTEPlanNode, CTEScopeNode {
 	readonly nodeType = PlanNodeType.RecursiveCTE;
 	readonly isRecursive = true; // Always true for recursive CTEs
 	readonly tableDescriptor: TableDescriptor;
@@ -57,9 +57,9 @@ export class RecursiveCTENode extends PlanNode implements CTEPlanNode {
 
 		// Use explicit column names if provided, otherwise use base case column names
 		const baseCaseType = this.baseCaseQuery.getType();
-		const columnNames = this.columns || baseCaseType.columns.map((c: any) => c.name);
+		const columnNames = this.columns || baseCaseType.columns.map((c) => c.name);
 
-		return baseCaseAttributes.map((attr: any, index: number) => ({
+		return baseCaseAttributes.map((attr, index) => ({
 			id: attr.id, // Preserve original attribute ID for proper context resolution
 			name: columnNames[index] || attr.name,
 			type: attr.type,
@@ -71,8 +71,8 @@ export class RecursiveCTENode extends PlanNode implements CTEPlanNode {
 		return {
 			typeClass: 'relation',
 			isReadOnly: false,
-			isSet: !this.isUnionAll, // UNION creates a set, UNION ALL creates a bag
-			columns: this.getAttributes().map((attr: any) => ({
+			isSet: false, // Recursive CTEs can generate duplicates
+			columns: this.getAttributes().map((attr) => ({
 				name: attr.name,
 				type: attr.type
 			})),