Optimize ~! '.*' and '.*' cases to False instead of Eq empty str condition (fixes old behavior)

Author: petern48

datafusion/optimizer/src/simplify_expressions/regex.rs

@@ -42,7 +42,7 @@ const ANY_CHAR_REGEX_PATTERN: &str = ".*";
 /// - partial anchored regex patterns (e.g. `^foo`) to `LIKE 'foo%'`
 /// - combinations (alternatives) of the above, will be concatenated with `OR` or `AND`
 /// - `EQ .*` to NotNull
-/// - `NE .*` means IS EMPTY
+/// - `NE .*` to false (.* matches any string, and NULL !~ results in NULL so NOT match can never be true)
 ///
 /// Dev note: unit tests of this function are in `expr_simplifier.rs`, case `test_simplify_regex`.
 pub fn simplify_regex_expr(
@@ -71,13 +71,8 @@ pub fn simplify_regex_expr(
     // Handle the special case for ".*" pattern
     if pattern == ANY_CHAR_REGEX_PATTERN {
         let new_expr = if mode.not {
-            // not empty
-            let empty_lit = Box::new(string_scalar.to_expr(""));
-            Expr::BinaryExpr(BinaryExpr {
-                left,
-                op: Operator::Eq,
-                right: empty_lit,
-            })
+            // Always false.
+            lit(false)
         } else {
             // not null
             left.is_not_null()
@@ -100,13 +95,7 @@ pub fn simplify_regex_expr(
             (false, true) => left.is_not_null(),
             // not (contains(left, inner))
             (true, false) => Expr::Not(Box::new(contains(*left, lit(inner)))),
-            (true, true) => {
-                return Ok(Transformed::no(Expr::BinaryExpr(BinaryExpr {
-                    left,
-                    op,
-                    right,
-                })));
-            }
+            (true, true) => lit(false), // "!~ '.*'" is always false.
         };
         return Ok(Transformed::yes(new_expr));
     }

datafusion/optimizer/src/simplify_expressions/simplify_exprs.rs

@@ -883,17 +883,17 @@ mod tests {
         "
         )?;
 
-        // Test `!= ".*"` transforms to checking if the column is empty
+        // Test `!= ".*"` transforms to false (.* matches any string, so NOT match is always false)
         let plan = LogicalPlanBuilder::from(table_scan.clone())
             .filter(binary_expr(col("a"), Operator::RegexNotMatch, lit(".*")))?
             .build()?;
 
         assert_optimized_plan_equal!(
             plan,
-            @ r#"
-        Filter: test.a = Utf8("")
+            @ r"
+        Filter: Boolean(false)
           TableScan: test
-        "#
+        "
         )?;
 
         // Test case-insensitive versions
@@ -911,17 +911,17 @@ mod tests {
         "
         )?;
 
-        // Test `!~ ".*"` (case-insensitive) transforms to checking if the column is empty
+        // Test `!~ ".*"` (case-insensitive) transforms to false (.* matches any string, so NOT match is always false)
         let plan = LogicalPlanBuilder::from(table_scan.clone())
             .filter(binary_expr(col("a"), Operator::RegexNotIMatch, lit(".*")))?
             .build()?;
 
         assert_optimized_plan_equal!(
             plan,
-            @ r#"
-        Filter: test.a = Utf8("")
+            @ r"
+        Filter: Boolean(false)
           TableScan: test
-        "#
+        "
         )
     }
 

datafusion/sqllogictest/test_files/simplify_expr.slt

@@ -43,12 +43,8 @@ physical_plan
 query TT
 explain select b from t where b !~ '.*'
 ----
-logical_plan
-01)Filter: t.b = Utf8View("")
-02)--TableScan: t projection=[b]
-physical_plan
-01)FilterExec: b@0 =
-02)--DataSourceExec: partitions=1, partition_sizes=[1]
+logical_plan EmptyRelation: rows=0
+physical_plan EmptyExec
 
 query T
 select b from t where b ~ '.*'
@@ -58,6 +54,7 @@ c
 
 query T
 select b from t where b !~ '.*'
+----
 
 # test regex .*literal.* simplifies to contains()
 query TT
@@ -108,6 +105,7 @@ c
 
 query T
 select b from t where b !~ '.*.*'
+----
 
 query TT
 explain select * from t where a = a;