@quereus/quereus 0.4.8 → 0.4.10

package/src/core/database.ts

@@ -217,6 +217,34 @@ export class Database {
 	 * @returns A Promise resolving when execution completes.
 	 * @throws QuereusError on failure.
 	 */
+	/**
+	 * @internal
+	 * Executes a single AST statement without transaction management.
+	 * Used by both exec() and eval() to avoid code duplication.
+	 */
+	private async _executeStatement(statementAst: AST.Statement, params?: SqlParameters | SqlValue[]): Promise<void> {
+		const plan = this._buildPlan([statementAst], params);
+
+		if (plan.statements.length === 0) return; // No-op for this AST
+
+		const optimizedPlan = this.optimizer.optimize(plan, this) as BlockNode;
+		const emissionContext = new EmissionContext(this);
+		const rootInstruction = emitPlanNode(optimizedPlan, emissionContext);
+		const scheduler = new Scheduler(rootInstruction);
+
+		const runtimeCtx: RuntimeContext = {
+			db: this,
+			stmt: undefined,
+			params: params ?? {},
+			context: new Map(),
+			tableContexts: new Map(),
+			tracer: this.instructionTracer,
+			enableMetrics: this.options.getBooleanOption('runtime_stats'),
+		};
+
+		await scheduler.run(runtimeCtx);
+	}
+
 	async exec(
 		sql: string,
 		params?: SqlParameters,
@@ -250,39 +278,13 @@ export class Database {
 			}
 
 			for (let i = 0; i < batch.length; i++) {
-				const statementAst = batch[i];
-				let plan: BlockNode;
-
 				try {
-					plan = this._buildPlan([statementAst], params);
-
-					if (plan.statements.length === 0) continue; // No-op for this AST
-
-					const optimizedPlan = this.optimizer.optimize(plan, this) as BlockNode;
-
-					const emissionContext = new EmissionContext(this);
-					const rootInstruction = emitPlanNode(optimizedPlan, emissionContext);
-
-					const scheduler = new Scheduler(rootInstruction);
-
-					const runtimeCtx: RuntimeContext = {
-						db: this,
-						stmt: undefined,
-						params: params ?? {},
-						context: new Map(),
-						tableContexts: new Map(),
-						tracer: this.instructionTracer,
-						enableMetrics: this.options.getBooleanOption('runtime_stats'),
-					};
-
-					void await scheduler.run(runtimeCtx);
-					// Nothing to do with the result, this is executed for side effects only
+					await this._executeStatement(batch[i], params);
 				} catch (err) {
 					const error = err instanceof Error ? err : new Error(String(err));
 					executionError = error instanceof QuereusError ? error : new QuereusError(error.message, StatusCode.ERROR, error);
 					break; // Stop processing further statements on error
 				}
-				// No explicit finalize for transient plan/scheduler used in exec loop
 			}
 
 		} finally {
@@ -755,17 +757,35 @@ export class Database {
 		let stmt: Statement | null = null;
 		try {
 			stmt = this.prepare(sql);
-			if (stmt.astBatch.length > 1) {
-				warnLog(`Database.eval called with multi-statement SQL. Only results from the first statement will be yielded.`);
-			}
 
-			if (stmt.astBatch.length > 0) { // Check if there are any statements to execute
-				// If currentAstIndex defaults to 0 and astBatch is not empty, this will run the first statement.
-				yield* stmt.all(params);
-			} else {
+			if (stmt.astBatch.length === 0) {
 				// No statements, yield nothing.
 				return;
 			}
+
+			if (stmt.astBatch.length > 1) {
+				// Multi-statement batch: execute all but the last statement,
+				// then yield results from the last statement
+				const parser = new Parser();
+				const batch = parser.parseAll(sql);
+
+				// Execute all statements except the last one
+				for (let i = 0; i < batch.length - 1; i++) {
+					await this._executeStatement(batch[i], params);
+				}
+
+				// Now prepare and execute the last statement to yield its results
+				const lastStmt = new Statement(this, [batch[batch.length - 1]]);
+				this.statements.add(lastStmt);
+				try {
+					yield* lastStmt.all(params);
+				} finally {
+					await lastStmt.finalize();
+				}
+			} else {
+				// Single statement: execute and yield results
+				yield* stmt.all(params);
+			}
 		} finally {
 			if (stmt) { await stmt.finalize(); }
 		}

package/src/index.ts

@@ -93,6 +93,15 @@ export type {
 	PluginRegistrations
 } from './vtab/manifest.js';
 
+// Re-export config system
+export {
+	interpolateEnvVars,
+	interpolateConfigEnvVars,
+	loadPluginsFromConfig,
+	validateConfig
+} from './config/loader.js';
+export type { QuoombConfig, PluginConfig } from './config/loader.js';
+
 // Re-export virtual table framework
 export type { VirtualTableModule } from './vtab/module.js';
 

package/src/parser/parser.ts

@@ -2048,12 +2048,23 @@ export class Parser {
         if (this.matchKeyword('USING')) {
 			moduleName = this.consumeIdentifier("Expected module name after 'USING'.");
             if (this.match(TokenType.LPAREN)) {
+				let positionalIndex = 0;
                 if (!this.check(TokenType.RPAREN)) {
                     do {
-                        const nameValue = this.nameValueItem('module argument');
-                        moduleArgs[nameValue.name] = nameValue.value && nameValue.value.type === 'literal'
-                            ? getSyncLiteral(nameValue.value)
-                            : (nameValue.value && nameValue.value.type === 'identifier' ? nameValue.value.name : nameValue.name);
+						// Check if this is a positional argument (string/number literal) or named argument (identifier=value)
+						if (this.check(TokenType.STRING) || this.check(TokenType.INTEGER) || this.check(TokenType.FLOAT)) {
+							// Positional argument
+							const token = this.advance();
+							moduleArgs[String(positionalIndex++)] = token.literal;
+						} else if (this.check(TokenType.IDENTIFIER)) {
+							// Could be named argument or identifier value
+							const nameValue = this.nameValueItem('module argument');
+							moduleArgs[nameValue.name] = nameValue.value && nameValue.value.type === 'literal'
+								? getSyncLiteral(nameValue.value)
+								: (nameValue.value && nameValue.value.type === 'identifier' ? nameValue.value.name : nameValue.name);
+						} else {
+							throw this.error(this.peek(), "Expected module argument (string, number, or name=value pair).");
+						}
                     } while (this.match(TokenType.COMMA));
                 }
                 this.consume(TokenType.RPAREN, "Expected ')' after module arguments.");
@@ -2452,10 +2463,21 @@ export class Parser {
 			}
 			if (this.match(TokenType.LPAREN)) {
 				moduleArgs = {};
+				let positionalIndex = 0;
 				if (!this.check(TokenType.RPAREN)) {
 					do {
-						const nv = this.nameValueItem('module argument');
-						moduleArgs[nv.name] = nv.value && nv.value.type === 'literal' ? getSyncLiteral(nv.value) : (nv.value && nv.value.type === 'identifier' ? nv.value.name : null);
+						// Check if this is a positional argument (string/number literal) or named argument (identifier=value)
+						if (this.check(TokenType.STRING) || this.check(TokenType.INTEGER) || this.check(TokenType.FLOAT)) {
+							// Positional argument
+							const token = this.advance();
+							moduleArgs[String(positionalIndex++)] = token.literal;
+						} else if (this.check(TokenType.IDENTIFIER)) {
+							// Could be named argument or identifier value
+							const nv = this.nameValueItem('module argument');
+							moduleArgs[nv.name] = nv.value && nv.value.type === 'literal' ? getSyncLiteral(nv.value) : (nv.value && nv.value.type === 'identifier' ? nv.value.name : null);
+						} else {
+							throw this.error(this.peek(), "Expected module argument (string, number, or name=value pair).");
+						}
 					} while (this.match(TokenType.COMMA));
 				}
 				this.consume(TokenType.RPAREN, "Expected ')' after module arguments.");

package/src/planner/building/create-view.ts

@@ -1,6 +1,7 @@
 import type * as AST from '../../parser/ast.js';
 import type { PlanningContext } from '../planning-context.js';
 import { CreateViewNode } from '../nodes/create-view-node.js';
+import { createViewToString } from '../../util/ast-stringify.js';
 
 /**
  * Builds a plan node for CREATE VIEW statements.
@@ -11,9 +12,8 @@ export function buildCreateViewStmt(ctx: PlanningContext, stmt: AST.CreateViewSt
 	const viewName = stmt.view.name;
 
 	// The original SQL text is needed for the view definition
-	// For now, we'll reconstruct it from the AST
-	// In a full implementation, this should be preserved from the original input
-	const sql = reconstructViewSQL(stmt);
+	// Reconstruct it from the AST using the proper stringifier
+	const sql = createViewToString(stmt);
 
 	return new CreateViewNode(
 		ctx.scope,
@@ -26,31 +26,4 @@ export function buildCreateViewStmt(ctx: PlanningContext, stmt: AST.CreateViewSt
 	);
 }
 
-/**
- * Reconstructs the original SQL text for a CREATE VIEW statement.
- * This is a simplified version - in production, the original text should be preserved.
- */
-function reconstructViewSQL(stmt: AST.CreateViewStmt): string {
-	let sql = 'CREATE VIEW ';
-
-	if (stmt.ifNotExists) {
-		sql += 'IF NOT EXISTS ';
-	}
-
-	if (stmt.view.schema) {
-		sql += `${stmt.view.schema}.`;
-	}
-	sql += stmt.view.name;
 
-	if (stmt.columns && stmt.columns.length > 0) {
-		sql += ` (${stmt.columns.join(', ')})`;
-	}
-
-	sql += ' AS ';
-
-	// For now, just add a placeholder for the SELECT statement
-	// In a full implementation, this would reconstruct the full SELECT
-	sql += '(SELECT statement)';
-
-	return sql;
-}

package/src/planner/building/select.ts

@@ -333,7 +333,35 @@ export function buildFrom(fromClause: AST.FromClause, parentContext: PlanningCon
 
 			if (viewSchema) {
 				// Build the view's SELECT statement
-				fromTable = buildSelectStmt(parentContext, viewSchema.selectAst, cteNodes) as RelationalPlanNode;
+				let viewSelectNode = buildSelectStmt(parentContext, viewSchema.selectAst, cteNodes) as RelationalPlanNode;
+
+				// If the view has explicit column names, wrap with a projection to rename columns
+				if (viewSchema.columns && viewSchema.columns.length > 0) {
+					const viewAttributes = viewSelectNode.getAttributes();
+					const projections = viewSchema.columns.map((columnName, i) => {
+						if (i >= viewAttributes.length) {
+							throw new QuereusError(
+								`View '${viewSchema.name}' has more explicit column names than SELECT columns`,
+								StatusCode.ERROR
+							);
+						}
+						const attr = viewAttributes[i];
+						const columnRef = new ColumnReferenceNode(
+							parentContext.scope,
+							{ type: 'column', name: attr.name } as AST.ColumnExpr,
+							attr.type,
+							attr.id,
+							i
+						);
+						return {
+							node: columnRef,
+							alias: columnName
+						};
+					});
+					fromTable = new ProjectNode(parentContext.scope, viewSelectNode, projections);
+				} else {
+					fromTable = viewSelectNode;
+				}
 
 				// Create scope for view columns
 				const viewScope = new RegisteredScope(parentContext.scope);

package/src/schema/catalog.ts

@@ -2,7 +2,7 @@ import type { Database } from '../core/database.js';
 import type { TableSchema } from './table.js';
 import type { ViewSchema } from './view.js';
 import type { IntegrityAssertionSchema } from './assertion.js';
-import { createTableToString } from '../util/ast-stringify.js';
+import { createTableToString, createViewToString } from '../util/ast-stringify.js';
 import type * as AST from '../parser/ast.js';
 
 /**
@@ -196,9 +196,23 @@ export function generateDeclaredDDL(declaredSchema: AST.DeclareSchemaStmt, targe
 			case 'declaredIndex':
 				// TODO: Implement index DDL generation
 				break;
-			case 'declaredView':
-				// TODO: Implement view DDL generation
+			case 'declaredView': {
+				// Qualify view name with schema if specified
+				const viewStmt = item.viewStmt;
+				if (targetSchema && targetSchema !== 'main' && !viewStmt.view.schema) {
+					const qualifiedStmt: AST.CreateViewStmt = {
+						...viewStmt,
+						view: {
+							...viewStmt.view,
+							schema: targetSchema
+						}
+					};
+					ddlStatements.push(createViewToString(qualifiedStmt));
+				} else {
+					ddlStatements.push(createViewToString(viewStmt));
+				}
 				break;
+			}
 		}
 	}
 

package/src/schema/schema-differ.ts

@@ -1,6 +1,6 @@
 import type { SchemaCatalog } from './catalog.js';
 import type * as AST from '../parser/ast.js';
-import { createTableToString } from '../util/ast-stringify.js';
+import { createTableToString, createViewToString } from '../util/ast-stringify.js';
 
 /**
  * Represents the difference between a declared schema and actual database state
@@ -104,8 +104,8 @@ export function computeSchemaDiff(
 	// Find views to create/drop
 	for (const [name, declaredView] of declaredViews) {
 		if (!actualViews.has(name)) {
-			// TODO: Generate view DDL
-			diff.viewsToCreate.push(`CREATE VIEW "${declaredView.viewStmt.view.name}" AS SELECT 1`);
+			// Generate proper view DDL using AST stringifier
+			diff.viewsToCreate.push(createViewToString(declaredView.viewStmt));
 		}
 	}
 

package/src/util/ast-stringify.ts

@@ -629,7 +629,7 @@ function createIndexToString(stmt: AST.CreateIndexStmt): string {
 	return parts.join(' ');
 }
 
-function createViewToString(stmt: AST.CreateViewStmt): string {
+export function createViewToString(stmt: AST.CreateViewStmt): string {
 	const parts: string[] = ['create'];
 	if (stmt.isTemporary) parts.push('temp');
 	parts.push('view');