alamb commented on code in PR #8983:
URL: https://github.com/apache/arrow-datafusion/pull/8983#discussion_r1464870454
##########
datafusion/optimizer/src/simplify_expressions/expr_simplifier.rs:
##########
@@ -229,6 +235,60 @@ impl<S: SimplifyInfo> ExprSimplifier<S> {
self.guarantees = guarantees;
self
}
+
+ /// Should [`Canonicalizer`] be applied before simplification?
+ ///
+ /// If true (the default), the expression will be rewritten to canonical
+ /// form before simplification. This is useful to ensure that the
simplifier
+ /// can apply all possible simplifications.
+ ///
+ /// Some expressions, such as those in some Joins, can not be canonicalized
+ /// without changing their meaning. In these cases, canonicalization should
+ /// be disabled.
+ ///
+ /// ```rust
+ /// use arrow::datatypes::{DataType, Field, Schema};
+ /// use datafusion_expr::{col, lit, Expr};
+ /// use datafusion_expr::interval_arithmetic::{Interval, NullableInterval};
+ /// use datafusion_common::{Result, ScalarValue, ToDFSchema};
+ /// use datafusion_physical_expr::execution_props::ExecutionProps;
+ /// use datafusion_optimizer::simplify_expressions::{
+ /// ExprSimplifier, SimplifyContext};
+ ///
+ /// let schema = Schema::new(vec![
+ /// Field::new("a", DataType::Int64, false),
+ /// Field::new("b", DataType::Int64, false),
+ /// Field::new("c", DataType::Int64, false),
+ /// ])
+ /// .to_dfschema_ref().unwrap();
+ ///
+ /// // Create the simplifier
+ /// let props = ExecutionProps::new();
+ /// let context = SimplifyContext::new(&props)
+ /// .with_schema(schema);
+ /// let simplifier = ExprSimplifier::new(context);
+ ///
+ /// // Expression: a = c AND 1 = b)
+ /// let expr = col("a").eq(col("c")).and(lit(1).eq(col("b")));
+ ///
+ /// // With canonicalization, the expression is rewritten to canonical form
+ /// // (though it is no simpler in this case):
+ /// let canonical = simplifier.simplify(expr.clone()).unwrap();
+ /// // Expression has been rewritten to: (c = a AND b = 1)
+ /// assert_eq!(canonical, col("c").eq(col("a")).and(col("b").eq(lit(1))));
+ ///
+ /// // If canonicalization is disabled, the expression is not changed
+ /// let non_canonicalized = simplifier
+ /// .with_canonicalize(false)
+ /// .simplify(expr.clone())
+ /// .unwrap();
+ ///
+ /// assert_eq!(non_canonicalized, expr);
+ /// ```
+ pub fn with_canonicalize(mut self, canonicalize: bool) -> Self {
Review Comment:
Here is the new api that is part of the ExprSimplifer that mirrors the
guarantees
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
