@quereus/quereus 0.5.1 → 0.6.0

package/src/planner/building/insert.ts

@@ -197,7 +197,7 @@ export function buildInsertStmt(
 				name: contextVar.name,
 				type: {
 					typeClass: 'scalar' as const,
-					affinity: contextVar.affinity,
+					logicalType: contextVar.logicalType,
 					nullable: !contextVar.notNull,
 					isReadOnly: true
 				},
@@ -287,7 +287,7 @@ export function buildInsertStmt(
 		name: col.name,
 		type: {
 			typeClass: 'scalar' as const,
-			affinity: col.affinity,
+			logicalType: col.logicalType,
 			nullable: true, // OLD values are always NULL for INSERT
 			isReadOnly: false
 		},
@@ -299,7 +299,7 @@ export function buildInsertStmt(
 		name: col.name,
 		type: {
 			typeClass: 'scalar' as const,
-			affinity: col.affinity,
+			logicalType: col.logicalType,
 			nullable: !col.notNull,
 			isReadOnly: false
 		},

package/src/planner/building/select.ts

@@ -18,6 +18,7 @@ import { InternalRecursiveCTERefNode as _InternalRecursiveCTERefNode } from '../
 import type { CTEScopeNode, CTEPlanNode } from '../nodes/cte-node.js';
 import { JoinNode } from '../nodes/join-node.js';
 import { ColumnReferenceNode } from '../nodes/reference.js';
+import { TEXT_TYPE } from '../../types/builtin-types.js';
 import { ValuesNode } from '../nodes/values-node.js';
 import { createLogger } from '../../common/logger.js';
 
@@ -440,7 +441,7 @@ export function buildFrom(fromClause: AST.FromClause, parentContext: PlanningCon
 		columnNames.forEach((colName, i) => {
 			if (i < subqueryAttributes.length) {
 				const attr = subqueryAttributes[i];
-				const columnType = fromTable.getType().columns[i]?.type || { typeClass: 'scalar', affinity: 'TEXT', nullable: true, isReadOnly: true };
+				const columnType = fromTable.getType().columns[i]?.type || { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: true, isReadOnly: true };
 				subqueryScope.registerSymbol(colName.toLowerCase(), (exp, s) =>
 					new ColumnReferenceNode(s, exp as AST.ColumnExpr, columnType, attr.id, i));
 			}
@@ -479,7 +480,7 @@ export function buildFrom(fromClause: AST.FromClause, parentContext: PlanningCon
 		columnNames.forEach((colName, i) => {
 			if (i < mutatingAttributes.length) {
 				const attr = mutatingAttributes[i];
-				const columnType = fromTable.getType().columns[i]?.type || { typeClass: 'scalar', affinity: 'TEXT', nullable: true, isReadOnly: false };
+				const columnType = fromTable.getType().columns[i]?.type || { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: true, isReadOnly: false };
 				mutatingScope.registerSymbol(colName.toLowerCase(), (exp, s) =>
 					new ColumnReferenceNode(s, exp as AST.ColumnExpr, columnType, attr.id, i));
 			}

package/src/planner/building/update.ts

@@ -36,7 +36,7 @@ export function buildUpdateStmt(
         name: contextVar.name,
         type: {
           typeClass: 'scalar' as const,
-          affinity: contextVar.affinity,
+          logicalType: contextVar.logicalType,
           nullable: !contextVar.notNull,
           isReadOnly: true
         },
@@ -86,7 +86,7 @@ export function buildUpdateStmt(
     name: col.name,
     type: {
       typeClass: 'scalar' as const,
-      affinity: col.affinity,
+      logicalType: col.logicalType,
       nullable: !col.notNull,
       isReadOnly: false
     },
@@ -98,7 +98,7 @@ export function buildUpdateStmt(
     name: col.name,
     type: {
       typeClass: 'scalar' as const,
-      affinity: col.affinity,
+      logicalType: col.logicalType,
       nullable: !col.notNull,
       isReadOnly: false
     },
@@ -151,7 +151,7 @@ export function buildUpdateStmt(
           exp as AST.ColumnExpr,
           {
             typeClass: 'scalar',
-            affinity: tableColumn.affinity,
+            logicalType: tableColumn.logicalType,
             nullable: !tableColumn.notNull,
             isReadOnly: false
           },
@@ -168,7 +168,7 @@ export function buildUpdateStmt(
           exp as AST.ColumnExpr,
           {
             typeClass: 'scalar',
-            affinity: tableColumn.affinity,
+            logicalType: tableColumn.logicalType,
             nullable: !tableColumn.notNull,
             isReadOnly: false
           },
@@ -184,7 +184,7 @@ export function buildUpdateStmt(
           exp as AST.ColumnExpr,
           {
             typeClass: 'scalar',
-            affinity: tableColumn.affinity,
+            logicalType: tableColumn.logicalType,
             nullable: !tableColumn.notNull,
             isReadOnly: false
           },
@@ -200,7 +200,7 @@ export function buildUpdateStmt(
           exp as AST.ColumnExpr,
           {
             typeClass: 'scalar',
-            affinity: tableColumn.affinity,
+            logicalType: tableColumn.logicalType,
             nullable: !tableColumn.notNull,
             isReadOnly: false
           },

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

@@ -6,6 +6,7 @@ import type { FunctionSchema } from '../../schema/function.js';
 import { isAggregateFunctionSchema } from '../../schema/function.js';
 import type * as AST from '../../parser/ast.js';
 import { formatExpressionList, formatScalarType } from '../../util/plan-formatter.js';
+import { NULL_TYPE } from '../../types/builtin-types.js';
 
 /**
  * Represents an aggregate function call within a SQL query.
@@ -13,6 +14,7 @@ import { formatExpressionList, formatScalarType } from '../../util/plan-formatte
  */
 export class AggregateFunctionCallNode extends PlanNode implements ScalarPlanNode {
 	readonly nodeType = PlanNodeType.ScalarFunctionCall; // Using same type as scalar functions
+	private readonly _inferredType?: ScalarType;
 
 	constructor(
 		scope: Scope,
@@ -22,12 +24,19 @@ export class AggregateFunctionCallNode extends PlanNode implements ScalarPlanNod
 		public readonly args: ReadonlyArray<ScalarPlanNode>,
 		public readonly isDistinct: boolean = false,
 		public readonly orderBy?: ReadonlyArray<{ expression: ScalarPlanNode; direction: 'asc' | 'desc' }>,
-		public readonly filter?: ScalarPlanNode
+		public readonly filter?: ScalarPlanNode,
+		inferredType?: ScalarType
 	) {
 		super(scope);
+		this._inferredType = inferredType;
 	}
 
 	getType(): ScalarType {
+		// Use inferred type if available
+		if (this._inferredType) {
+			return this._inferredType;
+		}
+
 		// Get the return type from the function schema
 		if (isAggregateFunctionSchema(this.functionSchema)) {
 			return this.functionSchema.returnType;
@@ -36,7 +45,7 @@ export class AggregateFunctionCallNode extends PlanNode implements ScalarPlanNod
 		// Fallback for non-aggregate functions (shouldn't happen)
 		return {
 			typeClass: 'scalar',
-			affinity: 0,
+			logicalType: NULL_TYPE,
 			nullable: true, // Aggregates can return NULL
 			isReadOnly: true
 		};
@@ -109,7 +118,8 @@ export class AggregateFunctionCallNode extends PlanNode implements ScalarPlanNod
 			newArgs,
 			this.isDistinct,
 			newOrderBy,
-			newFilter
+			newFilter,
+			this._inferredType
 		);
 	}
 

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

@@ -1,10 +1,10 @@
 import { PlanNode, type UnaryRelationalNode, type RelationalPlanNode, type Attribute, type TableDescriptor, isRelationalNode } from './plan-node.js';
 import type { RelationType, ScalarType } 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 { Cached } from '../../util/cached.js';
 import type { CTECapable } from '../framework/characteristics.js';
+import { TEXT_TYPE } from '../../types/builtin-types.js';
 
 /**
  * Narrow contract that any node must satisfy to be placed in the CTE lookup map
@@ -74,7 +74,7 @@ export class CTENode extends PlanNode implements CTEPlanNode, CTEScopeNode, CTEC
 			}
 			// Fallback: generic TEXT scalar if nothing else is available (should not normally happen)
 			if (!resolvedType) {
-				resolvedType = { typeClass: 'scalar', affinity: SqlDataType.TEXT, nullable: true, isReadOnly: false } satisfies ScalarType;
+				resolvedType = { typeClass: 'scalar', logicalType: TEXT_TYPE, nullable: true, isReadOnly: false } satisfies ScalarType;
 			}
 			return {
 				id: srcAttr?.id ?? PlanNode.nextAttrId(),

package/src/planner/nodes/declarative-schema.ts

@@ -3,7 +3,7 @@ import { PlanNodeType } from './plan-node-type.js';
 import type { Scope } from '../scopes/scope.js';
 import type * as AST from '../../parser/ast.js';
 import { RelationType, type VoidType } from '../../common/datatype.js';
-import { SqlDataType } from '../../common/types.js';
+import { TEXT_TYPE } from '../../types/builtin-types.js';
 
 /**
  * DECLARE SCHEMA statement plan node
@@ -66,7 +66,7 @@ export class DiffSchemaNode extends PlanNode implements RelationalPlanNode {
 					name: 'ddl',
 					type: {
 						typeClass: 'scalar',
-						affinity: SqlDataType.TEXT,
+						logicalType: TEXT_TYPE,
 						nullable: false,
 						isReadOnly: true,
 					},
@@ -172,7 +172,7 @@ export class ExplainSchemaNode extends PlanNode implements RelationalPlanNode {
 					name: 'info',
 					type: {
 						typeClass: 'scalar',
-						affinity: SqlDataType.TEXT,
+						logicalType: TEXT_TYPE,
 						nullable: false,
 						isReadOnly: true,
 					},

package/src/planner/nodes/function.ts

@@ -9,18 +9,22 @@ import { FunctionFlags } from '../../common/constants.js';
 
 export class ScalarFunctionCallNode extends PlanNode implements NaryScalarNode {
 	override readonly nodeType = PlanNodeType.ScalarFunctionCall;
+	private readonly _inferredType?: ScalarType;
 
 	constructor(
 		scope: Scope,
 		public readonly expression: AST.FunctionExpr,
 		public readonly functionSchema: FunctionSchema,
-		public readonly operands: ScalarPlanNode[]
+		public readonly operands: ScalarPlanNode[],
+		inferredType?: ScalarType
 	) {
 		super(scope);
+		this._inferredType = inferredType;
 	}
 
 	getType(): ScalarType {
-		return this.functionSchema.returnType as ScalarType;
+		// Use inferred type if available, otherwise use schema's return type
+		return this._inferredType ?? (this.functionSchema.returnType as ScalarType);
 	}
 
 	getChildren(): readonly ScalarPlanNode[] {
@@ -54,7 +58,8 @@ export class ScalarFunctionCallNode extends PlanNode implements NaryScalarNode {
 			this.scope,
 			this.expression,
 			this.functionSchema,
-			newChildren as ScalarPlanNode[]
+			newChildren as ScalarPlanNode[],
+			this._inferredType
 		);
 	}
 

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

@@ -50,7 +50,7 @@ export class InsertNode extends PlanNode implements RelationalPlanNode {
           name: col.name,
           type: {
             typeClass: 'scalar',
-            affinity: col.affinity,
+            logicalType: col.logicalType,
             nullable: isOld ? true : !col.notNull, // OLD values can be null, NEW follows column constraints
             isReadOnly: false
           },

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