Reduce number of traversals per node in PhysicalExprSimplifier (#20082)

## Which issue does this PR close?

- Closes #20081.

## Rationale for this change

Ran into this while investigating #20078, in my benchmarks this saves
around %10, which can quickly add up to a few ms per query.

The benchmarking code is
[here](https://gist.github.com/AdamGS/4fc6612814786a95a673378de7d61202),
measuring it on my laptop the effect is:
```
tpc-ds/q76/cs/16        time:   [927.65 µs 928.86 µs 930.14 µs]
                        change: [−12.309% −11.983% −11.667%] (p = 0.00 < 0.05)
                        Performance has improved.

tpc-ds/q76/ws/16        time:   [929.00 µs 930.51 µs 932.13 µs]
                        change: [−12.102% −11.808% −11.475%] (p = 0.00 < 0.05)

tpc-ds/q76/cs/128       time:   [6.8376 ms 6.8460 ms 6.8552 ms]
                        change: [−12.626% −12.411% −12.207%] (p = 0.00 < 0.05)


tpc-ds/q76/ws/128       time:   [6.8394 ms 6.8536 ms 6.8710 ms]
                        change: [−12.039% −11.813% −11.575%] (p = 0.00 < 0.05)
```

## What changes are included in this PR?

I've also changed `[cfg(test)]` to a debug assertion, which seems more
in the spirit of #18001, and
will make the check fail even if a test in another crate triggers, which
effectively increases the coverage.


## Are these changes tested?

The functionality is identical, and in addition to existing tests I've
changed the defensive assertion into a debug check and ran tests for
other crates that make use of this codepath (like
`datafusion-datasource-parquet` and `datafusion-pruning`).

## Are there any user-facing changes?

None

Author: AdamGS

datafusion/physical-expr/src/simplifier/const_evaluator.rs

@@ -25,7 +25,6 @@ use arrow::record_batch::RecordBatch;
 use datafusion_common::tree_node::{Transformed, TreeNode, TreeNodeRecursion};
 use datafusion_common::{Result, ScalarValue};
 use datafusion_expr_common::columnar_value::ColumnarValue;
-use datafusion_physical_expr_common::physical_expr::is_volatile;
 
 use crate::PhysicalExpr;
 use crate::expressions::{Column, Literal};
@@ -43,7 +42,7 @@ use crate::expressions::{Column, Literal};
 pub fn simplify_const_expr(
     expr: &Arc<dyn PhysicalExpr>,
 ) -> Result<Transformed<Arc<dyn PhysicalExpr>>> {
-    if is_volatile(expr) || has_column_references(expr) {
+    if !can_evaluate_as_constant(expr) {
         return Ok(Transformed::no(Arc::clone(expr)));
     }
 
@@ -73,6 +72,22 @@ pub fn simplify_const_expr(
     }
 }
 
+fn can_evaluate_as_constant(expr: &Arc<dyn PhysicalExpr>) -> bool {
+    let mut can_evaluate = true;
+
+    expr.apply(|e| {
+        if e.as_any().is::<Column>() || e.is_volatile_node() {
+            can_evaluate = false;
+            Ok(TreeNodeRecursion::Stop)
+        } else {
+            Ok(TreeNodeRecursion::Continue)
+        }
+    })
+    .expect("apply should not fail");
+
+    can_evaluate
+}
+
 /// Create a 1-row dummy RecordBatch for evaluating constant expressions.
 ///
 /// The batch is never actually accessed for data - it's just needed because

datafusion/physical-expr/src/simplifier/mod.rs

@@ -53,7 +53,7 @@ impl<'a> PhysicalExprSimplifier<'a> {
         while count < MAX_LOOP_COUNT {
             count += 1;
             let result = current_expr.transform(|node| {
-                #[cfg(test)]
+                #[cfg(debug_assertions)]
                 let original_type = node.data_type(schema).unwrap();
 
                 // Apply NOT expression simplification first, then unwrap cast optimization,
@@ -64,7 +64,7 @@ impl<'a> PhysicalExprSimplifier<'a> {
                     })?
                     .transform_data(|node| const_evaluator::simplify_const_expr(&node))?;
 
-                #[cfg(test)]
+                #[cfg(debug_assertions)]
                 assert_eq!(
                     rewritten.data.data_type(schema).unwrap(),
                     original_type,