@quereus/quereus 0.1.0 → 0.2.0

package/src/index.ts

@@ -11,16 +11,41 @@ export { Statement } from './core/statement.js';
 
 // Common data types and constants
 export { StatusCode, SqlDataType } from './common/types.js';
-export type { SqlValue, SqlParameters, Row } from './common/types.js';
-export { ConflictResolution } from './common/constants.js';
+export type { SqlValue, SqlParameters, Row, MaybePromise } from './common/types.js';
+export { ConflictResolution, IndexConstraintOp, VTabConfig, FunctionFlags } from './common/constants.js';
 export { QuereusError, MisuseError, ConstraintError, unwrapError, formatErrorChain, getPrimaryError } from './common/errors.js';
 export type { ErrorInfo } from './common/errors.js';
 
 // Virtual Table API
 export { VirtualTable } from './vtab/table.js';
+export type { VirtualTableConnection } from './vtab/connection.js';
 export { MemoryTableModule } from './vtab/memory/module.js';
-export type { IndexInfo, IndexConstraint, IndexConstraintUsage, IndexOrderBy, IndexScanFlags } from './vtab/index-info.js';
+export type { IndexInfo, IndexConstraint, IndexConstraintUsage, IndexOrderBy } from './vtab/index-info.js';
+export { IndexScanFlags } from './vtab/index-info.js';
 export type { FilterInfo } from './vtab/filter-info.js';
+export type { BaseModuleConfig, SchemaChangeInfo } from './vtab/module.js';
+
+// Best Access Plan API (modern vtable planning interface)
+export type {
+	BestAccessPlanRequest,
+	BestAccessPlanResult,
+	ConstraintOp,
+	ColumnMeta,
+	PredicateConstraint,
+	OrderingSpec
+} from './vtab/best-access-plan.js';
+export { AccessPlanBuilder, validateAccessPlan } from './vtab/best-access-plan.js';
+
+// Collation functions
+export type { CollationFunction } from './util/comparison.js';
+export {
+	BINARY_COLLATION,
+	NOCASE_COLLATION,
+	RTRIM_COLLATION,
+	registerCollation,
+	getCollation,
+	resolveCollation
+} from './util/comparison.js';
 
 // SQL Parser and Compiler
 export { Parser } from './parser/parser.js';
@@ -58,10 +83,19 @@ import './runtime/register.js';
 
 // Re-export plugin system
 export { dynamicLoadModule, validatePluginUrl } from './util/plugin-loader.js';
-export type { PluginManifest, PluginRecord, PluginSetting } from './vtab/manifest.js';
+export type {
+	PluginManifest,
+	PluginRecord,
+	PluginSetting,
+	VTablePluginInfo,
+	FunctionPluginInfo,
+	CollationPluginInfo,
+	PluginRegistrations
+} from './vtab/manifest.js';
 
 // Re-export virtual table framework
 export type { VirtualTableModule } from './vtab/module.js';
 
 // Debug and development utilities
-export { serializePlanTree } from './planner/debug.js';
+export { serializePlanTree, formatPlanTree, formatPlanSummary, serializePlanTreeWithOptions } from './planner/debug.js';
+export type { PlanDisplayOptions } from './planner/debug.js';

package/src/parser/ast.ts

