@quereus/quereus 0.5.2 → 0.6.1

package/src/planner/nodes/pragma.ts

@@ -1,4 +1,4 @@
-import { SqlDataType, type SqlValue } from '../../common/types.js';
+import type { SqlValue } from '../../common/types.js';
 import * as AST from '../../parser/ast.js';
 import { Attribute, type RelationalPlanNode } from './plan-node.js';
 import { PlanNodeType } from './plan-node-type.js';
@@ -6,6 +6,7 @@ import { expressionToString } from '../../util/ast-stringify.js';
 import { PlanNode } from './plan-node.js';
 import { RelationType } from '../../common/datatype.js';
 import { Scope } from '../scopes/scope.js';
+import { TEXT_TYPE } from '../../types/builtin-types.js';
 
 export class PragmaPlanNode extends PlanNode implements RelationalPlanNode {
 	override readonly nodeType = PlanNodeType.Pragma;
@@ -29,7 +30,7 @@ export class PragmaPlanNode extends PlanNode implements RelationalPlanNode {
 					name: "name",
 					type: {
 						typeClass: 'scalar',
-						affinity: SqlDataType.TEXT,
+						logicalType: TEXT_TYPE,
 						nullable: false,
 						isReadOnly: true,
 					},
@@ -39,7 +40,7 @@ export class PragmaPlanNode extends PlanNode implements RelationalPlanNode {
 					name: "value",
 					type: {
 						typeClass: 'scalar',
-						affinity: SqlDataType.TEXT,
+						logicalType: TEXT_TYPE,
 						nullable: false,
 					},
 					generated: true,

package/src/planner/nodes/reference.ts

@@ -38,7 +38,7 @@ export class TableReferenceNode extends PlanNode implements ZeroAryRelationalNod
 				name: column.name,
 				type: {
 					typeClass: 'scalar' as const,
-					affinity: column.affinity,
+					logicalType: column.logicalType,
 					nullable: !column.notNull,
 					isReadOnly: false,
 					collationName: column.collation

package/src/planner/nodes/scalar.ts

@@ -8,6 +8,8 @@ import { Cached } from "../../util/cached.js";
 import { formatExpression, formatScalarType } from "../../util/plan-formatter.js";
 import { quereusError } from '../../common/errors.js';
 import { StatusCode } from '../../common/types.js';
+import { NULL_TYPE, INTEGER_TYPE, REAL_TYPE, TEXT_TYPE, BLOB_TYPE, BOOLEAN_TYPE } from "../../types/builtin-types.js";
+import { typeRegistry } from "../../types/registry.js";
 
 export class UnaryOpNode extends PlanNode implements UnaryScalarNode {
 	readonly nodeType = PlanNodeType.UnaryOp;
@@ -25,36 +27,31 @@ export class UnaryOpNode extends PlanNode implements UnaryScalarNode {
 	generateType = (): ScalarType => {
 		const operandType = this.operand.getType();
 
-		let datatype: SqlDataType | undefined;
-		let affinity: SqlDataType = operandType.affinity;
+		let logicalType = operandType.logicalType;
 		let nullable = operandType.nullable;
 
 		switch (this.expression.operator) {
 			case 'NOT':
 			case 'IS NULL':
 			case 'IS NOT NULL':
-				datatype = SqlDataType.INTEGER;
-				affinity = SqlDataType.INTEGER;
+				logicalType = BOOLEAN_TYPE;
 				nullable = false; // Boolean results are never null
 				break;
 			case '-':
 			case '+':
-				// Numeric unary operators preserve type but may change nullability
-				datatype = operandType.datatype;
+				// Numeric unary operators preserve type
 				break;
 			case '~':
 				// Bitwise NOT - results in integer
-				datatype = SqlDataType.INTEGER;
-				affinity = SqlDataType.INTEGER;
+				logicalType = INTEGER_TYPE;
 				break;
 		}
 
 		return {
 			typeClass: 'scalar',
-			affinity,
+			logicalType,
 			nullable,
 			isReadOnly: operandType.isReadOnly,
-			datatype,
 			collationName: operandType.collationName,
 		};
 	}
@@ -130,17 +127,11 @@ export class BinaryOpNode extends PlanNode implements BinaryScalarNode {
 		const leftType = this.left.getType();
 		const rightType = this.right.getType();
 
-		const affinity = leftType.affinity;
+		let logicalType = leftType.logicalType;
 
-		let datatype: SqlDataType | undefined;
 		switch (this.expression.operator) {
 			case 'OR':
 			case 'AND':
-			case '+':
-			case '-':
-			case '*':
-			case '/':
-			case '%':
 			case '=':
 			case '!=':
 			case '<':
@@ -150,10 +141,33 @@ export class BinaryOpNode extends PlanNode implements BinaryScalarNode {
 			case 'IS':
 			case 'IS NOT':
 			case 'IN':
-				datatype = SqlDataType.INTEGER;
+				// Comparison and logical operators return boolean
+				logicalType = BOOLEAN_TYPE;
+				break;
+			case '+':
+			case '-':
+			case '*':
+			case '/':
+			case '%':
+				// Arithmetic operators - implement numeric type promotion
+				// Rules: INTEGER + INTEGER -> INTEGER, INTEGER + REAL -> REAL, REAL + REAL -> REAL
+				if (leftType.logicalType.isNumeric && rightType.logicalType.isNumeric) {
+					// Both operands are numeric
+					if (leftType.logicalType.name === 'REAL' || rightType.logicalType.name === 'REAL') {
+						// If either is REAL, result is REAL
+						logicalType = REAL_TYPE;
+					} else {
+						// Both are INTEGER, result is INTEGER
+						logicalType = INTEGER_TYPE;
+					}
+				} else {
+					// Non-numeric operands - use left operand type (fallback)
+					logicalType = leftType.logicalType;
+				}
 				break;
 			case '||':
-				datatype = SqlDataType.TEXT;
+				// String concatenation
+				logicalType = TEXT_TYPE;
 				break;
 		};
 
@@ -162,10 +176,9 @@ export class BinaryOpNode extends PlanNode implements BinaryScalarNode {
 
 		return {
 			typeClass: 'scalar',
-			affinity,
+			logicalType,
 			nullable: leftType.nullable || rightType.nullable,
 			isReadOnly: leftType.isReadOnly || rightType.isReadOnly,
-			datatype,
 			collationName,
 		};
 	}
@@ -252,55 +265,49 @@ export class LiteralNode extends PlanNode implements ZeroAryScalarNode, Constant
 		if (value === null) {
 			return {
 				typeClass: 'scalar',
-				affinity: SqlDataType.NULL,
+				logicalType: NULL_TYPE,
 				nullable: true,
 				isReadOnly: true,
-				datatype: SqlDataType.NULL,
 			};
 		}
 		if (typeof value === 'number') {
 			return {
 				typeClass: 'scalar',
-				affinity: SqlDataType.REAL,
+				logicalType: REAL_TYPE,
 				nullable: false,
 				isReadOnly: true,
-				datatype: SqlDataType.REAL,
 			};
 		}
 		if (typeof value === 'bigint') {
 			return {
 				typeClass: 'scalar',
-				affinity: SqlDataType.INTEGER,
+				logicalType: INTEGER_TYPE,
 				nullable: false,
 				isReadOnly: true,
-				datatype: SqlDataType.INTEGER,
 			};
 		}
 		if (typeof value === 'string') {
 			return {
 				typeClass: 'scalar',
-				affinity: SqlDataType.TEXT,
+				logicalType: TEXT_TYPE,
 				nullable: false,
 				isReadOnly: true,
-				datatype: SqlDataType.TEXT,
 			};
 		}
 		if (typeof value === 'boolean') {
 			return {
 				typeClass: 'scalar',
-				affinity: SqlDataType.INTEGER,
+				logicalType: BOOLEAN_TYPE,
 				nullable: false,
 				isReadOnly: true,
-				datatype: SqlDataType.INTEGER,
 			};
 		}
 		if (value instanceof Uint8Array) {
 			return {
 				typeClass: 'scalar',
-				affinity: SqlDataType.BLOB,
+				logicalType: BLOB_TYPE,
 				nullable: false,
 				isReadOnly: true,
-				datatype: SqlDataType.BLOB,
 			};
 		}
 		quereusError(`Unknown literal type ${typeof value}`, StatusCode.INTERNAL);
@@ -377,16 +384,15 @@ export class CaseExprNode extends PlanNode implements NaryScalarNode {
 			// No THEN clauses and no ELSE - should not happen in valid SQL
 			return {
 				typeClass: 'scalar',
-				affinity: SqlDataType.NULL,
+				logicalType: NULL_TYPE,
 				nullable: true,
 				isReadOnly: true,
-				datatype: SqlDataType.NULL,
 			};
 		}
 
 		// Use the first result expression as the base type
 		const firstType = resultExpressions[0].getType();
-		let affinity = firstType.affinity;
+		let logicalType = firstType.logicalType;
 		let nullable = firstType.nullable;
 		let isReadOnly = firstType.isReadOnly;
 		let collationName = firstType.collationName;
@@ -411,9 +417,9 @@ export class CaseExprNode extends PlanNode implements NaryScalarNode {
 			}
 
 			// TODO: Implement proper type coercion rules for SQL
-			// For now, if types differ, default to TEXT affinity
-			if (exprType.affinity !== affinity) {
-				affinity = SqlDataType.TEXT;
+			// For now, if types differ, default to TEXT
+			if (exprType.logicalType !== logicalType) {
+				logicalType = TEXT_TYPE;
 			}
 		}
 
@@ -424,11 +430,10 @@ export class CaseExprNode extends PlanNode implements NaryScalarNode {
 
 		return {
 			typeClass: 'scalar',
-			affinity,
+			logicalType,
 			nullable,
 			isReadOnly,
 			collationName,
-			// Don't set datatype since it can vary based on runtime conditions
 		};
 	}
 
@@ -558,69 +563,17 @@ export class CastNode extends PlanNode implements UnaryScalarNode {
 
 	generateType = (): ScalarType => {
 		const operandType = this.operand.getType();
-		const targetType = this.expression.targetType.toUpperCase();
-
-		// Determine the SQL data type and affinity based on the target type
-		let datatype: SqlDataType;
-		let affinity: SqlDataType;
-
-		switch (targetType) {
-			case 'INTEGER':
-			case 'INT':
-			case 'TINYINT':
-			case 'SMALLINT':
-			case 'MEDIUMINT':
-			case 'BIGINT':
-			case 'UNSIGNED BIG INT':
-			case 'INT2':
-			case 'INT8':
-				datatype = SqlDataType.INTEGER;
-				affinity = SqlDataType.INTEGER;
-				break;
-			case 'REAL':
-			case 'DOUBLE':
-			case 'DOUBLE PRECISION':
-			case 'FLOAT':
-				datatype = SqlDataType.REAL;
-				affinity = SqlDataType.REAL;
-				break;
-			case 'TEXT':
-			case 'CHARACTER':
-			case 'VARCHAR':
-			case 'VARYING CHARACTER':
-			case 'NCHAR':
-			case 'NATIVE CHARACTER':
-			case 'NVARCHAR':
-			case 'CLOB':
-				datatype = SqlDataType.TEXT;
-				affinity = SqlDataType.TEXT;
-				break;
-			case 'BLOB':
-				datatype = SqlDataType.BLOB;
-				affinity = SqlDataType.BLOB;
-				break;
-			case 'NUMERIC':
-			case 'DECIMAL':
-			case 'BOOLEAN':
-			case 'DATE':
-			case 'DATETIME':
-				datatype = SqlDataType.NUMERIC;
-				affinity = SqlDataType.NUMERIC;
-				break;
-			default:
-				// For unknown types, default to BLOB affinity
-				datatype = SqlDataType.BLOB;
-				affinity = SqlDataType.BLOB;
-				break;
-		}
+		const targetType = this.expression.targetType;
+
+		// Look up the logical type from the type registry
+		const logicalType = typeRegistry.getTypeOrDefault(targetType);
 
 		return {
 			typeClass: 'scalar',
-			affinity,
+			logicalType,
 			nullable: operandType.nullable, // CAST preserves nullability
 			isReadOnly: operandType.isReadOnly,
-			datatype,
-			collationName: affinity === SqlDataType.TEXT ? operandType.collationName : undefined,
+			collationName: logicalType.isTextual ? operandType.collationName : undefined,
 		};
 	}
 
@@ -756,13 +709,12 @@ export class BetweenNode extends PlanNode implements TernaryScalarNode {
 	}
 
 	getType(): ScalarType {
-		// BETWEEN always returns INTEGER (0 or 1)
+		// BETWEEN always returns BOOLEAN
 		return {
 			typeClass: 'scalar',
-			affinity: SqlDataType.INTEGER,
+			logicalType: BOOLEAN_TYPE,
 			nullable: false,
 			isReadOnly: true,
-			datatype: SqlDataType.INTEGER,
 		};
 	}
 

package/src/planner/nodes/sequencing-node.ts

@@ -3,7 +3,7 @@ import { isRelationalNode, PlanNode, type Attribute, type RelationalPlanNode, ty
 import type { RelationType } from '../../common/datatype.js';
 import type { Scope } from '../scopes/scope.js';
 import { Cached } from '../../util/cached.js';
-import { SqlDataType } from '../../common/types.js';
+import { INTEGER_TYPE } from '../../types/builtin-types.js';
 
 /**
  * Represents a sequencing operation that adds a row number column to convert bags to sets.
@@ -31,7 +31,7 @@ export class SequencingNode extends PlanNode implements UnaryRelationalNode {
 				name: this.sequenceColumnName,
 				type: {
 					typeClass: 'scalar' as const,
-					affinity: SqlDataType.INTEGER,
+					logicalType: INTEGER_TYPE,
 					nullable: false,
 					isReadOnly: true
 				},

package/src/planner/nodes/sink-node.ts

@@ -2,7 +2,7 @@ import { PlanNodeType } from './plan-node-type.js';
 import { PlanNode, type RelationalPlanNode } from './plan-node.js';
 import type { ScalarType } from '../../common/datatype.js';
 import type { Scope } from '../scopes/scope.js';
-import { SqlDataType } from '../../common/types.js';
+import { INTEGER_TYPE } from '../../types/builtin-types.js';
 
 /**
  * A sink node that consumes an async iterable for side effects.
@@ -25,7 +25,7 @@ export class SinkNode extends PlanNode {
 		return {
 			typeClass: 'scalar',
 			isReadOnly: true,
-			affinity: SqlDataType.INTEGER,
+			logicalType: INTEGER_TYPE,
 			nullable: false
 		};
 	}

package/src/planner/nodes/subquery.ts

@@ -1,13 +1,14 @@
 import { PlanNode, type ScalarPlanNode } from "./plan-node.js";
 import type { ScalarType } from "../../common/datatype.js";
 import type { RelationalPlanNode } from "./plan-node.js";
-import { type CompareFn, SqlDataType } from "../../common/types.js";
+import { type CompareFn } from "../../common/types.js";
 import { PlanNodeType } from "./plan-node-type.js";
 import type { Scope } from "../scopes/scope.js";
 import { compareSqlValues } from "../../util/comparison.js";
 import type { Expression } from "../../parser/ast.js";
 import { formatExpression, formatScalarType } from "../../util/plan-formatter.js";
 import { quereusError } from "../../common/errors.js";
+import { BLOB_TYPE, BOOLEAN_TYPE, INTEGER_TYPE } from "../../types/builtin-types.js";
 import { StatusCode } from "../../common/types.js";
 
 export class ScalarSubqueryNode extends PlanNode implements ScalarPlanNode {
@@ -31,10 +32,9 @@ export class ScalarSubqueryNode extends PlanNode implements ScalarPlanNode {
 		// Fallback to nullable BLOB if we can't determine type
 		return {
 			typeClass: 'scalar',
-			affinity: SqlDataType.BLOB,
+			logicalType: BLOB_TYPE,
 			nullable: true,
 			isReadOnly: true,
-			datatype: SqlDataType.BLOB,
 		};
 	}
 
@@ -103,10 +103,9 @@ export class InNode extends PlanNode implements ScalarPlanNode {
 	getType(): ScalarType {
 		return {
 			typeClass: 'scalar',
-			affinity: SqlDataType.INTEGER,
+			logicalType: BOOLEAN_TYPE,
 			nullable: false,
 			isReadOnly: true,
-			datatype: SqlDataType.INTEGER,
 		}
 	}
 
@@ -216,10 +215,9 @@ export class ExistsNode extends PlanNode implements ScalarPlanNode {
 	getType(): ScalarType {
 		return {
 			typeClass: 'scalar',
-			affinity: SqlDataType.INTEGER,
+			logicalType: BOOLEAN_TYPE,
 			nullable: false,
 			isReadOnly: true,
-			datatype: SqlDataType.INTEGER,
 		};
 	}
 

package/src/planner/nodes/view-reference-node.ts

@@ -1,10 +1,10 @@
 import { PlanNode, type ZeroAryRelationalNode, type Attribute } from './plan-node.js';
 import type { RelationType } from '../../common/datatype.js';
-import { SqlDataType } from '../../common/types.js';
 import { PlanNodeType } from './plan-node-type.js';
 import type { Scope } from '../scopes/scope.js';
 import type { ViewSchema } from '../../schema/view.js';
 import { Cached } from '../../util/cached.js';
+import { TEXT_TYPE } from '../../types/builtin-types.js';
 
 /**
  * Plan node for referencing a view in a FROM clause.
@@ -36,7 +36,7 @@ export class ViewReferenceNode extends PlanNode implements ZeroAryRelationalNode
 			name: columnName,
 			type: {
 				typeClass: 'scalar' as const,
-				affinity: SqlDataType.TEXT,
+				logicalType: TEXT_TYPE,
 				nullable: true,
 				isReadOnly: false
 			}, // Default type, should be inferred

package/src/planner/nodes/window-function.ts

@@ -4,8 +4,8 @@ import type { ScalarType } from '../../common/datatype.js';
 import type { Scope } from '../scopes/scope.js';
 import type { WindowFunctionExpr } from '../../parser/ast.js';
 import { Cached } from '../../util/cached.js';
-import { SqlDataType } from '../../common/types.js';
 import { formatScalarType } from '../../util/plan-formatter.js';
+import { INTEGER_TYPE, REAL_TYPE } from '../../types/builtin-types.js';
 
 /**
  * Represents a window function call in the query plan.
@@ -30,10 +30,10 @@ export class WindowFunctionCallNode extends PlanNode implements ZeroAryScalarNod
 			// Most window functions return numeric types
 			// row_number() specifically returns an integer
 			if (this.functionName === 'row_number') {
-				return { typeClass: 'scalar', affinity: SqlDataType.INTEGER, nullable: false } satisfies ScalarType;
+				return { typeClass: 'scalar', logicalType: INTEGER_TYPE, nullable: false } satisfies ScalarType;
 			}
 			// Other window functions would have their own type inference
-			return { typeClass: 'scalar', affinity: SqlDataType.NUMERIC, nullable: false } satisfies ScalarType;
+			return { typeClass: 'scalar', logicalType: REAL_TYPE, nullable: false } satisfies ScalarType;
 		});
 	}
 

package/src/planner/rules/access/rule-select-access-path.ts

@@ -120,7 +120,7 @@ function createIndexBasedAccess(retrieveNode: RetrieveNode, context: OptContext)
 			columns: tableSchema.columns.map((col, index) => ({
 				index,
 				name: col.name,
-				type: col.affinity,
+				type: col.logicalType,
 				isPrimaryKey: col.primaryKey || false,
 				isUnique: col.primaryKey || false // For now, assume only PK columns are unique
 			} as ColumnMeta)),

package/src/planner/rules/retrieve/rule-grow-retrieve.ts

@@ -231,7 +231,7 @@ function fallbackIndexSupports(
 		columns: tableSchema.columns.map((col, index) => ({
 			index,
 			name: col.name,
-			type: col.affinity,
+			type: col.logicalType,
 			isPrimaryKey: col.primaryKey || false,
 			isUnique: col.primaryKey || false
 		})),

package/src/planner/scopes/global.ts

@@ -5,8 +5,8 @@ import * as AST from "../../parser/ast.js";
 import { FunctionReferenceNode, TableReferenceNode } from "../nodes/reference.js";
 import { Ambiguous } from "./scope.js";
 import type { ScalarType } from "../../common/datatype.js";
-import { SqlDataType } from "../../common/types.js";
 import { isScalarFunctionSchema } from "../../schema/function.js";
+import { REAL_TYPE } from "../../types/builtin-types.js";
 
 export class GlobalScope extends BaseScope {
 	constructor(public readonly manager: SchemaManager) {
@@ -25,7 +25,7 @@ export class GlobalScope extends BaseScope {
 			// Get the proper scalar type from the function schema
 			const scalarType: ScalarType = isScalarFunctionSchema(func)
 				? func.returnType
-				: { typeClass: 'scalar', affinity: SqlDataType.NUMERIC, nullable: true, isReadOnly: true };
+				: { typeClass: 'scalar', logicalType: REAL_TYPE, nullable: true, isReadOnly: true };
 
 			return new FunctionReferenceNode(this, func, scalarType);
 		}
@@ -54,7 +54,7 @@ export class GlobalScope extends BaseScope {
 			// Get the proper scalar type from the function schema
 			const scalarType: ScalarType = isScalarFunctionSchema(func)
 				? func.returnType
-				: { typeClass: 'scalar', affinity: SqlDataType.NUMERIC, nullable: true, isReadOnly: true };
+				: { typeClass: 'scalar', logicalType: REAL_TYPE, nullable: true, isReadOnly: true };
 
 			return new FunctionReferenceNode(this, func, scalarType);
 		}

package/src/planner/scopes/param.ts

@@ -3,13 +3,13 @@ import { ParameterReferenceNode } from '../nodes/reference.js'; // Corrected imp
 import { BaseScope } from './base.js';
 import { Ambiguous, type Scope } from './scope.js';
 import type { ScalarType } from '../../common/datatype.js';
-import { SqlDataType } from '../../common/types.js';
 import type { PlanNode } from '../nodes/plan-node.js';
+import { TEXT_TYPE } from '../../types/builtin-types.js';
 
 // Default type for parameters when not otherwise specified.
 const DEFAULT_PARAMETER_TYPE: ScalarType = {
 	typeClass: 'scalar',
-	affinity: SqlDataType.TEXT,
+	logicalType: TEXT_TYPE,
 	nullable: true,
 };
 

package/src/planner/type-utils.ts

@@ -4,8 +4,7 @@ import type { RelationType, ColumnDef, ScalarType, ColRef } from '../common/data
 import { SqlDataType, StatusCode, type DeepReadonly, type SqlValue } from '../common/types.js'; // Import SqlValue and ensure SqlDataType is not type-only
 import type { AstNode } from '../parser/ast.js';
 import { QuereusError } from '../common/errors.js';
-// Note: getAffinity from '../schema/column.js' is used by the ColumnSchema type from table.js itself if that's what we use.
-// If tableSchema.columns are of type from '../schema/column.js', then their affinity is already SqlDataType.
+import { inferLogicalTypeFromValue } from '../common/type-inference.js';
 
 /**
  * Converts a TableSchema (from src/schema/table.ts) to a RelationType (from src/common/datatype.ts).
@@ -17,7 +16,7 @@ export function relationTypeFromTableSchema(tableSchema: TableSchema): RelationT
       name: col.name,
       type: {
 				typeClass: 'scalar',
-				affinity: col.affinity,
+				logicalType: col.logicalType,
 				collationName: col.collation,
 				nullable: !col.notNull,
 				isReadOnly: false,
@@ -53,18 +52,11 @@ export function relationTypeFromTableSchema(tableSchema: TableSchema): RelationT
  * @returns A ScalarType representing the inferred type of the value.
  */
 export function getParameterScalarType(value: SqlValue): ScalarType {
-  let affinity: SqlDataType;
-  if (value === null) affinity = SqlDataType.NULL;
-  else if (typeof value === 'number') affinity = SqlDataType.REAL;
-  else if (typeof value === 'bigint') affinity = SqlDataType.INTEGER;
-  else if (typeof value === 'string') affinity = SqlDataType.TEXT;
-  else if (value instanceof Uint8Array) affinity = SqlDataType.BLOB;
-  else if (typeof value === 'boolean') affinity = SqlDataType.INTEGER; // Store booleans as INTEGER
-  else affinity = SqlDataType.BLOB; // Default for unknown types that might pass as SqlValue
+  const logicalType = inferLogicalTypeFromValue(value);
 
   return {
     typeClass: 'scalar',
-    affinity: affinity,
+    logicalType,
     nullable: true,	// No guarantees about the value, so it's nullable
     isReadOnly: true, // Parameters are read-only within the query execution context
   };
@@ -80,12 +72,12 @@ export function checkRelationsAssignable(source: RelationType, target: RelationT
 	return checkColumnsAssignable(source.columns, target.columns, astNode);
 }
 
-export function columnSchemaToDef(colName: string, colDef: ColumnSchema): { name: string; type: { typeClass: "scalar"; affinity: SqlDataType; collationName: string; nullable: boolean; isReadOnly: false; }; generated: boolean; } {
+export function columnSchemaToDef(colName: string, colDef: ColumnSchema): ColumnDef {
 	return {
 		name: colName,
 		type: {
 			typeClass: 'scalar',
-			affinity: colDef.affinity,
+			logicalType: colDef.logicalType,
 			collationName: colDef.collation,
 			nullable: !colDef.notNull,
 			isReadOnly: false,

package/src/runtime/emit/between.ts

@@ -27,11 +27,11 @@ export function emitBetween(plan: BetweenNode, ctx: EmissionContext): Instructio
 		const upperResult = compareSqlValuesFast(coercedValue2, coercedUpper, collationFunc);
 
 		// value >= lowerBound AND value <= upperBound
-		const betweenResult = (lowerResult >= 0 && upperResult <= 0) ? 1 : 0;
+		const betweenResult = (lowerResult >= 0 && upperResult <= 0);
 
 		// Handle NOT BETWEEN
 		if (plan.expression.not) {
-			return betweenResult ? 0 : 1;
+			return !betweenResult;
 		}
 
 		return betweenResult;