@quereus/quereus 4.5.0 → 4.6.0

package/dist/src/types/cast-semantics.d.ts

@@ -1,4 +1,5 @@
 import type { SqlValue } from '../common/types.js';
+import type { ScalarType } from '../common/datatype.js';
 import type { LogicalType } from './logical-type.js';
 /**
  * What a CAST produces when the target type's `parse` rejects the operand.
@@ -24,6 +25,29 @@ import type { LogicalType } from './logical-type.js';
  * loosening this to "no validate ⇒ keep".
  */
 export declare function castFallback(value: SqlValue, type: LogicalType): SqlValue;
+/**
+ * What `cast(<value> as type)` produces: the target type's `parse`, falling back to
+ * {@link castFallback} when it rejects the operand. CAST stays lenient and never throws.
+ *
+ * THE one definition of "convert to this type the way CAST does". `emitCast` is the
+ * expression-level caller; `emitIn`'s membership evaluation converts a per-row subquery
+ * value where the plan-time coercion (`insertCrossTypeCoercion`) has no fixed operand to
+ * wrap; `makeComparisonGroup` (`runtime/emit/operand-comparator.ts`) converts a per-row
+ * *copy* of a comparison builtin's argument, where wrapping the operand would corrupt the
+ * value that builtin returns.
+ *
+ * NOTE: a type with no `parse` defines no conversion, so the operand passes through while
+ * the caller still advertises the target type — the very shape castFallback exists to
+ * prevent. Unreachable today: NULL is the only builtin without `parse`, and the parser
+ * rejects it as a CAST target. If a plugin ever registers a parse-less type, validate here.
+ *
+ * NOTE: the fallback path costs one *thrown* exception per call, and every caller runs
+ * per row — so a scan whose operands mostly fail to parse (`json_col in (select
+ * free_text from big_table)`, or `least(free_text, 1)` over a text column of prose) pays
+ * V8 exception construction on every row. Fine at current scale; if it ever shows up in
+ * a profile, give LogicalType an optional non-throwing `tryParse` and prefer it here.
+ */
+export declare function lenientCast(value: SqlValue, type: LogicalType): SqlValue;
 /**
  * Can `cast(<non-null operand> as type)` produce NULL? Answers the static
  * nullability of a converting CAST ({@link import('../planner/nodes/scalar.js').CastNode}).
@@ -40,4 +64,22 @@ export declare function castFallback(value: SqlValue, type: LogicalType): SqlVal
  * declaration, while under-reporting it would let a NULL reach a NOT NULL column.
  */
 export declare function castCanYieldNull(type: LogicalType): boolean;
+/**
+ * The ScalarType a conversion to `target` advertises for an operand of
+ * `operandType` — THE one derivation of "what does the converted value look like
+ * statically". {@link import('../planner/nodes/scalar.js').CastNode} is the
+ * plan-time caller; `makeComparisonGroup` (`runtime/emit/operand-comparator.ts`)
+ * is the emit-time one, so an emit-time comparison key resolves its collation and
+ * comparator routing off exactly the types a plan-time cast would have produced.
+ *
+ * A converting CAST is nullable even from a non-null operand: `cast('' as integer)`
+ * is null because INTEGER's parse maps the empty string to null, and a conversion
+ * that fails outright yields null rather than the unconverted operand. A cast to
+ * the operand's own type converts nothing, and TEXT/BLOB convert every non-null
+ * operand ({@link castCanYieldNull}), so both keep the operand's nullability.
+ *
+ * Collation survives only into a textual target: a number or a JSON document has
+ * no collation to compare under.
+ */
+export declare function castedScalarType(operandType: ScalarType, target: LogicalType): ScalarType;
 //# sourceMappingURL=cast-semantics.d.ts.map

package/dist/src/types/cast-semantics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cast-semantics.d.ts","sourceRoot":"","sources":["../../../src/types/cast-semantics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,GAAG,QAAQ,CAezE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAE3D"}
+{"version":3,"file":"cast-semantics.d.ts","sourceRoot":"","sources":["../../../src/types/cast-semantics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAGrD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,GAAG,QAAQ,CAezE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,GAAG,QAAQ,CAUxE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,WAAW,GAAG,OAAO,CAE3D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,gBAAgB,CAAC,WAAW,EAAE,UAAU,EAAE,MAAM,EAAE,WAAW,GAAG,UAAU,CAUzF"}

package/dist/src/types/cast-semantics.js

@@ -38,6 +38,42 @@ export function castFallback(value, type) {
             return type.validate?.(value) === true ? value : null;
     }
 }
