@quereus/quereus 0.2.1 → 0.4.5

package/src/planner/building/pragma.ts

@@ -17,6 +17,7 @@ export function buildPragmaStmt(ctx: PlanningContext, stmt: AST.PragmaStmt): Pla
 		} else if (stmt.value.type === 'identifier') {
 			value = stmt.value.name;
 		} else {
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
 			throw new QuereusError(`Unsupported PRAGMA value type: ${(stmt.value as any).type}`, StatusCode.ERROR);
 		}
 	}

package/src/planner/building/schema-resolution.ts

@@ -1,176 +1,176 @@
-import type { PlanningContext, SchemaDependency } from '../planning-context.js';
-import type { TableSchema } from '../../schema/table.js';
-import type { FunctionSchema } from '../../schema/function.js';
-import type { VirtualTableModule } from '../../vtab/module.js';
-import type { CollationFunction } from '../../util/comparison.js';
-import { QuereusError } from '../../common/errors.js';
-import { StatusCode } from '../../common/types.js';
-import { createLogger } from '../../common/logger.js';
-
-const log = createLogger('planner:schema-resolution');
-
-/**
- * Resolves a table schema at build time and records the dependency.
- */
-export function resolveTableSchema(
-	ctx: PlanningContext,
-	tableName: string,
-	schemaName?: string
-): TableSchema {
-	const resolvedSchemaName = schemaName || ctx.db.schemaManager.getCurrentSchemaName();
-	const cacheKey = `table:${resolvedSchemaName}:${tableName}`;
-
-	// Check cache first
-	const cached = ctx.schemaCache.get(cacheKey);
-	if (cached) {
-		log('Using cached table schema: %s.%s', resolvedSchemaName, tableName);
-		return cached as TableSchema;
-	}
-
-	// Resolve table schema
-	const tableSchema = ctx.schemaManager.findTable(tableName, resolvedSchemaName);
-	if (!tableSchema) {
-		throw new QuereusError(
-			`Table not found: ${resolvedSchemaName}.${tableName}`,
-			StatusCode.ERROR
-		);
-	}
-
-	// Record dependency
-	const dependency: SchemaDependency = {
-		type: 'table',
-		schemaName: tableSchema.schemaName,
-		objectName: tableSchema.name
-	};
-	ctx.schemaDependencies.recordDependency(dependency, tableSchema);
-
-	// Cache result
-	ctx.schemaCache.set(cacheKey, tableSchema);
-
-	log('Resolved table schema: %s.%s', tableSchema.schemaName, tableSchema.name);
-	return tableSchema;
-}
-
-/**
- * Resolves a function schema at build time and records the dependency.
- */
-export function resolveFunctionSchema(
-	ctx: PlanningContext,
-	funcName: string,
-	numArgs: number
-): FunctionSchema {
-	const cacheKey = `function:${funcName}/${numArgs}`;
-
-	// Check cache first
-	const cached = ctx.schemaCache.get(cacheKey);
-	if (cached) {
-		log('Using cached function schema: %s/%d', funcName, numArgs);
-		return cached as FunctionSchema;
-	}
-
-	// Resolve function schema - try exact match first
-	let functionSchema = ctx.schemaManager.findFunction(funcName, numArgs);
-
-	// If not found, try variable argument function
-	if (!functionSchema) {
-		functionSchema = ctx.schemaManager.findFunction(funcName, -1);
-	}
-
-	if (!functionSchema) {
-		throw new QuereusError(
-			`Function not found: ${funcName}/${numArgs}`,
-			StatusCode.ERROR
-		);
-	}
-
-	// Record dependency using the actual function's numArgs
-	const dependency: SchemaDependency = {
-		type: 'function',
-		objectName: `${functionSchema.name}/${functionSchema.numArgs}`
-	};
-	ctx.schemaDependencies.recordDependency(dependency, functionSchema);
-
-	// Cache result with the requested key for future lookups
-	ctx.schemaCache.set(cacheKey, functionSchema);
-
-	log('Resolved function schema: %s/%d', functionSchema.name, functionSchema.numArgs);
-	return functionSchema;
-}
-
-/**
- * Resolves a virtual table module at build time and records the dependency.
- */
-export function resolveVtabModule(
-	ctx: PlanningContext,
-	moduleName: string
-): { module: VirtualTableModule<any, any>, auxData?: unknown } {
-	const cacheKey = `vtab_module:${moduleName}`;
-
-	// Check cache first
-	const cached = ctx.schemaCache.get(cacheKey);
-	if (cached) {
-		log('Using cached vtab module: %s', moduleName);
-		return cached;
-	}
-
-	// Resolve vtab module
-	const moduleInfo = ctx.schemaManager.getModule(moduleName);
-	if (!moduleInfo) {
-		throw new QuereusError(
-			`Virtual table module not found: ${moduleName}`,
-			StatusCode.ERROR
-		);
-	}
-
-	// Record dependency
-	const dependency: SchemaDependency = {
-		type: 'vtab_module',
-		objectName: moduleName
-	};
-	ctx.schemaDependencies.recordDependency(dependency, moduleInfo);
-
-	// Cache result
-	ctx.schemaCache.set(cacheKey, moduleInfo);
-
-	log('Resolved vtab module: %s', moduleName);
-	return moduleInfo;
-}
-
-/**
- * Resolves a collation function at build time and records the dependency.
- */
-export function resolveCollation(
-	ctx: PlanningContext,
-	collationName: string
-): CollationFunction {
-	const cacheKey = `collation:${collationName}`;
-
-	// Check cache first
-	const cached = ctx.schemaCache.get(cacheKey);
-	if (cached) {
-		log('Using cached collation: %s', collationName);
-		return cached as CollationFunction;
-	}
-
-	// Resolve collation
-	const collation = ctx.db._getCollation(collationName);
-	if (!collation) {
-		throw new QuereusError(
-			`Collation not found: ${collationName}`,
-			StatusCode.ERROR
-		);
-	}
-
-	// Record dependency
-	const dependency: SchemaDependency = {
-		type: 'collation',
-		objectName: collationName
-	};
-	ctx.schemaDependencies.recordDependency(dependency, collation);
-
-	// Cache result
-	ctx.schemaCache.set(cacheKey, collation);
-
-	log('Resolved collation: %s', collationName);
-	return collation;
-}
+import type { PlanningContext, SchemaDependency } from '../planning-context.js';
+import type { TableSchema } from '../../schema/table.js';
+import type { FunctionSchema } from '../../schema/function.js';
+import type { AnyVirtualTableModule } from '../../vtab/module.js';
+import type { CollationFunction } from '../../util/comparison.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+import { createLogger } from '../../common/logger.js';
+
+const log = createLogger('planner:schema-resolution');
+
+/**
+ * Resolves a table schema at build time and records the dependency.
+ */
+export function resolveTableSchema(
+	ctx: PlanningContext,
+	tableName: string,
+	schemaName?: string
+): TableSchema {
+	const resolvedSchemaName = schemaName || ctx.db.schemaManager.getCurrentSchemaName();
+	const cacheKey = `table:${resolvedSchemaName}:${tableName}`;
+
+	// Check cache first
+	const cached = ctx.schemaCache.get(cacheKey);
+	if (cached) {
+		log('Using cached table schema: %s.%s', resolvedSchemaName, tableName);
+		return cached as TableSchema;
+	}
+
+	// Resolve table schema
+	const tableSchema = ctx.schemaManager.findTable(tableName, resolvedSchemaName);
+	if (!tableSchema) {
+		throw new QuereusError(
+			`Table not found: ${resolvedSchemaName}.${tableName}`,
+			StatusCode.ERROR
+		);
+	}
+
+	// Record dependency
+	const dependency: SchemaDependency = {
+		type: 'table',
+		schemaName: tableSchema.schemaName,
+		objectName: tableSchema.name
+	};
+	ctx.schemaDependencies.recordDependency(dependency, tableSchema);
+
+	// Cache result
+	ctx.schemaCache.set(cacheKey, tableSchema);
+
+	log('Resolved table schema: %s.%s', tableSchema.schemaName, tableSchema.name);
+	return tableSchema;
+}
+
+/**
+ * Resolves a function schema at build time and records the dependency.
+ */
+export function resolveFunctionSchema(
+	ctx: PlanningContext,
+	funcName: string,
+	numArgs: number
+): FunctionSchema {
+	const cacheKey = `function:${funcName}/${numArgs}`;
+
+	// Check cache first
+	const cached = ctx.schemaCache.get(cacheKey);
+	if (cached) {
+		log('Using cached function schema: %s/%d', funcName, numArgs);
+		return cached as FunctionSchema;
+	}
+
+	// Resolve function schema - try exact match first
+	let functionSchema = ctx.schemaManager.findFunction(funcName, numArgs);
+
+	// If not found, try variable argument function
+	if (!functionSchema) {
+		functionSchema = ctx.schemaManager.findFunction(funcName, -1);
+	}
+
+	if (!functionSchema) {
+		throw new QuereusError(
+			`Function not found: ${funcName}/${numArgs}`,
+			StatusCode.ERROR
+		);
+	}
+
+	// Record dependency using the actual function's numArgs
+	const dependency: SchemaDependency = {
+		type: 'function',
+		objectName: `${functionSchema.name}/${functionSchema.numArgs}`
+	};
+	ctx.schemaDependencies.recordDependency(dependency, functionSchema);
+
+	// Cache result with the requested key for future lookups
+	ctx.schemaCache.set(cacheKey, functionSchema);
+
+	log('Resolved function schema: %s/%d', functionSchema.name, functionSchema.numArgs);
+	return functionSchema;
+}
+
+/**
+ * Resolves a virtual table module at build time and records the dependency.
+ */
+export function resolveVtabModule(
+	ctx: PlanningContext,
+	moduleName: string
+): { module: AnyVirtualTableModule, auxData?: unknown } {
+	const cacheKey = `vtab_module:${moduleName}`;
+
+	// Check cache first
+	const cached = ctx.schemaCache.get(cacheKey);
+	if (cached) {
+		log('Using cached vtab module: %s', moduleName);
+		return cached;
+	}
+
+	// Resolve vtab module
+	const moduleInfo = ctx.schemaManager.getModule(moduleName);
+	if (!moduleInfo) {
+		throw new QuereusError(
+			`Virtual table module not found: ${moduleName}`,
+			StatusCode.ERROR
+		);
+	}
+
+	// Record dependency
+	const dependency: SchemaDependency = {
+		type: 'vtab_module',
+		objectName: moduleName
+	};
+	ctx.schemaDependencies.recordDependency(dependency, moduleInfo);
+
+	// Cache result
+	ctx.schemaCache.set(cacheKey, moduleInfo);
+
+	log('Resolved vtab module: %s', moduleName);
+	return moduleInfo;
+}
+
+/**
+ * Resolves a collation function at build time and records the dependency.
+ */
+export function resolveCollation(
+	ctx: PlanningContext,
+	collationName: string
+): CollationFunction {
+	const cacheKey = `collation:${collationName}`;
+
+	// Check cache first
+	const cached = ctx.schemaCache.get(cacheKey);
+	if (cached) {
+		log('Using cached collation: %s', collationName);
+		return cached as CollationFunction;
+	}
+
+	// Resolve collation
+	const collation = ctx.db._getCollation(collationName);
+	if (!collation) {
+		throw new QuereusError(
+			`Collation not found: ${collationName}`,
+			StatusCode.ERROR
+		);
+	}
+
+	// Record dependency
+	const dependency: SchemaDependency = {
+		type: 'collation',
+		objectName: collationName
+	};
+	ctx.schemaDependencies.recordDependency(dependency, collation);
+
+	// Cache result
+	ctx.schemaCache.set(cacheKey, collation);
+
+	log('Resolved collation: %s', collationName);
+	return collation;
+}

