@quereus/quereus 0.7.3 → 0.7.4

package/src/planner/nodes/create-index-node.ts

@@ -1,41 +0,0 @@
-import type * as AST from '../../parser/ast.js';
-import type { Scope } from '../scopes/scope.js';
-import { PhysicalProperties, VoidNode } from './plan-node.js';
-import { PlanNodeType } from './plan-node-type.js';
-import { astToString, expressionToString } from '../../util/ast-stringify.js';
-
-/**
- * Represents a CREATE INDEX statement in the logical query plan.
- */
-export class CreateIndexNode extends VoidNode {
-  override readonly nodeType = PlanNodeType.CreateIndex;
-
-  constructor(
-    scope: Scope,
-    public readonly statementAst: AST.CreateIndexStmt,
-  ) {
-    super(scope);
-  }
-
-  override toString(): string {
-    const uniquePrefix = this.statementAst.isUnique ? 'UNIQUE ' : '';
-    return `CREATE ${uniquePrefix}INDEX ${this.statementAst.index.name} ON ${this.statementAst.table.name}`;
-  }
-
-  override getLogicalAttributes(): Record<string, unknown> {
-    return {
-      index: this.statementAst.index.name,
-      table: this.statementAst.table.name,
-      schema: this.statementAst.table.schema,
-      isUnique: this.statementAst.isUnique,
-      ifNotExists: this.statementAst.ifNotExists,
-      columns: this.statementAst.columns.map(col => col.name || expressionToString(col.expr!)),
-      hasWhereClause: !!this.statementAst.where,
-      statement: astToString(this.statementAst)
-    };
-  }
-
-	override computePhysical(_children: readonly PhysicalProperties[]): Partial<PhysicalProperties> {
-		return { readonly: false };
-	}
-}

package/src/planner/nodes/create-table-node.ts

@@ -1,35 +0,0 @@
-import type * as AST from '../../parser/ast.js';
-import type { Scope } from '../scopes/scope.js';
-import { PhysicalProperties, VoidNode } from './plan-node.js';
-import { PlanNodeType } from './plan-node-type.js';
-import { astToString } from '../../util/ast-stringify.js';
-
-/**
- * Represents a CREATE TABLE statement in the logical query plan.
- */
-export class CreateTableNode extends VoidNode {
-  override readonly nodeType = PlanNodeType.CreateTable;
-
-  constructor(
-    scope: Scope,
-		public readonly statementAst: AST.CreateTableStmt,
-  ) {
-    super(scope);
-  }
-
-  override toString(): string {
-    return `CREATE TABLE ${this.statementAst.table.name}`;
-  }
-
-  override getLogicalAttributes(): Record<string, unknown> {
-    return {
-      table: this.statementAst.table.name,
-      schema: this.statementAst.table.schema,
-      statement: astToString(this.statementAst)
-    };
-  }
-
-	override computePhysical(_children: readonly PhysicalProperties[]): Partial<PhysicalProperties> {
-		return { readonly: false };
-	}
-}

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

@@ -1,44 +0,0 @@
-import type * as AST from '../../parser/ast.js';
-import { PhysicalProperties, VoidNode } from './plan-node.js';
-import { PlanNodeType } from './plan-node-type.js';
-import type { Scope } from '../scopes/scope.js';
-
-/**
- * Plan node for CREATE VIEW statements.
- * Creates a new view definition in the schema.
- */
-export class CreateViewNode extends VoidNode {
-	readonly nodeType = PlanNodeType.CreateView;
-
-	constructor(
-		scope: Scope,
-		public readonly viewName: string,
-		public readonly schemaName: string,
-		public readonly ifNotExists: boolean,
-		public readonly columns: string[] | undefined,
-		public readonly selectStmt: AST.SelectStmt,
-		public readonly sql: string
-	) {
-		super(scope, 1); // Low cost for DDL operations
-	}
-
-	override toString(): string {
-		const ifNotExistsClause = this.ifNotExists ? 'IF NOT EXISTS ' : '';
-		const columnsClause = this.columns ? `(${this.columns.join(', ')})` : '';
-		return `CREATE VIEW ${ifNotExistsClause}${this.schemaName}.${this.viewName}${columnsClause}`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			viewName: this.viewName,
-			schemaName: this.schemaName,
-			ifNotExists: this.ifNotExists,
-			columns: this.columns,
-			selectSql: this.sql
-		};
-	}
-
-	override computePhysical(_children: readonly PhysicalProperties[]): Partial<PhysicalProperties> {
-		return { readonly: false };
-	}
-}

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