+/**
+ * What `cast(<value> as type)` produces: the target type's `parse`, falling back to
+ * {@link castFallback} when it rejects the operand. CAST stays lenient and never throws.
+ *
+ * THE one definition of "convert to this type the way CAST does". `emitCast` is the
+ * expression-level caller; `emitIn`'s membership evaluation converts a per-row subquery
+ * value where the plan-time coercion (`insertCrossTypeCoercion`) has no fixed operand to
+ * wrap; `makeComparisonGroup` (`runtime/emit/operand-comparator.ts`) converts a per-row
+ * *copy* of a comparison builtin's argument, where wrapping the operand would corrupt the
+ * value that builtin returns.
+ *
+ * NOTE: a type with no `parse` defines no conversion, so the operand passes through while
+ * the caller still advertises the target type — the very shape castFallback exists to
+ * prevent. Unreachable today: NULL is the only builtin without `parse`, and the parser
+ * rejects it as a CAST target. If a plugin ever registers a parse-less type, validate here.
+ *
+ * NOTE: the fallback path costs one *thrown* exception per call, and every caller runs
+ * per row — so a scan whose operands mostly fail to parse (`json_col in (select
+ * free_text from big_table)`, or `least(free_text, 1)` over a text column of prose) pays
+ * V8 exception construction on every row. Fine at current scale; if it ever shows up in
+ * a profile, give LogicalType an optional non-throwing `tryParse` and prefer it here.
+ */
+export function lenientCast(value, type) {
+    if (value === null)
+        return null;
+    if (!type.parse)
+        return value;
+    try {
+        return type.parse(value);
+    }
+    catch {
+        // CAST failures in SQL return 0 for numeric targets, '' for text, etc.
+        // This matches SQLite's lenient CAST behavior.
+        return castFallback(value, type);
+    }
+}
 /**
  * Can `cast(<non-null operand> as type)` produce NULL? Answers the static
  * nullability of a converting CAST ({@link import('../planner/nodes/scalar.js').CastNode}).
@@ -56,4 +92,32 @@ export function castFallback(value, type) {
 export function castCanYieldNull(type) {
     return type !== TEXT_TYPE && type !== BLOB_TYPE;
 }
+/**
+ * The ScalarType a conversion to `target` advertises for an operand of
+ * `operandType` — THE one derivation of "what does the converted value look like
+ * statically". {@link import('../planner/nodes/scalar.js').CastNode} is the
+ * plan-time caller; `makeComparisonGroup` (`runtime/emit/operand-comparator.ts`)
+ * is the emit-time one, so an emit-time comparison key resolves its collation and
+ * comparator routing off exactly the types a plan-time cast would have produced.
+ *
+ * A converting CAST is nullable even from a non-null operand: `cast('' as integer)`
+ * is null because INTEGER's parse maps the empty string to null, and a conversion
+ * that fails outright yields null rather than the unconverted operand. A cast to
+ * the operand's own type converts nothing, and TEXT/BLOB convert every non-null
+ * operand ({@link castCanYieldNull}), so both keep the operand's nullability.
+ *
+ * Collation survives only into a textual target: a number or a JSON document has
+ * no collation to compare under.
+ */
+export function castedScalarType(operandType, target) {
+    return {
+        typeClass: 'scalar',
+        logicalType: target,
+        nullable: operandType.nullable
+            || (target !== operandType.logicalType && castCanYieldNull(target)),
+        isReadOnly: operandType.isReadOnly,
+        collationName: target.isTextual ? operandType.collationName : undefined,
+        collationSource: target.isTextual ? operandType.collationSource : undefined,
+    };
+}
 //# sourceMappingURL=cast-semantics.js.map

package/dist/src/types/cast-semantics.js.map

