Method order_by_to_sort_expr

datafusion/sql/src/expr/order_by.rs:42–119

Convert sql [OrderByExpr] to `Vec `. `input_schema` and `additional_schema` are used to resolve column references in the order-by expressions. `input_schema` is the schema of the input logical plan, typically derived from the SELECT list. Usually order-by expressions can only reference the input plan's columns. But the `SELECT ... FROM ... ORDER BY ...` syntax is a special case. Besides the

(
        &self,
        order_by_exprs: Vec<OrderByExpr>,
        input_schema: &DFSchema,
        planner_context: &mut PlannerContext,
        literal_to_column: bool,
        additional_schema: Op

    ///
    /// If false, interpret numeric literals as constant values.
    pub(crate) fn order_by_to_sort_expr(
        &self,
        order_by_exprs: Vec<OrderByExpr>,
        input_schema: &DFSchema,
        planner_context: &mut PlannerContext,
        literal_to_column: bool,
        additional_schema: Option<&DFSchema>,
    ) -> Result<Vec<SortExpr>> {
        if order_by_exprs.is_empty() {
            return Ok(vec![]);
        }

        let mut combined_schema;
        let order_by_schema = match additional_schema {
            Some(schema) => {
                combined_schema = input_schema.clone();
                combined_schema.merge(schema);
                &combined_schema
            }
            None => input_schema,
        };

        let mut sort_expr_vec = Vec::with_capacity(order_by_exprs.len());

        let make_sort_expr = |expr: Expr,
                              asc: Option<bool>,
                              nulls_first: Option<bool>| {
            let asc = asc.unwrap_or(true);
            let nulls_first = nulls_first
                .unwrap_or_else(|| self.options.default_null_ordering.nulls_first(asc));
            Sort::new(expr, asc, nulls_first)
        };

        for order_by_expr in order_by_exprs {
            let OrderByExpr {
                expr,
                options: OrderByOptions { asc, nulls_first },
                with_fill,
            } = order_by_expr;

            if let Some(with_fill) = with_fill {
                return not_impl_err!("ORDER BY WITH FILL is not supported: {with_fill}");
            }

            let expr = match expr {
                SQLExpr::Value(ValueWithSpan {
                    value: Value::Number(v, _),
                    span: _,
                }) if literal_to_column => {
                    let field_index = v
                        .parse::<usize>()
                        .map_err(|err| plan_datafusion_err!("{}", err))?;

                    if field_index == 0 {
                        return plan_err!(
                            "Order by index starts at 1 for column indexes"
                        );
                    } else if input_schema.fields().len() < field_index {