@@ -13,7 +13,7 @@ export interface AstNode {
 		| 'rollback' | 'table' | 'join' | 'savepoint' | 'release' | 'functionSource' | 'with' | 'commonTableExpr' | 'pragma'
 		| 'collate' | 'primaryKey' | 'notNull' | 'null' | 'unique' | 'check' | 'default' | 'foreignKey' | 'generated' | 'windowFunction'
 		| 'windowDefinition' | 'windowFrame' | 'currentRow' | 'unboundedPreceding' | 'unboundedFollowing' | 'preceding' | 'following'
-		| 'subquerySource' | 'mutatingSubquerySource' | 'case' | 'in' | 'exists' | 'values';
+		| 'subquerySource' | 'mutatingSubquerySource' | 'case' | 'in' | 'exists' | 'values' | 'between';
 	loc?: {
 		start: { line: number, column: number, offset: number };
 		end: { line: number, column: number, offset: number };
@@ -23,7 +23,7 @@ export interface AstNode {
 // Expression types
 export type Expression = LiteralExpr | IdentifierExpr | BinaryExpr | UnaryExpr | FunctionExpr | CastExpr
 	| ParameterExpr | SubqueryExpr | ColumnExpr | FunctionSource | CollateExpr | WindowFunctionExpr | CaseExpr
-	| InExpr | ExistsExpr;
+	| InExpr | ExistsExpr | BetweenExpr;
 
 // Literal value expression (number, string, null, etc.)
 export interface LiteralExpr extends AstNode {
@@ -129,6 +129,15 @@ export interface SubqueryExpr extends AstNode {
 	query: SelectStmt;
 }
 
+// BETWEEN expression
+export interface BetweenExpr extends AstNode {
+	type: 'between';
+	expr: Expression;      // Left side of BETWEEN
+	lower: Expression;     // Lower bound
+	upper: Expression;     // Upper bound
+	not?: boolean;         // For NOT BETWEEN
+}
+
 // IN expression
 export interface InExpr extends AstNode {
 	type: 'in';

package/src/parser/parser.ts

@@ -466,7 +466,24 @@ export class Parser {
 				const expr = this.expression();
 				const direction = this.match(TokenType.DESC) ? 'desc' :
 					(this.match(TokenType.ASC) ? 'asc' : 'asc'); // Default to ASC
-				orderBy.push({ expr, direction });
+
+				// Handle NULLS FIRST/LAST
+				let nulls: 'first' | 'last' | undefined;
+				if (this.matchKeyword('NULLS')) {
+					if (this.matchKeyword('FIRST')) {
+						nulls = 'first';
+					} else if (this.matchKeyword('LAST')) {
+						nulls = 'last';
+					} else {
+						throw this.error(this.peek(), "Expected 'FIRST' or 'LAST' after 'NULLS'.");
+					}
+				}
+
+				const orderClause: AST.OrderByClause = { expr, direction };
+				if (nulls) {
+					orderClause.nulls = nulls;
+				}
+				orderBy.push(orderClause);
 			} while (this.match(TokenType.COMMA));
 			lastConsumedToken = this.previous(); // After last order by clause
 		}
@@ -1125,33 +1142,18 @@ export class Parser {
 					}
 				} else if (this.match(TokenType.BETWEEN)) {
 					// NOT BETWEEN
-					const low = this.term();
+					const lower = this.term();
 					this.consume(TokenType.AND, "Expected 'AND' after NOT BETWEEN lower bound.");
-					const high = this.term();
-					const endToken = this.previous(); // End token is end of high expr
-
-					// Create a binary AND expression for the bounds
-					const boundsExpr: AST.BinaryExpr = {
-						type: 'binary',
-						operator: 'AND',
-						left: low,
-						right: high,
-						loc: _createLoc(low.loc?.start ? this.tokens.find(t => t.startOffset === low.loc!.start.offset) ?? this.peek() : this.peek(), endToken)
-					};
-
-					// Create the BETWEEN expression as a binary expression, then wrap in NOT
-					const betweenExpr: AST.BinaryExpr = {
-						type: 'binary',
-						operator: 'BETWEEN',
-						left: expr,
-						right: boundsExpr,
-						loc: _createLoc(startToken, endToken),
-					};
+					const upper = this.term();
+					const endToken = this.previous(); // End token is end of upper expr
 
+					// Create the NOT BETWEEN expression as a dedicated node type
 					expr = {
-						type: 'unary',
-						operator: 'NOT',
-						expr: betweenExpr,
+						type: 'between',
+						expr,
+						lower,
+						upper,
+						not: true,
 						loc: _createLoc(notStartToken, endToken),
 					};
 				} else if (this.match(TokenType.LIKE)) {
@@ -1194,26 +1196,17 @@ export class Parser {
 				};
 			} else if (operatorToken.type === TokenType.BETWEEN) {
 				// Parse BETWEEN expression: expr BETWEEN low AND high
-				const low = this.term();
+				const lower = this.term();
 				this.consume(TokenType.AND, "Expected 'AND' after BETWEEN lower bound.");
-				const high = this.term();
-				const endToken = this.previous(); // End token is end of high expr
+				const upper = this.term();
+				const endToken = this.previous(); // End token is end of upper expr
 
-				// Create a binary AND expression for the bounds
-				const boundsExpr: AST.BinaryExpr = {
-					type: 'binary',
-					operator: 'AND',
-					left: low,
-					right: high,
-					loc: _createLoc(low.loc?.start ? this.tokens.find(t => t.startOffset === low.loc!.start.offset) ?? this.peek() : this.peek(), endToken)
-				};
-
-				// Create the BETWEEN expression as a binary expression
+				// Create the BETWEEN expression as a dedicated node type
 				expr = {
-					type: 'binary',
-					operator: 'BETWEEN',
-					left: expr,
-					right: boundsExpr,
+					type: 'between',
+					expr,
+					lower,
+					upper,
 					loc: _createLoc(startToken, endToken),
 				};
 			} else if (operatorToken.type === TokenType.IN) {
@@ -1617,20 +1610,20 @@ export class Parser {
 					const direction = this.match(TokenType.DESC) ? 'desc' : (this.match(TokenType.ASC) ? 'asc' : 'asc');
 
 					// Handle NULLS FIRST/LAST
-					let nullsOrdering: 'first' | 'last' | undefined;
+					let nulls: 'first' | 'last' | undefined;
 					if (this.matchKeyword('NULLS')) {
 						if (this.matchKeyword('FIRST')) {
-							nullsOrdering = 'first';
+							nulls = 'first';
 						} else if (this.matchKeyword('LAST')) {
-							nullsOrdering = 'last';
+							nulls = 'last';
 						} else {
 							throw this.error(this.peek(), "Expected 'FIRST' or 'LAST' after 'NULLS'.");
 						}
 					}
 
 					const orderClause: AST.OrderByClause = { expr, direction };
-					if (nullsOrdering) {
-						(orderClause as any).nullsOrdering = nullsOrdering;
+					if (nulls) {
+						orderClause.nulls = nulls;
 					}
 					orderBy.push(orderClause);
 				} while (this.match(TokenType.COMMA));