Apache DataFusion SQL Query Engine
perf(parquet): skip Bloom reads for fully matched row groups (#25854)
xudong.wf427fb788fdb
diff --git a/datafusion/datasource-parquet/src/opener/mod.rs b/datafusion/datasource-parquet/src/opener/mod.rsindex 1f4a09a58b..eb329fb303 100644--- a/datafusion/datasource-parquet/src/opener/mod.rs+++ b/datafusion/datasource-parquet/src/opener/mod.rs@@ -1482,6 +1482,10 @@ impl RowGroupsPrunedParquetOpen {self.prepared.pruning_predicate.as_ref().map(|p| p.as_ref())&& self.prepared.loaded.prepared.enable_bloom_filter&& !self.row_groups.is_empty()+ && self+ .row_groups+ .row_group_indexes()+ .any(|idx| !self.row_groups.access_plan().is_fully_matched(idx)){// Use the existing reader for bloom filter I/O;// replace with a fresh reader for decoding below.@@ -1521,6 +1525,11 @@ impl RowGroupsPrunedParquetOpen {.collect();for idx in self.row_groups.row_group_indexes() {+ // Statistics have already proved that every row in this group+ // matches the predicate, so its Bloom filters cannot prune it.+ if self.row_groups.access_plan().is_fully_matched(idx) {+ continue;+ }let mut row_group_filters =BloomFilterStatistics::with_capacity(parquet_columns.len());for (column_name, column_idx, physical_type, type_length) in@@ -2485,6 +2494,11 @@ mod test {self}+ fn with_enable_bloom_filter(mut self, enable: bool) -> Self {+ self.enable_bloom_filter = enable;+ self+ }+fn with_metrics(mut self, metrics: ExecutionPlanMetricsSet) -> Self {self.metrics = metrics;self@@ -4570,6 +4584,86 @@ mod test {);}+ #[tokio::test]+ async fn fully_matched_row_groups_skip_bloom_filter_reads() {+ let store = Arc::new(InMemory::new()) as Arc<dyn ObjectStore>;+ let batches = vec![+ record_batch!(("a", Int32, vec![1, 1, 1])).unwrap(),+ record_batch!(("a", Int32, vec![0, 1, 2])).unwrap(),+ ];+ let schema = batches[0].schema();+ let props = WriterProperties::builder()+ .set_max_row_group_row_count(Some(3))+ .set_bloom_filter_enabled(true)+ .set_statistics_enabled(EnabledStatistics::Chunk)+ .build();+ let data_size = write_parquet_batches(+ Arc::clone(&store),+ "bloom.parquet",+ batches,+ Some(props),+ )+ .await;+ let file = PartitionedFile::new("bloom.parquet".to_string(), data_size as u64);+ let predicate = logical2physical(&col("a").eq(lit(1)), &schema);++ let mut bloom_bytes = Vec::new();+ for stats_pruning in [false, true] {+ let metrics = ExecutionPlanMetricsSet::new();+ let morselizer = ParquetMorselizerBuilder::new()+ .with_store(Arc::clone(&store))+ .with_schema(Arc::clone(&schema))+ .with_predicate(Arc::clone(&predicate))+ .with_pushdown_filters(true)+ .with_row_group_stats_pruning(stats_pruning)+ .with_enable_bloom_filter(true)+ .with_metrics(metrics.clone())+ .build();+ let stream = open_file(&morselizer, file.clone()).await.unwrap();+ // The decoder has not been polled yet, so only Bloom filter reads+ // contribute to this metric.+ bloom_bytes.push(counter_metric_value(&metrics, "bytes_scanned"));+ assert_eq!(collect_int32_values(stream).await, vec![1, 1, 1, 1]);+ }+ assert!(bloom_bytes[1] > 0, "partial row group needs Bloom I/O");+ assert!(+ bloom_bytes[1] < bloom_bytes[0],+ "fully matched row group should not load Bloom filters: {bloom_bytes:?}"+ );++ let all_matched = record_batch!(("a", Int32, vec![1, 1, 1])).unwrap();+ let data_size = write_parquet_batches(+ Arc::clone(&store),+ "all-matched.parquet",+ vec![all_matched],+ Some(+ WriterProperties::builder()+ .set_bloom_filter_enabled(true)+ .set_statistics_enabled(EnabledStatistics::Chunk)+ .build(),+ ),+ )+ .await;+ let metrics = ExecutionPlanMetricsSet::new();+ let morselizer = ParquetMorselizerBuilder::new()+ .with_store(Arc::clone(&store))+ .with_schema(Arc::clone(&schema))+ .with_predicate(predicate)+ .with_pushdown_filters(true)+ .with_row_group_stats_pruning(true)+ .with_enable_bloom_filter(true)+ .with_metrics(metrics.clone())+ .build();+ let stream = open_file(+ &morselizer,+ PartitionedFile::new("all-matched.parquet".to_string(), data_size as u64),+ )+ .await+ .unwrap();+ assert_eq!(counter_metric_value(&metrics, "bytes_scanned"), 0);+ assert_eq!(collect_int32_values(stream).await, vec![1, 1, 1]);+ }+#[test]fn should_load_page_index_with_row_selection() {use parquet::arrow::arrow_reader::{RowSelection, RowSelector};diff --git a/datafusion/datasource-parquet/src/row_group_filter.rs b/datafusion/datasource-parquet/src/row_group_filter.rsindex a88912d0c2..626ae46445 100644--- a/datafusion/datasource-parquet/src/row_group_filter.rs+++ b/datafusion/datasource-parquet/src/row_group_filter.rs@@ -451,6 +451,11 @@ impl RowGroupAccessPlanFilter {continue;}+ if self.access_plan.is_fully_matched(idx) {+ metrics.row_groups_pruned_bloom_filter.add_matched(1);+ continue;+ }+// A row group without any loaded bloom filter cannot be pruned by this pass: with no// bloom statistics to consult, evaluation can only conclude "may match". Skip the// evaluation in that case: it runs once per row group and can be expensive for wide