feat: add eq delete parse test and fix logic bug

Author: sdd

crates/iceberg/src/arrow/delete_file_manager.rs

@@ -17,7 +17,7 @@
 
 use std::collections::HashMap;
 use std::future::Future;
-use std::ops::BitOrAssign;
+use std::ops::{BitOrAssign, Not};
 use std::pin::Pin;
 use std::sync::{Arc, OnceLock, RwLock};
 use std::task::{Context, Poll};
@@ -413,10 +413,10 @@ impl DeleteFileManager {
                         }
                     }
                 }
-                result_predicate = result_predicate.or(row_predicate);
+                result_predicate = result_predicate.and(row_predicate.not());
             }
         }
-        Ok(result_predicate)
+        Ok(result_predicate.rewrite_not())
     }
 
     /// Builds eq delete predicate for the provided task.
@@ -596,7 +596,7 @@ mod tests {
             .build()
             .unwrap();
 
-        let file_scan_tasks = setup(table_location);
+        let file_scan_tasks = setup_load_deletes_test_tasks(table_location);
 
         delete_file_manager
             .load_deletes(&file_scan_tasks[0].deletes, file_io, 5)
@@ -614,7 +614,31 @@ mod tests {
         assert_eq!(result.len(), 3); // pos dels from pos del file 3
     }
 
-    fn setup(table_location: &Path) -> Vec<FileScanTask> {
+    #[tokio::test]
+    async fn test_delete_file_manager_parse_equality_deletes() {
+        let tmp_dir = TempDir::new().unwrap();
+        let table_location = tmp_dir.path().as_os_str().to_str().unwrap();
+        let file_io = FileIO::from_path(table_location).unwrap().build().unwrap();
+
+        let eq_delete_file_path = setup_write_equality_delete_file_1(table_location);
+
+        let record_batch_stream =
+            DeleteFileManager::parquet_to_batch_stream(&eq_delete_file_path, file_io.clone())
+                .await
+                .expect("could not get batch stream");
+
+        let parsed_eq_delete =
+            DeleteFileManager::parse_equality_deletes_record_batch_stream(record_batch_stream)
+                .await
+                .expect("error parsing batch stream");
+        println!("{}", parsed_eq_delete);
+
+        let expected = "(((y != 1) OR (z != 100)) OR (a != \"HELP\")) AND (y != 2)".to_string();
+
+        assert_eq!(parsed_eq_delete.to_string(), expected);
+    }
+
+    fn setup_load_deletes_test_tasks(table_location: &Path) -> Vec<FileScanTask> {
         let data_file_schema = Arc::new(Schema::builder().build().unwrap());
         let positional_delete_schema = create_pos_del_schema();
 
@@ -751,4 +775,58 @@ mod tests {
         ];
         Arc::new(arrow_schema::Schema::new(fields))
     }
+    
+    fn setup_write_equality_delete_file_1(table_location: &str) -> String {
+        let col_y_vals = vec![1, 2];
+        let col_y = Arc::new(Int64Array::from(col_y_vals)) as ArrayRef;
+
+        let col_z_vals = vec![Some(100), None];
+        let col_z = Arc::new(Int64Array::from(col_z_vals)) as ArrayRef;
+
+        let col_a_vals = vec![Some("HELP"), None];
+        let col_a = Arc::new(StringArray::from(col_a_vals)) as ArrayRef;
+
+        let equality_delete_schema = {
+            let fields = vec![
+                arrow_schema::Field::new("y", arrow_schema::DataType::Int64, true).with_metadata(
+                    HashMap::from([(PARQUET_FIELD_ID_META_KEY.to_string(), "2".to_string())]),
+                ),
+                arrow_schema::Field::new("z", arrow_schema::DataType::Int64, true).with_metadata(
+                    HashMap::from([(PARQUET_FIELD_ID_META_KEY.to_string(), "3".to_string())]),
+                ),
+                arrow_schema::Field::new("a", arrow_schema::DataType::Utf8, true).with_metadata(
+                    HashMap::from([(PARQUET_FIELD_ID_META_KEY.to_string(), "4".to_string())]),
+                ),
+            ];
+            Arc::new(arrow_schema::Schema::new(fields))
+        };
+
+        let equality_deletes_to_write =
+            RecordBatch::try_new(equality_delete_schema.clone(), vec![col_y, col_z, col_a])
+                .unwrap();
+
+        let path = format!("{}/equality-deletes-1.parquet", &table_location);
+
+        let file = File::create(&path).unwrap();
+
+        let props = WriterProperties::builder()
+            .set_compression(Compression::SNAPPY)
+            .build();
+
+        let mut writer = ArrowWriter::try_new(
+            file,
+            equality_deletes_to_write.schema(),
+            Some(props.clone()),
+        )
+        .unwrap();
+
+        writer
+            .write(&equality_deletes_to_write)
+            .expect("Writing batch");
+
+        // writer must be closed to write footer
+        writer.close().unwrap();
+
+        path
+    }
 }