Method fold_sql_transforms

prqlc/prqlc/src/sql/pq/postprocess.rs:321–436

(
        &mut self,
        transforms: Vec<SqlTransform<RelationExpr, ()>>,
    )

    }

    fn fold_sql_transforms(
        &mut self,
        transforms: Vec<SqlTransform<RelationExpr, ()>>,
    ) -> Result<Vec<SqlTransform<RelationExpr, ()>>> {
        let mut sorting = Vec::new();
        // Track whether sorting originated from DISTINCT ON (internal row selection).
        // Per PRQL spec, `group` resets order - internal sorts don't define output order.
        let mut sorting_from_distinct_on = false;

        let mut result = Vec::with_capacity(transforms.len() + 1);

        for mut transform in transforms {
            match transform {
                SqlTransform::From(mut expr) => {
                    match expr.kind {
                        RelationExprKind::Ref(ref tid) => {
                            // infer sorting from referenced pipeline
                            if let Some(cte_sorting) = self.ctes_sorting.get(tid) {
                                sorting.clone_from(&cte_sorting.sorting);
                                sorting_from_distinct_on = cte_sorting.from_distinct_on;
                            } else {
                                sorting.clear();
                                sorting_from_distinct_on = false;
                            };
                        }
                        RelationExprKind::SubQuery(rel) => {
                            let rel = self.fold_sql_relation(rel)?;

                            // infer sorting from sub-query
                            sorting = self.last_sorting.drain(..).collect();
                            sorting_from_distinct_on = self.last_sorting_from_distinct_on;

                            expr.kind = RelationExprKind::SubQuery(rel);
                        }
                    }
                    sorting =
                        CidRedirector::redirect_sorts(sorting, &expr.riid, &mut self.ctx.anchor);
                    transform = SqlTransform::From(expr);
                }

                // just store sorting and don't emit Sort
                SqlTransform::Sort(expr) => {
                    sorting.clone_from(&expr);
                    // A new explicit Sort clears the DISTINCT ON flag - this is a
                    // user-requested ordering, not an internal DISTINCT ON sort.
                    sorting_from_distinct_on = false;
                    continue;
                }

                // clear sorting
                SqlTransform::Distinct | SqlTransform::Aggregate { .. } => {
                    sorting.clear();
                    sorting_from_distinct_on = false;
                }

                // Per PRQL spec: `group` resets order, `join` retains left's order.
                // DISTINCT ON sorting is internal to the group (for row selection),
                // so it must not propagate past joins. Explicit user sorts are preserved.