Function create_physical_expr

datafusion/physical-expr/src/planner.rs:115–572

(
    e: &Expr,
    input_dfschema: &DFSchema,
    execution_props: &ExecutionProps,
)

///   to qualified or unqualified fields by name.
#[cfg_attr(feature = "recursive_protection", recursive::recursive)]
pub fn create_physical_expr(
    e: &Expr,
    input_dfschema: &DFSchema,
    execution_props: &ExecutionProps,
) -> Result<Arc<dyn PhysicalExpr>> {
    let input_schema = input_dfschema.as_arrow();

    match e {
        Expr::Alias(Alias { expr, metadata, .. }) => {
            if let Expr::Literal(v, prior_metadata) = expr.as_ref() {
                let new_metadata = FieldMetadata::merge_options(
                    prior_metadata.as_ref(),
                    metadata.as_ref(),
                );
                Ok(Arc::new(Literal::new_with_metadata(
                    v.clone(),
                    new_metadata,
                )))
            } else {
                Ok(create_physical_expr(expr, input_dfschema, execution_props)?)
            }
        }
        Expr::Column(c) => {
            let idx = input_dfschema.index_of_column(c)?;
            Ok(Arc::new(Column::new(&c.name, idx)))
        }
        Expr::Literal(value, metadata) => Ok(Arc::new(Literal::new_with_metadata(
            value.clone(),
            metadata.clone(),
        ))),
        Expr::ScalarVariable(_, variable_names) => {
            if is_system_variables(variable_names) {
                match execution_props.get_var_provider(VarType::System) {
                    Some(provider) => {
                        let scalar_value = provider.get_value(variable_names.clone())?;
                        Ok(Arc::new(Literal::new(scalar_value)))
                    }
                    _ => plan_err!("No system variable provider found"),
                }
            } else {
                match execution_props.get_var_provider(VarType::UserDefined) {
                    Some(provider) => {
                        let scalar_value = provider.get_value(variable_names.clone())?;
                        Ok(Arc::new(Literal::new(scalar_value)))
                    }
                    _ => plan_err!("No user defined variable provider found"),
                }
            }
        }
        Expr::IsTrue(expr) => {
            let binary_op = binary_expr(
                expr.as_ref().clone(),
                Operator::IsNotDistinctFrom,
                lit(true),
            );
            create_physical_expr(&binary_op, input_dfschema, execution_props)
        }
        Expr::IsNotTrue(expr) => {