@quereus/quereus 0.2.1 → 0.4.5

package/src/planner/nodes/table-function-call.ts

@@ -1,127 +1,134 @@
-import { PlanNodeType } from './plan-node-type.js';
-import { PlanNode, type RelationalPlanNode, type ScalarPlanNode, type Attribute } from './plan-node.js';
-import type { RelationType } from '../../common/datatype.js';
-import type { Scope } from '../scopes/scope.js';
-import type { FunctionSchema } from '../../schema/function.js';
-import { isTableValuedFunctionSchema } from '../../schema/function.js';
-import { Cached } from '../../util/cached.js';
-import { formatExpressionList } from '../../util/plan-formatter.js';
-
-/**
- * Represents a table-valued function call in the FROM clause.
- * This produces a relation from a function call like query_plan('SELECT ...').
- */
-export class TableFunctionCallNode extends PlanNode implements RelationalPlanNode {
-  override readonly nodeType = PlanNodeType.TableFunctionCall;
-
-  private attributesCache: Cached<Attribute[]>;
-
-  constructor(
-    scope: Scope,
-    public readonly functionName: string,
-    public readonly functionSchema: FunctionSchema,
-    public readonly operands: readonly ScalarPlanNode[],
-    public readonly alias?: string,
-    estimatedCostOverride?: number
-  ) {
-    super(scope, estimatedCostOverride ?? 1); // Default cost for function calls
-
-    this.attributesCache = new Cached(() => {
-      // Create attributes from function schema return type
-      if (isTableValuedFunctionSchema(this.functionSchema)) {
-        return this.functionSchema.returnType.columns.map((col) => ({
-          id: PlanNode.nextAttrId(),
-          name: col.name,
-          type: col.type,
-          sourceRelation: `${this.functionName}()`
-        }));
-      }
-      return [];
-    });
-  }
-
-  getType(): RelationType {
-    // Return the function's defined return type
-    if (isTableValuedFunctionSchema(this.functionSchema)) {
-      return this.functionSchema.returnType;
-    }
-
-    // Fallback for non-table-valued functions (shouldn't happen)
-    return {
-      typeClass: 'relation',
-      isReadOnly: true,
-      isSet: false, // Table functions can return duplicate rows (bags)
-      columns: [],
-      keys: [], // Functions don't typically have inherent keys
-      rowConstraints: [],
-    };
-  }
-
-  getAttributes(): Attribute[] {
-    return this.attributesCache.value;
-  }
-
-  getChildren(): readonly ScalarPlanNode[] {
-    return this.operands;
-  }
-
-  getRelations(): readonly [] {
-    return [];
-  }
-
-  withChildren(newChildren: readonly PlanNode[]): PlanNode {
-    if (newChildren.length !== this.operands.length) {
-      throw new Error(`TableFunctionCallNode expects ${this.operands.length} children, got ${newChildren.length}`);
-    }
-
-    // Type check
-    for (const child of newChildren) {
-      if (!('expression' in child)) {
-        throw new Error('TableFunctionCallNode: all children must be ScalarPlanNodes');
-      }
-    }
-
-    // Check if anything changed
-    const childrenChanged = newChildren.some((child, i) => child !== this.operands[i]);
-    if (!childrenChanged) {
-      return this;
-    }
-
-    // Create new instance
-    return new TableFunctionCallNode(
-      this.scope,
-      this.functionName,
-      this.functionSchema,
-      newChildren as ScalarPlanNode[],
-      this.alias
-    );
-  }
-
-  get estimatedRows(): number | undefined {
-    // Functions can return variable numbers of rows, so we'll use a default estimate
-    return 10; // Conservative estimate
-  }
-
-  override toString(): string {
-    const argsStr = formatExpressionList(this.operands);
-    const aliasStr = this.alias ? ` AS ${this.alias}` : '';
-    return `${this.functionName}(${argsStr})${aliasStr}`;
-  }
-
-  override getLogicalAttributes(): Record<string, unknown> {
-    const props: Record<string, unknown> = {
-      function: this.functionName,
-      arguments: this.operands.map(op => op.toString())
-    };
-
-    if (this.alias) {
-      props.alias = this.alias;
-    }
-
-    if (isTableValuedFunctionSchema(this.functionSchema)) {
-      props.columns = this.functionSchema.returnType.columns.map(col => col.name);
-    }
-
-    return props;
-  }
-}
+import { PlanNodeType } from './plan-node-type.js';
+import { PlanNode, type RelationalPlanNode, type ScalarPlanNode, type Attribute } from './plan-node.js';
+import type { RelationType } from '../../common/datatype.js';
+import type { Scope } from '../scopes/scope.js';
+import type { FunctionSchema } from '../../schema/function.js';
+import { isTableValuedFunctionSchema } from '../../schema/function.js';
+import { Cached } from '../../util/cached.js';
+import { formatExpressionList } from '../../util/plan-formatter.js';
+
+/**
+ * Represents a table-valued function call in the FROM clause.
+ * This produces a relation from a function call like query_plan('SELECT ...').
+ */
+export class TableFunctionCallNode extends PlanNode implements RelationalPlanNode {
+  override readonly nodeType = PlanNodeType.TableFunctionCall;
+
+  private attributesCache: Cached<Attribute[]>;
+
+  constructor(
+    scope: Scope,
+    public readonly functionName: string,
+    public readonly functionSchema: FunctionSchema,
+    public readonly operands: readonly ScalarPlanNode[],
+    public readonly alias?: string,
+    public readonly aliasColumns?: readonly string[],
+    estimatedCostOverride?: number
+  ) {
+    super(scope, estimatedCostOverride ?? 1); // Default cost for function calls
+
+    this.attributesCache = new Cached(() => {
+      // Create attributes from function schema return type
+      if (isTableValuedFunctionSchema(this.functionSchema)) {
+        const renamed = this.functionSchema.returnType.columns.map((col, i) => ({
+          id: PlanNode.nextAttrId(),
+          name: (this.aliasColumns && this.aliasColumns[i]) ? this.aliasColumns[i] : col.name,
+          type: col.type,
+          sourceRelation: `${this.functionName}()`
+        }));
+        return renamed;
+      }
+      return [];
+    });
+  }
+
+  getType(): RelationType {
+    // Return the function's defined return type
+    if (isTableValuedFunctionSchema(this.functionSchema)) {
+      return this.functionSchema.returnType;
+    }
+
+    // Fallback for non-table-valued functions (shouldn't happen)
+    return {
+      typeClass: 'relation',
+      isReadOnly: true,
+      isSet: false, // Table functions can return duplicate rows (bags)
+      columns: [],
+      keys: [], // Functions don't typically have inherent keys
+      rowConstraints: [],
+    };
+  }
+
+  getAttributes(): Attribute[] {
+    return this.attributesCache.value;
+  }
+
+  getChildren(): readonly ScalarPlanNode[] {
+    return this.operands;
+  }
+
+  getRelations(): readonly [] {
+    return [];
+  }
+
+  withChildren(newChildren: readonly PlanNode[]): PlanNode {
+    if (newChildren.length !== this.operands.length) {
+      throw new Error(`TableFunctionCallNode expects ${this.operands.length} children, got ${newChildren.length}`);
+    }
+
+    // Type check
+    for (const child of newChildren) {
+      if (!('expression' in child)) {
+        throw new Error('TableFunctionCallNode: all children must be ScalarPlanNodes');
+      }
+    }
+
+    // Check if anything changed
+    const childrenChanged = newChildren.some((child, i) => child !== this.operands[i]);
+    if (!childrenChanged) {
+      return this;
+    }
+
+    // Create new instance
+    return new TableFunctionCallNode(
+      this.scope,
+      this.functionName,
+      this.functionSchema,
+      newChildren as ScalarPlanNode[],
+      this.alias,
+      this.aliasColumns
+    );
+  }
+
+  get estimatedRows(): number | undefined {
+    // Functions can return variable numbers of rows, so we'll use a default estimate
+    return 10; // Conservative estimate
+  }
+
+  override toString(): string {
+    const argsStr = formatExpressionList(this.operands);
+    const aliasColsStr = this.aliasColumns && this.aliasColumns.length > 0 ? `(${this.aliasColumns.join(', ')})` : '';
+    const aliasStr = this.alias ? ` AS ${this.alias}${aliasColsStr}` : '';
+    return `${this.functionName}(${argsStr})${aliasStr}`;
+  }
+
+  override getLogicalAttributes(): Record<string, unknown> {
+    const props: Record<string, unknown> = {
+      function: this.functionName,
+      arguments: this.operands.map(op => op.toString())
+    };
+
+    if (this.alias) {
+      props.alias = this.alias;
+    }
+    if (this.aliasColumns && this.aliasColumns.length > 0) {
+      props.aliasColumns = [...this.aliasColumns];
+    }
+
+    if (isTableValuedFunctionSchema(this.functionSchema)) {
+      props.columns = this.functionSchema.returnType.columns.map(col => col.name);
+    }
+
+    return props;
+  }
+}

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