@@ -1,168 +0,0 @@
-import { PlanNode, type UnaryRelationalNode, type RelationalPlanNode, type Attribute, type TableDescriptor, isRelationalNode } from './plan-node.js';
-import type { RelationType, ScalarType } 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 { CTECapable } from '../framework/characteristics.js';
-import { TEXT_TYPE } from '../../types/builtin-types.js';
-
-/**
- * Narrow contract that any node must satisfy to be placed in the CTE lookup map
- * while planning.  Both regular `CTENode`s and the internal placeholder used
- * for the recursive working table satisfy this contract.
- */
-export interface CTEScopeNode extends PlanNode {
-    /** Lower-cased CTE name */
-    readonly cteName: string;
-
-    /** Column metadata produced by this CTE when referenced */
-    getAttributes(): readonly Attribute[];
-
-    /** Relation type for the CTE output */
-    getType(): RelationType;
-}
-
-/**
- * Common interface for all CTE nodes (regular and recursive)
- */
-export interface CTEPlanNode extends UnaryRelationalNode {
-	readonly cteName: string;
-	readonly columns: string[] | undefined;
-	readonly materializationHint: 'materialized' | 'not_materialized' | undefined;
-	readonly isRecursive: boolean;
-	readonly tableDescriptor: TableDescriptor;
-}
-
-/**
- * Plan node for Common Table Expressions (CTEs).
- * This represents a single CTE definition within a WITH clause.
- */
-export class CTENode extends PlanNode implements CTEPlanNode, CTEScopeNode, CTECapable {
-	readonly nodeType = PlanNodeType.CTE;
-	readonly tableDescriptor: TableDescriptor = {}; // Identity object for table context lookup
-
-	private attributesCache: Cached<Attribute[]>;
-	private typeCache: Cached<RelationType>;
-
-	constructor(
-		scope: Scope,
-		public readonly cteName: string,
-		public readonly columns: string[] | undefined,
-		public readonly source: RelationalPlanNode,
-		public readonly materializationHint: 'materialized' | 'not_materialized' | undefined,
-		public readonly isRecursive: boolean = false
-	) {
-		super(scope, source.getTotalCost() + 10); // Add small overhead for CTE materialization
-		this.attributesCache = new Cached(() => this.buildAttributes());
-		this.typeCache = new Cached(() => this.buildType());
-	}
-
-	private buildAttributes(): Attribute[] {
-		const queryAttributes = this.source.getAttributes();
-		const queryType = this.source.getType();
-		// eslint-disable-next-line @typescript-eslint/no-explicit-any
-		const columnNames = this.columns || queryType.columns.map((c: any) => c.name);
-
-		return columnNames.map((name: string) => {
-			const srcAttr = queryAttributes.find(a => a.name.toLowerCase() === name.toLowerCase());
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			let resolvedType: any = srcAttr?.type;
-			if (!resolvedType) {
-				// eslint-disable-next-line @typescript-eslint/no-explicit-any
-				const colMeta = queryType.columns.find((c: any) => c.name.toLowerCase() === name.toLowerCase());
-				resolvedType = colMeta?.type;
-			}
-			// Fallback: generic TEXT scalar if nothing else is available (should not normally happen)
-			if (!resolvedType) {
-				resolvedType = { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: true, isReadOnly: false } satisfies ScalarType;
-			}
-			return {
-				id: srcAttr?.id ?? PlanNode.nextAttrId(),
-				name,
-				type: resolvedType,
-				sourceRelation: `cte:${this.cteName}`
-			};
-		});
-	}
-
-	private buildType(): RelationType {
-		const queryType = this.source.getType();
-		return {
-			typeClass: 'relation',
-			isReadOnly: false,
-			isSet: queryType.isSet, // CTEs preserve the set/bag nature of their query
-			// eslint-disable-next-line @typescript-eslint/no-explicit-any
-			columns: this.getAttributes().map((attr: any) => ({
-				name: attr.name,
-				type: attr.type
-			})),
-			keys: [], // CTEs don't have inherent keys
-			rowConstraints: []
-		};
-	}
-
-	getAttributes(): readonly Attribute[] {
-		return this.attributesCache.value;
-	}
-
-	getType(): RelationType {
-		return this.typeCache.value;
-	}
-
-	getChildren(): readonly [RelationalPlanNode] {
-		return [this.source];
-	}
-
-	getRelations(): readonly [RelationalPlanNode] {
-		return [this.source];
-	}
-
-	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== 1) {
-			throw new Error(`CTENode expects 1 child, got ${newChildren.length}`);
-		}
-
-		const [newSource] = newChildren;
-
-		// Type check
-		if (!isRelationalNode(newSource)) {
-			throw new Error('CTENode: child must be a RelationalPlanNode');
-		}
-
-		// Return same instance if nothing changed
-		if (newSource === this.source) {
-			return this;
-		}
-
-		// Create new instance with updated source
-		return new CTENode(
-			this.scope,
-			this.cteName,
-			this.columns,
-			newSource as RelationalPlanNode,
-			this.materializationHint,
-			this.isRecursive
-		);
-	}
-
-	getCTESource(): RelationalPlanNode {
-		return this.source;
-	}
-
-	override toString(): string {
-		const recursiveText = this.isRecursive ? 'RECURSIVE ' : '';
-		const columnsText = this.columns ? `(${this.columns.join(', ')})` : '';
-		const materializationText = this.materializationHint ? ` ${this.materializationHint.toUpperCase()}` : '';
-		return `${recursiveText}CTE ${this.cteName}${columnsText}${materializationText}`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			cteName: this.cteName,
-			columns: this.columns,
-			materializationHint: this.materializationHint,
-			isRecursive: this.isRecursive,
-			queryType: this.getType()
-		};
-	}
-}

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

