Function referencesAliasWithRemappedSelect

packages/db/src/query/optimizer.ts:1154–1212

* Detects whether a WHERE clause references the subquery alias through fields that * are re-exposed under different names (renamed SELECT projections or fnSelect output). * In those cases we keep the clause at the outer level to avoid alias remapping bugs. * TODO: in future we should handle this

(
  subquery: QueryIR,
  whereClause: BasicExpression<boolean>,
  outerAlias: string,
)

 * internal field references, but it likely needs a wider refactor to do cleanly.
 */
function referencesAliasWithRemappedSelect(
  subquery: QueryIR,
  whereClause: BasicExpression<boolean>,
  outerAlias: string,
): boolean {
  const refs = collectRefs(whereClause)
  // Only care about clauses that actually reference the outer alias.
  if (refs.every((ref) => ref.path[0] !== outerAlias)) {
    return false
  }

  // fnSelect always rewrites the row shape, so alias-safe pushdown is impossible.
  if (subquery.fnSelect) {
    return true
  }

  const select = subquery.select
  // Without an explicit SELECT the clause still refers to the original collection.
  if (!select) {
    return false
  }

  for (const ref of refs) {
    const path = ref.path
    // Need at least alias + field to matter.
    if (path.length < 2) continue
    if (path[0] !== outerAlias) continue

    const projected = select[path[1]!]
    // Unselected fields can't be remapped, so skip - only care about fields in the SELECT.
    if (!projected) continue

    // Non-PropRef projections are computed values; cannot push down.
    if (!(projected instanceof PropRef)) {
      return true
    }

    // If the projection is just the alias (whole row) without a specific field,
    // we can't verify whether the field we're referencing is being preserved or remapped.
    if (projected.path.length < 2) {
      return true
    }

    const [innerAlias, innerField] = projected.path

    // Safe only when the projection points straight back to the same alias or the
    // underlying source alias and preserves the field name.
    const firstFromAlias = getFirstFromAlias(subquery)
    if (innerAlias !== outerAlias && innerAlias !== firstFromAlias) {
      return true
    }

    if (innerField !== path[1]) {
      return true
    }
  }

  return false