Function extractSourceWhereClauses

packages/db/src/query/optimizer.ts:247–286

* Extracts collection-specific WHERE clauses from a query for index optimization. * This analyzes the original query to identify single-source WHERE clauses that * reference collection sources (not subqueries), including joined collections. * * For outer joins, clauses referencing the nullable s

(
  query: QueryIR,
)

 * @returns Map of source aliases to their WHERE clauses
 */
function extractSourceWhereClauses(
  query: QueryIR,
): Map<string, BasicExpression<boolean>> {
  const sourceWhereClauses = new Map<string, BasicExpression<boolean>>()

  // Only analyze queries that have WHERE clauses
  if (!query.where || query.where.length === 0) {
    return sourceWhereClauses
  }

  // Split all AND clauses at the root level for granular analysis
  const splitWhereClauses = splitAndClauses(query.where)

  // Analyze each WHERE clause to determine which sources it touches
  const analyzedClauses = splitWhereClauses.map((clause) =>
    analyzeWhereClause(clause),
  )

  // Group clauses by single-source vs multi-source
  const groupedClauses = groupWhereClauses(analyzedClauses)

  // Determine which source aliases are on the nullable side of outer joins.
  // WHERE clauses for these sources must not be used for index optimization
  // because they should filter the final joined result, not the input data.
  const nullableSources = getNullableJoinSources(query)

  // Only include single-source clauses that reference collections directly
  // and are not on the nullable side of an outer join
  for (const [sourceAlias, whereClause] of groupedClauses.singleSource) {
    // Check if this source alias corresponds to a collection reference
    if (
      isCollectionReference(query, sourceAlias) &&
      !nullableSources.has(sourceAlias)
    ) {
      sourceWhereClauses.set(sourceAlias, whereClause)
    }
  }

  return sourceWhereClauses
}

/**
 * Determines if a source alias refers to a collection reference (not a subquery).