@@ -1 +1 @@
-{"version":3,"file":"cast-semantics.js","sourceRoot":"","sources":["../../../src/types/cast-semantics.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,YAAY,CAAC,KAAe,EAAE,IAAiB;IAC9D,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QACnB,KAAK,SAAS;YACb,OAAO,CAAC,CAAC;QACV,KAAK,MAAM;YACV,OAAO,GAAG,CAAC;QACZ,KAAK,SAAS;YACb,OAAO,CAAC,CAAC;QACV,KAAK,MAAM;YACV,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;QACtB,KAAK,MAAM;YACV,OAAO,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QAChD;YACC,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;IACxD,CAAC;AACF,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAiB;IACjD,OAAO,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS,CAAC;AACjD,CAAC"}
+{"version":3,"file":"cast-semantics.js","sourceRoot":"","sources":["../../../src/types/cast-semantics.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,UAAU,YAAY,CAAC,KAAe,EAAE,IAAiB;IAC9D,QAAQ,IAAI,CAAC,IAAI,EAAE,CAAC;QACnB,KAAK,SAAS;YACb,OAAO,CAAC,CAAC;QACV,KAAK,MAAM;YACV,OAAO,GAAG,CAAC;QACZ,KAAK,SAAS;YACb,OAAO,CAAC,CAAC;QACV,KAAK,MAAM;YACV,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;QACtB,KAAK,MAAM;YACV,OAAO,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;QAChD;YACC,OAAO,IAAI,CAAC,QAAQ,EAAE,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC;IACxD,CAAC;AACF,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,UAAU,WAAW,CAAC,KAAe,EAAE,IAAiB;IAC7D,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IAChC,IAAI,CAAC,IAAI,CAAC,KAAK;QAAE,OAAO,KAAK,CAAC;IAC9B,IAAI,CAAC;QACJ,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;IAC1B,CAAC;IAAC,MAAM,CAAC;QACR,uEAAuE;QACvE,+CAA+C;QAC/C,OAAO,YAAY,CAAC,KAAK,EAAE,IAAI,CAAC,CAAC;IAClC,CAAC;AACF,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAiB;IACjD,OAAO,IAAI,KAAK,SAAS,IAAI,IAAI,KAAK,SAAS,CAAC;AACjD,CAAC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,UAAU,gBAAgB,CAAC,WAAuB,EAAE,MAAmB;IAC5E,OAAO;QACN,SAAS,EAAE,QAAQ;QACnB,WAAW,EAAE,MAAM;QACnB,QAAQ,EAAE,WAAW,CAAC,QAAQ;eAC1B,CAAC,MAAM,KAAK,WAAW,CAAC,WAAW,IAAI,gBAAgB,CAAC,MAAM,CAAC,CAAC;QACpE,UAAU,EAAE,WAAW,CAAC,UAAU;QAClC,aAAa,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS;QACvE,eAAe,EAAE,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,WAAW,CAAC,eAAe,CAAC,CAAC,CAAC,SAAS;KAC3E,CAAC;AACH,CAAC"}

package/dist/src/types/comparison-coercion.d.ts

@@ -0,0 +1,101 @@
+import type { LogicalType } from './logical-type.js';
+/**
+ * THE type-level decision behind every comparison-site coercion: given the
+ * declared types of the operands, which of them must be converted, and to what.
+ * Purely about `LogicalType` — no plan nodes, no values — so both consumers read
+ * the same rule and cannot drift:
+ *
+ * - **Plan-time** (`planner/building/coercion.ts`) maps the answer onto synthetic
+ *   `CastNode` wrappers, for `=` and friends, BETWEEN, IN value lists and simple
+ *   CASE.
+ * - **Emit-time** (`runtime/emit/operand-comparator.ts` `makeComparisonGroup`)
+ *   maps the same answer onto per-row {@link import('./cast-semantics.js').lenientCast}
+ *   calls, for the comparison builtins that *return* one of their arguments
+ *   (`nullif`, `greatest`, `least`) and therefore cannot have that argument
+ *   replaced by its cast.
+ *
+ * Both paths convert identically: a plan-time `CastNode` runs `lenientCast` per
+ * row too (`runtime/emit/cast.ts`), so "compare the converted copy" and "compare
+ * the cast operand" are the same comparison.
+ */
+/**
+ * The argument positions a function's `comparesArgs` declaration
+ * ({@link import('../schema/function.js').BaseFunctionSchema.comparesArgs}) names,
+ * clamped to the call's actual arity. Index 0 of the result is the group's probe.
+ * Shared by the plan-time rewrite and the emit-time group builder so they cannot
+ * disagree about which positions form the group.
+ */
+export declare function comparisonGroupIndices(comparesArgs: 'all' | readonly number[], argCount: number): readonly number[];
+/** Which side of a pairwise comparison converts, and to what. */
+export interface CrossTypeCoercion {
+    readonly side: 'left' | 'right';
+    readonly target: LogicalType;
+}
+/**
+ * Reconcile two operand types that cannot be compared meaningfully as-is.
+ * Returns `null` when neither side converts.
+ *
+ * Two pairings are handled, in this order:
+ *
+ * 1. **Object-physical vs anything else.** JSON is the engine's only logical type
+ *    whose `physicalType` is `PhysicalType.OBJECT`: its runtime values are native
+ *    JS objects/arrays, which `compareSqlValuesFast` short-circuits against any
+ *    other storage class — so `json_col = '{"a":1}'` was unconditionally false,
+ *    even for byte-identical text. The non-object side converts to the object
+ *    side's type, never the reverse: converting the JSON side to text would make
+ *    equality depend on spelling and put `=` out of step with the index, which
+ *    compares structurally.
+ *
+ *    The gate is deliberately `physicalType === OBJECT`, **not**
+ *    `semanticOrdering`. DATE/TIME/DATETIME/TIMESPAN also carry semantic ordering
+ *    but are physically text, and the runtime's `tryTemporalComparison` already
+ *    reconciles them; routing them through a conversion would change behavior for
+ *    no gain.
+ *
+ *    A conversion to JSON is lenient (see `types/cast-semantics.ts`): text that
+ *    does not parse comes back unchanged, so `json_col = 'not json'` is false
+ *    rather than an error. Note the consequence for JSON *string scalars*, which
+ *    are stored as plain JS strings: a column holding `"hello"` matches BOTH the
+ *    SQL literal `'"hello"'` (parses to the JSON string `hello`) and the bare
+ *    `'hello'` (does not parse, falls back to the raw string `hello`, which
+ *    `JSON_TYPE.compare` then compares as text). Only the first form generalizes —
+ *    `'[1,2]'` matches the JSON array while a bare `[1,2]` is not SQL text at all.
+ *
+ *    A NULL-typed operand is left alone: the comparison is UNKNOWN regardless, so
+ *    the conversion would only add a runtime hop.
+ *
+ * 2. **Numeric vs textual.** The textual operand converts to the numeric side's
+ *    type (e.g. INTEGER or REAL) so the runtime can take the fast path.
+ */
+export declare function crossTypeCoercion(left: LogicalType, right: LogicalType): CrossTypeCoercion | null;
+/**
+ * Per-operand conversion target for a "one probe against many values" comparison
+ * group — an IN value list, a simple CASE, or a comparison builtin's argument
+ * group. Index 0 is the probe, the rest the value list. The result is aligned with
+ * the input array; `null` at a position means "leave that operand alone".
+ *
+ * This is more than a `map` over {@link crossTypeCoercion} because the probe is a
+ * SINGLE operand shared by every value, so it can convert at most once:
+ *
+ * - **A value-side conversion is per value** and never conflicts: an
+ *   object-physical or numeric probe leaves the probe alone and converts each
+ *   value independently, so a mixed list (`case i when '1' when 2 …`) gets a
+ *   per-clause decision for free.
+ * - **A probe-side conversion is hoisted** and therefore has to be unambiguous.
+ *   For the object arm it always is: a conversion to JSON is lenient, so a textual
+ *   value that is not JSON source survives as itself and still compares as text.
+ *   For the numeric arm it is NOT — `cast('abc' as real)` is `0`, so hoisting a
+ *   probe conversion over a MIXED list would make `t in (1, 'abc')` true for the
+ *   stored text `'0'`, which `t = 1 or t = 'abc'` is not. So the numeric probe
+ *   conversion applies only when every non-NULL value is numeric.
+ *
+ * NOTE: the leftover gap is a textual probe against a list mixing numeric and
+ * textual values (`text_col in (1, 'abc')`), which stays unconverted and so still
+ * disagrees with the `=` disjunction on the numeric member. Closing it needs a
+ * per-value probe, which `IN` cannot express — its members live in ONE key space
+ * (a BTree keyed under one collation, `runtime/emit/subquery.ts`). If that shape
+ * ever matters, desugar a mixed `IN` list into an `OR` of `=` comparisons at build
+ * time rather than widening the hoist here.
+ */
+export declare function comparisonGroupCoercions(logicals: readonly LogicalType[]): readonly (LogicalType | null)[];
+//# sourceMappingURL=comparison-coercion.d.ts.map

package/dist/src/types/comparison-coercion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparison-coercion.d.ts","sourceRoot":"","sources":["../../../src/types/comparison-coercion.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD;;;;;;;;;;;;;;;;;;GAkBG;AAEH;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACrC,YAAY,EAAE,KAAK,GAAG,SAAS,MAAM,EAAE,EACvC,QAAQ,EAAE,MAAM,GACd,SAAS,MAAM,EAAE,CAInB;AAED,iEAAiE;AACjE,MAAM,WAAW,iBAAiB;IACjC,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC7B;AAID;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,GAAG,iBAAiB,GAAG,IAAI,CAgBjG;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,wBAAwB,CACvC,QAAQ,EAAE,SAAS,WAAW,EAAE,GAC9B,SAAS,CAAC,WAAW,GAAG,IAAI,CAAC,EAAE,CAqCjC"}

package/dist/src/types/comparison-coercion.js

@@ -0,0 +1,162 @@
+import { PhysicalType } from './logical-type.js';
+import { NULL_TYPE, NUMERIC_TYPE } from './builtin-types.js';
+/**
+ * THE type-level decision behind every comparison-site coercion: given the
+ * declared types of the operands, which of them must be converted, and to what.
+ * Purely about `LogicalType` — no plan nodes, no values — so both consumers read
+ * the same rule and cannot drift:
+ *
+ * - **Plan-time** (`planner/building/coercion.ts`) maps the answer onto synthetic
+ *   `CastNode` wrappers, for `=` and friends, BETWEEN, IN value lists and simple
+ *   CASE.
+ * - **Emit-time** (`runtime/emit/operand-comparator.ts` `makeComparisonGroup`)
+ *   maps the same answer onto per-row {@link import('./cast-semantics.js').lenientCast}
+ *   calls, for the comparison builtins that *return* one of their arguments
+ *   (`nullif`, `greatest`, `least`) and therefore cannot have that argument
+ *   replaced by its cast.
+ *
+ * Both paths convert identically: a plan-time `CastNode` runs `lenientCast` per
+ * row too (`runtime/emit/cast.ts`), so "compare the converted copy" and "compare
+ * the cast operand" are the same comparison.
+ */
+/**
+ * The argument positions a function's `comparesArgs` declaration
+ * ({@link import('../schema/function.js').BaseFunctionSchema.comparesArgs}) names,
+ * clamped to the call's actual arity. Index 0 of the result is the group's probe.
+ * Shared by the plan-time rewrite and the emit-time group builder so they cannot
+ * disagree about which positions form the group.
+ */
+export function comparisonGroupIndices(comparesArgs, argCount) {
+    return comparesArgs === 'all'
+        ? Array.from({ length: argCount }, (_, i) => i)
+        : comparesArgs.filter(i => i >= 0 && i < argCount);
+}
+const isObject = (type) => type.physicalType === PhysicalType.OBJECT;
+/**
+ * Reconcile two operand types that cannot be compared meaningfully as-is.
+ * Returns `null` when neither side converts.
+ *
+ * Two pairings are handled, in this order:
+ *
+ * 1. **Object-physical vs anything else.** JSON is the engine's only logical type
+ *    whose `physicalType` is `PhysicalType.OBJECT`: its runtime values are native
+ *    JS objects/arrays, which `compareSqlValuesFast` short-circuits against any
+ *    other storage class — so `json_col = '{"a":1}'` was unconditionally false,
+ *    even for byte-identical text. The non-object side converts to the object
+ *    side's type, never the reverse: converting the JSON side to text would make
+ *    equality depend on spelling and put `=` out of step with the index, which
+ *    compares structurally.
+ *
+ *    The gate is deliberately `physicalType === OBJECT`, **not**
+ *    `semanticOrdering`. DATE/TIME/DATETIME/TIMESPAN also carry semantic ordering
+ *    but are physically text, and the runtime's `tryTemporalComparison` already
+ *    reconciles them; routing them through a conversion would change behavior for
+ *    no gain.
+ *
+ *    A conversion to JSON is lenient (see `types/cast-semantics.ts`): text that
+ *    does not parse comes back unchanged, so `json_col = 'not json'` is false
+ *    rather than an error. Note the consequence for JSON *string scalars*, which
+ *    are stored as plain JS strings: a column holding `"hello"` matches BOTH the
+ *    SQL literal `'"hello"'` (parses to the JSON string `hello`) and the bare
+ *    `'hello'` (does not parse, falls back to the raw string `hello`, which
+ *    `JSON_TYPE.compare` then compares as text). Only the first form generalizes —
+ *    `'[1,2]'` matches the JSON array while a bare `[1,2]` is not SQL text at all.
+ *
+ *    A NULL-typed operand is left alone: the comparison is UNKNOWN regardless, so
+ *    the conversion would only add a runtime hop.
+ *
+ * 2. **Numeric vs textual.** The textual operand converts to the numeric side's
+ *    type (e.g. INTEGER or REAL) so the runtime can take the fast path.
+ */
+export function crossTypeCoercion(left, right) {
+    const leftObject = isObject(left);
+    const rightObject = isObject(right);
+    // NOTE: two object-physical operands of DIFFERENT logical types fall through both
+    // arms onto the generic runtime path. Unreachable while JSON is the only
+    // PhysicalType.OBJECT type; adding a second one means deciding which side converts.
+    if (leftObject !== rightObject) {
+        if (leftObject && right !== NULL_TYPE)
+            return { side: 'right', target: left };
+        if (rightObject && left !== NULL_TYPE)
+            return { side: 'left', target: right };
+        return null;
+    }
+    if (left.isNumeric && right.isTextual)
+        return { side: 'right', target: left };
+    if (right.isNumeric && left.isTextual)
+        return { side: 'left', target: right };
+    return null;
+}
+/**
+ * Per-operand conversion target for a "one probe against many values" comparison
+ * group — an IN value list, a simple CASE, or a comparison builtin's argument
+ * group. Index 0 is the probe, the rest the value list. The result is aligned with
+ * the input array; `null` at a position means "leave that operand alone".
+ *
+ * This is more than a `map` over {@link crossTypeCoercion} because the probe is a
+ * SINGLE operand shared by every value, so it can convert at most once:
+ *
+ * - **A value-side conversion is per value** and never conflicts: an
+ *   object-physical or numeric probe leaves the probe alone and converts each
+ *   value independently, so a mixed list (`case i when '1' when 2 …`) gets a
+ *   per-clause decision for free.
+ * - **A probe-side conversion is hoisted** and therefore has to be unambiguous.
+ *   For the object arm it always is: a conversion to JSON is lenient, so a textual
+ *   value that is not JSON source survives as itself and still compares as text.
+ *   For the numeric arm it is NOT — `cast('abc' as real)` is `0`, so hoisting a
+ *   probe conversion over a MIXED list would make `t in (1, 'abc')` true for the
+ *   stored text `'0'`, which `t = 1 or t = 'abc'` is not. So the numeric probe
+ *   conversion applies only when every non-NULL value is numeric.
+ *
+ * NOTE: the leftover gap is a textual probe against a list mixing numeric and
+ * textual values (`text_col in (1, 'abc')`), which stays unconverted and so still
+ * disagrees with the `=` disjunction on the numeric member. Closing it needs a
+ * per-value probe, which `IN` cannot express — its members live in ONE key space
+ * (a BTree keyed under one collation, `runtime/emit/subquery.ts`). If that shape
+ * ever matters, desugar a mixed `IN` list into an `OR` of `=` comparisons at build
+ * time rather than widening the hoist here.
+ */
+export function comparisonGroupCoercions(logicals) {
+    const none = logicals.map(() => null);
+    if (logicals.length < 2)
+        return none;
+    const probe = logicals[0];
+    const values = logicals.slice(1);
+    /** The value-side half of a pairwise decision against an already-settled probe type. */
+    const valueTarget = (probeType, value) => {
+        const coercion = crossTypeCoercion(probeType, value);
+        return coercion?.side === 'right' ? coercion.target : null;
+    };
+    // Object arm: the non-object side converts, exactly as the pairwise function decides.
+    const objectValue = values.find(isObject);
+    if (isObject(probe) || objectValue) {
+        const effectiveProbe = isObject(probe) ? probe : objectValue;
+        return [
+            isObject(probe) ? null : effectiveProbe,
+            ...values.map(value => valueTarget(effectiveProbe, value)),
+        ];
+    }
+    // Numeric probe: every textual value converts to the probe's numeric type, independently.
+    if (probe.isNumeric) {
+        return [null, ...values.map(value => valueTarget(probe, value))];
+    }
+    // Textual probe: one hoisted conversion, but only over an all-numeric value list.
+    if (probe.isTextual) {
+        const nonNull = values.filter(type => type !== NULL_TYPE);
+        if (nonNull.length > 0 && nonNull.every(type => type.isNumeric)) {
+            return [commonNumericType(nonNull), ...values.map(() => null)];
+        }
+    }
+    return none;
+}
+/**
+ * The conversion target for a hoisted probe over an all-numeric value list. One
+ * shared type means one key space; NUMERIC is the fallback because its value
+ * space (`number | bigint`) covers INTEGER and REAL together, so a list mixing a
+ * bigint literal with a real one does not have to pick a lossy winner.
+ */
+function commonNumericType(valueTypes) {
+    const first = valueTypes[0];
+    return valueTypes.every(type => type === first) ? first : NUMERIC_TYPE;
+}
+//# sourceMappingURL=comparison-coercion.js.map

package/dist/src/types/comparison-coercion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparison-coercion.js","sourceRoot":"","sources":["../../../src/types/comparison-coercion.ts"],"names":[],"mappings":"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"}

package/dist/src/types/index.d.ts

@@ -1,7 +1,7 @@
 export { PhysicalType, type LogicalType, getPhysicalType, physicalTypeName, compareNulls } from './logical-type.js';
-export { NULL_TYPE, INTEGER_TYPE, REAL_TYPE, TEXT_TYPE, BLOB_TYPE, BOOLEAN_TYPE, NUMERIC_TYPE, ANY_TYPE } from './builtin-types.js';
+export { NULL_TYPE, INTEGER_TYPE, REAL_TYPE, TEXT_TYPE, BLOB_TYPE, BOOLEAN_TYPE, NUMERIC_TYPE, ANY_TYPE, isNumericOrUnknownType } from './builtin-types.js';
 export { DATE_TYPE, TIME_TYPE, DATETIME_TYPE, TIMESPAN_TYPE } from './temporal-types.js';
 export { JSON_TYPE } from './json-type.js';
 export { typeRegistry, registerType, getType, getTypeOrDefault, inferType } from './registry.js';
-export { validateValue, parseValue, validateAndParse, coerceRowToSchema, isValidForType, tryParse } from './validation.js';
+export { validateValue, parseValue, validateAndParse, coerceRowToSchema, foldDefaultToType, isValidForType, tryParse } from './validation.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/src/types/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,eAAe,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGpH,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAGpI,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzF,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAGjG,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,KAAK,WAAW,EAAE,eAAe,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAGpH,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAG5J,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAGzF,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAG3C,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAGjG,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/src/types/index.js

@@ -1,7 +1,7 @@
 // Core type system exports
 export { PhysicalType, getPhysicalType, physicalTypeName, compareNulls } 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';
+export { NULL_TYPE, INTEGER_TYPE, REAL_TYPE, TEXT_TYPE, BLOB_TYPE, BOOLEAN_TYPE, NUMERIC_TYPE, ANY_TYPE, isNumericOrUnknownType } from './builtin-types.js';
 // Temporal types
 export { DATE_TYPE, TIME_TYPE, DATETIME_TYPE, TIMESPAN_TYPE } from './temporal-types.js';
 // JSON type
@@ -9,5 +9,5 @@ export { JSON_TYPE } from './json-type.js';
 // Type registry
 export { typeRegistry, registerType, getType, getTypeOrDefault, inferType } from './registry.js';
 // Validation utilities
-export { validateValue, parseValue, validateAndParse, coerceRowToSchema, isValidForType, tryParse } from './validation.js';
+export { validateValue, parseValue, validateAndParse, coerceRowToSchema, foldDefaultToType, isValidForType, tryParse } from './validation.js';
 //# sourceMappingURL=index.js.map

package/dist/src/types/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AAAA,2BAA2B;AAC3B,OAAO,EAAE,YAAY,EAAoB,eAAe,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEpH,iBAAiB;AACjB,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEpI,iBAAiB;AACjB,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzF,YAAY;AACZ,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,gBAAgB;AAChB,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAEjG,uBAAuB;AACvB,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/types/index.ts"],"names":[],"mappings":"AAAA,2BAA2B;AAC3B,OAAO,EAAE,YAAY,EAAoB,eAAe,EAAE,gBAAgB,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEpH,iBAAiB;AACjB,OAAO,EAAE,SAAS,EAAE,YAAY,EAAE,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,sBAAsB,EAAE,MAAM,oBAAoB,CAAC;AAE5J,iBAAiB;AACjB,OAAO,EAAE,SAAS,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEzF,YAAY;AACZ,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAE3C,gBAAgB;AAChB,OAAO,EAAE,YAAY,EAAE,YAAY,EAAE,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,eAAe,CAAC;AAEjG,uBAAuB;AACvB,OAAO,EAAE,aAAa,EAAE,UAAU,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,iBAAiB,EAAE,cAAc,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/src/types/logical-type.d.ts

@@ -58,6 +58,13 @@ export interface LogicalType {
     parse?(value: SqlValue): SqlValue;
     /** Type-specific comparison function */
     compare?(a: SqlValue, b: SqlValue, collation?: CollationFunction): number;
+    /**
+     * True when {@link compare} actually applies the collation function it is handed
+     * (TEXT, ANY). When unset, the type's compare is collation-blind, so a key
+     * structure over such a column must be keyed under BINARY regardless of the
+     * column's declared COLLATE — see `pkKeyCollationName`.
+     */
+    collationAware?: boolean;
     /**
      * True when {@link compare} defines an order that OBSERVABLY differs from
      * storage-class + collation ordering of the stored representation (e.g. TIMESPAN

package/dist/src/types/logical-type.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"logical-type.d.ts","sourceRoot":"","sources":["../../../src/types/logical-type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;AAEjE;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,aAAa,EAAE,MAAM,KAAK,iBAAiB,CAAC;AAE7E;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,KAAK,aAAa,CAAC;AAEzF;;;GAGG;AACH,oBAAY,YAAY;IACvB,IAAI,IAAI;IACR,OAAO,IAAI,CAAK,kBAAkB;IAClC,IAAI,IAAI,CAAQ,0BAA0B;IAC1C,IAAI,IAAI,CAAQ,SAAS;IACzB,IAAI,IAAI,CAAQ,aAAa;IAC7B,OAAO,IAAI,CAAK,UAAU;IAC1B,MAAM,IAAI;CACV;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAE3B,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,sCAAsC;IACtC,YAAY,EAAE,YAAY,CAAC;IAG3B,4CAA4C;IAC5C,QAAQ,CAAC,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC;IACpC,gDAAgD;IAChD,KAAK,CAAC,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAGlC,wCAAwC;IACxC,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,iBAAiB,GAAG,MAAM,CAAC;IAC1E;;;;;;;;;;OAUG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;;OAQG;IACH,QAAQ,CAAC,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACrC,0CAA0C;IAC1C,mBAAmB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAGxC,iCAAiC;IACjC,SAAS,CAAC,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACtC,2BAA2B;IAC3B,WAAW,CAAC,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAGxC,8BAA8B;IAC9B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,8BAA8B;IAC9B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,+BAA+B;IAC/B,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;;;;OAMG;IACH,YAAY,CAAC,CACZ,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,QAAQ,GACb;QAAE,cAAc,EAAE,QAAQ,CAAC;QAAC,cAAc,EAAE,QAAQ,CAAA;KAAE,GAAG,SAAS,CAAC;CACtE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,GAAG,YAAY,CAW7D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAIzE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,CAWnE"}
+{"version":3,"file":"logical-type.d.ts","sourceRoot":"","sources":["../../../src/types/logical-type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAEnD;;;GAGG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;AAEjE;;;;;;;GAOG;AACH,MAAM,MAAM,iBAAiB,GAAG,CAAC,aAAa,EAAE,MAAM,KAAK,iBAAiB,CAAC;AAE7E;;;;;;GAMG;AACH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,MAAM,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,MAAM,qBAAqB,GAAG,CAAC,aAAa,EAAE,MAAM,GAAG,SAAS,KAAK,aAAa,CAAC;AAEzF;;;GAGG;AACH,oBAAY,YAAY;IACvB,IAAI,IAAI;IACR,OAAO,IAAI,CAAK,kBAAkB;IAClC,IAAI,IAAI,CAAQ,0BAA0B;IAC1C,IAAI,IAAI,CAAQ,SAAS;IACzB,IAAI,IAAI,CAAQ,aAAa;IAC7B,OAAO,IAAI,CAAK,UAAU;IAC1B,MAAM,IAAI;CACV;AAED;;;GAGG;AACH,MAAM,WAAW,WAAW;IAE3B,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,sCAAsC;IACtC,YAAY,EAAE,YAAY,CAAC;IAG3B,4CAA4C;IAC5C,QAAQ,CAAC,CAAC,KAAK,EAAE,QAAQ,GAAG,OAAO,CAAC;IACpC,gDAAgD;IAChD,KAAK,CAAC,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAGlC,wCAAwC;IACxC,OAAO,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,EAAE,SAAS,CAAC,EAAE,iBAAiB,GAAG,MAAM,CAAC;IAC1E;;;;;OAKG;IACH,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;;;;OAUG;IACH,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B;;;;;;;;OAQG;IACH,QAAQ,CAAC,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACrC,0CAA0C;IAC1C,mBAAmB,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAGxC,iCAAiC;IACjC,SAAS,CAAC,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAAC;IACtC,2BAA2B;IAC3B,WAAW,CAAC,CAAC,KAAK,EAAE,QAAQ,GAAG,QAAQ,CAAC;IAGxC,8BAA8B;IAC9B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,8BAA8B;IAC9B,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,+BAA+B;IAC/B,UAAU,CAAC,EAAE,OAAO,CAAC;IAErB;;;;;;OAMG;IACH,YAAY,CAAC,CACZ,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,QAAQ,GACb;QAAE,cAAc,EAAE,QAAQ,CAAC;QAAC,cAAc,EAAE,QAAQ,CAAA;KAAE,GAAG,SAAS,CAAC;CACtE;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,GAAG,YAAY,CAW7D;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,EAAE,QAAQ,GAAG,MAAM,GAAG,SAAS,CAIzE;AAED;;;GAGG;AACH,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,YAAY,GAAG,MAAM,CAWnE"}

package/dist/src/types/logical-type.js.map

@@ -1 +1 @@
-{"version":3,"file":"logical-type.js","sourceRoot":"","sources":["../../../src/types/logical-type.ts"],"names":[],"mappings":"AAqCA;;;GAGG;AACH,MAAM,CAAN,IAAY,YAQX;AARD,WAAY,YAAY;IACvB,+CAAQ,CAAA;IACR,qDAAW,CAAA;IACX,+CAAQ,CAAA;IACR,+CAAQ,CAAA;IACR,+CAAQ,CAAA;IACR,qDAAW,CAAA;IACX,mDAAU,CAAA;AACX,CAAC,EARW,YAAY,KAAZ,YAAY,QAQvB;AA0ED;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,KAAe;IAC9C,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,YAAY,CAAC,IAAI,CAAC;IAC7C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC/B,OAAO,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC;IAC3E,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,YAAY,CAAC,OAAO,CAAC;IAC3D,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,YAAY,CAAC,IAAI,CAAC;IACxD,IAAI,OAAO,KAAK,KAAK,SAAS;QAAE,OAAO,YAAY,CAAC,OAAO,CAAC;IAC5D,IAAI,KAAK,YAAY,UAAU;QAAE,OAAO,YAAY,CAAC,IAAI,CAAC;IAC1D,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,YAAY,CAAC,MAAM,CAAC;IAC5E,OAAO,YAAY,CAAC,IAAI,CAAC;AAC1B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,CAAW,EAAE,CAAW;IACpD,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3C,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,CAAC,CAAC;IACzB,OAAO,SAAS,CAAC;AAClB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,YAA0B;IAC1D,QAAQ,YAAY,EAAE,CAAC;QACtB,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC,OAAO,MAAM,CAAC;QACtC,KAAK,YAAY,CAAC,OAAO,CAAC,CAAC,OAAO,SAAS,CAAC;QAC5C,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC,OAAO,MAAM,CAAC;QACtC,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC,OAAO,MAAM,CAAC;QACtC,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC,OAAO,MAAM,CAAC;QACtC,KAAK,YAAY,CAAC,OAAO,CAAC,CAAC,OAAO,SAAS,CAAC;QAC5C,KAAK,YAAY,CAAC,MAAM,CAAC,CAAC,OAAO,QAAQ,CAAC;QAC1C,OAAO,CAAC,CAAC,OAAO,SAAS,CAAC;IAC3B,CAAC;AACF,CAAC"}
+{"version":3,"file":"logical-type.js","sourceRoot":"","sources":["../../../src/types/logical-type.ts"],"names":[],"mappings":"AAqCA;;;GAGG;AACH,MAAM,CAAN,IAAY,YAQX;AARD,WAAY,YAAY;IACvB,+CAAQ,CAAA;IACR,qDAAW,CAAA;IACX,+CAAQ,CAAA;IACR,+CAAQ,CAAA;IACR,+CAAQ,CAAA;IACR,qDAAW,CAAA;IACX,mDAAU,CAAA;AACX,CAAC,EARW,YAAY,KAAZ,YAAY,QAQvB;AAiFD;;;GAGG;AACH,MAAM,UAAU,eAAe,CAAC,KAAe;IAC9C,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,YAAY,CAAC,IAAI,CAAC;IAC7C,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC/B,OAAO,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,IAAI,CAAC;IAC3E,CAAC;IACD,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,YAAY,CAAC,OAAO,CAAC;IAC3D,IAAI,OAAO,KAAK,KAAK,QAAQ;QAAE,OAAO,YAAY,CAAC,IAAI,CAAC;IACxD,IAAI,OAAO,KAAK,KAAK,SAAS;QAAE,OAAO,YAAY,CAAC,OAAO,CAAC;IAC5D,IAAI,KAAK,YAAY,UAAU;QAAE,OAAO,YAAY,CAAC,IAAI,CAAC;IAC1D,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,KAAK,KAAK,IAAI;QAAE,OAAO,YAAY,CAAC,MAAM,CAAC;IAC5E,OAAO,YAAY,CAAC,IAAI,CAAC;AAC1B,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,CAAW,EAAE,CAAW;IACpD,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,CAAC,KAAK,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAC3C,IAAI,CAAC,KAAK,IAAI;QAAE,OAAO,CAAC,CAAC;IACzB,OAAO,SAAS,CAAC;AAClB,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,gBAAgB,CAAC,YAA0B;IAC1D,QAAQ,YAAY,EAAE,CAAC;QACtB,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC,OAAO,MAAM,CAAC;QACtC,KAAK,YAAY,CAAC,OAAO,CAAC,CAAC,OAAO,SAAS,CAAC;QAC5C,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC,OAAO,MAAM,CAAC;QACtC,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC,OAAO,MAAM,CAAC;QACtC,KAAK,YAAY,CAAC,IAAI,CAAC,CAAC,OAAO,MAAM,CAAC;QACtC,KAAK,YAAY,CAAC,OAAO,CAAC,CAAC,OAAO,SAAS,CAAC;QAC5C,KAAK,YAAY,CAAC,MAAM,CAAC,CAAC,OAAO,QAAQ,CAAC;QAC1C,OAAO,CAAC,CAAC,OAAO,SAAS,CAAC;IAC3B,CAAC;AACF,CAAC"}

package/dist/src/types/validation.d.ts

@@ -1,6 +1,7 @@
 import type { Row, SqlValue } from '../common/types.js';
 import type { LogicalType } from './logical-type.js';
 import type { ColumnSchema } from '../schema/column.js';
+import type { Expression } from '../parser/ast.js';
 /**
  * Validate a value against a logical type.
  * Throws an error if the value is invalid.
@@ -71,6 +72,61 @@ export declare function coerceRowToSchema(row: Row, columns: readonly ColumnSche
  * guard, mirroring {@link coerceRowToSchema}'s map-over-present-cells behavior.
  */
 export declare function buildRowCoercion(sourceTypes: ReadonlyArray<LogicalType | undefined>, columns: readonly ColumnSchema[]): ((row: Row) => Row) | undefined;
+/**
+ * Fold a DEFAULT expression to a literal AND convert it to the column's declared
+ * logical type — the value a fresh INSERT under the same DEFAULT would store. Every
+ * ALTER backfill site (ADD COLUMN literal default, SET NOT NULL backfill, and their
+ * event-image remaps, across the memory module, the store module and the isolation
+ * overlay) goes through here, so a backfilled cell is indistinguishable from an
+ * inserted one and the sites cannot drift apart.
+ *
+ * Returns `undefined` when the expression does not fold to a literal (the caller's
+ * per-row evaluator path owns that case) and `null` when it folds to NULL. An AST
+ * literal is always raw source form (a TEXT literal `'"abc"'`, never an already-parsed
+ * JSON value), so unlike {@link buildRowCoercion} this needs no identity guard — the
+ * conversion is always the first one applied to the value.
+ *
+ * NOTE: that "raw source form" invariant holds because every DEFAULT expression here comes
+ * from the parser (schema round-trips re-stringify and re-parse it). If a path ever
+ * synthesizes a DEFAULT AST node from an already-stored value, this becomes a second
+ * conversion and needs the same identity guard `buildRowCoercion` carries.
+ *
+ * @throws QuereusError (MISMATCH) when the literal cannot be converted, carrying the
+ *   same message text the INSERT path produces.
+ */
+export declare function foldDefaultToType(expr: Expression | null | undefined, logicalType: LogicalType, columnName: string): SqlValue | undefined;
+/** What {@link planRetypeConversion} decided for one `alter column … set data type`. */
+export interface RetypeConversion {
+    /** The target's logical type, resolved via {@link inferType}. */
+    readonly newLogicalType: LogicalType;
+    /**
+     * `null` for a metadata-only (alias) retype — nothing to rewrite. Otherwise converts one
+     * non-NULL value; callers route NULLs around it themselves (`set data type` leaves them
+     * untouched, a NOT NULL backfill maps them to DEFAULT before this ever sees them).
+     */
+    readonly convert: ((value: SqlValue) => SqlValue) | null;
+}
+/**
+ * Decide whether `alter column … set data type` rewrites stored values, and if so, build the
+ * per-value converter. Shared by every backend that implements SET DATA TYPE (the memory
+ * module, the KV store module, and the isolation overlay's staged-row migration) so the
+ * "does this retype touch anything" gate and the conversion failure's message/status code
+ * cannot drift between them — the isolation layer keys its own error routing off that status
+ * code, deciding whether another connection's staged rows are marked unusable rather than
+ * aborting the ALTER outright.
+ *
+ * Gated on logical-type IDENTITY, not physical storage class: {@link inferType} flattens
+ * aliases to the shared type object (`varchar(50)` IS `TEXT_TYPE`), so an alias retype
+ * returns a `null` converter. Any other retype — including a same-storage-class move like
+ * text → date — returns one that validates AND normalizes to the new type's canonical
+ * spelling, rethrowing a parse/validate failure as `QuereusError(MISMATCH)`.
+ *
+ * @param dataType The target type name as written in the ALTER statement (echoed into the
+ *   failure message verbatim)
+ * @param oldLogicalType The column's CURRENT logical type
+ * @param columnName The column name (echoed into the failure message)
+ */
+export declare function planRetypeConversion(dataType: string, oldLogicalType: LogicalType, columnName: string): RetypeConversion;
 /**
  * Check if a value is compatible with a logical type without throwing.
  *

package/dist/src/types/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/types/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAGxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC5B,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,WAAW,EACjB,UAAU,CAAC,EAAE,MAAM,GACjB,QAAQ,CAcV;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACzB,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,WAAW,EACjB,UAAU,CAAC,EAAE,MAAM,GACjB,QAAQ,CAmBV;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC/B,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,WAAW,EACjB,UAAU,CAAC,EAAE,MAAM,GACjB,QAAQ,CAMV;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,SAAS,YAAY,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,CAQhG;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,CAC/B,WAAW,EAAE,aAAa,CAAC,WAAW,GAAG,SAAS,CAAC,EACnD,OAAO,EAAE,SAAS,YAAY,EAAE,GAC9B,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,CAAC,GAAG,SAAS,CAgBjC;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAI1E;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,GAAG,QAAQ,GAAG,IAAI,CAM5E"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../../src/types/validation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,GAAG,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAGxD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAInD;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAC5B,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,WAAW,EACjB,UAAU,CAAC,EAAE,MAAM,GACjB,QAAQ,CAcV;AAED;;;;;;;;;GASG;AACH,wBAAgB,UAAU,CACzB,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,WAAW,EACjB,UAAU,CAAC,EAAE,MAAM,GACjB,QAAQ,CAmBV;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC/B,KAAK,EAAE,QAAQ,EACf,IAAI,EAAE,WAAW,EACjB,UAAU,CAAC,EAAE,MAAM,GACjB,QAAQ,CAMV;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,SAAS,YAAY,EAAE,EAAE,KAAK,EAAE,MAAM,GAAG,GAAG,CAQhG;AAED;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,wBAAgB,gBAAgB,CAC/B,WAAW,EAAE,aAAa,CAAC,WAAW,GAAG,SAAS,CAAC,EACnD,OAAO,EAAE,SAAS,YAAY,EAAE,GAC9B,CAAC,CAAC,GAAG,EAAE,GAAG,KAAK,GAAG,CAAC,GAAG,SAAS,CAgBjC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,iBAAiB,CAChC,IAAI,EAAE,UAAU,GAAG,IAAI,GAAG,SAAS,EACnC,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE,MAAM,GAChB,QAAQ,GAAG,SAAS,CAKtB;AAED,wFAAwF;AACxF,MAAM,WAAW,gBAAgB;IAChC,iEAAiE;IACjE,QAAQ,CAAC,cAAc,EAAE,WAAW,CAAC;IACrC;;;;OAIG;IACH,QAAQ,CAAC,OAAO,EAAE,CAAC,CAAC,KAAK,EAAE,QAAQ,KAAK,QAAQ,CAAC,GAAG,IAAI,CAAC;CACzD;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CACnC,QAAQ,EAAE,MAAM,EAChB,cAAc,EAAE,WAAW,EAC3B,UAAU,EAAE,MAAM,GAChB,gBAAgB,CAgBlB;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,GAAG,OAAO,CAI1E;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,WAAW,GAAG,QAAQ,GAAG,IAAI,CAM5E"}