@quereus/quereus 3.2.1 → 4.0.0

package/dist/src/planner/util/fd-utils.d.ts

@@ -4,7 +4,8 @@
  * section "Functional Dependency Tracking" for the propagation table and
  * design rationale.
  */
-import type { ConstantBinding, ConstantValue, DomainConstraint, FunctionalDependency, GuardPredicate, ScalarPlanNode } from '../nodes/plan-node.js';
+import type { ConstantBinding, ConstantValue, DomainConstraint, FunctionalDependency, GuardPredicate, InclusionDependency, IndTarget, PhysicalProperties, ScalarPlanNode } from '../nodes/plan-node.js';
+import type { RelationType } from '../../common/datatype.js';
 /**
  * Per-node cap on the number of FDs we materialize. The propagation rules
  * are conservative enough that hitting this in practice is rare; the cap
@@ -26,6 +27,8 @@ export declare function computeClosure(attrs: ReadonlySet<number>, fds: Readonly
  * column indices, then concatenate with the existing FDs. For a class
  * `{c0, c1, ..., ck}` this emits `{ci} → {cj}` for every distinct ordered pair
  * — enough for `computeClosure` to derive every member from any one of them.
+ * EC-derived FDs are pure value claims (`kind: 'determination'`) — an equality
+ * never implies row-uniqueness of either endpoint.
  */
 export declare function expandEcsToFds(ecs: ReadonlyArray<ReadonlyArray<number>>, fds: ReadonlyArray<FunctionalDependency>): FunctionalDependency[];
 /** True iff `attrs` determines every attribute in `target` under `fds`. */