package/src/planner/building/select-aggregates.ts

@@ -10,6 +10,8 @@ import { ColumnReferenceNode } from '../nodes/reference.js';
 import { buildExpression } from './expression.js';
 import { QuereusError } from '../../common/errors.js';
 import { StatusCode } from '../../common/types.js';
+import { CapabilityDetectors } from '../framework/characteristics.js';
+import { Scope } from '../scopes/scope.js';
 
 /**
  * Processes GROUP BY, aggregates, and HAVING clauses
@@ -143,7 +145,7 @@ function validateAggregateProjections(
  * Creates a scope that includes the aggregate output columns
  */
 function createAggregateOutputScope(
-	parentScope: any,
+	parentScope: Scope,
 	aggregateNode: RelationalPlanNode,
 	groupByExpressions: ScalarPlanNode[],
 	aggregates: { expression: ScalarPlanNode; alias: string }[]
@@ -254,7 +256,7 @@ function checkNeedsFinalProjection(projections: Projection[]): boolean {
 	// Check if any of the projections are complex expressions (not just column refs)
 	return projections.some(proj => {
 		// If it's not a simple ColumnReferenceNode, we need final projection
-		return !(proj.node instanceof ColumnReferenceNode);
+		return !CapabilityDetectors.isColumnReference(proj.node);
 	});
 }
 
@@ -275,7 +277,7 @@ export function buildFinalAggregateProjections(
 			const scalarNode = buildExpression(finalContext, column.expr, true);
 
 			let attrId: number | undefined = undefined;
-			if (scalarNode instanceof ColumnReferenceNode) {
+			if (CapabilityDetectors.isColumnReference(scalarNode)) {
 				attrId = scalarNode.attributeId;
 			}
 

package/src/planner/building/select-compound.ts

@@ -1,7 +1,8 @@
 import type * as AST from '../../parser/ast.js';
 import type { RelationalPlanNode } from '../nodes/plan-node.js';
 import type { PlanningContext } from '../planning-context.js';
-import type { CTEPlanNode } from '../nodes/cte-node.js';
+import type { CTEScopeNode } from '../nodes/cte-node.js';
+import type { Scope } from '../scopes/scope.js';
 import { SetOperationNode } from '../nodes/set-operation-node.js';
 import { SortNode, type SortKey } from '../nodes/sort.js';
 import { LimitOffsetNode } from '../nodes/limit-offset.js';
@@ -19,23 +20,31 @@ import { StatusCode } from '../../common/types.js';
 export function buildCompoundSelect(
 	stmt: AST.SelectStmt,
 	contextWithCTEs: PlanningContext,
-	cteNodes: Map<string, CTEPlanNode>,
-	buildSelectStmt: (ctx: PlanningContext, stmt: AST.SelectStmt, parentCTEs?: Map<string, CTEPlanNode>) => RelationalPlanNode
+	cteNodes: Map<string, CTEScopeNode>,
+	buildSelectStmt: (ctx: PlanningContext, stmt: AST.SelectStmt, parentCTEs?: Map<string, CTEScopeNode>) => RelationalPlanNode
 ): RelationalPlanNode {
 	if (!stmt.compound) {
 		throw new QuereusError('buildCompoundSelect called without compound clause', StatusCode.INTERNAL);
 	}
 
 	// Build left side by cloning the statement without compound and stripping ORDER BY/LIMIT/OFFSET that belong to outer query
-	const { compound: _outerCompound, orderBy: outerOrderBy, limit: outerLimit, offset: outerOffset, ...leftCore } = stmt as any;
+	const { compound: _outerCompound, orderBy: outerOrderBy, limit: outerLimit, offset: outerOffset, ...leftCore } = stmt;
 
 	// Also strip ORDER BY/LIMIT/OFFSET from the right side - they should only apply to the final compound result
-	const { orderBy: _rightOrderBy, limit: _rightLimit, offset: _rightOffset, ...rightCore } = stmt.compound.select as any;
+	const { orderBy: _rightOrderBy, limit: _rightLimit, offset: _rightOffset, ...rightCore } = stmt.compound.select;
 
 	const leftPlan = buildSelectStmt(contextWithCTEs, leftCore as AST.SelectStmt, cteNodes) as RelationalPlanNode;
 	const rightPlan = buildSelectStmt(contextWithCTEs, rightCore as AST.SelectStmt, cteNodes) as RelationalPlanNode;
 
-	const setNode = new SetOperationNode(contextWithCTEs.scope, leftPlan, rightPlan, stmt.compound.op);
+	// Expand DIFF as (A EXCEPT B) UNION (B EXCEPT A)
+	let setNode: RelationalPlanNode;
+	if (stmt.compound.op === 'diff') {
+		const leftMinusRight = new SetOperationNode(contextWithCTEs.scope, leftPlan, rightPlan, 'except');
+		const rightMinusLeft = new SetOperationNode(contextWithCTEs.scope, rightPlan, leftPlan, 'except');
+		setNode = new SetOperationNode(contextWithCTEs.scope, leftMinusRight, rightMinusLeft, 'union');
+	} else {
+		setNode = new SetOperationNode(contextWithCTEs.scope, leftPlan, rightPlan, stmt.compound.op);
+	}
 
 	// After set operation, apply ORDER BY / LIMIT / OFFSET from the *outer* (original) statement
 	let input: RelationalPlanNode = setNode;
@@ -58,15 +67,15 @@ function createSetOperationScope(setNode: RelationalPlanNode): RegisteredScope {
 	const setScope = new RegisteredScope();
 	const attrs = setNode.getAttributes();
 
-	setNode.getType().columns.forEach((c: any, i: number) => {
+	setNode.getType().columns.forEach((c, i: number) => {
 		const attr = attrs[i];
 		// Ensure column has a name - use attribute name as fallback
 		const columnName = c.name || attr.name;
 		if (!columnName) {
 			throw new QuereusError(`Column at index ${i} has no name in set operation`, StatusCode.ERROR);
 		}
-		setScope.registerSymbol(columnName.toLowerCase(), (exp: any, s: any) =>
-			new ColumnReferenceNode(s, exp, c.type, attr.id, i));
+		setScope.registerSymbol(columnName.toLowerCase(), (exp: AST.Expression, s: Scope) =>
+			new ColumnReferenceNode(s, exp as AST.ColumnExpr, c.type, attr.id, i));
 	});
 
 	return setScope;
@@ -77,11 +86,11 @@ function createSetOperationScope(setNode: RelationalPlanNode): RegisteredScope {
  */
 function applyOuterOrderBy(
 	input: RelationalPlanNode,
-	outerOrderBy: any[] | undefined,
+	outerOrderBy: AST.OrderByClause[] | undefined,
 	selectContext: PlanningContext
 ): RelationalPlanNode {
 	if (outerOrderBy && outerOrderBy.length > 0) {
-		const sortKeys: SortKey[] = outerOrderBy.map((ob: any) => ({
+		const sortKeys: SortKey[] = outerOrderBy.map((ob) => ({
 			expression: buildExpression(selectContext, ob.expr),
 			direction: ob.direction,
 			nulls: ob.nulls,
@@ -96,8 +105,8 @@ function applyOuterOrderBy(
  */
 function applyOuterLimitOffset(
 	input: RelationalPlanNode,
-	outerLimit: any,
-	outerOffset: any,
+	outerLimit: AST.Expression | undefined,
+	outerOffset: AST.Expression | undefined,
 	selectContext: PlanningContext
 ): RelationalPlanNode {
 	if (outerLimit || outerOffset) {

package/src/planner/building/select-context.ts

@@ -1,6 +1,6 @@
 import type * as AST from '../../parser/ast.js';
 import type { PlanningContext } from '../planning-context.js';
-import type { CTEPlanNode } from '../nodes/cte-node.js';
+import type { CTEScopeNode } from '../nodes/cte-node.js';
 import type { Scope } from '../scopes/scope.js';
 import { RegisteredScope } from '../scopes/registered.js';
 import { ParameterScope } from '../scopes/param.js';
@@ -22,13 +22,13 @@ export function getNonParamAncestor(scope: Scope): Scope {
 export function buildWithContext(
 	ctx: PlanningContext,
 	stmt: AST.SelectStmt,
-	parentCTEs: Map<string, CTEPlanNode> = new Map()
+	parentCTEs: Map<string, CTEScopeNode> = new Map()
 ): {
 	contextWithCTEs: PlanningContext;
-	cteNodes: Map<string, CTEPlanNode>;
+	cteNodes: Map<string, CTEScopeNode>;
 } {
 	// Start with parent CTEs - either from parameter or from context
-	const cteNodes: Map<string, CTEPlanNode> = new Map(parentCTEs.size > 0 ? parentCTEs : (ctx.cteNodes ?? new Map()));
+	const cteNodes: Map<string, CTEScopeNode> = new Map(parentCTEs.size > 0 ? parentCTEs : (ctx.cteNodes ?? new Map()));
 	let contextWithCTEs = ctx;
 
 	if (stmt.withClause) {
@@ -56,7 +56,7 @@ export function buildWithContext(
  * that might cause attribute ID collisions in correlated subqueries
  */
 function createCTEScope(
-	cteNodes: Map<string, CTEPlanNode>,
+	cteNodes: Map<string, CTEScopeNode>,
 	ctx: PlanningContext
 ): RegisteredScope {
 	const cteScope = new RegisteredScope(getNonParamAncestor(ctx.scope));
@@ -70,7 +70,7 @@ function createCTEScope(
 
 		// Only register columns that are stable input attributes
 		// This prevents scope pollution from projection output attributes
-		columnTypes.forEach((col: any, i: number) => {
+		columnTypes.forEach((col, i) => {
 			if (i < attributes.length) {
 				const attr = attributes[i];
 				// Register CTE columns with qualified names to avoid collisions

package/src/planner/building/select-modifiers.ts

@@ -1,24 +1,25 @@
 import type * as AST from '../../parser/ast.js';
 import type { RelationalPlanNode } from '../nodes/plan-node.js';
 import type { PlanningContext } from '../planning-context.js';
-import type { Projection } from '../nodes/project-node.js';
+import type { Scope } from '../scopes/scope.js';
+import { ProjectNode, type Projection } from '../nodes/project-node.js';
 import { DistinctNode } from '../nodes/distinct-node.js';
 import { SortNode, type SortKey } from '../nodes/sort.js';
 import { LimitOffsetNode } from '../nodes/limit-offset.js';
 import { LiteralNode } from '../nodes/scalar.js';
-import { ProjectNode } from '../nodes/project-node.js';
 import { MultiScope } from '../scopes/multi.js';
 import { RegisteredScope } from '../scopes/registered.js';
 import { ColumnReferenceNode } from '../nodes/reference.js';
 import { buildExpression } from './expression.js';
+import { CapabilityDetectors } from '../framework/characteristics.js';
 
 /**
- * Builds final projections for non-aggregate cases
+ * Creates final output projections and applies result column aliases
  */
 export function buildFinalProjections(
 	input: RelationalPlanNode,
 	projections: Projection[],
-	selectScope: any,
+	selectScope: Scope,
 	stmt: AST.SelectStmt,
 	selectContext: PlanningContext,
 	preserveInputColumns: boolean = true
@@ -68,12 +69,12 @@ export function buildFinalProjections(
 }
 
 /**
- * Applies DISTINCT modifier if present
+ * Applies DISTINCT if specified
  */
 export function applyDistinct(
 	input: RelationalPlanNode,
 	stmt: AST.SelectStmt,
-	selectScope: any
+	selectScope: Scope
 ): RelationalPlanNode {
 	if (stmt.distinct) {
 		return new DistinctNode(selectScope, input);
@@ -156,7 +157,7 @@ function shouldApplyOrderByBeforeProjection(
 			// Check if this column is in the projection aliases
 			const isInProjection = projections.some(proj =>
 				(proj.alias?.toLowerCase() === orderColumn) ||
-				(proj.node instanceof ColumnReferenceNode && proj.node.expression.name.toLowerCase() === orderColumn)
+				(CapabilityDetectors.isColumnReference(proj.node) && proj.node.expression.name.toLowerCase() === orderColumn)
 			);
 			if (!isInProjection) {
 				return true;