@quereus/quereus 0.6.1 → 0.6.3

package/src/planner/scopes/param.ts

@@ -20,14 +20,14 @@ const DEFAULT_PARAMETER_TYPE: ScalarType = {
 export class ParameterScope extends BaseScope {
 	private _nextAnonymousIndex: number = 1;
 	private readonly _parameters: Map<string | number, ParameterReferenceNode> = new Map();
-	private readonly _parameterTypeHints: ReadonlyMap<string | number, ScalarType>;
+	private readonly _parameterTypes: ReadonlyMap<string | number, ScalarType>;
 
 	constructor(
 		public readonly parentScope: Scope,
-		parameterTypeHints?: ReadonlyMap<string | number, ScalarType>
+		parameterTypes?: ReadonlyMap<string | number, ScalarType>
 	) {
 		super();
-		this._parameterTypeHints = parameterTypeHints || new Map();
+		this._parameterTypes = parameterTypes || new Map();
 	}
 
 	resolveSymbol(symbolKey: string, expression: AST.Expression): PlanNode | typeof Ambiguous | undefined {
@@ -42,9 +42,9 @@ export class ParameterScope extends BaseScope {
 			// Use the current _nextAnonymousIndex as the potential identifier for this '?'
 			const currentAnonymousId = this._nextAnonymousIndex;
 
-			// Check if this specific anonymous parameter (by its future index) has a type hint
-			if (this._parameterTypeHints.has(currentAnonymousId)) {
-				resolvedType = this._parameterTypeHints.get(currentAnonymousId)!;
+			// Check if this specific anonymous parameter (by its future index) has a declared type
+			if (this._parameterTypes.has(currentAnonymousId)) {
+				resolvedType = this._parameterTypes.get(currentAnonymousId)!;
 			}
 			// Note: We don't check _parameters here for '?' because each '?' AST node should resolve,
 			// potentially creating a new ParameterReferenceNode if it's a new '?' instance in the query,
@@ -63,10 +63,10 @@ export class ParameterScope extends BaseScope {
 
 			if (this._parameters.has(identifier)) {
 				parameterNode = this._parameters.get(identifier)!;
-				// If already exists, its type was set at creation. Type hints are for new nodes.
+				// If already exists, its type was set at creation
 			} else {
-				if (this._parameterTypeHints.has(identifier)) {
-					resolvedType = this._parameterTypeHints.get(identifier)!;
+				if (this._parameterTypes.has(identifier)) {
+					resolvedType = this._parameterTypes.get(identifier)!;
 				}
 				parameterNode = new ParameterReferenceNode(this, parameterExpression, identifier, resolvedType);
 				this._parameters.set(identifier, parameterNode);

package/src/runtime/emit/schema-declarative.ts

@@ -195,7 +195,7 @@ export function emitExplainSchema(plan: PlanNode, _ctx: EmissionContext): Instru
 		}
 
 		// Compute hash
-		const hash = await computeShortSchemaHash(declaredSchema);
+		const hash = computeShortSchemaHash(declaredSchema);
 
 		// Return hash with version if specified
 		const result = explainStmt.version

package/src/schema/schema-hasher.ts

@@ -1,44 +1,26 @@
 import type * as AST from '../parser/ast.js';
 import { generateDeclaredDDL } from './catalog.js';
+import { fnv1aHash, toBase64Url } from '../util/hash.js';
 
 /**
  * Computes a hash of a declared schema for versioning
  */
-export async function computeSchemaHash(declaredSchema: AST.DeclareSchemaStmt): Promise<string> {
+export function computeSchemaHash(declaredSchema: AST.DeclareSchemaStmt): string {
 	// Generate canonical DDL representation
 	const ddlStatements = generateDeclaredDDL(declaredSchema);
 	const canonicalText = ddlStatements.join('\n');
 
-	// Compute SHA-256 hash
-	const hash = await sha256(canonicalText);
-	return hash;
+	// Compute hash using FNV-1a algorithm and encode as base64url
+	const hashBytes = fnv1aHash(canonicalText);
+	return toBase64Url(hashBytes);
 }
 
 /**
- * Computes SHA-256 hash of a string
+ * Computes a short hash (first 8 characters) for display
  */
-async function sha256(message: string): Promise<string> {
-	// Use Node.js crypto if available, otherwise Web Crypto API
-	if (typeof globalThis.crypto !== 'undefined' && globalThis.crypto.subtle) {
-		// Web Crypto API
-		const encoder = new TextEncoder();
-		const data = encoder.encode(message);
-		const hashBuffer = await globalThis.crypto.subtle.digest('SHA-256', data);
-		const hashArray = Array.from(new Uint8Array(hashBuffer));
-		return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
-	} else {
-		// Node.js crypto
-		const crypto = await import('node:crypto');
-		return crypto.createHash('sha256').update(message, 'utf8').digest('hex');
-	}
-}
-
-/**
- * Computes a short hash (first 12 characters) for display
- */
-export async function computeShortSchemaHash(declaredSchema: AST.DeclareSchemaStmt): Promise<string> {
-	const fullHash = await computeSchemaHash(declaredSchema);
-	return fullHash.substring(0, 12);
+export function computeShortSchemaHash(declaredSchema: AST.DeclareSchemaStmt): string {
+	const fullHash = computeSchemaHash(declaredSchema);
+	return fullHash.substring(0, 8);
 }
 
 

package/src/types/index.ts

@@ -1,5 +1,5 @@
 // Core type system exports
-export { PhysicalType, type LogicalType, getPhysicalType } from './logical-type.js';
+export { PhysicalType, type LogicalType, getPhysicalType, physicalTypeName } from './logical-type.js';
 
 // Built-in types
 export { NULL_TYPE, INTEGER_TYPE, REAL_TYPE, TEXT_TYPE, BLOB_TYPE, BOOLEAN_TYPE, NUMERIC_TYPE, ANY_TYPE } from './builtin-types.js';

package/src/types/logical-type.ts

@@ -73,3 +73,19 @@ export function getPhysicalType(value: SqlValue): PhysicalType {
 	return PhysicalType.NULL;
 }
 
+/**
+ * Get a human-readable name for a physical type code.
+ * Useful for error messages and debugging.
+ */
+export function physicalTypeName(physicalType: PhysicalType): string {
+	switch (physicalType) {
+		case PhysicalType.NULL: return 'NULL';
+		case PhysicalType.INTEGER: return 'INTEGER';
+		case PhysicalType.REAL: return 'REAL';
+		case PhysicalType.TEXT: return 'TEXT';
+		case PhysicalType.BLOB: return 'BLOB';
+		case PhysicalType.BOOLEAN: return 'BOOLEAN';
+		default: return 'UNKNOWN';
+	}
+}
+