@quereus/quereus 3.3.0 → 4.1.0

package/dist/src/planner/analysis/comparison-collation.js

@@ -0,0 +1,341 @@
+/**
+ * THE shared resolution of a comparison's *effective collation*. Both the
+ * plan-time mirrors (access-path collation-cover analysis, FD/EC gates in
+ * `fd-utils.ts`, the predicate normalizer's eq↔IN gate, the constraint
+ * extractor's collation gates) and the runtime emitters (`emitComparisonOp`,
+ * `emitIn`, `emitBetween`, the USING-join comparator) call through this module,
+ * so plan-time facts and runtime behavior cannot drift.
+ *
+ * ## The resolution lattice
+ *
+ * Each operand contributes at most one `(collation, rank)`, derived from the
+ * provenance of its `ScalarType.collationName` ({@link CollationSource}):
+ *
+ * | rank | source                                            | BINARY contributes? |
+ * |------|---------------------------------------------------|---------------------|
+ * | 3    | `explicit` — a COLLATE expression                 | yes (`collate binary` is a real demand) |
+ * | 2    | `declared` — column with an explicit COLLATE      | yes (`c text collate binary` is a real preference) |
+ * | 1    | `default` — defaulted column collation            | **no** — a defaulted BINARY is the engine floor |
+ * | —    | no `collationName` (literals, most expressions)   | n/a |
+ *
+ * Resolution of `left <op> right` is **symmetric** (`a = b` ≡ `b = a`):
+ * 1. The highest rank present among the two contributions wins.
+ * 2. If both operands contribute at that rank with *different* normalized
+ *    names: rank 3 or 2 → plan-time error ({@link collationConflictError});
+ *    rank 1 → BINARY, silently (defaults are preferences, not declarations).
+ * 3. Otherwise the winning (single, or name-identical) contribution's name;
+ *    no contributions at all → BINARY.
+ *
+ * This deliberately diverges from SQLite's left-operand precedence: the engine
+ * follows explicit-over-implicit semantics and keeps comparisons commutative.
+ * See `docs/types.md` § Comparison collation resolution.
+ */
+import { normalizeCollationName } from '../../util/comparison.js';
+import { PhysicalType } from '../../types/logical-type.js';
+import { collectCollateNames, collectColumnNames, columnIndexFromExpr } from './predicate-shape.js';
+import { QuereusError } from '../../common/errors.js';
+import { StatusCode } from '../../common/types.js';
+const RANK_BY_SOURCE = { explicit: 3, declared: 2, default: 1 };
+const SOURCE_BY_RANK = { 3: 'explicit', 2: 'declared', 1: 'default' };
+/**
+ * The contribution one operand's type makes to a comparison, or `undefined`
+ * when it makes none (no `collationName`, or a defaulted BINARY — the engine
+ * floor is not a preference). An absent `collationSource` with a present
+ * `collationName` is treated as `'default'` (the safe floor for any
+ * construction site the provenance sweep missed).
+ */
+export function collationContribution(t) {
+    if (t.collationName === undefined)
+        return undefined;
+    const rank = RANK_BY_SOURCE[t.collationSource ?? 'default'];
+    const name = normalizeCollationName(t.collationName);
+    if (rank === 1 && name === 'BINARY')
+        return undefined;
+    return { name, rank };
+}
+const RESOLVED_BINARY = { kind: 'resolved', name: 'BINARY' };
+function resolveContributions(l, r) {
+    if (!l && !r)
+        return RESOLVED_BINARY;
+    if (!l)
+        return { kind: 'resolved', name: r.name };
+    if (!r)
+        return { kind: 'resolved', name: l.name };
+    if (l.rank !== r.rank)
+        return { kind: 'resolved', name: (l.rank > r.rank ? l : r).name };
+    if (l.name === r.name)
+        return { kind: 'resolved', name: l.name };
+    // Same-rank, different names. Defaults resolve to the floor silently;
+    // explicit/declared conflicts are user errors.
+    if (l.rank === 1)
+        return RESOLVED_BINARY;
+    return { kind: 'conflict', level: l.rank === 3 ? 'explicit' : 'declared', left: l.name, right: r.name };
+}
+/**
+ * Effective collation of a binary comparison `left <op> right` under the
+ * lattice. Pure — never throws; conflicts are returned for the caller to
+ * surface (plan-time validation) or gate on (the predicate normalizer).
+ */
+export function resolveComparisonCollation(left, right) {
+    return resolveContributions(collationContribution(left), collationContribution(right));
+}
+/** Build the plan-time error for a same-rank explicit/declared conflict. */
+export function collationConflictError(conflict, expr) {
+    const message = conflict.level === 'explicit'
+        ? `conflicting COLLATE clauses in comparison: ${conflict.left} vs ${conflict.right}`
+        : `ambiguous collation for comparison: column collations ${conflict.left} vs ${conflict.right} differ; apply an explicit COLLATE`;
+    return new QuereusError(message, StatusCode.ERROR, undefined, expr?.loc?.start.line, expr?.loc?.start.column);
+}
+function resolvedOrThrow(res, expr) {
+    if (res.kind === 'conflict')
+        throw collationConflictError(res, expr);
+    return res.name;
+}
+/**
+ * Throwing form of {@link resolveComparisonCollation} over bare types, for
+ * sites that hold types rather than plan nodes (the USING-join emitter). The
+ * throw is a backstop — plan-time validation rejects user-written conflicts.
+ */
+export function effectiveCollationOfTypes(left, right, expr) {
+    return resolvedOrThrow(resolveComparisonCollation(left, right), expr);
+}
+/**
+ * Effective collation of a binary comparison `left <op> right`. Symmetric —
+ * operand order never changes the result. Throws `QuereusError` on a
+ * same-rank explicit/declared conflict (normally unreachable past plan-time
+ * validation in `BinaryOpNode.generateType`).
+ */
+export function effectiveComparisonCollation(left, right) {
+    return effectiveCollationOfTypes(left.getType(), right.getType());
+}
+/**
+ * Effective collation of one BETWEEN bound comparison. BETWEEN desugars to
+ * `expr >= lower AND expr <= upper`; each bound resolves independently through
+ * the same lattice (two independent comparisons — differing bound collations
+ * are NOT a conflict with each other, only with the tested expression).
+ */
+export function effectiveBetweenBoundCollation(expr, bound) {
+    return effectiveCollationOfTypes(expr.getType(), bound.getType());
+}
+function mergeContributions(contribs) {
+    let best;
+    let conflictingName;
+    for (const c of contribs) {
+        if (!c)
+            continue;
+        if (!best || c.rank > best.rank) {
+            best = c;
+            conflictingName = undefined;
+            continue;
+        }
+        if (c.rank === best.rank && c.name !== best.name && conflictingName === undefined) {
+            conflictingName = c.name;
+        }
+    }
+    if (best && conflictingName !== undefined) {
+        if (best.rank === 1)
+            return { kind: 'contribution', contribution: undefined };
+        return { kind: 'conflict', level: best.rank === 3 ? 'explicit' : 'declared', left: best.name, right: conflictingName };
+    }
+    return { kind: 'contribution', contribution: best };
+}
+/**
+ * Pure IN resolution: merge the right-hand-side contributions first (list
+ * elements under the lattice — a rank-3/2 name conflict among elements is the
+ * same plan-time error; rank-1 conflicts merge to no-contribution; a subquery
+ * RHS contributes its single output column's contribution), then resolve
+ * condition-vs-RHS. Literal-only lists contribute nothing, preserving
+ * condition-driven behavior for the dominant case.
+ */
+export function resolveInCollation(condition, rhs) {
+    const merged = mergeContributions(rhs.map(collationContribution));
+    if (merged.kind === 'conflict') {
+        return { kind: 'conflict', level: merged.level, left: merged.left, right: merged.right };
+    }
+    return resolveContributions(collationContribution(condition), merged.contribution);
+}
+/** RHS contribution sources of an InNode: list element types, or the subquery's single output column. */
+function inRhsTypes(node) {
+    if (node.values)
+        return node.values.map(v => v.getType());
+    if (node.source) {
+        const rel = node.source.getType();
+        const col = rel.columns[0];
+        return col ? [col.type] : [];
+    }
+    return [];
+}
+/** Pure form of {@link effectiveInCollation} — conflicts returned, not thrown. */
+export function resolveInCollationForNode(node) {
+    return resolveInCollation(node.condition.getType(), inRhsTypes(node));
+}
+/**
+ * Effective collation of `condition IN (...)`. `emitIn` pre-resolves this ONE
+ * collation for the whole membership test (the BTree build keys under it).
+ * Throws on conflict (backstop past `InNode.generateType` validation).
+ */
+export function effectiveInCollation(node) {
+    return resolvedOrThrow(resolveInCollationForNode(node), node.expression);
+}
+/**
+ * Collation propagated through a non-comparison combiner (`||` concat, CASE
+ * branch merge): the highest-ranked contribution wins; equal-rank
+ * contributions with the same name keep it; equal-rank contributions with
+ * different names propagate **no** collation — the conflict is not an error
+ * here (these nodes do not compare), but it must not silently coin-flip; a
+ * later comparison over the result then falls back to BINARY. Set-based over
+ * the winning rank, so operand/branch order cannot change the result.
+ */
+export function mergePropagatedCollation(types) {
+    const merged = mergeContributions(types.map(collationContribution));
+    if (merged.kind === 'conflict' || merged.contribution === undefined)
+        return {};
+    return { collationName: merged.contribution.name, collationSource: SOURCE_BY_RANK[merged.contribution.rank] };
+}
+/**
+ * Resolve one set-operation output column's dedup/compare collation across both
+ * inputs. Pure — never throws; a conflict is returned for the caller to handle
+ * per operator (throw for `union`/`intersect`/`except`; treat as no-collation
+ * for `union all`). Semantically `resolveContributions(left, right)` except it
+ * keeps the winning contribution's *rank* (as `collationSource`) instead of
+ * collapsing to a bare name, so a nested set-op re-resolves at the correct rank.
+ */
+export function resolveSetOpColumnCollation(left, right) {
+    const merged = mergeContributions([collationContribution(left), collationContribution(right)]);
+    if (merged.kind === 'conflict')
+        return { kind: 'conflict', level: merged.level, left: merged.left, right: merged.right };
+    const c = merged.contribution;
+    return c
+        ? { kind: 'resolved', collationName: c.name, collationSource: SOURCE_BY_RANK[c.rank] }
+        : { kind: 'resolved' }; // BINARY floor — no collationName/collationSource
+}
+/**
+ * Binary operators that compare their operands under a collation, and so must
+ * validate the lattice in `generateType`. The parser currently produces only
+ * unary `IS [NOT] NULL/TRUE/FALSE` forms — binary `IS`/`IS NOT` are listed so
+ * validation comes for free if it ever grows them.
+ */
+const COMPARISON_OPERATORS = new Set(['=', '==', '!=', '<>', '<', '<=', '>', '>=', 'IS', 'IS NOT']);
+export function isComparisonOperator(op) {
+    return COMPARISON_OPERATORS.has(op.toUpperCase());
+}
+/**
+ * The collation a single operand contributes to a comparison, normalized.
+ * `'BINARY'` when the operand's type carries none. Provenance-blind by design:
+ * gates that compare an operand's own collation against an effective collation
+ * (covered-key detection, equi-pair extraction) care about the *name* the
+ * operand resolves under, not its rank.
+ */
+export function operandCollation(node) {
+    return normalizeCollationName(node.getType().collationName ?? 'BINARY');
+}
+/**
+ * True when a logical type can never produce a text value at runtime. `ANY`
+ * validates every value (it can hold text), so it is treated as potentially
+ * textual despite carrying no `isTextual` marker. An absent type is unknown —
+ * potentially textual.
+ */
+function isNonTextualLogicalType(lt) {
+    if (lt === undefined)
+        return false;
+    return lt.isTextual !== true && lt.physicalType !== PhysicalType.TEXT && lt.name !== 'ANY';
+}
+/**
+ * True when the operand's static type can never produce a text value at
+ * runtime.
+ */
+function isStaticallyNonTextual(node) {
+    return isNonTextualLogicalType(node.getType().logicalType);
+}
+/**
+ * True iff an equality `left = right` is **value-discriminating**: rows it
+ * passes are genuinely value-equal on the compared operands, so the conjunct
+ * may mint value-level facts (constant pins `∅ → col`, `col1 = col2` mirror
+ * FDs, equivalence classes, constant bindings, join equi-pairs).
+ *
+ * Rule (the soundness gate from ticket
+ * `collation-blind-equality-fact-extraction`):
+ *   - non-textual operands: always — collation does not apply to non-text
+ *     comparisons (`compareSqlValuesFast` only consults the collation function
+ *     for text/text; cross-class comparisons order by storage class);
+ *   - textual (or statically unknown) operands: every collation either
+ *     operand could contribute must be BINARY. A NOCASE/RTRIM comparison
+ *     passes value-DIFFERENT rows ('Bob' = 'bob' NOCASE), so any value-level
+ *     fact minted from it over-claims.
+ *
+ * Both sides are checked (not just `effectiveComparisonCollation`'s lattice
+ * winner) so the gate stays robust to per-algorithm resolution-order
+ * differences among runtime comparison sites (the merge/bloom join emitters
+ * resolve per-key from one side's attribute type). Note this deliberately
+ * blocks on a *defaulted* non-BINARY contribution too (session
+ * `default_collation`), which the lattice would also resolve to.
+ */
+export function isValueDiscriminatingEquality(left, right) {
+    if (operandCollation(left) === 'BINARY' && operandCollation(right) === 'BINARY')
+        return true;
+    // A non-BINARY collation is in play; it is inert only when text values can
+    // never meet at runtime.
+    return isStaticallyNonTextual(left) && isStaticallyNonTextual(right);
+}
+function astOperandContribution(expr, columnIndexMap, columns) {
+    const colIdx = columnIndexFromExpr(expr, columnIndexMap);
+    if (colIdx !== undefined) {
+        const meta = columns[colIdx];
+        return {
+            binary: normalizeCollationName(meta?.collation ?? 'BINARY') === 'BINARY',
+            nonTextual: isNonTextualLogicalType(meta?.logicalType),
+        };
+    }
+    if (expr.type === 'literal') {
+        // A bare literal carries no collation. Deferred (Promise) literal values
+        // have unknown textuality.
+        const v = expr.value;
+        return { binary: true, nonTextual: !(v instanceof Promise) && typeof v !== 'string' };
+    }
+    // Any other expression contributes BINARY only when nothing in its subtree
+    // could inject a non-BINARY collation: no non-BINARY COLLATE wrapper, and
+    // every column referenced inside is BINARY-declared or non-textual (robust
+    // to however collation propagates through planner node types). Textuality
+    // of the result is unknown — treat as textual.
+    for (const name of collectCollateNames(expr)) {
+        if (normalizeCollationName(name) !== 'BINARY') {
+            return { binary: false, nonTextual: false };
+        }
+    }
+    for (const idx of collectColumnNames(expr, columnIndexMap)) {
+        const meta = columns[idx];
+        if (normalizeCollationName(meta?.collation ?? 'BINARY') !== 'BINARY'
+            && !isNonTextualLogicalType(meta?.logicalType)) {
+            return { binary: false, nonTextual: false };
+        }
+    }
+    return { binary: true, nonTextual: false };
+}
+/**
+ * Schema-level (AST + declared column metadata) variant of
+ * {@link isValueDiscriminatingEquality}, for fact producers that run on raw
+ * AST before any plan nodes exist (`check-extraction.ts`, assertion hoist).
+ *
+ * Mirrors **enforcement** semantics: write-time CHECK / assertion evaluation
+ * resolves declared column collations (constraint-builder threads
+ * `collationName` into the CHECK scope types) plus explicit COLLATE wrappers —
+ * so the comparison a declared constraint actually enforces is
+ * value-discriminating exactly when every collation either operand could
+ * contribute is BINARY, or both operands are statically non-textual.
+ *
+ * Used for ALL value-level CHECK contributions — equality facts (FDs, EC
+ * pairs, constant pins/bindings) AND domain facts (ranges, BETWEEN, IN enums):
+ * a text-typed domain extracted from a non-BINARY enforcement comparison
+ * over-claims just like an equality fact (`check (c in ('a','b'))` under
+ * NOCASE admits 'A'). Guard *scopes* are not gated here — discharge soundness
+ * lives in `buildPredicateFacts`' per-conjunct gate, which assumes guard
+ * scopes are evaluated under declared collations (true of enforcement).
+ */
+export function isValueDiscriminatingAstComparison(left, right, columnIndexMap, columns) {
+    const l = astOperandContribution(left, columnIndexMap, columns);
+    const r = astOperandContribution(right, columnIndexMap, columns);
+    if (l.binary && r.binary)
+        return true;
+    return l.nonTextual && r.nonTextual;
+}
+//# sourceMappingURL=comparison-collation.js.map

