@quereus/quereus 0.6.0 → 0.6.2

package/src/runtime/emit/binary.ts

@@ -152,7 +152,7 @@ export function emitComparisonOp(plan: BinaryOpNode, ctx: EmissionContext): Inst
 
 				// Apply type coercion before comparison
 				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) === 0 ? 1 : 0;
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) === 0;
 			};
 			break;
 		case '!=':
@@ -169,7 +169,7 @@ export function emitComparisonOp(plan: BinaryOpNode, ctx: EmissionContext): Inst
 
 				// Apply type coercion before comparison
 				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) !== 0 ? 1 : 0;
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) !== 0;
 			};
 			break;
 		case '<':
@@ -185,7 +185,7 @@ export function emitComparisonOp(plan: BinaryOpNode, ctx: EmissionContext): Inst
 
 				// Apply type coercion before comparison
 				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) < 0 ? 1 : 0;
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) < 0;
 			};
 			break;
 		case '<=':
@@ -201,7 +201,7 @@ export function emitComparisonOp(plan: BinaryOpNode, ctx: EmissionContext): Inst
 
 				// Apply type coercion before comparison
 				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) <= 0 ? 1 : 0;
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) <= 0;
 			};
 			break;
 		case '>':
@@ -219,9 +219,7 @@ export function emitComparisonOp(plan: BinaryOpNode, ctx: EmissionContext): Inst
 
 				// Apply type coercion before comparison
 				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				const comparisonResult = compareSqlValuesFast(coercedV1, coercedV2, collationFunc);
-				const finalResult = comparisonResult > 0 ? 1 : 0;
-				return finalResult;
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) > 0;
 			};
 			break;
 		case '>=':
@@ -237,7 +235,7 @@ export function emitComparisonOp(plan: BinaryOpNode, ctx: EmissionContext): Inst
 
 				// Apply type coercion before comparison
 				const [coercedV1, coercedV2] = coerceForComparison(v1, v2);
-				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) >= 0 ? 1 : 0;
+				return compareSqlValuesFast(coercedV1, coercedV2, collationFunc) >= 0;
 			};
 			break;
 		default:
@@ -283,38 +281,38 @@ export function emitLogicalOp(plan: BinaryOpNode, ctx: EmissionContext): Instruc
 		// SQL three-valued logic
 		switch (operator) {
 			case 'AND': {
-				// NULL AND x -> NULL if x is true or NULL, otherwise 0
-				// 0 AND x -> 0
-				// 1 AND x -> x
+				// NULL AND x -> NULL if x is true or NULL, otherwise false
+				// false AND x -> false
+				// true AND x -> x
 				if (v1 === null) {
-					return (v2 === null || v2) ? null : 0;
+					return (v2 === null || v2) ? null : false;
 				}
-				if (!v1) return 0;
-				return v2 === null ? null : (v2 ? 1 : 0);
+				if (!v1) return false;
+				return v2 === null ? null : (v2 ? true : false);
 			}
 
 			case 'OR': {
-				// NULL OR x -> NULL if x is false or NULL, otherwise 1
-				// 1 OR x -> 1
-				// 0 OR x -> x
+				// NULL OR x -> NULL if x is false or NULL, otherwise true
+				// true OR x -> true
+				// false OR x -> x
 				if (v1 === null) {
-					return (v2 === null || !v2) ? null : 1;
+					return (v2 === null || !v2) ? null : true;
 				}
-				if (v1) return 1;
-				return v2 === null ? null : (v2 ? 1 : 0);
+				if (v1) return true;
+				return v2 === null ? null : (v2 ? true : false);
 			}
 
 			case 'XOR': {
 				// NULL XOR x -> NULL
 				// x XOR NULL -> NULL
-				// 0 XOR 0 -> 0
-				// 0 XOR 1 -> 1
-				// 1 XOR 0 -> 1
-				// 1 XOR 1 -> 0
+				// false XOR false -> false
+				// false XOR true -> true
+				// true XOR false -> true
+				// true XOR true -> false
 				if (v1 === null || v2 === null) return null;
-				const b1 = v1 ? 1 : 0;
-				const b2 = v2 ? 1 : 0;
-				return b1 !== b2 ? 1 : 0;
+				const b1 = !!v1;
+				const b2 = !!v2;
+				return b1 !== b2;
 			}
 
 			default:
@@ -344,7 +342,7 @@ export function emitLikeOp(plan: BinaryOpNode, ctx: EmissionContext): Instructio
 		const textStr = String(text);
 		const patternStr = String(pattern);
 
-		return simpleLike(patternStr, textStr) ? 1 : 0;
+		return simpleLike(patternStr, textStr);
 	}
 
 	const leftExpr = emitPlanNode(plan.left, ctx);

package/src/runtime/emit/subquery.ts

