Method resolve_special_func

prqlc/prqlc/src/semantic/resolver/transforms.rs:21–513

(&mut self, func: Box<Func>, needs_window: bool)

    /// try to convert function call with enough args into transform
    #[allow(clippy::boxed_local)]
    pub fn resolve_special_func(&mut self, func: Box<Func>, needs_window: bool) -> Result<Expr> {
        let internal_name = func.body.kind.into_internal().unwrap();

        let (kind, input) = match internal_name.as_str() {
            "select" => {
                let [assigns, tbl] = unpack::<2>(func.args);

                let assigns = Box::new(self.coerce_into_tuple(assigns)?);
                (TransformKind::Select { assigns }, tbl)
            }
            "filter" => {
                let [filter, tbl] = unpack::<2>(func.args);

                let filter = Box::new(filter);
                (TransformKind::Filter { filter }, tbl)
            }
            "derive" => {
                let [assigns, tbl] = unpack::<2>(func.args);

                let assigns = Box::new(self.coerce_into_tuple(assigns)?);
                (TransformKind::Derive { assigns }, tbl)
            }
            "aggregate" => {
                let [assigns, tbl] = unpack::<2>(func.args);

                let assigns = Box::new(self.coerce_into_tuple(assigns)?);
                (TransformKind::Aggregate { assigns }, tbl)
            }
            "sort" => {
                let [by, tbl] = unpack::<2>(func.args);

                let by = self
                    .coerce_into_tuple(by)?
                    .try_cast(|x| x.into_tuple(), Some("sort"), "tuple")?
                    .into_iter()
                    .map(|expr| {
                        let (column, direction) = match expr.kind {
                            ExprKind::RqOperator { name, mut args } if name == "std.neg" => {
                                (args.remove(0), SortDirection::Desc)
                            }
                            _ => (expr, SortDirection::default()),
                        };
                        let column = Box::new(column);

                        ColumnSort { direction, column }
                    })
                    .collect();

                (TransformKind::Sort { by }, tbl)
            }
            "take" => {
                let [expr, tbl] = unpack::<2>(func.args);

                let range = if let ExprKind::Literal(Literal::Integer(n)) = expr.kind {
                    range_from_ints(None, Some(n))
                } else {
                    match try_restrict_range(expr) {
                        Ok((start, end)) => Range {