Remove unused predicate helper functions

Author: kevin-dp

packages/db/src/query/index.ts

@@ -61,14 +61,11 @@ export { type LiveQueryCollectionUtils } from "./live/collection-config-builder.
 // Predicate utilities for predicate push-down
 export {
   isWhereSubset,
-  intersectWherePredicates,
   unionWherePredicates,
   minusWherePredicates,
   isOrderBySubset,
   isLimitSubset,
   isPredicateSubset,
-  intersectPredicates,
-  unionPredicates,
 } from "./predicate-utils.js"
 
 export { DeduplicatedLoadSubset } from "./subset-dedupe.js"

packages/db/src/query/predicate-utils.ts

@@ -231,34 +231,6 @@ function combineWherePredicates(
   } as BasicExpression<boolean>
 }
 
-/**
- * Combine multiple where predicates with AND logic (intersection).
- * Returns a predicate that is satisfied only when all input predicates are satisfied.
- * Simplifies when possible (e.g., age > 10 AND age > 20 → age > 20).
- * Returns a false literal if predicates are contradictory (empty set).
- *
- * @example
- * // Take most restrictive
- * intersectWherePredicates([gt(ref('age'), val(10)), gt(ref('age'), val(20))]) // age > 20
- *
- * @example
- * // Different fields combine with AND
- * intersectWherePredicates([gt(ref('age'), val(10)), eq(ref('status'), val('active'))])
- * // age > 10 AND status = 'active'
- *
- * @example
- * // Contradictory predicates return false
- * intersectWherePredicates([eq(ref('age'), val(5)), eq(ref('age'), val(6))])
- * // {type: 'val', value: false}
- *
- * @param predicates - Array of where predicates to intersect
- * @returns Combined predicate representing the intersection, or false literal for empty set
- */
-export function intersectWherePredicates(
-  predicates: Array<BasicExpression<boolean>>
-): BasicExpression<boolean> {
-  return combineWherePredicates(predicates, `and`, intersectSameFieldPredicates)
-}
 
 /**
  * Combine multiple where predicates with OR logic (union).
@@ -783,84 +755,7 @@ export function isPredicateSubset(
   )
 }
 
-/**
- * Helper to combine predicates (where + orderBy + limit)
- */
-function combinePredicates(
-  predicates: Array<LoadSubsetOptions>,
-  operation: `intersect` | `union`,
-  whereFn: (
-    clauses: Array<BasicExpression<boolean>>
-  ) => BasicExpression<boolean>
-): LoadSubsetOptions {
-  if (predicates.length === 0) {
-    return {}
-  }
-
-  if (predicates.length === 1) {
-    return predicates[0]!
-  }
-
-  // Combine where clauses
-  const whereClauses = predicates
-    .map((p) => p.where)
-    .filter((w): w is BasicExpression<boolean> => w !== undefined)
-
-  const mergedWhere =
-    whereClauses.length > 0 ? whereFn(whereClauses) : undefined
-
-  // OrderBy logic differs by operation
-  const mergedOrderBy =
-    operation === `intersect`
-      ? predicates.find((p) => p.orderBy && p.orderBy.length > 0)?.orderBy
-      : undefined // Union: different orderings can't be combined
-
-  // Limit logic
-  const limits = predicates
-    .map((p) => p.limit)
-    .filter((l): l is number => l !== undefined)
-
-  const mergedLimit =
-    operation === `intersect`
-      ? limits.length === 0
-        ? undefined
-        : Math.min(...limits) // All unlimited = unlimited, else min
-      : limits.length === predicates.length && limits.length > 0
-        ? Math.min(...limits)
-        : undefined // Min only if all have limits
-
-  return {
-    where: mergedWhere,
-    orderBy: mergedOrderBy,
-    limit: mergedLimit,
-  }
-}
-
-/**
- * Merge multiple predicates by intersecting their where clauses.
- * Intersection semantics: returns predicate satisfied by data matching ALL input predicates.
- * For limits, this means the MINIMUM (most restrictive) limit.
- *
- * @param predicates - Array of predicates to merge
- * @returns Combined predicate representing the intersection
- */
-export function intersectPredicates(
-  predicates: Array<LoadSubsetOptions>
-): LoadSubsetOptions {
-  return combinePredicates(predicates, `intersect`, intersectWherePredicates)
-}
 