@@ -1,125 +0,0 @@
-import { PlanNode, type RelationalPlanNode, type Attribute } 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';
-import type { CTEPlanNode } from './cte-node.js';
-import { Cached } from '../../util/cached.js';
-
-/**
- * Plan node for referencing a CTE in a FROM clause.
- * This points to a materialized CTE result.
- */
-export class CTEReferenceNode extends PlanNode implements RelationalPlanNode {
-	readonly nodeType = PlanNodeType.CTEReference;
-	private static nextRefId = 1;
-	public readonly referenceId: number;
-
-	// Cache of attributes to avoid regenerating new IDs on each plan rewrite
-	private attributesCache: Cached<Attribute[]>;
-	private typeCache: Cached<RelationType>;
-
-	constructor(
-		scope: Scope,
-		public readonly source: CTEPlanNode,
-		public readonly alias?: string,
-		/**
-		 * Optionally provide an attribute list to preserve attribute IDs across
-		 * plan rewrites (e.g. when `withChildren` creates a new instance). When
-		 * omitted, a fresh list will be generated the first time it is requested.
-		 */
-		private readonly existingAttributes?: Attribute[]
-	) {
-		super(scope, 5); // Low cost since CTEs are materialized
-		this.referenceId = CTEReferenceNode.nextRefId++;
-		this.attributesCache = new Cached(() => this.existingAttributes ?? this.buildAttributes());
-		this.typeCache = new Cached(() => this.buildType());
-	}
-
-	private buildAttributes(): Attribute[] {
-		// CRITICAL: Always create fresh attribute IDs for each CTE reference instance.
-		// Since we now cache CTEReferenceNode instances per alias in buildFrom(),
-		// each alias gets its own unique set of attribute IDs that remain consistent
-		// throughout the planning and execution phases.
-		const relationName = this.alias || this.source.cteName;
-		// Only use fresh IDs when we have an alias that differs from the CTE name
-		const useFreshIds = this.alias !== undefined && this.alias.toLowerCase() !== this.source.cteName.toLowerCase();
-		return this.source.getAttributes().map((attr) => ({
-			id: useFreshIds ? PlanNode.nextAttrId() : attr.id,
-			name: attr.name,
-			type: attr.type,
-			sourceRelation: `cte_ref:${this.source.cteName}`,
-			relationName
-		}));
-	}
-
-	private buildType(): RelationType {
-		const cteType = this.source.getType();
-		return {
-			typeClass: 'relation',
-			isReadOnly: false,
-			isSet: cteType.isSet,
-			columns: this.getAttributes().map(attr => ({
-				name: attr.name,
-				type: attr.type
-			})),
-			keys: [], // CTE references don't have inherent keys
-			rowConstraints: []
-		};
-	}
-
-	getAttributes(): Attribute[] {
-		return this.attributesCache.value;
-	}
-
-	getType(): RelationType {
-		return this.typeCache.value;
-	}
-
-	getChildren(): readonly [CTEPlanNode] {
-		return [this.source];
-	}
-
-	getRelations(): readonly [RelationalPlanNode] {
-		return [this.source];
-	}
-
-	withChildren(newChildren: readonly PlanNode[]): PlanNode {
-		if (newChildren.length !== 1) {
-			throw new Error(`CTEReferenceNode expects 1 child, got ${newChildren.length}`);
-		}
-
-		const [newSource] = newChildren;
-
-		// Type check
-		if (newSource.nodeType !== PlanNodeType.CTE && newSource.nodeType !== PlanNodeType.RecursiveCTE) {
-			throw new Error(`CTEReferenceNode: child (${newSource.nodeType}) must be a CTEPlanNode`);
-		}
-
-		// Return same instance if nothing changed
-		if (newSource === this.source) {
-			return this;
-		}
-
-		// Create new instance with updated source
-		return new CTEReferenceNode(
-			this.scope,
-			newSource as CTEPlanNode,
-			this.alias,
-			// Preserve the original attribute list so IDs remain stable across rewrites
-			this.getAttributes()
-		);
-	}
-
-	override toString(): string {
-		const aliasText = this.alias ? ` AS ${this.alias}` : '';
-		return `CTE_REF ${this.source.cteName}${aliasText}`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			cteName: this.source.cteName,
-			alias: this.alias,
-			materializationHint: this.source.materializationHint
-		};
-	}
-}