package/dist/src/planner/analysis/comparison-collation.js.map

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

package/dist/src/planner/analysis/constraint-extractor.d.ts

@@ -116,7 +116,9 @@ export declare function extractCoveredKeysForTable(plan: RelationalPlanNode, tar
  * Given a set of constraints and a table's unique keys, compute which keys are fully covered by
  * equality (optionally using FDs and equivalence classes to expand the equality-covered column set
  * via closure). A key is covered if every column in it lies in the closure of equality-covered
- * columns under the supplied FDs + EC-derived FDs.
+ * columns under the supplied FDs + EC-derived FDs. Equality constraints whose
+ * comparison collation is coarser than the column's declared (enforcement)
+ * collation are skipped — see {@link equalityConstraintCollationOk}.
  */
 export declare function computeCoveredKeysForConstraints(constraints: readonly PredicateConstraint[], tableUniqueKeys: readonly number[][], fds?: readonly FunctionalDependency[], equivClasses?: readonly (readonly number[])[]): number[][];
 /**

package/dist/src/planner/analysis/constraint-extractor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"constraint-extractor.d.ts","sourceRoot":"","sources":["../../../../src/planner/analysis/constraint-extractor.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"constraint-extractor.d.ts","sourceRoot":"","sources":["../../../../src/planner/analysis/constraint-extractor.ts"],"names":[],"mappings":"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"}