@@ -2,7 +2,7 @@ import { VoidNode } from './plan-node.js';
 import { PlanNodeType } from './plan-node-type.js';
 import type { Scope } from '../scopes/scope.js';
 import * as AST from '../../parser/ast.js';
-import { expressionToString } from '../../util/ast-stringify.js';
+import { astToString } from '../../util/ast-stringify.js';
 
 export interface TransactionNode extends VoidNode {
 	nodeType: PlanNodeType.Transaction;
@@ -45,7 +45,7 @@ export class TransactionPlanNode extends VoidNode implements TransactionNode {
 	override getLogicalAttributes(): Record<string, unknown> {
 		const props: Record<string, unknown> = {
 			operation: this.operation,
-			statement: expressionToString(this.statementAst as any)
+			statement: astToString(this.statementAst)
 		};
 
 		if (this.mode) {

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

@@ -1,132 +1,138 @@
-import type * as AST from '../../parser/ast.js';
-import type { Scope } from '../scopes/scope.js';
-import { PlanNode, type RelationalPlanNode, type Attribute, type RowDescriptor, isRelationalNode } from './plan-node.js';
-import { PlanNodeType } from './plan-node-type.js';
-import type { TableReferenceNode } from './reference.js';
-import type { ScalarPlanNode } from './plan-node.js';
-import type { ConflictResolution } from '../../common/constants.js';
-import type { RelationType } from '../../common/datatype.js';
-import { formatExpression } from '../../util/plan-formatter.js';
-import { buildAttributesFromFlatDescriptor } from '../../util/row-descriptor.js';
-import type { PhysicalProperties } from './plan-node.js';
-
-export interface UpdateAssignment {
-  targetColumn: AST.ColumnExpr; // Could be resolved ColumnReferenceNode or just index
-  value: ScalarPlanNode;
-}
-
-/**
- * Represents an UPDATE statement in the logical query plan.
- */
-export class UpdateNode extends PlanNode implements RelationalPlanNode {
-  override readonly nodeType = PlanNodeType.Update;
-
-  constructor(
-    scope: Scope,
-    public readonly table: TableReferenceNode,
-    public readonly assignments: ReadonlyArray<UpdateAssignment>,
-    		public readonly source: RelationalPlanNode, // Typically a FilterNode wrapping a TableReferenceNode
-		public readonly onConflict: ConflictResolution | undefined,
-    public readonly oldRowDescriptor: RowDescriptor, // For constraint checking
-    public readonly newRowDescriptor: RowDescriptor, // For constraint checking
-    public readonly flatRowDescriptor: RowDescriptor, // For flat OLD/NEW row attributes
-  ) {
-    super(scope);
-  }
-
-	getType(): RelationType {
-		return this.source.getType();
-	}
-
-  getAttributes(): Attribute[] {
-    return buildAttributesFromFlatDescriptor(this.flatRowDescriptor);
-  }
-
-  getRelations(): readonly [RelationalPlanNode, TableReferenceNode] {
-    // The source provides rows to be updated, table is the target of updates.
-    return [this.source, this.table];
-  }
-
-  getChildren(): readonly PlanNode[] {
-    // Return ALL child nodes: the source relation and the scalar assignment values
-    return [this.source, ...this.assignments.map(a => a.value)];
-  }
-
-  withChildren(newChildren: readonly PlanNode[]): PlanNode {
-    const expectedChildCount = 1 + this.assignments.length; // source + assignment values
-    if (newChildren.length !== expectedChildCount) {
-      throw new Error(`UpdateNode expects ${expectedChildCount} children (1 source + ${this.assignments.length} assignments), got ${newChildren.length}`);
-    }
-
-    // First child is the source
-    const newSource = newChildren[0] as RelationalPlanNode;
-    if (!isRelationalNode(newSource)) {
-      throw new Error('UpdateNode: first child must be a RelationalPlanNode (source)');
-    }
-
-    // Remaining children are assignment values
-    const newAssignmentValues = newChildren.slice(1);
-    for (const child of newAssignmentValues) {
-      if (!('expression' in child)) {
-        throw new Error('UpdateNode: assignment children must be ScalarPlanNodes');
-      }
-    }
-
-    // Check if anything changed
-    const sourceChanged = newSource !== this.source;
-    const assignmentsChanged = newAssignmentValues.some((child, i) => child !== this.assignments[i].value);
-
-    if (!sourceChanged && !assignmentsChanged) {
-      return this;
-    }
-
-    // Create new assignments with updated values
-    const newAssignments = this.assignments.map((assignment, i) => ({
-      targetColumn: assignment.targetColumn,
-      value: newAssignmentValues[i] as ScalarPlanNode
-    }));
-
-    // Create new instance
-    return new UpdateNode(
-      this.scope,
-      this.table,
-      newAssignments,
-      newSource,
-      this.onConflict,
-      this.oldRowDescriptor,
-      this.newRowDescriptor,
-      this.flatRowDescriptor
-    );
-  }
-
-  computePhysical(): Partial<PhysicalProperties> {
-    return {
-      readonly: false,  // UPDATE has side effects
-    };
-  }
-
-  get estimatedRows(): number | undefined {
-    return this.source.estimatedRows;
-  }
-
-  override toString(): string {
-    return `UPDATE ${this.table.tableSchema.name}`;
-  }
-
-  override getLogicalAttributes(): Record<string, unknown> {
-    const props: Record<string, unknown> = {
-      table: this.table.tableSchema.name,
-      schema: this.table.tableSchema.schemaName,
-      assignments: this.assignments.map(assign => ({
-        column: assign.targetColumn.name,
-        value: formatExpression(assign.value)
-      }))
-    };
-
-    if (this.onConflict) {
-      props.onConflict = this.onConflict;
-    }
-
-    return props;
-  }
-}
+import type * as AST from '../../parser/ast.js';
+import type { Scope } from '../scopes/scope.js';
+import { PlanNode, type RelationalPlanNode, type Attribute, type RowDescriptor, isRelationalNode } from './plan-node.js';
+import { PlanNodeType } from './plan-node-type.js';
+import type { TableReferenceNode } from './reference.js';
+import type { ScalarPlanNode } from './plan-node.js';
+import type { ConflictResolution } from '../../common/constants.js';
+import type { RelationType } from '../../common/datatype.js';
+import { formatExpression } from '../../util/plan-formatter.js';
+import { buildAttributesFromFlatDescriptor } from '../../util/row-descriptor.js';
+import type { PhysicalProperties } from './plan-node.js';
+
+export interface UpdateAssignment {
+  targetColumn: AST.ColumnExpr; // Could be resolved ColumnReferenceNode or just index
+  value: ScalarPlanNode;
+}
+
+/**
+ * Represents an UPDATE statement in the logical query plan.
+ */
+export class UpdateNode extends PlanNode implements RelationalPlanNode {
+  override readonly nodeType = PlanNodeType.Update;
+
+  constructor(
+    scope: Scope,
+    public readonly table: TableReferenceNode,
+    public readonly assignments: ReadonlyArray<UpdateAssignment>,
+    		public readonly source: RelationalPlanNode, // Typically a FilterNode wrapping a TableReferenceNode
+		public readonly onConflict: ConflictResolution | undefined,
+    public readonly oldRowDescriptor: RowDescriptor, // For constraint checking
+    public readonly newRowDescriptor: RowDescriptor, // For constraint checking
+    public readonly flatRowDescriptor: RowDescriptor, // For flat OLD/NEW row attributes
+    public readonly mutationContextValues?: Map<string, ScalarPlanNode>, // Mutation context value expressions
+    public readonly contextAttributes?: Attribute[], // Mutation context attributes
+    public readonly contextDescriptor?: RowDescriptor, // Mutation context row descriptor
+  ) {
+    super(scope);
+  }
+
+	getType(): RelationType {
+		return this.source.getType();
+	}
+
+  getAttributes(): Attribute[] {
+    return buildAttributesFromFlatDescriptor(this.flatRowDescriptor);
+  }
+
+  getRelations(): readonly [RelationalPlanNode, TableReferenceNode] {
+    // The source provides rows to be updated, table is the target of updates.
+    return [this.source, this.table];
+  }
+
+  getChildren(): readonly PlanNode[] {
+    // Return ALL child nodes: the source relation and the scalar assignment values
+    return [this.source, ...this.assignments.map(a => a.value)];
+  }
+
+  withChildren(newChildren: readonly PlanNode[]): PlanNode {
+    const expectedChildCount = 1 + this.assignments.length; // source + assignment values
+    if (newChildren.length !== expectedChildCount) {
+      throw new Error(`UpdateNode expects ${expectedChildCount} children (1 source + ${this.assignments.length} assignments), got ${newChildren.length}`);
+    }
+
+    // First child is the source
+    const newSource = newChildren[0] as RelationalPlanNode;
+    if (!isRelationalNode(newSource)) {
+      throw new Error('UpdateNode: first child must be a RelationalPlanNode (source)');
+    }
+
+    // Remaining children are assignment values
+    const newAssignmentValues = newChildren.slice(1);
+    for (const child of newAssignmentValues) {
+      if (!('expression' in child)) {
+        throw new Error('UpdateNode: assignment children must be ScalarPlanNodes');
+      }
+    }
+
+    // Check if anything changed
+    const sourceChanged = newSource !== this.source;
+    const assignmentsChanged = newAssignmentValues.some((child, i) => child !== this.assignments[i].value);
+
+    if (!sourceChanged && !assignmentsChanged) {
+      return this;
+    }
+
+    // Create new assignments with updated values
+    const newAssignments = this.assignments.map((assignment, i) => ({
+      targetColumn: assignment.targetColumn,
+      value: newAssignmentValues[i] as ScalarPlanNode
+    }));
+
+    // Create new instance
+    return new UpdateNode(
+      this.scope,
+      this.table,
+      newAssignments,
+      newSource,
+      this.onConflict,
+      this.oldRowDescriptor,
+      this.newRowDescriptor,
+      this.flatRowDescriptor,
+      this.mutationContextValues,
+      this.contextAttributes,
+      this.contextDescriptor
+    );
+  }
+
+  computePhysical(): Partial<PhysicalProperties> {
+    return {
+      readonly: false,  // UPDATE has side effects
+    };
+  }
+
+  get estimatedRows(): number | undefined {
+    return this.source.estimatedRows;
+  }
+
+  override toString(): string {
+    return `UPDATE ${this.table.tableSchema.name}`;
+  }
+
+  override getLogicalAttributes(): Record<string, unknown> {
+    const props: Record<string, unknown> = {
+      table: this.table.tableSchema.name,
+      schema: this.table.tableSchema.schemaName,
+      assignments: this.assignments.map(assign => ({
+        column: assign.targetColumn.name,
+        value: formatExpression(assign.value)
+      }))
+    };
+
+    if (this.onConflict) {
+      props.onConflict = this.onConflict;
+    }
+
+    return props;
+  }
+}

package/src/planner/nodes/view-reference-node.ts

@@ -49,7 +49,7 @@ export class ViewReferenceNode extends PlanNode implements ZeroAryRelationalNode
 			typeClass: 'relation',
 			isReadOnly: false,
 			isSet: false, // Views can contain duplicates unless they have DISTINCT
-			columns: this.getAttributes().map((attr: any) => ({
+			columns: this.getAttributes().map((attr) => ({
 				name: attr.name,
 				type: attr.type
 			})),

package/src/planner/nodes/window-function.ts

@@ -30,10 +30,10 @@ export class WindowFunctionCallNode extends PlanNode implements ZeroAryScalarNod
 			// Most window functions return numeric types
 			// row_number() specifically returns an integer
 			if (this.functionName === 'row_number') {
-				return { typeClass: 'scalar', affinity: SqlDataType.INTEGER, nullable: false } as ScalarType;
+				return { typeClass: 'scalar', affinity: SqlDataType.INTEGER, nullable: false } satisfies ScalarType;
 			}
 			// Other window functions would have their own type inference
-			return { typeClass: 'scalar', affinity: SqlDataType.NUMERIC, nullable: false } as ScalarType;
+			return { typeClass: 'scalar', affinity: SqlDataType.NUMERIC, nullable: false } satisfies ScalarType;
 		});
 	}
 

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

@@ -53,7 +53,7 @@ export class WindowNode extends PlanNode implements UnaryRelationalNode {
 				columns: [...sourceType.columns, ...windowColumns],
 				keys: sourceType.keys, // Window functions don't change key structure
 				rowConstraints: sourceType.rowConstraints,
-			} as RelationType;
+			} satisfies RelationType;
 		});
 
 		this.attributesCache = new Cached(() => {

package/src/planner/optimizer-tuning.ts

@@ -53,6 +53,18 @@ export interface OptimizerTuning {
 		/** Whether to validate physical plans before emission */
 		readonly validatePlan: boolean;
 	};
+
+	/** QuickPick join enumeration tuning */
+	readonly quickpick?: {
+		/** Maximum number of random greedy tours to evaluate */
+		readonly maxTours: number;
+		/** Time limit in milliseconds for enumeration (soft cap) */
+		readonly timeLimitMs: number;
+		/** Minimum estimated plan cost to trigger enumeration */
+		readonly minTriggerCost: number;
+		/** Enable/disable QuickPick globally */
+		readonly enabled: boolean;
+	};
 }
 
 /**
@@ -83,5 +95,11 @@ export const DEFAULT_TUNING: OptimizerTuning = {
 	},
 	debug: {
 		validatePlan: false // Default to disabled in production
+	},
+	quickpick: {
+		maxTours: 100,
+		timeLimitMs: 100,
+		minTriggerCost: 0,
+		enabled: true
 	}
 };