Method collect_predicate_constants

datafusion/physical-expr/src/utils/mod.rs:62–105

Collects predicate-derived constants from equality conjunctions. For each equality predicate of the form `lhs = rhs`, if either side is already known constant according to `input_eqs`, or is a literal, then the other side is also constant and will be returned as a [`ConstExpr`]. Literals are treated as uniform constants across partitions, so `col = literal` produces a constant for `col` with the

(
        input_eqs: &EquivalenceProperties,
        predicate: &Arc<dyn PhysicalExpr>,
    )

    /// known constant, this returns constants for both `a` (Uniform with value
    /// 5) and `b` (propagating `c`'s across-partitions value).
    pub fn collect_predicate_constants(
        input_eqs: &EquivalenceProperties,
        predicate: &Arc<dyn PhysicalExpr>,
    ) -> Vec<ConstExpr> {
        /// Returns the `AcrossPartitions` value for `expr` if it is constant:
        /// either already known constant in `input_eqs`, or a `Literal`
        /// (which is inherently constant across all partitions).
        fn expr_constant_or_literal(
            expr: &Arc<dyn PhysicalExpr>,
            input_eqs: &EquivalenceProperties,
        ) -> Option<AcrossPartitions> {
            input_eqs.is_expr_constant(expr).or_else(|| {
                expr.downcast_ref::<Literal>()
                    .map(|l| AcrossPartitions::Uniform(Some(l.value().clone())))
            })
        }

        let mut constants = Vec::new();
        for conjunction in split_conjunction(predicate) {
            if let Some(binary) = conjunction.downcast_ref::<BinaryExpr>()
                && binary.op() == &Operator::Eq
            {
                // Check if either side is constant — either already known
                // constant from the input equivalence properties, or a literal
                // value (which is inherently constant across all partitions).
                let left_const = expr_constant_or_literal(binary.left(), input_eqs);
                let right_const = expr_constant_or_literal(binary.right(), input_eqs);

                if let Some(left_across) = left_const {
                    // LEFT is constant, so RIGHT must also be constant.
                    // Use RIGHT's known across value if available, otherwise
                    // propagate LEFT's (e.g. Uniform from a literal).
                    let across = right_const.unwrap_or(left_across);
                    constants.push(ConstExpr::new(Arc::clone(binary.right()), across));
                } else if let Some(right_across) = right_const {
                    // RIGHT is constant, so LEFT must also be constant.
                    constants
                        .push(ConstExpr::new(Arc::clone(binary.left()), right_across));
                }
            }
        }

        constants
    }
}

/// Create a conjunction of the given predicates.