Fix tests

coralogix · Aug 14, 2024 · 6de5eb8 · 6de5eb8
1 parent 46488b0
commit 6de5eb8
Show file tree

Hide file tree

Showing 5 changed files with 32 additions and 34 deletions.
diff --git a/datafusion/common/Cargo.toml b/datafusion/common/Cargo.toml
@@ -39,6 +39,8 @@ path = "src/lib.rs"
 avro = ["apache-avro"]
 backtrace = []
 pyarrow = ["pyo3", "arrow/pyarrow", "parquet"]
+# Used for testing ONLY: causes all values to hash to the same value (test for collisions)
+force_hash_collisions = []
 
 [dependencies]
 ahash = { workspace = true }

diff --git a/datafusion/core/tests/dataframe/dataframe_functions.rs b/datafusion/core/tests/dataframe/dataframe_functions.rs
@@ -361,11 +361,11 @@ async fn test_fn_approx_percentile_cont() -> Result<()> {
     let expr = approx_percentile_cont(col("b"), lit(0.5));
 
     let expected = [
-        "+---------------------------------------------+",
-        "| APPROX_PERCENTILE_CONT(test.b,Float64(0.5)) |",
-        "+---------------------------------------------+",
-        "| 10                                          |",
-        "+---------------------------------------------+",
+        "+----------------------------------------------+",
+        "| APPROX_PERCENTILE_CONT(test.b, Float64(0.5)) |",
+        "+----------------------------------------------+",
+        "| 10                                           |",
+        "+----------------------------------------------+",
     ];
 
     let df = create_test_table().await?;
@@ -382,11 +382,11 @@ async fn test_fn_approx_percentile_cont() -> Result<()> {
     let expr = approx_percentile_cont(col("b"), alias_expr);
     let df = create_test_table().await?;
     let expected = [
-        "+--------------------------------------+",
-        "| APPROX_PERCENTILE_CONT(test.b,arg_2) |",
-        "+--------------------------------------+",
-        "| 10                                   |",
-        "+--------------------------------------+",
+        "+---------------------------------------+",
+        "| APPROX_PERCENTILE_CONT(test.b, arg_2) |",
+        "+---------------------------------------+",
+        "| 10                                    |",
+        "+---------------------------------------+",
     ];
     let batches = df.aggregate(vec![], vec![expr]).unwrap().collect().await?;
 

diff --git a/datafusion/expr/src/simplify.rs b/datafusion/expr/src/simplify.rs
@@ -74,7 +74,7 @@ impl<'a> SimplifyContext<'a> {
 impl<'a> SimplifyInfo for SimplifyContext<'a> {
     /// returns true if this Expr has boolean type
     fn is_boolean_type(&self, expr: &Expr) -> Result<bool> {
-        for schema in &self.schema {
+        if let Some(schema) = &self.schema {
             if let Ok(DataType::Boolean) = expr.get_type(schema) {
                 return Ok(true);
             }

diff --git a/datafusion/physical-plan/Cargo.toml b/datafusion/physical-plan/Cargo.toml
@@ -35,6 +35,10 @@ workspace = true
 name = "datafusion_physical_plan"
 path = "src/lib.rs"
 
+[features]
+# Used for testing ONLY: causes all values to hash to the same value (test for collisions)
+force_hash_collisions = []
+
 [dependencies]
 ahash = { workspace = true }
 arrow = { workspace = true }

diff --git a/datafusion/substrait/src/logical_plan/consumer.rs b/datafusion/substrait/src/logical_plan/consumer.rs
@@ -164,32 +164,24 @@ fn split_eq_and_noneq_join_predicate_with_nulls_equality(
 
     for expr in exprs {
         match expr {
-            Expr::BinaryExpr(binary_expr) => match binary_expr {
-                x @ (BinaryExpr {
-                    left,
-                    op: Operator::Eq,
-                    right,
-                }
-                | BinaryExpr {
-                    left,
-                    op: Operator::IsNotDistinctFrom,
-                    right,
-                }) => {
-                    nulls_equal_nulls = match x.op {
-                        Operator::Eq => false,
-                        Operator::IsNotDistinctFrom => true,
-                        _ => unreachable!(),
-                    };
+            Expr::BinaryExpr(BinaryExpr {
+                left,
+                op: op @ (Operator::Eq | Operator::IsNotDistinctFrom),
+                right,
+            }) => {
+                nulls_equal_nulls = match op {
+                    Operator::Eq => false,
+                    Operator::IsNotDistinctFrom => true,
+                    _ => unreachable!(),
+                };
 
-                    match (left.as_ref(), right.as_ref()) {
-                        (Expr::Column(l), Expr::Column(r)) => {
-                            accum_join_keys.push((l.clone(), r.clone()));
-                        }
-                        _ => accum_filters.push(expr.clone()),
+                match (left.as_ref(), right.as_ref()) {
+                    (Expr::Column(l), Expr::Column(r)) => {
+                        accum_join_keys.push((l.clone(), r.clone()));
                     }
+                    _ => accum_filters.push(expr.clone()),
                 }
-                _ => accum_filters.push(expr.clone()),
-            },
+            }
             _ => accum_filters.push(expr.clone()),
         }
     }