@rocicorp/zero 0.25.0-canary.1 → 0.25.0-canary.10

package/out/zql/src/planner/planner-graph.js.map

@@ -1 +1 @@
-{"version":3,"file":"planner-graph.js","sourceRoot":"","sources":["../../../../../zql/src/planner/planner-graph.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"planner-graph.js","sources":["../../../../../zql/src/planner/planner-graph.ts"],"sourcesContent":["import {assert} from '../../../shared/src/asserts.ts';\nimport {must} from '../../../shared/src/must.ts';\nimport {PlannerException} from '../error.ts';\nimport type {PlanDebugger} from './planner-debug.ts';\nimport type {PlannerConnection} from './planner-connection.ts';\nimport type {PlannerConstraint} from './planner-constraint.ts';\nimport type {PlannerFanIn} from './planner-fan-in.ts';\nimport type {PlannerFanOut} from './planner-fan-out.ts';\nimport type {PlannerJoin} from './planner-join.ts';\nimport {omitFanout} from './planner-node.ts';\nimport type {PlannerNode} from './planner-node.ts';\nimport {PlannerSource, type ConnectionCostModel} from './planner-source.ts';\nimport type {PlannerTerminus} from './planner-terminus.ts';\n\n/**\n * Captured state of a plan for comparison and restoration.\n */\nexport type PlanState = {\n  connections: Array<{limit: number | undefined}>;\n  joins: Array<{type: 'semi' | 'flipped'}>;\n  fanOuts: Array<{type: 'FO' | 'UFO'}>;\n  fanIns: Array<{type: 'FI' | 'UFI'}>;\n  connectionConstraints: Array<Map<string, PlannerConstraint | undefined>>;\n};\n\n/**\n * Maximum number of flippable joins to attempt exhaustive enumeration.\n * With n flippable joins, we explore 2^n plans.\n * 10 joins = 1024 plans (~100-200ms), 12 joins = 4096 plans (~400ms - 1 second)\n */\nconst MAX_FLIPPABLE_JOINS = 9;\n\n/**\n * Cached information about FanOut→FanIn relationships.\n * Computed once during planning to avoid redundant BFS traversals.\n */\ntype FOFIInfo = {\n  fi: PlannerFanIn | undefined;\n  joinsBetween: PlannerJoin[];\n};\n\nexport class PlannerGraph {\n  // Sources indexed by table name\n  readonly #sources = new Map<string, PlannerSource>();\n\n  // The final output node where constraint propagation starts\n  #terminus: PlannerTerminus | undefined = undefined;\n\n  // Collections of nodes with mutable planning state\n  joins: PlannerJoin[] = [];\n  fanOuts: PlannerFanOut[] = [];\n  fanIns: PlannerFanIn[] = [];\n  connections: PlannerConnection[] = [];\n\n  /**\n   * Reset all planning state back to initial values for another planning pass.\n   * Resets only mutable planning state - graph structure is unchanged.\n   *\n   * This allows replanning the same query graph with different strategies.\n   */\n  resetPlanningState() {\n    for (const j of this.joins) j.reset();\n    for (const fo of this.fanOuts) fo.reset();\n    for (const fi of this.fanIns) fi.reset();\n    for (const c of this.connections) c.reset();\n  }\n\n  /**\n   * Create and register a source (table) in the graph.\n   */\n  addSource(name: string, model: ConnectionCostModel): PlannerSource {\n    assert(\n      !this.#sources.has(name),\n      `Source ${name} already exists in the graph`,\n    );\n    const source = new PlannerSource(name, model);\n    this.#sources.set(name, source);\n    return source;\n  }\n\n  /**\n   * Get a source by table name.\n   */\n  getSource(name: string): PlannerSource {\n    const source = this.#sources.get(name);\n    assert(source !== undefined, `Source ${name} not found in the graph`);\n    return source;\n  }\n\n  /**\n   * Check if a source exists by table name.\n   */\n  hasSource(name: string): boolean {\n    return this.#sources.has(name);\n  }\n\n  /**\n   * Set the terminus (final output) node of the graph.\n   * Constraint propagation starts from this node.\n   */\n  setTerminus(terminus: PlannerTerminus): void {\n    this.#terminus = terminus;\n  }\n\n  /**\n   * Initiate constraint propagation from the terminus node.\n   * This sends constraints up through the graph to update\n   * connection cost estimates.\n   */\n  propagateConstraints(planDebugger?: PlanDebugger): void {\n    assert(\n      this.#terminus !== undefined,\n      'Cannot propagate constraints without a terminus node',\n    );\n    this.#terminus.propagateConstraints(planDebugger);\n  }\n\n  /**\n   * Calculate total cost of the current plan.\n   * Total cost includes both startup cost (one-time, e.g., sorting) and running cost.\n   */\n  getTotalCost(planDebugger?: PlanDebugger): number {\n    const estimate = must(this.#terminus).estimateCost(planDebugger);\n    return estimate.cost + estimate.startupCost;\n  }\n\n  /**\n   * Capture a lightweight snapshot of the current planning state.\n   * Used for backtracking during multi-start greedy search.\n   *\n   * Captures mutable state including pinned flags, join types, and\n   * constraint maps to avoid needing repropagation on restore.\n   *\n   * @returns A snapshot that can be restored via restorePlanningSnapshot()\n   */\n  capturePlanningSnapshot(): PlanState {\n    return {\n      connections: this.connections.map(c => ({\n        limit: c.limit,\n      })),\n      joins: this.joins.map(j => ({type: j.type})),\n      fanOuts: this.fanOuts.map(fo => ({type: fo.type})),\n      fanIns: this.fanIns.map(fi => ({type: fi.type})),\n      connectionConstraints: this.connections.map(c => c.captureConstraints()),\n    };\n  }\n\n  /**\n   * Restore planning state from a previously captured snapshot.\n   * Used for backtracking when a planning attempt fails.\n   *\n   * Restores pinned flags, join types, and constraint maps, eliminating\n   * the need for repropagation.\n   *\n   * @param state - Snapshot created by capturePlanningSnapshot()\n   */\n  restorePlanningSnapshot(state: PlanState): void {\n    this.#validateSnapshotShape(state);\n    this.#restoreConnections(state);\n    this.#restoreJoins(state);\n    this.#restoreFanNodes(state);\n  }\n\n  /**\n   * Validate that snapshot shape matches current graph structure.\n   */\n  #validateSnapshotShape(state: PlanState): void {\n    assert(\n      this.connections.length === state.connections.length,\n      'Plan state mismatch: connections',\n    );\n    assert(\n      this.joins.length === state.joins.length,\n      'Plan state mismatch: joins',\n    );\n    assert(\n      this.fanOuts.length === state.fanOuts.length,\n      'Plan state mismatch: fanOuts',\n    );\n    assert(\n      this.fanIns.length === state.fanIns.length,\n      'Plan state mismatch: fanIns',\n    );\n    assert(\n      this.connections.length === state.connectionConstraints.length,\n      'Plan state mismatch: connectionConstraints',\n    );\n  }\n\n  /**\n   * Restore connection pinned flags, limits, and constraint maps.\n   */\n  #restoreConnections(state: PlanState): void {\n    for (let i = 0; i < this.connections.length; i++) {\n      this.connections[i].limit = state.connections[i].limit;\n      this.connections[i].restoreConstraints(state.connectionConstraints[i]);\n    }\n  }\n\n  /**\n   * Restore join types and pinned flags.\n   */\n  #restoreJoins(state: PlanState): void {\n    for (let i = 0; i < this.joins.length; i++) {\n      const join = this.joins[i];\n      const targetState = state.joins[i];\n\n      // Reset to initial state first\n      join.reset();\n\n      // Apply target state\n      if (targetState.type === 'flipped' && join.type !== 'flipped') {\n        join.flip();\n      }\n      assert(\n        targetState.type === join.type,\n        'join is not in the correct state after reset',\n      );\n    }\n  }\n\n  /**\n   * Restore FanOut and FanIn types.\n   */\n  #restoreFanNodes(state: PlanState): void {\n    for (let i = 0; i < this.fanOuts.length; i++) {\n      const fo = this.fanOuts[i];\n      const targetType = state.fanOuts[i].type;\n      if (targetType === 'UFO' && fo.type === 'FO') {\n        fo.convertToUFO();\n      }\n    }\n\n    for (let i = 0; i < this.fanIns.length; i++) {\n      const fi = this.fanIns[i];\n      const targetType = state.fanIns[i].type;\n      if (targetType === 'UFI' && fi.type === 'FI') {\n        fi.convertToUFI();\n      }\n    }\n  }\n\n  /**\n   * Main planning algorithm using exhaustive join flip enumeration.\n   *\n   * Enumerates all possible flip patterns for flippable joins (2^n for n flippable joins).\n   * Each pattern represents a different query execution plan. We evaluate the cost of each\n   * plan and select the one with the lowest cost.\n   *\n   * Connections are used only for cost estimation - the flip patterns determine the plan.\n   * FanOut/FanIn states (FO/UFO and FI/UFI) are automatically derived from join flip states.\n   *\n   * @param planDebugger - Optional debugger to receive structured events during planning\n   */\n  plan(planDebugger?: PlanDebugger): void {\n    // Get all flippable joins\n    const flippableJoins = this.joins.filter(j => j.isFlippable());\n\n    // Safety check: throw if too many flippable joins\n    if (flippableJoins.length > MAX_FLIPPABLE_JOINS) {\n      throw new PlannerException(\n        'max_flippable_joins',\n        `Query has ${flippableJoins.length} EXISTS checks in a single RELATED call (or in the top level query), which would require ` +\n          `${2 ** flippableJoins.length} plan evaluations. This may be very slow. ` +\n          `Consider simplifying the query or increasing MAX_FLIPPABLE_JOINS (currently set to ${MAX_FLIPPABLE_JOINS}).`,\n      );\n    }\n\n    // Build FO→FI cache once to avoid redundant BFS traversals in each iteration\n    const fofiCache = buildFOFICache(this);\n\n    const numPatterns =\n      flippableJoins.length === 0 ? 0 : 2 ** flippableJoins.length;\n    let bestCost = Infinity;\n    let bestPlan: PlanState | undefined = undefined;\n    let bestAttemptNumber = -1;\n\n    // Enumerate all flip patterns\n    for (let pattern = 0; pattern < numPatterns; pattern++) {\n      // Reset to initial state\n      this.resetPlanningState();\n\n      if (planDebugger) {\n        planDebugger.log({\n          type: 'attempt-start',\n          attemptNumber: pattern,\n          totalAttempts: numPatterns,\n        });\n      }\n\n      // Apply flip pattern (treat pattern as bitmask)\n      // Bit i set to 1 means flip join i\n      for (let i = 0; i < flippableJoins.length; i++) {\n        if (pattern & (1 << i)) {\n          flippableJoins[i].flip();\n        }\n      }\n\n      // Derive FO/UFO and FI/UFI states from join flip states\n      checkAndConvertFOFI(fofiCache);\n\n      // Propagate unlimiting for flipped joins\n      propagateUnlimitForFlippedJoins(this);\n\n      // Propagate constraints through the graph\n      this.propagateConstraints(planDebugger);\n\n      if (planDebugger) {\n        planDebugger.log({\n          type: 'constraints-propagated',\n          attemptNumber: pattern,\n          connectionConstraints: this.connections.map(c => {\n            const constraintCosts = c.getConstraintCostsForDebug();\n            const constraintCostsWithoutFanout: Record<\n              string,\n              Omit<(typeof constraintCosts)[string], 'fanout'>\n            > = {};\n            for (const [key, cost] of Object.entries(constraintCosts)) {\n              constraintCostsWithoutFanout[key] = omitFanout(cost);\n            }\n            return {\n              connection: c.name,\n              constraints: c.getConstraintsForDebug(),\n              constraintCosts: constraintCostsWithoutFanout,\n            };\n          }),\n        });\n      }\n\n      // Evaluate this plan\n      const totalCost = this.getTotalCost(planDebugger);\n\n      if (planDebugger) {\n        planDebugger.log({\n          type: 'plan-complete',\n          attemptNumber: pattern,\n          totalCost,\n          flipPattern: pattern, // Bitmask of which joins are flipped\n          planSnapshot: this.capturePlanningSnapshot(),\n          joinStates: this.joins.map(j => {\n            const info = j.getDebugInfo();\n            return {\n              join: info.name,\n              type: info.type,\n            };\n          }),\n        });\n      }\n\n      // Track best plan\n      if (totalCost < bestCost) {\n        bestCost = totalCost;\n        bestPlan = this.capturePlanningSnapshot();\n        bestAttemptNumber = pattern;\n      }\n    }\n\n    // Restore best plan\n    if (bestPlan) {\n      this.restorePlanningSnapshot(bestPlan);\n      // Propagate constraints to ensure all derived state is consistent\n      this.propagateConstraints(planDebugger);\n\n      if (planDebugger) {\n        planDebugger.log({\n          type: 'best-plan-selected',\n          bestAttemptNumber,\n          totalCost: bestCost,\n          flipPattern: bestAttemptNumber, // The best attempt number is also the flip pattern\n          joinStates: this.joins.map(j => ({\n            join: j.getName(),\n            type: j.type,\n          })),\n        });\n      }\n    } else {\n      assert(\n        numPatterns === 0,\n        'no plan was found but flippable joins did exist!',\n      );\n    }\n  }\n}\n\n/**\n * Build cache of FO→FI relationships and joins between them.\n * Called once at the start of planning to avoid redundant BFS traversals.\n */\nfunction buildFOFICache(graph: PlannerGraph): Map<PlannerFanOut, FOFIInfo> {\n  const cache = new Map<PlannerFanOut, FOFIInfo>();\n\n  for (const fo of graph.fanOuts) {\n    const info = findFIAndJoins(fo);\n    cache.set(fo, info);\n  }\n\n  return cache;\n}\n\n/**\n * Check if any joins downstream of a FanOut (before reaching FanIn) are flipped.\n * If so, convert the FO to UFO and the FI to UFI.\n *\n * This must be called after join flipping and before propagateConstraints.\n */\nfunction checkAndConvertFOFI(fofiCache: Map<PlannerFanOut, FOFIInfo>): void {\n  for (const [fo, info] of fofiCache) {\n    const hasFlippedJoin = info.joinsBetween.some(j => j.type === 'flipped');\n    if (info.fi && hasFlippedJoin) {\n      fo.convertToUFO();\n      info.fi.convertToUFI();\n    }\n  }\n}\n\n/**\n * Traverse from a FanOut through its outputs to find the corresponding FanIn\n * and collect all joins along the way.\n */\nfunction findFIAndJoins(fo: PlannerFanOut): FOFIInfo {\n  const joinsBetween: PlannerJoin[] = [];\n  let fi: PlannerFanIn | undefined = undefined;\n\n  // BFS through FO outputs to find FI and collect joins\n  const queue: PlannerNode[] = [...fo.outputs];\n  const visited = new Set<PlannerNode>();\n\n  while (queue.length > 0) {\n    const node = must(queue.shift());\n    if (visited.has(node)) continue;\n    visited.add(node);\n\n    switch (node.kind) {\n      case 'join':\n        joinsBetween.push(node);\n        queue.push(node.output);\n        break;\n      case 'fan-out':\n        // Nested FO - traverse its outputs\n        queue.push(...node.outputs);\n        break;\n      case 'fan-in':\n        // Found the FI - this is the boundary, don't traverse further\n        fi = node;\n        break;\n      case 'connection':\n        // Shouldn't happen in a well-formed graph\n        break;\n      case 'terminus':\n        // Reached the end without finding FI\n        break;\n    }\n  }\n\n  return {fi, joinsBetween};\n}\n\n/**\n * Propagate unlimiting to all flipped joins in the graph.\n * When a join is flipped, its child becomes the outer loop and should no longer\n * be limited by EXISTS semantics.\n *\n * This must be called after join flipping and before propagateConstraints.\n */\nfunction propagateUnlimitForFlippedJoins(graph: PlannerGraph): void {\n  for (const join of graph.joins) {\n    if (join.type === 'flipped') {\n      join.propagateUnlimit();\n    }\n  }\n}\n"],"names":[],"mappings":"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"}

package/out/zql/src/planner/planner-join.d.ts

@@ -1,5 +1,23 @@
 import { type PlannerConstraint } from './planner-constraint.ts';
+import type { PlanDebugger } from './planner-debug.ts';
 import type { CostEstimate, JoinOrConnection, PlannerNode } from './planner-node.ts';
+import type { PlannerTerminus } from './planner-terminus.ts';
+/**
+ * Semi-join overhead multiplier.
+ *
+ * Semi-joins represent correlated subqueries (EXISTS checks) which have
+ * execution overhead compared to flipped joins, even when logical row counts
+ * are identical. This overhead comes from:
+ * - Need to execute a separate correlation check for each parent row
+ * - Cannot leverage combined constraint checking as effectively as flipped joins
+ *
+ * A multiplier of 1.5 means semi-joins are estimated to be ~50% more expensive
+ * than equivalent flipped joins, which empirically matches observed performance
+ * differences in production workloads (e.g., 1.7x in zbugs benchmarks).
+ *
+ * Flipped joins have a different overhead in that they become unlimited. This
+ * is accounted for when propagating unlimits rather than here.
+ */
 /**
  * Represents a join between two data streams (parent and child).
  *
@@ -32,7 +50,7 @@ export declare class PlannerJoin {
     #private;
     readonly kind: "join";
     readonly planId: number;
-    constructor(parent: PlannerNode, child: PlannerNode, parentConstraint: PlannerConstraint, childConstraint: PlannerConstraint, flippable: boolean, planId: number);
+    constructor(parent: Exclude<PlannerNode, PlannerTerminus>, child: Exclude<PlannerNode, PlannerTerminus>, parentConstraint: PlannerConstraint, childConstraint: PlannerConstraint, flippable: boolean, planId: number, initialType?: 'semi' | 'flipped');
     setOutput(node: PlannerNode): void;
     get output(): PlannerNode;
     closestJoinOrSource(): JoinOrConnection;
@@ -41,9 +59,13 @@ export declare class PlannerJoin {
     get type(): 'semi' | 'flipped';
     isFlippable(): boolean;
     /**
-     * Propagate unlimiting through the child subgraph when this join is flipped.
-     * When a join is flipped, the child becomes the outer loop and should produce
-     * all rows rather than stopping at an EXISTS limit.
+     * Propagate unlimiting when this join is flipped.
+     * When a join is flipped:
+     * 1. Child becomes outer loop → produces all rows (unlimited)
+     * 2. Parent is fetched once per child row → effectively unlimited
+     *
+     * Example: If child produces 896 rows, parent is fetched 896 times.
+     * Even if each fetch returns 1 row, parent produces 896 total rows.
      *
      * Propagation rules:
      * - Connection: call unlimit()
@@ -54,13 +76,50 @@ export declare class PlannerJoin {
     propagateUnlimit(): void;
     /**
      * Called when a parent join is flipped and this join is part of its child subgraph.
-     * - Semi-join: continue propagation to parent (the outer loop)
-     * - Flipped join: stop propagation (already unlimited when it was flipped)
+     * Continue propagation to parent (the outer loop).
+     * If we are hitting a semi-join, the parent drives.
+     * If we are hitting a flip-join, well now we have to unlimit its parent too!
      */
     propagateUnlimitFromFlippedJoin(): void;
-    propagateConstraints(branchPattern: number[], constraint: PlannerConstraint | undefined): void;
+    propagateConstraints(branchPattern: number[], constraint: PlannerConstraint | undefined, from?: PlannerNode, planDebugger?: PlanDebugger): void;
     reset(): void;
-    estimateCost(branchPattern?: number[]): CostEstimate;
+    estimateCost(
+    /**
+     * This argument is to deal with consecutive `andExists` statements.
+     * Each one will constrain how often a parent row passes all constraints.
+     * This means that we have to scan more and more parent rows the more
+     * constraints we add.
+     *
+     * DownstreamChildSelectivity factors in fanout factor
+     * from parent -> child
+     */
+    downstreamChildSelectivity: number, 
+    /**
+     * branchPattern uniquely identifies OR branches in the graph.
+     * Each path through an OR will have unique constraints to apply to the source
+     * connection.
+     * branchPattern allows us to correlate a path through the graph
+     * to the constraints that should be applied for that path.
+     *
+     * Example graph:
+     *  UFO
+     * /  \
+     * J1   J2
+     * \  /
+     *  UFI
+     *
+     * J1 and J2 are joins inside an OR (FO).
+     * branchPattern [0] = path through J1
+     * branchPattern [1] = path through J2
+     *
+     * If many ORs are nested, branchPattern will have multiple elements
+     * representing each level of OR.
+     *
+     * If no joins are flipped within the `OR`, then only a single
+     * branchPattern element will be needed, as FO represents all sub-joins
+     * as a single path.
+     */
+    branchPattern: number[], planDebugger?: PlanDebugger): CostEstimate;
     /**
      * Get a human-readable name for this join for debugging.
      * Format: "parentName ⋈ childName"

package/out/zql/src/planner/planner-join.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"planner-join.d.ts","sourceRoot":"","sources":["../../../../../zql/src/planner/planner-join.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAoB3B;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,WAAW;;IACtB,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAU;IAOhC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAOtB,MAAM,EAAE,WAAW,EACnB,KAAK,EAAE,WAAW,EAClB,gBAAgB,EAAE,iBAAiB,EACnC,eAAe,EAAE,iBAAiB,EAClC,SAAS,EAAE,OAAO,EAClB,MAAM,EAAE,MAAM;IAWhB,SAAS,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;IAIlC,IAAI,MAAM,IAAI,WAAW,CAGxB;IAED,mBAAmB,IAAI,gBAAgB;IAIvC,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAWtC,IAAI,IAAI,IAAI;IAUZ,IAAI,IAAI,IAAI,MAAM,GAAG,SAAS,CAE7B;IACD,WAAW,IAAI,OAAO;IAItB;;;;;;;;;;OAUG;IACH,gBAAgB,IAAI,IAAI;IAKxB;;;;OAIG;IACH,+BAA+B,IAAI,IAAI;IAOvC,oBAAoB,CAClB,aAAa,EAAE,MAAM,EAAE,EACvB,UAAU,EAAE,iBAAiB,GAAG,SAAS,GACxC,IAAI;IA2BP,KAAK,IAAI,IAAI;IAIb,YAAY,CAAC,aAAa,CAAC,EAAE,MAAM,EAAE,GAAG,YAAY;IAkDpD;;;OAGG;IACH,OAAO,IAAI,MAAM;IAMjB;;OAEG;IACH,YAAY,IAAI;QACd,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;QACzB,MAAM,EAAE,MAAM,CAAC;KAChB;CAOF;AAED,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAI5B"}
+{"version":3,"file":"planner-join.d.ts","sourceRoot":"","sources":["../../../../../zql/src/planner/planner-join.ts"],"names":[],"mappings":"AACA,OAAO,EAEL,KAAK,iBAAiB,EACvB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAErD,OAAO,KAAK,EACV,YAAY,EACZ,gBAAgB,EAChB,WAAW,EACZ,MAAM,mBAAmB,CAAC;AAC3B,OAAO,KAAK,EAAC,eAAe,EAAC,MAAM,uBAAuB,CAAC;AAoC3D;;;;;;;;;;;;;;;GAeG;AAGH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,WAAW;;IACtB,QAAQ,CAAC,IAAI,EAAG,MAAM,CAAU;IAOhC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAQtB,MAAM,EAAE,OAAO,CAAC,WAAW,EAAE,eAAe,CAAC,EAC7C,KAAK,EAAE,OAAO,CAAC,WAAW,EAAE,eAAe,CAAC,EAC5C,gBAAgB,EAAE,iBAAiB,EACnC,eAAe,EAAE,iBAAiB,EAClC,SAAS,EAAE,OAAO,EAClB,MAAM,EAAE,MAAM,EACd,WAAW,GAAE,MAAM,GAAG,SAAkB;IAY1C,SAAS,CAAC,IAAI,EAAE,WAAW,GAAG,IAAI;IAIlC,IAAI,MAAM,IAAI,WAAW,CAGxB;IAED,mBAAmB,IAAI,gBAAgB;IAIvC,YAAY,CAAC,KAAK,EAAE,WAAW,GAAG,IAAI;IAWtC,IAAI,IAAI,IAAI;IAUZ,IAAI,IAAI,IAAI,MAAM,GAAG,SAAS,CAE7B;IACD,WAAW,IAAI,OAAO;IAItB;;;;;;;;;;;;;;OAcG;IACH,gBAAgB,IAAI,IAAI;IAMxB;;;;;OAKG;IACH,+BAA+B,IAAI,IAAI;IAIvC,oBAAoB,CAClB,aAAa,EAAE,MAAM,EAAE,EACvB,UAAU,EAAE,iBAAiB,GAAG,SAAS,EACzC,IAAI,CAAC,EAAE,WAAW,EAClB,YAAY,CAAC,EAAE,YAAY,GAC1B,IAAI;IAuDP,KAAK,IAAI,IAAI;IAIb,YAAY;IACV;;;;;;;;OAQG;IACH,0BAA0B,EAAE,MAAM;IAClC;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,aAAa,EAAE,MAAM,EAAE,EACvB,YAAY,CAAC,EAAE,YAAY,GAC1B,YAAY;IAsGf;;;OAGG;IACH,OAAO,IAAI,MAAM;IAMjB;;OAEG;IACH,YAAY,IAAI;QACd,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,GAAG,SAAS,CAAC;QACzB,MAAM,EAAE,MAAM,CAAC;KAChB;CAOF;AAED,qBAAa,oBAAqB,SAAQ,KAAK;gBACjC,OAAO,EAAE,MAAM;CAI5B"}

package/out/zql/src/planner/planner-join.js

@@ -1,246 +1,244 @@
 import { assert } from "../../../shared/src/asserts.js";
-import { mergeConstraints, } from "./planner-constraint.js";
-/**
- * Semi-join overhead multiplier.
- *
- * Semi-joins represent correlated subqueries (EXISTS checks) which have
- * execution overhead compared to flipped joins, even when logical row counts
- * are identical. This overhead comes from:
- * - Need to execute a separate correlation check for each parent row
- * - Cannot leverage combined constraint checking as effectively as flipped joins
- *
- * A multiplier of 1.5 means semi-joins are estimated to be ~50% more expensive
- * than equivalent flipped joins, which empirically matches observed performance
- * differences in production workloads (e.g., 1.7x in zbugs benchmarks).
- *
- * Flipped joins have a different overhead in that they become unlimited. This
- * is accounted for when propagating unlimits rather than here.
- */
-const SEMI_JOIN_OVERHEAD_MULTIPLIER = 1.5;
-/**
- * Represents a join between two data streams (parent and child).
- *
- * # Dual-State Pattern
- * Like all planner nodes, PlannerJoin separates:
- * 1. IMMUTABLE STRUCTURE: Parent/child nodes, constraints, flippability
- * 2. MUTABLE STATE: Join type (semi/flipped), pinned status
- *
- * # Join Flipping
- * A join can be in two states:
- * - 'semi': Parent is outer loop, child is inner (semi-join for EXISTS)
- * - 'flipped': Child is outer loop, parent is inner
- *
- * Flipping is the key optimization: choosing which table scans first.
- * NOT EXISTS joins cannot be flipped (#flippable = false).
- *
- * # Constraint Propagation
- * - Semi-join: Sends childConstraint to child, forwards received constraints to parent
- * - Flipped join: Sends undefined to child, merges parentConstraint with received to parent
- * - Unpinned join: Only forwards constraints to parent (doesn't constrain child yet)
- *
- * # Lifecycle
- * 1. Construct with immutable structure (parent, child, constraints, flippability)
- * 2. Wire to output node during graph construction
- * 3. Planning calls flipIfNeeded() based on connection selection order
- * 4. pin() locks the join type once chosen
- * 5. reset() clears mutable state (type → 'semi', pinned → false)
- */
-export class PlannerJoin {
-    kind = 'join';
-    #parent;
-    #child;
-    #parentConstraint;
-    #childConstraint;
-    #flippable;
-    planId;
-    #output; // Set once during graph construction
-    // Reset between planning attempts
-    #type;
-    constructor(parent, child, parentConstraint, childConstraint, flippable, planId) {
-        this.#type = 'semi';
-        this.#parent = parent;
-        this.#child = child;
-        this.#childConstraint = childConstraint;
-        this.#parentConstraint = parentConstraint;
-        this.#flippable = flippable;
-        this.planId = planId;
-    }
-    setOutput(node) {
-        this.#output = node;
-    }
-    get output() {
-        assert(this.#output !== undefined, 'Output not set');
-        return this.#output;
-    }
-    closestJoinOrSource() {
-        return 'join';
-    }
-    flipIfNeeded(input) {
-        if (input === this.#child) {
-            this.flip();
-        }
-        else {
-            assert(input === this.#parent, 'Can only flip a join from one of its inputs');
-        }
-    }
-    flip() {
-        assert(this.#type === 'semi', 'Can only flip a semi-join');
-        if (!this.#flippable) {
-            throw new UnflippableJoinError('Cannot flip a non-flippable join (e.g., NOT EXISTS)');
-        }
-        this.#type = 'flipped';
-    }
-    get type() {
-        return this.#type;
-    }
-    isFlippable() {
-        return this.#flippable;
-    }
-    /**
-     * Propagate unlimiting through the child subgraph when this join is flipped.
-     * When a join is flipped, the child becomes the outer loop and should produce
-     * all rows rather than stopping at an EXISTS limit.
-     *
-     * Propagation rules:
-     * - Connection: call unlimit()
-     * - Semi-join: continue to parent (outer loop)
-     * - Flipped join: stop (already unlimited when it was flipped)
-     * - Fan-out/Fan-in: propagate to all inputs
-     */
-    propagateUnlimit() {
-        assert(this.#type === 'flipped', 'Can only unlimit a flipped join');
-        propagateUnlimitToNode(this.#child);
-    }
-    /**
-     * Called when a parent join is flipped and this join is part of its child subgraph.
-     * - Semi-join: continue propagation to parent (the outer loop)
-     * - Flipped join: stop propagation (already unlimited when it was flipped)
-     */
-    propagateUnlimitFromFlippedJoin() {
-        if (this.#type === 'semi') {
-            propagateUnlimitToNode(this.#parent);
-        }
-        // For flipped joins, stop propagation
-    }
-    propagateConstraints(branchPattern, constraint) {
-        if (this.#type === 'semi') {
-            // A semi-join always has constraints for its child.
-            // They are defined by the correlation between parent and child.
-            this.#child.propagateConstraints(branchPattern, this.#childConstraint, this);
-            // A semi-join forwards constraints to its parent.
-            this.#parent.propagateConstraints(branchPattern, constraint, this);
-        }
-        else if (this.#type === 'flipped') {
-            // A flipped join has no constraints to pass to its child.
-            // It is a standalone fetch that is relying on the filters of the child
-            // connection to do the heavy work.
-            this.#child.propagateConstraints(branchPattern, undefined, this);
-            // A flipped join will have constraints to send to its parent.
-            // - The constraints its output sent
-            // - The constraints its child creates
-            this.#parent.propagateConstraints(branchPattern, mergeConstraints(constraint, this.#parentConstraint), this);
-        }
-    }
-    reset() {
-        this.#type = 'semi';
-    }
-    estimateCost(branchPattern) {
-        const parentCost = this.#parent.estimateCost(branchPattern);
-        const childCost = this.#child.estimateCost(branchPattern);
-        let scanEst = parentCost.rows;
-        if (this.#type === 'semi' && parentCost.limit !== undefined) {
-            if (childCost.selectivity !== 0) {
-                scanEst = Math.min(scanEst, parentCost.limit / childCost.selectivity);
-            }
-        }
-        if (this.#parent.closestJoinOrSource() === 'join') {
-            // if the parent is a join, we're in a pipeline rather than nesting of joins.
-            const pipelineCost = this.#type === 'flipped'
-                ? childCost.startupCost +
-                    childCost.runningCost *
-                        (parentCost.startupCost + parentCost.runningCost)
-                : parentCost.runningCost +
-                    SEMI_JOIN_OVERHEAD_MULTIPLIER *
-                        scanEst *
-                        (childCost.startupCost + childCost.runningCost);
-            return {
-                rows: parentCost.rows,
-                runningCost: pipelineCost,
-                startupCost: parentCost.startupCost,
-                selectivity: parentCost.selectivity,
-                limit: parentCost.limit,
-            };
-        }
-        // if the parent is a source, we're in a nested loop join
-        const nestedLoopCost = this.#type === 'flipped'
-            ? childCost.runningCost *
-                (parentCost.startupCost + parentCost.runningCost)
-            : SEMI_JOIN_OVERHEAD_MULTIPLIER *
-                scanEst *
-                (childCost.startupCost + childCost.runningCost);
-        return {
-            rows: parentCost.rows,
-            runningCost: nestedLoopCost,
-            startupCost: parentCost.startupCost,
-            selectivity: parentCost.selectivity,
-            limit: parentCost.limit,
-        };
-    }
-    /**
-     * Get a human-readable name for this join for debugging.
-     * Format: "parentName ⋈ childName"
-     */
-    getName() {
-        const parentName = getNodeName(this.#parent);
-        const childName = getNodeName(this.#child);
-        return `${parentName} ⋈ ${childName}`;
-    }
-    /**
-     * Get debug information about this join's state.
-     */
-    getDebugInfo() {
-        return {
-            name: this.getName(),
-            type: this.#type,
-            planId: this.planId,
-        };
-    }
+import { mergeConstraints } from "./planner-constraint.js";
+import { omitFanout } from "./planner-node.js";
+function translateConstraintsForFlippedJoin(incomingConstraint, parentConstraint, childConstraint) {
+  if (!incomingConstraint) return void 0;
+  const parentKeys = Object.keys(parentConstraint);
+  const childKeys = Object.keys(childConstraint);
+  const translated = {};
+  for (const [key, value] of Object.entries(incomingConstraint)) {
+    const index = parentKeys.indexOf(key);
+    if (index !== -1) {
+      translated[childKeys[index]] = value;
+    }
+  }
+  return Object.keys(translated).length > 0 ? translated : void 0;
 }
-export class UnflippableJoinError extends Error {
-    constructor(message) {
-        super(message);
-        this.name = 'UnflippableJoinError';
-    }
+class PlannerJoin {
+  kind = "join";
+  #parent;
+  #child;
+  #parentConstraint;
+  #childConstraint;
+  #flippable;
+  planId;
+  #output;
+  // Set once during graph construction
+  // Reset between planning attempts
+  #type;
+  #initialType;
+  constructor(parent, child, parentConstraint, childConstraint, flippable, planId, initialType = "semi") {
+    this.#type = initialType;
+    this.#initialType = initialType;
+    this.#parent = parent;
+    this.#child = child;
+    this.#childConstraint = childConstraint;
+    this.#parentConstraint = parentConstraint;
+    this.#flippable = flippable;
+    this.planId = planId;
+  }
+  setOutput(node) {
+    this.#output = node;
+  }
+  get output() {
+    assert(this.#output !== void 0, "Output not set");
+    return this.#output;
+  }
+  closestJoinOrSource() {
+    return "join";
+  }
+  flipIfNeeded(input) {
+    if (input === this.#child) {
+      this.flip();
+    } else {
+      assert(
+        input === this.#parent,
+        "Can only flip a join from one of its inputs"
+      );
+    }
+  }
+  flip() {
+    assert(this.#type === "semi", "Can only flip a semi-join");
+    if (!this.#flippable) {
+      throw new UnflippableJoinError(
+        "Cannot flip a non-flippable join (e.g., NOT EXISTS)"
+      );
+    }
+    this.#type = "flipped";
+  }
+  get type() {
+    return this.#type;
+  }
+  isFlippable() {
+    return this.#flippable;
+  }
+  /**
+   * Propagate unlimiting when this join is flipped.
+   * When a join is flipped:
+   * 1. Child becomes outer loop → produces all rows (unlimited)
+   * 2. Parent is fetched once per child row → effectively unlimited
+   *
+   * Example: If child produces 896 rows, parent is fetched 896 times.
+   * Even if each fetch returns 1 row, parent produces 896 total rows.
+   *
+   * Propagation rules:
+   * - Connection: call unlimit()
+   * - Semi-join: continue to parent (outer loop)
+   * - Flipped join: stop (already unlimited when it was flipped)
+   * - Fan-out/Fan-in: propagate to all inputs
+   */
+  propagateUnlimit() {
+    assert(this.#type === "flipped", "Can only unlimit a flipped join");
+    this.#child.propagateUnlimitFromFlippedJoin();
+  }
+  /**
+   * Called when a parent join is flipped and this join is part of its child subgraph.
+   * Continue propagation to parent (the outer loop).
+   * If we are hitting a semi-join, the parent drives.
+   * If we are hitting a flip-join, well now we have to unlimit its parent too!
+   */
+  propagateUnlimitFromFlippedJoin() {
+    this.#parent.propagateUnlimitFromFlippedJoin();
+  }
+  propagateConstraints(branchPattern, constraint, from, planDebugger) {
+    planDebugger?.log({
+      type: "node-constraint",
+      nodeType: "join",
+      node: this.getName(),
+      branchPattern,
+      constraint,
+      from: from ? getNodeName(from) : "unknown"
+    });
+    if (this.#type === "semi") {
+      this.#child.propagateConstraints(
+        branchPattern,
+        this.#childConstraint,
+        this,
+        planDebugger
+      );
+      this.#parent.propagateConstraints(
+        branchPattern,
+        constraint,
+        this,
+        planDebugger
+      );
+    } else if (this.#type === "flipped") {
+      const translatedConstraint = translateConstraintsForFlippedJoin(
+        constraint,
+        this.#parentConstraint,
+        this.#childConstraint
+      );
+      this.#child.propagateConstraints(
+        branchPattern,
+        translatedConstraint,
+        this,
+        planDebugger
+      );
+      this.#parent.propagateConstraints(
+        branchPattern,
+        mergeConstraints(constraint, this.#parentConstraint),
+        this,
+        planDebugger
+      );
+    }
+  }
+  reset() {
+    this.#type = this.#initialType;
+  }
+  estimateCost(downstreamChildSelectivity, branchPattern, planDebugger) {
+    const child = this.#child.estimateCost(1, branchPattern, planDebugger);
+    const fanoutFactor = child.fanout(Object.keys(this.#childConstraint));
+    const scaledChildSelectivity = 1 - Math.pow(1 - child.selectivity, fanoutFactor.fanout);
+    const parent = this.#parent.estimateCost(
+      // Selectivity flows up the graph from child to parent
+      // so we can determine the total selectivity of all ANDed exists checks.
+      this.#type === "flipped" ? 1 * downstreamChildSelectivity : scaledChildSelectivity * downstreamChildSelectivity,
+      branchPattern,
+      planDebugger
+    );
+    let costEstimate;
+    if (this.type === "semi") {
+      costEstimate = {
+        startupCost: parent.startupCost,
+        scanEst: parent.limit === void 0 ? parent.returnedRows : Math.min(
+          parent.returnedRows,
+          downstreamChildSelectivity === 0 ? 0 : parent.limit / downstreamChildSelectivity
+        ),
+        cost: parent.cost + parent.scanEst * (child.startupCost + child.cost + child.scanEst),
+        returnedRows: parent.returnedRows * child.selectivity,
+        selectivity: child.selectivity * parent.selectivity,
+        limit: parent.limit,
+        fanout: parent.fanout
+      };
+    } else {
+      costEstimate = {
+        startupCost: child.startupCost,
+        scanEst: parent.limit === void 0 ? parent.returnedRows * child.returnedRows : Math.min(
+          parent.returnedRows * child.returnedRows,
+          downstreamChildSelectivity === 0 ? 0 : parent.limit / downstreamChildSelectivity
+        ),
+        cost: child.cost + child.scanEst * (parent.startupCost + parent.cost + parent.scanEst),
+        returnedRows: parent.returnedRows * child.returnedRows * child.selectivity,
+        selectivity: parent.selectivity * child.selectivity,
+        limit: parent.limit,
+        fanout: parent.fanout
+      };
+    }
+    if (planDebugger) {
+      planDebugger.log({
+        type: "node-cost",
+        nodeType: "join",
+        node: this.getName(),
+        branchPattern,
+        downstreamChildSelectivity,
+        costEstimate: omitFanout(costEstimate),
+        joinType: this.#type
+      });
+    }
+    return costEstimate;
+  }
+  /**
+   * Get a human-readable name for this join for debugging.
+   * Format: "parentName ⋈ childName"
+   */
+  getName() {
+    const parentName = getNodeName(this.#parent);
+    const childName = getNodeName(this.#child);
+    return `${parentName} ⋈ ${childName}`;
+  }
+  /**
+   * Get debug information about this join's state.
+   */
+  getDebugInfo() {
+    return {
+      name: this.getName(),
+      type: this.#type,
+      planId: this.planId
+    };
+  }
 }
-/**
- * Get a human-readable name for any planner node.
- * Used for debugging and tracing.
- */
-function getNodeName(node) {
-    switch (node.kind) {
-        case 'connection':
-            return node.name;
-        case 'join':
-            return node.getName();
-        case 'fan-out':
-            return 'FO';
-        case 'fan-in':
-            return 'FI';
-        case 'terminus':
-            return 'terminus';
-    }
+class UnflippableJoinError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "UnflippableJoinError";
+  }
 }
-/**
- * Propagate unlimiting through a node in the planner graph.
- * Called recursively to unlimit all nodes in a subgraph when a join is flipped.
- *
- * This calls the propagateUnlimitFromFlippedJoin() method on each node,
- * which implements the type-specific logic.
- */
-function propagateUnlimitToNode(node) {
-    if ('propagateUnlimitFromFlippedJoin' in node &&
-        typeof node.propagateUnlimitFromFlippedJoin === 'function') {
-        node.propagateUnlimitFromFlippedJoin();
-    }
+function getNodeName(node) {
+  switch (node.kind) {
+    case "connection":
+      return node.name;
+    case "join":
+      return node.getName();
+    case "fan-out":
+      return "FO";
+    case "fan-in":
+      return "FI";
+    case "terminus":
+      return "terminus";
+  }
 }
-//# sourceMappingURL=planner-join.js.map
+export {
+  PlannerJoin,
+  UnflippableJoinError
+};
+//# sourceMappingURL=planner-join.js.map