@quereus/quereus 2.8.0 → 3.0.0

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

@@ -0,0 +1,245 @@
+/**
+ * Functional dependency (FD) and equivalence-class (EC) helpers used by
+ * `computePhysical` on relational plan nodes. See `docs/optimizer.md`
+ * section "Functional Dependency Tracking" for the propagation table and
+ * design rationale.
+ */
+import type { ConstantBinding, ConstantValue, DomainConstraint, FunctionalDependency, GuardPredicate, ScalarPlanNode } from '../nodes/plan-node.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
+ * is a safety valve for pathological plans.
+ */
+export declare const MAX_FDS_PER_NODE = 64;
+/**
+ * Closure of `attrs` under `fds`. Iterative fixed-point.
+ *
+ * Guarded FDs (`fd.guard !== undefined`) are skipped — they are only valid
+ * under a surrounding predicate, and the closure layer has no notion of one.
+ * Filter activation strips the guard before the FD reaches closure consumers.
+ *
+ * O(|fds| × growth) — terminates when no new attribute is added in a pass.
+ */
+export declare function computeClosure(attrs: ReadonlySet<number>, fds: ReadonlyArray<FunctionalDependency>): Set<number>;
+/**
+ * Expand a list of equivalence classes into bi-directional FDs over the same
+ * 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.
+ */
+export declare function expandEcsToFds(ecs: ReadonlyArray<ReadonlyArray<number>>, fds: ReadonlyArray<FunctionalDependency>): FunctionalDependency[];
+/** True iff `attrs` determines every attribute in `target` under `fds`. */
+export declare function determines(attrs: ReadonlySet<number>, target: ReadonlySet<number>, fds: ReadonlyArray<FunctionalDependency>): boolean;
+/**
+ * Smallest subset of `attrs` whose closure equals the closure of `attrs`.
+ * Greedy minimization: try dropping each attribute; keep the drop iff the
+ * resulting closure is unchanged. O(|attrs|² × |fds|).
+ */
+export declare function minimalCover(attrs: ReadonlySet<number>, fds: ReadonlyArray<FunctionalDependency>): Set<number>;
+export interface AddFdOptions {
+    /**
+     * Hint: column subsets that are known full-cover keys on the relation.
+     * Used by `enforceCap` to prefer FDs whose determinants are subsets of
+     * any such key when truncating; otherwise unused. Optional.
+     */
+    keyHints?: ReadonlyArray<ReadonlyArray<number>>;
+    cap?: number;
+}
+/**
+ * Add a single FD, dropping any existing entry with the same determinants
+ * (and same guard) whose dependents are a subset of the new one (subsumption).
+ * When the resulting list exceeds the cap, drop FDs whose determinants are
+ * not a subset of any `keyHints` entry on the same node.
+ *
+ * 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.
+ */
+export declare function addFd(fds: ReadonlyArray<FunctionalDependency>, next: FunctionalDependency, opts?: AddFdOptions): FunctionalDependency[];
+/** Merge two FD lists, applying subsumption via `addFd`. */
+export declare function mergeFds(a: ReadonlyArray<FunctionalDependency>, b: ReadonlyArray<FunctionalDependency>, opts?: AddFdOptions): FunctionalDependency[];
+/**
+ * Project FDs through a column mapping (oldCol → newCol). FDs whose
+ * determinants lose any column are dropped entirely (the projection breaks
+ * the determinant set). Dependents that don't survive are filtered out;
+ * an FD whose dependents are completely filtered is dropped.
+ *
+ * Exception: an FD with empty determinants (the singleton "at-most-one-row"
+ * marker) survives as long as at least one dependent does — losing some
+ * dependent columns to projection doesn't invalidate the at-most-one-row
+ * claim on the surviving columns.
+ *
+ * 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.
+ */
+export declare function projectFds(fds: ReadonlyArray<FunctionalDependency>, mapping: ReadonlyMap<number, number>): FunctionalDependency[];
+/** Shift all column indices in `fds` (including any `guard` columns) by `offset`. */
+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.
+ */
+export declare function stripGuard(fd: FunctionalDependency): FunctionalDependency;
+/** Shift all column indices in `classes` by `offset`. */
+export declare function shiftEquivClasses(classes: ReadonlyArray<ReadonlyArray<number>>, offset: number): number[][];
+/**
+ * Merge two equivalence-class sets, taking the transitive closure of
+ * overlapping classes (union-find style).
+ */
+export declare function mergeEquivClasses(a: ReadonlyArray<ReadonlyArray<number>>, b: ReadonlyArray<ReadonlyArray<number>>): number[][];
+/** Add a new equality `a ≡ b` to an existing class list. */
+export declare function addEquivalence(classes: ReadonlyArray<ReadonlyArray<number>>, a: number, b: number): number[][];
+/**
+ * Build an FD `key → {0..columnCount-1} \ key` from a superkey. The canonical
+ * 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.
+ *
+ * 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.
+ */
+export declare function isSuperkey(attrs: ReadonlySet<number>, fds: ReadonlyArray<FunctionalDependency> | undefined, columnCount: number): 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.
+ *
+ * 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`.
+ */
+export declare function deriveKeysFromFds(fds: ReadonlyArray<FunctionalDependency> | undefined, columnCount: number): 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.
+ */
+export declare function hasAnyKey(fds: ReadonlyArray<FunctionalDependency> | undefined, columnCount: number): 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`.
+ */
+export declare function hasSingletonFd(fds: ReadonlyArray<FunctionalDependency> | undefined, columnCount: number): boolean;
+/**
+ * Build the singleton FD `∅ → {0..columnCount-1}` that encodes
+ * "at-most-one-row". 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.
+ *
+ * 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.
+ */
+export declare function isAssertedKey(attrs: ReadonlySet<number>, fds: ReadonlyArray<FunctionalDependency> | undefined, columnCount: number): boolean;
+/**
+ * Re-export so callers can import the binding shape from this module
+ * alongside the helpers (avoids reaching into `plan-node.js` for types
+ * that are conceptually part of the FD/EC layer).
+ */
+export type { ConstantBinding, ConstantValue };
+/**
+ * Extracted FD/EC/binding contributions from an equality-shaped predicate.
+ *
+ * - `fds`: FDs of the form `∅ → col` (column constant under the predicate)
+ *   or `col1 → col2` / `col2 → col1` (mutual determination from `col1 = col2`).
+ * - `equivPairs`: `[col1, col2]` pairs to be merged into the EC list.
+ * - `constantBindings`: per-column constant bindings (one per `col = const`
+ *   or `col = ?` conjunct). The caller is responsible for closing these
+ *   over the resulting EC list.
+ */
+export interface EqualityFds {
+    readonly fds: ReadonlyArray<FunctionalDependency>;
+    readonly equivPairs: ReadonlyArray<readonly [number, number]>;
+    readonly constantBindings: ReadonlyArray<ConstantBinding>;
+}
+/**
+ * Walk `predicate` (assumed to be a normalized conjunction) and extract FDs,
+ * equivalence-class contributions, and constant bindings from equality
+ * conjuncts.
+ *
+ * `attrIdToIndex` maps an attribute ID to its column index in the predicate's
+ * relation. Equality conjuncts referencing attributes outside this map
+ * (correlated subqueries, etc.) are silently ignored.
+ *
+ * Recognized shapes (per AND-conjunct):
+ *   - `col = literal`  ⇒ FD `∅ → col`  +  binding `{col} → literal value`.
+ *   - `col = ?`        ⇒ FD `∅ → col`  +  binding `{col} → parameter ref`.
+ *   - `col1 = col2`    ⇒ FDs `{col1} → {col2}` and `{col2} → {col1}` plus an
+ *     equivalence pair `[col1, col2]`.
+ *
+ * Non-equality conjuncts contribute nothing.
+ */
+export declare function extractEqualityFds(predicate: ScalarPlanNode, attrIdToIndex: ReadonlyMap<number, number>): EqualityFds;
+/**
+ * Decide whether the surrounding `predicate` (combined with the source's ECs
+ * and constant bindings) entails every clause in `guard`. Conservative — when
+ * in doubt, returns `false`.
+ *
+ * `isColumnNonNullable(col)` reports whether the source's output column is
+ * declared NOT NULL; the helper uses it to discharge `is-null negated:true`
+ * guards from type information alone.
+ *
+ * `isColumnNumeric(col)` reports whether the source's output column has a
+ * numeric logical type. Used to gate the `NOT col → col = 0` rewrite: only
+ * 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.
+ */
+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;
+/**
+ * Merge two binding lists, coalescing bindings that share a `ConstantValue`
+ * by unioning their `attrs`. Caps the result at `MAX_FDS_PER_NODE`; later
+ * additions are dropped when the cap is exceeded — bindings sourced from
+ * earlier nodes are preferred since they typically sit closer to keyed
+ * columns. Truncations are logged under `quereus:planner:fd`.
+ */
+export declare function mergeConstantBindings(a: ReadonlyArray<ConstantBinding>, b: ReadonlyArray<ConstantBinding>): ConstantBinding[];
+/**
+ * Extend `bindings` over `ecs`: if a binding pins column `c` to value `v` and
+ * `c` is in an equivalence class `{c, c2, ...}`, fold every member of that
+ * class into the binding's `attrs`. This is what lets predicate-inference
+ * rules consume bindings directly without walking ECs.
+ */
+export declare function closeConstantBindingsOverEcs(bindings: ReadonlyArray<ConstantBinding>, ecs: ReadonlyArray<ReadonlyArray<number>>): ConstantBinding[];
+/**
+ * Project bindings through `mapping` (oldCol → newCol). A binding whose
+ * `attrs` lose every member is dropped; otherwise the surviving members are
+ * remapped.
+ */
+export declare function projectConstantBindings(bindings: ReadonlyArray<ConstantBinding>, mapping: ReadonlyMap<number, number>): ConstantBinding[];
+/** Shift `attrs` by `offset` (column-index translation for joins). */
+export declare function shiftConstantBindings(bindings: ReadonlyArray<ConstantBinding>, offset: number): ConstantBinding[];
+export type { DomainConstraint };
+/**
+ * Concatenate two domain-constraint lists, dropping structurally equal
+ * duplicates. We deliberately do NOT intersect overlapping range/enum
+ * constraints on the same column — that's deferred to the
+ * predicate-contradiction-detection ticket. Caps at `MAX_FDS_PER_NODE`.
+ */
+export declare function mergeDomainConstraints(a: ReadonlyArray<DomainConstraint>, b: ReadonlyArray<DomainConstraint>): DomainConstraint[];
+/**
+ * Project domain constraints through `mapping` (oldCol → newCol). Drops any
+ * constraint whose column is not in the mapping; remaps the rest.
+ */
+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[];
+//# sourceMappingURL=fd-utils.d.ts.map

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

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