@quereus/quereus 0.4.11 → 0.5.1

package/src/func/builtins/json.ts

@@ -2,10 +2,20 @@ import fastJsonPatch from 'fast-json-patch';
 import type { Operation } from 'fast-json-patch';
 const { applyPatch } = fastJsonPatch;
 
+// moat-maker: Runtime validation library with TypeScript-like syntax
+// Used for json_schema() function to validate JSON against structural schemas
+import { validator } from 'moat-maker';
+
 import { createLogger } from '../../common/logger.js';
 import type { SqlValue, JSONValue } from '../../common/types.js';
 import { createScalarFunction, createAggregateFunction } from '../registration.js';
 import { safeJsonParse, resolveJsonPathForModify, prepareJsonValue, deepCopyJson, getJsonType } from './json-helpers.js';
+import type { ScalarFunctionCallNode } from '../../planner/nodes/function.js';
+import type { EmissionContext } from '../../runtime/emission-context.js';
+import type { Instruction, RuntimeContext } from '../../runtime/types.js';
+import { PlanNodeType } from '../../planner/nodes/plan-node-type.js';
+import { LiteralNode } from '../../planner/nodes/scalar.js';
+import { emitPlanNode } from '../../runtime/emitters.js';
 
 const log = createLogger('func:builtins:json');
 const errorLog = log.extend('error');
@@ -20,6 +30,117 @@ export const jsonValidFunc = createScalarFunction(
 	}
 );
 