package/src/planner/nodes/declarative-schema.ts

@@ -1,221 +0,0 @@
-import { PlanNode, type VoidNode, type RelationalPlanNode, Attribute } from './plan-node.js';
-import { PlanNodeType } from './plan-node-type.js';
-import type { Scope } from '../scopes/scope.js';
-import type * as AST from '../../parser/ast.js';
-import { RelationType, type VoidType } from '../../common/datatype.js';
-import { TEXT_TYPE } from '../../types/builtin-types.js';
-
-/**
- * DECLARE SCHEMA statement plan node
- */
-export class DeclareSchemaNode extends PlanNode implements VoidNode {
-	override readonly nodeType = PlanNodeType.DeclareSchema;
-
-	constructor(
-		scope: Scope,
-		public readonly statementAst: AST.DeclareSchemaStmt
-	) {
-		super(scope, 1);
-	}
-
-	getType(): VoidType {
-		return { typeClass: 'void' };
-	}
-
-	getChildren(): PlanNode[] {
-		return [];
-	}
-
-	withChildren(_newChildren: readonly PlanNode[]): PlanNode {
-		return new DeclareSchemaNode(this.scope, this.statementAst);
-	}
-
-	override toString(): string {
-		return `DECLARE SCHEMA ${this.statementAst.schemaName || 'main'}`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			type: 'declareSchema',
-			schemaName: this.statementAst.schemaName || 'main',
-			itemCount: this.statementAst.items.length
-		};
-	}
-}
-
-/**
- * DIFF SCHEMA statement plan node - returns DDL statements as rows
- */
-export class DiffSchemaNode extends PlanNode implements RelationalPlanNode {
-	override readonly nodeType = PlanNodeType.DiffSchema;
-
-	constructor(
-		scope: Scope,
-		public readonly statementAst: AST.DiffSchemaStmt
-	) {
-		super(scope, 1);
-	}
-
-	getType(): RelationType {
-		return {
-			typeClass: 'relation',
-			isReadOnly: true,
-			isSet: false, // DDL statements can have duplicates (though unlikely)
-			columns: [
-				{
-					name: 'ddl',
-					type: {
-						typeClass: 'scalar',
-						logicalType: TEXT_TYPE,
-						nullable: false,
-						isReadOnly: true,
-					},
-					generated: true,
-				}
-			],
-			keys: [],
-			rowConstraints: [],
-		};
-	}
-
-	get estimatedRows(): number | undefined {
-		return 10; // Estimated number of migration statements
-	}
-
-	getAttributes(): Attribute[] {
-		return this.getType().columns.map((column) => ({
-			id: PlanNode.nextAttrId(),
-			name: column.name,
-			type: column.type,
-			sourceRelation: `${this.nodeType}:${this.id}`
-		}));
-	}
-
-	getChildren(): PlanNode[] {
-		return [];
-	}
-
-	withChildren(_newChildren: readonly PlanNode[]): PlanNode {
-		return new DiffSchemaNode(this.scope, this.statementAst);
-	}
-
-	override toString(): string {
-		return `DIFF SCHEMA ${this.statementAst.schemaName || 'main'}`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			type: 'diffSchema',
-			schemaName: this.statementAst.schemaName || 'main'
-		};
-	}
-}
-
-/**
- * APPLY SCHEMA statement plan node
- */
-export class ApplySchemaNode extends PlanNode implements VoidNode {
-	override readonly nodeType = PlanNodeType.ApplySchema;
-
-	constructor(
-		scope: Scope,
-		public readonly statementAst: AST.ApplySchemaStmt
-	) {
-		super(scope, 1);
-	}
-
-	getType(): VoidType {
-		return { typeClass: 'void' };
-	}
-
-	getChildren(): PlanNode[] {
-		return [];
-	}
-
-	withChildren(_newChildren: readonly PlanNode[]): PlanNode {
-		return new ApplySchemaNode(this.scope, this.statementAst);
-	}
-
-	override toString(): string {
-		return `APPLY SCHEMA ${this.statementAst.schemaName || 'main'}${this.statementAst.withSeed ? ' WITH SEED' : ''}`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			type: 'applySchema',
-			schemaName: this.statementAst.schemaName || 'main',
-			withSeed: this.statementAst.withSeed || false
-		};
-	}
-}
-
-/**
- * EXPLAIN SCHEMA statement plan node - returns result rows with hash info
- */
-export class ExplainSchemaNode extends PlanNode implements RelationalPlanNode {
-	override readonly nodeType = PlanNodeType.ExplainSchema;
-
-	constructor(
-		scope: Scope,
-		public readonly statementAst: AST.ExplainSchemaStmt
-	) {
-		super(scope, 1);
-	}
-
-	getType(): RelationType {
-		return {
-			typeClass: 'relation',
-			isReadOnly: true,
-			isSet: true,
-			columns: [
-				{
-					name: 'info',
-					type: {
-						typeClass: 'scalar',
-						logicalType: TEXT_TYPE,
-						nullable: false,
-						isReadOnly: true,
-					},
-					generated: true,
-				}
-			],
-			keys: [[]],
-			rowConstraints: [],
-		};
-	}
-
-	get estimatedRows(): number | undefined {
-		return 1;
-	}
-
-	getAttributes(): Attribute[] {
-		return this.getType().columns.map((column) => ({
-			id: PlanNode.nextAttrId(),
-			name: column.name,
-			type: column.type,
-			sourceRelation: `${this.nodeType}:${this.id}`
-		}));
-	}
-
-	getChildren(): PlanNode[] {
-		return [];
-	}
-
-	withChildren(_newChildren: readonly PlanNode[]): PlanNode {
-		return new ExplainSchemaNode(this.scope, this.statementAst);
-	}
-
-	override toString(): string {
-		return `EXPLAIN SCHEMA ${this.statementAst.schemaName || 'main'}`;
-	}
-
-	override getLogicalAttributes(): Record<string, unknown> {
-		return {
-			type: 'explainSchema',
-			schemaName: this.statementAst.schemaName || 'main',
-			version: this.statementAst.version
-		};
-	}
-}
-
-