@@ -54,6 +57,14 @@ export interface AddFdOptions {
  * Guard-aware: FDs with different `guard` predicates are kept side-by-side
  * even when their determinants/dependents match — they are logically distinct
  * facts and may be activated by different surrounding predicates.
+ *
+ * Kind reconciliation: on a merge between entries with equal determinants and
+ * guards, the surviving entry's `kind` is `'unique'` when EITHER side claims
+ * it — uniqueness is a property of the determinant set, so equal-determinant
+ * claims compose. This includes upgrading a kept 'determination' entry in
+ * place when the subsumed newcomer is 'unique'. Equal-determinant entries with
+ * incomparable dependent sets both survive and each keeps its own kind (a
+ * sound under-claim). Object identity is preserved when nothing changes.
  */
 export declare function addFd(fds: ReadonlyArray<FunctionalDependency>, next: FunctionalDependency, opts?: AddFdOptions): FunctionalDependency[];
 /** Merge two FD lists, applying subsumption via `addFd`. */
@@ -72,14 +83,30 @@ export declare function mergeFds(a: ReadonlyArray<FunctionalDependency>, b: Read
  * Guarded FDs additionally require every column referenced in `guard.clauses`
  * to be in the mapping — if any guard column is dropped the guard becomes
  * unobservable and the FD can never be re-activated downstream.
+ *
+ * Rebuilds via spread so `kind` / `source` / `valueEquality` survive verbatim.
+ * Preserving `kind` is sound: a projection maps rows 1:1 (no merge, no
+ * duplication), so determinant row-uniqueness survives whenever the
+ * determinants survive — which the determinant-loss drop above already
+ * requires. The empty-determinant exception keeps its kind too: a 'unique'
+ * singleton stays ≤1-row under projection; a 'determination' constant pin
+ * stays a mere pin.
  */
 export declare function projectFds(fds: ReadonlyArray<FunctionalDependency>, mapping: ReadonlyMap<number, number>): FunctionalDependency[];
-/** Shift all column indices in `fds` (including any `guard` columns) by `offset`. */
+/**
+ * Shift all column indices in `fds` (including any `guard` columns) by `offset`.
+ * Rebuilds via spread so `kind` / `source` / `valueEquality` survive verbatim —
+ * a shift is a pure column relabel, so every claim (uniqueness included) holds
+ * unchanged on the relabeled columns.
+ */
 export declare function shiftFds(fds: ReadonlyArray<FunctionalDependency>, offset: number): FunctionalDependency[];
 /**
- * Return the unconditional twin of `fd` — drop the guard but keep determinants
- * and dependents. Used by Filter activation when the surrounding predicate
- * entails the guard.
+ * Return the unconditional twin of `fd` — drop the guard but keep every other
+ * field (`kind` / `source` / `valueEquality` survive verbatim). Used by Filter
+ * activation when the surrounding predicate entails the guard. Preserving
+ * 'unique' is sound at the activating Filter: its rows all satisfy the guard,
+ * and filtering only shrinks the row set — fan-out hazards are handled by the
+ * join-side downgrade, not here.
  */
 export declare function stripGuard(fd: FunctionalDependency): FunctionalDependency;
 /** Shift all column indices in `classes` by `offset`. */
@@ -96,59 +123,174 @@ export declare function addEquivalence(classes: ReadonlyArray<ReadonlyArray<numb
  * way to encode "K is a unique key on a relation": K determines every other
  * output column. K = ∅ produces the "at-most-one-row" singleton FD.
  *
+ * Emits `kind: 'unique'` — every caller passes a genuine key (declared or
+ * projected keys, fan-out-aware join `preservedKeys`, the aggregate group key,
+ * the set-op data-columns key, lens key obligations, TVF-declared keys), so
+ * the relation has at most one row per determinant tuple at the minting site.
+ *
  * Returns undefined when K covers every column (the all-columns case has no
  * non-trivial encoding — that case is communicated via `RelationType.isSet`
  * instead).
  */
 export declare function superkeyToFd(key: readonly number[], columnCount: number): FunctionalDependency | undefined;
 /**
- * True iff the closure of `attrs` under `fds` covers `{0..columnCount-1}` —
- * i.e., `attrs` is a superkey of the relation. Replaces the legacy "covers a
- * `uniqueKeys` entry" check; FDs are the canonical surface now.
+ * True iff the closure of `attrs` under `fds` covers `{0..columnCount-1}`.
+ * COVERAGE ONLY — this is a pure value-determination claim and says NOTHING
+ * about row-uniqueness: over a bag, a determination-only closure path can
+ * cover every column while the relation still holds duplicate rows. For the
+ * uniqueness question ("at most one row per attrs-tuple?") use
+ * `isUniqueDeterminant`. (Renamed from `isSuperkey`, whose name read as a
+ * uniqueness claim and invited exactly that misuse — ticket
+ * `fd-determination-reader-side-rule`.)
  */
-export declare function isSuperkey(attrs: ReadonlySet<number>, fds: ReadonlyArray<FunctionalDependency> | undefined, columnCount: number): boolean;
+export declare function closureCoversAll(attrs: ReadonlySet<number>, fds: ReadonlyArray<FunctionalDependency> | undefined, columnCount: number): boolean;
+/**
+ * True iff `attrs` is provably row-unique on the relation: its FD closure
+ * covers every column AND uniqueness is reachable —
+ *   - the relation is a set (two rows agreeing on `attrs` would agree on all
+ *     columns = a duplicate, impossible in a set), or
+ *   - some unguarded `kind: 'unique'` FD has determinants ⊆ closure(attrs)
+ *     (rows agreeing on `attrs` agree on that unique determinant set; ≤1 row
+ *     per its tuple ⇒ ≤1 row per attrs-tuple).
+ *
+ * Coverage alone (a determination-only closure path over a bag) proves
+ * nothing — that is the over-claim family the kind-aware readers exist to
+ * prevent (ticket `fd-determination-reader-side-rule`). This is the single
+ * reader-side uniqueness primitive; producers no longer gate determinations.
+ *
+ * Guarded FDs participate in neither branch: `computeClosure` skips them, and
+ * only UNguarded 'unique' FDs can witness (a guarded uniqueness claim holds
+ * only under its predicate, which this layer cannot see).
+ */
+export declare function isUniqueDeterminant(attrs: ReadonlySet<number>, fds: ReadonlyArray<FunctionalDependency> | undefined, columnCount: number, isSet: boolean): boolean;
 /**
  * Enumerate the minimal full-cover key sets discoverable from `fds`: for each
- * FD `K → Y` whose closure covers all columns, return `K` (greedily minimized
- * within `K`). Deduplicated by set equality.
+ * FD `K → Y` where `K` is a provably row-unique determinant
+ * (`isUniqueDeterminant` — coverage AND uniqueness reachability), return `K`
+ * (greedily minimized within `K`). Deduplicated by set equality.
+ *
+ * `minimalCover` preserves the closure, so the minimized key keeps both
+ * coverage and the unique witness (witness determinants ⊆ the unchanged
+ * closure).
  *
- * Excludes the trivial "all-columns is a superkey" tautology — only FDs with
- * `K ⊊ all_cols` are considered, since the all-cols case is encoded via
- * `RelationType.isSet`.
+ * Excludes the trivial "all-columns is a key of a set" tautology — only FDs
+ * with `K ⊊ all_cols` are considered, since the all-cols case is encoded via
+ * `RelationType.isSet` (the `keysOf` fallback).
  */
-export declare function deriveKeysFromFds(fds: ReadonlyArray<FunctionalDependency> | undefined, columnCount: number): number[][];
+export declare function deriveKeysFromFds(fds: ReadonlyArray<FunctionalDependency> | undefined, columnCount: number, isSet: boolean): number[][];
 /**
  * True iff the FD set encodes any non-trivial key — i.e., there exists some
- * FD whose determinants form a superkey of `columnCount` columns with the
- * determinant set strictly smaller than all columns. This is the FD-surface
- * replacement for "the relation has a known unique key smaller than its full
- * column list" (the old `uniqueKeys.length > 0` check), excluding the
- * tautological all-columns case which carries no information.
+ * FD whose determinants are a provably row-unique determinant set
+ * (`isUniqueDeterminant`) strictly smaller than all columns. This is the
+ * FD-surface replacement for "the relation has a known unique key smaller
+ * than its full column list" (the old `uniqueKeys.length > 0` check),
+ * excluding the tautological all-columns case which carries no information.
  */
-export declare function hasAnyKey(fds: ReadonlyArray<FunctionalDependency> | undefined, columnCount: number): boolean;
+export declare function hasAnyKey(fds: ReadonlyArray<FunctionalDependency> | undefined, columnCount: number, isSet: boolean): boolean;
 /**
- * True iff the relation has at-most-one-row — i.e., some FD `∅ → Y` exists
- * whose closure covers every column. Replaces the legacy `[[]]` singleton
- * marker on `uniqueKeys`.
+ * True iff the relation is provably at-most-one-row from its FD surface —
+ * `isUniqueDeterminant(∅, …)`: the closure of the empty set covers every
+ * column AND uniqueness is reachable (the relation is a set, or an unguarded
+ * 'unique' FD witnesses). Replaces the legacy `[[]]` singleton marker on
+ * `uniqueKeys`.
+ *
+ * On a bag, constant pins (`∅ → col` determinations from `where a = 1`) no
+ * longer over-claim ≤1-row; on a set, pinning every column IS a sound ≤1-row
+ * derivation. Zero-column relations return false — the `∅ → all_cols` FD is
+ * unrepresentable there, so the ≤1-row claim rides `estimatedRows` instead
+ * (see `characteristics.guaranteesUniqueRows`).
  */
-export declare function hasSingletonFd(fds: ReadonlyArray<FunctionalDependency> | undefined, columnCount: number): boolean;
+export declare function hasSingletonFd(fds: ReadonlyArray<FunctionalDependency> | undefined, columnCount: number, isSet: boolean): boolean;
 /**
  * Build the singleton FD `∅ → {0..columnCount-1}` that encodes
- * "at-most-one-row". Returns undefined when `columnCount === 0` (no
- * dependents).
+ * "at-most-one-row". `kind: 'unique'` — ∅ row-unique ⟺ ≤1 row, which is
+ * exactly what every caller asserts. Returns undefined when
+ * `columnCount === 0` (no dependents).
  */
 export declare function singletonFd(columnCount: number): FunctionalDependency | undefined;
 /**
- * True iff `attrs` is asserted to be a unique key by the FD set — i.e., there
- * exists some FD whose determinants are a subset of `attrs` and whose closure
- * covers all columns. Stricter than `isSuperkey`: the trivial "all-cols is a
- * superkey of itself" tautology does NOT count, because no FD makes that claim.
+ * Fold the singleton FD `∅ → {0..columnCount-1}` ("at-most-one-row") into `fds`
+ * via `addFd`. The canonical producer-side spelling of the ≤1-row fact — every
+ * `computePhysical` site that proves a relation emits ≤1 row should reach for
+ * this rather than open-coding `singletonFd` + `addFd`.
+ *
+ * A no-op returning a copy of `fds` when `columnCount === 0` (since
+ * `singletonFd(0)` is `undefined` — a zero-column relation cannot carry the
+ * marker). Pairs with the `hasSingletonFd` / `isAtMostOneRow` read surface.
+ */
+export declare function addSingletonFd(fds: ReadonlyArray<FunctionalDependency>, columnCount: number): FunctionalDependency[];
+/**
+ * The minimal slice of a relational plan node needed to read its uniqueness
+ * facts. `getType()` supplies the declared `keys`, the `isSet` flag, and the
+ * output column count; `physical?.fds` supplies the derived FD surface.
+ */
+export interface KeyRel {
+    getType(): RelationType;
+    physical?: PhysicalProperties;
+}
+/**
+ * Canonical minimal candidate keys of a relation, each a sorted readonly
+ * `number[]` of output column indices, normalized and deduped. This is the
+ * single uniqueness read path — it reconciles all three surfaces a uniqueness
+ * fact can live on (declared `RelationType.keys`, the `PhysicalProperties.fds`
+ * FD set, and `RelationType.isSet`) so consumers never have to "check all
+ * three" by hand.
+ *
+ * Keys are gathered cheap → expensive:
+ *   1. Declared `keys` (mapped to column indices). The empty key `[]`
+ *      (TableDee / ≤1-row) is preserved as an empty entry and subsumes all.
+ *   2. The `∅ → all_cols` FD (`hasSingletonFd`) ⇒ the empty key `[]`.
+ *   3. FD-derived keys via `deriveKeysFromFds`.
+ *   4. All-columns fallback: if nothing smaller was found AND the relation is
+ *      a set (`getType().isSet`), the all-columns key `[0..n-1]`.
+ *
+ * Result is `[]` (no entries) ⟺ the relation is a bag (no provable key).
+ *
+ * **Enumeration bound (soundness vs completeness):** deriving minimal keys
+ * from a general FD set is the candidate-key enumeration problem (NP-hard in
+ * column count). We do NOT enumerate column subsets — `deriveKeysFromFds`
+ * seeds one candidate per existing FD and minimizes within it, and the
+ * declared keys + all-columns fallback are always emitted regardless of
+ * FD-enumeration cost. Over-capping here costs **completeness only** (a real
+ * key may go unlisted), never **soundness** (a listed key always holds). Use
+ * `isUnique` for the soundness-critical "is this set a superkey?" question —
+ * it additionally consults FD closure, which can prove a superkey absent from
+ * this minimal list.
+ */
+export declare function keysOf(rel: KeyRel): readonly (readonly number[])[];
+/**
+ * True iff `cols` is a superkey of `rel` — i.e., the relation has at most one
+ * row per distinct `cols` tuple. The soundness-critical uniqueness predicate.
+ *
+ * Returns true iff any of:
+ *   - `cols` is a (non-strict) superset of some `keysOf(rel)` entry (covers
+ *     declared keys, the ≤1-row empty key, FD-derived keys, and the
+ *     all-columns/set key), OR
+ *   - `cols` is a provably row-unique determinant (`isUniqueDeterminant`:
+ *     closure coverage AND uniqueness reachability) — this proves a superkey
+ *     even when it is absent from the minimal `keysOf` list.
+ *
+ * No all-columns guard is needed on the closure branch: an all-columns probe
+ * on a bag fails `isUniqueDeterminant` on its own (no unique FD ⇒ false; if a
+ * unique FD exists the relation cannot hold duplicate rows, so true is
+ * correct).
+ */
+export declare function isUnique(cols: readonly number[], rel: KeyRel): boolean;
+/**
+ * The single named spelling of the node-level "at-most-one-row" predicate:
+ * true iff `rel` is provably ≤1-row. Defined as `isUnique([], rel)` — the empty
+ * key is a subset of every column set, so a relation carrying it (via a declared
+ * empty key, the `∅ → all_cols` singleton FD, or any other channel `keysOf`
+ * reconciles) reports unique on the empty column list.
  *
- * Use this when you need a positive uniqueness claim (e.g., the
- * sort/window strict-monotonicOn check). For "would attrs functionally
- * determine the rest of the relation under closure?" use `isSuperkey` directly.
+ * Use this at node / rule level. The FD-only `hasSingletonFd` is the lower-level
+ * test `keysOf` itself calls; `isAtMostOneRow` is the surface consumers (joins,
+ * sort elimination) should reach for. Note it does **not** capture the
+ * zero-column `estimatedRows === 1` case — a zero-column relation has no
+ * representable empty key — so consumers needing that fallback keep their own
+ * check (see `characteristics.guaranteesUniqueRows`).
  */
-export declare function isAssertedKey(attrs: ReadonlySet<number>, fds: ReadonlyArray<FunctionalDependency> | undefined, columnCount: number): boolean;
+export declare function isAtMostOneRow(rel: KeyRel): boolean;
 /**
  * Re-export so callers can import the binding shape from this module
  * alongside the helpers (avoids reaching into `plan-node.js` for types
@@ -186,6 +328,19 @@ export interface EqualityFds {
  *     equivalence pair `[col1, col2]`.
  *
  * Non-equality conjuncts contribute nothing.
+ *
+ * **Collation gate.** Every extracted fact is a VALUE-level claim (a pinned
+ * column has one value across rows; `col1 = col2` rows are value-equal), so a
+ * conjunct only contributes when its comparison is value-discriminating
+ * (`isValueDiscriminatingEquality`): for textual operands the effective
+ * comparison collation must be BINARY. A NOCASE/RTRIM comparison — via a
+ * `COLLATE` wrapper on either side or a non-BINARY declared column collation —
+ * passes value-DIFFERENT rows ('Bob' = 'bob' NOCASE), so its facts would
+ * over-claim (false ≤1-row keys, false EC-driven inferences, wrong insert
+ * defaults — ticket `collation-blind-equality-fact-extraction`). Declared-
+ * collation covered-key ≤1-row detection is NOT lost: it flows through the
+ * independent (and collation-sound) `extractConstraints` path in
+ * `FilterNode.computePhysical`.
  */
 export declare function extractEqualityFds(predicate: ScalarPlanNode, attrIdToIndex: ReadonlyMap<number, number>): EqualityFds;
 /**
@@ -202,8 +357,12 @@ export declare function extractEqualityFds(predicate: ScalarPlanNode, attrIdToIn
  * sound for numeric columns since the consumer matches `eq-literal{col, 0}`
  * via strict `sqlValueEquals`, which treats TEXT `''`, BLOB, and boolean
  * `false` as unequal to integer 0.
+ *
+ * `declaredCollationOf(col)` reports the source's output column collation
+ * (normalized or not; `'BINARY'` when undeclared). Used by the per-conjunct
+ * collation gate in `buildPredicateFacts` — see its doc.
  */
-export declare function predicateImpliesGuard(predicate: ScalarPlanNode, guard: GuardPredicate, ecs: ReadonlyArray<ReadonlyArray<number>>, bindings: ReadonlyArray<ConstantBinding>, attrIdToIndex: ReadonlyMap<number, number>, isColumnNonNullable: (col: number) => boolean, isColumnNumeric: (col: number) => boolean): boolean;
+export declare function predicateImpliesGuard(predicate: ScalarPlanNode, guard: GuardPredicate, ecs: ReadonlyArray<ReadonlyArray<number>>, bindings: ReadonlyArray<ConstantBinding>, attrIdToIndex: ReadonlyMap<number, number>, isColumnNonNullable: (col: number) => boolean, isColumnNumeric: (col: number) => boolean, declaredCollationOf: (col: number) => string): boolean;
 /**
  * Merge two binding lists, coalescing bindings that share a `ConstantValue`
  * by unioning their `attrs`. Caps the result at `MAX_FDS_PER_NODE`; later
@@ -242,4 +401,37 @@ export declare function mergeDomainConstraints(a: ReadonlyArray<DomainConstraint
 export declare function projectDomainConstraints(domains: ReadonlyArray<DomainConstraint>, mapping: ReadonlyMap<number, number>): DomainConstraint[];
 /** Shift every domain constraint's `column` by `offset` (join translation). */
 export declare function shiftDomainConstraints(domains: ReadonlyArray<DomainConstraint>, offset: number): DomainConstraint[];
+export type { InclusionDependency, IndTarget };
+/**
+ * Per-node cap on the number of INDs we materialize, mirroring
+ * `MAX_FDS_PER_NODE`. A safety valve for pathological plans; truncations are
+ * logged under the `quereus:planner:fd` logger like the FD/binding/domain caps.
+ */
+export declare const MAX_INDS_PER_NODE = 64;
+export interface AddIndOptions {
+    cap?: number;
+}
+/**
+ * Add a single IND, skipping it when a structurally-equal entry (per
+ * `indsEqual`) already exists. Enforces the per-node cap; truncations are
+ * logged. Mirrors `addFd` minus the determinant-subsumption logic (an IND has
+ * no determinant/dependent split to subsume).
+ */
+export declare function addInd(inds: ReadonlyArray<InclusionDependency>, next: InclusionDependency, opts?: AddIndOptions): InclusionDependency[];
+/** Merge two IND lists: concat with structural dedup via `addInd`, capped. */
+export declare function mergeInds(a: ReadonlyArray<InclusionDependency>, b: ReadonlyArray<InclusionDependency>, opts?: AddIndOptions): InclusionDependency[];
+/**
+ * Project INDs through a column mapping (oldCol → newCol). An IND's `cols` is
+ * **all-or-nothing**: drop the IND when ANY of its `cols` loses its mapping (the
+ * relation no longer carries the witnessing columns) — there is no partial-
+ * dependent survival as in `projectFds`. Survivors have their `cols` remapped to
+ * output indices; `target.targetCols` index into the *target* relation, NOT this
+ * relation's output, so they are NOT remapped. Result is deduped + capped.
+ */
+export declare function projectInds(inds: ReadonlyArray<InclusionDependency>, mapping: ReadonlyMap<number, number>): InclusionDependency[];
+/**
+ * Shift each IND's `cols` by `offset` (mirrors `shiftFds` for join column
+ * translation). `target.targetCols` are target-relative ⇒ NOT shifted.
+ */
+export declare function shiftInds(inds: ReadonlyArray<InclusionDependency>, offset: number): InclusionDependency[];
 //# sourceMappingURL=fd-utils.d.ts.map

package/dist/src/planner/util/fd-utils.d.ts.map

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