-/**
- * Merge multiple predicates by unioning their where clauses.
- *
- * @param predicates - Array of predicates to merge
- * @returns Combined predicate
- */
-export function unionPredicates(
-  predicates: Array<LoadSubsetOptions>
-): LoadSubsetOptions {
-  return combinePredicates(predicates, `union`, unionWherePredicates)
-}
 
 // ============================================================================
 // Helper functions
@@ -1107,25 +1002,6 @@ function arrayIncludesWithSet(
   return array.some((v) => areValuesEqual(v, value))
 }
 
-/**
- * Intersect two arrays, with optional pre-built Set for optimization.
- * The set2 is cached in InField during extraction and reused for all operations.
- */
-function intersectArraysWithSet(
-  arr1: Array<any>,
-  arr2: Array<any>,
-  set2: Set<any> | null
-): Array<any> {
-  // Fast path: use pre-built Set for O(n) intersection
-  if (set2) {
-    // If set2 exists, arr2 contains ONLY primitives (that's when we build the Set).
-    // So we can skip non-primitives in arr1 immediately - they can't be in arr2.
-    return arr1.filter((v) => isPrimitive(v) && set2.has(v))
-  }
-
-  // Fallback: use areValuesEqual for all comparisons
-  return arr1.filter((v) => arr2.some((v2) => areValuesEqual(v, v2)))
-}
 
 /**
  * Get the maximum of two values, handling both numbers and Dates
@@ -1334,202 +1210,6 @@ function groupPredicatesByField(
   return groups
 }
 
-function intersectSameFieldPredicates(
-  predicates: Array<BasicExpression<boolean>>
-): BasicExpression<boolean> {
-  if (predicates.length === 1) {
-    return predicates[0]!
-  }
-
-  // Try to extract range constraints
-  let minGt: number | null = null
-  let minGte: number | null = null
-  let maxLt: number | null = null
-  let maxLte: number | null = null
-  const eqValues: Set<any> = new Set()
-  const inFields: Array<InField> = [] // Store full InField objects to access cached data
-  const otherPredicates: Array<BasicExpression<boolean>> = []
-
-  for (const pred of predicates) {
-    if (pred.type === `func`) {
-      const func = pred as Func
-      const field = extractComparisonField(func)
-
-      if (field) {
-        const value = field.value
-        if (func.name === `gt`) {
-          minGt = minGt === null ? value : maxValue(minGt, value)
-        } else if (func.name === `gte`) {
-          minGte = minGte === null ? value : maxValue(minGte, value)
-        } else if (func.name === `lt`) {
-          maxLt = maxLt === null ? value : minValue(maxLt, value)
-        } else if (func.name === `lte`) {
-          maxLte = maxLte === null ? value : minValue(maxLte, value)
-        } else if (func.name === `eq`) {
-          eqValues.add(value)
-        } else {
-          otherPredicates.push(pred)
-        }
-      } else {
-        const inField = extractInField(func)
-        if (inField) {
-          inFields.push(inField) // Store full InField with cached primitiveSet
-        } else {
-          otherPredicates.push(pred)
-        }
-      }
-    } else {
-      otherPredicates.push(pred)
-    }
-  }
-
-  // Check for conflicting equality values (field = 5 AND field = 6 → empty set)
-  // Need to use areValuesEqual for proper Date/object comparison
-  const uniqueEqValues: Array<any> = []
-  for (const value of eqValues) {
-    if (!uniqueEqValues.some((v) => areValuesEqual(v, value))) {
-      uniqueEqValues.push(value)
-    }
-  }
-  if (uniqueEqValues.length > 1) {
-    return { type: `val`, value: false } as BasicExpression<boolean>
-  }
-
-  // If we have an equality, that's the most restrictive
-  const eqValue = uniqueEqValues.length === 1 ? uniqueEqValues[0] : null
-  if (eqValue !== null) {
-    // Check if it satisfies the range constraints
-    if (minGt !== null && !(eqValue > minGt)) {
-      return { type: `val`, value: false } as BasicExpression<boolean>
-    }
-    if (minGte !== null && !(eqValue >= minGte)) {
-      return { type: `val`, value: false } as BasicExpression<boolean>
-    }
-    if (maxLt !== null && !(eqValue < maxLt)) {
-      return { type: `val`, value: false } as BasicExpression<boolean>
-    }
-    if (maxLte !== null && !(eqValue <= maxLte)) {
-      return { type: `val`, value: false } as BasicExpression<boolean>
-    }
-
-    // Check if it's in all IN sets (use cached primitive sets and metadata)
-    for (const inField of inFields) {
-      if (
-        !arrayIncludesWithSet(
-          inField.values,
-          eqValue,
-          inField.primitiveSet ?? null,
-          inField.areAllPrimitives
-        )
-      ) {
-        return { type: `val`, value: false } as BasicExpression<boolean>
-      }
-    }
-
-    // Return just the equality (use areValuesEqual for Date support)
-    return predicates.find((p) => {
-      if (p.type === `func`) {
-        const f = p as Func
-        const field = extractComparisonField(f)
-        return f.name === `eq` && field && areValuesEqual(field.value, eqValue)
-      }
-      return false
-    })!
-  }
-
-  // Handle intersection of multiple IN clauses (use cached primitive sets)
-  let intersectedInValues: Array<any> | null = null
-  if (inFields.length > 0) {
-    // All primitive sets already cached in inFields from extraction
-    intersectedInValues = [...inFields[0]!.values]
-    for (let i = 1; i < inFields.length; i++) {
-      const currentField = inFields[i]!
-      intersectedInValues = intersectArraysWithSet(
-        intersectedInValues,
-        currentField.values,
-        currentField.primitiveSet ?? null
-      )
-      // Early exit if intersection becomes empty
-      if (intersectedInValues.length === 0) {
-        return { type: `val`, value: false } as BasicExpression<boolean>
-      }
-    }
-  }
-
-  // Build the most restrictive range
-  const result: Array<BasicExpression<boolean>> = []
-
-  // Choose the most restrictive lower bound
-  if (minGt !== null && minGte !== null) {
-    // If we have both > and >=, use > if it's more restrictive
-    const pred =
-      minGt >= minGte
-        ? findPredicateWithOperator(predicates, `gt`, minGt)
-        : findPredicateWithOperator(predicates, `gte`, minGte)
-    if (pred) result.push(pred)
-  } else if (minGt !== null) {
-    const pred = findPredicateWithOperator(predicates, `gt`, minGt)
-    if (pred) result.push(pred)
-  } else if (minGte !== null) {
-    const pred = findPredicateWithOperator(predicates, `gte`, minGte)
-    if (pred) result.push(pred)
-  }
-
-  // Choose the most restrictive upper bound
-  if (maxLt !== null && maxLte !== null) {
-    const pred =
-      maxLt <= maxLte
-        ? findPredicateWithOperator(predicates, `lt`, maxLt)
-        : findPredicateWithOperator(predicates, `lte`, maxLte)
-    if (pred) result.push(pred)
-  } else if (maxLt !== null) {
-    const pred = findPredicateWithOperator(predicates, `lt`, maxLt)
-    if (pred) result.push(pred)
-  } else if (maxLte !== null) {
-    const pred = findPredicateWithOperator(predicates, `lte`, maxLte)
-    if (pred) result.push(pred)
-  }
-
-  // Add intersected IN values if present
-  if (intersectedInValues !== null && intersectedInValues.length > 0) {
-    // Get the ref from one of the original IN predicates
-    const firstInPred = predicates.find((p) => {
-      if (p.type === `func`) {
-        return (p as Func).name === `in`
-      }
-      return false
-    })
-
-    if (firstInPred && firstInPred.type === `func`) {
-      const ref = (firstInPred as Func).args[0]
-      result.push({
-        type: `func`,
-        name: `in`,
-        args: [
-          ref,
-          { type: `val`, value: intersectedInValues } as BasicExpression,
-        ],
-      } as BasicExpression<boolean>)
-    }
-  }
-
-  // Add other predicates
-  result.push(...otherPredicates)
-
-  if (result.length === 0) {
-    return { type: `val`, value: true } as BasicExpression<boolean>
-  }
-
-  if (result.length === 1) {
-    return result[0]!
-  }
-
-  return {
-    type: `func`,
-    name: `and`,
-    args: result,
-  } as BasicExpression<boolean>
-}
 
 function unionSameFieldPredicates(
   predicates: Array<BasicExpression<boolean>>