Function minusWherePredicates

packages/db/src/query/predicate-utils.ts:340–404

(
  fromPredicate: BasicExpression<boolean> | undefined,
  subtractPredicate: BasicExpression<boolean> | undefined,
)

 * @returns The simplified difference, or null if cannot be simplified
 */
export function minusWherePredicates(
  fromPredicate: BasicExpression<boolean> | undefined,
  subtractPredicate: BasicExpression<boolean> | undefined,
): BasicExpression<boolean> | null {
  // If nothing to subtract, return the original
  if (subtractPredicate === undefined) {
    return (
      fromPredicate ??
      ({ type: `val`, value: true } as BasicExpression<boolean>)
    )
  }

  // If from is undefined then we are asking for all data
  // so we need to load all data minus what we already loaded
  // i.e. we need to load NOT(subtractPredicate)
  if (fromPredicate === undefined) {
    return {
      type: `func`,
      name: `not`,
      args: [subtractPredicate],
    } as BasicExpression<boolean>
  }

  // Check if fromPredicate is entirely contained in subtractPredicate
  // In that case, fromPredicate AND NOT(subtractPredicate) = empty set
  if (isWhereSubset(fromPredicate, subtractPredicate)) {
    return { type: `val`, value: false } as BasicExpression<boolean>
  }

  // Try to detect and handle common conditions
  const commonConditions = findCommonConditions(
    fromPredicate,
    subtractPredicate,
  )
  if (commonConditions.length > 0) {
    // Extract predicates without common conditions
    const fromWithoutCommon = removeConditions(fromPredicate, commonConditions)
    const subtractWithoutCommon = removeConditions(
      subtractPredicate,
      commonConditions,
    )

    // Recursively compute difference on simplified predicates
    const simplifiedDifference = minusWherePredicates(
      fromWithoutCommon,
      subtractWithoutCommon,
    )

    if (simplifiedDifference !== null) {
      // Combine the simplified difference with common conditions
      return combineConditions([...commonConditions, simplifiedDifference])
    }
  }

  // Check if they are on the same field - if so, we can try to simplify
  if (fromPredicate.type === `func` && subtractPredicate.type === `func`) {
    const result = minusSameFieldPredicates(fromPredicate, subtractPredicate)
    if (result !== null) {