@@ -63,13 +63,13 @@ export function emitIn(plan: InNode, ctx: EmissionContext): Instruction {
 					}
 					// Check for match immediately - no need to materialize
 					if (compareSqlValuesFast(condition, rowValue, collation) === 0) {
-						return 1; // Found a match
+						return true; // Found a match
 					}
 				}
 			}
 
 			// No match found - if any value was NULL, result is NULL
-			return hasNull ? null : 0;
+			return hasNull ? null : false;
 		}
 
 		const sourceInstruction = emitPlanNode(plan.source, ctx);
@@ -103,11 +103,11 @@ export function emitIn(plan: InNode, ctx: EmissionContext): Instruction {
 				// Check if condition exists in pre-built tree
 				const path = tree.find(condition);
 				if (path.on) {
-					return 1; // Found a match
+					return true; // Found a match
 				}
 
 				// No match found - if any value was NULL, result is NULL
-				return hasNull ? null : 0;
+				return hasNull ? null : false;
 			}
 
 			const values = plan.values.map(val => (val as unknown as ConstantNode).getValue());
@@ -163,12 +163,12 @@ export function emitIn(plan: InNode, ctx: EmissionContext): Instruction {
 						continue;
 					}
 					if (compareSqlValuesFast(condition, value, collation) === 0) {
-						return 1; // Found a match
+						return true; // Found a match
 					}
 				}
 
 				// No match found - if any value was NULL, result is NULL
-				return hasNull ? null : 0;
+				return hasNull ? null : false;
 			}
 
 			const conditionExpr = emitPlanNode(plan.condition, ctx);
@@ -188,9 +188,9 @@ export function emitIn(plan: InNode, ctx: EmissionContext): Instruction {
 export function emitExists(plan: ExistsNode, ctx: EmissionContext): Instruction {
 	async function run(_rctx: RuntimeContext, input: AsyncIterable<Row>): Promise<SqlValue> {
 		for await (const _row of input) {
-			return 1; // First row => TRUE
+			return true; // First row => TRUE
 		}
-		return 0; // Empty => FALSE
+		return false; // Empty => FALSE
 	}
 
 	const innerInstruction = emitPlanNode(plan.subquery, ctx);

package/src/runtime/emit/temporal-arithmetic.ts

@@ -268,7 +268,7 @@ export function emitTemporalArithmetic(plan: BinaryOpNode, ctx: EmissionContext)
  * @param operator The comparison operator (=, !=, <, <=, >, >=)
  * @param v1 First value
  * @param v2 Second value
- * @returns Comparison result (0 or 1) if temporal comparison, undefined otherwise
+ * @returns Comparison result (boolean) if temporal comparison, undefined otherwise
  */
 export function tryTemporalComparison(operator: string, v1: SqlValue, v2: SqlValue): SqlValue | undefined {
 	// Check if both values are timespans
@@ -284,18 +284,18 @@ export function tryTemporalComparison(operator: string, v1: SqlValue, v2: SqlVal
 	switch (operator) {
 		case '=':
 		case '==':
-			return cmp === 0 ? 1 : 0;
+			return cmp === 0;
 		case '!=':
 		case '<>':
-			return cmp !== 0 ? 1 : 0;
+			return cmp !== 0;
 		case '<':
-			return cmp < 0 ? 1 : 0;
+			return cmp < 0;
 		case '<=':
-			return cmp <= 0 ? 1 : 0;
+			return cmp <= 0;
 		case '>':
-			return cmp > 0 ? 1 : 0;
+			return cmp > 0;
 		case '>=':
-			return cmp >= 0 ? 1 : 0;
+			return cmp >= 0;
 		default:
 			return undefined;
 	}

package/src/runtime/emit/unary.ts

@@ -19,23 +19,23 @@ export function emitUnaryOp(plan: UnaryOpNode, ctx: EmissionContext): Instructio
 	switch (operator) {
 		case 'NOT':
 			run = (ctx: RuntimeContext, operand: SqlValue) => {
-				// SQL NOT: NULL -> NULL, 0 -> 1, anything else -> 0
+				// SQL NOT: NULL -> NULL, false -> true, true -> false
 				if (operand === null) return null;
-				return isTruthy(operand) ? 0 : 1;
+				return !isTruthy(operand);
 			};
 			note = 'NOT';
 			break;
 
 		case 'IS NULL':
 			run = (ctx: RuntimeContext, operand: SqlValue) => {
-				return operand === null ? 1 : 0;
+				return operand === null;
 			};
 			note = 'IS NULL';
 			break;
 
 		case 'IS NOT NULL':
 			run = (ctx: RuntimeContext, operand: SqlValue) => {
-				return operand !== null ? 1 : 0;
+				return operand !== null;
 			};
 			note = 'IS NOT NULL';
 			break;

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';
+	}
+}
+