Method try_new

datafusion/pruning/src/pruning_predicate.rs:463–503

Try to create a new instance of [`PruningPredicate`] This will translate the provided `expr` filter expression into a *pruning predicate*. A pruning predicate is one that has been rewritten in terms of the min and max values of column references and that evaluates to FALSE if the filter predicate would evaluate FALSE *for every row* whose values fell within the min / max ranges (aka could be pru

(mut expr: Arc<dyn PhysicalExpr>, schema: SchemaRef)

    /// It is recommended that you pass the expressions through [`PhysicalExprSimplifier`]
    /// before calling this method to make sure the expressions can be used for pruning.
    pub fn try_new(mut expr: Arc<dyn PhysicalExpr>, schema: SchemaRef) -> Result<Self> {
        // Get a (simpler) snapshot of the physical expr here to use with `PruningPredicate`.
        // In particular this unravels any `DynamicFilterPhysicalExpr`s by snapshotting them
        // so that PruningPredicate can work with a static expression.
        let tf = snapshot_physical_expr_opt(expr)?;
        if tf.transformed {
            // If we had an expression such as Dynamic(part_col < 5 and col < 10)
            // (this could come from something like `select * from t order by part_col, col, limit 10`)
            // after snapshotting and because `DynamicFilterPhysicalExpr` applies child replacements to its
            // children after snapshotting and previously `replace_columns_with_literals` may have been called with partition values
            // the expression we have now is `8 < 5 and col < 10`.
            // Thus we need as simplifier pass to get `false and col < 10` => `false` here.
            let simplifier = PhysicalExprSimplifier::new(&schema);
            expr = simplifier.simplify(tf.data)?;
        } else {
            expr = tf.data;
        }
        let unhandled_hook = Arc::new(ConstantUnhandledPredicateHook::default()) as _;

        // build predicate expression once
        let mut required_columns = RequiredColumns::new();
        let predicate_expr = build_predicate_expression(
            &expr,
            &schema,
            &mut required_columns,
            &unhandled_hook,
        );
        let predicate_schema = required_columns.schema();
        // Simplify the newly created predicate to get rid of redundant casts, comparisons, etc.
        let predicate_expr =
            PhysicalExprSimplifier::new(&predicate_schema).simplify(predicate_expr)?;
        let literal_guarantees = LiteralGuarantee::analyze(&expr);

        Ok(Self {
            schema,
            predicate_expr,
            required_columns,
            orig_expr: expr,
            literal_guarantees,
        })
    }

    /// For each set of statistics, evaluates the pruning predicate
    /// and returns a `bool` with the following meaning for a