+
+
+/**
+ * Custom emitter for json_schema that caches compiled validators in the EmissionContext.
+ * This provides significant performance improvements for CHECK constraints and repeated validations.
+ */
+function emitJsonSchema(
+	plan: ScalarFunctionCallNode,
+	ctx: EmissionContext,
+	defaultEmit: (plan: ScalarFunctionCallNode, ctx: EmissionContext) => Instruction
+): Instruction {
+	// Check if the second argument (schema definition) is a constant
+	const schemaDefArg = plan.operands[1];
+
+	if (schemaDefArg?.nodeType === PlanNodeType.Literal) {
+		const literalNode = schemaDefArg as LiteralNode;
+		const schemaDef = literalNode.getValue();
+
+		if (typeof schemaDef === 'string') {
+			try {
+				// Compile the validator once at emission time using moat-maker
+				// moat-maker uses template literals, so we need to create a validator dynamically
+				// Template literals have a special structure: an array with a 'raw' property
+				// We create this structure manually to simulate a template literal
+				const parts: any = [schemaDef];
+				parts.raw = [schemaDef];
+				const compiledValidator = validator(parts, ...[]);
+
+				// Emit only the JSON argument (first operand)
+				const jsonArgInstruction = emitPlanNode(plan.operands[0], ctx);
+
+				// Create optimized runtime function that uses the cached validator
+				// The validator is captured in the closure, so it lives with the plan
+				function run(_rctx: RuntimeContext, ...args: any[]): SqlValue {
+					const json = args[0];
+					if (typeof json !== 'string') return 0;
+
+					let data: JSONValue | null;
+					try {
+						data = JSON.parse(json) as JSONValue;
+					} catch {
+						return 0; // Invalid JSON
+					}
+
+					// Use the cached compiled validator
+					try {
+						// moat-maker's .matches() returns true if valid, false otherwise
+						const isValid = compiledValidator.matches(data);
+						return isValid ? 1 : 0;
+					} catch (e) {
+						errorLog('json_schema validation failed: %O', e);
+						return 0;
+					}
+				}
+
+				return {
+					params: [jsonArgInstruction],
+					run,
+					note: `json_schema(cached:${schemaDef.substring(0, 20)}...)`
+				};
+			} catch (e) {
+				errorLog('Failed to compile schema at emission time: %O', e);
+				// Fall through to default emission
+			}
+		}
+	}
+
+	// If schema is not a constant or compilation failed, use default emission
+	return defaultEmit(plan, ctx);
+}
+
+// json_schema(X, schema_def)
+// Note: This function uses a custom emitter that caches compiled validators
+// during plan emission for better performance.
+export const jsonSchemaFunc = createScalarFunction(
+	{ name: 'json_schema', numArgs: 2, deterministic: true },
+	(json: SqlValue, schemaDef: SqlValue): SqlValue => {
+		// This is the fallback implementation for when no cache is available
+		// (e.g., during direct function calls outside of query execution)
+
+		// Schema definition must be a string
+		if (typeof schemaDef !== 'string') return 0;
+
+		// Parse the JSON value - need to check if it's valid JSON first
+		if (typeof json !== 'string') return 0;
+
+		let data: JSONValue | null;
+		try {
+			data = JSON.parse(json) as JSONValue;
+		} catch {
+			return 0; // Invalid JSON
+		}
+
+		// Compile and validate using moat-maker (no caching in fallback path)
+		try {
+			const parts: any = [schemaDef];
+			parts.raw = [schemaDef];
+			const compiledValidator = validator(parts, ...[]);
+			// moat-maker's .matches() returns true if valid, false otherwise
+			const isValid = compiledValidator.matches(data);
+			return isValid ? 1 : 0;
+		} catch (e) {
+			errorLog('json_schema validation failed: %O', e);
+			return 0;
+		}
+	}
+);
+
+// Attach the custom emitter to the function schema
+jsonSchemaFunc.customEmitter = emitJsonSchema;
+
 // json_type(X, P?)
 export const jsonTypeFunc = createScalarFunction(
 	{ name: 'json_type', numArgs: -1, deterministic: true },

package/src/func/builtins/schema.ts

@@ -49,7 +49,7 @@ export const schemaFunc = createIntegratedTableValuedFunction(
 				for (const tableSchema of schemaInstance.getAllTables()) {
 					let createSql: string | null = null;
 					try {
-						const columnsStr = tableSchema.columns.map((c: ColumnSchema) => `"${c.name}" ${c.affinity ?? SqlDataType.TEXT}`).join(', ');
+						const columnsStr = tableSchema.columns.map((c: ColumnSchema) => `"${c.name}" ${c.logicalType.name}`).join(', ');
 						const argsStr = Object.entries(tableSchema.vtabArgs ?? {}).map(([key, value]) => `${key}=${value}`).join(', ');
 						createSql = `create table "${tableSchema.name}" (${columnsStr}) using ${tableSchema.vtabModuleName}(${argsStr})`;
 					} catch {

package/src/index.ts

@@ -47,6 +47,40 @@ export {
 	resolveCollation
 } from './util/comparison.js';
 
+// Type system
+export type { LogicalType, CollationFunction as TypeCollationFunction } from './types/logical-type.js';
+export { PhysicalType } from './types/logical-type.js';
+export {
+	NULL_TYPE,
+	INTEGER_TYPE,
+	REAL_TYPE,
+	TEXT_TYPE,
+	BLOB_TYPE,
+	BOOLEAN_TYPE,
+	NUMERIC_TYPE,
+	ANY_TYPE
+} from './types/builtin-types.js';
+export {
+	DATE_TYPE,
+	TIME_TYPE,
+	DATETIME_TYPE
+} from './types/temporal-types.js';
+export { JSON_TYPE } from './types/json-type.js';
+export {
+	typeRegistry,
+	registerType,
+	getType,
+	getTypeOrDefault,
+	inferType
+} from './types/registry.js';
+export {
+	validateValue,
+	parseValue,
+	validateAndParse,
+	isValidForType,
+	tryParse
+} from './types/validation.js';
+
 // SQL Parser and Compiler
 export { Parser } from './parser/parser.js';
 export { Lexer, TokenType, KEYWORDS } from './parser/lexer.js';
@@ -90,6 +124,7 @@ export type {
 	VTablePluginInfo,
 	FunctionPluginInfo,
 	CollationPluginInfo,
+	TypePluginInfo,
 	PluginRegistrations
 } from './vtab/manifest.js';
 

package/src/runtime/emit/binary.ts

@@ -10,7 +10,10 @@ import { simpleLike } from "../../util/patterns.js";
 import type { EmissionContext } from "../emission-context.js";
 
 export function emitBinaryOp(plan: BinaryOpNode, ctx: EmissionContext): Instruction {
-	switch (plan.expression.operator) {
+	// Normalize operator to uppercase for case-insensitive matching of keywords
+	const operator = plan.expression.operator.toUpperCase();
+
+	switch (operator) {
 		case '+':
 		case '-':
 		case '*':
@@ -227,9 +230,12 @@ export function emitConcatOp(plan: BinaryOpNode, ctx: EmissionContext): Instruct
 }
 
 export function emitLogicalOp(plan: BinaryOpNode, ctx: EmissionContext): Instruction {
+	// Normalize operator to uppercase for case-insensitive matching
+	const operator = plan.expression.operator.toUpperCase();
+
 	function run(ctx: RuntimeContext, v1: SqlValue, v2: SqlValue): SqlValue {
 		// SQL three-valued logic
-		switch (plan.expression.operator) {
+		switch (operator) {
 			case 'AND': {
 				// NULL AND x -> NULL if x is true or NULL, otherwise 0
 				// 0 AND x -> 0

package/src/runtime/emit/constraint-check.ts

@@ -9,12 +9,14 @@ import type { RowConstraintSchema, TableSchema } from '../../schema/table.js';
 import type { RowDescriptor } from '../../planner/nodes/plan-node.js';
 import { RowOpFlag } from '../../schema/table.js';
 import { withAsyncRowContext, createRowSlot } from '../context-helpers.js';
+import { expressionToString } from '../../util/ast-stringify.js';
 
 interface ConstraintMetadataEntry {
 	schema: RowConstraintSchema;
 	flatRowDescriptor: RowDescriptor;
 	evaluator: (ctx: RuntimeContext) => OutputValue;
 	constraintName: string;
+	constraintExpr: string; // Stringified constraint expression
 	shouldDefer: boolean;
 	baseTable: string;
 	contextRow?: Row; // Mutation context row if present
@@ -52,11 +54,13 @@ export function emitConstraintCheck(plan: ConstraintCheckNode, ctx: EmissionCont
 	const constraintMetadata: ConstraintMetadataEntry[] = plan.constraintChecks.map((check, idx) => {
 		const evaluatorInstruction = checkEvaluators[idx];
 		const constraintName = check.constraint.name ?? generateDefaultConstraintName(tableSchema, check.constraint);
+		const constraintExpr = expressionToString(check.constraint.expr);
 		return {
 			schema: check.constraint,
 			flatRowDescriptor: plan.flatRowDescriptor,
 			evaluator: evaluatorInstruction.run,
 			constraintName,
+			constraintExpr,
 			shouldDefer: Boolean(check.deferrable || check.initiallyDeferred || check.containsSubquery),
 			baseTable: `${tableSchema.schemaName}.${tableSchema.name}`,
 			contextRow: undefined,
@@ -261,8 +265,12 @@ async function checkCheckConstraints(
 			// CHECK constraint passes if result is truthy or NULL
 			// It fails only if result is false or 0 (SQLite-style numeric boolean)
 			if (result === false || result === 0) {
+				// Include constraint expression in error message for better debugging
+				const exprHint = metadata.constraintExpr.length <= 60
+					? ` (${metadata.constraintExpr})`
+					: '';
 				throw new QuereusError(
-					`CHECK constraint failed: ${metadata.constraintName}`,
+					`CHECK constraint failed: ${metadata.constraintName}${exprHint}`,
 					StatusCode.CONSTRAINT
 				);
 			}

package/src/runtime/emit/insert.ts

@@ -3,12 +3,11 @@ import type { Instruction, RuntimeContext, InstructionRun } from '../types.js';
 import { emitPlanNode } from '../emitters.js';
 import type { Row } from '../../common/types.js';
 import type { EmissionContext } from '../emission-context.js';
-import { SqlDataType, type SqlValue } from '../../common/types.js';
-import { applyIntegerAffinity, applyRealAffinity, applyNumericAffinity, applyTextAffinity, applyBlobAffinity } from '../../util/affinity.js';
 
 export function emitInsert(plan: InsertNode, ctx: EmissionContext): Instruction {
 	// INSERT node now only handles data transformations and passes flat rows through.
 	// The actual database insert operations are handled by DmlExecutorNode.
+	// Type conversion is handled by the table manager's validateAndParse in performInsert.
 	async function* run(_ctx: RuntimeContext, sourceValue: AsyncIterable<Row>): AsyncIterable<Row> {
 		const tableSchema = plan.table.tableSchema;
 		const colCount = tableSchema.columns.length;
@@ -23,21 +22,10 @@ export function emitInsert(plan: InsertNode, ctx: EmissionContext): Instruction
 				flatRow[i] = null;
 			}
 
-			// Fill NEW section with source values and apply type affinity (indices n..2n-1)
+			// Fill NEW section with source values (indices n..2n-1)
+			// No affinity conversion here - let the type system handle it
 			for (let colIdx = 0; colIdx < colCount; colIdx++) {
-				const sourceValue: SqlValue = sourceRow[colIdx];
-
-				let converted: SqlValue;
-				switch (tableSchema.columns[colIdx].affinity) {
-					case SqlDataType.INTEGER: converted = applyIntegerAffinity(sourceValue); break;
-					case SqlDataType.REAL: converted = applyRealAffinity(sourceValue); break;
-					case SqlDataType.NUMERIC: converted = applyNumericAffinity(sourceValue); break;
-					case SqlDataType.TEXT: converted = applyTextAffinity(sourceValue); break;
-					case SqlDataType.BLOB: converted = applyBlobAffinity(sourceValue); break;
-					default: converted = sourceValue;
-				}
-
-				flatRow[colCount + colIdx] = converted;
+				flatRow[colCount + colIdx] = sourceRow[colIdx];
 			}
 
 			yield flatRow;

package/src/runtime/emit/scalar-function.ts

@@ -7,7 +7,11 @@ import type { EmissionContext } from '../emission-context.js';
 import type { ScalarFunctionSchema } from '../../schema/function.js';
 import { isScalarFunctionSchema } from '../../schema/function.js';
 
-export function emitScalarFunctionCall(plan: ScalarFunctionCallNode, ctx: EmissionContext): Instruction {
+/**
+ * Default emission logic for scalar function calls.
+ * This is exported so custom emitters can call it if needed.
+ */
+export function emitScalarFunctionCallDefault(plan: ScalarFunctionCallNode, ctx: EmissionContext): Instruction {
 	const functionName = plan.expression.name.toLowerCase();
 	const functionSchema = plan.functionSchema;
 
@@ -41,3 +45,25 @@ export function emitScalarFunctionCall(plan: ScalarFunctionCallNode, ctx: Emissi
 		`${plan.expression.name}(${plan.operands.length})`
 	);
 }
+
+/**
+ * Main emitter for scalar function calls.
+ * Checks if the function has a custom emitter and uses it, otherwise uses default logic.
+ */
+export function emitScalarFunctionCall(plan: ScalarFunctionCallNode, ctx: EmissionContext): Instruction {
+	const functionSchema = plan.functionSchema;
+
+	// Validate that it's a scalar function
+	if (!isScalarFunctionSchema(functionSchema)) {
+		const functionName = plan.expression.name.toLowerCase();
+		throw new QuereusError(`Function ${functionName} is not a scalar function`, StatusCode.ERROR);
+	}
+
+	// Check if function has a custom emitter
+	if (functionSchema.customEmitter) {
+		return functionSchema.customEmitter(plan, ctx, emitScalarFunctionCallDefault);
+	}
+
+	// Use default emission logic
+	return emitScalarFunctionCallDefault(plan, ctx);
+}

package/src/runtime/emit/unary.ts

@@ -12,7 +12,10 @@ export function emitUnaryOp(plan: UnaryOpNode, ctx: EmissionContext): Instructio
 	let run: (ctx: RuntimeContext, operand: SqlValue) => SqlValue;
 	let note: string;
 
-	switch (plan.expression.operator) {
+	// Normalize operator to uppercase for case-insensitive matching
+	const operator = plan.expression.operator.toUpperCase();
+
+	switch (operator) {
 		case 'NOT':
 			run = (ctx: RuntimeContext, operand: SqlValue) => {
 				// SQL NOT: NULL -> NULL, 0 -> 1, anything else -> 0

package/src/schema/column.ts

@@ -1,5 +1,6 @@
 import { SqlDataType } from '../common/types.js';
 import type { Expression } from '../parser/ast.js';
+import type { LogicalType } from '../types/logical-type.js';
 
 /**
  * Represents the schema definition of a single column in a table.
@@ -7,7 +8,9 @@ import type { Expression } from '../parser/ast.js';
 export interface ColumnSchema {
 	/** Column name */
 	name: string;
-	/** Data type affinity (TEXT, INTEGER, REAL, BLOB, NUMERIC) */
+	/** Logical type definition */
+	logicalType: LogicalType;
+	/** Data type affinity (TEXT, INTEGER, REAL, BLOB, NUMERIC) - kept for backward compatibility during transition */
 	affinity: SqlDataType;
 	/** Whether the column has a NOT NULL constraint */
 	notNull: boolean;
@@ -34,8 +37,12 @@ export interface ColumnSchema {
  * @returns A new column schema with default values
  */
 export function createDefaultColumnSchema(name: string, defaultNotNull: boolean = true): ColumnSchema {
+	// Import TEXT_TYPE lazily to avoid circular dependencies
+	const { TEXT_TYPE } = require('../types/builtin-types.js');
+
 	return {
 		name: name,
+		logicalType: TEXT_TYPE,
 		affinity: SqlDataType.TEXT,
 		notNull: defaultNotNull, // Third Manifesto: default to NOT NULL
 		primaryKey: false,

package/src/schema/function.ts

@@ -33,6 +33,17 @@ export type AggregateReducer<T = any> = (accumulator: T, ...args: SqlValue[]) =>
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export type AggregateFinalizer<T = any> = (accumulator: T) => SqlValue;
 
+/**
+ * Custom emitter hook for functions that need special emission logic.
+ * This allows functions to cache compiled state in the EmissionContext,
+ * optimize constant arguments, or perform other emission-time optimizations.
+ */
+export type CustomEmitterHook = (
+	plan: any, // ScalarFunctionCallNode, but we avoid circular dependency
+	ctx: any,  // EmissionContext, but we avoid circular dependency
+	defaultEmit: (plan: any, ctx: any) => any // Instruction
+) => any; // Instruction
+
 /**
  * Base interface for all function schemas with common properties.
  */
@@ -47,6 +58,13 @@ interface BaseFunctionSchema {
 	userData?: unknown;
 	/** Return type information */
 	returnType: BaseType;
+	/**
+	 * Optional custom emitter hook for emission-time optimizations.
+	 * If provided, this function will be called during plan emission instead of
+	 * the default scalar function emitter. The hook receives the plan node,
+	 * emission context, and a reference to the default emitter.
+	 */
+	customEmitter?: CustomEmitterHook;
 }
 
 /**