Method fold_sql_transforms

prqlc/prqlc/src/sql/pq/gen_query.rs:139–177

(
        &mut self,
        transforms: Vec<pq::SqlTransform<RIId, rq::Transform>>,
    )

    }

    fn fold_sql_transforms(
        &mut self,
        transforms: Vec<pq::SqlTransform<RIId, rq::Transform>>,
    ) -> Result<Vec<pq::SqlTransform<pq::RelationExpr, ()>>> {
        transforms
            .into_iter()
            .map(|transform| {
                Ok(Some(match transform {
                    pq::SqlTransform::From(v) => pq::SqlTransform::From(self.fold_rel(v)?),
                    pq::SqlTransform::Join { side, with, filter } => pq::SqlTransform::Join {
                        side,
                        with: self.fold_rel(with)?,
                        filter,
                    },

                    pq::SqlTransform::Super(sup) => {
                        match sup {
                            rq::Transform::Select(v) => pq::SqlTransform::Select(v),
                            rq::Transform::Filter(v) => pq::SqlTransform::Filter(v),
                            rq::Transform::Aggregate { partition, compute } => {
                                pq::SqlTransform::Aggregate { partition, compute }
                            }
                            rq::Transform::Sort(v) => pq::SqlTransform::Sort(v),
                            rq::Transform::Take(v) => pq::SqlTransform::Take(v),
                            rq::Transform::Compute(_)
                            | rq::Transform::Append(_)
                            | rq::Transform::Loop(_) => {
                                // these are not used from here on
                                return Ok(None);
                            }
                            rq::Transform::From(_) | rq::Transform::Join { .. } => unreachable!(),
                        }
                    }
                    _ => fold_sql_transform(self, transform)?,
                }))
            })
            .flat_map(|x| x.transpose())
            .try_collect()
    }
}

pub(super) fn compile_relation_instance(riid: RIId, ctx: &mut Context) -> Result<pq::RelationExpr> {