From 95fe8e8406448c3cd757644854100984eeeac5f8 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Sat, 9 Nov 2024 00:11:28 +0000
Subject: [PATCH 01/85] Initial stuff for reading bloom filter from PQ files

---
 .../io/parquet/compact_protocol_reader.cpp    |  33 +++-
 .../io/parquet/compact_protocol_reader.hpp    |   4 +
 cpp/src/io/parquet/parquet.hpp                |  45 +++++
 .../io/parquet/reader_apply_bloom_filters.cu  |  36 ++++
 cpp/src/io/parquet/reader_impl_helpers.cpp    | 178 ++++++++++++++++++
 cpp/src/io/parquet/reader_impl_helpers.hpp    |  25 ++-
 cpp/src/io/parquet/reader_impl_preprocess.cu  |   3 +-
 7 files changed, 321 insertions(+), 3 deletions(-)
 create mode 100644 cpp/src/io/parquet/reader_apply_bloom_filters.cu

diff --git a/cpp/src/io/parquet/compact_protocol_reader.cpp b/cpp/src/io/parquet/compact_protocol_reader.cpp
index d276e946a51..55874822ade 100644
--- a/cpp/src/io/parquet/compact_protocol_reader.cpp
+++ b/cpp/src/io/parquet/compact_protocol_reader.cpp
@@ -655,6 +655,33 @@ void CompactProtocolReader::read(ColumnChunk* c)
   function_builder(this, op);
 }
 
+void CompactProtocolReader::read(BloomFilterAlgorithm* alg)
+{
+  auto op = std::make_tuple(parquet_field_union_enumerator(1, alg->algorithm));
+  function_builder(this, op);
+}
+
+void CompactProtocolReader::read(BloomFilterHash* hash)
+{
+  auto op = std::make_tuple(parquet_field_union_enumerator(1, hash->hash));
+  function_builder(this, op);
+}
+
+void CompactProtocolReader::read(BloomFilterCompression* comp)
+{
+  auto op = std::make_tuple(parquet_field_union_enumerator(1, comp->compression));
+  function_builder(this, op);
+}
+
+void CompactProtocolReader::read(BloomFilterHeader* bf)
+{
+  auto op = std::make_tuple(parquet_field_int32(1, bf->num_bytes),
+                            parquet_field_struct(2, bf->algorithm),
+                            parquet_field_struct(3, bf->hash),
+                            parquet_field_struct(4, bf->compression));
+  function_builder(this, op);
+}
+
 void CompactProtocolReader::read(ColumnChunkMetaData* c)
 {
   using optional_size_statistics =
@@ -662,7 +689,9 @@ void CompactProtocolReader::read(ColumnChunkMetaData* c)
   using optional_list_enc_stats =
     parquet_field_optional<std::vector<PageEncodingStats>,
                            parquet_field_struct_list<PageEncodingStats>>;
-  auto op = std::make_tuple(parquet_field_enum<Type>(1, c->type),
+  using optional_i64 = parquet_field_optional<int64_t, parquet_field_int64>;
+  using optional_i32 = parquet_field_optional<int32_t, parquet_field_int32>;
+  auto op            = std::make_tuple(parquet_field_enum<Type>(1, c->type),
                             parquet_field_enum_list(2, c->encodings),
                             parquet_field_string_list(3, c->path_in_schema),
                             parquet_field_enum<Compression>(4, c->codec),
@@ -674,6 +703,8 @@ void CompactProtocolReader::read(ColumnChunkMetaData* c)
                             parquet_field_int64(11, c->dictionary_page_offset),
                             parquet_field_struct(12, c->statistics),
                             optional_list_enc_stats(13, c->encoding_stats),
+                            optional_i64(14, c->bloom_filter_offset),
+                            optional_i32(15, c->bloom_filter_length),
                             optional_size_statistics(16, c->size_statistics));
   function_builder(this, op);
 }
diff --git a/cpp/src/io/parquet/compact_protocol_reader.hpp b/cpp/src/io/parquet/compact_protocol_reader.hpp
index b87f2e9c692..3d39daa60d1 100644
--- a/cpp/src/io/parquet/compact_protocol_reader.hpp
+++ b/cpp/src/io/parquet/compact_protocol_reader.hpp
@@ -108,6 +108,10 @@ class CompactProtocolReader {
   void read(IntType* t);
   void read(RowGroup* r);
   void read(ColumnChunk* c);
+  void read(BloomFilterAlgorithm* bf);
+  void read(BloomFilterHash* bf);
+  void read(BloomFilterCompression* bf);
+  void read(BloomFilterHeader* bf);
   void read(ColumnChunkMetaData* c);
   void read(PageHeader* p);
   void read(DataPageHeader* d);
diff --git a/cpp/src/io/parquet/parquet.hpp b/cpp/src/io/parquet/parquet.hpp
index 2851ef67a65..118ec43133b 100644
--- a/cpp/src/io/parquet/parquet.hpp
+++ b/cpp/src/io/parquet/parquet.hpp
@@ -382,12 +382,57 @@ struct ColumnChunkMetaData {
   // Set of all encodings used for pages in this column chunk. This information can be used to
   // determine if all data pages are dictionary encoded for example.
   std::optional<std::vector<PageEncodingStats>> encoding_stats;
+  // Byte offset from beginning of file to Bloom filter data.
+  std::optional<int64_t> bloom_filter_offset;
+  // Size of Bloom filter data including the serialized header, in bytes. Added in 2.10 so readers
+  // may not read this field from old files and it can be obtained after the BloomFilterHeader has
+  // been deserialized. Writers should write this field so readers can read the bloom filter in a
+  // single I/O.
+  std::optional<int32_t> bloom_filter_length;
   // Optional statistics to help estimate total memory when converted to in-memory representations.
   // The histograms contained in these statistics can also be useful in some cases for more
   // fine-grained nullability/list length filter pushdown.
   std::optional<SizeStatistics> size_statistics;
 };
 
+/**
+ * @brief The algorithm used in Bloom filter.
+ **/
+struct BloomFilterAlgorithm {
+  /** Block-based Bloom filter. **/
+  enum Algorithm { UNDEFINED, SPLIT_BLOCK };
+  Algorithm algorithm{Algorithm::SPLIT_BLOCK};
+};
+
+/**
+ * @brief The hash function used in Bloom filter. This function takes the hash of a column value
+ * using plain encoding.
+ **/
+struct BloomFilterHash {
+  /** xxHash Strategy. **/
+  enum Hash { UNDEFINED, XXHASH };
+  Hash hash{Hash::XXHASH};
+};
+
+/**
+ * @brief The compression used in the Bloom filter.
+ **/
+struct BloomFilterCompression {
+  enum Compression { UNDEFINED, UNCOMPRESSED };
+  Compression compression{Compression::UNCOMPRESSED};
+};
+
+struct BloomFilterHeader {
+  // The size of bitset in bytes
+  int32_t num_bytes;
+  // The algorithm for setting bits. *
+  BloomFilterAlgorithm algorithm;
+  // The hash function used for Bloom filter. *
+  BloomFilterHash hash;
+  // The compression used in the Bloom filter *
+  BloomFilterCompression compression;
+};
+
 /**
  * @brief Thrift-derived struct describing a chunk of data for a particular
  * column
diff --git a/cpp/src/io/parquet/reader_apply_bloom_filters.cu b/cpp/src/io/parquet/reader_apply_bloom_filters.cu
new file mode 100644
index 00000000000..2d1c20ba48c
--- /dev/null
+++ b/cpp/src/io/parquet/reader_apply_bloom_filters.cu
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file bloom_filter_reader.cu
+ * @brief Bloom filter reader based row group filtration implementation
+ */
+
+#include "parquet.hpp"
+#include "parquet_common.hpp"
+
+#include <cudf/utilities/error.hpp>
+
+#include <cuco/bloom_filter.cuh>
+
+#include <algorithm>
+#include <cstddef>
+#include <functional>
+#include <optional>
+#include <tuple>
+
+// TODO: Implement this
+cuda::std::optional<std::vector<std::vector<cudf::size_type>>> apply_bloom_filters() { return {}; }
\ No newline at end of file
diff --git a/cpp/src/io/parquet/reader_impl_helpers.cpp b/cpp/src/io/parquet/reader_impl_helpers.cpp
index a6562d33de2..b6348a3f897 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.cpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.cpp
@@ -25,11 +25,16 @@
 
 #include <cudf/detail/utilities/logger.hpp>
 
+#include <rmm/cuda_stream_view.hpp>
+#include <rmm/device_buffer.hpp>
+
 #include <thrust/iterator/counting_iterator.h>
 #include <thrust/iterator/zip_iterator.h>
 
 #include <functional>
+#include <future>
 #include <numeric>
+#include <optional>
 #include <regex>
 
 namespace cudf::io::parquet::detail {
@@ -1028,8 +1033,169 @@ std::vector<std::string> aggregate_reader_metadata::get_pandas_index_names() con
   return names;
 }
 
+/**
+ * @brief Asynchronously reads bloom filters to device.
+ *
+ * @param sources Dataset sources
+ * @param bloom_filter_data Devicebuffers to hold bloom filter bitsets for each chunk
+ * @param chunks List of chunk indices to read
+ * @param bloom_filter_offsets Bloom filter offsets for all chunks
+ * @param bloom_filter_sizes Bloom filter sizes for all chunks
+ * @param chunk_source_map Association between each column chunk and its source
+ * @param stream CUDA stream used for device memory operations and kernel launches
+ *
+ * @return A future object for reading synchronization
+ */
+std::future<void> read_bloom_filters_async(
+  host_span<std::unique_ptr<datasource> const> sources,
+  cudf::host_span<rmm::device_buffer> bloom_filter_data,
+  host_span<size_type const> chunks,
+  cudf::host_span<std::optional<int64_t>> bloom_filter_offsets,
+  cudf::host_span<std::optional<int32_t>> bloom_filter_sizes,
+  std::vector<size_type> const& chunk_source_map,
+  rmm::cuda_stream_view stream)
+{
+  // Transfer bloom filter data
+  std::vector<std::future<size_t>> read_tasks;
+
+  // FIXME: Do not read all chunks. Instead use a list of chunks to read.
+  for (auto chunk : chunks) {
+    // Read bloom filter if present
+    if (bloom_filter_offsets[chunk].has_value()) {
+      auto const bloom_filter_offset = bloom_filter_offsets[chunk].value();
+      // If Bloom filter size (header + bitset) is available, just read the entire thing.
+      // Else just read 256 bytes which will contain the entire header and may contain the
+      // entire bitset as well.
+      auto constexpr bloom_filter_header_size_guess = 256;
+      auto const initial_read_size =
+        bloom_filter_sizes[chunk].value_or(bloom_filter_header_size_guess);
+
+      // Read an initial buffer from source
+      auto& source = sources[chunk_source_map[chunk]];
+      auto buffer  = source->host_read(bloom_filter_offset, initial_read_size);
+
+      // Deserialize the Bloom filter header from the buffer.
+      BloomFilterHeader header;
+      CompactProtocolReader cp{buffer->data(), buffer->size()};
+      cp.read(&header);
+
+      // Bloom filter header size
+      auto const bloom_filter_header_size = static_cast<int64_t>(cp.bytecount());
+      auto const bitset_size              = header.num_bytes;
+
+      // Check if we already read in the filter bitset in the initial read.
+      if (initial_read_size >= bloom_filter_header_size + bitset_size) {
+        bloom_filter_data[chunk] =
+          rmm::device_buffer(buffer->data() + bloom_filter_header_size, bitset_size, stream);
+      }
+      // Read the bitset from datasource.
+      else {
+        auto const bitset_offset = bloom_filter_offset + bloom_filter_header_size;
+        // Directly read to device if preferred
+        if (source->is_device_read_preferred(bitset_size)) {
+          bloom_filter_data[chunk] = rmm::device_buffer(bitset_size, stream);
+          auto future_read_size =
+            source->device_read_async(bitset_offset,
+                                      bitset_size,
+                                      static_cast<uint8_t*>(bloom_filter_data[chunk].data()),
+                                      stream);
+
+          read_tasks.emplace_back(std::move(future_read_size));
+        } else {
+          buffer                   = source->host_read(bitset_offset, bitset_size);
+          bloom_filter_data[chunk] = rmm::device_buffer(buffer->data(), buffer->size(), stream);
+        }
+      }
+    }
+  }
+  auto sync_fn = [](decltype(read_tasks) read_tasks) {
+    for (auto& task : read_tasks) {
+      task.wait();
+    }
+  };
+  return std::async(std::launch::deferred, sync_fn, std::move(read_tasks));
+}
+
+std::optional<std::vector<std::vector<size_type>>>
+aggregate_reader_metadata::apply_bloom_filter_to_row_groups(
+  host_span<std::unique_ptr<datasource> const> sources,
+  host_span<std::vector<size_type> const> row_group_indices,
+  host_span<data_type const> output_dtypes,
+  host_span<int const> output_column_schemas,
+  rmm::cuda_stream_view stream) const
+{
+  // Number of row groups after filter_row_groups().
+  auto const num_row_groups = std::accumulate(
+    row_group_indices.begin(), row_group_indices.end(), 0, [](auto& sum, auto const& rgis) {
+      return sum + rgis.size();
+    });
+  // Descriptors for all the chunks that make up the selected columns
+  auto const num_input_columns = output_dtypes.size();
+  auto const num_chunks        = num_row_groups * num_input_columns;
+
+  // Association between each column chunk and its source
+  std::vector<size_type> chunk_source_map(num_chunks);
+
+  // Keep track of column chunk file offsets
+  std::vector<std::optional<int64_t>> bloom_filter_offsets(num_chunks);
+  std::vector<std::optional<int32_t>> bloom_filter_sizes(num_chunks);
+
+  // List of chunks to read
+  std::vector<size_type> chunks_to_read{};
+  chunks_to_read.reserve(num_chunks);
+
+  size_type chunk_count = 0;
+
+  // FIXME: We don't need to read bloom filters for all chunks. Only the ones belonging to the
+  // columns of our interest (equality predicate).
+  // For all data sources
+  for (size_t rg_source_index = 0; rg_source_index < row_group_indices.size(); rg_source_index++) {
+    auto const& rg_index = row_group_indices[rg_source_index];
+    // For all row groups in a data source
+    for (auto const rgi : rg_index) {
+      // For all column chunks in a row group
+      for (size_t col_idx = 0; col_idx < output_dtypes.size(); col_idx++) {
+        auto const schema_idx = output_column_schemas[col_idx];
+        auto& col_meta        = get_column_metadata(rgi, rg_source_index, schema_idx);
+
+        // Bloom filter offsets and sizes
+        bloom_filter_offsets[chunk_count] = col_meta.bloom_filter_offset;
+        bloom_filter_sizes[chunk_count]   = col_meta.bloom_filter_length;
+        chunks_to_read.emplace_back(chunk_count);
+
+        // Map each column chunk to its column index and its source index
+        chunk_source_map[chunk_count] = rg_source_index;
+        chunk_count++;
+      }
+    }
+  }
+
+  // Do we have any bloom filters
+  if (std::any_of(bloom_filter_offsets.cbegin(),
+                  bloom_filter_offsets.cend(),
+                  [](auto const offset) { return offset.has_value(); })) {
+    // Initialize the vector of bloom filter data buffers
+    std::vector<rmm::device_buffer> bloom_filter_data(num_chunks);
+
+    // Wait on bloom filter read tasks
+    read_bloom_filters_async(sources,
+                             bloom_filter_data,
+                             chunks_to_read,
+                             bloom_filter_offsets,
+                             bloom_filter_sizes,
+                             chunk_source_map,
+                             stream)
+      .wait();
+
+    // Apply bloom filter to row groups
+    // return apply_bloom_filters();
+  }
+  return {};
+}
+
 std::tuple<int64_t, size_type, std::vector<row_group_info>, std::vector<size_t>>
 aggregate_reader_metadata::select_row_groups(
+  host_span<std::unique_ptr<datasource> const> sources,
   host_span<std::vector<size_type> const> row_group_indices,
   int64_t skip_rows_opt,
   std::optional<size_type> const& num_rows_opt,
@@ -1048,6 +1214,18 @@ aggregate_reader_metadata::select_row_groups(
         host_span<std::vector<size_type> const>(filtered_row_group_indices.value());
     }
   }
+
+  // FIXME: Provide the actual condition for this if
+  if (true /* equality predicate provided */) {
+    filtered_row_group_indices = apply_bloom_filter_to_row_groups(
+      sources, row_group_indices, output_dtypes, output_column_schemas, stream);
+
+    if (filtered_row_group_indices.has_value()) {
+      row_group_indices =
+        host_span<std::vector<size_type> const>(filtered_row_group_indices.value());
+    }
+  }
+
   std::vector<row_group_info> selection;
   auto [rows_to_skip, rows_to_read] = [&]() {
     if (not row_group_indices.empty()) { return std::pair<int64_t, size_type>{}; }
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index fd692c0cdd6..82228599cd4 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -343,6 +343,7 @@ class aggregate_reader_metadata {
    * The input `row_start` and `row_count` parameters will be recomputed and output as the valid
    * values based on the input row group list.
    *
+   * @param sources Lists of input datasources.
    * @param row_group_indices Lists of row groups to read, one per source
    * @param row_start Starting row of the selection
    * @param row_count Total number of rows selected
@@ -354,7 +355,8 @@ class aggregate_reader_metadata {
    *         starting row, and list of number of rows per source.
    */
   [[nodiscard]] std::tuple<int64_t, size_type, std::vector<row_group_info>, std::vector<size_t>>
-  select_row_groups(host_span<std::vector<size_type> const> row_group_indices,
+  select_row_groups(host_span<std::unique_ptr<datasource> const> sources,
+                    host_span<std::vector<size_type> const> row_group_indices,
                     int64_t row_start,
                     std::optional<size_type> const& row_count,
                     host_span<data_type const> output_dtypes,
@@ -362,6 +364,27 @@ class aggregate_reader_metadata {
                     std::optional<std::reference_wrapper<ast::expression const>> filter,
                     rmm::cuda_stream_view stream) const;
 
+  /**
+   * @brief Filters the row groups using bloom filters
+   *
+   * @param sources Dataset sources
+   * @param bloom_filter_data Devicebuffers to hold bloom filter bitsets for each chunk
+   * @param begin_chunk Index of first column chunk to read
+   * @param end_chunk Index after the last column chunk to read
+   * @param bloom_filter_offsets Bloom filter offsets for all chunks
+   * @param bloom_filter_sizes Bloom filter sizes for all chunks
+   * @param chunk_source_map Association between each column chunk and its source
+   * @param stream CUDA stream used for device memory operations and kernel launches
+   *
+   * @return Filtered row group indices, if any is filtered.
+   */
+  std::optional<std::vector<std::vector<size_type>>> apply_bloom_filter_to_row_groups(
+    host_span<std::unique_ptr<datasource> const> sources,
+    host_span<std::vector<size_type> const> row_group_indices,
+    host_span<data_type const> output_dtypes,
+    host_span<int const> output_column_schemas,
+    rmm::cuda_stream_view stream) const;
+
   /**
    * @brief Filters and reduces down to a selection of columns
    *
diff --git a/cpp/src/io/parquet/reader_impl_preprocess.cu b/cpp/src/io/parquet/reader_impl_preprocess.cu
index f03f1214b9a..7c169f0e6ca 100644
--- a/cpp/src/io/parquet/reader_impl_preprocess.cu
+++ b/cpp/src/io/parquet/reader_impl_preprocess.cu
@@ -1281,7 +1281,8 @@ void reader::impl::preprocess_file(read_mode mode)
            _file_itm_data.global_num_rows,
            _file_itm_data.row_groups,
            _file_itm_data.num_rows_per_source) =
-    _metadata->select_row_groups(_options.row_group_indices,
+    _metadata->select_row_groups(_sources,
+                                 _options.row_group_indices,
                                  _options.skip_rows,
                                  _options.num_rows,
                                  output_dtypes,

From 4f0e7ab2b309a9cf7cb552523850fd4298df76c4 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Sat, 9 Nov 2024 00:22:21 +0000
Subject: [PATCH 02/85] Minor bug fix

---
 cpp/src/io/parquet/reader_impl_helpers.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/cpp/src/io/parquet/reader_impl_helpers.cpp b/cpp/src/io/parquet/reader_impl_helpers.cpp
index b6348a3f897..da000edfd04 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.cpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.cpp
@@ -1215,12 +1215,13 @@ aggregate_reader_metadata::select_row_groups(
     }
   }
 
-  // FIXME: Provide the actual condition for this if
+  // FIXME: Provide the actual condition for this
   if (true /* equality predicate provided */) {
-    filtered_row_group_indices = apply_bloom_filter_to_row_groups(
+    auto const bloom_filtered_row_groups = apply_bloom_filter_to_row_groups(
       sources, row_group_indices, output_dtypes, output_column_schemas, stream);
-
-    if (filtered_row_group_indices.has_value()) {
+    // TODO: Can use a better logic here.
+    if (bloom_filtered_row_groups.has_value()) {
+      filtered_row_group_indices.value() = std::move(bloom_filtered_row_groups.value());
       row_group_indices =
         host_span<std::vector<size_type> const>(filtered_row_group_indices.value());
     }

From 48a50c401aafb12bf7f29645092601b174a822f8 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Sat, 9 Nov 2024 00:22:55 +0000
Subject: [PATCH 03/85] Apply style fix

---
 cpp/src/io/parquet/reader_apply_bloom_filters.cu | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/io/parquet/reader_apply_bloom_filters.cu b/cpp/src/io/parquet/reader_apply_bloom_filters.cu
index 2d1c20ba48c..fc85a0a1eb2 100644
--- a/cpp/src/io/parquet/reader_apply_bloom_filters.cu
+++ b/cpp/src/io/parquet/reader_apply_bloom_filters.cu
@@ -33,4 +33,4 @@
 #include <tuple>
 
 // TODO: Implement this
-cuda::std::optional<std::vector<std::vector<cudf::size_type>>> apply_bloom_filters() { return {}; }
\ No newline at end of file
+cuda::std::optional<std::vector<std::vector<cudf::size_type>>> apply_bloom_filters() { return {}; }

From 68be24f204857c75ea10b85aebf6209d50677929 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Sat, 16 Nov 2024 03:12:55 +0000
Subject: [PATCH 04/85] Some updates

---
 cpp/src/io/parquet/predicate_pushdown.cpp  | 14 +++++++
 cpp/src/io/parquet/reader_impl_helpers.cpp | 44 +++++++++++++---------
 cpp/src/io/parquet/reader_impl_helpers.hpp |  2 +
 3 files changed, 43 insertions(+), 17 deletions(-)

diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp
index cd3dcd2bce4..abc8978d8db 100644
--- a/cpp/src/io/parquet/predicate_pushdown.cpp
+++ b/cpp/src/io/parquet/predicate_pushdown.cpp
@@ -391,6 +391,7 @@ class stats_expression_converter : public ast::detail::expression_transformer {
 }  // namespace
 
 std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::filter_row_groups(
+  host_span<std::unique_ptr<datasource> const> sources,
   host_span<std::vector<size_type> const> row_group_indices,
   host_span<data_type const> output_dtypes,
   host_span<int const> output_column_schemas,
@@ -491,6 +492,19 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
     }
     filtered_row_group_indices.push_back(std::move(filtered_row_groups));
   }
+
+  // If equality predicate
+  if (true /* is_equality_predicate */) {
+    filtered_row_group_indices =
+      apply_bloom_filter_to_row_groups(
+        sources,
+        filtered_row_group_indices.empty() ? input_row_group_indices : filtered_row_group_indices,
+        output_dtypes,
+        output_column_schemas,
+        stream)
+        .value();
+  }
+
   return {std::move(filtered_row_group_indices)};
 }
 
diff --git a/cpp/src/io/parquet/reader_impl_helpers.cpp b/cpp/src/io/parquet/reader_impl_helpers.cpp
index da000edfd04..7ca1ffc4253 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.cpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.cpp
@@ -1079,6 +1079,20 @@ std::future<void> read_bloom_filters_async(
       CompactProtocolReader cp{buffer->data(), buffer->size()};
       cp.read(&header);
 
+      // Test if header is valid.
+      auto const is_header_valid =
+        (header.num_bytes % 32) == 0 and
+        header.compression.compression == BloomFilterCompression::Compression::UNCOMPRESSED and
+        header.algorithm.algorithm == BloomFilterAlgorithm::Algorithm::SPLIT_BLOCK and
+        header.hash.hash == BloomFilterHash::Hash::XXHASH;
+
+      if (not is_header_valid) {
+        // Simply use an empty device buffer and move on.
+        bloom_filter_data[chunk] = rmm::device_buffer{};
+        CUDF_LOG_WARN("Encountered an invalid bloom filter header. Skipping");
+        continue;
+      }
+
       // Bloom filter header size
       auto const bloom_filter_header_size = static_cast<int64_t>(cp.bytecount());
       auto const bitset_size              = header.num_bytes;
@@ -1106,6 +1120,9 @@ std::future<void> read_bloom_filters_async(
           bloom_filter_data[chunk] = rmm::device_buffer(buffer->data(), buffer->size(), stream);
         }
       }
+    } else {
+      // Simply use an empty device buffer.
+      bloom_filter_data[chunk] = rmm::device_buffer{};
     }
   }
   auto sync_fn = [](decltype(read_tasks) read_tasks) {
@@ -1124,11 +1141,16 @@ aggregate_reader_metadata::apply_bloom_filter_to_row_groups(
   host_span<int const> output_column_schemas,
   rmm::cuda_stream_view stream) const
 {
-  // Number of row groups after filter_row_groups().
-  auto const num_row_groups = std::accumulate(
-    row_group_indices.begin(), row_group_indices.end(), 0, [](auto& sum, auto const& rgis) {
-      return sum + rgis.size();
-    });
+  // Create row group indices.
+  // std::vector<std::vector<size_type>> filtered_row_group_indices;
+  // Number of total row groups to process.
+  auto const num_row_groups = std::accumulate(row_group_indices.begin(),
+                                              row_group_indices.end(),
+                                              0,
+                                              [](size_type sum, auto const& per_file_row_groups) {
+                                                return sum + per_file_row_groups.size();
+                                              });
+
   // Descriptors for all the chunks that make up the selected columns
   auto const num_input_columns = output_dtypes.size();
   auto const num_chunks        = num_row_groups * num_input_columns;
@@ -1215,18 +1237,6 @@ aggregate_reader_metadata::select_row_groups(
     }
   }
 
-  // FIXME: Provide the actual condition for this
-  if (true /* equality predicate provided */) {
-    auto const bloom_filtered_row_groups = apply_bloom_filter_to_row_groups(
-      sources, row_group_indices, output_dtypes, output_column_schemas, stream);
-    // TODO: Can use a better logic here.
-    if (bloom_filtered_row_groups.has_value()) {
-      filtered_row_group_indices.value() = std::move(bloom_filtered_row_groups.value());
-      row_group_indices =
-        host_span<std::vector<size_type> const>(filtered_row_group_indices.value());
-    }
-  }
-
   std::vector<row_group_info> selection;
   auto [rows_to_skip, rows_to_read] = [&]() {
     if (not row_group_indices.empty()) { return std::pair<int64_t, size_type>{}; }
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index 82228599cd4..7faae405b4a 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -323,6 +323,7 @@ class aggregate_reader_metadata {
   /**
    * @brief Filters the row groups based on predicate filter
    *
+   * @param sources Lists of input datasources.
    * @param row_group_indices Lists of row groups to read, one per source
    * @param output_dtypes Datatypes of of output columns
    * @param output_column_schemas schema indices of output columns
@@ -331,6 +332,7 @@ class aggregate_reader_metadata {
    * @return Filtered row group indices, if any is filtered.
    */
   [[nodiscard]] std::optional<std::vector<std::vector<size_type>>> filter_row_groups(
+    host_span<std::unique_ptr<datasource> const> sources,
     host_span<std::vector<size_type> const> row_group_indices,
     host_span<data_type const> output_dtypes,
     host_span<int const> output_column_schemas,

From f84825126e3eba2a3d3bd7ed7e11e341541687ed Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Sat, 16 Nov 2024 05:04:13 +0000
Subject: [PATCH 05/85] Move contents to a separate file

---
 cpp/src/io/parquet/bloom_filter_reader.cpp | 209 +++++++++++++++++++++
 cpp/src/io/parquet/predicate_pushdown.cpp  |  12 --
 cpp/src/io/parquet/reader_impl_helpers.cpp | 184 +-----------------
 cpp/src/io/parquet/reader_impl_helpers.hpp |  19 +-
 4 files changed, 218 insertions(+), 206 deletions(-)
 create mode 100644 cpp/src/io/parquet/bloom_filter_reader.cpp

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cpp b/cpp/src/io/parquet/bloom_filter_reader.cpp
new file mode 100644
index 00000000000..346ccd22c58
--- /dev/null
+++ b/cpp/src/io/parquet/bloom_filter_reader.cpp
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "compact_protocol_reader.hpp"
+#include "io/parquet/parquet.hpp"
+#include "reader_impl_helpers.hpp"
+
+#include <cudf/detail/utilities/logger.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
+#include <rmm/device_buffer.hpp>
+
+#include <thrust/iterator/counting_iterator.h>
+
+#include <future>
+#include <numeric>
+#include <optional>
+
+namespace cudf::io::parquet::detail {
+
+namespace {
+/**
+ * @brief Asynchronously reads bloom filters to device.
+ *
+ * @param sources Dataset sources
+ * @param num_chunks Number of total column chunks to read
+ * @param bloom_filter_data Devicebuffers to hold bloom filter bitsets for each chunk
+ * @param bloom_filter_offsets Bloom filter offsets for all chunks
+ * @param bloom_filter_sizes Bloom filter sizes for all chunks
+ * @param chunk_source_map Association between each column chunk and its source
+ * @param stream CUDA stream used for device memory operations and kernel launches
+ *
+ * @return A future object for reading synchronization
+ */
+std::future<void> read_bloom_filters_async(
+  host_span<std::unique_ptr<datasource> const> sources,
+  size_t num_chunks,
+  cudf::host_span<rmm::device_buffer> bloom_filter_data,
+  cudf::host_span<std::optional<int64_t>> bloom_filter_offsets,
+  cudf::host_span<std::optional<int32_t>> bloom_filter_sizes,
+  std::vector<size_type> const& chunk_source_map,
+  rmm::cuda_stream_view stream)
+{
+  // Read tasks for bloom filter data
+  std::vector<std::future<size_t>> read_tasks;
+
+  // Read bloom filters for all column chunks
+  std::for_each(
+    thrust::make_counting_iterator<size_t>(0),
+    thrust::make_counting_iterator<size_t>(num_chunks),
+    [&](auto const chunk) {
+      // Read bloom filter if present
+      if (bloom_filter_offsets[chunk].has_value()) {
+        auto const bloom_filter_offset = bloom_filter_offsets[chunk].value();
+        // If Bloom filter size (header + bitset) is available, just read the entire thing.
+        // Else just read 256 bytes which will contain the entire header and may contain the
+        // entire bitset as well.
+        auto constexpr bloom_filter_header_size_guess = 256;
+        auto const initial_read_size =
+          bloom_filter_sizes[chunk].value_or(bloom_filter_header_size_guess);
+
+        // Read an initial buffer from source
+        auto& source = sources[chunk_source_map[chunk]];
+        auto buffer  = source->host_read(bloom_filter_offset, initial_read_size);
+
+        // Deserialize the Bloom filter header from the buffer.
+        BloomFilterHeader header;
+        CompactProtocolReader cp{buffer->data(), buffer->size()};
+        cp.read(&header);
+
+        // Test if header is valid.
+        auto const is_header_valid =
+          (header.num_bytes % 32) == 0 and
+          header.compression.compression == BloomFilterCompression::Compression::UNCOMPRESSED and
+          header.algorithm.algorithm == BloomFilterAlgorithm::Algorithm::SPLIT_BLOCK and
+          header.hash.hash == BloomFilterHash::Hash::XXHASH;
+
+        // Do not read if the bloom filter is invalid
+        if (not is_header_valid) {
+          CUDF_LOG_WARN("Encountered an invalid bloom filter header. Skipping");
+          return;
+        }
+
+        // Bloom filter header size
+        auto const bloom_filter_header_size = static_cast<int64_t>(cp.bytecount());
+        auto const bitset_size              = header.num_bytes;
+
+        // Check if we already read in the filter bitset in the initial read.
+        if (initial_read_size >= bloom_filter_header_size + bitset_size) {
+          bloom_filter_data[chunk] =
+            rmm::device_buffer(buffer->data() + bloom_filter_header_size, bitset_size, stream);
+        }
+        // Read the bitset from datasource.
+        else {
+          auto const bitset_offset = bloom_filter_offset + bloom_filter_header_size;
+          // Directly read to device if preferred
+          if (source->is_device_read_preferred(bitset_size)) {
+            bloom_filter_data[chunk] = rmm::device_buffer(bitset_size, stream);
+            auto future_read_size =
+              source->device_read_async(bitset_offset,
+                                        bitset_size,
+                                        static_cast<uint8_t*>(bloom_filter_data[chunk].data()),
+                                        stream);
+
+            read_tasks.emplace_back(std::move(future_read_size));
+          } else {
+            buffer                   = source->host_read(bitset_offset, bitset_size);
+            bloom_filter_data[chunk] = rmm::device_buffer(buffer->data(), buffer->size(), stream);
+          }
+        }
+      }
+    });
+  auto sync_fn = [](decltype(read_tasks) read_tasks) {
+    for (auto& task : read_tasks) {
+      task.wait();
+    }
+  };
+  return std::async(std::launch::deferred, sync_fn, std::move(read_tasks));
+}
+
+}  // namespace
+
+std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
+  host_span<std::unique_ptr<datasource> const> sources,
+  host_span<std::vector<size_type> const> row_group_indices,
+  host_span<int const> column_schemas,
+  rmm::cuda_stream_view stream) const
+{
+  // Number of total row groups to process.
+  auto const num_row_groups = std::accumulate(
+    row_group_indices.begin(),
+    row_group_indices.end(),
+    size_t{0},
+    [](size_t sum, auto const& per_file_row_groups) { return sum + per_file_row_groups.size(); });
+
+  // Descriptors for all the chunks that make up the selected columns
+  auto const num_input_columns = column_schemas.size();
+  auto const num_chunks        = num_row_groups * num_input_columns;
+
+  // Association between each column chunk and its source
+  std::vector<size_type> chunk_source_map(num_chunks);
+
+  // Keep track of column chunk file offsets
+  std::vector<std::optional<int64_t>> bloom_filter_offsets(num_chunks);
+  std::vector<std::optional<int32_t>> bloom_filter_sizes(num_chunks);
+
+  // Gather all bloom filter offsets and sizes.
+  size_type chunk_count = 0;
+
+  // For all data sources
+  std::for_each(thrust::make_counting_iterator<size_t>(0),
+                thrust::make_counting_iterator(row_group_indices.size()),
+                [&](auto const src_index) {
+                  // Get all row group indices in the data source
+                  auto const& rg_indices = row_group_indices[src_index];
+                  // For all row groups
+                  std::for_each(rg_indices.cbegin(), rg_indices.cend(), [&](auto const rg_index) {
+                    // For all column chunks
+                    std::for_each(
+                      column_schemas.begin(), column_schemas.end(), [&](auto const schema_idx) {
+                        auto& col_meta = get_column_metadata(rg_index, src_index, schema_idx);
+
+                        // Get bloom filter offsets and sizes
+                        bloom_filter_offsets[chunk_count] = col_meta.bloom_filter_offset;
+                        bloom_filter_sizes[chunk_count]   = col_meta.bloom_filter_length;
+
+                        // Map each column chunk to its source index
+                        chunk_source_map[chunk_count] = src_index;
+                        chunk_count++;
+                      });
+                  });
+                });
+
+  // Do we have any bloom filters
+  if (std::any_of(bloom_filter_offsets.cbegin(),
+                  bloom_filter_offsets.cend(),
+                  [](auto const offset) { return offset.has_value(); })) {
+    // Create a vector to store bloom filter data
+    std::vector<rmm::device_buffer> bloom_filter_data(num_chunks);
+
+    // Wait on bloom filter read tasks
+    read_bloom_filters_async(sources,
+                             num_chunks,
+                             bloom_filter_data,
+                             bloom_filter_offsets,
+                             bloom_filter_sizes,
+                             chunk_source_map,
+                             stream)
+      .wait();
+    // Return the vector
+    return bloom_filter_data;
+  }
+  return {};
+}
+
+}  // namespace cudf::io::parquet::detail
\ No newline at end of file
diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp
index abc8978d8db..a977cfdeca7 100644
--- a/cpp/src/io/parquet/predicate_pushdown.cpp
+++ b/cpp/src/io/parquet/predicate_pushdown.cpp
@@ -493,18 +493,6 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
     filtered_row_group_indices.push_back(std::move(filtered_row_groups));
   }
 
-  // If equality predicate
-  if (true /* is_equality_predicate */) {
-    filtered_row_group_indices =
-      apply_bloom_filter_to_row_groups(
-        sources,
-        filtered_row_group_indices.empty() ? input_row_group_indices : filtered_row_group_indices,
-        output_dtypes,
-        output_column_schemas,
-        stream)
-        .value();
-  }
-
   return {std::move(filtered_row_group_indices)};
 }
 
diff --git a/cpp/src/io/parquet/reader_impl_helpers.cpp b/cpp/src/io/parquet/reader_impl_helpers.cpp
index 7ca1ffc4253..9c05009b528 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.cpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.cpp
@@ -1033,188 +1033,6 @@ std::vector<std::string> aggregate_reader_metadata::get_pandas_index_names() con
   return names;
 }
 
-/**
- * @brief Asynchronously reads bloom filters to device.
- *
- * @param sources Dataset sources
- * @param bloom_filter_data Devicebuffers to hold bloom filter bitsets for each chunk
- * @param chunks List of chunk indices to read
- * @param bloom_filter_offsets Bloom filter offsets for all chunks
- * @param bloom_filter_sizes Bloom filter sizes for all chunks
- * @param chunk_source_map Association between each column chunk and its source
- * @param stream CUDA stream used for device memory operations and kernel launches
- *
- * @return A future object for reading synchronization
- */
-std::future<void> read_bloom_filters_async(
-  host_span<std::unique_ptr<datasource> const> sources,
-  cudf::host_span<rmm::device_buffer> bloom_filter_data,
-  host_span<size_type const> chunks,
-  cudf::host_span<std::optional<int64_t>> bloom_filter_offsets,
-  cudf::host_span<std::optional<int32_t>> bloom_filter_sizes,
-  std::vector<size_type> const& chunk_source_map,
-  rmm::cuda_stream_view stream)
-{
-  // Transfer bloom filter data
-  std::vector<std::future<size_t>> read_tasks;
-
-  // FIXME: Do not read all chunks. Instead use a list of chunks to read.
-  for (auto chunk : chunks) {
-    // Read bloom filter if present
-    if (bloom_filter_offsets[chunk].has_value()) {
-      auto const bloom_filter_offset = bloom_filter_offsets[chunk].value();
-      // If Bloom filter size (header + bitset) is available, just read the entire thing.
-      // Else just read 256 bytes which will contain the entire header and may contain the
-      // entire bitset as well.
-      auto constexpr bloom_filter_header_size_guess = 256;
-      auto const initial_read_size =
-        bloom_filter_sizes[chunk].value_or(bloom_filter_header_size_guess);
-
-      // Read an initial buffer from source
-      auto& source = sources[chunk_source_map[chunk]];
-      auto buffer  = source->host_read(bloom_filter_offset, initial_read_size);
-
-      // Deserialize the Bloom filter header from the buffer.
-      BloomFilterHeader header;
-      CompactProtocolReader cp{buffer->data(), buffer->size()};
-      cp.read(&header);
-
-      // Test if header is valid.
-      auto const is_header_valid =
-        (header.num_bytes % 32) == 0 and
-        header.compression.compression == BloomFilterCompression::Compression::UNCOMPRESSED and
-        header.algorithm.algorithm == BloomFilterAlgorithm::Algorithm::SPLIT_BLOCK and
-        header.hash.hash == BloomFilterHash::Hash::XXHASH;
-
-      if (not is_header_valid) {
-        // Simply use an empty device buffer and move on.
-        bloom_filter_data[chunk] = rmm::device_buffer{};
-        CUDF_LOG_WARN("Encountered an invalid bloom filter header. Skipping");
-        continue;
-      }
-
-      // Bloom filter header size
-      auto const bloom_filter_header_size = static_cast<int64_t>(cp.bytecount());
-      auto const bitset_size              = header.num_bytes;
-
-      // Check if we already read in the filter bitset in the initial read.
-      if (initial_read_size >= bloom_filter_header_size + bitset_size) {
-        bloom_filter_data[chunk] =
-          rmm::device_buffer(buffer->data() + bloom_filter_header_size, bitset_size, stream);
-      }
-      // Read the bitset from datasource.
-      else {
-        auto const bitset_offset = bloom_filter_offset + bloom_filter_header_size;
-        // Directly read to device if preferred
-        if (source->is_device_read_preferred(bitset_size)) {
-          bloom_filter_data[chunk] = rmm::device_buffer(bitset_size, stream);
-          auto future_read_size =
-            source->device_read_async(bitset_offset,
-                                      bitset_size,
-                                      static_cast<uint8_t*>(bloom_filter_data[chunk].data()),
-                                      stream);
-
-          read_tasks.emplace_back(std::move(future_read_size));
-        } else {
-          buffer                   = source->host_read(bitset_offset, bitset_size);
-          bloom_filter_data[chunk] = rmm::device_buffer(buffer->data(), buffer->size(), stream);
-        }
-      }
-    } else {
-      // Simply use an empty device buffer.
-      bloom_filter_data[chunk] = rmm::device_buffer{};
-    }
-  }
-  auto sync_fn = [](decltype(read_tasks) read_tasks) {
-    for (auto& task : read_tasks) {
-      task.wait();
-    }
-  };
-  return std::async(std::launch::deferred, sync_fn, std::move(read_tasks));
-}
-
-std::optional<std::vector<std::vector<size_type>>>
-aggregate_reader_metadata::apply_bloom_filter_to_row_groups(
-  host_span<std::unique_ptr<datasource> const> sources,
-  host_span<std::vector<size_type> const> row_group_indices,
-  host_span<data_type const> output_dtypes,
-  host_span<int const> output_column_schemas,
-  rmm::cuda_stream_view stream) const
-{
-  // Create row group indices.
-  // std::vector<std::vector<size_type>> filtered_row_group_indices;
-  // Number of total row groups to process.
-  auto const num_row_groups = std::accumulate(row_group_indices.begin(),
-                                              row_group_indices.end(),
-                                              0,
-                                              [](size_type sum, auto const& per_file_row_groups) {
-                                                return sum + per_file_row_groups.size();
-                                              });
-
-  // Descriptors for all the chunks that make up the selected columns
-  auto const num_input_columns = output_dtypes.size();
-  auto const num_chunks        = num_row_groups * num_input_columns;
-
-  // Association between each column chunk and its source
-  std::vector<size_type> chunk_source_map(num_chunks);
-
-  // Keep track of column chunk file offsets
-  std::vector<std::optional<int64_t>> bloom_filter_offsets(num_chunks);
-  std::vector<std::optional<int32_t>> bloom_filter_sizes(num_chunks);
-
-  // List of chunks to read
-  std::vector<size_type> chunks_to_read{};
-  chunks_to_read.reserve(num_chunks);
-
-  size_type chunk_count = 0;
-
-  // FIXME: We don't need to read bloom filters for all chunks. Only the ones belonging to the
-  // columns of our interest (equality predicate).
-  // For all data sources
-  for (size_t rg_source_index = 0; rg_source_index < row_group_indices.size(); rg_source_index++) {
-    auto const& rg_index = row_group_indices[rg_source_index];
-    // For all row groups in a data source
-    for (auto const rgi : rg_index) {
-      // For all column chunks in a row group
-      for (size_t col_idx = 0; col_idx < output_dtypes.size(); col_idx++) {
-        auto const schema_idx = output_column_schemas[col_idx];
-        auto& col_meta        = get_column_metadata(rgi, rg_source_index, schema_idx);
-
-        // Bloom filter offsets and sizes
-        bloom_filter_offsets[chunk_count] = col_meta.bloom_filter_offset;
-        bloom_filter_sizes[chunk_count]   = col_meta.bloom_filter_length;
-        chunks_to_read.emplace_back(chunk_count);
-
-        // Map each column chunk to its column index and its source index
-        chunk_source_map[chunk_count] = rg_source_index;
-        chunk_count++;
-      }
-    }
-  }
-
-  // Do we have any bloom filters
-  if (std::any_of(bloom_filter_offsets.cbegin(),
-                  bloom_filter_offsets.cend(),
-                  [](auto const offset) { return offset.has_value(); })) {
-    // Initialize the vector of bloom filter data buffers
-    std::vector<rmm::device_buffer> bloom_filter_data(num_chunks);
-
-    // Wait on bloom filter read tasks
-    read_bloom_filters_async(sources,
-                             bloom_filter_data,
-                             chunks_to_read,
-                             bloom_filter_offsets,
-                             bloom_filter_sizes,
-                             chunk_source_map,
-                             stream)
-      .wait();
-
-    // Apply bloom filter to row groups
-    // return apply_bloom_filters();
-  }
-  return {};
-}
-
 std::tuple<int64_t, size_type, std::vector<row_group_info>, std::vector<size_t>>
 aggregate_reader_metadata::select_row_groups(
   host_span<std::unique_ptr<datasource> const> sources,
@@ -1230,7 +1048,7 @@ aggregate_reader_metadata::select_row_groups(
   // if filter is not empty, then gather row groups to read after predicate pushdown
   if (filter.has_value()) {
     filtered_row_group_indices = filter_row_groups(
-      row_group_indices, output_dtypes, output_column_schemas, filter.value(), stream);
+      sources, row_group_indices, output_dtypes, output_column_schemas, filter.value(), stream);
     if (filtered_row_group_indices.has_value()) {
       row_group_indices =
         host_span<std::vector<size_type> const>(filtered_row_group_indices.value());
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index 7faae405b4a..b03aa9ec296 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -367,24 +367,21 @@ class aggregate_reader_metadata {
                     rmm::cuda_stream_view stream) const;
 
   /**
-   * @brief Filters the row groups using bloom filters
+   * @brief Reads bloom filter bitsets for the specified columns from the given lists of row
+   * groups.
    *
    * @param sources Dataset sources
-   * @param bloom_filter_data Devicebuffers to hold bloom filter bitsets for each chunk
-   * @param begin_chunk Index of first column chunk to read
-   * @param end_chunk Index after the last column chunk to read
-   * @param bloom_filter_offsets Bloom filter offsets for all chunks
-   * @param bloom_filter_sizes Bloom filter sizes for all chunks
-   * @param chunk_source_map Association between each column chunk and its source
+   * @param row_group_indices Lists of row groups to read bloom filters from, one per source
+   * @param column_schemas Schema indices of columns whose bloom filters will be read
    * @param stream CUDA stream used for device memory operations and kernel launches
    *
-   * @return Filtered row group indices, if any is filtered.
+   * @return A list of bloom filter bitset device buffers flattened over column schemas over lists
+   * of row group indices
    */
-  std::optional<std::vector<std::vector<size_type>>> apply_bloom_filter_to_row_groups(
+  std::vector<rmm::device_buffer> read_bloom_filters(
     host_span<std::unique_ptr<datasource> const> sources,
     host_span<std::vector<size_type> const> row_group_indices,
-    host_span<data_type const> output_dtypes,
-    host_span<int const> output_column_schemas,
+    host_span<int const> column_schemas,
     rmm::cuda_stream_view stream) const;
 
   /**

From 0b65233026b5868aa81ac86d51327d1e1521d625 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Sat, 16 Nov 2024 05:06:19 +0000
Subject: [PATCH 06/85] Revert erroneous changes

---
 .../io/parquet/reader_apply_bloom_filters.cu  | 36 -------------------
 cpp/src/io/parquet/reader_impl_helpers.cpp    |  5 ---
 2 files changed, 41 deletions(-)
 delete mode 100644 cpp/src/io/parquet/reader_apply_bloom_filters.cu

diff --git a/cpp/src/io/parquet/reader_apply_bloom_filters.cu b/cpp/src/io/parquet/reader_apply_bloom_filters.cu
deleted file mode 100644
index fc85a0a1eb2..00000000000
--- a/cpp/src/io/parquet/reader_apply_bloom_filters.cu
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) 2024, NVIDIA CORPORATION.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * @file bloom_filter_reader.cu
- * @brief Bloom filter reader based row group filtration implementation
- */
-
-#include "parquet.hpp"
-#include "parquet_common.hpp"
-
-#include <cudf/utilities/error.hpp>
-
-#include <cuco/bloom_filter.cuh>
-
-#include <algorithm>
-#include <cstddef>
-#include <functional>
-#include <optional>
-#include <tuple>
-
-// TODO: Implement this
-cuda::std::optional<std::vector<std::vector<cudf::size_type>>> apply_bloom_filters() { return {}; }
diff --git a/cpp/src/io/parquet/reader_impl_helpers.cpp b/cpp/src/io/parquet/reader_impl_helpers.cpp
index 9c05009b528..ae720a9622d 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.cpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.cpp
@@ -25,16 +25,11 @@
 
 #include <cudf/detail/utilities/logger.hpp>
 
-#include <rmm/cuda_stream_view.hpp>
-#include <rmm/device_buffer.hpp>
-
 #include <thrust/iterator/counting_iterator.h>
 #include <thrust/iterator/zip_iterator.h>
 
 #include <functional>
-#include <future>
 #include <numeric>
-#include <optional>
 #include <regex>
 
 namespace cudf::io::parquet::detail {

From cf7d762e26847842993dd4383f49c2fd0ca591a5 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Sat, 16 Nov 2024 05:13:54 +0000
Subject: [PATCH 07/85] Style and doc fix

---
 cpp/src/io/parquet/bloom_filter_reader.cpp |  2 +-
 cpp/src/io/parquet/parquet.hpp             | 29 +++++++++++++---------
 2 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cpp b/cpp/src/io/parquet/bloom_filter_reader.cpp
index 346ccd22c58..fabc70cc5f2 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cpp
+++ b/cpp/src/io/parquet/bloom_filter_reader.cpp
@@ -206,4 +206,4 @@ std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
   return {};
 }
 
-}  // namespace cudf::io::parquet::detail
\ No newline at end of file
+}  // namespace cudf::io::parquet::detail
diff --git a/cpp/src/io/parquet/parquet.hpp b/cpp/src/io/parquet/parquet.hpp
index 118ec43133b..ff8e7a63486 100644
--- a/cpp/src/io/parquet/parquet.hpp
+++ b/cpp/src/io/parquet/parquet.hpp
@@ -396,40 +396,45 @@ struct ColumnChunkMetaData {
 };
 
 /**
- * @brief The algorithm used in Bloom filter.
- **/
+ * @brief The algorithm used in bloom filter
+ */
 struct BloomFilterAlgorithm {
-  /** Block-based Bloom filter. **/
+  // Block-based Bloom filter.
   enum Algorithm { UNDEFINED, SPLIT_BLOCK };
   Algorithm algorithm{Algorithm::SPLIT_BLOCK};
 };
 
 /**
- * @brief The hash function used in Bloom filter. This function takes the hash of a column value
- * using plain encoding.
- **/
+ * @brief The hash function used in Bloom filter
+ */
 struct BloomFilterHash {
-  /** xxHash Strategy. **/
+  // xxHash_64
   enum Hash { UNDEFINED, XXHASH };
   Hash hash{Hash::XXHASH};
 };
 
 /**
- * @brief The compression used in the Bloom filter.
- **/
+ * @brief The compression used in the bloom filter
+ */
 struct BloomFilterCompression {
   enum Compression { UNDEFINED, UNCOMPRESSED };
   Compression compression{Compression::UNCOMPRESSED};
 };
 
+/**
+ * @brief Bloom filter header struct
+ *
+ * The bloom filter data of a column chunk stores this header at the beginning
+ * following by the filter bitset.
+ */
 struct BloomFilterHeader {
   // The size of bitset in bytes
   int32_t num_bytes;
-  // The algorithm for setting bits. *
+  // The algorithm for setting bits
   BloomFilterAlgorithm algorithm;
-  // The hash function used for Bloom filter. *
+  // The hash function used for bloom filter
   BloomFilterHash hash;
-  // The compression used in the Bloom filter *
+  // The compression used in the bloom filter
   BloomFilterCompression compression;
 };
 

From 81efad2637e24f31b17b8a8d2ee25779446ddaf1 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 19 Nov 2024 03:58:42 +0000
Subject: [PATCH 08/85] Get equality predicate col indices

---
 ...lter_reader.cpp => bloom_filter_reader.cu} | 189 ++++++++++++++++++
 cpp/src/io/parquet/predicate_pushdown.cpp     |   8 +-
 cpp/src/io/parquet/reader_impl_helpers.hpp    |  20 ++
 3 files changed, 216 insertions(+), 1 deletion(-)
 rename cpp/src/io/parquet/{bloom_filter_reader.cpp => bloom_filter_reader.cu} (51%)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cpp b/cpp/src/io/parquet/bloom_filter_reader.cu
similarity index 51%
rename from cpp/src/io/parquet/bloom_filter_reader.cpp
rename to cpp/src/io/parquet/bloom_filter_reader.cu
index fabc70cc5f2..89f448de05f 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cpp
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -18,14 +18,30 @@
 #include "io/parquet/parquet.hpp"
 #include "reader_impl_helpers.hpp"
 
+#include <cudf/ast/detail/expression_transformer.hpp>
+#include <cudf/ast/detail/operators.hpp>
+#include <cudf/ast/expressions.hpp>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/detail/cuco_helpers.hpp>
+#include <cudf/detail/iterator.cuh>
+#include <cudf/detail/transform.hpp>
 #include <cudf/detail/utilities/logger.hpp>
+#include <cudf/utilities/error.hpp>
 
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/device_buffer.hpp>
+#include <rmm/device_vector.hpp>
+#include <rmm/exec_policy.hpp>
 
+#include <cuco/bloom_filter_policy.cuh>
+#include <cuco/bloom_filter_ref.cuh>
+#include <cuco/hash_functions.cuh>
+#include <thrust/for_each.h>
 #include <thrust/iterator/counting_iterator.h>
+#include <thrust/sequence.h>
 
 #include <future>
+#include <iterator>
 #include <numeric>
 #include <optional>
 
@@ -102,6 +118,37 @@ std::future<void> read_bloom_filters_async(
         if (initial_read_size >= bloom_filter_header_size + bitset_size) {
           bloom_filter_data[chunk] =
             rmm::device_buffer(buffer->data() + bloom_filter_header_size, bitset_size, stream);
+
+          /* MH: Remove this
+          using word_type = uint32_t;
+
+          thrust::for_each(rmm::exec_policy(stream),
+                           thrust::make_counting_iterator(0),
+                           thrust::make_counting_iterator(1),
+                           [words = reinterpret_cast<word_type*>(bloom_filter_data[chunk].data()),
+                            num_blocks = bloom_filter_data[chunk].size() / sizeof(uint32_t),
+                            chunk      = chunk,
+                            stream     = stream] __device__(auto idx) {
+                             using key_type = cuda::std::string;
+                             using policy_type =
+                               cuco::bloom_filter_policy<cuco::xxhash_64<key_type>, std::uint32_t,
+          8>;
+                             // using arrow_policy_type = cuco::arrow_filter_policy<key_type>;
+                             cuco::bloom_filter_ref<key_type,
+                                                    cuco::extent<std::size_t>,
+                                                    cuco::thread_scope_device,
+                                                    policy_type>
+                               filter{words, size_t{num_blocks}, {}, {8}};
+                             // cuda::std::string key{"third-136666"};
+                             // filter.add("third-136666");
+
+                             cuco::xxhash_64<key_type> hasher{};
+                             cuda::std::array<char, 13> val{"third-136666"};
+                             auto hash =
+          hasher.compute_hash(reinterpret_cast<std::byte*>(val.data()), val.size()); if
+          (filter.contains(hash)) { printf("Filter chunk: %lu contains key: third-136666\n", chunk);
+                             }
+                           });*/
         }
         // Read the bitset from datasource.
         else {
@@ -123,16 +170,158 @@ std::future<void> read_bloom_filters_async(
         }
       }
     });
+
   auto sync_fn = [](decltype(read_tasks) read_tasks) {
     for (auto& task : read_tasks) {
       task.wait();
     }
   };
+
   return std::async(std::launch::deferred, sync_fn, std::move(read_tasks));
 }
 
+/**
+ * @brief Collects column indices with an equality predicate in the AST expression.
+ * This is used in row group filtering based on bloom filters.
+ */
+class equality_predicate_converter : public ast::detail::expression_transformer {
+ public:
+  equality_predicate_converter(ast::expression const& expr, size_type const& num_columns)
+    : _num_columns{num_columns}
+  {
+    expr.accept(*this);
+  }
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::literal const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(ast::literal const& expr) override
+  {
+    _equality_expr = std::reference_wrapper<ast::expression const>(expr);
+    return expr;
+  }
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::column_reference const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(ast::column_reference const& expr) override
+  {
+    CUDF_EXPECTS(expr.get_table_source() == ast::table_reference::LEFT,
+                 "Equality AST supports only left table");
+    CUDF_EXPECTS(expr.get_column_index() < _num_columns,
+                 "Column index cannot be more than number of columns in the table");
+    _equality_expr = std::reference_wrapper<ast::expression const>(expr);
+    return expr;
+  }
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::column_name_reference const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(
+    ast::column_name_reference const& expr) override
+  {
+    CUDF_FAIL("Column name reference is not supported in equality AST");
+  }
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::operation const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(ast::operation const& expr) override
+  {
+    using cudf::ast::ast_operator;
+    auto const operands = expr.get_operands();
+    auto const op       = expr.get_operator();
+
+    if (auto* v = dynamic_cast<ast::column_reference const*>(&operands[0].get())) {
+      // First operand should be column reference, second should be literal.
+      CUDF_EXPECTS(cudf::ast::detail::ast_operator_arity(op) == 2,
+                   "Only binary operations are supported on column reference");
+      CUDF_EXPECTS(dynamic_cast<ast::literal const*>(&operands[1].get()) != nullptr,
+                   "Second operand of binary operation with column reference must be a literal");
+      v->accept(*this);
+      if (op == ast_operator::EQUAL) { equality_col_idx.emplace_back(v->get_column_index()); }
+    } else {
+      auto new_operands = visit_operands(operands);
+      if (cudf::ast::detail::ast_operator_arity(op) == 2) {
+        _operators.emplace_back(op, new_operands.front(), new_operands.back());
+      } else if (cudf::ast::detail::ast_operator_arity(op) == 1) {
+        _operators.emplace_back(op, new_operands.front());
+      }
+    }
+    _equality_expr = std::reference_wrapper<ast::expression const>(_operators.back());
+    return std::reference_wrapper<ast::expression const>(_operators.back());
+  }
+
+  /**
+   * @brief Returns a list of column indices with an equality predicate in the AST expression.
+   *
+   * @return List of column indices
+   */
+  [[nodiscard]] std::vector<cudf::size_type> get_equality_col_idx() const
+  {
+    return equality_col_idx;
+  }
+
+ private:
+  std::vector<std::reference_wrapper<ast::expression const>> visit_operands(
+    cudf::host_span<std::reference_wrapper<ast::expression const> const> operands)
+  {
+    std::vector<std::reference_wrapper<ast::expression const>> transformed_operands;
+    for (auto const& operand : operands) {
+      auto const new_operand = operand.get().accept(*this);
+      transformed_operands.push_back(new_operand);
+    }
+    return transformed_operands;
+  }
+  std::optional<std::reference_wrapper<ast::expression const>> _equality_expr;
+  std::vector<cudf::size_type> equality_col_idx;
+  size_type _num_columns;
+  std::list<ast::column_reference> _col_ref;
+  std::list<ast::operation> _operators;
+};
+
 }  // namespace
 
+std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::apply_bloom_filters(
+  host_span<std::unique_ptr<datasource> const> sources,
+  host_span<std::vector<size_type> const> row_group_indices,
+  host_span<data_type const> output_dtypes,
+  host_span<int const> output_column_schemas,
+  std::reference_wrapper<ast::expression const> filter,
+  rmm::cuda_stream_view stream) const
+{
+  auto const num_cols = output_dtypes.size();
+  CUDF_EXPECTS(output_dtypes.size() == output_column_schemas.size(),
+               "Mismatched size between lists of output column dtypes and output column schema");
+  auto mr = cudf::get_current_device_resource_ref();
+  std::vector<std::unique_ptr<column>> cols;
+  // MH: How do I test for nested or non-comparable columns here?
+  cols.emplace_back(cudf::make_numeric_column(
+    data_type{cudf::type_id::INT32}, num_cols, rmm::device_buffer{}, 0, stream, mr));
+
+  auto mutable_col_idx = cols.back()->mutable_view();
+
+  thrust::sequence(rmm::exec_policy(stream),
+                   mutable_col_idx.begin<size_type>(),
+                   mutable_col_idx.end<size_type>(),
+                   0);
+
+  auto equality_table = cudf::table(std::move(cols));
+
+  // Converts AST to EqualityAST with reference to min, max columns in above `stats_table`.
+  equality_predicate_converter equality_expr{filter.get(), static_cast<size_type>(num_cols)};
+  auto equality_col_schemas = equality_expr.get_equality_col_idx();
+
+  // Convert column indices to column schema indices
+  std::for_each(equality_col_schemas.begin(), equality_col_schemas.end(), [&](auto& col_idx) {
+    col_idx = output_column_schemas[col_idx];
+  });
+
+  std::ignore = read_bloom_filters(sources, row_group_indices, equality_col_schemas, stream);
+
+  return std::nullopt;
+}
+
 std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
   host_span<std::unique_ptr<datasource> const> sources,
   host_span<std::vector<size_type> const> row_group_indices,
diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp
index a977cfdeca7..eb30cc6955a 100644
--- a/cpp/src/io/parquet/predicate_pushdown.cpp
+++ b/cpp/src/io/parquet/predicate_pushdown.cpp
@@ -479,7 +479,9 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
                   is_row_group_required.cend(),
                   [](auto i) { return bool(i); }) or
       predicate.null_count() == predicate.size()) {
-    return std::nullopt;
+    // Call with input_row_group_indices
+    return apply_bloom_filters(
+      sources, input_row_group_indices, output_dtypes, output_column_schemas, filter, stream);
   }
   size_type is_required_idx = 0;
   for (auto const& input_row_group_index : input_row_group_indices) {
@@ -493,6 +495,10 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
     filtered_row_group_indices.push_back(std::move(filtered_row_groups));
   }
 
+  // Call with filtered_row_group_indices
+  return apply_bloom_filters(
+    sources, filtered_row_group_indices, output_dtypes, output_column_schemas, filter, stream);
+
   return {std::move(filtered_row_group_indices)};
 }
 
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index b03aa9ec296..75edfdb7f7b 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -339,6 +339,26 @@ class aggregate_reader_metadata {
     std::reference_wrapper<ast::expression const> filter,
     rmm::cuda_stream_view stream) const;
 
+  /**
+   * @brief Filters the row groups using bloom filters
+   *
+   * @param sources Dataset sources
+   * @param row_group_indices Lists of row groups to read, one per source
+   * @param output_dtypes Datatypes of of output columns
+   * @param output_column_schemas schema indices of output columns
+   * @param filter AST expression to filter row groups based on Column chunk statistics
+   * @param stream CUDA stream used for device memory operations and kernel launches
+   *
+   * @return Filtered row group indices, if any is filtered.
+   */
+  [[nodiscard]] std::optional<std::vector<std::vector<size_type>>> apply_bloom_filters(
+    host_span<std::unique_ptr<datasource> const> sources,
+    host_span<std::vector<size_type> const> row_group_indices,
+    host_span<data_type const> output_dtypes,
+    host_span<int const> output_column_schemas,
+    std::reference_wrapper<ast::expression const> filter,
+    rmm::cuda_stream_view stream) const;
+
   /**
    * @brief Filters and reduces down to a selection of row groups
    *

From 088377b713b35b3d516c0c2c05af9e1e9815a41f Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 20 Nov 2024 02:45:46 +0000
Subject: [PATCH 09/85] Enable `arrow_filter_policy` and `span` types in bloom
 filter.

---
 cpp/src/io/parquet/arrow_filter_policy.cuh | 187 +++++++++++++++++++++
 cpp/src/io/parquet/bloom_filter_reader.cu  |  89 ++++++----
 2 files changed, 246 insertions(+), 30 deletions(-)
 create mode 100644 cpp/src/io/parquet/arrow_filter_policy.cuh

diff --git a/cpp/src/io/parquet/arrow_filter_policy.cuh b/cpp/src/io/parquet/arrow_filter_policy.cuh
new file mode 100644
index 00000000000..95edf68cab4
--- /dev/null
+++ b/cpp/src/io/parquet/arrow_filter_policy.cuh
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cuco/hash_functions.cuh>
+#include <cuda/functional>
+#include <cuda/std/bit>
+#include <cuda/std/limits>
+
+#include <cstdint>
+#include <nv/target>
+
+namespace cuco {
+
+/**
+ * @brief A policy that defines how Arrow Block-Split Bloom Filter generates and stores a key's
+ * fingerprint.
+ *
+ * @note: This file is a part of cuCollections. Copied here until we get a cuco bump for cudf.
+ *
+ * Reference:
+ * https://github.com/apache/arrow/blob/be1dcdb96b030639c0b56955c4c62f9d6b03f473/cpp/src/parquet/bloom_filter.cc#L219-L230
+ *
+ * Example:
+ * @code{.cpp}
+ * template <typename KeyType, std::uint32_t NUM_FILTER_BLOCKS>
+ * void bulk_insert_and_eval_arrow_policy_bloom_filter(device_vector<KeyType> const& positive_keys,
+ *                                                 device_vector<KeyType> const& negative_keys)
+ * {
+ *     using policy_type = cuco::arrow_filter_policy<key_type>;
+ *
+ *     // Warn or throw if the number of filter blocks is greater than maximum used by Arrow policy.
+ *     static_assert(NUM_FILTER_BLOCKS <= policy_type::max_filter_blocks, "NUM_FILTER_BLOCKS must be
+ *                                                                         in range: [1, 4194304]");
+ *
+ *     // Create a bloom filter with Arrow policy
+ *     cuco::bloom_filter<key_type, cuco::extent<size_t>,
+ *         cuda::thread_scope_device, policy_type> filter{NUM_FILTER_BLOCKS};
+ *
+ *     // Add positive keys to the bloom filter
+ *     filter.add(positive_keys.begin(), positive_keys.end());
+ *
+ *     auto const num_tp = positive_keys.size();
+ *     auto const num_tn = negative_keys.size();
+ *
+ *     // Vectors to store query results.
+ *     thrust::device_vector<bool> true_positive_result(num_tp, false);
+ *     thrust::device_vector<bool> true_negative_result(num_tn, false);
+ *
+ *     // Query the bloom filter for the inserted keys.
+ *     filter.contains(positive_keys.begin(), positive_keys.end(), true_positive_result.begin());
+ *
+ *     // We should see a true-positive rate of 1.
+ *     float true_positive_rate = float(thrust::count(thrust::device,
+ *          true_positive_result.begin(), true_positive_result.end(), true)) / float(num_tp);
+ *
+ *     // Query the bloom filter for the non-inserted keys.
+ *     filter.contains(negative_keys.begin(), negative_keys.end(), true_negative_result.begin());
+ *
+ *     // We may see a false-positive rate > 0 depending on the number of bits in the
+ *     // filter and the number of hashes used per key.
+ *     float false_positive_rate = float(thrust::count(thrust::device,
+ *          true_negative_result.begin(), true_negative_result.end(), true)) / float(num_tn);
+ * }
+ * @endcode
+ *
+ * @tparam Key The type of the values to generate a fingerprint for.
+ */
+template <class Key, class Hash>
+class arrow_filter_policy {
+ public:
+  using hasher             = Hash;           ///< Hash function for Arrow bloom filter policy
+  using word_type          = std::uint32_t;  ///< uint32_t for Arrow bloom filter policy
+  using hash_argument_type = typename hasher::argument_type;  ///< Hash function input type
+  using hash_result_type   = decltype(std::declval<hasher>()(
+    std::declval<hash_argument_type>()));  ///< hash function output type
+
+  static constexpr uint32_t bits_set_per_block = 8;  ///< hardcoded bits set per Arrow filter block
+  static constexpr uint32_t words_per_block    = 8;  ///< hardcoded words per Arrow filter block
+
+  static constexpr std::uint32_t bytes_per_filter_block =
+    32;  ///< Number of bytes in one Arrow filter block
+  static constexpr std::uint32_t max_arrow_filter_bytes =
+    128 * 1024 * 1024;  ///< Max bytes in Arrow bloom filter
+  static constexpr std::uint32_t max_filter_blocks =
+    (max_arrow_filter_bytes /
+     bytes_per_filter_block);  ///< Max sub-filter blocks allowed in Arrow bloom filter
+
+ private:
+  // Arrow's block-based bloom filter algorithm needs these eight odd SALT values to calculate
+  // eight indexes of bit to set, one bit in each 32-bit (uint32_t) word.
+  __device__ static constexpr cuda::std::array<std::uint32_t, 8> SALT()
+  {
+    return {0x47b6137bU,
+            0x44974d91U,
+            0x8824ad5bU,
+            0xa2b7289dU,
+            0x705495c7U,
+            0x2df1424bU,
+            0x9efc4947U,
+            0x5c6bfb31U};
+  }
+
+ public:
+  /**
+   * @brief Constructs the `arrow_filter_policy` object.
+   *
+   * @note The number of filter blocks with Arrow policy must be in the
+   * range of [1, 4194304]. If the bloom filter is constructed with a larger
+   * number of blocks, only the first 4194304 (128MB) blocks will be used.
+   *
+   * @param hash Hash function used to generate a key's fingerprint
+   */
+  __host__ __device__ constexpr arrow_filter_policy(hasher hash = {}) : hash_{hash} {}
+
+  /**
+   * @brief Generates the hash value for a given key.
+   *
+   * @param key The key to hash
+   *
+   * @return The hash value of the key
+   */
+  __device__ constexpr hash_result_type hash(hash_argument_type const& key) const
+  {
+    return hash_(key);
+  }
+
+  /**
+   * @brief Determines the filter block a key is added into.
+   *
+   * @note The number of filter blocks with Arrow policy must be in the
+   * range of [1, 4194304]. Passing a larger `num_blocks` will still
+   * upperbound the number of blocks used to the mentioned range.
+   *
+   * @tparam Extent Size type that is used to determine the number of blocks in the filter
+   *
+   * @param hash Hash value of the key
+   * @param num_blocks Number of block in the filter
+   *
+   * @return The block index for the given key's hash value
+   */
+  template <class Extent>
+  __device__ constexpr auto block_index(hash_result_type hash, Extent num_blocks) const
+  {
+    constexpr auto hash_bits = cuda::std::numeric_limits<word_type>::digits;
+    // TODO: assert if num_blocks > max_filter_blocks
+    auto const max_blocks = cuda::std::min<Extent>(num_blocks, max_filter_blocks);
+    // Make sure we are only contained withing the `max_filter_blocks` blocks
+    return static_cast<word_type>(((hash >> hash_bits) * max_blocks) >> hash_bits) % max_blocks;
+  }
+
+  /**
+   * @brief Determines the fingerprint pattern for a word/segment within the filter block for a
+   * given key's hash value.
+   *
+   * @param hash Hash value of the key
+   * @param word_index Target word/segment within the filter block
+   *
+   * @return The bit pattern for the word/segment in the filter block
+   */
+  __device__ constexpr word_type word_pattern(hash_result_type hash, std::uint32_t word_index) const
+  {
+    // SALT array to calculate bit indexes for the current word
+    auto constexpr salt = SALT();
+    word_type const key = static_cast<word_type>(hash);
+    return word_type{1} << ((key * salt[word_index]) >> 27);
+  }
+
+ private:
+  hasher hash_;
+};
+
+}  // namespace cuco
\ No newline at end of file
diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 89f448de05f..5178fbba3c1 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "arrow_filter_policy.cuh"
 #include "compact_protocol_reader.hpp"
 #include "io/parquet/parquet.hpp"
 #include "reader_impl_helpers.hpp"
@@ -36,6 +37,7 @@
 #include <cuco/bloom_filter_policy.cuh>
 #include <cuco/bloom_filter_ref.cuh>
 #include <cuco/hash_functions.cuh>
+#include <cuda/std/span>
 #include <thrust/for_each.h>
 #include <thrust/iterator/counting_iterator.h>
 #include <thrust/sequence.h>
@@ -48,6 +50,61 @@
 namespace cudf::io::parquet::detail {
 
 namespace {
+
+/**
+ * @brief Temporary function that tests for key `third-037493` in bloom filters of column `c2` in
+ * test Parquet file.
+ *
+ * @param buffer Device buffer containing bloom filter bitset
+ * @param chunk Current row group index
+ * @param stream CUDA stream used for device memory operations and kernel launches
+ *
+ */
+void check_arbitrary_string_key(rmm::device_buffer const& buffer,
+                                size_t chunk,
+                                rmm::cuda_stream_view stream)
+{
+  using word_type   = cuda::std::uint32_t;
+  using key_type    = cuda::std::span<cuda::std::byte>;
+  using policy_type = cuco::arrow_filter_policy<key_type, cuco::xxhash_64<key_type>>;
+
+  thrust::for_each(
+    rmm::exec_policy_nosync(stream),
+    thrust::make_counting_iterator(0),
+    thrust::make_counting_iterator(1),
+    [bitset     = const_cast<word_type*>(reinterpret_cast<word_type const*>(buffer.data())),
+     num_blocks = static_cast<cuda::std::size_t>(buffer.size()) / sizeof(uint32_t),
+     chunk      = chunk,
+     stream     = stream] __device__(auto idx) {
+      // using arrow_policy_type = cuco::arrow_filter_policy<key_type>;
+      cuco::bloom_filter_ref<key_type,
+                             cuco::extent<std::size_t>,
+                             cuco::thread_scope_device,
+                             policy_type>
+        filter{
+          bitset,
+          num_blocks,
+          {},  // scope
+          {0}  // policy
+        };
+
+      // literal to search
+      cudf::string_view literal("third-037493", sizeof("third-037493"));
+      // convert to a cuda::std::span key to search
+      cuda::std::span<cuda::std::byte> const key(
+        const_cast<cuda::std::byte*>(reinterpret_cast<cuda::std::byte const*>(literal.data())),
+        static_cast<cuda::std::size_t>(literal.length()));
+      // Search in the filter
+      if (filter.contains(key)) {
+        printf("YES: Filter chunk: %lu contains key: third-037493\n", chunk);
+      } else {
+        printf("NO: Filter chunk: %lu does not contain key: third-037493\n", chunk);
+      }
+    });
+
+  stream.synchronize_no_throw();
+}
+
 /**
  * @brief Asynchronously reads bloom filters to device.
  *
@@ -119,36 +176,8 @@ std::future<void> read_bloom_filters_async(
           bloom_filter_data[chunk] =
             rmm::device_buffer(buffer->data() + bloom_filter_header_size, bitset_size, stream);
 
-          /* MH: Remove this
-          using word_type = uint32_t;
-
-          thrust::for_each(rmm::exec_policy(stream),
-                           thrust::make_counting_iterator(0),
-                           thrust::make_counting_iterator(1),
-                           [words = reinterpret_cast<word_type*>(bloom_filter_data[chunk].data()),
-                            num_blocks = bloom_filter_data[chunk].size() / sizeof(uint32_t),
-                            chunk      = chunk,
-                            stream     = stream] __device__(auto idx) {
-                             using key_type = cuda::std::string;
-                             using policy_type =
-                               cuco::bloom_filter_policy<cuco::xxhash_64<key_type>, std::uint32_t,
-          8>;
-                             // using arrow_policy_type = cuco::arrow_filter_policy<key_type>;
-                             cuco::bloom_filter_ref<key_type,
-                                                    cuco::extent<std::size_t>,
-                                                    cuco::thread_scope_device,
-                                                    policy_type>
-                               filter{words, size_t{num_blocks}, {}, {8}};
-                             // cuda::std::string key{"third-136666"};
-                             // filter.add("third-136666");
-
-                             cuco::xxhash_64<key_type> hasher{};
-                             cuda::std::array<char, 13> val{"third-136666"};
-                             auto hash =
-          hasher.compute_hash(reinterpret_cast<std::byte*>(val.data()), val.size()); if
-          (filter.contains(hash)) { printf("Filter chunk: %lu contains key: third-136666\n", chunk);
-                             }
-                           });*/
+          // MH: TODO: Temporary test. Remove me!!
+          check_arbitrary_string_key(bloom_filter_data[chunk], chunk, stream);
         }
         // Read the bitset from datasource.
         else {

From 3dff590adeb7255d93e7fd15e081c25e5401d0ca Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Thu, 21 Nov 2024 08:41:10 +0000
Subject: [PATCH 10/85] Successfully search bloom filter

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 148 ++++++++++++++++++----
 1 file changed, 124 insertions(+), 24 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 5178fbba3c1..3c0c906a448 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -22,22 +22,18 @@
 #include <cudf/ast/detail/expression_transformer.hpp>
 #include <cudf/ast/detail/operators.hpp>
 #include <cudf/ast/expressions.hpp>
-#include <cudf/column/column_factories.hpp>
 #include <cudf/detail/cuco_helpers.hpp>
-#include <cudf/detail/iterator.cuh>
 #include <cudf/detail/transform.hpp>
 #include <cudf/detail/utilities/logger.hpp>
-#include <cudf/utilities/error.hpp>
+#include <cudf/hashing/detail/xxhash_64.cuh>
 
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/device_buffer.hpp>
 #include <rmm/device_vector.hpp>
 #include <rmm/exec_policy.hpp>
 
-#include <cuco/bloom_filter_policy.cuh>
+#include <cuco/bloom_filter.cuh>
 #include <cuco/bloom_filter_ref.cuh>
-#include <cuco/hash_functions.cuh>
-#include <cuda/std/span>
 #include <thrust/for_each.h>
 #include <thrust/iterator/counting_iterator.h>
 #include <thrust/sequence.h>
@@ -46,11 +42,115 @@
 #include <iterator>
 #include <numeric>
 #include <optional>
+#include <random>
 
 namespace cudf::io::parquet::detail {
 
 namespace {
 
+std::pair<std::vector<char>, std::vector<size_t>> generate_chars_and_offsets(size_t num_keys)
+{
+  static std::vector<std::string> const strings{"first",
+                                                "second",
+                                                "third",
+                                                "fourth",
+                                                "fifth",
+                                                "sixth",
+                                                "seventh",
+                                                "eighth",
+                                                "ninth",
+                                                "tenth",
+                                                "eleventh",
+                                                "twelfth",
+                                                "thirteenth",
+                                                "fourteenth",
+                                                "fifteenth",
+                                                "sixteenth",
+                                                "seventeenth",
+                                                "eighteenth"};
+
+  auto constexpr seed = 0xf00d;
+  /*static*/ std::mt19937 engine{seed};
+  /*static*/ std::uniform_int_distribution dist{};
+
+  std::vector<size_t> offsets(num_keys + 1);
+  std::vector<char> chars;
+  chars.reserve(12 * num_keys);  // 12 is the length of "seventeenth", the largest string
+  size_t offset = 0;
+  offsets[0]    = size_t{0};
+  std::generate_n(offsets.begin() + 1, num_keys, [&]() {
+    auto const& string  = strings[dist(engine) % strings.size()];
+    auto const char_ptr = const_cast<char*>(string.data());
+    chars.insert(chars.end(), char_ptr, char_ptr + string.length());
+    offset += string.length();
+    return offset;
+  });
+  return {std::move(chars), std::move(offsets)};
+}
+
+void validate_filter_bitwise(rmm::cuda_stream_view stream)
+{
+  std::size_t constexpr num_filter_blocks = 4;
+  std::size_t constexpr num_keys          = 50;
+
+  // Generate strings data
+  auto const [h_chars, h_offsets] = generate_chars_and_offsets(num_keys);
+  auto const mr                   = cudf::get_current_device_resource_ref();
+  auto d_chars                    = cudf::detail::make_device_uvector_async(h_chars, stream, mr);
+  auto d_offsets                  = cudf::detail::make_device_uvector_async(h_offsets, stream, mr);
+
+  rmm::device_uvector<cudf::string_view> d_keys(num_keys, stream);
+  thrust::transform(rmm::exec_policy_nosync(stream),
+                    thrust::make_counting_iterator<size_t>(0),
+                    thrust::make_counting_iterator<size_t>(num_keys),
+                    d_keys.begin(),
+                    [chars   = thrust::raw_pointer_cast(d_chars.data()),
+                     offsets = thrust::raw_pointer_cast(d_offsets.data())] __device__(auto idx) {
+                      return cudf::string_view{
+                        chars + offsets[idx],
+                        static_cast<cudf::size_type>(offsets[idx + 1] - offsets[idx])};
+                    });
+
+  using key_type    = cudf::string_view;
+  using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
+  using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
+  using filter_type = cuco::bloom_filter<key_type,
+                                         cuco::extent<size_t>,
+                                         cuda::thread_scope_device,
+                                         policy_type,
+                                         cudf::detail::cuco_allocator<char>>;
+  // Spawn a bloom filter
+  filter_type filter{
+    num_filter_blocks,
+    cuco::thread_scope_device,
+    {hasher_type{0}},
+    cudf::detail::cuco_allocator<char>{rmm::mr::polymorphic_allocator<char>{}, stream},
+    stream};
+
+  // Add strings to the bloom filter
+  filter.add(d_keys.begin(), d_keys.end(), stream);
+
+  using word_type = filter_type::word_type;
+
+  // Number of words in the filter
+  size_t const num_words = filter.block_extent() * filter.words_per_block;
+
+  // Get the filter bitset words
+  cudf::device_span<word_type const> filter_bitset(filter.data(), num_words);
+  // Expected filter bitset words
+  rmm::device_vector<word_type> const expected_bitset{
+    4194306,    4194305,  2359296,   1073774592, 524544,     1024,       268443648,  8519680,
+    2147500040, 8421380,  269500416, 4202624,    8396802,    100665344,  2147747840, 5243136,
+    131146,     655364,   285345792, 134222340,  545390596,  2281717768, 51201,      41943553,
+    1619656708, 67441680, 8462730,   361220,     2216738864, 587333888,  4219272,    873463873};
+
+  CUDF_EXPECTS(thrust::equal(rmm::exec_policy(stream),
+                             expected_bitset.cbegin(),
+                             expected_bitset.cend(),
+                             filter_bitset.begin()),
+               "Bloom filter bitset mismatched");
+}
+
 /**
  * @brief Temporary function that tests for key `third-037493` in bloom filters of column `c2` in
  * test Parquet file.
@@ -64,16 +164,21 @@ void check_arbitrary_string_key(rmm::device_buffer const& buffer,
                                 size_t chunk,
                                 rmm::cuda_stream_view stream)
 {
-  using word_type   = cuda::std::uint32_t;
-  using key_type    = cuda::std::span<cuda::std::byte>;
-  using policy_type = cuco::arrow_filter_policy<key_type, cuco::xxhash_64<key_type>>;
+  using key_type    = cudf::string_view;
+  using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
+  using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
+  using word_type   = policy_type::word_type;
+
+  auto constexpr word_size       = sizeof(word_type);
+  auto constexpr words_per_block = policy_type::words_per_block;
+  auto const num_filter_blocks   = buffer.size() / (word_size * words_per_block);
 
   thrust::for_each(
-    rmm::exec_policy_nosync(stream),
+    rmm::exec_policy(stream),
     thrust::make_counting_iterator(0),
     thrust::make_counting_iterator(1),
     [bitset     = const_cast<word_type*>(reinterpret_cast<word_type const*>(buffer.data())),
-     num_blocks = static_cast<cuda::std::size_t>(buffer.size()) / sizeof(uint32_t),
+     num_blocks = num_filter_blocks,
      chunk      = chunk,
      stream     = stream] __device__(auto idx) {
       // using arrow_policy_type = cuco::arrow_filter_policy<key_type>;
@@ -81,19 +186,13 @@ void check_arbitrary_string_key(rmm::device_buffer const& buffer,
                              cuco::extent<std::size_t>,
                              cuco::thread_scope_device,
                              policy_type>
-        filter{
-          bitset,
-          num_blocks,
-          {},  // scope
-          {0}  // policy
-        };
+        filter{bitset,
+               num_blocks,
+               {},  // scope
+               {hasher_type{0}}};
 
       // literal to search
-      cudf::string_view literal("third-037493", sizeof("third-037493"));
-      // convert to a cuda::std::span key to search
-      cuda::std::span<cuda::std::byte> const key(
-        const_cast<cuda::std::byte*>(reinterpret_cast<cuda::std::byte const*>(literal.data())),
-        static_cast<cuda::std::size_t>(literal.length()));
+      cudf::string_view key("third-037493", 12);
       // Search in the filter
       if (filter.contains(key)) {
         printf("YES: Filter chunk: %lu contains key: third-037493\n", chunk);
@@ -101,8 +200,6 @@ void check_arbitrary_string_key(rmm::device_buffer const& buffer,
         printf("NO: Filter chunk: %lu does not contain key: third-037493\n", chunk);
       }
     });
-
-  stream.synchronize_no_throw();
 }
 
 /**
@@ -206,6 +303,9 @@ std::future<void> read_bloom_filters_async(
     }
   };
 
+  // MH: Remove me. Bitwise validation for bloom filter
+  validate_filter_bitwise(stream);
+
   return std::async(std::launch::deferred, sync_fn, std::move(read_tasks));
 }
 

From 71e1d331f79ddef0521489f142527239836f6433 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Thu, 21 Nov 2024 19:03:22 +0000
Subject: [PATCH 11/85] style fix

---
 cpp/src/io/parquet/arrow_filter_policy.cuh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/io/parquet/arrow_filter_policy.cuh b/cpp/src/io/parquet/arrow_filter_policy.cuh
index 95edf68cab4..dfb6745bed8 100644
--- a/cpp/src/io/parquet/arrow_filter_policy.cuh
+++ b/cpp/src/io/parquet/arrow_filter_policy.cuh
@@ -184,4 +184,4 @@ class arrow_filter_policy {
   hasher hash_;
 };
 
-}  // namespace cuco
\ No newline at end of file
+}  // namespace cuco

From aa65a2bb58238c27a9f6d16fe714fe9e3c59dfd6 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Fri, 22 Nov 2024 02:35:00 +0000
Subject: [PATCH 12/85] Code cleanup

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 80 +++++++++++++----------
 1 file changed, 46 insertions(+), 34 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 3c0c906a448..6eed5c5dd21 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -34,8 +34,8 @@
 
 #include <cuco/bloom_filter.cuh>
 #include <cuco/bloom_filter_ref.cuh>
-#include <thrust/for_each.h>
 #include <thrust/iterator/counting_iterator.h>
+#include <thrust/logical.h>
 #include <thrust/sequence.h>
 
 #include <future>
@@ -155,51 +155,61 @@ void validate_filter_bitwise(rmm::cuda_stream_view stream)
  * @brief Temporary function that tests for key `third-037493` in bloom filters of column `c2` in
  * test Parquet file.
  *
+ * @tparam Key Type of the key to query bloom filter.
+ *
  * @param buffer Device buffer containing bloom filter bitset
  * @param chunk Current row group index
  * @param stream CUDA stream used for device memory operations and kernel launches
  *
  */
-void check_arbitrary_string_key(rmm::device_buffer const& buffer,
-                                size_t chunk,
-                                rmm::cuda_stream_view stream)
+template <typename Key = cudf::string_view>
+[[nodiscard]] bool check_arbitrary_string_key(rmm::device_buffer const& buffer,
+                                              Key const& literal,
+                                              size_t chunk_idx,
+                                              rmm::cuda_stream_view stream)
 {
-  using key_type    = cudf::string_view;
+  using key_type    = Key;
   using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
   using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
-  using word_type   = policy_type::word_type;
+  using word_type   = typename policy_type::word_type;
 
+  // Filter properties
   auto constexpr word_size       = sizeof(word_type);
   auto constexpr words_per_block = policy_type::words_per_block;
   auto const num_filter_blocks   = buffer.size() / (word_size * words_per_block);
 
-  thrust::for_each(
-    rmm::exec_policy(stream),
-    thrust::make_counting_iterator(0),
-    thrust::make_counting_iterator(1),
-    [bitset     = const_cast<word_type*>(reinterpret_cast<word_type const*>(buffer.data())),
-     num_blocks = num_filter_blocks,
-     chunk      = chunk,
-     stream     = stream] __device__(auto idx) {
-      // using arrow_policy_type = cuco::arrow_filter_policy<key_type>;
-      cuco::bloom_filter_ref<key_type,
-                             cuco::extent<std::size_t>,
-                             cuco::thread_scope_device,
-                             policy_type>
-        filter{bitset,
-               num_blocks,
-               {},  // scope
-               {hasher_type{0}}};
-
-      // literal to search
-      cudf::string_view key("third-037493", 12);
-      // Search in the filter
-      if (filter.contains(key)) {
-        printf("YES: Filter chunk: %lu contains key: third-037493\n", chunk);
-      } else {
-        printf("NO: Filter chunk: %lu does not contain key: third-037493\n", chunk);
-      }
-    });
+  // Bitset ptr must be a non-const to be used in bloom_filter_ref.
+  auto bitset = const_cast<word_type*>(reinterpret_cast<word_type const*>(buffer.data()));
+
+  // Create a bloom filter view
+  cuco::
+    bloom_filter_ref<key_type, cuco::extent<std::size_t>, cuco::thread_scope_device, policy_type>
+      filter{bitset,
+             num_filter_blocks,
+             {},  // scope
+             {hasher_type{0}}};
+
+  // Copy over the key (literal) to device
+  rmm::device_buffer d_key{literal.data(), static_cast<size_t>(literal.size_bytes()), stream};
+
+  // Query literal in bloom filter.
+  bool const is_literal_found =
+    thrust::count_if(rmm::exec_policy(stream),
+                     thrust::make_counting_iterator(0),
+                     thrust::make_counting_iterator(1),
+                     [filter   = filter,
+                      key_ptr  = reinterpret_cast<char*>(d_key.data()),
+                      key_size = static_cast<cudf::size_type>(d_key.size())] __device__(auto idx) {
+                       auto const d_key = cudf::string_view{key_ptr, key_size};
+                       return filter.contains(d_key);
+                     });
+
+  // MH: Temporary
+  auto const found_string = (is_literal_found) ? "YES" : "NO";
+  std::cout << "Literal: third-037493 found in chunk " << chunk_idx << ": " << found_string
+            << std::endl;
+
+  return is_literal_found;
 }
 
 /**
@@ -274,7 +284,9 @@ std::future<void> read_bloom_filters_async(
             rmm::device_buffer(buffer->data() + bloom_filter_header_size, bitset_size, stream);
 
           // MH: TODO: Temporary test. Remove me!!
-          check_arbitrary_string_key(bloom_filter_data[chunk], chunk, stream);
+          cudf::string_view literal{"third-037493", 12};
+          std::ignore =
+            check_arbitrary_string_key(bloom_filter_data[chunk], literal, chunk, stream);
         }
         // Read the bitset from datasource.
         else {

From c52821b91db31380c4cfc570bb08ba0d1093ef57 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Mon, 25 Nov 2024 21:30:54 +0000
Subject: [PATCH 13/85] add tests

---
 cpp/tests/CMakeLists.txt               |  1 +
 cpp/tests/hashing/bloom_filter_test.cu | 95 ++++++++++++++++++++++++++
 2 files changed, 96 insertions(+)
 create mode 100644 cpp/tests/hashing/bloom_filter_test.cu

diff --git a/cpp/tests/CMakeLists.txt b/cpp/tests/CMakeLists.txt
index 666a7d4ba4b..219fafc6952 100644
--- a/cpp/tests/CMakeLists.txt
+++ b/cpp/tests/CMakeLists.txt
@@ -182,6 +182,7 @@ ConfigureTest(DATETIME_OPS_TEST datetime/datetime_ops_test.cpp)
 # * hashing tests ---------------------------------------------------------------------------------
 ConfigureTest(
   HASHING_TEST
+  hashing/bloom_filter_test.cu
   hashing/md5_test.cpp
   hashing/murmurhash3_x86_32_test.cpp
   hashing/murmurhash3_x64_128_test.cpp
diff --git a/cpp/tests/hashing/bloom_filter_test.cu b/cpp/tests/hashing/bloom_filter_test.cu
new file mode 100644
index 00000000000..e0e98dd84a0
--- /dev/null
+++ b/cpp/tests/hashing/bloom_filter_test.cu
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+#include <cudf_test/base_fixture.hpp>
+#include <cudf_test/column_utilities.hpp>
+#include <cudf_test/column_wrapper.hpp>
+#include <cudf_test/iterator_utilities.hpp>
+
+#include <cudf/detail/cuco_helpers.hpp>
+#include <cudf/hashing/detail/xxhash_64.cuh>
+#include <cudf/utilities/default_stream.hpp>
+
+#include <cuco/bloom_filter.cuh>
+
+using StringType = cudf::string_view;
+
+template <typename T>
+class BloomFilter_TestTyped : public cudf::test::BaseFixture {};
+
+TYPED_TEST_SUITE(BloomFilter_TestTyped, StringType);
+
+TYPED_TEST(BloomFilter_TestTyped, TestStrings)
+{
+  using key_type    = StringType;
+  using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
+  using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
+
+  std::size_t constexpr num_filter_blocks = 4;
+  std::size_t constexpr num_keys          = 50;
+  auto stream                             = cudf::get_default_stream();
+
+  // strings data
+  auto data = cudf::test::strings_column_wrapper(
+    {"seventh",    "fifteenth",   "second",      "tenth",      "fifth",       "first",
+     "seventh",    "tenth",       "ninth",       "ninth",      "seventeenth", "eighteenth",
+     "thirteenth", "fifth",       "fourth",      "twelfth",    "second",      "second",
+     "fourth",     "seventh",     "seventh",     "tenth",      "thirteenth",  "seventeenth",
+     "fifth",      "seventeenth", "eighth",      "fourth",     "second",      "eighteenth",
+     "fifteenth",  "second",      "seventeenth", "thirteenth", "eighteenth",  "fifth",
+     "seventh",    "tenth",       "fourteenth",  "first",      "fifth",       "fifth",
+     "tenth",      "thirteenth",  "fourteenth",  "third",      "third",       "sixth",
+     "first",      "third"});
+  auto d_column = cudf::column_device_view::create(data);
+
+  // Spawn a bloom filter
+  cuco::bloom_filter<key_type,
+                     cuco::extent<size_t>,
+                     cuda::thread_scope_device,
+                     policy_type,
+                     cudf::detail::cuco_allocator<char>>
+    filter{num_filter_blocks,
+           cuco::thread_scope_device,
+           {hasher_type{0}},
+           cudf::detail::cuco_allocator<char>{rmm::mr::polymorphic_allocator<char>{}, stream},
+           stream};
+
+  // Add strings to the bloom filter
+  auto col = table.column(0);
+  filter.add(d_column->begin<key_type>(), d_column->end<key_type>(), stream);
+
+  // Number of words in the filter
+  cudf::size_type const num_words = filter.block_extent() * filter.words_per_block;
+
+  auto const output = cudf::column_view{
+    cudf::data_type{cudf::type_id::UINT32}, num_words, filter.data(), nullptr, 0, 0, {}};
+
+  using word_type = filter_type::word_type;
+
+  // Expected filter bitset words computed using Arrow implementation here:
+  // https://godbolt.org/z/oKfqcPWbY
+  auto expected = cudf::test::fixed_width_column_wrapper<word_type>(
+    {4194306,    4194305,  2359296,   1073774592, 524544,     1024,       268443648,  8519680,
+     2147500040, 8421380,  269500416, 4202624,    8396802,    100665344,  2147747840, 5243136,
+     131146,     655364,   285345792, 134222340,  545390596,  2281717768, 51201,      41943553,
+     1619656708, 67441680, 8462730,   361220,     2216738864, 587333888,  4219272,    873463873});
+  auto d_expected = cudf::column_device_view::create(expected);
+
+  // Check
+  CUDF_TEST_EXPECT_COLUMNS_EQUAL(output, d_expected);
+}
+*/
\ No newline at end of file

From 3a20a9814f60c08b893e9eb917d69f31672779c4 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Sat, 9 Nov 2024 00:11:28 +0000
Subject: [PATCH 14/85] Initial stuff for reading bloom filter from PQ files

---
 .../io/parquet/compact_protocol_reader.cpp    |  33 +++-
 .../io/parquet/compact_protocol_reader.hpp    |   4 +
 cpp/src/io/parquet/parquet.hpp                |  45 +++++
 .../io/parquet/reader_apply_bloom_filters.cu  |  36 ++++
 cpp/src/io/parquet/reader_impl_helpers.cpp    | 178 ++++++++++++++++++
 cpp/src/io/parquet/reader_impl_helpers.hpp    |  25 ++-
 cpp/src/io/parquet/reader_impl_preprocess.cu  |   3 +-
 7 files changed, 321 insertions(+), 3 deletions(-)
 create mode 100644 cpp/src/io/parquet/reader_apply_bloom_filters.cu

diff --git a/cpp/src/io/parquet/compact_protocol_reader.cpp b/cpp/src/io/parquet/compact_protocol_reader.cpp
index d276e946a51..55874822ade 100644
--- a/cpp/src/io/parquet/compact_protocol_reader.cpp
+++ b/cpp/src/io/parquet/compact_protocol_reader.cpp
@@ -655,6 +655,33 @@ void CompactProtocolReader::read(ColumnChunk* c)
   function_builder(this, op);
 }
 
+void CompactProtocolReader::read(BloomFilterAlgorithm* alg)
+{
+  auto op = std::make_tuple(parquet_field_union_enumerator(1, alg->algorithm));
+  function_builder(this, op);
+}
+
+void CompactProtocolReader::read(BloomFilterHash* hash)
+{
+  auto op = std::make_tuple(parquet_field_union_enumerator(1, hash->hash));
+  function_builder(this, op);
+}
+
+void CompactProtocolReader::read(BloomFilterCompression* comp)
+{
+  auto op = std::make_tuple(parquet_field_union_enumerator(1, comp->compression));
+  function_builder(this, op);
+}
+
+void CompactProtocolReader::read(BloomFilterHeader* bf)
+{
+  auto op = std::make_tuple(parquet_field_int32(1, bf->num_bytes),
+                            parquet_field_struct(2, bf->algorithm),
+                            parquet_field_struct(3, bf->hash),
+                            parquet_field_struct(4, bf->compression));
+  function_builder(this, op);
+}
+
 void CompactProtocolReader::read(ColumnChunkMetaData* c)
 {
   using optional_size_statistics =
@@ -662,7 +689,9 @@ void CompactProtocolReader::read(ColumnChunkMetaData* c)
   using optional_list_enc_stats =
     parquet_field_optional<std::vector<PageEncodingStats>,
                            parquet_field_struct_list<PageEncodingStats>>;
-  auto op = std::make_tuple(parquet_field_enum<Type>(1, c->type),
+  using optional_i64 = parquet_field_optional<int64_t, parquet_field_int64>;
+  using optional_i32 = parquet_field_optional<int32_t, parquet_field_int32>;
+  auto op            = std::make_tuple(parquet_field_enum<Type>(1, c->type),
                             parquet_field_enum_list(2, c->encodings),
                             parquet_field_string_list(3, c->path_in_schema),
                             parquet_field_enum<Compression>(4, c->codec),
@@ -674,6 +703,8 @@ void CompactProtocolReader::read(ColumnChunkMetaData* c)
                             parquet_field_int64(11, c->dictionary_page_offset),
                             parquet_field_struct(12, c->statistics),
                             optional_list_enc_stats(13, c->encoding_stats),
+                            optional_i64(14, c->bloom_filter_offset),
+                            optional_i32(15, c->bloom_filter_length),
                             optional_size_statistics(16, c->size_statistics));
   function_builder(this, op);
 }
diff --git a/cpp/src/io/parquet/compact_protocol_reader.hpp b/cpp/src/io/parquet/compact_protocol_reader.hpp
index b87f2e9c692..3d39daa60d1 100644
--- a/cpp/src/io/parquet/compact_protocol_reader.hpp
+++ b/cpp/src/io/parquet/compact_protocol_reader.hpp
@@ -108,6 +108,10 @@ class CompactProtocolReader {
   void read(IntType* t);
   void read(RowGroup* r);
   void read(ColumnChunk* c);
+  void read(BloomFilterAlgorithm* bf);
+  void read(BloomFilterHash* bf);
+  void read(BloomFilterCompression* bf);
+  void read(BloomFilterHeader* bf);
   void read(ColumnChunkMetaData* c);
   void read(PageHeader* p);
   void read(DataPageHeader* d);
diff --git a/cpp/src/io/parquet/parquet.hpp b/cpp/src/io/parquet/parquet.hpp
index 2851ef67a65..118ec43133b 100644
--- a/cpp/src/io/parquet/parquet.hpp
+++ b/cpp/src/io/parquet/parquet.hpp
@@ -382,12 +382,57 @@ struct ColumnChunkMetaData {
   // Set of all encodings used for pages in this column chunk. This information can be used to
   // determine if all data pages are dictionary encoded for example.
   std::optional<std::vector<PageEncodingStats>> encoding_stats;
+  // Byte offset from beginning of file to Bloom filter data.
+  std::optional<int64_t> bloom_filter_offset;
+  // Size of Bloom filter data including the serialized header, in bytes. Added in 2.10 so readers
+  // may not read this field from old files and it can be obtained after the BloomFilterHeader has
+  // been deserialized. Writers should write this field so readers can read the bloom filter in a
+  // single I/O.
+  std::optional<int32_t> bloom_filter_length;
   // Optional statistics to help estimate total memory when converted to in-memory representations.
   // The histograms contained in these statistics can also be useful in some cases for more
   // fine-grained nullability/list length filter pushdown.
   std::optional<SizeStatistics> size_statistics;
 };
 
+/**
+ * @brief The algorithm used in Bloom filter.
+ **/
+struct BloomFilterAlgorithm {
+  /** Block-based Bloom filter. **/
+  enum Algorithm { UNDEFINED, SPLIT_BLOCK };
+  Algorithm algorithm{Algorithm::SPLIT_BLOCK};
+};
+
+/**
+ * @brief The hash function used in Bloom filter. This function takes the hash of a column value
+ * using plain encoding.
+ **/
+struct BloomFilterHash {
+  /** xxHash Strategy. **/
+  enum Hash { UNDEFINED, XXHASH };
+  Hash hash{Hash::XXHASH};
+};
+
+/**
+ * @brief The compression used in the Bloom filter.
+ **/
+struct BloomFilterCompression {
+  enum Compression { UNDEFINED, UNCOMPRESSED };
+  Compression compression{Compression::UNCOMPRESSED};
+};
+
+struct BloomFilterHeader {
+  // The size of bitset in bytes
+  int32_t num_bytes;
+  // The algorithm for setting bits. *
+  BloomFilterAlgorithm algorithm;
+  // The hash function used for Bloom filter. *
+  BloomFilterHash hash;
+  // The compression used in the Bloom filter *
+  BloomFilterCompression compression;
+};
+
 /**
  * @brief Thrift-derived struct describing a chunk of data for a particular
  * column
diff --git a/cpp/src/io/parquet/reader_apply_bloom_filters.cu b/cpp/src/io/parquet/reader_apply_bloom_filters.cu
new file mode 100644
index 00000000000..2d1c20ba48c
--- /dev/null
+++ b/cpp/src/io/parquet/reader_apply_bloom_filters.cu
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/**
+ * @file bloom_filter_reader.cu
+ * @brief Bloom filter reader based row group filtration implementation
+ */
+
+#include "parquet.hpp"
+#include "parquet_common.hpp"
+
+#include <cudf/utilities/error.hpp>
+
+#include <cuco/bloom_filter.cuh>
+
+#include <algorithm>
+#include <cstddef>
+#include <functional>
+#include <optional>
+#include <tuple>
+
+// TODO: Implement this
+cuda::std::optional<std::vector<std::vector<cudf::size_type>>> apply_bloom_filters() { return {}; }
\ No newline at end of file
diff --git a/cpp/src/io/parquet/reader_impl_helpers.cpp b/cpp/src/io/parquet/reader_impl_helpers.cpp
index a6562d33de2..b6348a3f897 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.cpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.cpp
@@ -25,11 +25,16 @@
 
 #include <cudf/detail/utilities/logger.hpp>
 
+#include <rmm/cuda_stream_view.hpp>
+#include <rmm/device_buffer.hpp>
+
 #include <thrust/iterator/counting_iterator.h>
 #include <thrust/iterator/zip_iterator.h>
 
 #include <functional>
+#include <future>
 #include <numeric>
+#include <optional>
 #include <regex>
 
 namespace cudf::io::parquet::detail {
@@ -1028,8 +1033,169 @@ std::vector<std::string> aggregate_reader_metadata::get_pandas_index_names() con
   return names;
 }
 
+/**
+ * @brief Asynchronously reads bloom filters to device.
+ *
+ * @param sources Dataset sources
+ * @param bloom_filter_data Devicebuffers to hold bloom filter bitsets for each chunk
+ * @param chunks List of chunk indices to read
+ * @param bloom_filter_offsets Bloom filter offsets for all chunks
+ * @param bloom_filter_sizes Bloom filter sizes for all chunks
+ * @param chunk_source_map Association between each column chunk and its source
+ * @param stream CUDA stream used for device memory operations and kernel launches
+ *
+ * @return A future object for reading synchronization
+ */
+std::future<void> read_bloom_filters_async(
+  host_span<std::unique_ptr<datasource> const> sources,
+  cudf::host_span<rmm::device_buffer> bloom_filter_data,
+  host_span<size_type const> chunks,
+  cudf::host_span<std::optional<int64_t>> bloom_filter_offsets,
+  cudf::host_span<std::optional<int32_t>> bloom_filter_sizes,
+  std::vector<size_type> const& chunk_source_map,
+  rmm::cuda_stream_view stream)
+{
+  // Transfer bloom filter data
+  std::vector<std::future<size_t>> read_tasks;
+
+  // FIXME: Do not read all chunks. Instead use a list of chunks to read.
+  for (auto chunk : chunks) {
+    // Read bloom filter if present
+    if (bloom_filter_offsets[chunk].has_value()) {
+      auto const bloom_filter_offset = bloom_filter_offsets[chunk].value();
+      // If Bloom filter size (header + bitset) is available, just read the entire thing.
+      // Else just read 256 bytes which will contain the entire header and may contain the
+      // entire bitset as well.
+      auto constexpr bloom_filter_header_size_guess = 256;
+      auto const initial_read_size =
+        bloom_filter_sizes[chunk].value_or(bloom_filter_header_size_guess);
+
+      // Read an initial buffer from source
+      auto& source = sources[chunk_source_map[chunk]];
+      auto buffer  = source->host_read(bloom_filter_offset, initial_read_size);
+
+      // Deserialize the Bloom filter header from the buffer.
+      BloomFilterHeader header;
+      CompactProtocolReader cp{buffer->data(), buffer->size()};
+      cp.read(&header);
+
+      // Bloom filter header size
+      auto const bloom_filter_header_size = static_cast<int64_t>(cp.bytecount());
+      auto const bitset_size              = header.num_bytes;
+
+      // Check if we already read in the filter bitset in the initial read.
+      if (initial_read_size >= bloom_filter_header_size + bitset_size) {
+        bloom_filter_data[chunk] =
+          rmm::device_buffer(buffer->data() + bloom_filter_header_size, bitset_size, stream);
+      }
+      // Read the bitset from datasource.
+      else {
+        auto const bitset_offset = bloom_filter_offset + bloom_filter_header_size;
+        // Directly read to device if preferred
+        if (source->is_device_read_preferred(bitset_size)) {
+          bloom_filter_data[chunk] = rmm::device_buffer(bitset_size, stream);
+          auto future_read_size =
+            source->device_read_async(bitset_offset,
+                                      bitset_size,
+                                      static_cast<uint8_t*>(bloom_filter_data[chunk].data()),
+                                      stream);
+
+          read_tasks.emplace_back(std::move(future_read_size));
+        } else {
+          buffer                   = source->host_read(bitset_offset, bitset_size);
+          bloom_filter_data[chunk] = rmm::device_buffer(buffer->data(), buffer->size(), stream);
+        }
+      }
+    }
+  }
+  auto sync_fn = [](decltype(read_tasks) read_tasks) {
+    for (auto& task : read_tasks) {
+      task.wait();
+    }
+  };
+  return std::async(std::launch::deferred, sync_fn, std::move(read_tasks));
+}
+
+std::optional<std::vector<std::vector<size_type>>>
+aggregate_reader_metadata::apply_bloom_filter_to_row_groups(
+  host_span<std::unique_ptr<datasource> const> sources,
+  host_span<std::vector<size_type> const> row_group_indices,
+  host_span<data_type const> output_dtypes,
+  host_span<int const> output_column_schemas,
+  rmm::cuda_stream_view stream) const
+{
+  // Number of row groups after filter_row_groups().
+  auto const num_row_groups = std::accumulate(
+    row_group_indices.begin(), row_group_indices.end(), 0, [](auto& sum, auto const& rgis) {
+      return sum + rgis.size();
+    });
+  // Descriptors for all the chunks that make up the selected columns
+  auto const num_input_columns = output_dtypes.size();
+  auto const num_chunks        = num_row_groups * num_input_columns;
+
+  // Association between each column chunk and its source
+  std::vector<size_type> chunk_source_map(num_chunks);
+
+  // Keep track of column chunk file offsets
+  std::vector<std::optional<int64_t>> bloom_filter_offsets(num_chunks);
+  std::vector<std::optional<int32_t>> bloom_filter_sizes(num_chunks);
+
+  // List of chunks to read
+  std::vector<size_type> chunks_to_read{};
+  chunks_to_read.reserve(num_chunks);
+
+  size_type chunk_count = 0;
+
+  // FIXME: We don't need to read bloom filters for all chunks. Only the ones belonging to the
+  // columns of our interest (equality predicate).
+  // For all data sources
+  for (size_t rg_source_index = 0; rg_source_index < row_group_indices.size(); rg_source_index++) {
+    auto const& rg_index = row_group_indices[rg_source_index];
+    // For all row groups in a data source
+    for (auto const rgi : rg_index) {
+      // For all column chunks in a row group
+      for (size_t col_idx = 0; col_idx < output_dtypes.size(); col_idx++) {
+        auto const schema_idx = output_column_schemas[col_idx];
+        auto& col_meta        = get_column_metadata(rgi, rg_source_index, schema_idx);
+
+        // Bloom filter offsets and sizes
+        bloom_filter_offsets[chunk_count] = col_meta.bloom_filter_offset;
+        bloom_filter_sizes[chunk_count]   = col_meta.bloom_filter_length;
+        chunks_to_read.emplace_back(chunk_count);
+
+        // Map each column chunk to its column index and its source index
+        chunk_source_map[chunk_count] = rg_source_index;
+        chunk_count++;
+      }
+    }
+  }
+
+  // Do we have any bloom filters
+  if (std::any_of(bloom_filter_offsets.cbegin(),
+                  bloom_filter_offsets.cend(),
+                  [](auto const offset) { return offset.has_value(); })) {
+    // Initialize the vector of bloom filter data buffers
+    std::vector<rmm::device_buffer> bloom_filter_data(num_chunks);
+
+    // Wait on bloom filter read tasks
+    read_bloom_filters_async(sources,
+                             bloom_filter_data,
+                             chunks_to_read,
+                             bloom_filter_offsets,
+                             bloom_filter_sizes,
+                             chunk_source_map,
+                             stream)
+      .wait();
+
+    // Apply bloom filter to row groups
+    // return apply_bloom_filters();
+  }
+  return {};
+}
+
 std::tuple<int64_t, size_type, std::vector<row_group_info>, std::vector<size_t>>
 aggregate_reader_metadata::select_row_groups(
+  host_span<std::unique_ptr<datasource> const> sources,
   host_span<std::vector<size_type> const> row_group_indices,
   int64_t skip_rows_opt,
   std::optional<size_type> const& num_rows_opt,
@@ -1048,6 +1214,18 @@ aggregate_reader_metadata::select_row_groups(
         host_span<std::vector<size_type> const>(filtered_row_group_indices.value());
     }
   }
+
+  // FIXME: Provide the actual condition for this if
+  if (true /* equality predicate provided */) {
+    filtered_row_group_indices = apply_bloom_filter_to_row_groups(
+      sources, row_group_indices, output_dtypes, output_column_schemas, stream);
+
+    if (filtered_row_group_indices.has_value()) {
+      row_group_indices =
+        host_span<std::vector<size_type> const>(filtered_row_group_indices.value());
+    }
+  }
+
   std::vector<row_group_info> selection;
   auto [rows_to_skip, rows_to_read] = [&]() {
     if (not row_group_indices.empty()) { return std::pair<int64_t, size_type>{}; }
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index fd692c0cdd6..82228599cd4 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -343,6 +343,7 @@ class aggregate_reader_metadata {
    * The input `row_start` and `row_count` parameters will be recomputed and output as the valid
    * values based on the input row group list.
    *
+   * @param sources Lists of input datasources.
    * @param row_group_indices Lists of row groups to read, one per source
    * @param row_start Starting row of the selection
    * @param row_count Total number of rows selected
@@ -354,7 +355,8 @@ class aggregate_reader_metadata {
    *         starting row, and list of number of rows per source.
    */
   [[nodiscard]] std::tuple<int64_t, size_type, std::vector<row_group_info>, std::vector<size_t>>
-  select_row_groups(host_span<std::vector<size_type> const> row_group_indices,
+  select_row_groups(host_span<std::unique_ptr<datasource> const> sources,
+                    host_span<std::vector<size_type> const> row_group_indices,
                     int64_t row_start,
                     std::optional<size_type> const& row_count,
                     host_span<data_type const> output_dtypes,
@@ -362,6 +364,27 @@ class aggregate_reader_metadata {
                     std::optional<std::reference_wrapper<ast::expression const>> filter,
                     rmm::cuda_stream_view stream) const;
 
+  /**
+   * @brief Filters the row groups using bloom filters
+   *
+   * @param sources Dataset sources
+   * @param bloom_filter_data Devicebuffers to hold bloom filter bitsets for each chunk
+   * @param begin_chunk Index of first column chunk to read
+   * @param end_chunk Index after the last column chunk to read
+   * @param bloom_filter_offsets Bloom filter offsets for all chunks
+   * @param bloom_filter_sizes Bloom filter sizes for all chunks
+   * @param chunk_source_map Association between each column chunk and its source
+   * @param stream CUDA stream used for device memory operations and kernel launches
+   *
+   * @return Filtered row group indices, if any is filtered.
+   */
+  std::optional<std::vector<std::vector<size_type>>> apply_bloom_filter_to_row_groups(
+    host_span<std::unique_ptr<datasource> const> sources,
+    host_span<std::vector<size_type> const> row_group_indices,
+    host_span<data_type const> output_dtypes,
+    host_span<int const> output_column_schemas,
+    rmm::cuda_stream_view stream) const;
+
   /**
    * @brief Filters and reduces down to a selection of columns
    *
diff --git a/cpp/src/io/parquet/reader_impl_preprocess.cu b/cpp/src/io/parquet/reader_impl_preprocess.cu
index bcdae4cbd3b..135ca56af89 100644
--- a/cpp/src/io/parquet/reader_impl_preprocess.cu
+++ b/cpp/src/io/parquet/reader_impl_preprocess.cu
@@ -1284,7 +1284,8 @@ void reader::impl::preprocess_file(read_mode mode)
            _file_itm_data.global_num_rows,
            _file_itm_data.row_groups,
            _file_itm_data.num_rows_per_source) =
-    _metadata->select_row_groups(_options.row_group_indices,
+    _metadata->select_row_groups(_sources,
+                                 _options.row_group_indices,
                                  _options.skip_rows,
                                  _options.num_rows,
                                  output_dtypes,

From d67e4b5dce291213da6d321acf8d28975302f17a Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Sat, 9 Nov 2024 00:22:21 +0000
Subject: [PATCH 15/85] Minor bug fix

---
 cpp/src/io/parquet/reader_impl_helpers.cpp | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/cpp/src/io/parquet/reader_impl_helpers.cpp b/cpp/src/io/parquet/reader_impl_helpers.cpp
index b6348a3f897..da000edfd04 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.cpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.cpp
@@ -1215,12 +1215,13 @@ aggregate_reader_metadata::select_row_groups(
     }
   }
 
-  // FIXME: Provide the actual condition for this if
+  // FIXME: Provide the actual condition for this
   if (true /* equality predicate provided */) {
-    filtered_row_group_indices = apply_bloom_filter_to_row_groups(
+    auto const bloom_filtered_row_groups = apply_bloom_filter_to_row_groups(
       sources, row_group_indices, output_dtypes, output_column_schemas, stream);
-
-    if (filtered_row_group_indices.has_value()) {
+    // TODO: Can use a better logic here.
+    if (bloom_filtered_row_groups.has_value()) {
+      filtered_row_group_indices.value() = std::move(bloom_filtered_row_groups.value());
       row_group_indices =
         host_span<std::vector<size_type> const>(filtered_row_group_indices.value());
     }

From 10471d466ac3985feab08410a76c5e42b2f6f458 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Sat, 9 Nov 2024 00:22:55 +0000
Subject: [PATCH 16/85] Apply style fix

---
 cpp/src/io/parquet/reader_apply_bloom_filters.cu | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/io/parquet/reader_apply_bloom_filters.cu b/cpp/src/io/parquet/reader_apply_bloom_filters.cu
index 2d1c20ba48c..fc85a0a1eb2 100644
--- a/cpp/src/io/parquet/reader_apply_bloom_filters.cu
+++ b/cpp/src/io/parquet/reader_apply_bloom_filters.cu
@@ -33,4 +33,4 @@
 #include <tuple>
 
 // TODO: Implement this
-cuda::std::optional<std::vector<std::vector<cudf::size_type>>> apply_bloom_filters() { return {}; }
\ No newline at end of file
+cuda::std::optional<std::vector<std::vector<cudf::size_type>>> apply_bloom_filters() { return {}; }

From 1e12662ca1aa75a5a2d4c8ce894df2ef8b2117d8 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Sat, 16 Nov 2024 03:12:55 +0000
Subject: [PATCH 17/85] Some updates

---
 cpp/src/io/parquet/predicate_pushdown.cpp  | 14 +++++++
 cpp/src/io/parquet/reader_impl_helpers.cpp | 44 +++++++++++++---------
 cpp/src/io/parquet/reader_impl_helpers.hpp |  2 +
 3 files changed, 43 insertions(+), 17 deletions(-)

diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp
index cd3dcd2bce4..abc8978d8db 100644
--- a/cpp/src/io/parquet/predicate_pushdown.cpp
+++ b/cpp/src/io/parquet/predicate_pushdown.cpp
@@ -391,6 +391,7 @@ class stats_expression_converter : public ast::detail::expression_transformer {
 }  // namespace
 
 std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::filter_row_groups(
+  host_span<std::unique_ptr<datasource> const> sources,
   host_span<std::vector<size_type> const> row_group_indices,
   host_span<data_type const> output_dtypes,
   host_span<int const> output_column_schemas,
@@ -491,6 +492,19 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
     }
     filtered_row_group_indices.push_back(std::move(filtered_row_groups));
   }
+
+  // If equality predicate
+  if (true /* is_equality_predicate */) {
+    filtered_row_group_indices =
+      apply_bloom_filter_to_row_groups(
+        sources,
+        filtered_row_group_indices.empty() ? input_row_group_indices : filtered_row_group_indices,
+        output_dtypes,
+        output_column_schemas,
+        stream)
+        .value();
+  }
+
   return {std::move(filtered_row_group_indices)};
 }
 
diff --git a/cpp/src/io/parquet/reader_impl_helpers.cpp b/cpp/src/io/parquet/reader_impl_helpers.cpp
index da000edfd04..7ca1ffc4253 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.cpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.cpp
@@ -1079,6 +1079,20 @@ std::future<void> read_bloom_filters_async(
       CompactProtocolReader cp{buffer->data(), buffer->size()};
       cp.read(&header);
 
+      // Test if header is valid.
+      auto const is_header_valid =
+        (header.num_bytes % 32) == 0 and
+        header.compression.compression == BloomFilterCompression::Compression::UNCOMPRESSED and
+        header.algorithm.algorithm == BloomFilterAlgorithm::Algorithm::SPLIT_BLOCK and
+        header.hash.hash == BloomFilterHash::Hash::XXHASH;
+
+      if (not is_header_valid) {
+        // Simply use an empty device buffer and move on.
+        bloom_filter_data[chunk] = rmm::device_buffer{};
+        CUDF_LOG_WARN("Encountered an invalid bloom filter header. Skipping");
+        continue;
+      }
+
       // Bloom filter header size
       auto const bloom_filter_header_size = static_cast<int64_t>(cp.bytecount());
       auto const bitset_size              = header.num_bytes;
@@ -1106,6 +1120,9 @@ std::future<void> read_bloom_filters_async(
           bloom_filter_data[chunk] = rmm::device_buffer(buffer->data(), buffer->size(), stream);
         }
       }
+    } else {
+      // Simply use an empty device buffer.
+      bloom_filter_data[chunk] = rmm::device_buffer{};
     }
   }
   auto sync_fn = [](decltype(read_tasks) read_tasks) {
@@ -1124,11 +1141,16 @@ aggregate_reader_metadata::apply_bloom_filter_to_row_groups(
   host_span<int const> output_column_schemas,
   rmm::cuda_stream_view stream) const
 {
-  // Number of row groups after filter_row_groups().
-  auto const num_row_groups = std::accumulate(
-    row_group_indices.begin(), row_group_indices.end(), 0, [](auto& sum, auto const& rgis) {
-      return sum + rgis.size();
-    });
+  // Create row group indices.
+  // std::vector<std::vector<size_type>> filtered_row_group_indices;
+  // Number of total row groups to process.
+  auto const num_row_groups = std::accumulate(row_group_indices.begin(),
+                                              row_group_indices.end(),
+                                              0,
+                                              [](size_type sum, auto const& per_file_row_groups) {
+                                                return sum + per_file_row_groups.size();
+                                              });
+
   // Descriptors for all the chunks that make up the selected columns
   auto const num_input_columns = output_dtypes.size();
   auto const num_chunks        = num_row_groups * num_input_columns;
@@ -1215,18 +1237,6 @@ aggregate_reader_metadata::select_row_groups(
     }
   }
 
-  // FIXME: Provide the actual condition for this
-  if (true /* equality predicate provided */) {
-    auto const bloom_filtered_row_groups = apply_bloom_filter_to_row_groups(
-      sources, row_group_indices, output_dtypes, output_column_schemas, stream);
-    // TODO: Can use a better logic here.
-    if (bloom_filtered_row_groups.has_value()) {
-      filtered_row_group_indices.value() = std::move(bloom_filtered_row_groups.value());
-      row_group_indices =
-        host_span<std::vector<size_type> const>(filtered_row_group_indices.value());
-    }
-  }
-
   std::vector<row_group_info> selection;
   auto [rows_to_skip, rows_to_read] = [&]() {
     if (not row_group_indices.empty()) { return std::pair<int64_t, size_type>{}; }
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index 82228599cd4..7faae405b4a 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -323,6 +323,7 @@ class aggregate_reader_metadata {
   /**
    * @brief Filters the row groups based on predicate filter
    *
+   * @param sources Lists of input datasources.
    * @param row_group_indices Lists of row groups to read, one per source
    * @param output_dtypes Datatypes of of output columns
    * @param output_column_schemas schema indices of output columns
@@ -331,6 +332,7 @@ class aggregate_reader_metadata {
    * @return Filtered row group indices, if any is filtered.
    */
   [[nodiscard]] std::optional<std::vector<std::vector<size_type>>> filter_row_groups(
+    host_span<std::unique_ptr<datasource> const> sources,
     host_span<std::vector<size_type> const> row_group_indices,
     host_span<data_type const> output_dtypes,
     host_span<int const> output_column_schemas,

From ee7217ca59649d75b6d4fb465e5e92257121626e Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Sat, 16 Nov 2024 05:04:13 +0000
Subject: [PATCH 18/85] Move contents to a separate file

---
 cpp/src/io/parquet/bloom_filter_reader.cpp | 209 +++++++++++++++++++++
 cpp/src/io/parquet/predicate_pushdown.cpp  |  12 --
 cpp/src/io/parquet/reader_impl_helpers.cpp | 184 +-----------------
 cpp/src/io/parquet/reader_impl_helpers.hpp |  19 +-
 4 files changed, 218 insertions(+), 206 deletions(-)
 create mode 100644 cpp/src/io/parquet/bloom_filter_reader.cpp

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cpp b/cpp/src/io/parquet/bloom_filter_reader.cpp
new file mode 100644
index 00000000000..346ccd22c58
--- /dev/null
+++ b/cpp/src/io/parquet/bloom_filter_reader.cpp
@@ -0,0 +1,209 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "compact_protocol_reader.hpp"
+#include "io/parquet/parquet.hpp"
+#include "reader_impl_helpers.hpp"
+
+#include <cudf/detail/utilities/logger.hpp>
+
+#include <rmm/cuda_stream_view.hpp>
+#include <rmm/device_buffer.hpp>
+
+#include <thrust/iterator/counting_iterator.h>
+
+#include <future>
+#include <numeric>
+#include <optional>
+
+namespace cudf::io::parquet::detail {
+
+namespace {
+/**
+ * @brief Asynchronously reads bloom filters to device.
+ *
+ * @param sources Dataset sources
+ * @param num_chunks Number of total column chunks to read
+ * @param bloom_filter_data Devicebuffers to hold bloom filter bitsets for each chunk
+ * @param bloom_filter_offsets Bloom filter offsets for all chunks
+ * @param bloom_filter_sizes Bloom filter sizes for all chunks
+ * @param chunk_source_map Association between each column chunk and its source
+ * @param stream CUDA stream used for device memory operations and kernel launches
+ *
+ * @return A future object for reading synchronization
+ */
+std::future<void> read_bloom_filters_async(
+  host_span<std::unique_ptr<datasource> const> sources,
+  size_t num_chunks,
+  cudf::host_span<rmm::device_buffer> bloom_filter_data,
+  cudf::host_span<std::optional<int64_t>> bloom_filter_offsets,
+  cudf::host_span<std::optional<int32_t>> bloom_filter_sizes,
+  std::vector<size_type> const& chunk_source_map,
+  rmm::cuda_stream_view stream)
+{
+  // Read tasks for bloom filter data
+  std::vector<std::future<size_t>> read_tasks;
+
+  // Read bloom filters for all column chunks
+  std::for_each(
+    thrust::make_counting_iterator<size_t>(0),
+    thrust::make_counting_iterator<size_t>(num_chunks),
+    [&](auto const chunk) {
+      // Read bloom filter if present
+      if (bloom_filter_offsets[chunk].has_value()) {
+        auto const bloom_filter_offset = bloom_filter_offsets[chunk].value();
+        // If Bloom filter size (header + bitset) is available, just read the entire thing.
+        // Else just read 256 bytes which will contain the entire header and may contain the
+        // entire bitset as well.
+        auto constexpr bloom_filter_header_size_guess = 256;
+        auto const initial_read_size =
+          bloom_filter_sizes[chunk].value_or(bloom_filter_header_size_guess);
+
+        // Read an initial buffer from source
+        auto& source = sources[chunk_source_map[chunk]];
+        auto buffer  = source->host_read(bloom_filter_offset, initial_read_size);
+
+        // Deserialize the Bloom filter header from the buffer.
+        BloomFilterHeader header;
+        CompactProtocolReader cp{buffer->data(), buffer->size()};
+        cp.read(&header);
+
+        // Test if header is valid.
+        auto const is_header_valid =
+          (header.num_bytes % 32) == 0 and
+          header.compression.compression == BloomFilterCompression::Compression::UNCOMPRESSED and
+          header.algorithm.algorithm == BloomFilterAlgorithm::Algorithm::SPLIT_BLOCK and
+          header.hash.hash == BloomFilterHash::Hash::XXHASH;
+
+        // Do not read if the bloom filter is invalid
+        if (not is_header_valid) {
+          CUDF_LOG_WARN("Encountered an invalid bloom filter header. Skipping");
+          return;
+        }
+
+        // Bloom filter header size
+        auto const bloom_filter_header_size = static_cast<int64_t>(cp.bytecount());
+        auto const bitset_size              = header.num_bytes;
+
+        // Check if we already read in the filter bitset in the initial read.
+        if (initial_read_size >= bloom_filter_header_size + bitset_size) {
+          bloom_filter_data[chunk] =
+            rmm::device_buffer(buffer->data() + bloom_filter_header_size, bitset_size, stream);
+        }
+        // Read the bitset from datasource.
+        else {
+          auto const bitset_offset = bloom_filter_offset + bloom_filter_header_size;
+          // Directly read to device if preferred
+          if (source->is_device_read_preferred(bitset_size)) {
+            bloom_filter_data[chunk] = rmm::device_buffer(bitset_size, stream);
+            auto future_read_size =
+              source->device_read_async(bitset_offset,
+                                        bitset_size,
+                                        static_cast<uint8_t*>(bloom_filter_data[chunk].data()),
+                                        stream);
+
+            read_tasks.emplace_back(std::move(future_read_size));
+          } else {
+            buffer                   = source->host_read(bitset_offset, bitset_size);
+            bloom_filter_data[chunk] = rmm::device_buffer(buffer->data(), buffer->size(), stream);
+          }
+        }
+      }
+    });
+  auto sync_fn = [](decltype(read_tasks) read_tasks) {
+    for (auto& task : read_tasks) {
+      task.wait();
+    }
+  };
+  return std::async(std::launch::deferred, sync_fn, std::move(read_tasks));
+}
+
+}  // namespace
+
+std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
+  host_span<std::unique_ptr<datasource> const> sources,
+  host_span<std::vector<size_type> const> row_group_indices,
+  host_span<int const> column_schemas,
+  rmm::cuda_stream_view stream) const
+{
+  // Number of total row groups to process.
+  auto const num_row_groups = std::accumulate(
+    row_group_indices.begin(),
+    row_group_indices.end(),
+    size_t{0},
+    [](size_t sum, auto const& per_file_row_groups) { return sum + per_file_row_groups.size(); });
+
+  // Descriptors for all the chunks that make up the selected columns
+  auto const num_input_columns = column_schemas.size();
+  auto const num_chunks        = num_row_groups * num_input_columns;
+
+  // Association between each column chunk and its source
+  std::vector<size_type> chunk_source_map(num_chunks);
+
+  // Keep track of column chunk file offsets
+  std::vector<std::optional<int64_t>> bloom_filter_offsets(num_chunks);
+  std::vector<std::optional<int32_t>> bloom_filter_sizes(num_chunks);
+
+  // Gather all bloom filter offsets and sizes.
+  size_type chunk_count = 0;
+
+  // For all data sources
+  std::for_each(thrust::make_counting_iterator<size_t>(0),
+                thrust::make_counting_iterator(row_group_indices.size()),
+                [&](auto const src_index) {
+                  // Get all row group indices in the data source
+                  auto const& rg_indices = row_group_indices[src_index];
+                  // For all row groups
+                  std::for_each(rg_indices.cbegin(), rg_indices.cend(), [&](auto const rg_index) {
+                    // For all column chunks
+                    std::for_each(
+                      column_schemas.begin(), column_schemas.end(), [&](auto const schema_idx) {
+                        auto& col_meta = get_column_metadata(rg_index, src_index, schema_idx);
+
+                        // Get bloom filter offsets and sizes
+                        bloom_filter_offsets[chunk_count] = col_meta.bloom_filter_offset;
+                        bloom_filter_sizes[chunk_count]   = col_meta.bloom_filter_length;
+
+                        // Map each column chunk to its source index
+                        chunk_source_map[chunk_count] = src_index;
+                        chunk_count++;
+                      });
+                  });
+                });
+
+  // Do we have any bloom filters
+  if (std::any_of(bloom_filter_offsets.cbegin(),
+                  bloom_filter_offsets.cend(),
+                  [](auto const offset) { return offset.has_value(); })) {
+    // Create a vector to store bloom filter data
+    std::vector<rmm::device_buffer> bloom_filter_data(num_chunks);
+
+    // Wait on bloom filter read tasks
+    read_bloom_filters_async(sources,
+                             num_chunks,
+                             bloom_filter_data,
+                             bloom_filter_offsets,
+                             bloom_filter_sizes,
+                             chunk_source_map,
+                             stream)
+      .wait();
+    // Return the vector
+    return bloom_filter_data;
+  }
+  return {};
+}
+
+}  // namespace cudf::io::parquet::detail
\ No newline at end of file
diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp
index abc8978d8db..a977cfdeca7 100644
--- a/cpp/src/io/parquet/predicate_pushdown.cpp
+++ b/cpp/src/io/parquet/predicate_pushdown.cpp
@@ -493,18 +493,6 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
     filtered_row_group_indices.push_back(std::move(filtered_row_groups));
   }
 
-  // If equality predicate
-  if (true /* is_equality_predicate */) {
-    filtered_row_group_indices =
-      apply_bloom_filter_to_row_groups(
-        sources,
-        filtered_row_group_indices.empty() ? input_row_group_indices : filtered_row_group_indices,
-        output_dtypes,
-        output_column_schemas,
-        stream)
-        .value();
-  }
-
   return {std::move(filtered_row_group_indices)};
 }
 
diff --git a/cpp/src/io/parquet/reader_impl_helpers.cpp b/cpp/src/io/parquet/reader_impl_helpers.cpp
index 7ca1ffc4253..9c05009b528 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.cpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.cpp
@@ -1033,188 +1033,6 @@ std::vector<std::string> aggregate_reader_metadata::get_pandas_index_names() con
   return names;
 }
 
-/**
- * @brief Asynchronously reads bloom filters to device.
- *
- * @param sources Dataset sources
- * @param bloom_filter_data Devicebuffers to hold bloom filter bitsets for each chunk
- * @param chunks List of chunk indices to read
- * @param bloom_filter_offsets Bloom filter offsets for all chunks
- * @param bloom_filter_sizes Bloom filter sizes for all chunks
- * @param chunk_source_map Association between each column chunk and its source
- * @param stream CUDA stream used for device memory operations and kernel launches
- *
- * @return A future object for reading synchronization
- */
-std::future<void> read_bloom_filters_async(
-  host_span<std::unique_ptr<datasource> const> sources,
-  cudf::host_span<rmm::device_buffer> bloom_filter_data,
-  host_span<size_type const> chunks,
-  cudf::host_span<std::optional<int64_t>> bloom_filter_offsets,
-  cudf::host_span<std::optional<int32_t>> bloom_filter_sizes,
-  std::vector<size_type> const& chunk_source_map,
-  rmm::cuda_stream_view stream)
-{
-  // Transfer bloom filter data
-  std::vector<std::future<size_t>> read_tasks;
-
-  // FIXME: Do not read all chunks. Instead use a list of chunks to read.
-  for (auto chunk : chunks) {
-    // Read bloom filter if present
-    if (bloom_filter_offsets[chunk].has_value()) {
-      auto const bloom_filter_offset = bloom_filter_offsets[chunk].value();
-      // If Bloom filter size (header + bitset) is available, just read the entire thing.
-      // Else just read 256 bytes which will contain the entire header and may contain the
-      // entire bitset as well.
-      auto constexpr bloom_filter_header_size_guess = 256;
-      auto const initial_read_size =
-        bloom_filter_sizes[chunk].value_or(bloom_filter_header_size_guess);
-
-      // Read an initial buffer from source
-      auto& source = sources[chunk_source_map[chunk]];
-      auto buffer  = source->host_read(bloom_filter_offset, initial_read_size);
-
-      // Deserialize the Bloom filter header from the buffer.
-      BloomFilterHeader header;
-      CompactProtocolReader cp{buffer->data(), buffer->size()};
-      cp.read(&header);
-
-      // Test if header is valid.
-      auto const is_header_valid =
-        (header.num_bytes % 32) == 0 and
-        header.compression.compression == BloomFilterCompression::Compression::UNCOMPRESSED and
-        header.algorithm.algorithm == BloomFilterAlgorithm::Algorithm::SPLIT_BLOCK and
-        header.hash.hash == BloomFilterHash::Hash::XXHASH;
-
-      if (not is_header_valid) {
-        // Simply use an empty device buffer and move on.
-        bloom_filter_data[chunk] = rmm::device_buffer{};
-        CUDF_LOG_WARN("Encountered an invalid bloom filter header. Skipping");
-        continue;
-      }
-
-      // Bloom filter header size
-      auto const bloom_filter_header_size = static_cast<int64_t>(cp.bytecount());
-      auto const bitset_size              = header.num_bytes;
-
-      // Check if we already read in the filter bitset in the initial read.
-      if (initial_read_size >= bloom_filter_header_size + bitset_size) {
-        bloom_filter_data[chunk] =
-          rmm::device_buffer(buffer->data() + bloom_filter_header_size, bitset_size, stream);
-      }
-      // Read the bitset from datasource.
-      else {
-        auto const bitset_offset = bloom_filter_offset + bloom_filter_header_size;
-        // Directly read to device if preferred
-        if (source->is_device_read_preferred(bitset_size)) {
-          bloom_filter_data[chunk] = rmm::device_buffer(bitset_size, stream);
-          auto future_read_size =
-            source->device_read_async(bitset_offset,
-                                      bitset_size,
-                                      static_cast<uint8_t*>(bloom_filter_data[chunk].data()),
-                                      stream);
-
-          read_tasks.emplace_back(std::move(future_read_size));
-        } else {
-          buffer                   = source->host_read(bitset_offset, bitset_size);
-          bloom_filter_data[chunk] = rmm::device_buffer(buffer->data(), buffer->size(), stream);
-        }
-      }
-    } else {
-      // Simply use an empty device buffer.
-      bloom_filter_data[chunk] = rmm::device_buffer{};
-    }
-  }
-  auto sync_fn = [](decltype(read_tasks) read_tasks) {
-    for (auto& task : read_tasks) {
-      task.wait();
-    }
-  };
-  return std::async(std::launch::deferred, sync_fn, std::move(read_tasks));
-}
-
-std::optional<std::vector<std::vector<size_type>>>
-aggregate_reader_metadata::apply_bloom_filter_to_row_groups(
-  host_span<std::unique_ptr<datasource> const> sources,
-  host_span<std::vector<size_type> const> row_group_indices,
-  host_span<data_type const> output_dtypes,
-  host_span<int const> output_column_schemas,
-  rmm::cuda_stream_view stream) const
-{
-  // Create row group indices.
-  // std::vector<std::vector<size_type>> filtered_row_group_indices;
-  // Number of total row groups to process.
-  auto const num_row_groups = std::accumulate(row_group_indices.begin(),
-                                              row_group_indices.end(),
-                                              0,
-                                              [](size_type sum, auto const& per_file_row_groups) {
-                                                return sum + per_file_row_groups.size();
-                                              });
-
-  // Descriptors for all the chunks that make up the selected columns
-  auto const num_input_columns = output_dtypes.size();
-  auto const num_chunks        = num_row_groups * num_input_columns;
-
-  // Association between each column chunk and its source
-  std::vector<size_type> chunk_source_map(num_chunks);
-
-  // Keep track of column chunk file offsets
-  std::vector<std::optional<int64_t>> bloom_filter_offsets(num_chunks);
-  std::vector<std::optional<int32_t>> bloom_filter_sizes(num_chunks);
-
-  // List of chunks to read
-  std::vector<size_type> chunks_to_read{};
-  chunks_to_read.reserve(num_chunks);
-
-  size_type chunk_count = 0;
-
-  // FIXME: We don't need to read bloom filters for all chunks. Only the ones belonging to the
-  // columns of our interest (equality predicate).
-  // For all data sources
-  for (size_t rg_source_index = 0; rg_source_index < row_group_indices.size(); rg_source_index++) {
-    auto const& rg_index = row_group_indices[rg_source_index];
-    // For all row groups in a data source
-    for (auto const rgi : rg_index) {
-      // For all column chunks in a row group
-      for (size_t col_idx = 0; col_idx < output_dtypes.size(); col_idx++) {
-        auto const schema_idx = output_column_schemas[col_idx];
-        auto& col_meta        = get_column_metadata(rgi, rg_source_index, schema_idx);
-
-        // Bloom filter offsets and sizes
-        bloom_filter_offsets[chunk_count] = col_meta.bloom_filter_offset;
-        bloom_filter_sizes[chunk_count]   = col_meta.bloom_filter_length;
-        chunks_to_read.emplace_back(chunk_count);
-
-        // Map each column chunk to its column index and its source index
-        chunk_source_map[chunk_count] = rg_source_index;
-        chunk_count++;
-      }
-    }
-  }
-
-  // Do we have any bloom filters
-  if (std::any_of(bloom_filter_offsets.cbegin(),
-                  bloom_filter_offsets.cend(),
-                  [](auto const offset) { return offset.has_value(); })) {
-    // Initialize the vector of bloom filter data buffers
-    std::vector<rmm::device_buffer> bloom_filter_data(num_chunks);
-
-    // Wait on bloom filter read tasks
-    read_bloom_filters_async(sources,
-                             bloom_filter_data,
-                             chunks_to_read,
-                             bloom_filter_offsets,
-                             bloom_filter_sizes,
-                             chunk_source_map,
-                             stream)
-      .wait();
-
-    // Apply bloom filter to row groups
-    // return apply_bloom_filters();
-  }
-  return {};
-}
-
 std::tuple<int64_t, size_type, std::vector<row_group_info>, std::vector<size_t>>
 aggregate_reader_metadata::select_row_groups(
   host_span<std::unique_ptr<datasource> const> sources,
@@ -1230,7 +1048,7 @@ aggregate_reader_metadata::select_row_groups(
   // if filter is not empty, then gather row groups to read after predicate pushdown
   if (filter.has_value()) {
     filtered_row_group_indices = filter_row_groups(
-      row_group_indices, output_dtypes, output_column_schemas, filter.value(), stream);
+      sources, row_group_indices, output_dtypes, output_column_schemas, filter.value(), stream);
     if (filtered_row_group_indices.has_value()) {
       row_group_indices =
         host_span<std::vector<size_type> const>(filtered_row_group_indices.value());
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index 7faae405b4a..b03aa9ec296 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -367,24 +367,21 @@ class aggregate_reader_metadata {
                     rmm::cuda_stream_view stream) const;
 
   /**
-   * @brief Filters the row groups using bloom filters
+   * @brief Reads bloom filter bitsets for the specified columns from the given lists of row
+   * groups.
    *
    * @param sources Dataset sources
-   * @param bloom_filter_data Devicebuffers to hold bloom filter bitsets for each chunk
-   * @param begin_chunk Index of first column chunk to read
-   * @param end_chunk Index after the last column chunk to read
-   * @param bloom_filter_offsets Bloom filter offsets for all chunks
-   * @param bloom_filter_sizes Bloom filter sizes for all chunks
-   * @param chunk_source_map Association between each column chunk and its source
+   * @param row_group_indices Lists of row groups to read bloom filters from, one per source
+   * @param column_schemas Schema indices of columns whose bloom filters will be read
    * @param stream CUDA stream used for device memory operations and kernel launches
    *
-   * @return Filtered row group indices, if any is filtered.
+   * @return A list of bloom filter bitset device buffers flattened over column schemas over lists
+   * of row group indices
    */
-  std::optional<std::vector<std::vector<size_type>>> apply_bloom_filter_to_row_groups(
+  std::vector<rmm::device_buffer> read_bloom_filters(
     host_span<std::unique_ptr<datasource> const> sources,
     host_span<std::vector<size_type> const> row_group_indices,
-    host_span<data_type const> output_dtypes,
-    host_span<int const> output_column_schemas,
+    host_span<int const> column_schemas,
     rmm::cuda_stream_view stream) const;
 
   /**

From f8e6159e16d09e9c028f996c634ba9069d7c990e Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Sat, 16 Nov 2024 05:06:19 +0000
Subject: [PATCH 19/85] Revert erroneous changes

---
 .../io/parquet/reader_apply_bloom_filters.cu  | 36 -------------------
 cpp/src/io/parquet/reader_impl_helpers.cpp    |  5 ---
 2 files changed, 41 deletions(-)
 delete mode 100644 cpp/src/io/parquet/reader_apply_bloom_filters.cu

diff --git a/cpp/src/io/parquet/reader_apply_bloom_filters.cu b/cpp/src/io/parquet/reader_apply_bloom_filters.cu
deleted file mode 100644
index fc85a0a1eb2..00000000000
--- a/cpp/src/io/parquet/reader_apply_bloom_filters.cu
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright (c) 2024, NVIDIA CORPORATION.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-/**
- * @file bloom_filter_reader.cu
- * @brief Bloom filter reader based row group filtration implementation
- */
-
-#include "parquet.hpp"
-#include "parquet_common.hpp"
-
-#include <cudf/utilities/error.hpp>
-
-#include <cuco/bloom_filter.cuh>
-
-#include <algorithm>
-#include <cstddef>
-#include <functional>
-#include <optional>
-#include <tuple>
-
-// TODO: Implement this
-cuda::std::optional<std::vector<std::vector<cudf::size_type>>> apply_bloom_filters() { return {}; }
diff --git a/cpp/src/io/parquet/reader_impl_helpers.cpp b/cpp/src/io/parquet/reader_impl_helpers.cpp
index 9c05009b528..ae720a9622d 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.cpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.cpp
@@ -25,16 +25,11 @@
 
 #include <cudf/detail/utilities/logger.hpp>
 
-#include <rmm/cuda_stream_view.hpp>
-#include <rmm/device_buffer.hpp>
-
 #include <thrust/iterator/counting_iterator.h>
 #include <thrust/iterator/zip_iterator.h>
 
 #include <functional>
-#include <future>
 #include <numeric>
-#include <optional>
 #include <regex>
 
 namespace cudf::io::parquet::detail {

From 1886cabae52f2495e6b6071a15101f9c57b9d1a5 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Sat, 16 Nov 2024 05:13:54 +0000
Subject: [PATCH 20/85] Style and doc fix

---
 cpp/src/io/parquet/bloom_filter_reader.cpp |  2 +-
 cpp/src/io/parquet/parquet.hpp             | 29 +++++++++++++---------
 2 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cpp b/cpp/src/io/parquet/bloom_filter_reader.cpp
index 346ccd22c58..fabc70cc5f2 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cpp
+++ b/cpp/src/io/parquet/bloom_filter_reader.cpp
@@ -206,4 +206,4 @@ std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
   return {};
 }
 
-}  // namespace cudf::io::parquet::detail
\ No newline at end of file
+}  // namespace cudf::io::parquet::detail
diff --git a/cpp/src/io/parquet/parquet.hpp b/cpp/src/io/parquet/parquet.hpp
index 118ec43133b..ff8e7a63486 100644
--- a/cpp/src/io/parquet/parquet.hpp
+++ b/cpp/src/io/parquet/parquet.hpp
@@ -396,40 +396,45 @@ struct ColumnChunkMetaData {
 };
 
 /**
- * @brief The algorithm used in Bloom filter.
- **/
+ * @brief The algorithm used in bloom filter
+ */
 struct BloomFilterAlgorithm {
-  /** Block-based Bloom filter. **/
+  // Block-based Bloom filter.
   enum Algorithm { UNDEFINED, SPLIT_BLOCK };
   Algorithm algorithm{Algorithm::SPLIT_BLOCK};
 };
 
 /**
- * @brief The hash function used in Bloom filter. This function takes the hash of a column value
- * using plain encoding.
- **/
+ * @brief The hash function used in Bloom filter
+ */
 struct BloomFilterHash {
-  /** xxHash Strategy. **/
+  // xxHash_64
   enum Hash { UNDEFINED, XXHASH };
   Hash hash{Hash::XXHASH};
 };
 
 /**
- * @brief The compression used in the Bloom filter.
- **/
+ * @brief The compression used in the bloom filter
+ */
 struct BloomFilterCompression {
   enum Compression { UNDEFINED, UNCOMPRESSED };
   Compression compression{Compression::UNCOMPRESSED};
 };
 
+/**
+ * @brief Bloom filter header struct
+ *
+ * The bloom filter data of a column chunk stores this header at the beginning
+ * following by the filter bitset.
+ */
 struct BloomFilterHeader {
   // The size of bitset in bytes
   int32_t num_bytes;
-  // The algorithm for setting bits. *
+  // The algorithm for setting bits
   BloomFilterAlgorithm algorithm;
-  // The hash function used for Bloom filter. *
+  // The hash function used for bloom filter
   BloomFilterHash hash;
-  // The compression used in the Bloom filter *
+  // The compression used in the bloom filter
   BloomFilterCompression compression;
 };
 

From be228b31f7664c3d7bd12ce398c24e785b871400 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 19 Nov 2024 03:58:42 +0000
Subject: [PATCH 21/85] Get equality predicate col indices

---
 ...lter_reader.cpp => bloom_filter_reader.cu} | 189 ++++++++++++++++++
 cpp/src/io/parquet/predicate_pushdown.cpp     |   8 +-
 cpp/src/io/parquet/reader_impl_helpers.hpp    |  20 ++
 3 files changed, 216 insertions(+), 1 deletion(-)
 rename cpp/src/io/parquet/{bloom_filter_reader.cpp => bloom_filter_reader.cu} (51%)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cpp b/cpp/src/io/parquet/bloom_filter_reader.cu
similarity index 51%
rename from cpp/src/io/parquet/bloom_filter_reader.cpp
rename to cpp/src/io/parquet/bloom_filter_reader.cu
index fabc70cc5f2..89f448de05f 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cpp
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -18,14 +18,30 @@
 #include "io/parquet/parquet.hpp"
 #include "reader_impl_helpers.hpp"
 
+#include <cudf/ast/detail/expression_transformer.hpp>
+#include <cudf/ast/detail/operators.hpp>
+#include <cudf/ast/expressions.hpp>
+#include <cudf/column/column_factories.hpp>
+#include <cudf/detail/cuco_helpers.hpp>
+#include <cudf/detail/iterator.cuh>
+#include <cudf/detail/transform.hpp>
 #include <cudf/detail/utilities/logger.hpp>
+#include <cudf/utilities/error.hpp>
 
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/device_buffer.hpp>
+#include <rmm/device_vector.hpp>
+#include <rmm/exec_policy.hpp>
 
+#include <cuco/bloom_filter_policy.cuh>
+#include <cuco/bloom_filter_ref.cuh>
+#include <cuco/hash_functions.cuh>
+#include <thrust/for_each.h>
 #include <thrust/iterator/counting_iterator.h>
+#include <thrust/sequence.h>
 
 #include <future>
+#include <iterator>
 #include <numeric>
 #include <optional>
 
@@ -102,6 +118,37 @@ std::future<void> read_bloom_filters_async(
         if (initial_read_size >= bloom_filter_header_size + bitset_size) {
           bloom_filter_data[chunk] =
             rmm::device_buffer(buffer->data() + bloom_filter_header_size, bitset_size, stream);
+
+          /* MH: Remove this
+          using word_type = uint32_t;
+
+          thrust::for_each(rmm::exec_policy(stream),
+                           thrust::make_counting_iterator(0),
+                           thrust::make_counting_iterator(1),
+                           [words = reinterpret_cast<word_type*>(bloom_filter_data[chunk].data()),
+                            num_blocks = bloom_filter_data[chunk].size() / sizeof(uint32_t),
+                            chunk      = chunk,
+                            stream     = stream] __device__(auto idx) {
+                             using key_type = cuda::std::string;
+                             using policy_type =
+                               cuco::bloom_filter_policy<cuco::xxhash_64<key_type>, std::uint32_t,
+          8>;
+                             // using arrow_policy_type = cuco::arrow_filter_policy<key_type>;
+                             cuco::bloom_filter_ref<key_type,
+                                                    cuco::extent<std::size_t>,
+                                                    cuco::thread_scope_device,
+                                                    policy_type>
+                               filter{words, size_t{num_blocks}, {}, {8}};
+                             // cuda::std::string key{"third-136666"};
+                             // filter.add("third-136666");
+
+                             cuco::xxhash_64<key_type> hasher{};
+                             cuda::std::array<char, 13> val{"third-136666"};
+                             auto hash =
+          hasher.compute_hash(reinterpret_cast<std::byte*>(val.data()), val.size()); if
+          (filter.contains(hash)) { printf("Filter chunk: %lu contains key: third-136666\n", chunk);
+                             }
+                           });*/
         }
         // Read the bitset from datasource.
         else {
@@ -123,16 +170,158 @@ std::future<void> read_bloom_filters_async(
         }
       }
     });
+
   auto sync_fn = [](decltype(read_tasks) read_tasks) {
     for (auto& task : read_tasks) {
       task.wait();
     }
   };
+
   return std::async(std::launch::deferred, sync_fn, std::move(read_tasks));
 }
 
+/**
+ * @brief Collects column indices with an equality predicate in the AST expression.
+ * This is used in row group filtering based on bloom filters.
+ */
+class equality_predicate_converter : public ast::detail::expression_transformer {
+ public:
+  equality_predicate_converter(ast::expression const& expr, size_type const& num_columns)
+    : _num_columns{num_columns}
+  {
+    expr.accept(*this);
+  }
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::literal const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(ast::literal const& expr) override
+  {
+    _equality_expr = std::reference_wrapper<ast::expression const>(expr);
+    return expr;
+  }
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::column_reference const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(ast::column_reference const& expr) override
+  {
+    CUDF_EXPECTS(expr.get_table_source() == ast::table_reference::LEFT,
+                 "Equality AST supports only left table");
+    CUDF_EXPECTS(expr.get_column_index() < _num_columns,
+                 "Column index cannot be more than number of columns in the table");
+    _equality_expr = std::reference_wrapper<ast::expression const>(expr);
+    return expr;
+  }
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::column_name_reference const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(
+    ast::column_name_reference const& expr) override
+  {
+    CUDF_FAIL("Column name reference is not supported in equality AST");
+  }
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::operation const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(ast::operation const& expr) override
+  {
+    using cudf::ast::ast_operator;
+    auto const operands = expr.get_operands();
+    auto const op       = expr.get_operator();
+
+    if (auto* v = dynamic_cast<ast::column_reference const*>(&operands[0].get())) {
+      // First operand should be column reference, second should be literal.
+      CUDF_EXPECTS(cudf::ast::detail::ast_operator_arity(op) == 2,
+                   "Only binary operations are supported on column reference");
+      CUDF_EXPECTS(dynamic_cast<ast::literal const*>(&operands[1].get()) != nullptr,
+                   "Second operand of binary operation with column reference must be a literal");
+      v->accept(*this);
+      if (op == ast_operator::EQUAL) { equality_col_idx.emplace_back(v->get_column_index()); }
+    } else {
+      auto new_operands = visit_operands(operands);
+      if (cudf::ast::detail::ast_operator_arity(op) == 2) {
+        _operators.emplace_back(op, new_operands.front(), new_operands.back());
+      } else if (cudf::ast::detail::ast_operator_arity(op) == 1) {
+        _operators.emplace_back(op, new_operands.front());
+      }
+    }
+    _equality_expr = std::reference_wrapper<ast::expression const>(_operators.back());
+    return std::reference_wrapper<ast::expression const>(_operators.back());
+  }
+
+  /**
+   * @brief Returns a list of column indices with an equality predicate in the AST expression.
+   *
+   * @return List of column indices
+   */
+  [[nodiscard]] std::vector<cudf::size_type> get_equality_col_idx() const
+  {
+    return equality_col_idx;
+  }
+
+ private:
+  std::vector<std::reference_wrapper<ast::expression const>> visit_operands(
+    cudf::host_span<std::reference_wrapper<ast::expression const> const> operands)
+  {
+    std::vector<std::reference_wrapper<ast::expression const>> transformed_operands;
+    for (auto const& operand : operands) {
+      auto const new_operand = operand.get().accept(*this);
+      transformed_operands.push_back(new_operand);
+    }
+    return transformed_operands;
+  }
+  std::optional<std::reference_wrapper<ast::expression const>> _equality_expr;
+  std::vector<cudf::size_type> equality_col_idx;
+  size_type _num_columns;
+  std::list<ast::column_reference> _col_ref;
+  std::list<ast::operation> _operators;
+};
+
 }  // namespace
 
+std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::apply_bloom_filters(
+  host_span<std::unique_ptr<datasource> const> sources,
+  host_span<std::vector<size_type> const> row_group_indices,
+  host_span<data_type const> output_dtypes,
+  host_span<int const> output_column_schemas,
+  std::reference_wrapper<ast::expression const> filter,
+  rmm::cuda_stream_view stream) const
+{
+  auto const num_cols = output_dtypes.size();
+  CUDF_EXPECTS(output_dtypes.size() == output_column_schemas.size(),
+               "Mismatched size between lists of output column dtypes and output column schema");
+  auto mr = cudf::get_current_device_resource_ref();
+  std::vector<std::unique_ptr<column>> cols;
+  // MH: How do I test for nested or non-comparable columns here?
+  cols.emplace_back(cudf::make_numeric_column(
+    data_type{cudf::type_id::INT32}, num_cols, rmm::device_buffer{}, 0, stream, mr));
+
+  auto mutable_col_idx = cols.back()->mutable_view();
+
+  thrust::sequence(rmm::exec_policy(stream),
+                   mutable_col_idx.begin<size_type>(),
+                   mutable_col_idx.end<size_type>(),
+                   0);
+
+  auto equality_table = cudf::table(std::move(cols));
+
+  // Converts AST to EqualityAST with reference to min, max columns in above `stats_table`.
+  equality_predicate_converter equality_expr{filter.get(), static_cast<size_type>(num_cols)};
+  auto equality_col_schemas = equality_expr.get_equality_col_idx();
+
+  // Convert column indices to column schema indices
+  std::for_each(equality_col_schemas.begin(), equality_col_schemas.end(), [&](auto& col_idx) {
+    col_idx = output_column_schemas[col_idx];
+  });
+
+  std::ignore = read_bloom_filters(sources, row_group_indices, equality_col_schemas, stream);
+
+  return std::nullopt;
+}
+
 std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
   host_span<std::unique_ptr<datasource> const> sources,
   host_span<std::vector<size_type> const> row_group_indices,
diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp
index a977cfdeca7..eb30cc6955a 100644
--- a/cpp/src/io/parquet/predicate_pushdown.cpp
+++ b/cpp/src/io/parquet/predicate_pushdown.cpp
@@ -479,7 +479,9 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
                   is_row_group_required.cend(),
                   [](auto i) { return bool(i); }) or
       predicate.null_count() == predicate.size()) {
-    return std::nullopt;
+    // Call with input_row_group_indices
+    return apply_bloom_filters(
+      sources, input_row_group_indices, output_dtypes, output_column_schemas, filter, stream);
   }
   size_type is_required_idx = 0;
   for (auto const& input_row_group_index : input_row_group_indices) {
@@ -493,6 +495,10 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
     filtered_row_group_indices.push_back(std::move(filtered_row_groups));
   }
 
+  // Call with filtered_row_group_indices
+  return apply_bloom_filters(
+    sources, filtered_row_group_indices, output_dtypes, output_column_schemas, filter, stream);
+
   return {std::move(filtered_row_group_indices)};
 }
 
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index b03aa9ec296..75edfdb7f7b 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -339,6 +339,26 @@ class aggregate_reader_metadata {
     std::reference_wrapper<ast::expression const> filter,
     rmm::cuda_stream_view stream) const;
 
+  /**
+   * @brief Filters the row groups using bloom filters
+   *
+   * @param sources Dataset sources
+   * @param row_group_indices Lists of row groups to read, one per source
+   * @param output_dtypes Datatypes of of output columns
+   * @param output_column_schemas schema indices of output columns
+   * @param filter AST expression to filter row groups based on Column chunk statistics
+   * @param stream CUDA stream used for device memory operations and kernel launches
+   *
+   * @return Filtered row group indices, if any is filtered.
+   */
+  [[nodiscard]] std::optional<std::vector<std::vector<size_type>>> apply_bloom_filters(
+    host_span<std::unique_ptr<datasource> const> sources,
+    host_span<std::vector<size_type> const> row_group_indices,
+    host_span<data_type const> output_dtypes,
+    host_span<int const> output_column_schemas,
+    std::reference_wrapper<ast::expression const> filter,
+    rmm::cuda_stream_view stream) const;
+
   /**
    * @brief Filters and reduces down to a selection of row groups
    *

From aaf355e1b2efb830ed72b2bf09957ae3a1e95e76 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 20 Nov 2024 02:45:46 +0000
Subject: [PATCH 22/85] Enable `arrow_filter_policy` and `span` types in bloom
 filter.

---
 cpp/src/io/parquet/arrow_filter_policy.cuh | 187 +++++++++++++++++++++
 cpp/src/io/parquet/bloom_filter_reader.cu  |  89 ++++++----
 2 files changed, 246 insertions(+), 30 deletions(-)
 create mode 100644 cpp/src/io/parquet/arrow_filter_policy.cuh

diff --git a/cpp/src/io/parquet/arrow_filter_policy.cuh b/cpp/src/io/parquet/arrow_filter_policy.cuh
new file mode 100644
index 00000000000..95edf68cab4
--- /dev/null
+++ b/cpp/src/io/parquet/arrow_filter_policy.cuh
@@ -0,0 +1,187 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cuco/hash_functions.cuh>
+#include <cuda/functional>
+#include <cuda/std/bit>
+#include <cuda/std/limits>
+
+#include <cstdint>
+#include <nv/target>
+
+namespace cuco {
+
+/**
+ * @brief A policy that defines how Arrow Block-Split Bloom Filter generates and stores a key's
+ * fingerprint.
+ *
+ * @note: This file is a part of cuCollections. Copied here until we get a cuco bump for cudf.
+ *
+ * Reference:
+ * https://github.com/apache/arrow/blob/be1dcdb96b030639c0b56955c4c62f9d6b03f473/cpp/src/parquet/bloom_filter.cc#L219-L230
+ *
+ * Example:
+ * @code{.cpp}
+ * template <typename KeyType, std::uint32_t NUM_FILTER_BLOCKS>
+ * void bulk_insert_and_eval_arrow_policy_bloom_filter(device_vector<KeyType> const& positive_keys,
+ *                                                 device_vector<KeyType> const& negative_keys)
+ * {
+ *     using policy_type = cuco::arrow_filter_policy<key_type>;
+ *
+ *     // Warn or throw if the number of filter blocks is greater than maximum used by Arrow policy.
+ *     static_assert(NUM_FILTER_BLOCKS <= policy_type::max_filter_blocks, "NUM_FILTER_BLOCKS must be
+ *                                                                         in range: [1, 4194304]");
+ *
+ *     // Create a bloom filter with Arrow policy
+ *     cuco::bloom_filter<key_type, cuco::extent<size_t>,
+ *         cuda::thread_scope_device, policy_type> filter{NUM_FILTER_BLOCKS};
+ *
+ *     // Add positive keys to the bloom filter
+ *     filter.add(positive_keys.begin(), positive_keys.end());
+ *
+ *     auto const num_tp = positive_keys.size();
+ *     auto const num_tn = negative_keys.size();
+ *
+ *     // Vectors to store query results.
+ *     thrust::device_vector<bool> true_positive_result(num_tp, false);
+ *     thrust::device_vector<bool> true_negative_result(num_tn, false);
+ *
+ *     // Query the bloom filter for the inserted keys.
+ *     filter.contains(positive_keys.begin(), positive_keys.end(), true_positive_result.begin());
+ *
+ *     // We should see a true-positive rate of 1.
+ *     float true_positive_rate = float(thrust::count(thrust::device,
+ *          true_positive_result.begin(), true_positive_result.end(), true)) / float(num_tp);
+ *
+ *     // Query the bloom filter for the non-inserted keys.
+ *     filter.contains(negative_keys.begin(), negative_keys.end(), true_negative_result.begin());
+ *
+ *     // We may see a false-positive rate > 0 depending on the number of bits in the
+ *     // filter and the number of hashes used per key.
+ *     float false_positive_rate = float(thrust::count(thrust::device,
+ *          true_negative_result.begin(), true_negative_result.end(), true)) / float(num_tn);
+ * }
+ * @endcode
+ *
+ * @tparam Key The type of the values to generate a fingerprint for.
+ */
+template <class Key, class Hash>
+class arrow_filter_policy {
+ public:
+  using hasher             = Hash;           ///< Hash function for Arrow bloom filter policy
+  using word_type          = std::uint32_t;  ///< uint32_t for Arrow bloom filter policy
+  using hash_argument_type = typename hasher::argument_type;  ///< Hash function input type
+  using hash_result_type   = decltype(std::declval<hasher>()(
+    std::declval<hash_argument_type>()));  ///< hash function output type
+
+  static constexpr uint32_t bits_set_per_block = 8;  ///< hardcoded bits set per Arrow filter block
+  static constexpr uint32_t words_per_block    = 8;  ///< hardcoded words per Arrow filter block
+
+  static constexpr std::uint32_t bytes_per_filter_block =
+    32;  ///< Number of bytes in one Arrow filter block
+  static constexpr std::uint32_t max_arrow_filter_bytes =
+    128 * 1024 * 1024;  ///< Max bytes in Arrow bloom filter
+  static constexpr std::uint32_t max_filter_blocks =
+    (max_arrow_filter_bytes /
+     bytes_per_filter_block);  ///< Max sub-filter blocks allowed in Arrow bloom filter
+
+ private:
+  // Arrow's block-based bloom filter algorithm needs these eight odd SALT values to calculate
+  // eight indexes of bit to set, one bit in each 32-bit (uint32_t) word.
+  __device__ static constexpr cuda::std::array<std::uint32_t, 8> SALT()
+  {
+    return {0x47b6137bU,
+            0x44974d91U,
+            0x8824ad5bU,
+            0xa2b7289dU,
+            0x705495c7U,
+            0x2df1424bU,
+            0x9efc4947U,
+            0x5c6bfb31U};
+  }
+
+ public:
+  /**
+   * @brief Constructs the `arrow_filter_policy` object.
+   *
+   * @note The number of filter blocks with Arrow policy must be in the
+   * range of [1, 4194304]. If the bloom filter is constructed with a larger
+   * number of blocks, only the first 4194304 (128MB) blocks will be used.
+   *
+   * @param hash Hash function used to generate a key's fingerprint
+   */
+  __host__ __device__ constexpr arrow_filter_policy(hasher hash = {}) : hash_{hash} {}
+
+  /**
+   * @brief Generates the hash value for a given key.
+   *
+   * @param key The key to hash
+   *
+   * @return The hash value of the key
+   */
+  __device__ constexpr hash_result_type hash(hash_argument_type const& key) const
+  {
+    return hash_(key);
+  }
+
+  /**
+   * @brief Determines the filter block a key is added into.
+   *
+   * @note The number of filter blocks with Arrow policy must be in the
+   * range of [1, 4194304]. Passing a larger `num_blocks` will still
+   * upperbound the number of blocks used to the mentioned range.
+   *
+   * @tparam Extent Size type that is used to determine the number of blocks in the filter
+   *
+   * @param hash Hash value of the key
+   * @param num_blocks Number of block in the filter
+   *
+   * @return The block index for the given key's hash value
+   */
+  template <class Extent>
+  __device__ constexpr auto block_index(hash_result_type hash, Extent num_blocks) const
+  {
+    constexpr auto hash_bits = cuda::std::numeric_limits<word_type>::digits;
+    // TODO: assert if num_blocks > max_filter_blocks
+    auto const max_blocks = cuda::std::min<Extent>(num_blocks, max_filter_blocks);
+    // Make sure we are only contained withing the `max_filter_blocks` blocks
+    return static_cast<word_type>(((hash >> hash_bits) * max_blocks) >> hash_bits) % max_blocks;
+  }
+
+  /**
+   * @brief Determines the fingerprint pattern for a word/segment within the filter block for a
+   * given key's hash value.
+   *
+   * @param hash Hash value of the key
+   * @param word_index Target word/segment within the filter block
+   *
+   * @return The bit pattern for the word/segment in the filter block
+   */
+  __device__ constexpr word_type word_pattern(hash_result_type hash, std::uint32_t word_index) const
+  {
+    // SALT array to calculate bit indexes for the current word
+    auto constexpr salt = SALT();
+    word_type const key = static_cast<word_type>(hash);
+    return word_type{1} << ((key * salt[word_index]) >> 27);
+  }
+
+ private:
+  hasher hash_;
+};
+
+}  // namespace cuco
\ No newline at end of file
diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 89f448de05f..5178fbba3c1 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+#include "arrow_filter_policy.cuh"
 #include "compact_protocol_reader.hpp"
 #include "io/parquet/parquet.hpp"
 #include "reader_impl_helpers.hpp"
@@ -36,6 +37,7 @@
 #include <cuco/bloom_filter_policy.cuh>
 #include <cuco/bloom_filter_ref.cuh>
 #include <cuco/hash_functions.cuh>
+#include <cuda/std/span>
 #include <thrust/for_each.h>
 #include <thrust/iterator/counting_iterator.h>
 #include <thrust/sequence.h>
@@ -48,6 +50,61 @@
 namespace cudf::io::parquet::detail {
 
 namespace {
+
+/**
+ * @brief Temporary function that tests for key `third-037493` in bloom filters of column `c2` in
+ * test Parquet file.
+ *
+ * @param buffer Device buffer containing bloom filter bitset
+ * @param chunk Current row group index
+ * @param stream CUDA stream used for device memory operations and kernel launches
+ *
+ */
+void check_arbitrary_string_key(rmm::device_buffer const& buffer,
+                                size_t chunk,
+                                rmm::cuda_stream_view stream)
+{
+  using word_type   = cuda::std::uint32_t;
+  using key_type    = cuda::std::span<cuda::std::byte>;
+  using policy_type = cuco::arrow_filter_policy<key_type, cuco::xxhash_64<key_type>>;
+
+  thrust::for_each(
+    rmm::exec_policy_nosync(stream),
+    thrust::make_counting_iterator(0),
+    thrust::make_counting_iterator(1),
+    [bitset     = const_cast<word_type*>(reinterpret_cast<word_type const*>(buffer.data())),
+     num_blocks = static_cast<cuda::std::size_t>(buffer.size()) / sizeof(uint32_t),
+     chunk      = chunk,
+     stream     = stream] __device__(auto idx) {
+      // using arrow_policy_type = cuco::arrow_filter_policy<key_type>;
+      cuco::bloom_filter_ref<key_type,
+                             cuco::extent<std::size_t>,
+                             cuco::thread_scope_device,
+                             policy_type>
+        filter{
+          bitset,
+          num_blocks,
+          {},  // scope
+          {0}  // policy
+        };
+
+      // literal to search
+      cudf::string_view literal("third-037493", sizeof("third-037493"));
+      // convert to a cuda::std::span key to search
+      cuda::std::span<cuda::std::byte> const key(
+        const_cast<cuda::std::byte*>(reinterpret_cast<cuda::std::byte const*>(literal.data())),
+        static_cast<cuda::std::size_t>(literal.length()));
+      // Search in the filter
+      if (filter.contains(key)) {
+        printf("YES: Filter chunk: %lu contains key: third-037493\n", chunk);
+      } else {
+        printf("NO: Filter chunk: %lu does not contain key: third-037493\n", chunk);
+      }
+    });
+
+  stream.synchronize_no_throw();
+}
+
 /**
  * @brief Asynchronously reads bloom filters to device.
  *
@@ -119,36 +176,8 @@ std::future<void> read_bloom_filters_async(
           bloom_filter_data[chunk] =
             rmm::device_buffer(buffer->data() + bloom_filter_header_size, bitset_size, stream);
 
-          /* MH: Remove this
-          using word_type = uint32_t;
-
-          thrust::for_each(rmm::exec_policy(stream),
-                           thrust::make_counting_iterator(0),
-                           thrust::make_counting_iterator(1),
-                           [words = reinterpret_cast<word_type*>(bloom_filter_data[chunk].data()),
-                            num_blocks = bloom_filter_data[chunk].size() / sizeof(uint32_t),
-                            chunk      = chunk,
-                            stream     = stream] __device__(auto idx) {
-                             using key_type = cuda::std::string;
-                             using policy_type =
-                               cuco::bloom_filter_policy<cuco::xxhash_64<key_type>, std::uint32_t,
-          8>;
-                             // using arrow_policy_type = cuco::arrow_filter_policy<key_type>;
-                             cuco::bloom_filter_ref<key_type,
-                                                    cuco::extent<std::size_t>,
-                                                    cuco::thread_scope_device,
-                                                    policy_type>
-                               filter{words, size_t{num_blocks}, {}, {8}};
-                             // cuda::std::string key{"third-136666"};
-                             // filter.add("third-136666");
-
-                             cuco::xxhash_64<key_type> hasher{};
-                             cuda::std::array<char, 13> val{"third-136666"};
-                             auto hash =
-          hasher.compute_hash(reinterpret_cast<std::byte*>(val.data()), val.size()); if
-          (filter.contains(hash)) { printf("Filter chunk: %lu contains key: third-136666\n", chunk);
-                             }
-                           });*/
+          // MH: TODO: Temporary test. Remove me!!
+          check_arbitrary_string_key(bloom_filter_data[chunk], chunk, stream);
         }
         // Read the bitset from datasource.
         else {

From e92324ebe0eaa1cb0a1a214f713ffe4aba36743f Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Thu, 21 Nov 2024 08:41:10 +0000
Subject: [PATCH 23/85] Successfully search bloom filter

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 148 ++++++++++++++++++----
 1 file changed, 124 insertions(+), 24 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 5178fbba3c1..3c0c906a448 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -22,22 +22,18 @@
 #include <cudf/ast/detail/expression_transformer.hpp>
 #include <cudf/ast/detail/operators.hpp>
 #include <cudf/ast/expressions.hpp>
-#include <cudf/column/column_factories.hpp>
 #include <cudf/detail/cuco_helpers.hpp>
-#include <cudf/detail/iterator.cuh>
 #include <cudf/detail/transform.hpp>
 #include <cudf/detail/utilities/logger.hpp>
-#include <cudf/utilities/error.hpp>
+#include <cudf/hashing/detail/xxhash_64.cuh>
 
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/device_buffer.hpp>
 #include <rmm/device_vector.hpp>
 #include <rmm/exec_policy.hpp>
 
-#include <cuco/bloom_filter_policy.cuh>
+#include <cuco/bloom_filter.cuh>
 #include <cuco/bloom_filter_ref.cuh>
-#include <cuco/hash_functions.cuh>
-#include <cuda/std/span>
 #include <thrust/for_each.h>
 #include <thrust/iterator/counting_iterator.h>
 #include <thrust/sequence.h>
@@ -46,11 +42,115 @@
 #include <iterator>
 #include <numeric>
 #include <optional>
+#include <random>
 
 namespace cudf::io::parquet::detail {
 
 namespace {
 
+std::pair<std::vector<char>, std::vector<size_t>> generate_chars_and_offsets(size_t num_keys)
+{
+  static std::vector<std::string> const strings{"first",
+                                                "second",
+                                                "third",
+                                                "fourth",
+                                                "fifth",
+                                                "sixth",
+                                                "seventh",
+                                                "eighth",
+                                                "ninth",
+                                                "tenth",
+                                                "eleventh",
+                                                "twelfth",
+                                                "thirteenth",
+                                                "fourteenth",
+                                                "fifteenth",
+                                                "sixteenth",
+                                                "seventeenth",
+                                                "eighteenth"};
+
+  auto constexpr seed = 0xf00d;
+  /*static*/ std::mt19937 engine{seed};
+  /*static*/ std::uniform_int_distribution dist{};
+
+  std::vector<size_t> offsets(num_keys + 1);
+  std::vector<char> chars;
+  chars.reserve(12 * num_keys);  // 12 is the length of "seventeenth", the largest string
+  size_t offset = 0;
+  offsets[0]    = size_t{0};
+  std::generate_n(offsets.begin() + 1, num_keys, [&]() {
+    auto const& string  = strings[dist(engine) % strings.size()];
+    auto const char_ptr = const_cast<char*>(string.data());
+    chars.insert(chars.end(), char_ptr, char_ptr + string.length());
+    offset += string.length();
+    return offset;
+  });
+  return {std::move(chars), std::move(offsets)};
+}
+
+void validate_filter_bitwise(rmm::cuda_stream_view stream)
+{
+  std::size_t constexpr num_filter_blocks = 4;
+  std::size_t constexpr num_keys          = 50;
+
+  // Generate strings data
+  auto const [h_chars, h_offsets] = generate_chars_and_offsets(num_keys);
+  auto const mr                   = cudf::get_current_device_resource_ref();
+  auto d_chars                    = cudf::detail::make_device_uvector_async(h_chars, stream, mr);
+  auto d_offsets                  = cudf::detail::make_device_uvector_async(h_offsets, stream, mr);
+
+  rmm::device_uvector<cudf::string_view> d_keys(num_keys, stream);
+  thrust::transform(rmm::exec_policy_nosync(stream),
+                    thrust::make_counting_iterator<size_t>(0),
+                    thrust::make_counting_iterator<size_t>(num_keys),
+                    d_keys.begin(),
+                    [chars   = thrust::raw_pointer_cast(d_chars.data()),
+                     offsets = thrust::raw_pointer_cast(d_offsets.data())] __device__(auto idx) {
+                      return cudf::string_view{
+                        chars + offsets[idx],
+                        static_cast<cudf::size_type>(offsets[idx + 1] - offsets[idx])};
+                    });
+
+  using key_type    = cudf::string_view;
+  using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
+  using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
+  using filter_type = cuco::bloom_filter<key_type,
+                                         cuco::extent<size_t>,
+                                         cuda::thread_scope_device,
+                                         policy_type,
+                                         cudf::detail::cuco_allocator<char>>;
+  // Spawn a bloom filter
+  filter_type filter{
+    num_filter_blocks,
+    cuco::thread_scope_device,
+    {hasher_type{0}},
+    cudf::detail::cuco_allocator<char>{rmm::mr::polymorphic_allocator<char>{}, stream},
+    stream};
+
+  // Add strings to the bloom filter
+  filter.add(d_keys.begin(), d_keys.end(), stream);
+
+  using word_type = filter_type::word_type;
+
+  // Number of words in the filter
+  size_t const num_words = filter.block_extent() * filter.words_per_block;
+
+  // Get the filter bitset words
+  cudf::device_span<word_type const> filter_bitset(filter.data(), num_words);
+  // Expected filter bitset words
+  rmm::device_vector<word_type> const expected_bitset{
+    4194306,    4194305,  2359296,   1073774592, 524544,     1024,       268443648,  8519680,
+    2147500040, 8421380,  269500416, 4202624,    8396802,    100665344,  2147747840, 5243136,
+    131146,     655364,   285345792, 134222340,  545390596,  2281717768, 51201,      41943553,
+    1619656708, 67441680, 8462730,   361220,     2216738864, 587333888,  4219272,    873463873};
+
+  CUDF_EXPECTS(thrust::equal(rmm::exec_policy(stream),
+                             expected_bitset.cbegin(),
+                             expected_bitset.cend(),
+                             filter_bitset.begin()),
+               "Bloom filter bitset mismatched");
+}
+
 /**
  * @brief Temporary function that tests for key `third-037493` in bloom filters of column `c2` in
  * test Parquet file.
@@ -64,16 +164,21 @@ void check_arbitrary_string_key(rmm::device_buffer const& buffer,
                                 size_t chunk,
                                 rmm::cuda_stream_view stream)
 {
-  using word_type   = cuda::std::uint32_t;
-  using key_type    = cuda::std::span<cuda::std::byte>;
-  using policy_type = cuco::arrow_filter_policy<key_type, cuco::xxhash_64<key_type>>;
+  using key_type    = cudf::string_view;
+  using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
+  using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
+  using word_type   = policy_type::word_type;
+
+  auto constexpr word_size       = sizeof(word_type);
+  auto constexpr words_per_block = policy_type::words_per_block;
+  auto const num_filter_blocks   = buffer.size() / (word_size * words_per_block);
 
   thrust::for_each(
-    rmm::exec_policy_nosync(stream),
+    rmm::exec_policy(stream),
     thrust::make_counting_iterator(0),
     thrust::make_counting_iterator(1),
     [bitset     = const_cast<word_type*>(reinterpret_cast<word_type const*>(buffer.data())),
-     num_blocks = static_cast<cuda::std::size_t>(buffer.size()) / sizeof(uint32_t),
+     num_blocks = num_filter_blocks,
      chunk      = chunk,
      stream     = stream] __device__(auto idx) {
       // using arrow_policy_type = cuco::arrow_filter_policy<key_type>;
@@ -81,19 +186,13 @@ void check_arbitrary_string_key(rmm::device_buffer const& buffer,
                              cuco::extent<std::size_t>,
                              cuco::thread_scope_device,
                              policy_type>
-        filter{
-          bitset,
-          num_blocks,
-          {},  // scope
-          {0}  // policy
-        };
+        filter{bitset,
+               num_blocks,
+               {},  // scope
+               {hasher_type{0}}};
 
       // literal to search
-      cudf::string_view literal("third-037493", sizeof("third-037493"));
-      // convert to a cuda::std::span key to search
-      cuda::std::span<cuda::std::byte> const key(
-        const_cast<cuda::std::byte*>(reinterpret_cast<cuda::std::byte const*>(literal.data())),
-        static_cast<cuda::std::size_t>(literal.length()));
+      cudf::string_view key("third-037493", 12);
       // Search in the filter
       if (filter.contains(key)) {
         printf("YES: Filter chunk: %lu contains key: third-037493\n", chunk);
@@ -101,8 +200,6 @@ void check_arbitrary_string_key(rmm::device_buffer const& buffer,
         printf("NO: Filter chunk: %lu does not contain key: third-037493\n", chunk);
       }
     });
-
-  stream.synchronize_no_throw();
 }
 
 /**
@@ -206,6 +303,9 @@ std::future<void> read_bloom_filters_async(
     }
   };
 
+  // MH: Remove me. Bitwise validation for bloom filter
+  validate_filter_bitwise(stream);
+
   return std::async(std::launch::deferred, sync_fn, std::move(read_tasks));
 }
 

From 0b1719d61d0838ecc57cb3f6c7605d656c5491b6 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Thu, 21 Nov 2024 19:03:22 +0000
Subject: [PATCH 24/85] style fix

---
 cpp/src/io/parquet/arrow_filter_policy.cuh | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/io/parquet/arrow_filter_policy.cuh b/cpp/src/io/parquet/arrow_filter_policy.cuh
index 95edf68cab4..dfb6745bed8 100644
--- a/cpp/src/io/parquet/arrow_filter_policy.cuh
+++ b/cpp/src/io/parquet/arrow_filter_policy.cuh
@@ -184,4 +184,4 @@ class arrow_filter_policy {
   hasher hash_;
 };
 
-}  // namespace cuco
\ No newline at end of file
+}  // namespace cuco

From ef3a26212e38759f2aae8b1dbddb07576455d186 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Fri, 22 Nov 2024 02:35:00 +0000
Subject: [PATCH 25/85] Code cleanup

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 80 +++++++++++++----------
 1 file changed, 46 insertions(+), 34 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 3c0c906a448..6eed5c5dd21 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -34,8 +34,8 @@
 
 #include <cuco/bloom_filter.cuh>
 #include <cuco/bloom_filter_ref.cuh>
-#include <thrust/for_each.h>
 #include <thrust/iterator/counting_iterator.h>
+#include <thrust/logical.h>
 #include <thrust/sequence.h>
 
 #include <future>
@@ -155,51 +155,61 @@ void validate_filter_bitwise(rmm::cuda_stream_view stream)
  * @brief Temporary function that tests for key `third-037493` in bloom filters of column `c2` in
  * test Parquet file.
  *
+ * @tparam Key Type of the key to query bloom filter.
+ *
  * @param buffer Device buffer containing bloom filter bitset
  * @param chunk Current row group index
  * @param stream CUDA stream used for device memory operations and kernel launches
  *
  */
-void check_arbitrary_string_key(rmm::device_buffer const& buffer,
-                                size_t chunk,
-                                rmm::cuda_stream_view stream)
+template <typename Key = cudf::string_view>
+[[nodiscard]] bool check_arbitrary_string_key(rmm::device_buffer const& buffer,
+                                              Key const& literal,
+                                              size_t chunk_idx,
+                                              rmm::cuda_stream_view stream)
 {
-  using key_type    = cudf::string_view;
+  using key_type    = Key;
   using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
   using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
-  using word_type   = policy_type::word_type;
+  using word_type   = typename policy_type::word_type;
 
+  // Filter properties
   auto constexpr word_size       = sizeof(word_type);
   auto constexpr words_per_block = policy_type::words_per_block;
   auto const num_filter_blocks   = buffer.size() / (word_size * words_per_block);
 
-  thrust::for_each(
-    rmm::exec_policy(stream),
-    thrust::make_counting_iterator(0),
-    thrust::make_counting_iterator(1),
-    [bitset     = const_cast<word_type*>(reinterpret_cast<word_type const*>(buffer.data())),
-     num_blocks = num_filter_blocks,
-     chunk      = chunk,
-     stream     = stream] __device__(auto idx) {
-      // using arrow_policy_type = cuco::arrow_filter_policy<key_type>;
-      cuco::bloom_filter_ref<key_type,
-                             cuco::extent<std::size_t>,
-                             cuco::thread_scope_device,
-                             policy_type>
-        filter{bitset,
-               num_blocks,
-               {},  // scope
-               {hasher_type{0}}};
-
-      // literal to search
-      cudf::string_view key("third-037493", 12);
-      // Search in the filter
-      if (filter.contains(key)) {
-        printf("YES: Filter chunk: %lu contains key: third-037493\n", chunk);
-      } else {
-        printf("NO: Filter chunk: %lu does not contain key: third-037493\n", chunk);
-      }
-    });
+  // Bitset ptr must be a non-const to be used in bloom_filter_ref.
+  auto bitset = const_cast<word_type*>(reinterpret_cast<word_type const*>(buffer.data()));
+
+  // Create a bloom filter view
+  cuco::
+    bloom_filter_ref<key_type, cuco::extent<std::size_t>, cuco::thread_scope_device, policy_type>
+      filter{bitset,
+             num_filter_blocks,
+             {},  // scope
+             {hasher_type{0}}};
+
+  // Copy over the key (literal) to device
+  rmm::device_buffer d_key{literal.data(), static_cast<size_t>(literal.size_bytes()), stream};
+
+  // Query literal in bloom filter.
+  bool const is_literal_found =
+    thrust::count_if(rmm::exec_policy(stream),
+                     thrust::make_counting_iterator(0),
+                     thrust::make_counting_iterator(1),
+                     [filter   = filter,
+                      key_ptr  = reinterpret_cast<char*>(d_key.data()),
+                      key_size = static_cast<cudf::size_type>(d_key.size())] __device__(auto idx) {
+                       auto const d_key = cudf::string_view{key_ptr, key_size};
+                       return filter.contains(d_key);
+                     });
+
+  // MH: Temporary
+  auto const found_string = (is_literal_found) ? "YES" : "NO";
+  std::cout << "Literal: third-037493 found in chunk " << chunk_idx << ": " << found_string
+            << std::endl;
+
+  return is_literal_found;
 }
 
 /**
@@ -274,7 +284,9 @@ std::future<void> read_bloom_filters_async(
             rmm::device_buffer(buffer->data() + bloom_filter_header_size, bitset_size, stream);
 
           // MH: TODO: Temporary test. Remove me!!
-          check_arbitrary_string_key(bloom_filter_data[chunk], chunk, stream);
+          cudf::string_view literal{"third-037493", 12};
+          std::ignore =
+            check_arbitrary_string_key(bloom_filter_data[chunk], literal, chunk, stream);
         }
         // Read the bitset from datasource.
         else {

From 051be2d6caad8b4ad78b0a9d5e0f2880f7b37198 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Mon, 25 Nov 2024 21:30:54 +0000
Subject: [PATCH 26/85] add tests

---
 cpp/tests/CMakeLists.txt               |  1 +
 cpp/tests/hashing/bloom_filter_test.cu | 95 ++++++++++++++++++++++++++
 2 files changed, 96 insertions(+)
 create mode 100644 cpp/tests/hashing/bloom_filter_test.cu

diff --git a/cpp/tests/CMakeLists.txt b/cpp/tests/CMakeLists.txt
index 8928d27a871..94a5063d150 100644
--- a/cpp/tests/CMakeLists.txt
+++ b/cpp/tests/CMakeLists.txt
@@ -182,6 +182,7 @@ ConfigureTest(DATETIME_OPS_TEST datetime/datetime_ops_test.cpp)
 # * hashing tests ---------------------------------------------------------------------------------
 ConfigureTest(
   HASHING_TEST
+  hashing/bloom_filter_test.cu
   hashing/md5_test.cpp
   hashing/murmurhash3_x86_32_test.cpp
   hashing/murmurhash3_x64_128_test.cpp
diff --git a/cpp/tests/hashing/bloom_filter_test.cu b/cpp/tests/hashing/bloom_filter_test.cu
new file mode 100644
index 00000000000..e0e98dd84a0
--- /dev/null
+++ b/cpp/tests/hashing/bloom_filter_test.cu
@@ -0,0 +1,95 @@
+/*
+ * Copyright (c) 2024, NVIDIA CORPORATION.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+#include <cudf_test/base_fixture.hpp>
+#include <cudf_test/column_utilities.hpp>
+#include <cudf_test/column_wrapper.hpp>
+#include <cudf_test/iterator_utilities.hpp>
+
+#include <cudf/detail/cuco_helpers.hpp>
+#include <cudf/hashing/detail/xxhash_64.cuh>
+#include <cudf/utilities/default_stream.hpp>
+
+#include <cuco/bloom_filter.cuh>
+
+using StringType = cudf::string_view;
+
+template <typename T>
+class BloomFilter_TestTyped : public cudf::test::BaseFixture {};
+
+TYPED_TEST_SUITE(BloomFilter_TestTyped, StringType);
+
+TYPED_TEST(BloomFilter_TestTyped, TestStrings)
+{
+  using key_type    = StringType;
+  using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
+  using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
+
+  std::size_t constexpr num_filter_blocks = 4;
+  std::size_t constexpr num_keys          = 50;
+  auto stream                             = cudf::get_default_stream();
+
+  // strings data
+  auto data = cudf::test::strings_column_wrapper(
+    {"seventh",    "fifteenth",   "second",      "tenth",      "fifth",       "first",
+     "seventh",    "tenth",       "ninth",       "ninth",      "seventeenth", "eighteenth",
+     "thirteenth", "fifth",       "fourth",      "twelfth",    "second",      "second",
+     "fourth",     "seventh",     "seventh",     "tenth",      "thirteenth",  "seventeenth",
+     "fifth",      "seventeenth", "eighth",      "fourth",     "second",      "eighteenth",
+     "fifteenth",  "second",      "seventeenth", "thirteenth", "eighteenth",  "fifth",
+     "seventh",    "tenth",       "fourteenth",  "first",      "fifth",       "fifth",
+     "tenth",      "thirteenth",  "fourteenth",  "third",      "third",       "sixth",
+     "first",      "third"});
+  auto d_column = cudf::column_device_view::create(data);
+
+  // Spawn a bloom filter
+  cuco::bloom_filter<key_type,
+                     cuco::extent<size_t>,
+                     cuda::thread_scope_device,
+                     policy_type,
+                     cudf::detail::cuco_allocator<char>>
+    filter{num_filter_blocks,
+           cuco::thread_scope_device,
+           {hasher_type{0}},
+           cudf::detail::cuco_allocator<char>{rmm::mr::polymorphic_allocator<char>{}, stream},
+           stream};
+
+  // Add strings to the bloom filter
+  auto col = table.column(0);
+  filter.add(d_column->begin<key_type>(), d_column->end<key_type>(), stream);
+
+  // Number of words in the filter
+  cudf::size_type const num_words = filter.block_extent() * filter.words_per_block;
+
+  auto const output = cudf::column_view{
+    cudf::data_type{cudf::type_id::UINT32}, num_words, filter.data(), nullptr, 0, 0, {}};
+
+  using word_type = filter_type::word_type;
+
+  // Expected filter bitset words computed using Arrow implementation here:
+  // https://godbolt.org/z/oKfqcPWbY
+  auto expected = cudf::test::fixed_width_column_wrapper<word_type>(
+    {4194306,    4194305,  2359296,   1073774592, 524544,     1024,       268443648,  8519680,
+     2147500040, 8421380,  269500416, 4202624,    8396802,    100665344,  2147747840, 5243136,
+     131146,     655364,   285345792, 134222340,  545390596,  2281717768, 51201,      41943553,
+     1619656708, 67441680, 8462730,   361220,     2216738864, 587333888,  4219272,    873463873});
+  auto d_expected = cudf::column_device_view::create(expected);
+
+  // Check
+  CUDF_TEST_EXPECT_COLUMNS_EQUAL(output, d_expected);
+}
+*/
\ No newline at end of file

From fb55c3f0f689f7ba9084506acb060072c320be56 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 26 Nov 2024 05:00:27 +0000
Subject: [PATCH 27/85] Major cleanups

---
 cpp/CMakeLists.txt                         |   1 +
 cpp/src/io/parquet/bloom_filter_reader.cu  | 739 ++++++++++++---------
 cpp/src/io/parquet/predicate_pushdown.cpp  |   9 +-
 cpp/src/io/parquet/reader_impl_helpers.hpp |  38 +-
 4 files changed, 442 insertions(+), 345 deletions(-)

diff --git a/cpp/CMakeLists.txt b/cpp/CMakeLists.txt
index e4fa3b28383..cc14489654c 100644
--- a/cpp/CMakeLists.txt
+++ b/cpp/CMakeLists.txt
@@ -502,6 +502,7 @@ add_library(
   src/datetime/timezone.cpp
   src/io/orc/writer_impl.cu
   src/io/parquet/arrow_schema_writer.cpp
+  src/io/parquet/bloom_filter_reader.cu
   src/io/parquet/compact_protocol_reader.cpp
   src/io/parquet/compact_protocol_writer.cpp
   src/io/parquet/decode_preprocess.cu
diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 6eed5c5dd21..ecf59238a49 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -17,12 +17,14 @@
 #include "arrow_filter_policy.cuh"
 #include "compact_protocol_reader.hpp"
 #include "io/parquet/parquet.hpp"
+#include "io/parquet/parquet_gpu.hpp"
 #include "reader_impl_helpers.hpp"
 
 #include <cudf/ast/detail/expression_transformer.hpp>
 #include <cudf/ast/detail/operators.hpp>
 #include <cudf/ast/expressions.hpp>
 #include <cudf/detail/cuco_helpers.hpp>
+#include <cudf/detail/iterator.cuh>
 #include <cudf/detail/transform.hpp>
 #include <cudf/detail/utilities/logger.hpp>
 #include <cudf/hashing/detail/xxhash_64.cuh>
@@ -32,7 +34,6 @@
 #include <rmm/device_vector.hpp>
 #include <rmm/exec_policy.hpp>
 
-#include <cuco/bloom_filter.cuh>
 #include <cuco/bloom_filter_ref.cuh>
 #include <thrust/iterator/counting_iterator.h>
 #include <thrust/logical.h>
@@ -45,291 +46,95 @@
 #include <random>
 
 namespace cudf::io::parquet::detail {
-
 namespace {
 
-std::pair<std::vector<char>, std::vector<size_t>> generate_chars_and_offsets(size_t num_keys)
-{
-  static std::vector<std::string> const strings{"first",
-                                                "second",
-                                                "third",
-                                                "fourth",
-                                                "fifth",
-                                                "sixth",
-                                                "seventh",
-                                                "eighth",
-                                                "ninth",
-                                                "tenth",
-                                                "eleventh",
-                                                "twelfth",
-                                                "thirteenth",
-                                                "fourteenth",
-                                                "fifteenth",
-                                                "sixteenth",
-                                                "seventeenth",
-                                                "eighteenth"};
-
-  auto constexpr seed = 0xf00d;
-  /*static*/ std::mt19937 engine{seed};
-  /*static*/ std::uniform_int_distribution dist{};
-
-  std::vector<size_t> offsets(num_keys + 1);
-  std::vector<char> chars;
-  chars.reserve(12 * num_keys);  // 12 is the length of "seventeenth", the largest string
-  size_t offset = 0;
-  offsets[0]    = size_t{0};
-  std::generate_n(offsets.begin() + 1, num_keys, [&]() {
-    auto const& string  = strings[dist(engine) % strings.size()];
-    auto const char_ptr = const_cast<char*>(string.data());
-    chars.insert(chars.end(), char_ptr, char_ptr + string.length());
-    offset += string.length();
-    return offset;
-  });
-  return {std::move(chars), std::move(offsets)};
-}
-
-void validate_filter_bitwise(rmm::cuda_stream_view stream)
-{
-  std::size_t constexpr num_filter_blocks = 4;
-  std::size_t constexpr num_keys          = 50;
-
-  // Generate strings data
-  auto const [h_chars, h_offsets] = generate_chars_and_offsets(num_keys);
-  auto const mr                   = cudf::get_current_device_resource_ref();
-  auto d_chars                    = cudf::detail::make_device_uvector_async(h_chars, stream, mr);
-  auto d_offsets                  = cudf::detail::make_device_uvector_async(h_offsets, stream, mr);
-
-  rmm::device_uvector<cudf::string_view> d_keys(num_keys, stream);
-  thrust::transform(rmm::exec_policy_nosync(stream),
-                    thrust::make_counting_iterator<size_t>(0),
-                    thrust::make_counting_iterator<size_t>(num_keys),
-                    d_keys.begin(),
-                    [chars   = thrust::raw_pointer_cast(d_chars.data()),
-                     offsets = thrust::raw_pointer_cast(d_offsets.data())] __device__(auto idx) {
-                      return cudf::string_view{
-                        chars + offsets[idx],
-                        static_cast<cudf::size_type>(offsets[idx + 1] - offsets[idx])};
-                    });
-
-  using key_type    = cudf::string_view;
-  using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
-  using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
-  using filter_type = cuco::bloom_filter<key_type,
-                                         cuco::extent<size_t>,
-                                         cuda::thread_scope_device,
-                                         policy_type,
-                                         cudf::detail::cuco_allocator<char>>;
-  // Spawn a bloom filter
-  filter_type filter{
-    num_filter_blocks,
-    cuco::thread_scope_device,
-    {hasher_type{0}},
-    cudf::detail::cuco_allocator<char>{rmm::mr::polymorphic_allocator<char>{}, stream},
-    stream};
-
-  // Add strings to the bloom filter
-  filter.add(d_keys.begin(), d_keys.end(), stream);
-
-  using word_type = filter_type::word_type;
-
-  // Number of words in the filter
-  size_t const num_words = filter.block_extent() * filter.words_per_block;
-
-  // Get the filter bitset words
-  cudf::device_span<word_type const> filter_bitset(filter.data(), num_words);
-  // Expected filter bitset words
-  rmm::device_vector<word_type> const expected_bitset{
-    4194306,    4194305,  2359296,   1073774592, 524544,     1024,       268443648,  8519680,
-    2147500040, 8421380,  269500416, 4202624,    8396802,    100665344,  2147747840, 5243136,
-    131146,     655364,   285345792, 134222340,  545390596,  2281717768, 51201,      41943553,
-    1619656708, 67441680, 8462730,   361220,     2216738864, 587333888,  4219272,    873463873};
-
-  CUDF_EXPECTS(thrust::equal(rmm::exec_policy(stream),
-                             expected_bitset.cbegin(),
-                             expected_bitset.cend(),
-                             filter_bitset.begin()),
-               "Bloom filter bitset mismatched");
-}
-
 /**
- * @brief Temporary function that tests for key `third-037493` in bloom filters of column `c2` in
- * test Parquet file.
- *
- * @tparam Key Type of the key to query bloom filter.
- *
- * @param buffer Device buffer containing bloom filter bitset
- * @param chunk Current row group index
- * @param stream CUDA stream used for device memory operations and kernel launches
- *
- */
-template <typename Key = cudf::string_view>
-[[nodiscard]] bool check_arbitrary_string_key(rmm::device_buffer const& buffer,
-                                              Key const& literal,
-                                              size_t chunk_idx,
-                                              rmm::cuda_stream_view stream)
-{
-  using key_type    = Key;
-  using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
-  using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
-  using word_type   = typename policy_type::word_type;
-
-  // Filter properties
-  auto constexpr word_size       = sizeof(word_type);
-  auto constexpr words_per_block = policy_type::words_per_block;
-  auto const num_filter_blocks   = buffer.size() / (word_size * words_per_block);
-
-  // Bitset ptr must be a non-const to be used in bloom_filter_ref.
-  auto bitset = const_cast<word_type*>(reinterpret_cast<word_type const*>(buffer.data()));
-
-  // Create a bloom filter view
-  cuco::
-    bloom_filter_ref<key_type, cuco::extent<std::size_t>, cuco::thread_scope_device, policy_type>
-      filter{bitset,
-             num_filter_blocks,
-             {},  // scope
-             {hasher_type{0}}};
-
-  // Copy over the key (literal) to device
-  rmm::device_buffer d_key{literal.data(), static_cast<size_t>(literal.size_bytes()), stream};
-
-  // Query literal in bloom filter.
-  bool const is_literal_found =
-    thrust::count_if(rmm::exec_policy(stream),
-                     thrust::make_counting_iterator(0),
-                     thrust::make_counting_iterator(1),
-                     [filter   = filter,
-                      key_ptr  = reinterpret_cast<char*>(d_key.data()),
-                      key_size = static_cast<cudf::size_type>(d_key.size())] __device__(auto idx) {
-                       auto const d_key = cudf::string_view{key_ptr, key_size};
-                       return filter.contains(d_key);
-                     });
-
-  // MH: Temporary
-  auto const found_string = (is_literal_found) ? "YES" : "NO";
-  std::cout << "Literal: third-037493 found in chunk " << chunk_idx << ": " << found_string
-            << std::endl;
-
-  return is_literal_found;
-}
-
-/**
- * @brief Asynchronously reads bloom filters to device.
- *
- * @param sources Dataset sources
- * @param num_chunks Number of total column chunks to read
- * @param bloom_filter_data Devicebuffers to hold bloom filter bitsets for each chunk
- * @param bloom_filter_offsets Bloom filter offsets for all chunks
- * @param bloom_filter_sizes Bloom filter sizes for all chunks
- * @param chunk_source_map Association between each column chunk and its source
- * @param stream CUDA stream used for device memory operations and kernel launches
+ * @brief Converts bloom filter query results for column chunks to a device column.
  *
- * @return A future object for reading synchronization
  */
-std::future<void> read_bloom_filters_async(
-  host_span<std::unique_ptr<datasource> const> sources,
-  size_t num_chunks,
-  cudf::host_span<rmm::device_buffer> bloom_filter_data,
-  cudf::host_span<std::optional<int64_t>> bloom_filter_offsets,
-  cudf::host_span<std::optional<int32_t>> bloom_filter_sizes,
-  std::vector<size_type> const& chunk_source_map,
-  rmm::cuda_stream_view stream)
-{
-  // Read tasks for bloom filter data
-  std::vector<std::future<size_t>> read_tasks;
-
-  // Read bloom filters for all column chunks
-  std::for_each(
-    thrust::make_counting_iterator<size_t>(0),
-    thrust::make_counting_iterator<size_t>(num_chunks),
-    [&](auto const chunk) {
-      // Read bloom filter if present
-      if (bloom_filter_offsets[chunk].has_value()) {
-        auto const bloom_filter_offset = bloom_filter_offsets[chunk].value();
-        // If Bloom filter size (header + bitset) is available, just read the entire thing.
-        // Else just read 256 bytes which will contain the entire header and may contain the
-        // entire bitset as well.
-        auto constexpr bloom_filter_header_size_guess = 256;
-        auto const initial_read_size =
-          bloom_filter_sizes[chunk].value_or(bloom_filter_header_size_guess);
-
-        // Read an initial buffer from source
-        auto& source = sources[chunk_source_map[chunk]];
-        auto buffer  = source->host_read(bloom_filter_offset, initial_read_size);
-
-        // Deserialize the Bloom filter header from the buffer.
-        BloomFilterHeader header;
-        CompactProtocolReader cp{buffer->data(), buffer->size()};
-        cp.read(&header);
-
-        // Test if header is valid.
-        auto const is_header_valid =
-          (header.num_bytes % 32) == 0 and
-          header.compression.compression == BloomFilterCompression::Compression::UNCOMPRESSED and
-          header.algorithm.algorithm == BloomFilterAlgorithm::Algorithm::SPLIT_BLOCK and
-          header.hash.hash == BloomFilterHash::Hash::XXHASH;
-
-        // Do not read if the bloom filter is invalid
-        if (not is_header_valid) {
-          CUDF_LOG_WARN("Encountered an invalid bloom filter header. Skipping");
-          return;
-        }
-
-        // Bloom filter header size
-        auto const bloom_filter_header_size = static_cast<int64_t>(cp.bytecount());
-        auto const bitset_size              = header.num_bytes;
-
-        // Check if we already read in the filter bitset in the initial read.
-        if (initial_read_size >= bloom_filter_header_size + bitset_size) {
-          bloom_filter_data[chunk] =
-            rmm::device_buffer(buffer->data() + bloom_filter_header_size, bitset_size, stream);
-
-          // MH: TODO: Temporary test. Remove me!!
-          cudf::string_view literal{"third-037493", 12};
-          std::ignore =
-            check_arbitrary_string_key(bloom_filter_data[chunk], literal, chunk, stream);
-        }
-        // Read the bitset from datasource.
-        else {
-          auto const bitset_offset = bloom_filter_offset + bloom_filter_header_size;
-          // Directly read to device if preferred
-          if (source->is_device_read_preferred(bitset_size)) {
-            bloom_filter_data[chunk] = rmm::device_buffer(bitset_size, stream);
-            auto future_read_size =
-              source->device_read_async(bitset_offset,
-                                        bitset_size,
-                                        static_cast<uint8_t*>(bloom_filter_data[chunk].data()),
-                                        stream);
-
-            read_tasks.emplace_back(std::move(future_read_size));
-          } else {
-            buffer                   = source->host_read(bitset_offset, bitset_size);
-            bloom_filter_data[chunk] = rmm::device_buffer(buffer->data(), buffer->size(), stream);
-          }
-        }
-      }
-    });
-
-  auto sync_fn = [](decltype(read_tasks) read_tasks) {
-    for (auto& task : read_tasks) {
-      task.wait();
+struct bloom_filter_caster {
+  size_t num_row_groups;
+  size_t num_equality_columns;
+
+  // Creates device columns from column statistics (min, max)
+  template <typename T>
+  std::unique_ptr<cudf::column> operator()(cudf::device_span<void* const> buffer_ptrs,
+                                           cudf::device_span<size_t const> buffer_sizes,
+                                           cudf::size_type equality_col_idx,
+                                           cudf::data_type dtype,
+                                           ast::literal* const& literal,
+                                           rmm::cuda_stream_view stream,
+                                           rmm::device_async_resource_ref mr) const
+  {
+    // List, Struct, Dictionary types are not supported
+    if constexpr (cudf::is_compound<T>() && !std::is_same_v<T, string_view>) {
+      CUDF_FAIL("Compound types don't support equality predicate");
+    } else {
+      CUDF_EXPECTS(dtype.id() == literal->get_data_type().id(), "Mismatched data_types");
+
+      using key_type    = T;
+      using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
+      using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
+      using word_type   = typename policy_type::word_type;
+
+      // Filter properties
+      auto constexpr word_size       = sizeof(word_type);
+      auto constexpr words_per_block = policy_type::words_per_block;
+
+      rmm::device_buffer results{num_row_groups, stream, mr};
+
+      // Query literal in bloom filters.
+      thrust::for_each(
+        rmm::exec_policy(stream),
+        thrust::make_counting_iterator<size_t>(0),
+        thrust::make_counting_iterator(num_row_groups),
+        [buffer_ptrs          = buffer_ptrs.data(),
+         buffer_sizes         = buffer_sizes.data(),
+         d_scalar             = literal->get_value(),
+         col_idx              = equality_col_idx,
+         num_equality_columns = num_equality_columns,
+         results = reinterpret_cast<bool*>(results.data())] __device__(auto row_group_idx) {
+          // Filter bitset buffer index
+          auto const filter_idx = col_idx + (num_equality_columns * row_group_idx);
+          // Bitset ptr must be a non-const to be used in bloom_filter_ref.
+          auto bitset_ptr              = reinterpret_cast<word_type*>(buffer_ptrs[filter_idx]);
+          auto const num_filter_blocks = buffer_sizes[filter_idx] / (word_size * words_per_block);
+
+          // Create a bloom filter view
+          cuco::bloom_filter_ref<key_type,
+                                 cuco::extent<std::size_t>,
+                                 cuco::thread_scope_device,
+                                 policy_type>
+            filter{bitset_ptr,
+                   num_filter_blocks,
+                   {},  // scope
+                   {hasher_type{0}}};
+
+          // Query the bloom filter and store results
+          results[row_group_idx] = filter.contains(d_scalar.value<T>());
+        });
+
+      return std::make_unique<cudf::column>(cudf::data_type{cudf::type_id::BOOL8},
+                                            static_cast<cudf::size_type>(num_row_groups),
+                                            std::move(results),
+                                            rmm::device_buffer{},
+                                            0);
     }
-  };
-
-  // MH: Remove me. Bitwise validation for bloom filter
-  validate_filter_bitwise(stream);
-
-  return std::async(std::launch::deferred, sync_fn, std::move(read_tasks));
-}
+  }
+};
 
 /**
- * @brief Collects column indices with an equality predicate in the AST expression.
- * This is used in row group filtering based on bloom filters.
+ * @brief Collects lists of equality predicate  literals in the AST expression, one list per input
+ * table column. This is used in row group filtering based on bloom filters.
  */
-class equality_predicate_converter : public ast::detail::expression_transformer {
+class equality_literals_collector : public ast::detail::expression_transformer {
  public:
-  equality_predicate_converter(ast::expression const& expr, size_type const& num_columns)
+  equality_literals_collector() = default;
+
+  equality_literals_collector(ast::expression const& expr, cudf::size_type num_columns)
     : _num_columns{num_columns}
   {
+    _equality_literals.resize(_num_columns);
     expr.accept(*this);
   }
 
@@ -380,7 +185,13 @@ class equality_predicate_converter : public ast::detail::expression_transformer
       CUDF_EXPECTS(dynamic_cast<ast::literal const*>(&operands[1].get()) != nullptr,
                    "Second operand of binary operation with column reference must be a literal");
       v->accept(*this);
-      if (op == ast_operator::EQUAL) { equality_col_idx.emplace_back(v->get_column_index()); }
+
+      // Push to the corresponding column's literals list if equality predicate seen
+      if (op == ast_operator::EQUAL) {
+        auto const col_idx = v->get_column_index();
+        _equality_literals[col_idx].emplace_back(
+          const_cast<ast::literal*>(dynamic_cast<ast::literal const*>(&operands[1].get())));
+      }
     } else {
       auto new_operands = visit_operands(operands);
       if (cudf::ast::detail::ast_operator_arity(op) == 2) {
@@ -394,16 +205,16 @@ class equality_predicate_converter : public ast::detail::expression_transformer
   }
 
   /**
-   * @brief Returns a list of column indices with an equality predicate in the AST expression.
+   * @brief Vectors of equality literals in the AST expression, one per input table column
    *
-   * @return List of column indices
+   * @return Vectors of equality literals, one per input table column
    */
-  [[nodiscard]] std::vector<cudf::size_type> get_equality_col_idx() const
+  [[nodiscard]] std::vector<std::vector<ast::literal*>> get_equality_literals() const
   {
-    return equality_col_idx;
+    return _equality_literals;
   }
 
- private:
+ protected:
   std::vector<std::reference_wrapper<ast::expression const>> visit_operands(
     cudf::host_span<std::reference_wrapper<ast::expression const> const> operands)
   {
@@ -415,67 +226,218 @@ class equality_predicate_converter : public ast::detail::expression_transformer
     return transformed_operands;
   }
   std::optional<std::reference_wrapper<ast::expression const>> _equality_expr;
-  std::vector<cudf::size_type> equality_col_idx;
-  size_type _num_columns;
+  std::vector<std::vector<ast::literal*>> _equality_literals;
   std::list<ast::column_reference> _col_ref;
   std::list<ast::operation> _operators;
+  size_type _num_columns;
 };
 
-}  // namespace
+/**
+ * @brief Collects column indices with an equality predicate in the AST expression.
+ * This is used in row group filtering based on bloom filters.
+ */
+class equality_predicate_evaluator : public equality_literals_collector {
+ public:
+  equality_predicate_evaluator(ast::expression const& expr,
+                               size_type num_columns,
+                               std::vector<std::vector<ast::literal*>> const& equality_literals)
+  {
+    // Set the num columns and equality literals
+    _num_columns       = num_columns;
+    _equality_literals = std::move(equality_literals);
+
+    // Compute and store columns literals offsets
+    _col_literals_offsets.reserve(_num_columns + 1);
+    _col_literals_offsets.emplace_back(0);
+
+    std::transform(equality_literals.begin(),
+                   equality_literals.end(),
+                   std::back_inserter(_col_literals_offsets),
+                   [&](auto const& col_literal_map) {
+                     return _col_literals_offsets.back() +
+                            static_cast<cudf::size_type>(col_literal_map.size());
+                   });
+
+    // Add this visitor
+    expr.accept(*this);
+  }
 
-std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::apply_bloom_filters(
+  /**
+   * @brief Delete equality literals getter
+   */
+  [[nodiscard]] std::vector<std::vector<ast::literal*>> get_equality_literals() = delete;
+
+  // Bring all overloads of `visit` from equality_predicate_collector into scope
+  using equality_literals_collector::visit;
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::operation const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(ast::operation const& expr) override
+  {
+    using cudf::ast::ast_operator;
+    auto const operands = expr.get_operands();
+    auto const op       = expr.get_operator();
+
+    if (auto* v = dynamic_cast<ast::column_reference const*>(&operands[0].get())) {
+      // First operand should be column reference, second should be literal.
+      CUDF_EXPECTS(cudf::ast::detail::ast_operator_arity(op) == 2,
+                   "Only binary operations are supported on column reference");
+      CUDF_EXPECTS(dynamic_cast<ast::literal const*>(&operands[1].get()) != nullptr,
+                   "Second operand of binary operation with column reference must be a literal");
+      v->accept(*this);
+
+      if (op == ast_operator::EQUAL) {
+        auto const literal_ptr =
+          const_cast<ast::literal*>(dynamic_cast<ast::literal const*>(&operands[1].get()));
+        auto const col_idx            = v->get_column_index();
+        auto const& equality_literals = _equality_literals[col_idx];
+        auto col_ref_offset           = _col_literals_offsets[col_idx];
+        auto const ptr =
+          std::find(equality_literals.cbegin(), equality_literals.cend(), literal_ptr);
+        CUDF_EXPECTS(ptr != equality_literals.end(), "Could not find the literal ptr");
+        col_ref_offset += std::distance(equality_literals.cbegin(), ptr);
+
+        auto const& value = _col_ref.emplace_back(col_ref_offset);
+        auto const& op    = _operators.emplace_back(ast_operator::NOT, value);
+        _operators.emplace_back(ast_operator::NOT, op);
+      }
+    } else {
+      auto new_operands = visit_operands(operands);
+      if (cudf::ast::detail::ast_operator_arity(op) == 2) {
+        _operators.emplace_back(op, new_operands.front(), new_operands.back());
+      } else if (cudf::ast::detail::ast_operator_arity(op) == 1) {
+        _operators.emplace_back(op, new_operands.front());
+      }
+    }
+    _equality_expr = std::reference_wrapper<ast::expression const>(_operators.back());
+    return std::reference_wrapper<ast::expression const>(_operators.back());
+  }
+
+  /**
+   * @brief Returns the AST to apply on bloom filters
+   *
+   * @return AST operation expression
+   */
+  [[nodiscard]] std::reference_wrapper<ast::expression const> get_equality_expr() const
+  {
+    return _equality_expr.value().get();
+  }
+
+ private:
+  std::vector<cudf::size_type> _col_literals_offsets;
+};
+
+/**
+ * @brief Asynchronously reads bloom filters to device.
+ *
+ * @param sources Dataset sources
+ * @param num_chunks Number of total column chunks to read
+ * @param bloom_filter_data Devicebuffers to hold bloom filter bitsets for each chunk
+ * @param bloom_filter_offsets Bloom filter offsets for all chunks
+ * @param bloom_filter_sizes Bloom filter sizes for all chunks
+ * @param chunk_source_map Association between each column chunk and its source
+ * @param stream CUDA stream used for device memory operations and kernel launches
+ *
+ * @return A future object for reading synchronization
+ */
+std::future<void> read_bloom_filters_async(
   host_span<std::unique_ptr<datasource> const> sources,
-  host_span<std::vector<size_type> const> row_group_indices,
-  host_span<data_type const> output_dtypes,
-  host_span<int const> output_column_schemas,
-  std::reference_wrapper<ast::expression const> filter,
-  rmm::cuda_stream_view stream) const
+  size_t num_chunks,
+  cudf::host_span<rmm::device_buffer> bloom_filter_data,
+  cudf::host_span<std::optional<int64_t>> bloom_filter_offsets,
+  cudf::host_span<std::optional<int32_t>> bloom_filter_sizes,
+  std::vector<size_type> const& chunk_source_map,
+  rmm::cuda_stream_view stream)
 {
-  auto const num_cols = output_dtypes.size();
-  CUDF_EXPECTS(output_dtypes.size() == output_column_schemas.size(),
-               "Mismatched size between lists of output column dtypes and output column schema");
-  auto mr = cudf::get_current_device_resource_ref();
-  std::vector<std::unique_ptr<column>> cols;
-  // MH: How do I test for nested or non-comparable columns here?
-  cols.emplace_back(cudf::make_numeric_column(
-    data_type{cudf::type_id::INT32}, num_cols, rmm::device_buffer{}, 0, stream, mr));
+  // Read tasks for bloom filter data
+  std::vector<std::future<size_t>> read_tasks;
 
-  auto mutable_col_idx = cols.back()->mutable_view();
+  // Read bloom filters for all column chunks
+  std::for_each(
+    thrust::make_counting_iterator<size_t>(0),
+    thrust::make_counting_iterator<size_t>(num_chunks),
+    [&](auto const chunk) {
+      // Read bloom filter if present
+      if (bloom_filter_offsets[chunk].has_value()) {
+        auto const bloom_filter_offset = bloom_filter_offsets[chunk].value();
+        // If Bloom filter size (header + bitset) is available, just read the entire thing.
+        // Else just read 256 bytes which will contain the entire header and may contain the
+        // entire bitset as well.
+        auto constexpr bloom_filter_size_guess = 256;
+        auto const initial_read_size =
+          static_cast<size_t>(bloom_filter_sizes[chunk].value_or(bloom_filter_size_guess));
 
-  thrust::sequence(rmm::exec_policy(stream),
-                   mutable_col_idx.begin<size_type>(),
-                   mutable_col_idx.end<size_type>(),
-                   0);
+        // Read an initial buffer from source
+        auto& source = sources[chunk_source_map[chunk]];
+        auto buffer  = source->host_read(bloom_filter_offset, initial_read_size);
 
-  auto equality_table = cudf::table(std::move(cols));
+        // Deserialize the Bloom filter header from the buffer.
+        BloomFilterHeader header;
+        CompactProtocolReader cp{buffer->data(), buffer->size()};
+        cp.read(&header);
 
-  // Converts AST to EqualityAST with reference to min, max columns in above `stats_table`.
-  equality_predicate_converter equality_expr{filter.get(), static_cast<size_type>(num_cols)};
-  auto equality_col_schemas = equality_expr.get_equality_col_idx();
+        // Test if header is valid.
+        auto const is_header_valid =
+          (header.num_bytes % 32) == 0 and
+          header.compression.compression == BloomFilterCompression::Compression::UNCOMPRESSED and
+          header.algorithm.algorithm == BloomFilterAlgorithm::Algorithm::SPLIT_BLOCK and
+          header.hash.hash == BloomFilterHash::Hash::XXHASH;
 
-  // Convert column indices to column schema indices
-  std::for_each(equality_col_schemas.begin(), equality_col_schemas.end(), [&](auto& col_idx) {
-    col_idx = output_column_schemas[col_idx];
-  });
+        // Do not read if the bloom filter is invalid
+        if (not is_header_valid) {
+          CUDF_LOG_WARN("Encountered an invalid bloom filter header. Skipping");
+          return;
+        }
 
-  std::ignore = read_bloom_filters(sources, row_group_indices, equality_col_schemas, stream);
+        // Bloom filter header size
+        auto const bloom_filter_header_size = static_cast<int64_t>(cp.bytecount());
+        size_t const bitset_size            = header.num_bytes;
 
-  return std::nullopt;
+        // Check if we already read in the filter bitset in the initial read.
+        if (initial_read_size >= bloom_filter_header_size + bitset_size) {
+          bloom_filter_data[chunk] =
+            rmm::device_buffer{buffer->data() + bloom_filter_header_size, bitset_size, stream};
+        }
+        // Read the bitset from datasource.
+        else {
+          auto const bitset_offset = bloom_filter_offset + bloom_filter_header_size;
+          // Directly read to device if preferred
+          if (source->is_device_read_preferred(bitset_size)) {
+            bloom_filter_data[chunk] = rmm::device_buffer{bitset_size, stream};
+            auto future_read_size =
+              source->device_read_async(bitset_offset,
+                                        bitset_size,
+                                        static_cast<uint8_t*>(bloom_filter_data[chunk].data()),
+                                        stream);
+
+            read_tasks.emplace_back(std::move(future_read_size));
+          } else {
+            buffer                   = source->host_read(bitset_offset, bitset_size);
+            bloom_filter_data[chunk] = rmm::device_buffer{buffer->data(), buffer->size(), stream};
+          }
+        }
+      }
+    });
+
+  auto sync_fn = [](decltype(read_tasks) read_tasks) {
+    for (auto& task : read_tasks) {
+      task.wait();
+    }
+  };
+
+  return std::async(std::launch::deferred, sync_fn, std::move(read_tasks));
 }
 
+}  // namespace
+
 std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
   host_span<std::unique_ptr<datasource> const> sources,
   host_span<std::vector<size_type> const> row_group_indices,
   host_span<int const> column_schemas,
+  size_type num_row_groups,
   rmm::cuda_stream_view stream) const
 {
-  // Number of total row groups to process.
-  auto const num_row_groups = std::accumulate(
-    row_group_indices.begin(),
-    row_group_indices.end(),
-    size_t{0},
-    [](size_t sum, auto const& per_file_row_groups) { return sum + per_file_row_groups.size(); });
-
   // Descriptors for all the chunks that make up the selected columns
   auto const num_input_columns = column_schemas.size();
   auto const num_chunks        = num_row_groups * num_input_columns;
@@ -518,7 +480,7 @@ std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
   if (std::any_of(bloom_filter_offsets.cbegin(),
                   bloom_filter_offsets.cend(),
                   [](auto const offset) { return offset.has_value(); })) {
-    // Create a vector to store bloom filter data
+    // Vector to hold bloom filter data
     std::vector<rmm::device_buffer> bloom_filter_data(num_chunks);
 
     // Wait on bloom filter read tasks
@@ -530,10 +492,145 @@ std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
                              chunk_source_map,
                              stream)
       .wait();
-    // Return the vector
+
+    // Return bloom filter data
     return bloom_filter_data;
   }
+
+  // Return empty vector
   return {};
 }
 
+std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::apply_bloom_filters(
+  host_span<std::unique_ptr<datasource> const> sources,
+  host_span<std::vector<size_type> const> row_group_indices,
+  host_span<data_type const> output_dtypes,
+  host_span<int const> output_column_schemas,
+  std::reference_wrapper<ast::expression const> filter,
+  rmm::cuda_stream_view stream) const
+{
+  auto const num_cols = static_cast<cudf::size_type>(output_dtypes.size());
+  CUDF_EXPECTS(output_dtypes.size() == output_column_schemas.size(),
+               "Mismatched size between lists of output column dtypes and output column schema");
+  auto mr = cudf::get_current_device_resource_ref();
+
+  // Number of total row groups to process.
+  auto const num_row_groups = std::accumulate(
+    row_group_indices.begin(),
+    row_group_indices.end(),
+    size_t{0},
+    [](size_t sum, auto const& per_file_row_groups) { return sum + per_file_row_groups.size(); });
+
+  // Collect equality literals for each input table column
+  auto const equality_literals =
+    equality_literals_collector{filter.get(), num_cols}.get_equality_literals();
+
+  std::vector<cudf::size_type> equality_col_schemas;
+  // Convert column indices to column schema indices
+  std::for_each(thrust::make_counting_iterator<size_t>(0),
+                thrust::make_counting_iterator(output_column_schemas.size()),
+                [&](auto col_idx) {
+                  // Only for columns that have a non-empty list of literals associated with it
+                  if (equality_literals[col_idx].size()) {
+                    equality_col_schemas.emplace_back(output_column_schemas[col_idx]);
+                  }
+                });
+
+  // Return early if no equality column
+  if (equality_col_schemas.empty()) { return {}; }
+
+  auto bloom_filter_data =
+    read_bloom_filters(sources, row_group_indices, equality_col_schemas, num_row_groups, stream);
+
+  // No bloom filter buffers, return the original row group indices
+  if (not bloom_filter_data.size()) { return {}; }
+
+  // Copy bitset buffer pointers and sizes to device for querying
+  std::vector<void*> h_buffer_ptrs(bloom_filter_data.size());
+  std::vector<size_t> h_buffer_sizes(bloom_filter_data.size());
+  std::for_each(thrust::make_counting_iterator<size_t>(0),
+                thrust::make_counting_iterator<size_t>(bloom_filter_data.size()),
+                [&](auto i) {
+                  auto const& buffer = bloom_filter_data[i];
+                  h_buffer_ptrs[i]   = const_cast<void*>(buffer.data());
+                  h_buffer_sizes[i]  = buffer.size();
+                });
+
+  auto buffer_ptrs  = cudf::detail::make_device_uvector_async(h_buffer_ptrs, stream, mr);
+  auto buffer_sizes = cudf::detail::make_device_uvector_async(h_buffer_sizes, stream, mr);
+
+  // Create a bloom filter table caster
+  bloom_filter_caster bloom_filter_col{num_row_groups, equality_col_schemas.size()};
+
+  // Create a table
+  std::vector<std::unique_ptr<column>> columns;
+
+  size_t idx = 0;
+  for (size_t col_idx = 0; col_idx < output_dtypes.size(); col_idx++) {
+    if (equality_literals[col_idx].empty()) { continue; }
+    auto const& dtype = output_dtypes[col_idx];
+
+    // Only comparable types except fixed point are supported.
+    if (cudf::is_compound(dtype) and dtype.id() != cudf::type_id::STRING) { continue; }
+
+    auto& literals = equality_literals[col_idx];
+    for (ast::literal* const& literal : literals) {
+      columns.push_back(cudf::type_dispatcher<dispatch_storage_type>(
+        dtype, bloom_filter_col, buffer_ptrs, buffer_sizes, idx, dtype, literal, stream, mr));
+    }
+    idx++;
+  }
+
+  auto equality_table = cudf::table(std::move(columns));
+
+  // Make another expression converter but provide the literal map.
+  equality_predicate_evaluator equality_expr{filter.get(), num_cols, equality_literals};
+
+  auto equality_ast  = equality_expr.get_equality_expr();
+  auto predicate_col = cudf::detail::compute_column(equality_table, equality_ast.get(), stream, mr);
+  auto predicate     = predicate_col->view();
+  CUDF_EXPECTS(predicate.type().id() == cudf::type_id::BOOL8,
+               "Filter expression must return a boolean column");
+
+  auto const host_bitmask = [&] {
+    auto const num_bitmasks = num_bitmask_words(predicate.size());
+    if (predicate.nullable()) {
+      return cudf::detail::make_host_vector_sync(
+        device_span<bitmask_type const>(predicate.null_mask(), num_bitmasks), stream);
+    } else {
+      auto bitmask = cudf::detail::make_host_vector<bitmask_type>(num_bitmasks, stream);
+      std::fill(bitmask.begin(), bitmask.end(), ~bitmask_type{0});
+      return bitmask;
+    }
+  }();
+
+  auto validity_it = cudf::detail::make_counting_transform_iterator(
+    0, [bitmask = host_bitmask.data()](auto bit_index) { return bit_is_set(bitmask, bit_index); });
+
+  auto const is_row_group_required = cudf::detail::make_host_vector_sync(
+    device_span<uint8_t const>(predicate.data<uint8_t>(), predicate.size()), stream);
+
+  // Return only filtered row groups based on predicate
+  // if all are required or all are nulls, return.
+  if (predicate.null_count() == predicate.size() or std::all_of(is_row_group_required.cbegin(),
+                                                                is_row_group_required.cend(),
+                                                                [](auto i) { return bool(i); })) {
+    return std::nullopt;
+  }
+  size_type is_required_idx = 0;
+  std::vector<std::vector<size_type>> filtered_row_group_indices;
+  for (auto const& input_row_group_index : row_group_indices) {
+    std::vector<size_type> filtered_row_groups;
+    for (auto const rg_idx : input_row_group_index) {
+      if ((!validity_it[is_required_idx]) || is_row_group_required[is_required_idx]) {
+        filtered_row_groups.push_back(rg_idx);
+      }
+      ++is_required_idx;
+    }
+    filtered_row_group_indices.push_back(std::move(filtered_row_groups));
+  }
+
+  return {filtered_row_group_indices};
+}
+
 }  // namespace cudf::io::parquet::detail
diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp
index eb30cc6955a..2c6eea37c13 100644
--- a/cpp/src/io/parquet/predicate_pushdown.cpp
+++ b/cpp/src/io/parquet/predicate_pushdown.cpp
@@ -475,10 +475,9 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
 
   // Return only filtered row groups based on predicate
   // if all are required or all are nulls, return.
-  if (std::all_of(is_row_group_required.cbegin(),
-                  is_row_group_required.cend(),
-                  [](auto i) { return bool(i); }) or
-      predicate.null_count() == predicate.size()) {
+  if (predicate.null_count() == predicate.size() or std::all_of(is_row_group_required.cbegin(),
+                                                                is_row_group_required.cend(),
+                                                                [](auto i) { return bool(i); })) {
     // Call with input_row_group_indices
     return apply_bloom_filters(
       sources, input_row_group_indices, output_dtypes, output_column_schemas, filter, stream);
@@ -498,8 +497,6 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
   // Call with filtered_row_group_indices
   return apply_bloom_filters(
     sources, filtered_row_group_indices, output_dtypes, output_column_schemas, filter, stream);
-
-  return {std::move(filtered_row_group_indices)};
 }
 
 // convert column named expression to column index reference expression
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index 75edfdb7f7b..4a30b8b4593 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -195,6 +195,26 @@ class aggregate_reader_metadata {
    */
   void column_info_for_row_group(row_group_info& rg_info, size_type chunk_start_row) const;
 
+  /**
+   * @brief Reads bloom filter bitsets for the specified columns from the given lists of row
+   * groups.
+   *
+   * @param sources Dataset sources
+   * @param row_group_indices Lists of row groups to read bloom filters from, one per source
+   * @param[out] bloom_filter_data List of bloom filter data device buffers
+   * @param column_schemas Schema indices of columns whose bloom filters will be read
+   * @param stream CUDA stream used for device memory operations and kernel launches
+   *
+   * @return A flattened list of bloom filter bitset device buffers for each equality column in each
+   * row group
+   */
+  [[nodiscard]] std::vector<rmm::device_buffer> read_bloom_filters(
+    host_span<std::unique_ptr<datasource> const> sources,
+    host_span<std::vector<size_type> const> row_group_indices,
+    host_span<int const> column_schemas,
+    size_type num_row_groups,
+    rmm::cuda_stream_view stream) const;
+
  public:
   aggregate_reader_metadata(host_span<std::unique_ptr<datasource> const> sources,
                             bool use_arrow_schema,
@@ -386,24 +406,6 @@ class aggregate_reader_metadata {
                     std::optional<std::reference_wrapper<ast::expression const>> filter,
                     rmm::cuda_stream_view stream) const;
 
-  /**
-   * @brief Reads bloom filter bitsets for the specified columns from the given lists of row
-   * groups.
-   *
-   * @param sources Dataset sources
-   * @param row_group_indices Lists of row groups to read bloom filters from, one per source
-   * @param column_schemas Schema indices of columns whose bloom filters will be read
-   * @param stream CUDA stream used for device memory operations and kernel launches
-   *
-   * @return A list of bloom filter bitset device buffers flattened over column schemas over lists
-   * of row group indices
-   */
-  std::vector<rmm::device_buffer> read_bloom_filters(
-    host_span<std::unique_ptr<datasource> const> sources,
-    host_span<std::vector<size_type> const> row_group_indices,
-    host_span<int const> column_schemas,
-    rmm::cuda_stream_view stream) const;
-
   /**
    * @brief Filters and reduces down to a selection of columns
    *

From b477d2d025924a213f8d64aa028194808da91fde Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 26 Nov 2024 07:10:58 +0000
Subject: [PATCH 28/85] Significant code refactoring

---
 cpp/src/io/parquet/bloom_filter_reader.cu  | 212 +++++++++------------
 cpp/src/io/parquet/predicate_pushdown.cpp  | 114 ++++++-----
 cpp/src/io/parquet/reader_impl_helpers.hpp |  21 +-
 3 files changed, 181 insertions(+), 166 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index ecf59238a49..5866c42075c 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -53,30 +53,31 @@ namespace {
  *
  */
 struct bloom_filter_caster {
+  cudf::device_span<void* const> buffer_ptrs;
+  cudf::device_span<size_t const> buffer_sizes;
   size_t num_row_groups;
   size_t num_equality_columns;
 
-  // Creates device columns from column statistics (min, max)
+  // Creates device columns from bloom filter membership
   template <typename T>
-  std::unique_ptr<cudf::column> operator()(cudf::device_span<void* const> buffer_ptrs,
-                                           cudf::device_span<size_t const> buffer_sizes,
-                                           cudf::size_type equality_col_idx,
+  std::unique_ptr<cudf::column> operator()(cudf::size_type equality_col_idx,
                                            cudf::data_type dtype,
                                            ast::literal* const& literal,
                                            rmm::cuda_stream_view stream,
                                            rmm::device_async_resource_ref mr) const
   {
     // List, Struct, Dictionary types are not supported
-    if constexpr (cudf::is_compound<T>() && !std::is_same_v<T, string_view>) {
+    if constexpr (cudf::is_compound<T>() and not std::is_same_v<T, string_view>) {
       CUDF_FAIL("Compound types don't support equality predicate");
     } else {
-      CUDF_EXPECTS(dtype.id() == literal->get_data_type().id(), "Mismatched data_types");
-
       using key_type    = T;
       using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
       using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
       using word_type   = typename policy_type::word_type;
 
+      // Check if the literal has the same type as the column
+      CUDF_EXPECTS(dtype.id() == literal->get_data_type().id(), "Mismatched data_types");
+
       // Filter properties
       auto constexpr word_size       = sizeof(word_type);
       auto constexpr words_per_block = policy_type::words_per_block;
@@ -85,7 +86,7 @@ struct bloom_filter_caster {
 
       // Query literal in bloom filters.
       thrust::for_each(
-        rmm::exec_policy(stream),
+        rmm::exec_policy_nosync(stream),
         thrust::make_counting_iterator<size_t>(0),
         thrust::make_counting_iterator(num_row_groups),
         [buffer_ptrs          = buffer_ptrs.data(),
@@ -95,20 +96,19 @@ struct bloom_filter_caster {
          num_equality_columns = num_equality_columns,
          results = reinterpret_cast<bool*>(results.data())] __device__(auto row_group_idx) {
           // Filter bitset buffer index
-          auto const filter_idx = col_idx + (num_equality_columns * row_group_idx);
-          // Bitset ptr must be a non-const to be used in bloom_filter_ref.
-          auto bitset_ptr              = reinterpret_cast<word_type*>(buffer_ptrs[filter_idx]);
+          auto const filter_idx        = col_idx + (num_equality_columns * row_group_idx);
           auto const num_filter_blocks = buffer_sizes[filter_idx] / (word_size * words_per_block);
 
-          // Create a bloom filter view
+          // Create a bloom filter view.
           cuco::bloom_filter_ref<key_type,
                                  cuco::extent<std::size_t>,
-                                 cuco::thread_scope_device,
+                                 cuco::thread_scope_thread,
                                  policy_type>
-            filter{bitset_ptr,
+            filter{reinterpret_cast<word_type*>(buffer_ptrs[filter_idx]),
                    num_filter_blocks,
-                   {},  // scope
-                   {hasher_type{0}}};
+                   {},   // thread scope since the same literal is being search across different
+                         // bitsets per thread
+                   {}};  // Arrow policy with default xxhash_64, seed = 0 for Arrow compatiblity
 
           // Query the bloom filter and store results
           results[row_group_idx] = filter.contains(d_scalar.value<T>());
@@ -131,10 +131,10 @@ class equality_literals_collector : public ast::detail::expression_transformer {
  public:
   equality_literals_collector() = default;
 
-  equality_literals_collector(ast::expression const& expr, cudf::size_type num_columns)
-    : _num_columns{num_columns}
+  equality_literals_collector(ast::expression const& expr, cudf::size_type num_input_columns)
+    : _num_input_columns{num_input_columns}
   {
-    _equality_literals.resize(_num_columns);
+    _equality_literals.resize(_num_input_columns);
     expr.accept(*this);
   }
 
@@ -154,7 +154,7 @@ class equality_literals_collector : public ast::detail::expression_transformer {
   {
     CUDF_EXPECTS(expr.get_table_source() == ast::table_reference::LEFT,
                  "Equality AST supports only left table");
-    CUDF_EXPECTS(expr.get_column_index() < _num_columns,
+    CUDF_EXPECTS(expr.get_column_index() < _num_input_columns,
                  "Column index cannot be more than number of columns in the table");
     _equality_expr = std::reference_wrapper<ast::expression const>(expr);
     return expr;
@@ -229,25 +229,26 @@ class equality_literals_collector : public ast::detail::expression_transformer {
   std::vector<std::vector<ast::literal*>> _equality_literals;
   std::list<ast::column_reference> _col_ref;
   std::list<ast::operation> _operators;
-  size_type _num_columns;
+  size_type _num_input_columns;
 };
 
 /**
- * @brief Collects column indices with an equality predicate in the AST expression.
- * This is used in row group filtering based on bloom filters.
+ * @brief Converts AST expression to bloom filter membership (BloomfilterAST) expression .
+ * This is used in row group filtering based on equality predicate.
  */
-class equality_predicate_evaluator : public equality_literals_collector {
+class bloom_filter_expression_converter : public equality_literals_collector {
  public:
-  equality_predicate_evaluator(ast::expression const& expr,
-                               size_type num_columns,
-                               std::vector<std::vector<ast::literal*>> const& equality_literals)
+  bloom_filter_expression_converter(
+    ast::expression const& expr,
+    size_type num_input_columns,
+    std::vector<std::vector<ast::literal*>> const& equality_literals)
   {
     // Set the num columns and equality literals
-    _num_columns       = num_columns;
+    _num_input_columns = num_input_columns;
     _equality_literals = std::move(equality_literals);
 
     // Compute and store columns literals offsets
-    _col_literals_offsets.reserve(_num_columns + 1);
+    _col_literals_offsets.reserve(_num_input_columns + 1);
     _col_literals_offsets.emplace_back(0);
 
     std::transform(equality_literals.begin(),
@@ -263,7 +264,7 @@ class equality_predicate_evaluator : public equality_literals_collector {
   }
 
   /**
-   * @brief Delete equality literals getter
+   * @brief Delete equality literals getter as no longer needed
    */
   [[nodiscard]] std::vector<std::vector<ast::literal*>> get_equality_literals() = delete;
 
@@ -329,7 +330,7 @@ class equality_predicate_evaluator : public equality_literals_collector {
 };
 
 /**
- * @brief Asynchronously reads bloom filters to device.
+ * @brief Asynchronously reads bloom filters data to device.
  *
  * @param sources Dataset sources
  * @param num_chunks Number of total column chunks to read
@@ -341,7 +342,7 @@ class equality_predicate_evaluator : public equality_literals_collector {
  *
  * @return A future object for reading synchronization
  */
-std::future<void> read_bloom_filters_async(
+std::future<void> read_bloom_filter_data_async(
   host_span<std::unique_ptr<datasource> const> sources,
   size_t num_chunks,
   cudf::host_span<rmm::device_buffer> bloom_filter_data,
@@ -483,14 +484,14 @@ std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
     // Vector to hold bloom filter data
     std::vector<rmm::device_buffer> bloom_filter_data(num_chunks);
 
-    // Wait on bloom filter read tasks
-    read_bloom_filters_async(sources,
-                             num_chunks,
-                             bloom_filter_data,
-                             bloom_filter_offsets,
-                             bloom_filter_sizes,
-                             chunk_source_map,
-                             stream)
+    // Wait on bloom filter data read tasks
+    read_bloom_filter_data_async(sources,
+                                 num_chunks,
+                                 bloom_filter_data,
+                                 bloom_filter_offsets,
+                                 bloom_filter_sizes,
+                                 chunk_source_map,
+                                 stream)
       .wait();
 
     // Return bloom filter data
@@ -509,12 +510,12 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
   std::reference_wrapper<ast::expression const> filter,
   rmm::cuda_stream_view stream) const
 {
-  auto const num_cols = static_cast<cudf::size_type>(output_dtypes.size());
-  CUDF_EXPECTS(output_dtypes.size() == output_column_schemas.size(),
-               "Mismatched size between lists of output column dtypes and output column schema");
+  // Number of input table columns
+  auto const num_input_columns = static_cast<cudf::size_type>(output_dtypes.size());
+
   auto mr = cudf::get_current_device_resource_ref();
 
-  // Number of total row groups to process.
+  // Total number of row groups to process.
   auto const num_row_groups = std::accumulate(
     row_group_indices.begin(),
     row_group_indices.end(),
@@ -523,10 +524,10 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
 
   // Collect equality literals for each input table column
   auto const equality_literals =
-    equality_literals_collector{filter.get(), num_cols}.get_equality_literals();
+    equality_literals_collector{filter.get(), num_input_columns}.get_equality_literals();
 
+  // Collect schema indices of columns with equality predicate(s)
   std::vector<cudf::size_type> equality_col_schemas;
-  // Convert column indices to column schema indices
   std::for_each(thrust::make_counting_iterator<size_t>(0),
                 thrust::make_counting_iterator(output_column_schemas.size()),
                 [&](auto col_idx) {
@@ -536,101 +537,72 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
                   }
                 });
 
-  // Return early if no equality column
-  if (equality_col_schemas.empty()) { return {}; }
+  // Return early if no column with equality predicate(s)
+  if (equality_col_schemas.empty()) { return std::nullopt; }
 
+  // Read a vector of bloom filter bitset device buffers for all column with equality predicate(s)
+  // across all row groups
   auto bloom_filter_data =
     read_bloom_filters(sources, row_group_indices, equality_col_schemas, num_row_groups, stream);
 
   // No bloom filter buffers, return the original row group indices
-  if (not bloom_filter_data.size()) { return {}; }
+  if (bloom_filter_data.empty()) { return std::nullopt; }
 
-  // Copy bitset buffer pointers and sizes to device for querying
+  // Copy bloom filter bitset buffer pointers and sizes to device
   std::vector<void*> h_buffer_ptrs(bloom_filter_data.size());
   std::vector<size_t> h_buffer_sizes(bloom_filter_data.size());
   std::for_each(thrust::make_counting_iterator<size_t>(0),
                 thrust::make_counting_iterator<size_t>(bloom_filter_data.size()),
                 [&](auto i) {
                   auto const& buffer = bloom_filter_data[i];
-                  h_buffer_ptrs[i]   = const_cast<void*>(buffer.data());
-                  h_buffer_sizes[i]  = buffer.size();
+                  // Bitset ptr must be non-const to be used in cuco::bloom_filter.
+                  h_buffer_ptrs[i]  = const_cast<void*>(buffer.data());
+                  h_buffer_sizes[i] = buffer.size();
                 });
-
   auto buffer_ptrs  = cudf::detail::make_device_uvector_async(h_buffer_ptrs, stream, mr);
   auto buffer_sizes = cudf::detail::make_device_uvector_async(h_buffer_sizes, stream, mr);
 
-  // Create a bloom filter table caster
-  bloom_filter_caster bloom_filter_col{num_row_groups, equality_col_schemas.size()};
+  // Create a bloom filter query table caster.
+  bloom_filter_caster bloom_filter_col{
+    buffer_ptrs, buffer_sizes, num_row_groups, equality_col_schemas.size()};
 
-  // Create a table
+  // Converts bloom filter membership for equality predicate columns to a table
+  // containing a column for each `col[i] == literal` predicate to be evaluated.
+  // The table contains #sources * #column_chunks_per_src rows.
   std::vector<std::unique_ptr<column>> columns;
+  size_t equality_col_idx = 0;
+  std::for_each(thrust::make_counting_iterator<size_t>(0),
+                thrust::make_counting_iterator(output_dtypes.size()),
+                [&](auto input_col_idx) {
+                  auto const& dtype = output_dtypes[input_col_idx];
 
-  size_t idx = 0;
-  for (size_t col_idx = 0; col_idx < output_dtypes.size(); col_idx++) {
-    if (equality_literals[col_idx].empty()) { continue; }
-    auto const& dtype = output_dtypes[col_idx];
-
-    // Only comparable types except fixed point are supported.
-    if (cudf::is_compound(dtype) and dtype.id() != cudf::type_id::STRING) { continue; }
-
-    auto& literals = equality_literals[col_idx];
-    for (ast::literal* const& literal : literals) {
-      columns.push_back(cudf::type_dispatcher<dispatch_storage_type>(
-        dtype, bloom_filter_col, buffer_ptrs, buffer_sizes, idx, dtype, literal, stream, mr));
-    }
-    idx++;
-  }
-
-  auto equality_table = cudf::table(std::move(columns));
-
-  // Make another expression converter but provide the literal map.
-  equality_predicate_evaluator equality_expr{filter.get(), num_cols, equality_literals};
-
-  auto equality_ast  = equality_expr.get_equality_expr();
-  auto predicate_col = cudf::detail::compute_column(equality_table, equality_ast.get(), stream, mr);
-  auto predicate     = predicate_col->view();
-  CUDF_EXPECTS(predicate.type().id() == cudf::type_id::BOOL8,
-               "Filter expression must return a boolean column");
-
-  auto const host_bitmask = [&] {
-    auto const num_bitmasks = num_bitmask_words(predicate.size());
-    if (predicate.nullable()) {
-      return cudf::detail::make_host_vector_sync(
-        device_span<bitmask_type const>(predicate.null_mask(), num_bitmasks), stream);
-    } else {
-      auto bitmask = cudf::detail::make_host_vector<bitmask_type>(num_bitmasks, stream);
-      std::fill(bitmask.begin(), bitmask.end(), ~bitmask_type{0});
-      return bitmask;
-    }
-  }();
-
-  auto validity_it = cudf::detail::make_counting_transform_iterator(
-    0, [bitmask = host_bitmask.data()](auto bit_index) { return bit_is_set(bitmask, bit_index); });
-
-  auto const is_row_group_required = cudf::detail::make_host_vector_sync(
-    device_span<uint8_t const>(predicate.data<uint8_t>(), predicate.size()), stream);
+                  // Skip if no equality literals for this column
+                  if (equality_literals[input_col_idx].empty()) { return; }
 
-  // Return only filtered row groups based on predicate
-  // if all are required or all are nulls, return.
-  if (predicate.null_count() == predicate.size() or std::all_of(is_row_group_required.cbegin(),
-                                                                is_row_group_required.cend(),
-                                                                [](auto i) { return bool(i); })) {
-    return std::nullopt;
-  }
-  size_type is_required_idx = 0;
-  std::vector<std::vector<size_type>> filtered_row_group_indices;
-  for (auto const& input_row_group_index : row_group_indices) {
-    std::vector<size_type> filtered_row_groups;
-    for (auto const rg_idx : input_row_group_index) {
-      if ((!validity_it[is_required_idx]) || is_row_group_required[is_required_idx]) {
-        filtered_row_groups.push_back(rg_idx);
-      }
-      ++is_required_idx;
-    }
-    filtered_row_group_indices.push_back(std::move(filtered_row_groups));
-  }
+                  // Skip if non-comparable (compound) type except string
+                  if (cudf::is_compound(dtype) and dtype.id() != cudf::type_id::STRING) { return; }
 
-  return {filtered_row_group_indices};
+                  // Add a column for all literals associated with an equality column
+                  for (ast::literal* const& literal : equality_literals[input_col_idx]) {
+                    columns.emplace_back(cudf::type_dispatcher<dispatch_storage_type>(
+                      dtype, bloom_filter_col, equality_col_idx, dtype, literal, stream, mr));
+                  }
+                  equality_col_idx++;
+                });
+  auto bloom_filter_membership_table = cudf::table(std::move(columns));
+
+  // Convert AST to BloomfilterAST expression with reference to bloom filter membership
+  // in above `bloom_filter_membership_table`
+  bloom_filter_expression_converter equality_expr{
+    filter.get(), num_input_columns, equality_literals};
+
+  // Filter bloom filter membership table with the BloomfilterAST expression and collect filtered
+  // row group indices
+  return collect_filtered_row_group_indices(bloom_filter_membership_table,
+                                            equality_expr.get_equality_expr(),
+                                            row_group_indices,
+                                            stream,
+                                            mr);
 }
 
 }  // namespace cudf::io::parquet::detail
diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp
index 2c6eea37c13..760b2d18eec 100644
--- a/cpp/src/io/parquet/predicate_pushdown.cpp
+++ b/cpp/src/io/parquet/predicate_pushdown.cpp
@@ -400,7 +400,6 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
 {
   auto mr = cudf::get_current_device_resource_ref();
   // Create row group indices.
-  std::vector<std::vector<size_type>> filtered_row_group_indices;
   std::vector<std::vector<size_type>> all_row_group_indices;
   host_span<std::vector<size_type> const> input_row_group_indices;
   if (row_group_indices.empty()) {
@@ -449,54 +448,24 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
 
   // Converts AST to StatsAST with reference to min, max columns in above `stats_table`.
   stats_expression_converter stats_expr{filter.get(), static_cast<size_type>(output_dtypes.size())};
-  auto stats_ast     = stats_expr.get_stats_expr();
-  auto predicate_col = cudf::detail::compute_column(stats_table, stats_ast.get(), stream, mr);
-  auto predicate     = predicate_col->view();
-  CUDF_EXPECTS(predicate.type().id() == cudf::type_id::BOOL8,
-               "Filter expression must return a boolean column");
 
-  auto const host_bitmask = [&] {
-    auto const num_bitmasks = num_bitmask_words(predicate.size());
-    if (predicate.nullable()) {
-      return cudf::detail::make_host_vector_sync(
-        device_span<bitmask_type const>(predicate.null_mask(), num_bitmasks), stream);
-    } else {
-      auto bitmask = cudf::detail::make_host_vector<bitmask_type>(num_bitmasks, stream);
-      std::fill(bitmask.begin(), bitmask.end(), ~bitmask_type{0});
-      return bitmask;
-    }
-  }();
+  // Filter stats table with StatsAST expression and collect filtered row group indices
+  auto filtered_row_group_indices = collect_filtered_row_group_indices(
+    stats_table, stats_expr.get_stats_expr(), row_group_indices, stream, mr);
 
-  auto validity_it = cudf::detail::make_counting_transform_iterator(
-    0, [bitmask = host_bitmask.data()](auto bit_index) { return bit_is_set(bitmask, bit_index); });
+  // Span on row groups to apply bloom filtering on.
+  auto const bloom_filter_input_row_groups =
+    filtered_row_group_indices.has_value()
+      ? host_span<std::vector<size_type> const>(filtered_row_group_indices.value())
+      : input_row_group_indices;
 
-  auto const is_row_group_required = cudf::detail::make_host_vector_sync(
-    device_span<uint8_t const>(predicate.data<uint8_t>(), predicate.size()), stream);
+  // Apply bloom filtering on the bloom filter input row groups
+  auto const bloom_filtered_row_groups = apply_bloom_filters(
+    sources, bloom_filter_input_row_groups, output_dtypes, output_column_schemas, filter, stream);
 
-  // Return only filtered row groups based on predicate
-  // if all are required or all are nulls, return.
-  if (predicate.null_count() == predicate.size() or std::all_of(is_row_group_required.cbegin(),
-                                                                is_row_group_required.cend(),
-                                                                [](auto i) { return bool(i); })) {
-    // Call with input_row_group_indices
-    return apply_bloom_filters(
-      sources, input_row_group_indices, output_dtypes, output_column_schemas, filter, stream);
-  }
-  size_type is_required_idx = 0;
-  for (auto const& input_row_group_index : input_row_group_indices) {
-    std::vector<size_type> filtered_row_groups;
-    for (auto const rg_idx : input_row_group_index) {
-      if ((!validity_it[is_required_idx]) || is_row_group_required[is_required_idx]) {
-        filtered_row_groups.push_back(rg_idx);
-      }
-      ++is_required_idx;
-    }
-    filtered_row_group_indices.push_back(std::move(filtered_row_groups));
-  }
-
-  // Call with filtered_row_group_indices
-  return apply_bloom_filters(
-    sources, filtered_row_group_indices, output_dtypes, output_column_schemas, filter, stream);
+  // Return bloom filtered row group indices iff collected
+  return bloom_filtered_row_groups.has_value() ? bloom_filtered_row_groups
+                                               : filtered_row_group_indices;
 }
 
 // convert column named expression to column index reference expression
@@ -647,4 +616,59 @@ class names_from_expression : public ast::detail::expression_transformer {
   return names_from_expression(expr, skip_names).to_vector();
 }
 
+std::optional<std::vector<std::vector<size_type>>> collect_filtered_row_group_indices(
+  cudf::table_view table,
+  std::reference_wrapper<ast::expression const> expr_ast,
+  host_span<std::vector<size_type> const> input_row_group_indices,
+  rmm::cuda_stream_view stream,
+  rmm::device_async_resource_ref mr)
+{
+  // Filter the input table using equality predicate evaluator
+  auto predicate_col = cudf::detail::compute_column(table, expr_ast.get(), stream, mr);
+  auto predicate     = predicate_col->view();
+  CUDF_EXPECTS(predicate.type().id() == cudf::type_id::BOOL8,
+               "Filter expression must return a boolean column");
+
+  auto const host_bitmask = [&] {
+    auto const num_bitmasks = num_bitmask_words(predicate.size());
+    if (predicate.nullable()) {
+      return cudf::detail::make_host_vector_sync(
+        device_span<bitmask_type const>(predicate.null_mask(), num_bitmasks), stream);
+    } else {
+      auto bitmask = cudf::detail::make_host_vector<bitmask_type>(num_bitmasks, stream);
+      std::fill(bitmask.begin(), bitmask.end(), ~bitmask_type{0});
+      return bitmask;
+    }
+  }();
+
+  auto validity_it = cudf::detail::make_counting_transform_iterator(
+    0, [bitmask = host_bitmask.data()](auto bit_index) { return bit_is_set(bitmask, bit_index); });
+
+  auto const is_row_group_required = cudf::detail::make_host_vector_sync(
+    device_span<uint8_t const>(predicate.data<uint8_t>(), predicate.size()), stream);
+
+  // Return only filtered row groups based on predicate, or all are required, or all are nulls.
+  if (predicate.null_count() == predicate.size() or std::all_of(is_row_group_required.cbegin(),
+                                                                is_row_group_required.cend(),
+                                                                [](auto i) { return bool(i); })) {
+    return std::nullopt;
+  }
+
+  // Collect indices of the filtered row groups
+  size_type is_required_idx = 0;
+  std::vector<std::vector<size_type>> filtered_row_group_indices;
+  for (auto const& input_row_group_index : input_row_group_indices) {
+    std::vector<size_type> filtered_row_groups;
+    for (auto const rg_idx : input_row_group_index) {
+      if ((!validity_it[is_required_idx]) || is_row_group_required[is_required_idx]) {
+        filtered_row_groups.push_back(rg_idx);
+      }
+      ++is_required_idx;
+    }
+    filtered_row_group_indices.push_back(std::move(filtered_row_groups));
+  }
+
+  return {filtered_row_group_indices};
+}
+
 }  // namespace cudf::io::parquet::detail
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index 4a30b8b4593..c2ce897ce9b 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -366,7 +366,7 @@ class aggregate_reader_metadata {
    * @param row_group_indices Lists of row groups to read, one per source
    * @param output_dtypes Datatypes of of output columns
    * @param output_column_schemas schema indices of output columns
-   * @param filter AST expression to filter row groups based on Column chunk statistics
+   * @param filter AST expression to filter row groups based on bloom filter membership
    * @param stream CUDA stream used for device memory operations and kernel launches
    *
    * @return Filtered row group indices, if any is filtered.
@@ -489,4 +489,23 @@ class named_to_reference_converter : public ast::detail::expression_transformer
   std::optional<std::reference_wrapper<ast::expression const>> expr,
   std::vector<std::string> const& skip_names);
 
+/**
+ * @brief Filter table using the provided (StatsAST or BloomfilterAST) expression and
+ * collect filtered row group indices
+ *
+ * @param table Table of stats or bloom filter membership columns
+ * @param expr_ast StatsAST or BloomfilterAST expression to evaluate.
+ * @param input_row_group_indices Lists of input row groups to read, one per source
+ * @param stream CUDA stream used for device memory operations and kernel launches
+ * @param mr Device memory resource used to be used in cudf::compute_column
+ *
+ * @return Collected filtered row group indices, if any.
+ */
+[[nodiscard]] std::optional<std::vector<std::vector<size_type>>> collect_filtered_row_group_indices(
+  cudf::table_view ast_table,
+  std::reference_wrapper<ast::expression const> expr_ast,
+  host_span<std::vector<size_type> const> input_row_group_indices,
+  rmm::cuda_stream_view stream,
+  rmm::device_async_resource_ref mr);
+
 }  // namespace cudf::io::parquet::detail

From f9f17469269268c887a2e806ff5af60a870c23cb Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 26 Nov 2024 07:12:24 +0000
Subject: [PATCH 29/85] minor style fix

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 2 +-
 cpp/tests/hashing/bloom_filter_test.cu    | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 5866c42075c..ef59d313505 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -108,7 +108,7 @@ struct bloom_filter_caster {
                    num_filter_blocks,
                    {},   // thread scope since the same literal is being search across different
                          // bitsets per thread
-                   {}};  // Arrow policy with default xxhash_64, seed = 0 for Arrow compatiblity
+                   {}};  // Arrow policy with default xxhash_64, seed = 0 for Arrow compatibility
 
           // Query the bloom filter and store results
           results[row_group_idx] = filter.contains(d_scalar.value<T>());
diff --git a/cpp/tests/hashing/bloom_filter_test.cu b/cpp/tests/hashing/bloom_filter_test.cu
index e0e98dd84a0..c064b3cf0ff 100644
--- a/cpp/tests/hashing/bloom_filter_test.cu
+++ b/cpp/tests/hashing/bloom_filter_test.cu
@@ -92,4 +92,4 @@ TYPED_TEST(BloomFilter_TestTyped, TestStrings)
   // Check
   CUDF_TEST_EXPECT_COLUMNS_EQUAL(output, d_expected);
 }
-*/
\ No newline at end of file
+*/

From bad484f7155223b7002958747cc42222f93e9b8e Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 26 Nov 2024 07:41:21 +0000
Subject: [PATCH 30/85] refactoring

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 37 +++++++++++------------
 1 file changed, 17 insertions(+), 20 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index ef59d313505..a753ed76ba4 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -17,7 +17,6 @@
 #include "arrow_filter_policy.cuh"
 #include "compact_protocol_reader.hpp"
 #include "io/parquet/parquet.hpp"
-#include "io/parquet/parquet_gpu.hpp"
 #include "reader_impl_helpers.hpp"
 
 #include <cudf/ast/detail/expression_transformer.hpp>
@@ -28,6 +27,8 @@
 #include <cudf/detail/transform.hpp>
 #include <cudf/detail/utilities/logger.hpp>
 #include <cudf/hashing/detail/xxhash_64.cuh>
+#include <cudf/utilities/span.hpp>
+#include <cudf/utilities/traits.hpp>
 
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/device_buffer.hpp>
@@ -36,20 +37,16 @@
 
 #include <cuco/bloom_filter_ref.cuh>
 #include <thrust/iterator/counting_iterator.h>
-#include <thrust/logical.h>
-#include <thrust/sequence.h>
 
 #include <future>
-#include <iterator>
 #include <numeric>
 #include <optional>
-#include <random>
 
 namespace cudf::io::parquet::detail {
 namespace {
 
 /**
- * @brief Converts bloom filter query results for column chunks to a device column.
+ * @brief Converts bloom filter membership results for column chunks to a device column.
  *
  */
 struct bloom_filter_caster {
@@ -124,7 +121,7 @@ struct bloom_filter_caster {
 };
 
 /**
- * @brief Collects lists of equality predicate  literals in the AST expression, one list per input
+ * @brief Collects lists of equality predicate literals in the AST expression, one list per input
  * table column. This is used in row group filtering based on bloom filters.
  */
 class equality_literals_collector : public ast::detail::expression_transformer {
@@ -143,7 +140,7 @@ class equality_literals_collector : public ast::detail::expression_transformer {
    */
   std::reference_wrapper<ast::expression const> visit(ast::literal const& expr) override
   {
-    _equality_expr = std::reference_wrapper<ast::expression const>(expr);
+    _bloom_filter_expr = std::reference_wrapper<ast::expression const>(expr);
     return expr;
   }
 
@@ -153,10 +150,10 @@ class equality_literals_collector : public ast::detail::expression_transformer {
   std::reference_wrapper<ast::expression const> visit(ast::column_reference const& expr) override
   {
     CUDF_EXPECTS(expr.get_table_source() == ast::table_reference::LEFT,
-                 "Equality AST supports only left table");
+                 "BloomfilterAST supports only left table");
     CUDF_EXPECTS(expr.get_column_index() < _num_input_columns,
                  "Column index cannot be more than number of columns in the table");
-    _equality_expr = std::reference_wrapper<ast::expression const>(expr);
+    _bloom_filter_expr = std::reference_wrapper<ast::expression const>(expr);
     return expr;
   }
 
@@ -166,7 +163,7 @@ class equality_literals_collector : public ast::detail::expression_transformer {
   std::reference_wrapper<ast::expression const> visit(
     ast::column_name_reference const& expr) override
   {
-    CUDF_FAIL("Column name reference is not supported in equality AST");
+    CUDF_FAIL("Column name reference is not supported in BloomfilterAST");
   }
 
   /**
@@ -186,7 +183,7 @@ class equality_literals_collector : public ast::detail::expression_transformer {
                    "Second operand of binary operation with column reference must be a literal");
       v->accept(*this);
 
-      // Push to the corresponding column's literals list if equality predicate seen
+      // Push to the corresponding column's literals list iff equality predicate is seen
       if (op == ast_operator::EQUAL) {
         auto const col_idx = v->get_column_index();
         _equality_literals[col_idx].emplace_back(
@@ -200,7 +197,7 @@ class equality_literals_collector : public ast::detail::expression_transformer {
         _operators.emplace_back(op, new_operands.front());
       }
     }
-    _equality_expr = std::reference_wrapper<ast::expression const>(_operators.back());
+    _bloom_filter_expr = std::reference_wrapper<ast::expression const>(_operators.back());
     return std::reference_wrapper<ast::expression const>(_operators.back());
   }
 
@@ -225,7 +222,7 @@ class equality_literals_collector : public ast::detail::expression_transformer {
     }
     return transformed_operands;
   }
-  std::optional<std::reference_wrapper<ast::expression const>> _equality_expr;
+  std::optional<std::reference_wrapper<ast::expression const>> _bloom_filter_expr;
   std::vector<std::vector<ast::literal*>> _equality_literals;
   std::list<ast::column_reference> _col_ref;
   std::list<ast::operation> _operators;
@@ -311,18 +308,18 @@ class bloom_filter_expression_converter : public equality_literals_collector {
         _operators.emplace_back(op, new_operands.front());
       }
     }
-    _equality_expr = std::reference_wrapper<ast::expression const>(_operators.back());
+    _bloom_filter_expr = std::reference_wrapper<ast::expression const>(_operators.back());
     return std::reference_wrapper<ast::expression const>(_operators.back());
   }
 
   /**
-   * @brief Returns the AST to apply on bloom filters
+   * @brief Returns the AST to apply on bloom filters mmebership.
    *
    * @return AST operation expression
    */
-  [[nodiscard]] std::reference_wrapper<ast::expression const> get_equality_expr() const
+  [[nodiscard]] std::reference_wrapper<ast::expression const> get_bloom_filter_expr() const
   {
-    return _equality_expr.value().get();
+    return _bloom_filter_expr.value().get();
   }
 
  private:
@@ -593,13 +590,13 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
 
   // Convert AST to BloomfilterAST expression with reference to bloom filter membership
   // in above `bloom_filter_membership_table`
-  bloom_filter_expression_converter equality_expr{
+  bloom_filter_expression_converter bloom_filter_expr{
     filter.get(), num_input_columns, equality_literals};
 
   // Filter bloom filter membership table with the BloomfilterAST expression and collect filtered
   // row group indices
   return collect_filtered_row_group_indices(bloom_filter_membership_table,
-                                            equality_expr.get_equality_expr(),
+                                            bloom_filter_expr.get_bloom_filter_expr(),
                                             row_group_indices,
                                             stream,
                                             mr);

From ce09d43ac8dbded82c7d3370f95f67204eaba4fa Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 26 Nov 2024 07:47:06 +0000
Subject: [PATCH 31/85] Minor refactoring

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 115 +++++++++++-----------
 1 file changed, 59 insertions(+), 56 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index a753ed76ba4..91eeba69ca0 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -356,68 +356,71 @@ std::future<void> read_bloom_filter_data_async(
     thrust::make_counting_iterator<size_t>(0),
     thrust::make_counting_iterator<size_t>(num_chunks),
     [&](auto const chunk) {
-      // Read bloom filter if present
-      if (bloom_filter_offsets[chunk].has_value()) {
-        auto const bloom_filter_offset = bloom_filter_offsets[chunk].value();
-        // If Bloom filter size (header + bitset) is available, just read the entire thing.
-        // Else just read 256 bytes which will contain the entire header and may contain the
-        // entire bitset as well.
-        auto constexpr bloom_filter_size_guess = 256;
-        auto const initial_read_size =
-          static_cast<size_t>(bloom_filter_sizes[chunk].value_or(bloom_filter_size_guess));
-
-        // Read an initial buffer from source
-        auto& source = sources[chunk_source_map[chunk]];
-        auto buffer  = source->host_read(bloom_filter_offset, initial_read_size);
-
-        // Deserialize the Bloom filter header from the buffer.
-        BloomFilterHeader header;
-        CompactProtocolReader cp{buffer->data(), buffer->size()};
-        cp.read(&header);
-
-        // Test if header is valid.
-        auto const is_header_valid =
-          (header.num_bytes % 32) == 0 and
-          header.compression.compression == BloomFilterCompression::Compression::UNCOMPRESSED and
-          header.algorithm.algorithm == BloomFilterAlgorithm::Algorithm::SPLIT_BLOCK and
-          header.hash.hash == BloomFilterHash::Hash::XXHASH;
-
-        // Do not read if the bloom filter is invalid
-        if (not is_header_valid) {
-          CUDF_LOG_WARN("Encountered an invalid bloom filter header. Skipping");
-          return;
-        }
+      // Skip if bloom filter offset absent
+      if (not bloom_filter_offsets[chunk].has_value()) { return; }
+
+      // Read bloom filter iff present
+      auto const bloom_filter_offset = bloom_filter_offsets[chunk].value();
+
+      // If Bloom filter size (header + bitset) is available, just read the entire thing.
+      // Else just read 256 bytes which will contain the entire header and may contain the
+      // entire bitset as well.
+      auto constexpr bloom_filter_size_guess = 256;
+      auto const initial_read_size =
+        static_cast<size_t>(bloom_filter_sizes[chunk].value_or(bloom_filter_size_guess));
+
+      // Read an initial buffer from source
+      auto& source = sources[chunk_source_map[chunk]];
+      auto buffer  = source->host_read(bloom_filter_offset, initial_read_size);
+
+      // Deserialize the Bloom filter header from the buffer.
+      BloomFilterHeader header;
+      CompactProtocolReader cp{buffer->data(), buffer->size()};
+      cp.read(&header);
+
+      // Check if the bloom filter header is valid.
+      auto const is_header_valid =
+        (header.num_bytes % 32) == 0 and
+        header.compression.compression == BloomFilterCompression::Compression::UNCOMPRESSED and
+        header.algorithm.algorithm == BloomFilterAlgorithm::Algorithm::SPLIT_BLOCK and
+        header.hash.hash == BloomFilterHash::Hash::XXHASH;
+
+      // Do not read if the bloom filter is invalid
+      if (not is_header_valid) {
+        CUDF_LOG_WARN("Encountered an invalid bloom filter header. Skipping");
+        return;
+      }
 
-        // Bloom filter header size
-        auto const bloom_filter_header_size = static_cast<int64_t>(cp.bytecount());
-        size_t const bitset_size            = header.num_bytes;
+      // Bloom filter header size
+      auto const bloom_filter_header_size = static_cast<int64_t>(cp.bytecount());
+      size_t const bitset_size            = static_cast<size_t>(header.num_bytes);
 
-        // Check if we already read in the filter bitset in the initial read.
-        if (initial_read_size >= bloom_filter_header_size + bitset_size) {
-          bloom_filter_data[chunk] =
-            rmm::device_buffer{buffer->data() + bloom_filter_header_size, bitset_size, stream};
-        }
-        // Read the bitset from datasource.
-        else {
-          auto const bitset_offset = bloom_filter_offset + bloom_filter_header_size;
-          // Directly read to device if preferred
-          if (source->is_device_read_preferred(bitset_size)) {
-            bloom_filter_data[chunk] = rmm::device_buffer{bitset_size, stream};
-            auto future_read_size =
-              source->device_read_async(bitset_offset,
-                                        bitset_size,
-                                        static_cast<uint8_t*>(bloom_filter_data[chunk].data()),
-                                        stream);
-
-            read_tasks.emplace_back(std::move(future_read_size));
-          } else {
-            buffer                   = source->host_read(bitset_offset, bitset_size);
-            bloom_filter_data[chunk] = rmm::device_buffer{buffer->data(), buffer->size(), stream};
-          }
+      // Check if we already read in the filter bitset in the initial read.
+      if (initial_read_size >= bloom_filter_header_size + bitset_size) {
+        bloom_filter_data[chunk] =
+          rmm::device_buffer{buffer->data() + bloom_filter_header_size, bitset_size, stream};
+      }
+      // Read the bitset from datasource.
+      else {
+        auto const bitset_offset = bloom_filter_offset + bloom_filter_header_size;
+        // Directly read to device if preferred
+        if (source->is_device_read_preferred(bitset_size)) {
+          bloom_filter_data[chunk] = rmm::device_buffer{bitset_size, stream};
+          auto future_read_size =
+            source->device_read_async(bitset_offset,
+                                      bitset_size,
+                                      static_cast<uint8_t*>(bloom_filter_data[chunk].data()),
+                                      stream);
+
+          read_tasks.emplace_back(std::move(future_read_size));
+        } else {
+          buffer                   = source->host_read(bitset_offset, bitset_size);
+          bloom_filter_data[chunk] = rmm::device_buffer{buffer->data(), buffer->size(), stream};
         }
       }
     });
 
+  // Read task sync function
   auto sync_fn = [](decltype(read_tasks) read_tasks) {
     for (auto& task : read_tasks) {
       task.wait();

From dddee6ca406f0d4e9e4c0597c329b3b8f899dcf7 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 26 Nov 2024 08:16:25 +0000
Subject: [PATCH 32/85] Minor improvements

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 21 +++++++++++----------
 1 file changed, 11 insertions(+), 10 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 91eeba69ca0..1d9ef7a6742 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -206,7 +206,7 @@ class equality_literals_collector : public ast::detail::expression_transformer {
    *
    * @return Vectors of equality literals, one per input table column
    */
-  [[nodiscard]] std::vector<std::vector<ast::literal*>> get_equality_literals() const
+  [[nodiscard]] std::vector<std::vector<ast::literal*>> const get_equality_literals() const
   {
     return _equality_literals;
   }
@@ -286,17 +286,18 @@ class bloom_filter_expression_converter : public equality_literals_collector {
       v->accept(*this);
 
       if (op == ast_operator::EQUAL) {
-        auto const literal_ptr =
-          const_cast<ast::literal*>(dynamic_cast<ast::literal const*>(&operands[1].get()));
+        // Search the literal in this input column's equality literals list and add to the offset.
         auto const col_idx            = v->get_column_index();
         auto const& equality_literals = _equality_literals[col_idx];
-        auto col_ref_offset           = _col_literals_offsets[col_idx];
-        auto const ptr =
-          std::find(equality_literals.cbegin(), equality_literals.cend(), literal_ptr);
-        CUDF_EXPECTS(ptr != equality_literals.end(), "Could not find the literal ptr");
-        col_ref_offset += std::distance(equality_literals.cbegin(), ptr);
-
-        auto const& value = _col_ref.emplace_back(col_ref_offset);
+        auto col_literal_offset       = _col_literals_offsets[col_idx];
+        auto const literal_iter       = std::find(equality_literals.cbegin(),
+                                            equality_literals.cend(),
+                                            dynamic_cast<ast::literal const*>(&operands[1].get()));
+        CUDF_EXPECTS(literal_iter != equality_literals.end(), "Could not find the literal ptr");
+        col_literal_offset += std::distance(equality_literals.cbegin(), literal_iter);
+
+        // Evaluate boolean is_true(value) expression as NOT(NOT(value))
+        auto const& value = _col_ref.emplace_back(col_literal_offset);
         auto const& op    = _operators.emplace_back(ast_operator::NOT, value);
         _operators.emplace_back(ast_operator::NOT, op);
       }

From 0cfeb80a8a413d22c947b9dfa1782c38ac1dca52 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 26 Nov 2024 21:10:48 +0000
Subject: [PATCH 33/85] Add gtest

---
 cpp/src/io/parquet/predicate_pushdown.cpp  |  9 +++---
 cpp/src/io/parquet/reader_impl_helpers.hpp |  4 +--
 cpp/tests/hashing/bloom_filter_test.cu     | 36 ++++++++++------------
 3 files changed, 23 insertions(+), 26 deletions(-)

diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp
index 760b2d18eec..ba6f690abd3 100644
--- a/cpp/src/io/parquet/predicate_pushdown.cpp
+++ b/cpp/src/io/parquet/predicate_pushdown.cpp
@@ -618,13 +618,13 @@ class names_from_expression : public ast::detail::expression_transformer {
 
 std::optional<std::vector<std::vector<size_type>>> collect_filtered_row_group_indices(
   cudf::table_view table,
-  std::reference_wrapper<ast::expression const> expr_ast,
+  std::reference_wrapper<ast::expression const> ast_expr,
   host_span<std::vector<size_type> const> input_row_group_indices,
   rmm::cuda_stream_view stream,
   rmm::device_async_resource_ref mr)
 {
-  // Filter the input table using equality predicate evaluator
-  auto predicate_col = cudf::detail::compute_column(table, expr_ast.get(), stream, mr);
+  // Filter the input table using AST expression
+  auto predicate_col = cudf::detail::compute_column(table, ast_expr.get(), stream, mr);
   auto predicate     = predicate_col->view();
   CUDF_EXPECTS(predicate.type().id() == cudf::type_id::BOOL8,
                "Filter expression must return a boolean column");
@@ -644,10 +644,11 @@ std::optional<std::vector<std::vector<size_type>>> collect_filtered_row_group_in
   auto validity_it = cudf::detail::make_counting_transform_iterator(
     0, [bitmask = host_bitmask.data()](auto bit_index) { return bit_is_set(bitmask, bit_index); });
 
+  // Return only filtered row groups based on predicate
   auto const is_row_group_required = cudf::detail::make_host_vector_sync(
     device_span<uint8_t const>(predicate.data<uint8_t>(), predicate.size()), stream);
 
-  // Return only filtered row groups based on predicate, or all are required, or all are nulls.
+  // Return if all are required, or all are nulls.
   if (predicate.null_count() == predicate.size() or std::all_of(is_row_group_required.cbegin(),
                                                                 is_row_group_required.cend(),
                                                                 [](auto i) { return bool(i); })) {
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index c2ce897ce9b..6cb99a54720 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -494,7 +494,7 @@ class named_to_reference_converter : public ast::detail::expression_transformer
  * collect filtered row group indices
  *
  * @param table Table of stats or bloom filter membership columns
- * @param expr_ast StatsAST or BloomfilterAST expression to evaluate.
+ * @param ast_expr StatsAST or BloomfilterAST expression to filter with.
  * @param input_row_group_indices Lists of input row groups to read, one per source
  * @param stream CUDA stream used for device memory operations and kernel launches
  * @param mr Device memory resource used to be used in cudf::compute_column
@@ -503,7 +503,7 @@ class named_to_reference_converter : public ast::detail::expression_transformer
  */
 [[nodiscard]] std::optional<std::vector<std::vector<size_type>>> collect_filtered_row_group_indices(
   cudf::table_view ast_table,
-  std::reference_wrapper<ast::expression const> expr_ast,
+  std::reference_wrapper<ast::expression const> ast_expr,
   host_span<std::vector<size_type> const> input_row_group_indices,
   rmm::cuda_stream_view stream,
   rmm::device_async_resource_ref mr);
diff --git a/cpp/tests/hashing/bloom_filter_test.cu b/cpp/tests/hashing/bloom_filter_test.cu
index c064b3cf0ff..9ca76c085b6 100644
--- a/cpp/tests/hashing/bloom_filter_test.cu
+++ b/cpp/tests/hashing/bloom_filter_test.cu
@@ -14,13 +14,16 @@
  * limitations under the License.
  */
 
-/*
+// Remove this after cuco bump
+#include "src/io/parquet/arrow_filter_policy.cuh"
+
 #include <cudf_test/base_fixture.hpp>
 #include <cudf_test/column_utilities.hpp>
 #include <cudf_test/column_wrapper.hpp>
 #include <cudf_test/iterator_utilities.hpp>
 
 #include <cudf/detail/cuco_helpers.hpp>
+#include <cudf/hashing.hpp>
 #include <cudf/hashing/detail/xxhash_64.cuh>
 #include <cudf/utilities/default_stream.hpp>
 
@@ -28,19 +31,16 @@
 
 using StringType = cudf::string_view;
 
-template <typename T>
-class BloomFilter_TestTyped : public cudf::test::BaseFixture {};
-
-TYPED_TEST_SUITE(BloomFilter_TestTyped, StringType);
+class BloomFilterTest : public cudf::test::BaseFixture {};
 
-TYPED_TEST(BloomFilter_TestTyped, TestStrings)
+TEST_F(BloomFilterTest, TestStrings)
 {
   using key_type    = StringType;
   using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
   using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
+  using word_type   = policy_type::word_type;
 
   std::size_t constexpr num_filter_blocks = 4;
-  std::size_t constexpr num_keys          = 50;
   auto stream                             = cudf::get_default_stream();
 
   // strings data
@@ -64,12 +64,11 @@ TYPED_TEST(BloomFilter_TestTyped, TestStrings)
                      cudf::detail::cuco_allocator<char>>
     filter{num_filter_blocks,
            cuco::thread_scope_device,
-           {hasher_type{0}},
+           {hasher_type{cudf::DEFAULT_HASH_SEED}},
            cudf::detail::cuco_allocator<char>{rmm::mr::polymorphic_allocator<char>{}, stream},
            stream};
 
   // Add strings to the bloom filter
-  auto col = table.column(0);
   filter.add(d_column->begin<key_type>(), d_column->end<key_type>(), stream);
 
   // Number of words in the filter
@@ -78,18 +77,15 @@ TYPED_TEST(BloomFilter_TestTyped, TestStrings)
   auto const output = cudf::column_view{
     cudf::data_type{cudf::type_id::UINT32}, num_words, filter.data(), nullptr, 0, 0, {}};
 
-  using word_type = filter_type::word_type;
-
   // Expected filter bitset words computed using Arrow implementation here:
   // https://godbolt.org/z/oKfqcPWbY
   auto expected = cudf::test::fixed_width_column_wrapper<word_type>(
-    {4194306,    4194305,  2359296,   1073774592, 524544,     1024,       268443648,  8519680,
-     2147500040, 8421380,  269500416, 4202624,    8396802,    100665344,  2147747840, 5243136,
-     131146,     655364,   285345792, 134222340,  545390596,  2281717768, 51201,      41943553,
-     1619656708, 67441680, 8462730,   361220,     2216738864, 587333888,  4219272,    873463873});
-  auto d_expected = cudf::column_device_view::create(expected);
-
-  // Check
-  CUDF_TEST_EXPECT_COLUMNS_EQUAL(output, d_expected);
+    {4194306U,    4194305U,    2359296U,  1073774592U, 524544U,    1024U,      268443648U,
+     8519680U,    2147500040U, 8421380U,  269500416U,  4202624U,   8396802U,   100665344U,
+     2147747840U, 5243136U,    131146U,   655364U,     285345792U, 134222340U, 545390596U,
+     2281717768U, 51201U,      41943553U, 1619656708U, 67441680U,  8462730U,   361220U,
+     2216738864U, 587333888U,  4219272U,  873463873U});
+
+  // Check the bitset for equality
+  CUDF_TEST_EXPECT_COLUMNS_EQUAL(output, expected);
 }
-*/

From 91375850432305ef41fed391d8d99699aa47d731 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 26 Nov 2024 23:20:32 +0000
Subject: [PATCH 34/85] Improvements

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 40 +++++++++++++++++------
 1 file changed, 30 insertions(+), 10 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 1d9ef7a6742..d413a7b6b99 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -26,6 +26,7 @@
 #include <cudf/detail/iterator.cuh>
 #include <cudf/detail/transform.hpp>
 #include <cudf/detail/utilities/logger.hpp>
+#include <cudf/hashing.hpp>
 #include <cudf/hashing/detail/xxhash_64.cuh>
 #include <cudf/utilities/span.hpp>
 #include <cudf/utilities/traits.hpp>
@@ -93,7 +94,15 @@ struct bloom_filter_caster {
          num_equality_columns = num_equality_columns,
          results = reinterpret_cast<bool*>(results.data())] __device__(auto row_group_idx) {
           // Filter bitset buffer index
-          auto const filter_idx        = col_idx + (num_equality_columns * row_group_idx);
+          auto const filter_idx = col_idx + (num_equality_columns * row_group_idx);
+
+          // If no bloom filter, then fill in `true` as membership cannot be determined
+          if (buffer_sizes[filter_idx] == 0) {
+            results[row_group_idx] = true;
+            return;
+          }
+
+          // Number of filter blocks
           auto const num_filter_blocks = buffer_sizes[filter_idx] / (word_size * words_per_block);
 
           // Create a bloom filter view.
@@ -101,11 +110,13 @@ struct bloom_filter_caster {
                                  cuco::extent<std::size_t>,
                                  cuco::thread_scope_thread,
                                  policy_type>
-            filter{reinterpret_cast<word_type*>(buffer_ptrs[filter_idx]),
-                   num_filter_blocks,
-                   {},   // thread scope since the same literal is being search across different
-                         // bitsets per thread
-                   {}};  // Arrow policy with default xxhash_64, seed = 0 for Arrow compatibility
+            filter{
+              reinterpret_cast<word_type*>(buffer_ptrs[filter_idx]),
+              num_filter_blocks,
+              cuco::thread_scope_thread,  // Thread scope since the same literal is being search
+                                          // across (read-only) different bitsets per thread
+              {hasher_type{cudf::DEFAULT_HASH_SEED}}};  // Arrow policy with cudf::xxhash_64 seeded
+                                                        // with 0 for Arrow compatibility
 
           // Query the bloom filter and store results
           results[row_group_idx] = filter.contains(d_scalar.value<T>());
@@ -357,9 +368,11 @@ std::future<void> read_bloom_filter_data_async(
     thrust::make_counting_iterator<size_t>(0),
     thrust::make_counting_iterator<size_t>(num_chunks),
     [&](auto const chunk) {
-      // Skip if bloom filter offset absent
-      if (not bloom_filter_offsets[chunk].has_value()) { return; }
-
+      // If bloom filter offset absent, fill in an empty buffer and skip ahead
+      if (not bloom_filter_offsets[chunk].has_value()) {
+        bloom_filter_data[chunk] = {};
+        return;
+      }
       // Read bloom filter iff present
       auto const bloom_filter_offset = bloom_filter_offsets[chunk].value();
 
@@ -379,15 +392,22 @@ std::future<void> read_bloom_filter_data_async(
       CompactProtocolReader cp{buffer->data(), buffer->size()};
       cp.read(&header);
 
+      // Get the hardcoded words_per_block value from `cuco::arrow_filter_policy` using a temporary
+      // `std::byte` key type.
+      auto constexpr words_per_block =
+        cuco::arrow_filter_policy<std::byte,
+                                  cudf::hashing::detail::XXHash_64<std::byte>>::words_per_block;
+
       // Check if the bloom filter header is valid.
       auto const is_header_valid =
-        (header.num_bytes % 32) == 0 and
+        (header.num_bytes % words_per_block) == 0 and
         header.compression.compression == BloomFilterCompression::Compression::UNCOMPRESSED and
         header.algorithm.algorithm == BloomFilterAlgorithm::Algorithm::SPLIT_BLOCK and
         header.hash.hash == BloomFilterHash::Hash::XXHASH;
 
       // Do not read if the bloom filter is invalid
       if (not is_header_valid) {
+        bloom_filter_data[chunk] = {};
         CUDF_LOG_WARN("Encountered an invalid bloom filter header. Skipping");
         return;
       }

From 77152b43cb10f45e57de79f1201c25b92e69a296 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 27 Nov 2024 00:46:31 +0000
Subject: [PATCH 35/85] Support int96 in bloom filter

---
 cpp/src/io/parquet/bloom_filter_reader.cu  | 183 +++++++++++++--------
 cpp/src/io/parquet/reader_impl_helpers.hpp |  14 +-
 2 files changed, 131 insertions(+), 66 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index d413a7b6b99..640ae0d3d22 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -26,7 +26,6 @@
 #include <cudf/detail/iterator.cuh>
 #include <cudf/detail/transform.hpp>
 #include <cudf/detail/utilities/logger.hpp>
-#include <cudf/hashing.hpp>
 #include <cudf/hashing/detail/xxhash_64.cuh>
 #include <cudf/utilities/span.hpp>
 #include <cudf/utilities/traits.hpp>
@@ -53,9 +52,85 @@ namespace {
 struct bloom_filter_caster {
   cudf::device_span<void* const> buffer_ptrs;
   cudf::device_span<size_t const> buffer_sizes;
+  host_span<Type const> parquet_types;
   size_t num_row_groups;
   size_t num_equality_columns;
 
+  template <typename T, bool timestamp_is_int96 = false>
+  std::unique_ptr<cudf::column> compute_column(cudf::size_type equality_col_idx,
+                                               cudf::data_type dtype,
+                                               ast::literal* const& literal,
+                                               rmm::cuda_stream_view stream,
+                                               rmm::device_async_resource_ref mr) const
+  {
+    using key_type    = T;
+    using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
+    using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
+    using word_type   = typename policy_type::word_type;
+
+    // Check if the literal has the same type as the column
+    CUDF_EXPECTS(dtype.id() == literal->get_data_type().id(), "Mismatched data_types");
+
+    // Filter properties
+    auto constexpr word_size       = sizeof(word_type);
+    auto constexpr words_per_block = policy_type::words_per_block;
+
+    rmm::device_buffer results{num_row_groups, stream, mr};
+
+    // Query literal in bloom filters.
+    thrust::for_each(
+      rmm::exec_policy_nosync(stream),
+      thrust::make_counting_iterator<size_t>(0),
+      thrust::make_counting_iterator(num_row_groups),
+      [buffer_ptrs          = buffer_ptrs.data(),
+       buffer_sizes         = buffer_sizes.data(),
+       d_scalar             = literal->get_value(),
+       col_idx              = equality_col_idx,
+       num_equality_columns = num_equality_columns,
+       results = reinterpret_cast<bool*>(results.data())] __device__(auto row_group_idx) {
+        // Filter bitset buffer index
+        auto const filter_idx = col_idx + (num_equality_columns * row_group_idx);
+
+        // If no bloom filter, then fill in `true` as membership cannot be determined
+        if (buffer_sizes[filter_idx] == 0) {
+          results[row_group_idx] = true;
+          return;
+        }
+
+        // Number of filter blocks
+        auto const num_filter_blocks = buffer_sizes[filter_idx] / (word_size * words_per_block);
+
+        // Create a bloom filter view.
+        cuco::bloom_filter_ref<key_type,
+                               cuco::extent<std::size_t>,
+                               cuco::thread_scope_thread,
+                               policy_type>
+          filter{reinterpret_cast<word_type*>(buffer_ptrs[filter_idx]),
+                 num_filter_blocks,
+                 cuco::thread_scope_thread,  // Thread scope since the same literal is being search
+                                             // across (read-only) different bitsets per thread
+                 {hasher_type{0}}};          // Arrow policy with cudf::xxhash_64
+                                             // seeded with 0 for Arrow compatibility
+
+        // If int96_timestamp type, convert literal to string_view and query bloom
+        // filter
+        if constexpr (cuda::std::is_same_v<T, cudf::string_view> and timestamp_is_int96) {
+          auto const int128_key = static_cast<__int128_t>(d_scalar.value<int64_t>());
+          cudf::string_view probe_key{reinterpret_cast<char const*>(&int128_key), 12};
+          results[row_group_idx] = filter.contains(probe_key);
+        } else {
+          // Query the bloom filter and store results
+          results[row_group_idx] = filter.contains(d_scalar.value<T>());
+        }
+      });
+
+    return std::make_unique<cudf::column>(cudf::data_type{cudf::type_id::BOOL8},
+                                          static_cast<cudf::size_type>(num_row_groups),
+                                          std::move(results),
+                                          rmm::device_buffer{},
+                                          0);
+  }
+
   // Creates device columns from bloom filter membership
   template <typename T>
   std::unique_ptr<cudf::column> operator()(cudf::size_type equality_col_idx,
@@ -67,66 +142,16 @@ struct bloom_filter_caster {
     // List, Struct, Dictionary types are not supported
     if constexpr (cudf::is_compound<T>() and not std::is_same_v<T, string_view>) {
       CUDF_FAIL("Compound types don't support equality predicate");
+    } else if constexpr (cudf::is_timestamp<T>()) {
+      if (parquet_types[equality_col_idx] == Type::INT96) {
+        // For INT96 timestamps, convert to cudf::string_view of 12 bytes
+        return compute_column<cudf::string_view, true>(
+          equality_col_idx, dtype, literal, stream, mr);
+      } else {
+        return compute_column<T>(equality_col_idx, dtype, literal, stream, mr);
+      }
     } else {
-      using key_type    = T;
-      using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
-      using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
-      using word_type   = typename policy_type::word_type;
-
-      // Check if the literal has the same type as the column
-      CUDF_EXPECTS(dtype.id() == literal->get_data_type().id(), "Mismatched data_types");
-
-      // Filter properties
-      auto constexpr word_size       = sizeof(word_type);
-      auto constexpr words_per_block = policy_type::words_per_block;
-
-      rmm::device_buffer results{num_row_groups, stream, mr};
-
-      // Query literal in bloom filters.
-      thrust::for_each(
-        rmm::exec_policy_nosync(stream),
-        thrust::make_counting_iterator<size_t>(0),
-        thrust::make_counting_iterator(num_row_groups),
-        [buffer_ptrs          = buffer_ptrs.data(),
-         buffer_sizes         = buffer_sizes.data(),
-         d_scalar             = literal->get_value(),
-         col_idx              = equality_col_idx,
-         num_equality_columns = num_equality_columns,
-         results = reinterpret_cast<bool*>(results.data())] __device__(auto row_group_idx) {
-          // Filter bitset buffer index
-          auto const filter_idx = col_idx + (num_equality_columns * row_group_idx);
-
-          // If no bloom filter, then fill in `true` as membership cannot be determined
-          if (buffer_sizes[filter_idx] == 0) {
-            results[row_group_idx] = true;
-            return;
-          }
-
-          // Number of filter blocks
-          auto const num_filter_blocks = buffer_sizes[filter_idx] / (word_size * words_per_block);
-
-          // Create a bloom filter view.
-          cuco::bloom_filter_ref<key_type,
-                                 cuco::extent<std::size_t>,
-                                 cuco::thread_scope_thread,
-                                 policy_type>
-            filter{
-              reinterpret_cast<word_type*>(buffer_ptrs[filter_idx]),
-              num_filter_blocks,
-              cuco::thread_scope_thread,  // Thread scope since the same literal is being search
-                                          // across (read-only) different bitsets per thread
-              {hasher_type{cudf::DEFAULT_HASH_SEED}}};  // Arrow policy with cudf::xxhash_64 seeded
-                                                        // with 0 for Arrow compatibility
-
-          // Query the bloom filter and store results
-          results[row_group_idx] = filter.contains(d_scalar.value<T>());
-        });
-
-      return std::make_unique<cudf::column>(cudf::data_type{cudf::type_id::BOOL8},
-                                            static_cast<cudf::size_type>(num_row_groups),
-                                            std::move(results),
-                                            rmm::device_buffer{},
-                                            0);
+      return compute_column<T>(equality_col_idx, dtype, literal, stream, mr);
     }
   }
 };
@@ -523,6 +548,31 @@ std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
   return {};
 }
 
+std::vector<Type> aggregate_reader_metadata::get_parquet_types(
+  host_span<std::vector<size_type> const> row_group_indices,
+  host_span<int const> column_schemas) const
+{
+  std::vector<Type> parquet_types(column_schemas.size());
+  // Find a source with at least one row group
+  auto const src_iter = std::find_if(row_group_indices.begin(),
+                                     row_group_indices.end(),
+                                     [](auto const& rg) { return rg.size() > 0; });
+  CUDF_EXPECTS(src_iter != row_group_indices.end(), "");
+
+  // Source index
+  auto const src_index = std::distance(row_group_indices.begin(), src_iter);
+  std::transform(column_schemas.begin(),
+                 column_schemas.end(),
+                 parquet_types.begin(),
+                 [&](auto const schema_idx) {
+                   // Use the first row group in this source
+                   auto constexpr row_group_index = 0;
+                   return get_column_metadata(row_group_index, src_index, schema_idx).type;
+                 });
+
+  return parquet_types;
+}
+
 std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::apply_bloom_filters(
   host_span<std::unique_ptr<datasource> const> sources,
   host_span<std::vector<size_type> const> row_group_indices,
@@ -561,14 +611,17 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
   // Return early if no column with equality predicate(s)
   if (equality_col_schemas.empty()) { return std::nullopt; }
 
-  // Read a vector of bloom filter bitset device buffers for all column with equality predicate(s)
-  // across all row groups
+  // Read a vector of bloom filter bitset device buffers for all column with equality
+  // predicate(s) across all row groups
   auto bloom_filter_data =
     read_bloom_filters(sources, row_group_indices, equality_col_schemas, num_row_groups, stream);
 
   // No bloom filter buffers, return the original row group indices
   if (bloom_filter_data.empty()) { return std::nullopt; }
 
+  // Get parquet types for the predicate columns
+  auto const parquet_types = get_parquet_types(row_group_indices, equality_col_schemas);
+
   // Copy bloom filter bitset buffer pointers and sizes to device
   std::vector<void*> h_buffer_ptrs(bloom_filter_data.size());
   std::vector<size_t> h_buffer_sizes(bloom_filter_data.size());
@@ -585,7 +638,7 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
 
   // Create a bloom filter query table caster.
   bloom_filter_caster bloom_filter_col{
-    buffer_ptrs, buffer_sizes, num_row_groups, equality_col_schemas.size()};
+    buffer_ptrs, buffer_sizes, parquet_types, num_row_groups, equality_col_schemas.size()};
 
   // Converts bloom filter membership for equality predicate columns to a table
   // containing a column for each `col[i] == literal` predicate to be evaluated.
@@ -617,8 +670,8 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
   bloom_filter_expression_converter bloom_filter_expr{
     filter.get(), num_input_columns, equality_literals};
 
-  // Filter bloom filter membership table with the BloomfilterAST expression and collect filtered
-  // row group indices
+  // Filter bloom filter membership table with the BloomfilterAST expression and collect
+  // filtered row group indices
   return collect_filtered_row_group_indices(bloom_filter_membership_table,
                                             bloom_filter_expr.get_bloom_filter_expr(),
                                             row_group_indices,
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index 6cb99a54720..c280341ead7 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -205,7 +205,7 @@ class aggregate_reader_metadata {
    * @param column_schemas Schema indices of columns whose bloom filters will be read
    * @param stream CUDA stream used for device memory operations and kernel launches
    *
-   * @return A flattened list of bloom filter bitset device buffers for each equality column in each
+   * @return A flattened list of bloom filter bitset device buffers for each predicate column across
    * row group
    */
   [[nodiscard]] std::vector<rmm::device_buffer> read_bloom_filters(
@@ -215,6 +215,18 @@ class aggregate_reader_metadata {
     size_type num_row_groups,
     rmm::cuda_stream_view stream) const;
 
+  /**
+   * @brief Collects Parquet types for the columns with the specified schema indices
+   *
+   * @param row_group_indices Lists of row groups, once per source
+   * @param column_schemas Schema indices of columns whose types will be collected
+   *
+   * @return A list of parquet types for the columns matching the procided schema indices
+   */
+  [[nodiscard]] std::vector<Type> get_parquet_types(
+    host_span<std::vector<size_type> const> row_group_indices,
+    host_span<int const> column_schemas) const;
+
  public:
   aggregate_reader_metadata(host_span<std::unique_ptr<datasource> const> sources,
                             bool use_arrow_schema,

From 398429124e8989803cae6ccff2bc8a6f559b2f11 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 27 Nov 2024 00:59:42 +0000
Subject: [PATCH 36/85] Cleanup

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 32 +++++++++++------------
 1 file changed, 16 insertions(+), 16 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 640ae0d3d22..df6d48618b0 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -46,7 +46,7 @@ namespace cudf::io::parquet::detail {
 namespace {
 
 /**
- * @brief Converts bloom filter membership results for column chunks to a device column.
+ * @brief Converts bloom filter membership results (for each column chunk) to a device column.
  *
  */
 struct bloom_filter_caster {
@@ -57,11 +57,11 @@ struct bloom_filter_caster {
   size_t num_equality_columns;
 
   template <typename T, bool timestamp_is_int96 = false>
-  std::unique_ptr<cudf::column> compute_column(cudf::size_type equality_col_idx,
-                                               cudf::data_type dtype,
-                                               ast::literal* const& literal,
-                                               rmm::cuda_stream_view stream,
-                                               rmm::device_async_resource_ref mr) const
+  std::unique_ptr<cudf::column> query_bloom_filter(cudf::size_type equality_col_idx,
+                                                   cudf::data_type dtype,
+                                                   ast::literal* const& literal,
+                                                   rmm::cuda_stream_view stream,
+                                                   rmm::device_async_resource_ref mr) const
   {
     using key_type    = T;
     using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
@@ -69,7 +69,8 @@ struct bloom_filter_caster {
     using word_type   = typename policy_type::word_type;
 
     // Check if the literal has the same type as the column
-    CUDF_EXPECTS(dtype.id() == literal->get_data_type().id(), "Mismatched data_types");
+    CUDF_EXPECTS(dtype.id() == literal->get_data_type().id(),
+                 "Mismatched data types between the column and the literal");
 
     // Filter properties
     auto constexpr word_size       = sizeof(word_type);
@@ -77,7 +78,7 @@ struct bloom_filter_caster {
 
     rmm::device_buffer results{num_row_groups, stream, mr};
 
-    // Query literal in bloom filters.
+    // Query literal in bloom filters from each column chunk (row group).
     thrust::for_each(
       rmm::exec_policy_nosync(stream),
       thrust::make_counting_iterator<size_t>(0),
@@ -107,10 +108,9 @@ struct bloom_filter_caster {
                                policy_type>
           filter{reinterpret_cast<word_type*>(buffer_ptrs[filter_idx]),
                  num_filter_blocks,
-                 cuco::thread_scope_thread,  // Thread scope since the same literal is being search
-                                             // across (read-only) different bitsets per thread
-                 {hasher_type{0}}};          // Arrow policy with cudf::xxhash_64
-                                             // seeded with 0 for Arrow compatibility
+                 {},  // Thread scope as the same literal is being searched across different bitsets
+                      // per thread
+                 {}};  // Arrow policy with cudf::XXHash_64 seeded with 0 for Arrow compatibility
 
         // If int96_timestamp type, convert literal to string_view and query bloom
         // filter
@@ -144,14 +144,14 @@ struct bloom_filter_caster {
       CUDF_FAIL("Compound types don't support equality predicate");
     } else if constexpr (cudf::is_timestamp<T>()) {
       if (parquet_types[equality_col_idx] == Type::INT96) {
-        // For INT96 timestamps, convert to cudf::string_view of 12 bytes
-        return compute_column<cudf::string_view, true>(
+        // For INT96 timestamps, use cudf::string_view type and set timestamp_is_int96
+        return query_bloom_filter<cudf::string_view, true>(
           equality_col_idx, dtype, literal, stream, mr);
       } else {
-        return compute_column<T>(equality_col_idx, dtype, literal, stream, mr);
+        return query_bloom_filter<T>(equality_col_idx, dtype, literal, stream, mr);
       }
     } else {
-      return compute_column<T>(equality_col_idx, dtype, literal, stream, mr);
+      return query_bloom_filter<T>(equality_col_idx, dtype, literal, stream, mr);
     }
   }
 };

From 9a39aa4be813370275ee320c21fd68116ed22b56 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 27 Nov 2024 01:25:34 +0000
Subject: [PATCH 37/85] Minor improvements

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index df6d48618b0..14fda5911e8 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -271,10 +271,9 @@ class equality_literals_collector : public ast::detail::expression_transformer {
  */
 class bloom_filter_expression_converter : public equality_literals_collector {
  public:
-  bloom_filter_expression_converter(
-    ast::expression const& expr,
-    size_type num_input_columns,
-    std::vector<std::vector<ast::literal*>> const& equality_literals)
+  bloom_filter_expression_converter(ast::expression const& expr,
+                                    size_type num_input_columns,
+                                    std::vector<std::vector<ast::literal*>>& equality_literals)
   {
     // Set the num columns and equality literals
     _num_input_columns = num_input_columns;
@@ -594,7 +593,7 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
     [](size_t sum, auto const& per_file_row_groups) { return sum + per_file_row_groups.size(); });
 
   // Collect equality literals for each input table column
-  auto const equality_literals =
+  auto equality_literals =
     equality_literals_collector{filter.get(), num_input_columns}.get_equality_literals();
 
   // Collect schema indices of columns with equality predicate(s)
@@ -613,7 +612,7 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
 
   // Read a vector of bloom filter bitset device buffers for all column with equality
   // predicate(s) across all row groups
-  auto bloom_filter_data =
+  auto const bloom_filter_data =
     read_bloom_filters(sources, row_group_indices, equality_col_schemas, num_row_groups, stream);
 
   // No bloom filter buffers, return the original row group indices

From 1def80102140e02d325a09b03eb866b1bfb9e0b5 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 27 Nov 2024 01:34:14 +0000
Subject: [PATCH 38/85] Fix minor bug

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 14fda5911e8..f044b49e55f 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -271,13 +271,14 @@ class equality_literals_collector : public ast::detail::expression_transformer {
  */
 class bloom_filter_expression_converter : public equality_literals_collector {
  public:
-  bloom_filter_expression_converter(ast::expression const& expr,
-                                    size_type num_input_columns,
-                                    std::vector<std::vector<ast::literal*>>& equality_literals)
+  bloom_filter_expression_converter(
+    ast::expression const& expr,
+    size_type num_input_columns,
+    std::vector<std::vector<ast::literal*>> const& equality_literals)
   {
-    // Set the num columns and equality literals
+    // Set the num columns and copy equality literals
     _num_input_columns = num_input_columns;
-    _equality_literals = std::move(equality_literals);
+    _equality_literals = equality_literals;
 
     // Compute and store columns literals offsets
     _col_literals_offsets.reserve(_num_input_columns + 1);
@@ -593,7 +594,7 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
     [](size_t sum, auto const& per_file_row_groups) { return sum + per_file_row_groups.size(); });
 
   // Collect equality literals for each input table column
-  auto equality_literals =
+  auto const equality_literals =
     equality_literals_collector{filter.get(), num_input_columns}.get_equality_literals();
 
   // Collect schema indices of columns with equality predicate(s)

From 6edc2481447d2170a28a6d1b4645a907d0909e7d Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Thu, 28 Nov 2024 01:00:06 +0000
Subject: [PATCH 39/85] MInor bug fixing

---
 cpp/src/io/parquet/bloom_filter_reader.cu  | 14 +++++++-------
 cpp/src/io/parquet/predicate_pushdown.cpp  |  4 ++--
 cpp/src/io/parquet/reader_impl_helpers.hpp |  4 ++--
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index f044b49e55f..8514ec05cdb 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -575,7 +575,7 @@ std::vector<Type> aggregate_reader_metadata::get_parquet_types(
 
 std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::apply_bloom_filters(
   host_span<std::unique_ptr<datasource> const> sources,
-  host_span<std::vector<size_type> const> row_group_indices,
+  host_span<std::vector<size_type> const> input_row_group_indices,
   host_span<data_type const> output_dtypes,
   host_span<int const> output_column_schemas,
   std::reference_wrapper<ast::expression const> filter,
@@ -588,8 +588,8 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
 
   // Total number of row groups to process.
   auto const num_row_groups = std::accumulate(
-    row_group_indices.begin(),
-    row_group_indices.end(),
+    input_row_group_indices.begin(),
+    input_row_group_indices.end(),
     size_t{0},
     [](size_t sum, auto const& per_file_row_groups) { return sum + per_file_row_groups.size(); });
 
@@ -613,14 +613,14 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
 
   // Read a vector of bloom filter bitset device buffers for all column with equality
   // predicate(s) across all row groups
-  auto const bloom_filter_data =
-    read_bloom_filters(sources, row_group_indices, equality_col_schemas, num_row_groups, stream);
+  auto const bloom_filter_data = read_bloom_filters(
+    sources, input_row_group_indices, equality_col_schemas, num_row_groups, stream);
 
   // No bloom filter buffers, return the original row group indices
   if (bloom_filter_data.empty()) { return std::nullopt; }
 
   // Get parquet types for the predicate columns
-  auto const parquet_types = get_parquet_types(row_group_indices, equality_col_schemas);
+  auto const parquet_types = get_parquet_types(input_row_group_indices, equality_col_schemas);
 
   // Copy bloom filter bitset buffer pointers and sizes to device
   std::vector<void*> h_buffer_ptrs(bloom_filter_data.size());
@@ -674,7 +674,7 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
   // filtered row group indices
   return collect_filtered_row_group_indices(bloom_filter_membership_table,
                                             bloom_filter_expr.get_bloom_filter_expr(),
-                                            row_group_indices,
+                                            input_row_group_indices,
                                             stream,
                                             mr);
 }
diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp
index ba6f690abd3..65ea51f50f3 100644
--- a/cpp/src/io/parquet/predicate_pushdown.cpp
+++ b/cpp/src/io/parquet/predicate_pushdown.cpp
@@ -450,8 +450,8 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
   stats_expression_converter stats_expr{filter.get(), static_cast<size_type>(output_dtypes.size())};
 
   // Filter stats table with StatsAST expression and collect filtered row group indices
-  auto filtered_row_group_indices = collect_filtered_row_group_indices(
-    stats_table, stats_expr.get_stats_expr(), row_group_indices, stream, mr);
+  auto const filtered_row_group_indices = collect_filtered_row_group_indices(
+    stats_table, stats_expr.get_stats_expr(), input_row_group_indices, stream, mr);
 
   // Span on row groups to apply bloom filtering on.
   auto const bloom_filter_input_row_groups =
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index c280341ead7..9cc2e0e8be8 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -375,7 +375,7 @@ class aggregate_reader_metadata {
    * @brief Filters the row groups using bloom filters
    *
    * @param sources Dataset sources
-   * @param row_group_indices Lists of row groups to read, one per source
+   * @param row_group_indices Lists of input row groups to read, one per source
    * @param output_dtypes Datatypes of of output columns
    * @param output_column_schemas schema indices of output columns
    * @param filter AST expression to filter row groups based on bloom filter membership
@@ -385,7 +385,7 @@ class aggregate_reader_metadata {
    */
   [[nodiscard]] std::optional<std::vector<std::vector<size_type>>> apply_bloom_filters(
     host_span<std::unique_ptr<datasource> const> sources,
-    host_span<std::vector<size_type> const> row_group_indices,
+    host_span<std::vector<size_type> const> input_row_group_indices,
     host_span<data_type const> output_dtypes,
     host_span<int const> output_column_schemas,
     std::reference_wrapper<ast::expression const> filter,

From 2925f1e0098ba57ac79e8f4dfab53c7265bc8100 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Thu, 28 Nov 2024 02:19:42 +0000
Subject: [PATCH 40/85] Add python tests

---
 ...d_ndv_100_bf_fpp0.1_nostats.snappy.parquet | Bin 0 -> 14057 bytes
 ...ed_card_ndv_100_chunk_stats.snappy.parquet | Bin 0 -> 12413 bytes
 ...d_ndv_500_bf_fpp0.1_nostats.snappy.parquet | Bin 0 -> 37510 bytes
 ...ed_card_ndv_500_chunk_stats.snappy.parquet | Bin 0 -> 33028 bytes
 python/cudf/cudf/tests/test_parquet.py        |  54 ++++++++++++++++++
 5 files changed, 54 insertions(+)
 create mode 100644 python/cudf/cudf/tests/data/parquet/mixed_card_ndv_100_bf_fpp0.1_nostats.snappy.parquet
 create mode 100644 python/cudf/cudf/tests/data/parquet/mixed_card_ndv_100_chunk_stats.snappy.parquet
 create mode 100644 python/cudf/cudf/tests/data/parquet/mixed_card_ndv_500_bf_fpp0.1_nostats.snappy.parquet
 create mode 100644 python/cudf/cudf/tests/data/parquet/mixed_card_ndv_500_chunk_stats.snappy.parquet

diff --git a/python/cudf/cudf/tests/data/parquet/mixed_card_ndv_100_bf_fpp0.1_nostats.snappy.parquet b/python/cudf/cudf/tests/data/parquet/mixed_card_ndv_100_bf_fpp0.1_nostats.snappy.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..8c40a225c44f946689afcb71c495fcadaf195a22
GIT binary patch
literal 14057
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
Bx-0+y

literal 0
HcmV?d00001

diff --git a/python/cudf/cudf/tests/data/parquet/mixed_card_ndv_100_chunk_stats.snappy.parquet b/python/cudf/cudf/tests/data/parquet/mixed_card_ndv_100_chunk_stats.snappy.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..e1dad1ef8b59edea48aa8c5c41029d9a70babe8f
GIT binary patch
literal 12413
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

literal 0
HcmV?d00001

diff --git a/python/cudf/cudf/tests/data/parquet/mixed_card_ndv_500_bf_fpp0.1_nostats.snappy.parquet b/python/cudf/cudf/tests/data/parquet/mixed_card_ndv_500_bf_fpp0.1_nostats.snappy.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..2565b962b0ba920879466b07bdd3b3507be7579b
GIT binary patch
literal 37510
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

literal 0
HcmV?d00001

diff --git a/python/cudf/cudf/tests/data/parquet/mixed_card_ndv_500_chunk_stats.snappy.parquet b/python/cudf/cudf/tests/data/parquet/mixed_card_ndv_500_chunk_stats.snappy.parquet
new file mode 100644
index 0000000000000000000000000000000000000000..746916cf07dc329f95ccd024cd8a2645920b4bf8
GIT binary patch
literal 33028
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
Do`x(*

literal 0
HcmV?d00001

diff --git a/python/cudf/cudf/tests/test_parquet.py b/python/cudf/cudf/tests/test_parquet.py
index 659d2ebd89a..6ba0f78d434 100644
--- a/python/cudf/cudf/tests/test_parquet.py
+++ b/python/cudf/cudf/tests/test_parquet.py
@@ -1,6 +1,7 @@
 # Copyright (c) 2019-2024, NVIDIA CORPORATION.
 
 import datetime
+import decimal
 import glob
 import hashlib
 import math
@@ -4341,3 +4342,56 @@ def test_parquet_reader_mismatched_nullability_structs(tmpdir):
         cudf.read_parquet([buf2, buf1]),
         cudf.concat([df2, df1]).reset_index(drop=True),
     )
+
+
+@pytest.mark.parametrize(
+    "stats_fname,bloom_filter_fname",
+    [
+        (
+            "mixed_card_ndv_100_chunk_stats.snappy.parquet",
+            "mixed_card_ndv_100_bf_fpp0.1_nostats.snappy.parquet",
+        ),
+        (
+            "mixed_card_ndv_500_chunk_stats.snappy.parquet",
+            "mixed_card_ndv_500_bf_fpp0.1_nostats.snappy.parquet",
+        ),
+    ],
+)
+@pytest.mark.parametrize(
+    "predicate,expected_len",
+    [
+        ([[("str", "==", "FINDME")], [("fp64", "==", float(500))]], 2),
+        ([("fixed_pt", "==", decimal.Decimal(float(500)))], 2),
+        ([[("ui32", "==", np.uint32(500)), ("str", "==", "FINDME")]], 2),
+        (
+            [
+                ("str", "!=", "FINDME"),
+                ("fixed_pt", "==", decimal.Decimal(float(500))),
+            ],
+            0,
+        ),
+    ],
+)
+def test_parquet_bloom_filters(
+    datadir, stats_fname, bloom_filter_fname, predicate, expected_len
+):
+    fname_stats = datadir / stats_fname
+    fname_bf = datadir / bloom_filter_fname
+    df_stats = cudf.read_parquet(fname_stats, filters=predicate).reset_index(
+        drop=True
+    )
+    df_bf = cudf.read_parquet(fname_bf, filters=predicate).reset_index(
+        drop=True
+    )
+
+    # Check if tables equal
+    assert_eq(
+        df_stats,
+        df_bf,
+    )
+
+    # Check for table length
+    assert_eq(
+        len(df_stats),
+        expected_len,
+    )

From efc6ec0a5c4b956ba86d97259aff6f31b5443401 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Thu, 28 Nov 2024 02:28:03 +0000
Subject: [PATCH 41/85] Correct parquet files

---
 ...d_ndv_100_bf_fpp0.1_nostats.snappy.parquet | Bin 14057 -> 41508 bytes
 ...d_ndv_500_bf_fpp0.1_nostats.snappy.parquet | Bin 37510 -> 77985 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)

diff --git a/python/cudf/cudf/tests/data/parquet/mixed_card_ndv_100_bf_fpp0.1_nostats.snappy.parquet b/python/cudf/cudf/tests/data/parquet/mixed_card_ndv_100_bf_fpp0.1_nostats.snappy.parquet
index 8c40a225c44f946689afcb71c495fcadaf195a22..4123545a6e030b7c0b1b7852571348ed53074f72 100644
GIT binary patch
literal 41508
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
C`Z6d0

delta 5435
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
B*4Y36

diff --git a/python/cudf/cudf/tests/data/parquet/mixed_card_ndv_500_bf_fpp0.1_nostats.snappy.parquet b/python/cudf/cudf/tests/data/parquet/mixed_card_ndv_500_bf_fpp0.1_nostats.snappy.parquet
index 2565b962b0ba920879466b07bdd3b3507be7579b..e898f1d7d1bf6976b661b87b7ea39b615f318102 100644
GIT binary patch
literal 77985
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

delta 21505
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


From a2fa7842c08c619e864934961be1d02e1b7651a7 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Mon, 2 Dec 2024 19:13:09 +0000
Subject: [PATCH 42/85] minor spelling fix

---
 cpp/src/io/parquet/reader_impl_helpers.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index 9cc2e0e8be8..f1d55bef326 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -221,7 +221,7 @@ class aggregate_reader_metadata {
    * @param row_group_indices Lists of row groups, once per source
    * @param column_schemas Schema indices of columns whose types will be collected
    *
-   * @return A list of parquet types for the columns matching the procided schema indices
+   * @return A list of parquet types for the columns matching the provided schema indices
    */
   [[nodiscard]] std::vector<Type> get_parquet_types(
     host_span<std::vector<size_type> const> row_group_indices,

From fa0cec85d543c24ff005e9f2dacbda7282c92170 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <14217455+mhaseeb123@users.noreply.github.com>
Date: Mon, 2 Dec 2024 14:09:56 -0800
Subject: [PATCH 43/85] Apply suggestions from code review

Co-authored-by: Bradley Dice <bdice@bradleydice.com>
---
 cpp/src/io/parquet/reader_impl_helpers.hpp | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index f1d55bef326..7e9881e8947 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -355,7 +355,7 @@ class aggregate_reader_metadata {
   /**
    * @brief Filters the row groups based on predicate filter
    *
-   * @param sources Lists of input datasources.
+   * @param sources Lists of input datasources
    * @param row_group_indices Lists of row groups to read, one per source
    * @param output_dtypes Datatypes of of output columns
    * @param output_column_schemas schema indices of output columns
@@ -397,7 +397,7 @@ class aggregate_reader_metadata {
    * The input `row_start` and `row_count` parameters will be recomputed and output as the valid
    * values based on the input row group list.
    *
-   * @param sources Lists of input datasources.
+   * @param sources Lists of input datasources
    * @param row_group_indices Lists of row groups to read, one per source
    * @param row_start Starting row of the selection
    * @param row_count Total number of rows selected

From 7a309c691bb9c4ddf33451265231c5a2ab7d57c6 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <14217455+mhaseeb123@users.noreply.github.com>
Date: Mon, 2 Dec 2024 22:11:11 +0000
Subject: [PATCH 44/85] Minor bug fix

---
 cpp/include/cudf/hashing/detail/xxhash_64.cuh |  3 ++-
 cpp/src/io/parquet/bloom_filter_reader.cu     | 16 ++++++++--------
 cpp/src/io/parquet/reader_impl_helpers.hpp    | 10 +++++-----
 3 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/cpp/include/cudf/hashing/detail/xxhash_64.cuh b/cpp/include/cudf/hashing/detail/xxhash_64.cuh
index 7d72349e340..53b3fbad842 100644
--- a/cpp/include/cudf/hashing/detail/xxhash_64.cuh
+++ b/cpp/include/cudf/hashing/detail/xxhash_64.cuh
@@ -29,7 +29,8 @@ namespace cudf::hashing::detail {
 
 template <typename Key>
 struct XXHash_64 {
-  using result_type = std::uint64_t;
+  using argument_type = Key;
+  using result_type   = std::uint64_t;
 
   __host__ __device__ constexpr XXHash_64(uint64_t seed = cudf::DEFAULT_HASH_SEED) : _impl{seed} {}
 
diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 8514ec05cdb..dcbf17003d0 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -59,7 +59,7 @@ struct bloom_filter_caster {
   template <typename T, bool timestamp_is_int96 = false>
   std::unique_ptr<cudf::column> query_bloom_filter(cudf::size_type equality_col_idx,
                                                    cudf::data_type dtype,
-                                                   ast::literal* const& literal,
+                                                   ast::literal const* const literal,
                                                    rmm::cuda_stream_view stream,
                                                    rmm::device_async_resource_ref mr) const
   {
@@ -135,7 +135,7 @@ struct bloom_filter_caster {
   template <typename T>
   std::unique_ptr<cudf::column> operator()(cudf::size_type equality_col_idx,
                                            cudf::data_type dtype,
-                                           ast::literal* const& literal,
+                                           ast::literal* const literal,
                                            rmm::cuda_stream_view stream,
                                            rmm::device_async_resource_ref mr) const
   {
@@ -215,15 +215,15 @@ class equality_literals_collector : public ast::detail::expression_transformer {
       // First operand should be column reference, second should be literal.
       CUDF_EXPECTS(cudf::ast::detail::ast_operator_arity(op) == 2,
                    "Only binary operations are supported on column reference");
-      CUDF_EXPECTS(dynamic_cast<ast::literal const*>(&operands[1].get()) != nullptr,
+      auto const literal_ptr = dynamic_cast<ast::literal const*>(&operands[1].get());
+      CUDF_EXPECTS(literal_ptr != nullptr,
                    "Second operand of binary operation with column reference must be a literal");
       v->accept(*this);
 
       // Push to the corresponding column's literals list iff equality predicate is seen
       if (op == ast_operator::EQUAL) {
         auto const col_idx = v->get_column_index();
-        _equality_literals[col_idx].emplace_back(
-          const_cast<ast::literal*>(dynamic_cast<ast::literal const*>(&operands[1].get())));
+        _equality_literals[col_idx].emplace_back(const_cast<ast::literal*>(literal_ptr));
       }
     } else {
       auto new_operands = visit_operands(operands);
@@ -266,7 +266,7 @@ class equality_literals_collector : public ast::detail::expression_transformer {
 };
 
 /**
- * @brief Converts AST expression to bloom filter membership (BloomfilterAST) expression .
+ * @brief Converts AST expression to bloom filter membership (BloomfilterAST) expression.
  * This is used in row group filtering based on equality predicate.
  */
 class bloom_filter_expression_converter : public equality_literals_collector {
@@ -368,7 +368,7 @@ class bloom_filter_expression_converter : public equality_literals_collector {
  *
  * @param sources Dataset sources
  * @param num_chunks Number of total column chunks to read
- * @param bloom_filter_data Devicebuffers to hold bloom filter bitsets for each chunk
+ * @param bloom_filter_data Device buffers to hold bloom filter bitsets for each chunk
  * @param bloom_filter_offsets Bloom filter offsets for all chunks
  * @param bloom_filter_sizes Bloom filter sizes for all chunks
  * @param chunk_source_map Association between each column chunk and its source
@@ -657,7 +657,7 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
                   if (cudf::is_compound(dtype) and dtype.id() != cudf::type_id::STRING) { return; }
 
                   // Add a column for all literals associated with an equality column
-                  for (ast::literal* const& literal : equality_literals[input_col_idx]) {
+                  for (auto const& literal : equality_literals[input_col_idx]) {
                     columns.emplace_back(cudf::type_dispatcher<dispatch_storage_type>(
                       dtype, bloom_filter_col, equality_col_idx, dtype, literal, stream, mr));
                   }
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index 7e9881e8947..2e3e6c6b6dd 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -361,7 +361,7 @@ class aggregate_reader_metadata {
    * @param output_column_schemas schema indices of output columns
    * @param filter AST expression to filter row groups based on Column chunk statistics
    * @param stream CUDA stream used for device memory operations and kernel launches
-   * @return Filtered row group indices, if any is filtered.
+   * @return Filtered row group indices, if any is filtered
    */
   [[nodiscard]] std::optional<std::vector<std::vector<size_type>>> filter_row_groups(
     host_span<std::unique_ptr<datasource> const> sources,
@@ -381,7 +381,7 @@ class aggregate_reader_metadata {
    * @param filter AST expression to filter row groups based on bloom filter membership
    * @param stream CUDA stream used for device memory operations and kernel launches
    *
-   * @return Filtered row group indices, if any is filtered.
+   * @return Filtered row group indices, if any is filtered
    */
   [[nodiscard]] std::optional<std::vector<std::vector<size_type>>> apply_bloom_filters(
     host_span<std::unique_ptr<datasource> const> sources,
@@ -406,7 +406,7 @@ class aggregate_reader_metadata {
    * @param filter Optional AST expression to filter row groups based on Column chunk statistics
    * @param stream CUDA stream used for device memory operations and kernel launches
    * @return A tuple of corrected row_start, row_count, list of row group indexes and its
-   *         starting row, and list of number of rows per source.
+   *         starting row, and list of number of rows per source
    */
   [[nodiscard]] std::tuple<int64_t, size_type, std::vector<row_group_info>, std::vector<size_t>>
   select_row_groups(host_span<std::unique_ptr<datasource> const> sources,
@@ -469,7 +469,7 @@ class named_to_reference_converter : public ast::detail::expression_transformer
   std::reference_wrapper<ast::expression const> visit(ast::operation const& expr) override;
 
   /**
-   * @brief Returns the AST to apply on Column chunk statistics.
+   * @brief Returns the AST to apply on Column chunk statistics
    *
    * @return AST operation expression
    */
@@ -506,7 +506,7 @@ class named_to_reference_converter : public ast::detail::expression_transformer
  * collect filtered row group indices
  *
  * @param table Table of stats or bloom filter membership columns
- * @param ast_expr StatsAST or BloomfilterAST expression to filter with.
+ * @param ast_expr StatsAST or BloomfilterAST expression to filter with
  * @param input_row_group_indices Lists of input row groups to read, one per source
  * @param stream CUDA stream used for device memory operations and kernel launches
  * @param mr Device memory resource used to be used in cudf::compute_column

From bcc68c0e896fe59973e74fc6bfe78d24a54d5767 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Mon, 2 Dec 2024 23:26:19 +0000
Subject: [PATCH 45/85] Convert to enum class

---
 cpp/src/io/parquet/parquet.hpp | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/cpp/src/io/parquet/parquet.hpp b/cpp/src/io/parquet/parquet.hpp
index ff8e7a63486..241f6efbae3 100644
--- a/cpp/src/io/parquet/parquet.hpp
+++ b/cpp/src/io/parquet/parquet.hpp
@@ -400,7 +400,7 @@ struct ColumnChunkMetaData {
  */
 struct BloomFilterAlgorithm {
   // Block-based Bloom filter.
-  enum Algorithm { UNDEFINED, SPLIT_BLOCK };
+  enum class Algorithm { UNDEFINED, SPLIT_BLOCK };
   Algorithm algorithm{Algorithm::SPLIT_BLOCK};
 };
 
@@ -409,7 +409,7 @@ struct BloomFilterAlgorithm {
  */
 struct BloomFilterHash {
   // xxHash_64
-  enum Hash { UNDEFINED, XXHASH };
+  enum class Hash { UNDEFINED, XXHASH };
   Hash hash{Hash::XXHASH};
 };
 
@@ -417,7 +417,7 @@ struct BloomFilterHash {
  * @brief The compression used in the bloom filter
  */
 struct BloomFilterCompression {
-  enum Compression { UNDEFINED, UNCOMPRESSED };
+  enum class Compression { UNDEFINED, UNCOMPRESSED };
   Compression compression{Compression::UNCOMPRESSED};
 };
 

From 2dce9b1589b0bd046bb89262b0d97801bb6f51aa Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 3 Dec 2024 00:38:33 +0000
Subject: [PATCH 46/85] Apply suggestion from code review

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index dcbf17003d0..e42f3dd4111 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -29,6 +29,7 @@
 #include <cudf/hashing/detail/xxhash_64.cuh>
 #include <cudf/utilities/span.hpp>
 #include <cudf/utilities/traits.hpp>
+#include <cudf/utilities/type_checks.hpp>
 
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/device_buffer.hpp>
@@ -68,9 +69,11 @@ struct bloom_filter_caster {
     using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
     using word_type   = typename policy_type::word_type;
 
-    // Check if the literal has the same type as the column
-    CUDF_EXPECTS(dtype.id() == literal->get_data_type().id(),
-                 "Mismatched data types between the column and the literal");
+    // Check if the literal has the same type as the predicate column
+    CUDF_EXPECTS(
+      cudf::have_same_types(cudf::column_view{dtype, 0, {}, {}, 0, 0, {}},
+                            cudf::column_view{literal->get_data_type(), 0, {}, {}, 0, 0, {}}),
+      "Mismatched predicate column and literal types");
 
     // Filter properties
     auto constexpr word_size       = sizeof(word_type);

From e03bea02c97e060d082b95f934662f387a7aa645 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 3 Dec 2024 20:58:07 +0000
Subject: [PATCH 47/85] Suggestions from code reviews

---
 cpp/src/io/parquet/bloom_filter_reader.cu |  7 ++++++-
 cpp/src/io/parquet/predicate_pushdown.cpp | 19 ++++++++++++-------
 2 files changed, 18 insertions(+), 8 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index e42f3dd4111..7901776c7f6 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -40,6 +40,7 @@
 #include <thrust/iterator/counting_iterator.h>
 
 #include <future>
+#include <limits>
 #include <numeric>
 #include <optional>
 
@@ -476,7 +477,7 @@ std::future<void> read_bloom_filter_data_async(
     }
   };
 
-  return std::async(std::launch::deferred, sync_fn, std::move(read_tasks));
+  return std::async(std::launch::async, sync_fn, std::move(read_tasks));
 }
 
 }  // namespace
@@ -596,6 +597,10 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
     size_t{0},
     [](size_t sum, auto const& per_file_row_groups) { return sum + per_file_row_groups.size(); });
 
+  // Check if we have less than 2B total row groups.
+  CUDF_EXPECTS(num_row_groups <= std::numeric_limits<cudf::size_type>::max(),
+               "Total number of row groups exceed the size_type's limit");
+
   // Collect equality literals for each input table column
   auto const equality_literals =
     equality_literals_collector{filter.get(), num_input_columns}.get_equality_literals();
diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp
index 65ea51f50f3..b917c83d524 100644
--- a/cpp/src/io/parquet/predicate_pushdown.cpp
+++ b/cpp/src/io/parquet/predicate_pushdown.cpp
@@ -32,6 +32,7 @@
 #include <thrust/iterator/counting_iterator.h>
 
 #include <algorithm>
+#include <limits>
 #include <numeric>
 #include <optional>
 #include <unordered_set>
@@ -415,18 +416,22 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
   } else {
     input_row_group_indices = row_group_indices;
   }
-  auto const total_row_groups = std::accumulate(input_row_group_indices.begin(),
-                                                input_row_group_indices.end(),
-                                                0,
-                                                [](size_type sum, auto const& per_file_row_groups) {
-                                                  return sum + per_file_row_groups.size();
-                                                });
+  auto const total_row_groups = std::accumulate(
+    input_row_group_indices.begin(),
+    input_row_group_indices.end(),
+    size_t{0},
+    [](size_t sum, auto const& per_file_row_groups) { return sum + per_file_row_groups.size(); });
+
+  // Check if we have less than 2B total row groups.
+  CUDF_EXPECTS(total_row_groups <= std::numeric_limits<cudf::size_type>::max(),
+               "Total number of row groups exceed the size_type's limit");
 
   // Converts Column chunk statistics to a table
   // where min(col[i]) = columns[i*2], max(col[i])=columns[i*2+1]
   // For each column, it contains #sources * #column_chunks_per_src rows.
   std::vector<std::unique_ptr<column>> columns;
-  stats_caster stats_col{total_row_groups, per_file_metadata, input_row_group_indices};
+  stats_caster stats_col{
+    static_cast<size_type>(total_row_groups), per_file_metadata, input_row_group_indices};
   for (size_t col_idx = 0; col_idx < output_dtypes.size(); col_idx++) {
     auto const schema_idx = output_column_schemas[col_idx];
     auto const& dtype     = output_dtypes[col_idx];

From 4b0b5edb729936490ba74abd57dca5a7ee58bd2f Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 4 Dec 2024 00:31:09 +0000
Subject: [PATCH 48/85] Apply suggestions from code reviews

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 50 ++++++++++++-----------
 1 file changed, 26 insertions(+), 24 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 7901776c7f6..fb2b452fe1a 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -52,8 +52,7 @@ namespace {
  *
  */
 struct bloom_filter_caster {
-  cudf::device_span<void* const> buffer_ptrs;
-  cudf::device_span<size_t const> buffer_sizes;
+  cudf::device_span<cudf::device_span<cuda::std::byte> const> bloom_filter_spans;
   host_span<Type const> parquet_types;
   size_t num_row_groups;
   size_t num_equality_columns;
@@ -87,34 +86,35 @@ struct bloom_filter_caster {
       rmm::exec_policy_nosync(stream),
       thrust::make_counting_iterator<size_t>(0),
       thrust::make_counting_iterator(num_row_groups),
-      [buffer_ptrs          = buffer_ptrs.data(),
-       buffer_sizes         = buffer_sizes.data(),
+      [filter_span          = bloom_filter_spans.data(),
        d_scalar             = literal->get_value(),
        col_idx              = equality_col_idx,
        num_equality_columns = num_equality_columns,
        results = reinterpret_cast<bool*>(results.data())] __device__(auto row_group_idx) {
         // Filter bitset buffer index
-        auto const filter_idx = col_idx + (num_equality_columns * row_group_idx);
+        auto const filter_idx  = col_idx + (num_equality_columns * row_group_idx);
+        auto const filter_size = filter_span[filter_idx].size();
 
         // If no bloom filter, then fill in `true` as membership cannot be determined
-        if (buffer_sizes[filter_idx] == 0) {
+        if (filter_size == 0) {
           results[row_group_idx] = true;
           return;
         }
 
         // Number of filter blocks
-        auto const num_filter_blocks = buffer_sizes[filter_idx] / (word_size * words_per_block);
+        auto const num_filter_blocks = filter_size / (word_size * words_per_block);
 
         // Create a bloom filter view.
         cuco::bloom_filter_ref<key_type,
                                cuco::extent<std::size_t>,
                                cuco::thread_scope_thread,
                                policy_type>
-          filter{reinterpret_cast<word_type*>(buffer_ptrs[filter_idx]),
+          filter{reinterpret_cast<word_type*>(filter_span[filter_idx].data()),
                  num_filter_blocks,
                  {},  // Thread scope as the same literal is being searched across different bitsets
                       // per thread
-                 {}};  // Arrow policy with cudf::XXHash_64 seeded with 0 for Arrow compatibility
+                 {}};  // Arrow policy with cudf::hashing::detail::XXHash_64 seeded with 0 for Arrow
+                       // compatibility
 
         // If int96_timestamp type, convert literal to string_view and query bloom
         // filter
@@ -621,7 +621,7 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
 
   // Read a vector of bloom filter bitset device buffers for all column with equality
   // predicate(s) across all row groups
-  auto const bloom_filter_data = read_bloom_filters(
+  auto bloom_filter_data = read_bloom_filters(
     sources, input_row_group_indices, equality_col_schemas, num_row_groups, stream);
 
   // No bloom filter buffers, return the original row group indices
@@ -630,23 +630,25 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
   // Get parquet types for the predicate columns
   auto const parquet_types = get_parquet_types(input_row_group_indices, equality_col_schemas);
 
-  // Copy bloom filter bitset buffer pointers and sizes to device
-  std::vector<void*> h_buffer_ptrs(bloom_filter_data.size());
-  std::vector<size_t> h_buffer_sizes(bloom_filter_data.size());
-  std::for_each(thrust::make_counting_iterator<size_t>(0),
-                thrust::make_counting_iterator<size_t>(bloom_filter_data.size()),
-                [&](auto i) {
-                  auto const& buffer = bloom_filter_data[i];
-                  // Bitset ptr must be non-const to be used in cuco::bloom_filter.
-                  h_buffer_ptrs[i]  = const_cast<void*>(buffer.data());
-                  h_buffer_sizes[i] = buffer.size();
-                });
-  auto buffer_ptrs  = cudf::detail::make_device_uvector_async(h_buffer_ptrs, stream, mr);
-  auto buffer_sizes = cudf::detail::make_device_uvector_async(h_buffer_sizes, stream, mr);
+  // Create spans from bloom filter bitset buffers
+  std::vector<cudf::device_span<cuda::std::byte>> h_bloom_filter_spans;
+  h_bloom_filter_spans.reserve(bloom_filter_data.size());
+  std::transform(thrust::make_counting_iterator<size_t>(0),
+                 thrust::make_counting_iterator<size_t>(bloom_filter_data.size()),
+                 std::back_inserter(h_bloom_filter_spans),
+                 [&](auto const filter_idx) {
+                   return cudf::device_span<cuda::std::byte>{
+                     static_cast<cuda::std::byte*>(bloom_filter_data[filter_idx].data()),
+                     bloom_filter_data[filter_idx].size()};
+                 });
+
+  // Copy bloom filter bitset spans to device
+  auto const bloom_filter_spans =
+    cudf::detail::make_device_uvector_async(h_bloom_filter_spans, stream, mr);
 
   // Create a bloom filter query table caster.
   bloom_filter_caster bloom_filter_col{
-    buffer_ptrs, buffer_sizes, parquet_types, num_row_groups, equality_col_schemas.size()};
+    bloom_filter_spans, parquet_types, num_row_groups, equality_col_schemas.size()};
 
   // Converts bloom filter membership for equality predicate columns to a table
   // containing a column for each `col[i] == literal` predicate to be evaluated.

From c1256b135939249f79f90293dbe91e9cce967ece Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 4 Dec 2024 05:01:53 +0000
Subject: [PATCH 49/85] Refactor into single table for cudf::compute_column

---
 cpp/src/io/parquet/bloom_filter_reader.cu     | 242 +++---------
 cpp/src/io/parquet/predicate_pushdown.cpp     | 346 +++++++++---------
 cpp/src/io/parquet/reader_impl_helpers.hpp    |  93 ++++-
 ...ed_card_ndv_100_chunk_stats.snappy.parquet | Bin 12413 -> 37036 bytes
 ...ed_card_ndv_500_chunk_stats.snappy.parquet | Bin 33028 -> 58150 bytes
 5 files changed, 298 insertions(+), 383 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index fb2b452fe1a..5054051b042 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -23,7 +23,6 @@
 #include <cudf/ast/detail/operators.hpp>
 #include <cudf/ast/expressions.hpp>
 #include <cudf/detail/cuco_helpers.hpp>
-#include <cudf/detail/iterator.cuh>
 #include <cudf/detail/transform.hpp>
 #include <cudf/detail/utilities/logger.hpp>
 #include <cudf/hashing/detail/xxhash_64.cuh>
@@ -33,7 +32,6 @@
 
 #include <rmm/cuda_stream_view.hpp>
 #include <rmm/device_buffer.hpp>
-#include <rmm/device_vector.hpp>
 #include <rmm/exec_policy.hpp>
 
 #include <cuco/bloom_filter_ref.cuh>
@@ -54,7 +52,7 @@ namespace {
 struct bloom_filter_caster {
   cudf::device_span<cudf::device_span<cuda::std::byte> const> bloom_filter_spans;
   host_span<Type const> parquet_types;
-  size_t num_row_groups;
+  size_t total_row_groups;
   size_t num_equality_columns;
 
   template <typename T, bool timestamp_is_int96 = false>
@@ -79,13 +77,13 @@ struct bloom_filter_caster {
     auto constexpr word_size       = sizeof(word_type);
     auto constexpr words_per_block = policy_type::words_per_block;
 
-    rmm::device_buffer results{num_row_groups, stream, mr};
+    rmm::device_buffer results{total_row_groups, stream, mr};
 
     // Query literal in bloom filters from each column chunk (row group).
     thrust::for_each(
       rmm::exec_policy_nosync(stream),
       thrust::make_counting_iterator<size_t>(0),
-      thrust::make_counting_iterator(num_row_groups),
+      thrust::make_counting_iterator(total_row_groups),
       [filter_span          = bloom_filter_spans.data(),
        d_scalar             = literal->get_value(),
        col_idx              = equality_col_idx,
@@ -129,7 +127,7 @@ struct bloom_filter_caster {
       });
 
     return std::make_unique<cudf::column>(cudf::data_type{cudf::type_id::BOOL8},
-                                          static_cast<cudf::size_type>(num_row_groups),
+                                          static_cast<cudf::size_type>(total_row_groups),
                                           std::move(results),
                                           rmm::device_buffer{},
                                           0);
@@ -164,47 +162,22 @@ struct bloom_filter_caster {
  * @brief Collects lists of equality predicate literals in the AST expression, one list per input
  * table column. This is used in row group filtering based on bloom filters.
  */
-class equality_literals_collector : public ast::detail::expression_transformer {
+class equality_literals_collector : public combined_expression_converter {
  public:
-  equality_literals_collector() = default;
-
   equality_literals_collector(ast::expression const& expr, cudf::size_type num_input_columns)
-    : _num_input_columns{num_input_columns}
   {
+    _num_input_columns = num_input_columns;
     _equality_literals.resize(_num_input_columns);
     expr.accept(*this);
   }
 
-  /**
-   * @copydoc ast::detail::expression_transformer::visit(ast::literal const& )
-   */
-  std::reference_wrapper<ast::expression const> visit(ast::literal const& expr) override
-  {
-    _bloom_filter_expr = std::reference_wrapper<ast::expression const>(expr);
-    return expr;
-  }
-
-  /**
-   * @copydoc ast::detail::expression_transformer::visit(ast::column_reference const& )
-   */
-  std::reference_wrapper<ast::expression const> visit(ast::column_reference const& expr) override
-  {
-    CUDF_EXPECTS(expr.get_table_source() == ast::table_reference::LEFT,
-                 "BloomfilterAST supports only left table");
-    CUDF_EXPECTS(expr.get_column_index() < _num_input_columns,
-                 "Column index cannot be more than number of columns in the table");
-    _bloom_filter_expr = std::reference_wrapper<ast::expression const>(expr);
-    return expr;
-  }
+  // Bring all overloads of `visit` from combined_expression_converter into scope
+  using combined_expression_converter::visit;
 
   /**
-   * @copydoc ast::detail::expression_transformer::visit(ast::column_name_reference const& )
+   * @brief Delete converted expression getter as no longer needed
    */
-  std::reference_wrapper<ast::expression const> visit(
-    ast::column_name_reference const& expr) override
-  {
-    CUDF_FAIL("Column name reference is not supported in BloomfilterAST");
-  }
+  [[nodiscard]] std::reference_wrapper<ast::expression const> get_converted_expr() = delete;
 
   /**
    * @copydoc ast::detail::expression_transformer::visit(ast::operation const& )
@@ -237,7 +210,7 @@ class equality_literals_collector : public ast::detail::expression_transformer {
         _operators.emplace_back(op, new_operands.front());
       }
     }
-    _bloom_filter_expr = std::reference_wrapper<ast::expression const>(_operators.back());
+    _converted_expr = std::reference_wrapper<ast::expression const>(_operators.back());
     return std::reference_wrapper<ast::expression const>(_operators.back());
   }
 
@@ -250,121 +223,6 @@ class equality_literals_collector : public ast::detail::expression_transformer {
   {
     return _equality_literals;
   }
-
- protected:
-  std::vector<std::reference_wrapper<ast::expression const>> visit_operands(
-    cudf::host_span<std::reference_wrapper<ast::expression const> const> operands)
-  {
-    std::vector<std::reference_wrapper<ast::expression const>> transformed_operands;
-    for (auto const& operand : operands) {
-      auto const new_operand = operand.get().accept(*this);
-      transformed_operands.push_back(new_operand);
-    }
-    return transformed_operands;
-  }
-  std::optional<std::reference_wrapper<ast::expression const>> _bloom_filter_expr;
-  std::vector<std::vector<ast::literal*>> _equality_literals;
-  std::list<ast::column_reference> _col_ref;
-  std::list<ast::operation> _operators;
-  size_type _num_input_columns;
-};
-
-/**
- * @brief Converts AST expression to bloom filter membership (BloomfilterAST) expression.
- * This is used in row group filtering based on equality predicate.
- */
-class bloom_filter_expression_converter : public equality_literals_collector {
- public:
-  bloom_filter_expression_converter(
-    ast::expression const& expr,
-    size_type num_input_columns,
-    std::vector<std::vector<ast::literal*>> const& equality_literals)
-  {
-    // Set the num columns and copy equality literals
-    _num_input_columns = num_input_columns;
-    _equality_literals = equality_literals;
-
-    // Compute and store columns literals offsets
-    _col_literals_offsets.reserve(_num_input_columns + 1);
-    _col_literals_offsets.emplace_back(0);
-
-    std::transform(equality_literals.begin(),
-                   equality_literals.end(),
-                   std::back_inserter(_col_literals_offsets),
-                   [&](auto const& col_literal_map) {
-                     return _col_literals_offsets.back() +
-                            static_cast<cudf::size_type>(col_literal_map.size());
-                   });
-
-    // Add this visitor
-    expr.accept(*this);
-  }
-
-  /**
-   * @brief Delete equality literals getter as no longer needed
-   */
-  [[nodiscard]] std::vector<std::vector<ast::literal*>> get_equality_literals() = delete;
-
-  // Bring all overloads of `visit` from equality_predicate_collector into scope
-  using equality_literals_collector::visit;
-
-  /**
-   * @copydoc ast::detail::expression_transformer::visit(ast::operation const& )
-   */
-  std::reference_wrapper<ast::expression const> visit(ast::operation const& expr) override
-  {
-    using cudf::ast::ast_operator;
-    auto const operands = expr.get_operands();
-    auto const op       = expr.get_operator();
-
-    if (auto* v = dynamic_cast<ast::column_reference const*>(&operands[0].get())) {
-      // First operand should be column reference, second should be literal.
-      CUDF_EXPECTS(cudf::ast::detail::ast_operator_arity(op) == 2,
-                   "Only binary operations are supported on column reference");
-      CUDF_EXPECTS(dynamic_cast<ast::literal const*>(&operands[1].get()) != nullptr,
-                   "Second operand of binary operation with column reference must be a literal");
-      v->accept(*this);
-
-      if (op == ast_operator::EQUAL) {
-        // Search the literal in this input column's equality literals list and add to the offset.
-        auto const col_idx            = v->get_column_index();
-        auto const& equality_literals = _equality_literals[col_idx];
-        auto col_literal_offset       = _col_literals_offsets[col_idx];
-        auto const literal_iter       = std::find(equality_literals.cbegin(),
-                                            equality_literals.cend(),
-                                            dynamic_cast<ast::literal const*>(&operands[1].get()));
-        CUDF_EXPECTS(literal_iter != equality_literals.end(), "Could not find the literal ptr");
-        col_literal_offset += std::distance(equality_literals.cbegin(), literal_iter);
-
-        // Evaluate boolean is_true(value) expression as NOT(NOT(value))
-        auto const& value = _col_ref.emplace_back(col_literal_offset);
-        auto const& op    = _operators.emplace_back(ast_operator::NOT, value);
-        _operators.emplace_back(ast_operator::NOT, op);
-      }
-    } else {
-      auto new_operands = visit_operands(operands);
-      if (cudf::ast::detail::ast_operator_arity(op) == 2) {
-        _operators.emplace_back(op, new_operands.front(), new_operands.back());
-      } else if (cudf::ast::detail::ast_operator_arity(op) == 1) {
-        _operators.emplace_back(op, new_operands.front());
-      }
-    }
-    _bloom_filter_expr = std::reference_wrapper<ast::expression const>(_operators.back());
-    return std::reference_wrapper<ast::expression const>(_operators.back());
-  }
-
-  /**
-   * @brief Returns the AST to apply on bloom filters mmebership.
-   *
-   * @return AST operation expression
-   */
-  [[nodiscard]] std::reference_wrapper<ast::expression const> get_bloom_filter_expr() const
-  {
-    return _bloom_filter_expr.value().get();
-  }
-
- private:
-  std::vector<cudf::size_type> _col_literals_offsets;
 };
 
 /**
@@ -486,12 +344,12 @@ std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
   host_span<std::unique_ptr<datasource> const> sources,
   host_span<std::vector<size_type> const> row_group_indices,
   host_span<int const> column_schemas,
-  size_type num_row_groups,
+  size_type total_row_groups,
   rmm::cuda_stream_view stream) const
 {
   // Descriptors for all the chunks that make up the selected columns
   auto const num_input_columns = column_schemas.size();
-  auto const num_chunks        = num_row_groups * num_input_columns;
+  auto const num_chunks        = total_row_groups * num_input_columns;
 
   // Association between each column chunk and its source
   std::vector<size_type> chunk_source_map(num_chunks);
@@ -577,12 +435,14 @@ std::vector<Type> aggregate_reader_metadata::get_parquet_types(
   return parquet_types;
 }
 
-std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::apply_bloom_filters(
+std::pair<std::vector<std::unique_ptr<cudf::column>>, std::vector<std::vector<ast::literal*>>>
+aggregate_reader_metadata::apply_bloom_filters(
   host_span<std::unique_ptr<datasource> const> sources,
   host_span<std::vector<size_type> const> input_row_group_indices,
   host_span<data_type const> output_dtypes,
   host_span<int const> output_column_schemas,
   std::reference_wrapper<ast::expression const> filter,
+  size_t total_row_groups,
   rmm::cuda_stream_view stream) const
 {
   // Number of input table columns
@@ -590,17 +450,6 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
 
   auto mr = cudf::get_current_device_resource_ref();
 
-  // Total number of row groups to process.
-  auto const num_row_groups = std::accumulate(
-    input_row_group_indices.begin(),
-    input_row_group_indices.end(),
-    size_t{0},
-    [](size_t sum, auto const& per_file_row_groups) { return sum + per_file_row_groups.size(); });
-
-  // Check if we have less than 2B total row groups.
-  CUDF_EXPECTS(num_row_groups <= std::numeric_limits<cudf::size_type>::max(),
-               "Total number of row groups exceed the size_type's limit");
-
   // Collect equality literals for each input table column
   auto const equality_literals =
     equality_literals_collector{filter.get(), num_input_columns}.get_equality_literals();
@@ -616,16 +465,19 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
                   }
                 });
 
+  // Read bloom filters and add literal membership columns.
+  std::vector<std::unique_ptr<cudf::column>> bloom_filter_membership_columns;
+
   // Return early if no column with equality predicate(s)
-  if (equality_col_schemas.empty()) { return std::nullopt; }
+  if (equality_col_schemas.empty()) { return {}; }
 
   // Read a vector of bloom filter bitset device buffers for all column with equality
   // predicate(s) across all row groups
   auto bloom_filter_data = read_bloom_filters(
-    sources, input_row_group_indices, equality_col_schemas, num_row_groups, stream);
+    sources, input_row_group_indices, equality_col_schemas, total_row_groups, stream);
 
   // No bloom filter buffers, return the original row group indices
-  if (bloom_filter_data.empty()) { return std::nullopt; }
+  if (bloom_filter_data.empty()) { return {}; }
 
   // Get parquet types for the predicate columns
   auto const parquet_types = get_parquet_types(input_row_group_indices, equality_col_schemas);
@@ -648,45 +500,33 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
 
   // Create a bloom filter query table caster.
   bloom_filter_caster bloom_filter_col{
-    bloom_filter_spans, parquet_types, num_row_groups, equality_col_schemas.size()};
+    bloom_filter_spans, parquet_types, total_row_groups, equality_col_schemas.size()};
 
   // Converts bloom filter membership for equality predicate columns to a table
   // containing a column for each `col[i] == literal` predicate to be evaluated.
   // The table contains #sources * #column_chunks_per_src rows.
-  std::vector<std::unique_ptr<column>> columns;
   size_t equality_col_idx = 0;
-  std::for_each(thrust::make_counting_iterator<size_t>(0),
-                thrust::make_counting_iterator(output_dtypes.size()),
-                [&](auto input_col_idx) {
-                  auto const& dtype = output_dtypes[input_col_idx];
+  std::for_each(
+    thrust::make_counting_iterator<size_t>(0),
+    thrust::make_counting_iterator(output_dtypes.size()),
+    [&](auto input_col_idx) {
+      auto const& dtype = output_dtypes[input_col_idx];
 
-                  // Skip if no equality literals for this column
-                  if (equality_literals[input_col_idx].empty()) { return; }
+      // Skip if no equality literals for this column
+      if (equality_literals[input_col_idx].empty()) { return; }
 
-                  // Skip if non-comparable (compound) type except string
-                  if (cudf::is_compound(dtype) and dtype.id() != cudf::type_id::STRING) { return; }
+      // Skip if non-comparable (compound) type except string
+      if (cudf::is_compound(dtype) and dtype.id() != cudf::type_id::STRING) { return; }
 
-                  // Add a column for all literals associated with an equality column
-                  for (auto const& literal : equality_literals[input_col_idx]) {
-                    columns.emplace_back(cudf::type_dispatcher<dispatch_storage_type>(
-                      dtype, bloom_filter_col, equality_col_idx, dtype, literal, stream, mr));
-                  }
-                  equality_col_idx++;
-                });
-  auto bloom_filter_membership_table = cudf::table(std::move(columns));
-
-  // Convert AST to BloomfilterAST expression with reference to bloom filter membership
-  // in above `bloom_filter_membership_table`
-  bloom_filter_expression_converter bloom_filter_expr{
-    filter.get(), num_input_columns, equality_literals};
-
-  // Filter bloom filter membership table with the BloomfilterAST expression and collect
-  // filtered row group indices
-  return collect_filtered_row_group_indices(bloom_filter_membership_table,
-                                            bloom_filter_expr.get_bloom_filter_expr(),
-                                            input_row_group_indices,
-                                            stream,
-                                            mr);
+      // Add a column for all literals associated with an equality column
+      for (auto const& literal : equality_literals[input_col_idx]) {
+        bloom_filter_membership_columns.emplace_back(cudf::type_dispatcher<dispatch_storage_type>(
+          dtype, bloom_filter_col, equality_col_idx, dtype, literal, stream, mr));
+      }
+      equality_col_idx++;
+    });
+
+  return {std::move(bloom_filter_membership_columns), std::move(equality_literals)};
 }
 
 }  // namespace cudf::io::parquet::detail
diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp
index c2aa012feb5..5ff8645b569 100644
--- a/cpp/src/io/parquet/predicate_pushdown.cpp
+++ b/cpp/src/io/parquet/predicate_pushdown.cpp
@@ -246,149 +246,6 @@ struct stats_caster {
   }
 };
 
-/**
- * @brief Converts AST expression to StatsAST for comparing with column statistics
- * This is used in row group filtering based on predicate.
- * statistics min value of a column is referenced by column_index*2
- * statistics max value of a column is referenced by column_index*2+1
- *
- */
-class stats_expression_converter : public ast::detail::expression_transformer {
- public:
-  stats_expression_converter(ast::expression const& expr, size_type const& num_columns)
-    : _num_columns{num_columns}
-  {
-    expr.accept(*this);
-  }
-
-  /**
-   * @copydoc ast::detail::expression_transformer::visit(ast::literal const& )
-   */
-  std::reference_wrapper<ast::expression const> visit(ast::literal const& expr) override
-  {
-    _stats_expr = std::reference_wrapper<ast::expression const>(expr);
-    return expr;
-  }
-
-  /**
-   * @copydoc ast::detail::expression_transformer::visit(ast::column_reference const& )
-   */
-  std::reference_wrapper<ast::expression const> visit(ast::column_reference const& expr) override
-  {
-    CUDF_EXPECTS(expr.get_table_source() == ast::table_reference::LEFT,
-                 "Statistics AST supports only left table");
-    CUDF_EXPECTS(expr.get_column_index() < _num_columns,
-                 "Column index cannot be more than number of columns in the table");
-    _stats_expr = std::reference_wrapper<ast::expression const>(expr);
-    return expr;
-  }
-
-  /**
-   * @copydoc ast::detail::expression_transformer::visit(ast::column_name_reference const& )
-   */
-  std::reference_wrapper<ast::expression const> visit(
-    ast::column_name_reference const& expr) override
-  {
-    CUDF_FAIL("Column name reference is not supported in statistics AST");
-  }
-
-  /**
-   * @copydoc ast::detail::expression_transformer::visit(ast::operation const& )
-   */
-  std::reference_wrapper<ast::expression const> visit(ast::operation const& expr) override
-  {
-    using cudf::ast::ast_operator;
-    auto const operands = expr.get_operands();
-    auto const op       = expr.get_operator();
-
-    if (auto* v = dynamic_cast<ast::column_reference const*>(&operands[0].get())) {
-      // First operand should be column reference, second should be literal.
-      CUDF_EXPECTS(cudf::ast::detail::ast_operator_arity(op) == 2,
-                   "Only binary operations are supported on column reference");
-      CUDF_EXPECTS(dynamic_cast<ast::literal const*>(&operands[1].get()) != nullptr,
-                   "Second operand of binary operation with column reference must be a literal");
-      v->accept(*this);
-      auto const col_index = v->get_column_index();
-      switch (op) {
-        /* transform to stats conditions. op(col, literal)
-        col1 == val --> vmin <= val && vmax >= val
-        col1 != val --> !(vmin == val && vmax == val)
-        col1 >  val --> vmax > val
-        col1 <  val --> vmin < val
-        col1 >= val --> vmax >= val
-        col1 <= val --> vmin <= val
-        */
-        case ast_operator::EQUAL: {
-          auto const& vmin = _col_ref.emplace_back(col_index * 2);
-          auto const& vmax = _col_ref.emplace_back(col_index * 2 + 1);
-          auto const& op1 =
-            _operators.emplace_back(ast_operator::LESS_EQUAL, vmin, operands[1].get());
-          auto const& op2 =
-            _operators.emplace_back(ast_operator::GREATER_EQUAL, vmax, operands[1].get());
-          _operators.emplace_back(ast::ast_operator::LOGICAL_AND, op1, op2);
-          break;
-        }
-        case ast_operator::NOT_EQUAL: {
-          auto const& vmin = _col_ref.emplace_back(col_index * 2);
-          auto const& vmax = _col_ref.emplace_back(col_index * 2 + 1);
-          auto const& op1  = _operators.emplace_back(ast_operator::NOT_EQUAL, vmin, vmax);
-          auto const& op2 =
-            _operators.emplace_back(ast_operator::NOT_EQUAL, vmax, operands[1].get());
-          _operators.emplace_back(ast_operator::LOGICAL_OR, op1, op2);
-          break;
-        }
-        case ast_operator::LESS: [[fallthrough]];
-        case ast_operator::LESS_EQUAL: {
-          auto const& vmin = _col_ref.emplace_back(col_index * 2);
-          _operators.emplace_back(op, vmin, operands[1].get());
-          break;
-        }
-        case ast_operator::GREATER: [[fallthrough]];
-        case ast_operator::GREATER_EQUAL: {
-          auto const& vmax = _col_ref.emplace_back(col_index * 2 + 1);
-          _operators.emplace_back(op, vmax, operands[1].get());
-          break;
-        }
-        default: CUDF_FAIL("Unsupported operation in Statistics AST");
-      };
-    } else {
-      auto new_operands = visit_operands(operands);
-      if (cudf::ast::detail::ast_operator_arity(op) == 2) {
-        _operators.emplace_back(op, new_operands.front(), new_operands.back());
-      } else if (cudf::ast::detail::ast_operator_arity(op) == 1) {
-        _operators.emplace_back(op, new_operands.front());
-      }
-    }
-    _stats_expr = std::reference_wrapper<ast::expression const>(_operators.back());
-    return std::reference_wrapper<ast::expression const>(_operators.back());
-  }
-
-  /**
-   * @brief Returns the AST to apply on Column chunk statistics.
-   *
-   * @return AST operation expression
-   */
-  [[nodiscard]] std::reference_wrapper<ast::expression const> get_stats_expr() const
-  {
-    return _stats_expr.value().get();
-  }
-
- private:
-  std::vector<std::reference_wrapper<ast::expression const>> visit_operands(
-    cudf::host_span<std::reference_wrapper<ast::expression const> const> operands)
-  {
-    std::vector<std::reference_wrapper<ast::expression const>> transformed_operands;
-    for (auto const& operand : operands) {
-      auto const new_operand = operand.get().accept(*this);
-      transformed_operands.push_back(new_operand);
-    }
-    return transformed_operands;
-  }
-  std::optional<std::reference_wrapper<ast::expression const>> _stats_expr;
-  size_type _num_columns;
-  std::list<ast::column_reference> _col_ref;
-  std::list<ast::operation> _operators;
-};
 }  // namespace
 
 std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::filter_row_groups(
@@ -399,6 +256,9 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
   std::reference_wrapper<ast::expression const> filter,
   rmm::cuda_stream_view stream) const
 {
+  // Number of input table columns
+  auto const num_input_columns = static_cast<cudf::size_type>(output_dtypes.size());
+
   auto mr = cudf::get_current_device_resource_ref();
   // Create row group indices.
   std::vector<std::vector<size_type>> all_row_group_indices;
@@ -449,34 +309,180 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
     columns.push_back(std::move(min_col));
     columns.push_back(std::move(max_col));
   }
-  auto stats_table = cudf::table(std::move(columns));
 
-  // Converts AST to StatsAST with reference to min, max columns in above `stats_table`.
-  stats_expression_converter const stats_expr{filter.get(),
-                                              static_cast<size_type>(output_dtypes.size())};
-  auto stats_ast     = stats_expr.get_stats_expr();
-  auto predicate_col = cudf::detail::compute_column(stats_table, stats_ast.get(), stream, mr);
-  auto predicate     = predicate_col->view();
-  CUDF_EXPECTS(predicate.type().id() == cudf::type_id::BOOL8,
-               "Filter expression must return a boolean column");
+  // Apply bloom filter membership to row groups for each equality predicate column, literal pair
+  // and get corresponding boolean columns.
+  auto [bloom_filter_membership_cols, equality_literals] =
+    apply_bloom_filters(sources,
+                        input_row_group_indices,
+                        output_dtypes,
+                        output_column_schemas,
+                        filter,
+                        total_row_groups,
+                        stream);
+
+  // Check if we have any bloom filter membership columns
+  auto const has_bloom_filters = not bloom_filter_membership_cols.empty();
+
+  // Append bloom filter membership columns to stats columns to get combined columns if needed
+  if (has_bloom_filters) {
+    columns.insert(columns.end(),
+                   std::make_move_iterator(bloom_filter_membership_cols.begin()),
+                   std::make_move_iterator(bloom_filter_membership_cols.end()));
+  }
 
-  // Filter stats table with StatsAST expression and collect filtered row group indices
-  auto const filtered_row_group_indices = collect_filtered_row_group_indices(
-    stats_table, stats_expr.get_stats_expr(), input_row_group_indices, stream, mr);
+  auto combined_table = cudf::table(std::move(columns));
 
-  // Span on row groups to apply bloom filtering on.
-  auto const bloom_filter_input_row_groups =
-    filtered_row_group_indices.has_value()
-      ? host_span<std::vector<size_type> const>(filtered_row_group_indices.value())
-      : input_row_group_indices;
+  // Convert AST to a CombinedAST (StatsAST and BloomfilterAST) expression
+  combined_expression_converter combined_expr{
+    filter.get(), num_input_columns, equality_literals, has_bloom_filters};
+
+  // Filter combined table with the AST expression and collect filtered row group indices
+  return collect_filtered_row_group_indices(
+    combined_table, combined_expr.get_converted_expr(), input_row_group_indices, stream, mr);
+}
+
+// Convert AST expression to a CombinedAST (StatsAST and BloomfilterAST)
+combined_expression_converter::combined_expression_converter(
+  ast::expression const& expr,
+  size_type num_input_columns,
+  std::vector<std::vector<ast::literal*>> const& equality_literals,
+  bool has_bloom_filters)
+  : _has_bloom_filters{has_bloom_filters}
+{
+  // Set the num columns and copy equality literals
+  _num_input_columns = num_input_columns;
+  _equality_literals = equality_literals;
+
+  // Compute and store columns literals offsets
+  _col_literals_offsets.reserve(_num_input_columns + 1);
+  _col_literals_offsets.emplace_back(0);
+
+  std::transform(equality_literals.begin(),
+                 equality_literals.end(),
+                 std::back_inserter(_col_literals_offsets),
+                 [&](auto const& col_literal_map) {
+                   return _col_literals_offsets.back() +
+                          static_cast<cudf::size_type>(col_literal_map.size());
+                 });
+
+  // Add this visitor
+  expr.accept(*this);
+}
+
+std::reference_wrapper<ast::expression const> combined_expression_converter::visit(
+  ast::literal const& expr)
+{
+  _converted_expr = std::reference_wrapper<ast::expression const>(expr);
+  return expr;
+}
+
+std::reference_wrapper<ast::expression const> combined_expression_converter::visit(
+  ast::column_reference const& expr)
+{
+  CUDF_EXPECTS(expr.get_table_source() == ast::table_reference::LEFT,
+               "CombinedAST (Stats and Bloomfilter) supports only left table");
+  CUDF_EXPECTS(expr.get_column_index() < _num_input_columns,
+               "Column index cannot be more than number of columns in the table");
+  _converted_expr = std::reference_wrapper<ast::expression const>(expr);
+  return expr;
+}
 
-  // Apply bloom filtering on the bloom filter input row groups
-  auto const bloom_filtered_row_groups = apply_bloom_filters(
-    sources, bloom_filter_input_row_groups, output_dtypes, output_column_schemas, filter, stream);
+std::reference_wrapper<ast::expression const> combined_expression_converter::visit(
+  ast::operation const& expr)
+{
+  using cudf::ast::ast_operator;
+  auto const operands = expr.get_operands();
+  auto const op       = expr.get_operator();
+
+  if (auto* v = dynamic_cast<ast::column_reference const*>(&operands[0].get())) {
+    // First operand should be column reference, second should be literal.
+    CUDF_EXPECTS(cudf::ast::detail::ast_operator_arity(op) == 2,
+                 "Only binary operations are supported on column reference");
+    CUDF_EXPECTS(dynamic_cast<ast::literal const*>(&operands[1].get()) != nullptr,
+                 "Second operand of binary operation with column reference must be a literal");
+    v->accept(*this);
+    auto const col_index = v->get_column_index();
+    switch (op) {
+      /* transform to stats conditions. op(col, literal)
+      col1 == val --> vmin <= val && vmax >= val && bloom_filter[col1, val].contains(val)
+      col1 != val --> !(vmin == val && vmax == val)
+      col1 >  val --> vmax > val
+      col1 <  val --> vmin < val
+      col1 >= val --> vmax >= val
+      col1 <= val --> vmin <= val
+      */
+      case ast_operator::EQUAL: {
+        auto const& vmin = _col_ref.emplace_back(col_index * 2);
+        auto const& vmax = _col_ref.emplace_back(col_index * 2 + 1);
+        auto const& op1 =
+          _operators.emplace_back(ast_operator::LESS_EQUAL, vmin, operands[1].get());
+        auto const& op2 =
+          _operators.emplace_back(ast_operator::GREATER_EQUAL, vmax, operands[1].get());
+        _operators.emplace_back(ast::ast_operator::LOGICAL_AND, op1, op2);
+
+        // Use this input column's bloom filter membership column as well if available.
+        if (_has_bloom_filters) {
+          auto const& equality_literals = _equality_literals[col_index];
+          auto col_literal_offset = (_num_input_columns * 2) + _col_literals_offsets[col_index];
+          auto const literal_iter =
+            std::find(equality_literals.cbegin(),
+                      equality_literals.cend(),
+                      dynamic_cast<ast::literal const*>(&operands[1].get()));
+          CUDF_EXPECTS(literal_iter != equality_literals.end(), "Could not find the literal ptr");
+          col_literal_offset += std::distance(equality_literals.cbegin(), literal_iter);
+
+          // Evaluate boolean is_true(value) expression as NOT(NOT(value))
+          auto const& value = _col_ref.emplace_back(col_literal_offset);
+          auto const& op    = _operators.emplace_back(ast_operator::NOT, value);
+          _operators.emplace_back(ast_operator::NOT, op);
+        }
+        break;
+      }
+      case ast_operator::NOT_EQUAL: {
+        auto const& vmin = _col_ref.emplace_back(col_index * 2);
+        auto const& vmax = _col_ref.emplace_back(col_index * 2 + 1);
+        auto const& op1  = _operators.emplace_back(ast_operator::NOT_EQUAL, vmin, vmax);
+        auto const& op2 = _operators.emplace_back(ast_operator::NOT_EQUAL, vmax, operands[1].get());
+        _operators.emplace_back(ast_operator::LOGICAL_OR, op1, op2);
+        break;
+      }
+      case ast_operator::LESS: [[fallthrough]];
+      case ast_operator::LESS_EQUAL: {
+        auto const& vmin = _col_ref.emplace_back(col_index * 2);
+        _operators.emplace_back(op, vmin, operands[1].get());
+        break;
+      }
+      case ast_operator::GREATER: [[fallthrough]];
+      case ast_operator::GREATER_EQUAL: {
+        auto const& vmax = _col_ref.emplace_back(col_index * 2 + 1);
+        _operators.emplace_back(op, vmax, operands[1].get());
+        break;
+      }
+      default: CUDF_FAIL("Unsupported operation in CombinedAST");
+    };
+  } else {
+    auto new_operands = visit_operands(operands);
+    if (cudf::ast::detail::ast_operator_arity(op) == 2) {
+      _operators.emplace_back(op, new_operands.front(), new_operands.back());
+    } else if (cudf::ast::detail::ast_operator_arity(op) == 1) {
+      _operators.emplace_back(op, new_operands.front());
+    }
+  }
+  _converted_expr = std::reference_wrapper<ast::expression const>(_operators.back());
+  return std::reference_wrapper<ast::expression const>(_operators.back());
+}
 
-  // Return bloom filtered row group indices iff collected
-  return bloom_filtered_row_groups.has_value() ? bloom_filtered_row_groups
-                                               : filtered_row_group_indices;
+std::vector<std::reference_wrapper<ast::expression const>>
+combined_expression_converter::visit_operands(
+  cudf::host_span<std::reference_wrapper<ast::expression const> const> operands)
+{
+  std::vector<std::reference_wrapper<ast::expression const>> transformed_operands;
+  for (auto const& operand : operands) {
+    auto const new_operand = operand.get().accept(*this);
+    transformed_operands.push_back(new_operand);
+  }
+  return transformed_operands;
 }
 
 // convert column named expression to column index reference expression
@@ -497,14 +503,14 @@ named_to_reference_converter::named_to_reference_converter(
 std::reference_wrapper<ast::expression const> named_to_reference_converter::visit(
   ast::literal const& expr)
 {
-  _stats_expr = std::reference_wrapper<ast::expression const>(expr);
+  _converted_expr = std::reference_wrapper<ast::expression const>(expr);
   return expr;
 }
 
 std::reference_wrapper<ast::expression const> named_to_reference_converter::visit(
   ast::column_reference const& expr)
 {
-  _stats_expr = std::reference_wrapper<ast::expression const>(expr);
+  _converted_expr = std::reference_wrapper<ast::expression const>(expr);
   return expr;
 }
 
@@ -518,7 +524,7 @@ std::reference_wrapper<ast::expression const> named_to_reference_converter::visi
   }
   auto col_index = col_index_it->second;
   _col_ref.emplace_back(col_index);
-  _stats_expr = std::reference_wrapper<ast::expression const>(_col_ref.back());
+  _converted_expr = std::reference_wrapper<ast::expression const>(_col_ref.back());
   return std::reference_wrapper<ast::expression const>(_col_ref.back());
 }
 
@@ -533,7 +539,7 @@ std::reference_wrapper<ast::expression const> named_to_reference_converter::visi
   } else if (cudf::ast::detail::ast_operator_arity(op) == 1) {
     _operators.emplace_back(op, new_operands.front());
   }
-  _stats_expr = std::reference_wrapper<ast::expression const>(_operators.back());
+  _converted_expr = std::reference_wrapper<ast::expression const>(_operators.back());
   return std::reference_wrapper<ast::expression const>(_operators.back());
 }
 
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index 2e3e6c6b6dd..859d9aadc94 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -372,24 +372,28 @@ class aggregate_reader_metadata {
     rmm::cuda_stream_view stream) const;
 
   /**
-   * @brief Filters the row groups using bloom filters
+   * @brief Computes bloom filter membership for the row groups based on predicate filter
    *
    * @param sources Dataset sources
    * @param row_group_indices Lists of input row groups to read, one per source
    * @param output_dtypes Datatypes of of output columns
    * @param output_column_schemas schema indices of output columns
    * @param filter AST expression to filter row groups based on bloom filter membership
+   * @param total_row_groups Total number of row groups across all input sources.
    * @param stream CUDA stream used for device memory operations and kernel launches
    *
-   * @return Filtered row group indices, if any is filtered
+   * @return A pair of list of bloom filter membership columns and a list of pointers to (equality
+   * predicate) literals associated with each input column.
    */
-  [[nodiscard]] std::optional<std::vector<std::vector<size_type>>> apply_bloom_filters(
-    host_span<std::unique_ptr<datasource> const> sources,
-    host_span<std::vector<size_type> const> input_row_group_indices,
-    host_span<data_type const> output_dtypes,
-    host_span<int const> output_column_schemas,
-    std::reference_wrapper<ast::expression const> filter,
-    rmm::cuda_stream_view stream) const;
+  [[nodiscard]] std::pair<std::vector<std::unique_ptr<cudf::column>>,
+                          std::vector<std::vector<ast::literal*>>>
+  apply_bloom_filters(host_span<std::unique_ptr<datasource> const> sources,
+                      host_span<std::vector<size_type> const> input_row_group_indices,
+                      host_span<data_type const> output_dtypes,
+                      host_span<int const> output_column_schemas,
+                      std::reference_wrapper<ast::expression const> filter,
+                      size_t total_row_groups,
+                      rmm::cuda_stream_view stream) const;
 
   /**
    * @brief Filters and reduces down to a selection of row groups
@@ -441,6 +445,71 @@ class aggregate_reader_metadata {
                  type_id timestamp_type_id);
 };
 
+/**
+ * @brief Converts AST expression to a CombinedAST (StatsAST and BloomfilterAST) for comparing with
+ * column statistics and testing bloom filter membership altogether. This is used in row group
+ * filtering based on predicate.
+ *
+ * statistics min value of a column is referenced by column_index*2
+ * statistics max value of a column is referenced by column_index*2+1
+ * bloom filter membership of each (column, literal) pair is appended to the end of stats.
+ *
+ */
+class combined_expression_converter : public ast::detail::expression_transformer {
+ public:
+  combined_expression_converter() = default;
+  combined_expression_converter(ast::expression const& expr,
+                                size_type num_input_columns,
+                                std::vector<std::vector<ast::literal*>> const& equality_literals,
+                                bool has_bloom_filters);
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::literal const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(ast::literal const& expr) override;
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::column_reference const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(ast::column_reference const& expr) override;
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::column_name_reference const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(
+    ast::column_name_reference const& expr) override
+  {
+    CUDF_FAIL("Column name reference is not supported in CombinedAST");
+  }
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::operation const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(ast::operation const& expr) override;
+  /**
+   * @brief Returns the AST to apply Column chunk statistics and bloom filter membership
+   *
+   * @return AST operation expression
+   */
+  [[nodiscard]] std::reference_wrapper<ast::expression const> get_converted_expr() const
+  {
+    return _converted_expr.value().get();
+  }
+
+ protected:
+  std::vector<std::reference_wrapper<ast::expression const>> visit_operands(
+    cudf::host_span<std::reference_wrapper<ast::expression const> const> operands);
+
+  std::optional<std::reference_wrapper<ast::expression const>> _converted_expr;
+  size_type _num_columns;
+  std::list<ast::column_reference> _col_ref;
+  std::list<ast::operation> _operators;
+  std::vector<std::vector<ast::literal*>> _equality_literals;
+  size_type _num_input_columns;
+
+ private:
+  bool _has_bloom_filters;
+  std::vector<cudf::size_type> _col_literals_offsets;
+};
+
 /**
  * @brief Converts named columns to index reference columns
  *
@@ -469,14 +538,14 @@ class named_to_reference_converter : public ast::detail::expression_transformer
   std::reference_wrapper<ast::expression const> visit(ast::operation const& expr) override;
 
   /**
-   * @brief Returns the AST to apply on Column chunk statistics
+   * @brief Returns the converted AST expression
    *
    * @return AST operation expression
    */
   [[nodiscard]] std::optional<std::reference_wrapper<ast::expression const>> get_converted_expr()
     const
   {
-    return _stats_expr;
+    return _converted_expr;
   }
 
  private:
@@ -484,7 +553,7 @@ class named_to_reference_converter : public ast::detail::expression_transformer
     cudf::host_span<std::reference_wrapper<ast::expression const> const> operands);
 
   std::unordered_map<std::string, size_type> column_name_to_index;
-  std::optional<std::reference_wrapper<ast::expression const>> _stats_expr;
+  std::optional<std::reference_wrapper<ast::expression const>> _converted_expr;
   // Using std::list or std::deque to avoid reference invalidation
   std::list<ast::column_reference> _col_ref;
   std::list<ast::operation> _operators;
diff --git a/python/cudf/cudf/tests/data/parquet/mixed_card_ndv_100_chunk_stats.snappy.parquet b/python/cudf/cudf/tests/data/parquet/mixed_card_ndv_100_chunk_stats.snappy.parquet
index e1dad1ef8b59edea48aa8c5c41029d9a70babe8f..7dc2cee21ae5e3414f4f23edd0dc31ad03a3976c 100644
GIT binary patch
literal 37036
zcmeI530xEBzV{PIFkuG?0-^?lh>D6x6%{230m8l`P#5-1Kz5PZ9;Ax678R{pYjMZ5
zYHh1MwFj;HzErEN_Sm|#cC}VdwWsZQf4>PJR=eGM?tAZjU-R*2GLy_RGtd7w4>RBY
zGtWe8Vh1WDidzcBk<Q_YLt=%<RwTM->SHPriOSPsi$f+QhNdKmE#0EZ@)ANzQYuQK
zFp(3HT^yJ_J|rd`6D2{TvMV%^d4<84h^|b}hzin#M`)y$%DBLY{D6eY!fbp|Se=p(
z86KDuJ4tM*EG^Uql;q}yM@pTQ0foicC1El8QBq%JN>E8)RdPhuBx$i*dQ4_?W?FHi
zHec-P7F;l@G`hT`xHthtg$Cz`Raa&OWmaJ#M;lXE9haRwX%tpiQ8_-cJifF#8DGQ(
z=cQM~#+PPiVq&~5Av_{XJ24;#Yfnr`3(pBl%8ZfDc1sT*ACRoc3kwSsJG+$@r{tAq
z6o%^xu}DbTgk*hGT6A$4*D@ioygV%-Kd}H4!NJM-)!K~QQXM8H=1vSwjxULiEMm!d
z>5+L6MZr<hrEa>|qJ+GNlH|Y~lw6q?Ss0ug6A_z;t<20Usm_e87$1hkC&UM(WfbP8
zPm0GxU|>p$t|BR-RF8>@>hQ|aw9L$jxhObUn^>(0$w`WH-|kkJ5tEmqjVg<-5IZZg
zV<)7S2B)OwO8Y3|^9u?JCKgteNsE=`L7Jreq>%K9QcJh|%IdVZu=K3RDAZ(Fc6PC@
zydWpKl55uo#a3odh#a4XiHPEfy1b-hUGW60FfX8DQgY^~@geS7w@htNRc`U9s)^xP
zp<Ww1DJCSKAPohV#KvWp>k5M>YO#yjkh1L1xS()t2^NpY3@wOA3rjDQe(k0&tE|k(
zNQnrK#o|>VF<BXju^Bn;(QYNBq1vp7!icB<e36libw{Rassinlx{8VUA)&!J0kA=i
zZd9;NQ&5soD(>T!6BMnF)<wogV&j!11(lV#K_#QA+zZ?yDg&c4<HL&6;!spUR(MwQ
zq=_YIsFR?|knD`=^y)}yymCTHNknj=J~9MOi%rYONhr(<2y`E-%+RH1@-wnZXxZxG
z3|&dSHY3K}M;RA8F>X?LNNIH7d}U>Id0uY3K0Q9rOBpmFCO#x9B`RIIPZ>6;A}+R~
zT2~pEs|?DIk1q-+uZqC@4E=<H?C^qw(m)ess6HYst2n$m*S%g@T3Qw~zPL1Tg4EY7
zGqxb0NM8_DJzji9sm%?F$%)F*CAvo|ar9JWrH{%A%Q8|%hvx_6=<-J8OVizQ3Ioat
zqaw<)$`MFiR76r<TyQ~R2<l=&T5x=EW^r~})?Byvpxlh~?2L+(N<<|&t*AU!S6&vM
zg$U;qm1P$cm1@IaHf4TTWqR(YN%2)U2IHfmC&Z-%Ch7w#l|dyz+IW3YWS09SWkRNA
zQbu}wb)vh2+o;_9@G@O&Y+|)I$Spl#R7Gw@xkg`#VzWwebF|e}y5M3I8#iiHVOn8X
zW`;CKS(K7FAv!%NG$ha3c~o|K1VS9>e#tF1A|$LhVPZ&bEOsM1HYRamWK3)>+Z9b=
zVMtC;eq>G{<6E5&q^*ul3zIf0wdI=9;_>=~I8<$NR9e=Al=MtZ;M>mFiJ<JNQIqoK
zDl5|~#%t2bLISWqg_`{0l>DIh#A!c_)+WW4==0*UwApOaCMIelV`IiwmR2f6icgFb
zpBs598jKaz3KNBiNVH9SYip-LH8rVf4+qQosp)%ieY-c*XKL3c^<O+Y``w#WBbyp>
zb$ymZHaF()&)+q6>*9i-jTeh{E-O0t#r@}6nu_(FPA?o<U3$1+*ej=+%R@J(yn10%
z<<YOI|8`|-mAOo2GPU;O8oh`8?7FMs8G2RY%<Hv>a|bV*`>C<%jG)!?Z%z$epSWq!
z7t&dWvv(~0s_y8`%D0z))5+X)`o5Ll)`$0b@z~n$<a0vTy|>}+%;WiQUfS}#ndPj5
zXuh|aDZZA5E8Z|P-xs8kP9nKjWG3$<5t&-ZMExNJG!{yLdO=Dk0_qA$pipQOWCsm_
zVjyp5G^BwBK!K1iq=sA}V`w<!0eL}#p#UftvWL1u-Jsr(4U`CVfrdg)L1|DJ)DKF9
z20>3laZnFvB-9h~hvK1OkSC;voS|eW5=w_gKq@E&(n3Da7|02Vg5*#p)E5#%4$wHr
z0t$glAWKLFNg*T18cMQ|*@#60E##ukn2LtnpdbsGp9}27m!IKH^al*(x-Hem*-EeT
zUJ>uv<(TWBQw6@=tUgBYy_;<6eU_N3*1T|YYM-iD<8%4NrCU?B)ZVy0Wq;;tM>7LA
z<`oP%92`6Abnz-@&Gd`kT8{Yp_3!@rc6pyGE*`TZOy;<3%WZU?7vi3JKRrEuW!?O{
zJ=0RP>VpeYL?*`8n;LC=US5)89jeiFlb($lwr0cft)HjopG{tH_{KShqt1~R#;m+`
zY<o(;xP)0|r<@*VsO~hBiiTo^(G)ZXE1lJ12C?E;X$&H&N8}DMz?~oli$T#rG$VtW
z0nsEb5KU+d#X_zSgG0m8sH}1Zk_Mz<89<tNAVee5D1JhaLJ%Z|Ujs4xv|~8LfYH*l
z9qru>Vu*QY(7v>hEkt`dLbN_@POH+Iv<YoW8`Ik65Dynx&kE`T(V9HGXkFTE6hzC>
z_B_;hc+hsVAT3F&@o=KWB~Sni^;D~o{QtP29<)$0&o1EyR$eR~W`43$xs0vJ`t)HD
zma{}N=fzeyZM4{Uy?Rgj_T+=wji(Ei%iZP=y{y~0%yQ3}ul(K)Ioau-;^&92=<i$J
zoV~zgo6M_wUvsy*8-G1F_V8#go5@lOJNNO23%nO~?f&llsc&T-jE~m_l)A;rdp>n7
z;_0{z?|!T=9X&LlKJj(ih&>x^jy7#=e5=;7B_sLO7d%fk=8f3_Lp7Kw&ZC9eZfKzn
zNhQ5$sLnJLjl^o>5y&c|Nm#`+3agn0VxVafRu#?0aIyuV>DbE9a11wF28M)&qj7j-
zGt>+lLqStA)U0}%i(z7zX=;X@#-q{L3Neff6<Z&g)dQkk7-|(n<Iy^_5yB@JlSZY@
z+#s5jR-}>Hx-rx=ZW@GEMQF)rPZ}Nu7R)~o?>vZTJKBpjNr$W<+KUHQPbdYVrD$ay
zL~I>tFWS_F2ZM9spEl9Hfh#=vEHX1$5S?jjv^VgzkIR+IUvM}6V5)AFt}foYn`)gt
za7yTUt;vy@=R$W{4_NH+M(ttmSC`C8eC=|vG|Y14ho_DF>er6CRp{;cft5qN`)Hf#
z#SUKt+P&^jzgT{;XkEHhZb7$-L#spgM1Qm>e6hM|{>_5pGZuWe*!Pu&44IR~q1979
z^9jA45P1H>bH)P~Hz>~EelfseYk2K=#RoD8OjKj0SSAZsY&DpuMQSc`yCV{d&0C%y
zAQj8ZMGdEn#WGn-;?Gh{?ARxfTFZWXNi3B~F02!GvKG}GGcgj&Wi8T+QU{rO%NKHM
ziMOfLS61VD75}SSvhe$s;lXm5q)VLCLsm1jyV&1cB$AJi%49Y7he(yOn$R)QdYRhk
z5ax)cFF-LZxmD6=S&i9tskMz*rjDN>HIvoc`azl`Ytc=WD<vP_m8xaxF$b`)$bX}>
zS=REo3yZV+M(!aw`3(M(MRMAx0)^EqTFlMq<|(a`wJg7ZWz=Ee+}0^?N%b<(%1{(I
zyMWtqE&$sh(tpOE{NpU=ymAhUin_kZ!c=)!NHn+zrO*7Ho4Rp2OVL_kuS82MxSN*t
z@+3)0I)DA{VX2p_<v>6Dy24SqQ`S;_Tka(}nU6(UBKF|_8jVugBvZfXfd$q7vgYEw
zk7KV}lnq?|)7_|Ub=9+Cu|}p|;DfJg;+CRFk!`iOi@B)gt=ZhZ(eJaolGm|oH3QaS
zxt8z7Vt1NtQQdQ%X8qgD!b0i^YPo~tqZ(<dtYzVPEFvnngc3#1C8F*`8Lx2VA77KI
z{aVHim(b$sHCv4M{s;d03XP?x^{;Puc2k-Xr(OrYlNYO3?AQ6YE)0Ls;>y%o&)7bq
zw5L*^(k@tJw#w=4)EP;^l}k>?uUuL<rOCX=P13*D>7kWY4zIp>Yfj?2agwS}G}=9l
zQ4WX92kcwfQgzLuoBl$`*%=Y_%iN-NeVH`*Z!gbYl4oD+z4q1K7yAvG-FW<>(})#Y
z*A!WwQ#<=N*vVcVIrPPtLfzej%?noDnOW{*4xhJ36-Urmw)*^v(VcN(C+uQ>s0)+?
z@#Mo38Udw2!O+tX|AvG>(NHgle@lWOSI7qH3JroXA!o<|(m-P%D`+f~0`-KtL&i`j
z)E81i{h*Q15Xc=G0F8q>L%pHlPz>Y-g+qfOoLCDlZ~Wg0iieV+RLC0ALc<^#)Ca;b
zCmId02^$JYp*Y9`vVhVd#-8W%pcSG3s2ik*<d70FgCd~}C=3dOq97d<0a-%6kP3>0
z{+NA4&Q|(sE=!{Om>iY%Jj65iJw5N&7`+m$fqg>P9+$fxSsmZke$BL)U6HREd#dIs
z`m5fboxT2a{@}fZx_8B;!!FJ35_4BF^8J(hjZ5`)SBy`2-|C}~8{M(Cv{)hDmV3(K
zh2C;+`Rv}E=UpG*qwBxG{6_QH)k9zQ|M0BW2e)c>CR&G@1`d63mED@fp#ytgvs=76
zar6Gm3#XNyuy#z0Ub^eKYBrN5ikT+iiWWmNSz~<XFXG`wBGD!>sv7Snu)F;b*CEgx
zOgCX#hWB86e;=QBV*WLV_8N`%r}5ph_^vCo5}yy@eKXz{LR0aZf8qT+es>tk!e@qN
z8nhYH{qfr(s1~1x;oS}2@4&kn-|O)?9P^jq^A%_rzsLJ6ybr|udH7xdjl$=Jm_G!c
zEAd@2-itBa3G-9&z830*&#yt-@cnY=F6P<dJrBR#j?WXJgP2~8_j=5G3cr;@S1|8s
zXgfrk9m02E`0NkSE-iQu!n``XXW{oN@cCQJx4`>cOsC+Thr>;Le;k?zt%jU1e+}mE
z!skQy-5;}8hl|a%+deM$>k+MIv(zg-^!4=DM-NB}AH3>Z!I06BZ(hAS**`Vf*Uf%T
zaAxeT%)u{5<;D+NlW23k@8FG>7wx=&3&UTz*mUX|dGI^&G+ocw!{ypF@qH7I-mTrA
zIVk0L<-6C*hmSq^y|Kx(fb`Q<I@Q9k?6dc$2Ca$9SETJuf9-?98MAO5%ht(Uam2ix
z6*igN>0vzM#Yp)TXIHh=cV9b<EbFR%HYMA{a(#F8r2VOjS9Wn#TTa}q)E$<n5A^aM
zdalq>J@H=4_*h3*^`bdAP)c0XQQy@qy7{@iTHkZ#y<Lv~^k35?ll-f~TAe8N8eMj!
zr@B{G&Du`WZuzHHzoWf3U9KM4RHhvy>Z$fgwCaBOzKwe7^nYdfY!j(Z-BHgSm?Bqy
zVY<U}h^MRi%z_Yc*#%SewO1>j4{@+j-?^}8>N8y()i>5Itz7J^RF_1Xj2QW9XLZ9J
zb<H-L&;2bI4xY5}D|_{+f$q^UmFNBQUrv5{vj5lqrFAy@hnD~BUsH8v+ljZks#E`A
ze)ajyChBEd^pzgVx~lIrS34Ya{lVY7N4MC^@7?zI`0>PsB_AL6zcI1zx}n3J)k~9{
zdNlWUQBMxoUDh&RtR9v5!uIiEW3}?bi?2k#+~WV!a{ITEk2<R3wMQ2RTglX_pzAK7
zH}3l1xW3u<$G<zOQ#CJ53;d~zx-_nSr1rXvde8f%%L|^l=f8U5*fT%Qa#Sz+skfJQ
zn7umg<wItlMcb&i&+FE5JLw01>&ShJRxEH;$5tM{Srp)+ZXVI}VdINk)gM`W*T4P?
z)axv_GdBizQUB{NBlejtG*e$W@9MPj<=g&ilC(=-i*!({W`7^~!a+Orss)!eb*r#Z
z-v}v64*j5~+T{G82GtRzT76*iKc5?S+yBM0!)JKD>Y`T1pEVy{-RNI_{ij!qt(?^L
z;$8i(4VA0k-eOesFRyND-`#F5KbrScx5OR#Xy0IkdcaFf3-wdGtE1m5+M~?+*#DsE
znet`ZoYYtUv3LIF6Sw`piaPxKvrpNobtTHZE4G-bhkgHD;>^rX{i}>-P2P32o4S5e
z)Mc9sU->VJD2&{_P@=Xh^8Y#ixi9>0{r%HkZ$Im#KJeAbQ|s+y>eSUnue>nklK<4$
zIo~9YJMC}uvWt~F;t=((n$La?uv14jIhI~@{+oYNg#C^iB`5r=b-V6vU+<(I=JSmI
zj4lfG<`>W3zq9<Vf7159nQr=Crat76=9%5+j=yqQm%p78nW$50e>5>Svr-?po@KeE
zSgam-tACd1OaJmWx^ypluCtN)PappOgIUv)RKb%}!IM<MlT^WzRKfqsQ~^NTM-PEG
z4}v%gf;eNqBf_gph`>n;5x^0C5z-N05onQv5~7jB0yYVti!hE5kMN36tPQvkcoE={
zffC-4zY>TM@DZdDx)EX#Xc4Fpypg>U1QM(fXc5E_1`^g0@)3XqK!9pM^PNF`iOooS
ziOWVqM1;hGM0>=B#CF7eIw%$*I!l9`AR@aV5b+~1+6agUk@$_ckf@GG&=DdbCfXxj
zBq}6c^o06AM0iAv#D&Cnt{}R+0_KZX;C%hj^MJM#L3mKyh2mk$t#WP7)T?{O_RbhK
zCAvAf&#IJdDO<XPcV1AKZI*J}{<H9+{?VddUZYF9U!ME^yX$dnQ2hF0=g7VKFN(h~
zpRs<%irnyS^Fl7`+`o{Nhwdx&ZaFk^=A~~kJ$EmzT|GB3|1G-{7Y8kIxbE3Mcje;V
z_7Mj>222Ssku<Nc8@Og#^T7@4=IyY3TIb}oGP+ymra7Pd(6Yq?mjRC$$$>_a&`1n6
zgUKMVib*gTWSWGAp?PQ`RynCEsVzfCx=9n!1mmE#>STBsQih3DP6N?=3=c!bs%Kak
zYMKO9FBq04qFJIL8j(h#v1v$#mF9yrU?Mx1NQ@~4o%W|e7-Vu~2A(XJL8h%UAX?NI
zqD5(Ua$FuBHc)>^3y~4i9Dxw6P6N_(w7v$CK{OjJO~cV-WVt*PIzu!xjRX_>wb5L)
zV58qOl3J~Fur{qTc3qL=<urG?v2AOjv3I5qul@3rvL?NLhhu`?{j6N=xFXi%bjX_I
zZ7G%~CF$Z_YFuRAa&W{2;heN*UPfXw@`lToRl94x`CfEGGGt7H>z9soUg`7R8`M2V
z>UgG9Z{!ks#@Kyyy0z`)xp~{S)kl0fXx)@|R-U=Ja(jrwnAkaAJU`i~hkD7i_uU%m
zjQgys_DYJ_(zoY%uQxI+-4frJwW1P6+G?uUf);750aq-RN(RwL-fg)iRuKcmpz)Yv
zwb4`zfgMES&<qR#4259oTa$G>+F98Q2m{N2(Gm<UEz009u(S^YzyP+j6bvkFN*j)a
zXj@u_fi;2xAO@BJWuR$4T9js>JsG%kh$f<8)DR6sbFpRO;Xq@twHO2SgoZ++A=;FO
z0j*8z^Kd|0CzykW04*E_(VSw4rla+FIPkE-Vdh7k#uwQgU%%b*i0sTe>9kBv)^>7p
z1>ag^wz77Hwf9nsX=jtGMm{h0aI>B5u=-5PYTp&sy=NX;y?s+G^3(~#Vp0cQ3}3nO
zT*1`j>u-2p5v^YK^^RHJdM@g|F4L>f=bcyTY?sPQox2$i6eV_lzG<z(wz6(Wddv{7
z?()I!54a_st@W3h=gn~Q*Tk&ZW0UV1>Tdh`k5cJ+o9}XSQ@kT`EZz(q8P>;RyLx8e
zv@@M|)HUj2VVF~<iff(16&nnOX_lJT%z2t=0MdD;0j4iN8o)rLW#&NDMx6T4S%O3W
z7(YP#;39JKWhLa&pY8^L2Cvo=fr|%#J?_{?k`5H^YmQWbSnNo64LFWm0U&x<IH5MF
zv>t96K_0D}%0g|ckxu|M2W|(KM{&T{dYSsGMbcb>l&fXPKVV%S)!;u6aBRWM@8!M(
z`dHn8k(dh}??E(Ast&?0Q-}>If(twG<;LmqXvsg$;uEp~NkUFxkdP(tU@n6z93Ct^
zBp`cig4-QzF$lY_L~DiZLec?P{@ue^+Nc6_A883>Es$=&!e{<Y#*dsuDr`HDxd0>p
z8YG8T0?#8Af#s0<0QpC5LrsDYJ`bdiZAP*I6@s*Yhpc8>6hCJhbJLM7s1foEzOCs3
zL&5~yUapoc@G+9gB`ZUjiU8D)#=-5*^{etwZo?^j6!JF$>sQKJetbz@?AuI~2WW^4
z!S8!n=((ZY3NO!Y_3}}1+~Hi?u93Yy*)v(~a=Jd=`{n3`fuZjAq7yfT9lcw+Cw->P
zXD&yNS-YgHOdNi($aq=rPjlnT7j%2I=Fr{vkta`@n469fzv~rfcjmeMjt6!Qb6wDP
zP3(?K*8NRS*4(Tan!SDPcQwsd`p@m<v&QUmkIssa25)QEBk{JyzC*1>?k&tcRF$}~
zXUMc+(&u7sPHkEeRP*BD85@ibSo5!_RIwC|-)e)G4;kGF7JFkKiN}e$iNoC?;(TIs
zVr^n;Vty?|_Q;bAFUS^RI)Lch86sxy0l7lN=*08H|Ex<gT4HcGS-|&W@y-|10mSM|
z2lzqVA*LKMA*L1BoG^Vb5K=>)5K|0HKlFt9LB#G%At)d=LrD<vydA_817qj|F+HJy
zi1r<!K#1uBdx%(`=?bPDTp*%-U{sL|QbMs1`K%E%3hECHfQbK{paAH%o4oc8KDId7
zGHM9-P)y%nya#_Hjn*x=l{>P@I>5zgUg+A+ru$l!#r8R8I*kN&afa=J<GBL^zN+1J
zSyyM#KV!+Y$gP_FPwlzp^OiI%$LUu2rsV@%^qS{d4rF&OKV53#QoATuWcRLh%*4Kn
z>|U<jTl&}C*-lqu-tb-15K<epS~oXkdO*RXc(0iL*}CBIiOV)5eLL#Vh;hxQ)}0OW
zYg((yI8#5?4K{g#^q(O8CrJMZ(tm>VpCJ8zfA`TRNdF1ae}eR%ApIvu|9>UYZ!uH+
z1J{r{4cCxYq>@Aev}6J_VysYzh>7HsIE)C4c#5o%2#c5t$VdQdL|7!K#90!EsEJsK
z7>dY>Y?36ED2o7&7|abKgd?*grXtTICL;kRx+3c&ZX*^Wup?q40viMohY_I>dl^H7
zc*JdBo&v!I&=VLb@fdk1Q5|s}(HGGi5g8Gi4k9)qASB)+FeDlyT_#E+vLhlRX(sX`
z$0eR4f+I>B2@w$zr4g|aFai$(CJqBkbj1__UNl5tN0JK|=*O#6zIcVo*B`v%Y`dkz
zDqOV!9kxwR9;|8Yk+Z!iR(5WKI%%2rrbV-E*X|G6?$|GIyLG;O{a1DG)|U?3GxK$H
z{aJt1%E4~A&&so2Y09-TC0FOg`b0N`xc7V0`QGA)oUQVz6Z)PRpSaa-v5e`xVB+bg
z{K8bCL2DA%_0yc~9I?r7gPlAzVcRnAvv(&Ng%8_faocToV3mJ{iD}E&=_isG^*Yo2
z4N}=(-csUCQ`xrReO4ZW#b7W9eWA9>qv=@5i4cQAqtPS-AXYeyh{_dsDa}YD&~P*r
zgVh@%Q)SR-Fq(>nHHT;*nuDfhC}<v<Zv;d`&<r#cSuIV*z|yn~84XOMFpOla3@Hsl
zBhy?o0!_n%Vi-h|&=fR3&Dj~!KqSyE5KWc=@gSj5dEn5PG<^?<CXzr_5G~XRN``na
z@_>WsVX&?+7%hv#!*8&`M*>RuqlU6+y`?10$3t;+|CGaOpScz}du~>F2))M~-4@P2
zJa6d0==F6+wk9XbHZAIVx3(pE>Eca;UOVOa`gGi6B-g!ldFK0llP1sU;pK7ZuxeJ9
z{e%40)UOMSk!8w<9LSJ)X$Q|ga-rdDa-E+t`?a;jBUii_9A#gjpR#2A>A-|rrW^Y_
zC0~8H=KS#)s<+bvYL&{mOG#cyJ$(Lo*4wvhlWS(mwNxSu!yN$aowp?#8p?=<VgOi?
z3@nU;N?}ruwqe`EW1cobbqQ6;u&^p=6IQtvqD^Q4hTZ~V^*ca4At^+=(mo71LvIYx
zIt(R4Ok2`2v<E}P@Y2o<lQ%@0(5eX#ZN)Z@?FntlaMQj#40t#wq2Um%NK4X!v@LBo
z1ftz}xX{vO5G_Ny(PlgZ*xu68v?~uKT8D=KZN@_?1oDSyKQTn>^@3<?Sk8}3jxRDk
zzJ9M&GHFHsOgffC_c5MzwS*ij^5E5bHCm(k<~Y%8y`xo=?&j$5`3o|xY1TOP*)#K8
z>F%VhiJQ(iI3rioFD>A5@zA-UZ;t=C^6l;|--peq*{ED)e@{N$XlzYVqv!0JQ`>5H
zxJ88?uW1_XJ?{8|Z=#KSUs373zEj$a^~@4E`MI0zJhgt{?4PIhzFxb2$*s``FNcIW
zM65q6Z_d9{zErm6snov)85>MAv*R5Ap5XN4f}$EgXJCHPejw=Y#-i81tmJhffAr-C
znU0?!wrcB(-iqxb_Q>@F+~{<EcqITg2tGN!p$k25xLzjOEtVIPorB|}mpza-I?u~w
zEf>}qC^;AEHxQs5efWLNd3%A>MFN~H6S%j5jib9ey0`ae>&*`Ejl$M!K>@hGfC&h6
zj5nkq93;M1QC8KnSSLs~;5RZ3Nw}+kU|*o{p!ewJ-&Ll*mJAeMBiu7U((eGskCoOm
z+afW*&i6?&+zUarKS7P1N4I%-y##k0I7o0K0-!u@eQ=QAmIZuuVJAyMvH@F*dkp~P
zQ__(yK-QvO)`HXoW(cW?kMCmTxPhTq=)I4*xcecAcpeL~Lq6^Xz-<+%58Tt>D?x$<
zd699$xiX|#iiJB6@Fh|!s6O1;fW5~}3P>s-A%nC75&_u!ZBYma?wYWc;Fbh@hubW$
z{F%RFW09$-7j6Z}^+S?D%!ngh!?)kHw{Rb)2)Eryh0K=aQEAO#JD-<~)?Gaf%-fKA
zO}Wr=ZJc!B(#H4|isrrfg?9btWvq0S;pWb;y7kA>&Cxfu>&HpErWL(5>phj9_Ep<&
zf0DUh@$mgjR<<U2%?(FwePG7dRc1=>LuvhX#d^Fbow>HfZDqcdrt^)-&xK36`h3u6
zyJ%z1R$azczjdef$zK{-x=S`I^i025ai8BX*%&+dd|zYz=WAxe-jC_{PpVDYO<GT~
z&x`;mIlB}vE6j6`wyXfDy$)greEumR9Vg)@c_(#OLZt3&A($y3;U}$UW`WdP12F@@
zYy$~Di9YE*vkN5rr0~oDu;Q6bNQEpQW(P?0T_N5WKq8+8k?gbcJ+lBL@+ACxWkAdh
zu!UmQA|B$olo$$!+#u3@HN;E@vj?3aW+s>c=me4UGrRFLWC=0L!0ZMy9SIOK8q9(W
zf|yBQhJl%dWXK(2W`Wt0-)kKWw*h-OzaVZ+jH*_p;jYb-o$PFfTKBYF8SnLS^wP$e
zThm|HZ|Nc%JaeJ<_UT6lt%}Hgs_TuqXRhTsUS1`+cuG5btmeg=-6ne(fAZ<7V>LSx
zy_AhtLif7F#7uVVG3Wj4LBm}~4YA(4Lf$fL?Th^;MLQ%MIqaReb+@+~ov<hC2A>?&
zPxR9<+38c-AHsXD>*BC*apokabF&nI*5|B;-CVe^(Y}_g<CBj6cM;Mj9seJ5m-&;9
z|4%ypKk4}Yq~rg8e2|H$_KJ@%M$i!hW~wzC&C`aUkVsubApbBw86fDtaeyGV_5p%8
zR#S%&f-Ikm5cFh(peG{){niLU%Jvb0vOGsW7$1mj+Jh0${@7(ghZ{Kmvv+WXTgv{c
zMhgOoyM%l}JBgFs5sRc4-9>7Giz^Z+(kv1s!dTKT5;l@54Mgfhuu1q!>P9F^sz&-m
z(ne}Unng-S`bJVmnniL&I!Dw=N=AA{szwS%vIhJqP%W}R5-<`p5;)Q|5-`#}QZ!OL
z5;#&p5<ZeKf@QKpk~GpaQa2Jd5<`Mwl08D#6o`b6G?65a#E_Jcw2yR+RFL%06H0?X
z>mmk7z=N#?IOm301ckN`As^vj4=55MU?fb;fC%Ua<pBQtc=^j0FOT{99Uqws{cyd|
zal4a5Q?FOq9bS>XYqXc+@w&6$PL?dN@Nh$?G}XM?GQ+*Q(<bflTQmQfU0g0G+?oSb
z7m9q}3%}ugUD^Mv{>`{sBL~#3`1GHXbR#62R*7+6Z^Nh0_q3mRplAMmb@v6H(=yJ+
z)Wsh?rfnHLcu2Tp^Yvq!i%-hFda7n*zp!yTJmxR2X@2*PwyU}<>iMbpHQP7*^+d@*
zbyDYHWA&9U)odZHFjc$-A2l0J2%4m=J_?eW;KJU*N`m^e7UIV`XM9Lr+u|?^pGjKj
z2gZtVpr67Z#+7kkj2SC>gnpzi3F_&+v5*9!@8~54gs~=t&4fr!=@WV^0-}HDPm)vm
zIS^v-7*KkX9;DysRr(oT2ZweBho*~-AcmdJrMu`56*Lf{;~086k*=rPXcZnMaFB3B
z@#vwu+MGtq&|!2voya3b57FIlzaMD_U+IRo-?PoH3|6MBclWvCqw6_evg1Ny_zNL{
z*ObemdneRw{QzT21vTGENkaGSV}YyQ^BBA@$Sdj6u$>E4>puL}cg;r!rfBXz=Y7%A
z!LF`uhUE0M&n}qkOZj&C$Eo4|M^42paC~7zX2^xN+!lt-AGmL|Lziw*ua#-~rM+0!
za^Kl|&PF@CpqV56m3b$mrPief|Nh=7C)Xj?o!2!lSyT+$TrpJ~f^9Y#Y_qk^Hfo{y
z;UUcMqxyyLGeoov?ZD8oNn)ikj0_>0Ct8D*P8+cKp`9339`3Xon=FQwfnwlzY~paY
z_*8<ZTMG`No9H06Fl@2t9>#_4WGv}8#6@rrV?{TkRf0oY;1If^4@8gAlk_WHlL0aE
zbPjz@7tuBJX#hmWbcWc*(X(_DUBPyXzNg;@Lp)CC4jwaf5nZN((7*`Jqa*2cIu31`
zUz=;l_W1gpMn`bZJfxAPv~~VhtwLUMxs}Hb>p6P&xTbQgqq6t8neO@BI0%7q(6R0|
zPDd4k=9#`;Q=2ZkF#65+EnYml-ubP|U-xwRw)&lMMh-gpbZ^(I6J71+_$nH14NYkf
zho9`C|Gd$!$u_;QVNsuB(mJnhi(h)->$CAr%Lcsvx!l5M!i<kPoA#ON_iFS0UJGmN
z`qmvDl(4*c!{-O}-!>I*YcMjss93;8$4v1KG63z#ZckCxaq>YC#^7PMe{?4o`uk5%
zi<u7)Mh23J1bhuNEii0AexUvy<l@Bk1J+8UHWKu)_mJp6!++=lFEa<WHWCBD8#?2I
zw1eXVuVYbwb+Bn<3_z^W4<7g%LjWbQGe72YFdZ2gI{V{ekQ{uLj}VVD7h!xH5`FZ@
zm+?k|Xd$7XXJ2`FlLR*t__mJV(>hKLhA;vmpYt@(H-^^%$Ok9Kn#K(WA-DU6D-!TI
z*nI2oLcYvR;MW3SXJ>wt9k&#Fb1fNjF`kZtz|$Sr>0hpv0Jx_L!wMY|y6ywY<8B44
z2E+IG%36>z!G<IG;lM-$T+UI8fb}spQnchv59|W&8Ne^x?nwLcZUJe7kUYRvA*F%&
z7^uiWf*eP#;Wh^0W(u`A!M(V*Fb0qZ^9T5i)`~Y%Fms^f*h=!n62m<O!XQJ)r!cJ`
z3`B$>ny}{>#z-dIQGxBn$V5rJWdmD{gaUS{o2Ojqi;M-mfLk(*`Tj?Yk1-zYtn^bk
zs*C-!Yr=Spk?($Y&sY6?tvmkO`r$UIg|V9*aJ$RGZ8hFo^}SUuVK|rlbEXCiEM4Ac
z`P$XXKGVBLp1%E4jeD$DbewFu&i2(@zb(;0=fz8gCC+c0UwTpR{nCl$H)q_^HBHMs
zxVJGfO8&V|;Kr4e=Wo;uY23c0+le(U`?oBfxv8kLrYQQ{`pjWJ^)6^}{^WwIqiN@U
zvpU_r%!K@7?i9dzo4~@!{mIVB*EJ9sdK|=dfSj9*p1hnVBjn&@<yH`L2xRfRkY_G{
zT%36T<{HT6T_M(I2*f-B89ws|<n<nqHN?MEMiBD?Wbu5ZL4zQ+KV<RDUy$=NufVvF
z;hRB9$PUs$3aBl2Kt@ki&s+rAK64Pvb@YUo*C4lNPJ)b|xdrA5$oiQ>;E5LVAIx8L
zhj<##e8*GJIEc9gJ;a<q3giO)hE3FJFJ<e^QPwyqb8{^Tcfzop+gmby8Z4%t`F64l
zDJ0uHRYCIktKE<aSbs7oYyBp>xz-!+7Ox-cndIp@e~sy^B{M45bC^)qw1G;U=a}H^
zjIXR08h>+kMYQu9dv3gEcJH}GQR{+jL}pV`br-Je&y`tOt#r!P?)xPBwvo-Gp!%zy
zmF;RUsz0{y%O#ClvZOOIORXcOo{gV8c)W4I+WYx~7l$@`EZvyp1Dn*FDCT4EpS^~^
zu2YTgJTH!Z_sQTt|DA*XaPXzyuvpDwN1Odm4*>Kl*N^{(JisY)#RUui)CvNd(Rzr*
zcU+Cte|a+g&y(?go{azVnDKww#>e{8t-$|aiiC8)m5%9v|DHz%gttF3Ac|)(hIEA3
z=fCQK0rmg;9vHBtV>;l;0|TBsFn|vXaBF{HKt3iqJTbuX|NAEf{Np$B0S}%@@_)T0
zZ-06~LzmhA=BEeTGE+3*lHnc0CBr?bWFULy2C!!?(VG+^ej~vGHWT{bf<#H~h~?;{
z%U_Y5wt+a(F@QIVAshzAT7YO|Zq5+V6;T+G7O_}gh&*pNL?%bvON>RB3XCN%JEAV)
zFCtm;KEgS$J%BeYz#G9oAsC@8Ng)X!(JG-Z(OnxvBVZ$pBj_dKBV8nTBQPV7BT@8#
zh+l#A1ms5$*ApU9B<T-=NFWK53GPTK3GxWvTp&Wbu~0fhTu2Z|DoOfCTu6LKKuD11
z1CdM;2of9u=K1jgn6FI3+wWX4ShtVZ0d}EW5^bkA8u;K@5`9+Ktk3*pS!i>-iOsF4
z@qHUt?8~<q-2cQ;>8z~GK_>mw8!i_4YSHa+U*uoSPnHh!sviEzq4)2LjrS}p);muN
z3hcR})YCO;i(A0Z#nVz3x|hB8WuxzjUi*!{3S84mo7<;f%<~TWOcKvs-qbVg^B?xu
zx*u=O$ngsgzWB=dz)Rk{l7n2f`hC0HB=7yc#o;1cl-8IEqZ~9D99AQh*wJAMdWTiX
zu+aeIn+!0*WN=pse?bmQ+)EE4^nxwuHd=%gO<S;HNnsgC285`W0bmeW`3yFxEN#d@
z&}JbJgGiImqNJ~+sx%V=L%Ui*3?hRig?d2@G|dIu!iGa(LmD&_qRnU(hLpxNg#sX2
zlGdS>Xc=0_4WeCWJ6eQRrj2+I@OYwyd9cuS_7JTIyZVu(@I?;7*KapON|7)UP_(Cm
z#X)1+d7f^aL-&{N$@E%kvF_^qXbgstrd!!)yEZa+b#IHv=J-RaQX<^UFea?XcdYA$
z`pyfEJ9{@ydt<{zleI7Ps_l7AS@Zmfri;(IzIo{I{^7g(jCdtrUuo`hEo0q18qH@+
zIro|J<0(P=4{e@0ufU_}z~05fTzgumW0T8tvNbXNHBCPao}U$ydCOr*#JYjT@2!`Z
zbUJll=A3f>BimwzURw^EJaW&84Q(Q(2^efzgGW1$P#(!VS{WSL=Z-}P0&6WWe=Vk2
zy$FzSG%|>+Mw*8KWLQ|u3^JQ5RyW(1p%6{LR)Jw+8^sXNPz)o(Lz7uU3?W0LffyQ^
zhT)}AX-;DZEe#AZ3I?GaRS<1NgV1iY5QE<bqJ4QFutlVaXbdGpQ^=q&XfVWsgogpm
zMAOjLJs{eiR;CGQd0Lch42>5HDWEurwx=<9NI63=mLFjlUxa*o{kEZmVKZtuy2=YQ
z6o$<>nl%N_u#rZtTkviB=qkMx&+kaL!5C$;tv@`J?GugBg#$~yFgV%F@M`hjKj~!t
zhVNeUyq#e-ae*sOm*`Yxp>{=bvG?>XH$qhN%9klzzuGnBYf((6DIUE;`aQKg;~(GM
zU)%Fy<FL;0n>W|{{BWe)$MbN-g7HOlqQl<z_uSsl!&%{bB(ndCUY|PJRuoA;DryPM
z3xT0-nJOBPEZAabcXnc=phb%TE6mwPp4oxw+Y-D1t}}Ch{^v*;AcPx9nbA`o1My;n
z9&3)bBQrcCz?{hju?u^=3l9|ds78380N8md`^n>H>@$xa&v{zh1GgK1U<0b-)&V_7
z^#?b{T?*jU=+ECEV`>6j;xQ5reh;P(Ko9z^7W&jTFwG$FabkL*6Tcy|z%&9ju{}j0
z?Tx<n*hJxB2EgO>>?DtAqydnm07kD7?peTk&|kl}b!Z*6EK;tt0My5r|E3sWh^xjO
z1qSes8wij+z>Z+3eq;-fW<X`c&j9_$tqUOhNP;vmslhLCGXgdSSrm0E{|Dkn$^pq0
z^!`Uy1hdhHzeadOfR}Ku0p<htBej9d3D$udDUi6p9TTV}WK=HTSbh_`jawRo!H|$J
zF+5@b0}y#Ixgb|EMH4OQeH@=~<3zEL4M1&GIATyE4F80U;-eVMk!a!L2$&_X_QNd%
zq|TzYM+W=>hx1VZmTjZ(9dlW5N;G)ci9KiU)i`1NAkFQ@@VTA)AS;lxd8XO7wR!2=
z9XFrfb~(lOdGp5CHmCHvd}3b1XNhmu%zgj6pGG!!wz}uwSgUpUy3#nbPQ748l27+J
zEmOUo5AS1j)Omqy(!HfFpO!6fJ>s<4Y)8T#-#NSD?P@pVb$_?Zwz#zQBXvEj_Z|tE
z6ML}ngQE#n1FU0S(?$>XozYpjd($R3{EAfZ`Gb2uZyDX0AWp@ul8BS^^REOcIf?pE
zh$LMMk)$(wz)S$CxjjTW&I|xgM6{4M)CVHnCp{-AXAk=zh_t;6MEafp@!Fd&()!*I
zNq;(&2r-+$3<Wa>Y-E^OU_4x*0T3G?-d(_~0<!|l<}tI-AL3s-4a6S*%rKDdt0B_;
zG>9ilN+<wg#)HIP4*5dNK6pUPBJ_Zm31HTP831N8`a#T&$RK7;m=Rz$g4q&gLzs<V
zmVsFU9mI?VvmqIfEi?j(f&QSKTJQRF>JlD=N2~btXmD|J8mM1|{+QeG%z(tBfnK|j
zjn54leoi)c)~e$1A9o)*e{Sc1ow}xOGp66X|C}^6x;f9H)4op*dAJ@f4L)VGEA&Xx
zk?ZwxBa0H_Su@}7nVkAgO5FBR)hnlRH@J+6Tz|l|--VZ2mhReMoO(HVn)UgwW~P*T
zD_$v`mT+S6tI6lrUr%`Rgd(VHPrr&&?|-)KrxrEr^qA}c>GdCZbO5sqPaYkBLriQq
z{95q-?|5{;{XcCnJge?MojquKd_c{^SDXKy?7;^evj=y2{o5ZOfEq(H@s}r$4|wwU
zfd3~RAF!tNaTtH@FU`O6k(K{u=;Y{Zf2XrzzA;Wa9POKWh%mjVn_-%tcd8zI-aFvI
z=lR1Qd~VP^_<SPb!RKRR9(+DhZus1`j!Vxz`0ndE@q>v|FLaprY-xvyH&%6+xPv}x
z!bWo=Z@=AP;?~*LiMCZOz1-p3w{LWqIPgt}iK+kWFi|_z=t1!<b2?1C^KyrYQ#)EG
z9PJkiRd;1~hi^|D=rD2QWQU2jKkP6u^IC_AQ(twMxb#zpiCc}vhD~Z)*N)|_Ggt++
z>pD!V-r8Z}v%hwjsN3IR;@F7}6CZrkHlZ+bT&6cqD=nQcaa>tOZdPHM!dj#-cNaMr
zmz9^gi^6%vsgQ6wZ?KQylSz5m(}iVY+-<{W+dA|6)?aXbQQ4RR%;kAp>s)E((-ru!
zb@*gkXLbm|Y$FsWsmL4T?d}x5sk4$Nb;3MZc3xFh=D6Z=cT=1bS$mG=|NPRF3uG5#
z1ME*(IgWOmtr9sa%pIQ+nOHjt8>%p}Z!orB=4k)3z3NV9mCSjt$iuY#nZkJvrkeIA
z+}hZP!s&gH{g)pbE0j15cUDN+io!k`in?TJzf!JR)J;{_#o0l|(_OwCc+M)k>_r}r
znTxVT_Om}RRyaIVY-@#eEP1C&)vWxpC9i&L$*6Ke$!}ZQ&y=h74p1HGjgon~%-6%)
z{ODX^o8Nw<WJA~t1#hynKV_zxKV0>mHwxyZ^P>enI#($8z4n5QTI*N{yrJALW%fVI
zR1G@S>X8hXgw^aIVcEj6Up}&IyFpsFOK$&;Ty-KswKCY*LBeNeIY_uTg41D2C~NA~
zwxF1{Z3q3-x*b;bKU=AejZs~R#{RWEqz6~$t&i1VupgZ(l)FqQ*S@6!{!_{9&!^%_
z=C|#6q+In;>L2pw4wU_C{zR<j%T<@2Rb86+XI=DOdsVdA{vm%FN=7rS`npE^XUqN)
zWjj6M{dR|5vatU|rb4T)s+swx%dWfj%d$Iq^hXQ(#bzq}4N-kEpG80FM@I3{xk411
z+KYaSOW&5+pOC5W2TAqA%i_oR^sPsheymUNS4?$iEw-(LHy`8F_u5PQRj1-lpsH>w
z_wrF!{)Sh-7D~2nDWg|EO0{1*&d%s}%!<FSs;Mo)UjJ@$T7TVG;rdYQ`6r|G2(z@`
zAXnj!v#R#}KOOiDDELuR;V+P(Y(rCxzxAq3SN?R_`yN|%yJ6Atp-IK5gX+Z1KV9}m
zkCfffuqgT+GZjumR2Ocu=tr&j8-~5tUi4!OYiL$+R-;<<^J5J=|3+Jdwk`cw!{Ss(
z)i~Yg_YAwKy|iC7EY71;XBtq_pEK+Mq2$)a6*ja#mTD*YRmX01w4dKag|jr(sV1Y}
zYhZB(C$hhS@_)^-2v37tg;PA$CvS4YN$vP@khOl`Uzx|u721>9PunW^u}$ok7WQAu
zR5)W)-EMifY{NQ)zhE88ZkucPi}TpB+Z{XG(*8%83MZhdD~JDd*>5~jc1Op4X=#7k
zOoh`~)ul5my6p}Cd}@6Oj%~d!;K5vBvrn}b-R8LtCjy2h7U#yQ6CVkoLmKj-Q-RMP
zS^5`_-66L>AXnjpTD9y`Y@38s?7_*vgDGKKrhe8Ip2s-$M=Sf;)+(Hht3J6U>?QXN
zP~+j#0bz$9nk$sNTqxOoQ#qSh*wB7?s-4MiIkvHj3g`OxQ)~Q(9J>?c|C(c$S=sNC
zt8k&9s$FdSkYih;^9#qe%@sEMgZ3(UtYbG>@NXclJ5&c&{OPjqJhtq1#~RviT*jyx
zH~i_c=iY1!W!rXlbnG%q`+Ybm_^Yw%jn`Q8pK@$-d(n?^>}<LHa=8juSgIf15kmJ%
z$L@V(>Bl-2mu0HOhp=tG?bu80r9IxUbFEdlrc-@%TG&fQ_91Ty$K@k)g~0zqDA|6K
zZ~_Y(+W(wthm@_SgGq5(QD$11!&Uh+u6ae7SykgQCKOZ@7L~aUQ$GES>v+t=C)d)n
zqMR&OPo-;7T45Gu6jc-yV5+P<t+X7IUc%=I#rQbT%gZp8B}_d#245M994C~Y)mrky
z1!d=D6=aTkc%EU)#+6Sh<{Diqit;ihWEwW2qOf>U`xg_^^RqI_xp9SA<!PB|<!Si&
zGp<=h_<3GY4wp@c59;UZ`fP`dd3Y<ZBc&|hq0MNU`JdVjR@Aee*qqjVbH&NhqibrN
z`HMB>6_p!)T=dZXw$JXcyN|5KaPj`=njXym#mZ1`S><^ME~??-^|gI7*oQoT-~Y~v
zam+t<#jW%IBP(uQ^tV<l0EkD|+dlgjt9{^_hxe9skeO9bo`&58(fGaHCEs{-rEPP6
zvCayF&hYbx*ZE-nZ|z_kHhFY)9l!a-Dl@Y(@(R-mxXi=re6ar=*7=NUaVZuk%bQSy
z!^Rg2m1U$A@bL3~_8}MZs`@e8(K`1R+mKx_A?>kF?(jv2jS##nG#jN^Y2_12g`>G3
zFTFIabP^Bd;z<I?;_552N?W(pb)av5ul`=H*h<&d)pz*PyT5n;L9Wk=9LzPbu~DOj
z85o$uG3fxlsx$!_jV1=-D@>!As0ql?gmM<%H5#ojACs8YXhJxJS#9r_;*SD+SVD#-
zP@~cDYn=~&SIPfEgrdFpQ7B5E-*><OUtwktX9}+fVcMs1$bbP8F@r_oCHy`(WnyH$
z@U^Bm8sAs(2bu`}$CuVHEquoIVSY~g_8H0%3KO<BrLe#!WmIf-hTc#fwsw?ZC7S5g
zDhO$vPG*66p;Z1CB242$aBKN^Z><D=&~V2!n#@t-t0N5CKAu%;SYFs(ejWOtJl5Yt
zjW&nxh6PxfVXG4GQ|<UsgA%KgI3uVUCHZnDs<!Plp>2Dx$EExpU$j>Ve<W;Qram$~
zy(lsh@rilN_Jj$Q(pID<neoMPZAA;a)b{Oz@{(AdE`sF=GwB|~E5NXSIowVxTqYRH
zP&2|0gm4<RQ(MfK;ztR;RsRq6H^ERfLNPI1#ISL!T79HfMvi8L$icBVt+b>ftGr)n
enX=XW%BKdw`(BQ-L2w`YPvnd=L9`}z;Qs+M^A6Ae

literal 12413
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

diff --git a/python/cudf/cudf/tests/data/parquet/mixed_card_ndv_500_chunk_stats.snappy.parquet b/python/cudf/cudf/tests/data/parquet/mixed_card_ndv_500_chunk_stats.snappy.parquet
index 746916cf07dc329f95ccd024cd8a2645920b4bf8..3060234d499cd6b614621e19fc55b10c96b2182a 100644
GIT binary patch
literal 58150
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

literal 33028
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
Do`x(*


From 88bf4913713b4ae73c4b45110b976220eca7af26 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 4 Dec 2024 05:11:18 +0000
Subject: [PATCH 50/85] Minor, add const

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 5054051b042..7f7db91d1c4 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -499,7 +499,7 @@ aggregate_reader_metadata::apply_bloom_filters(
     cudf::detail::make_device_uvector_async(h_bloom_filter_spans, stream, mr);
 
   // Create a bloom filter query table caster.
-  bloom_filter_caster bloom_filter_col{
+  bloom_filter_caster const bloom_filter_col{
     bloom_filter_spans, parquet_types, total_row_groups, equality_col_schemas.size()};
 
   // Converts bloom filter membership for equality predicate columns to a table

From 9ca42c62eab9acdb52148e479e14516a10200cf9 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 4 Dec 2024 05:42:55 +0000
Subject: [PATCH 51/85] Move bloom filter test to parquet test

---
 cpp/tests/CMakeLists.txt                                    | 6 +++---
 .../parquet_bloom_filter_test.cu}                           | 0
 2 files changed, 3 insertions(+), 3 deletions(-)
 rename cpp/tests/{hashing/bloom_filter_test.cu => io/parquet_bloom_filter_test.cu} (100%)

diff --git a/cpp/tests/CMakeLists.txt b/cpp/tests/CMakeLists.txt
index 94a5063d150..2e30e390032 100644
--- a/cpp/tests/CMakeLists.txt
+++ b/cpp/tests/CMakeLists.txt
@@ -182,7 +182,6 @@ ConfigureTest(DATETIME_OPS_TEST datetime/datetime_ops_test.cpp)
 # * hashing tests ---------------------------------------------------------------------------------
 ConfigureTest(
   HASHING_TEST
-  hashing/bloom_filter_test.cu
   hashing/md5_test.cpp
   hashing/murmurhash3_x86_32_test.cpp
   hashing/murmurhash3_x64_128_test.cpp
@@ -315,14 +314,15 @@ ConfigureTest(
 )
 ConfigureTest(
   PARQUET_TEST
-  io/parquet_test.cpp
+  io/parquet_bloom_filter_test.cu
   io/parquet_chunked_reader_test.cu
   io/parquet_chunked_writer_test.cpp
   io/parquet_common.cpp
   io/parquet_misc_test.cpp
   io/parquet_reader_test.cpp
-  io/parquet_writer_test.cpp
+  io/parquet_test.cpp
   io/parquet_v2_test.cpp
+  io/parquet_writer_test.cpp
   GPUS 1
   PERCENT 30
 )
diff --git a/cpp/tests/hashing/bloom_filter_test.cu b/cpp/tests/io/parquet_bloom_filter_test.cu
similarity index 100%
rename from cpp/tests/hashing/bloom_filter_test.cu
rename to cpp/tests/io/parquet_bloom_filter_test.cu

From 84c24c16c8374c9951827b0b5890e5c0e72e8901 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 4 Dec 2024 06:04:27 +0000
Subject: [PATCH 52/85] Minor updates

---
 cpp/tests/io/parquet_bloom_filter_test.cu | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/cpp/tests/io/parquet_bloom_filter_test.cu b/cpp/tests/io/parquet_bloom_filter_test.cu
index 9ca76c085b6..c290de4568a 100644
--- a/cpp/tests/io/parquet_bloom_filter_test.cu
+++ b/cpp/tests/io/parquet_bloom_filter_test.cu
@@ -31,9 +31,9 @@
 
 using StringType = cudf::string_view;
 
-class BloomFilterTest : public cudf::test::BaseFixture {};
+class ParquetBloomFilterTest : public cudf::test::BaseFixture {};
 
-TEST_F(BloomFilterTest, TestStrings)
+TEST_F(ParquetBloomFilterTest, TestStrings)
 {
   using key_type    = StringType;
   using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
@@ -43,8 +43,8 @@ TEST_F(BloomFilterTest, TestStrings)
   std::size_t constexpr num_filter_blocks = 4;
   auto stream                             = cudf::get_default_stream();
 
-  // strings data
-  auto data = cudf::test::strings_column_wrapper(
+  // strings keys to insert
+  auto keys = cudf::test::strings_column_wrapper(
     {"seventh",    "fifteenth",   "second",      "tenth",      "fifth",       "first",
      "seventh",    "tenth",       "ninth",       "ninth",      "seventeenth", "eighteenth",
      "thirteenth", "fifth",       "fourth",      "twelfth",    "second",      "second",
@@ -54,7 +54,8 @@ TEST_F(BloomFilterTest, TestStrings)
      "seventh",    "tenth",       "fourteenth",  "first",      "fifth",       "fifth",
      "tenth",      "thirteenth",  "fourteenth",  "third",      "third",       "sixth",
      "first",      "third"});
-  auto d_column = cudf::column_device_view::create(data);
+
+  auto d_keys = cudf::column_device_view::create(keys);
 
   // Spawn a bloom filter
   cuco::bloom_filter<key_type,
@@ -69,15 +70,16 @@ TEST_F(BloomFilterTest, TestStrings)
            stream};
 
   // Add strings to the bloom filter
-  filter.add(d_column->begin<key_type>(), d_column->end<key_type>(), stream);
+  filter.add(d_keys->begin<key_type>(), d_keys->end<key_type>(), stream);
 
   // Number of words in the filter
   cudf::size_type const num_words = filter.block_extent() * filter.words_per_block;
 
-  auto const output = cudf::column_view{
+  // Filter bitset as a column
+  auto const bitset = cudf::column_view{
     cudf::data_type{cudf::type_id::UINT32}, num_words, filter.data(), nullptr, 0, 0, {}};
 
-  // Expected filter bitset words computed using Arrow implementation here:
+  // Expected filter bitset words computed using Arrow's implementation here:
   // https://godbolt.org/z/oKfqcPWbY
   auto expected = cudf::test::fixed_width_column_wrapper<word_type>(
     {4194306U,    4194305U,    2359296U,  1073774592U, 524544U,    1024U,      268443648U,
@@ -87,5 +89,5 @@ TEST_F(BloomFilterTest, TestStrings)
      2216738864U, 587333888U,  4219272U,  873463873U});
 
   // Check the bitset for equality
-  CUDF_TEST_EXPECT_COLUMNS_EQUAL(output, expected);
+  CUDF_TEST_EXPECT_COLUMNS_EQUAL(bitset, expected);
 }

From 0c0503174b78220b2e99ac71f242cdd8caa1fced Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 4 Dec 2024 17:57:54 +0000
Subject: [PATCH 53/85] Minor

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 9 ++++-----
 1 file changed, 4 insertions(+), 5 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 7f7db91d1c4..9bebd6bcabf 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -485,13 +485,12 @@ aggregate_reader_metadata::apply_bloom_filters(
   // Create spans from bloom filter bitset buffers
   std::vector<cudf::device_span<cuda::std::byte>> h_bloom_filter_spans;
   h_bloom_filter_spans.reserve(bloom_filter_data.size());
-  std::transform(thrust::make_counting_iterator<size_t>(0),
-                 thrust::make_counting_iterator<size_t>(bloom_filter_data.size()),
+  std::transform(bloom_filter_data.begin(),
+                 bloom_filter_data.end(),
                  std::back_inserter(h_bloom_filter_spans),
-                 [&](auto const filter_idx) {
+                 [&](auto& buffer) {
                    return cudf::device_span<cuda::std::byte>{
-                     static_cast<cuda::std::byte*>(bloom_filter_data[filter_idx].data()),
-                     bloom_filter_data[filter_idx].size()};
+                     static_cast<cuda::std::byte*>(buffer.data()), buffer.size()};
                  });
 
   // Copy bloom filter bitset spans to device

From 09560c56cb84c6eac103e34a713ed8bb2f739a7a Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 4 Dec 2024 18:27:13 +0000
Subject: [PATCH 54/85] Logical and between bloom filter and stats

---
 cpp/src/io/parquet/predicate_pushdown.cpp | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp
index 5ff8645b569..57c168d4c56 100644
--- a/cpp/src/io/parquet/predicate_pushdown.cpp
+++ b/cpp/src/io/parquet/predicate_pushdown.cpp
@@ -419,7 +419,7 @@ std::reference_wrapper<ast::expression const> combined_expression_converter::vis
           _operators.emplace_back(ast_operator::LESS_EQUAL, vmin, operands[1].get());
         auto const& op2 =
           _operators.emplace_back(ast_operator::GREATER_EQUAL, vmax, operands[1].get());
-        _operators.emplace_back(ast::ast_operator::LOGICAL_AND, op1, op2);
+        auto const& stats_op = _operators.emplace_back(ast::ast_operator::LOGICAL_AND, op1, op2);
 
         // Use this input column's bloom filter membership column as well if available.
         if (_has_bloom_filters) {
@@ -433,9 +433,12 @@ std::reference_wrapper<ast::expression const> combined_expression_converter::vis
           col_literal_offset += std::distance(equality_literals.cbegin(), literal_iter);
 
           // Evaluate boolean is_true(value) expression as NOT(NOT(value))
-          auto const& value = _col_ref.emplace_back(col_literal_offset);
-          auto const& op    = _operators.emplace_back(ast_operator::NOT, value);
-          _operators.emplace_back(ast_operator::NOT, op);
+          auto const& value           = _col_ref.emplace_back(col_literal_offset);
+          auto const& op              = _operators.emplace_back(ast_operator::NOT, value);
+          auto const& bloom_filter_op = _operators.emplace_back(ast_operator::NOT, op);
+
+          // Logical and between stats and bloom filter operators
+          _operators.emplace_back(ast_operator::LOGICAL_AND, stats_op, bloom_filter_op);
         }
         break;
       }

From 21f4412d7ebcce746fac06b24f49325874a93daa Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 4 Dec 2024 19:14:56 +0000
Subject: [PATCH 55/85] Revert merging converted AST tables.

---
 cpp/src/io/parquet/bloom_filter_reader.cu  | 179 ++++++++++-
 cpp/src/io/parquet/predicate_pushdown.cpp  | 353 ++++++++++-----------
 cpp/src/io/parquet/reader_impl_helpers.hpp |  89 +-----
 3 files changed, 351 insertions(+), 270 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 9bebd6bcabf..d01ff0c1c63 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -162,22 +162,47 @@ struct bloom_filter_caster {
  * @brief Collects lists of equality predicate literals in the AST expression, one list per input
  * table column. This is used in row group filtering based on bloom filters.
  */
-class equality_literals_collector : public combined_expression_converter {
+class equality_literals_collector : public ast::detail::expression_transformer {
  public:
+  equality_literals_collector() = default;
+
   equality_literals_collector(ast::expression const& expr, cudf::size_type num_input_columns)
+    : _num_input_columns{num_input_columns}
   {
-    _num_input_columns = num_input_columns;
     _equality_literals.resize(_num_input_columns);
     expr.accept(*this);
   }
 
-  // Bring all overloads of `visit` from combined_expression_converter into scope
-  using combined_expression_converter::visit;
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::literal const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(ast::literal const& expr) override
+  {
+    _bloom_filter_expr = std::reference_wrapper<ast::expression const>(expr);
+    return expr;
+  }
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::column_reference const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(ast::column_reference const& expr) override
+  {
+    CUDF_EXPECTS(expr.get_table_source() == ast::table_reference::LEFT,
+                 "BloomfilterAST supports only left table");
+    CUDF_EXPECTS(expr.get_column_index() < _num_input_columns,
+                 "Column index cannot be more than number of columns in the table");
+    _bloom_filter_expr = std::reference_wrapper<ast::expression const>(expr);
+    return expr;
+  }
 
   /**
-   * @brief Delete converted expression getter as no longer needed
+   * @copydoc ast::detail::expression_transformer::visit(ast::column_name_reference const& )
    */
-  [[nodiscard]] std::reference_wrapper<ast::expression const> get_converted_expr() = delete;
+  std::reference_wrapper<ast::expression const> visit(
+    ast::column_name_reference const& expr) override
+  {
+    CUDF_FAIL("Column name reference is not supported in BloomfilterAST");
+  }
 
   /**
    * @copydoc ast::detail::expression_transformer::visit(ast::operation const& )
@@ -210,7 +235,7 @@ class equality_literals_collector : public combined_expression_converter {
         _operators.emplace_back(op, new_operands.front());
       }
     }
-    _converted_expr = std::reference_wrapper<ast::expression const>(_operators.back());
+    _bloom_filter_expr = std::reference_wrapper<ast::expression const>(_operators.back());
     return std::reference_wrapper<ast::expression const>(_operators.back());
   }
 
@@ -223,6 +248,121 @@ class equality_literals_collector : public combined_expression_converter {
   {
     return _equality_literals;
   }
+
+ protected:
+  std::vector<std::reference_wrapper<ast::expression const>> visit_operands(
+    cudf::host_span<std::reference_wrapper<ast::expression const> const> operands)
+  {
+    std::vector<std::reference_wrapper<ast::expression const>> transformed_operands;
+    for (auto const& operand : operands) {
+      auto const new_operand = operand.get().accept(*this);
+      transformed_operands.push_back(new_operand);
+    }
+    return transformed_operands;
+  }
+  std::optional<std::reference_wrapper<ast::expression const>> _bloom_filter_expr;
+  std::vector<std::vector<ast::literal*>> _equality_literals;
+  std::list<ast::column_reference> _col_ref;
+  std::list<ast::operation> _operators;
+  size_type _num_input_columns;
+};
+
+/**
+ * @brief Converts AST expression to bloom filter membership (BloomfilterAST) expression.
+ * This is used in row group filtering based on equality predicate.
+ */
+class bloom_filter_expression_converter : public equality_literals_collector {
+ public:
+  bloom_filter_expression_converter(
+    ast::expression const& expr,
+    size_type num_input_columns,
+    std::vector<std::vector<ast::literal*>> const& equality_literals)
+  {
+    // Set the num columns and copy equality literals
+    _num_input_columns = num_input_columns;
+    _equality_literals = equality_literals;
+
+    // Compute and store columns literals offsets
+    _col_literals_offsets.reserve(_num_input_columns + 1);
+    _col_literals_offsets.emplace_back(0);
+
+    std::transform(equality_literals.begin(),
+                   equality_literals.end(),
+                   std::back_inserter(_col_literals_offsets),
+                   [&](auto const& col_literal_map) {
+                     return _col_literals_offsets.back() +
+                            static_cast<cudf::size_type>(col_literal_map.size());
+                   });
+
+    // Add this visitor
+    expr.accept(*this);
+  }
+
+  /**
+   * @brief Delete equality literals getter as no longer needed
+   */
+  [[nodiscard]] std::vector<std::vector<ast::literal*>> get_equality_literals() = delete;
+
+  // Bring all overloads of `visit` from equality_predicate_collector into scope
+  using equality_literals_collector::visit;
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::operation const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(ast::operation const& expr) override
+  {
+    using cudf::ast::ast_operator;
+    auto const operands = expr.get_operands();
+    auto const op       = expr.get_operator();
+
+    if (auto* v = dynamic_cast<ast::column_reference const*>(&operands[0].get())) {
+      // First operand should be column reference, second should be literal.
+      CUDF_EXPECTS(cudf::ast::detail::ast_operator_arity(op) == 2,
+                   "Only binary operations are supported on column reference");
+      CUDF_EXPECTS(dynamic_cast<ast::literal const*>(&operands[1].get()) != nullptr,
+                   "Second operand of binary operation with column reference must be a literal");
+      v->accept(*this);
+
+      if (op == ast_operator::EQUAL) {
+        // Search the literal in this input column's equality literals list and add to the offset.
+        auto const col_idx            = v->get_column_index();
+        auto const& equality_literals = _equality_literals[col_idx];
+        auto col_literal_offset       = _col_literals_offsets[col_idx];
+        auto const literal_iter       = std::find(equality_literals.cbegin(),
+                                            equality_literals.cend(),
+                                            dynamic_cast<ast::literal const*>(&operands[1].get()));
+        CUDF_EXPECTS(literal_iter != equality_literals.end(), "Could not find the literal ptr");
+        col_literal_offset += std::distance(equality_literals.cbegin(), literal_iter);
+
+        // Evaluate boolean is_true(value) expression as NOT(NOT(value))
+        auto const& value = _col_ref.emplace_back(col_literal_offset);
+        auto const& op    = _operators.emplace_back(ast_operator::NOT, value);
+        _operators.emplace_back(ast_operator::NOT, op);
+      }
+    } else {
+      auto new_operands = visit_operands(operands);
+      if (cudf::ast::detail::ast_operator_arity(op) == 2) {
+        _operators.emplace_back(op, new_operands.front(), new_operands.back());
+      } else if (cudf::ast::detail::ast_operator_arity(op) == 1) {
+        _operators.emplace_back(op, new_operands.front());
+      }
+    }
+    _bloom_filter_expr = std::reference_wrapper<ast::expression const>(_operators.back());
+    return std::reference_wrapper<ast::expression const>(_operators.back());
+  }
+
+  /**
+   * @brief Returns the AST to apply on bloom filters mmebership.
+   *
+   * @return AST operation expression
+   */
+  [[nodiscard]] std::reference_wrapper<ast::expression const> get_bloom_filter_expr() const
+  {
+    return _bloom_filter_expr.value().get();
+  }
+
+ private:
+  std::vector<cudf::size_type> _col_literals_offsets;
 };
 
 /**
@@ -435,8 +575,7 @@ std::vector<Type> aggregate_reader_metadata::get_parquet_types(
   return parquet_types;
 }
 
-std::pair<std::vector<std::unique_ptr<cudf::column>>, std::vector<std::vector<ast::literal*>>>
-aggregate_reader_metadata::apply_bloom_filters(
+std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::apply_bloom_filters(
   host_span<std::unique_ptr<datasource> const> sources,
   host_span<std::vector<size_type> const> input_row_group_indices,
   host_span<data_type const> output_dtypes,
@@ -469,7 +608,7 @@ aggregate_reader_metadata::apply_bloom_filters(
   std::vector<std::unique_ptr<cudf::column>> bloom_filter_membership_columns;
 
   // Return early if no column with equality predicate(s)
-  if (equality_col_schemas.empty()) { return {}; }
+  if (equality_col_schemas.empty()) { return std::nullopt; }
 
   // Read a vector of bloom filter bitset device buffers for all column with equality
   // predicate(s) across all row groups
@@ -477,12 +616,12 @@ aggregate_reader_metadata::apply_bloom_filters(
     sources, input_row_group_indices, equality_col_schemas, total_row_groups, stream);
 
   // No bloom filter buffers, return the original row group indices
-  if (bloom_filter_data.empty()) { return {}; }
+  if (bloom_filter_data.empty()) { return std::nullopt; }
 
   // Get parquet types for the predicate columns
   auto const parquet_types = get_parquet_types(input_row_group_indices, equality_col_schemas);
 
-  // Create spans from bloom filter bitset buffers
+  // Create spans from bloom filter bitset buffers to use in cuco::bloom_filter_ref.
   std::vector<cudf::device_span<cuda::std::byte>> h_bloom_filter_spans;
   h_bloom_filter_spans.reserve(bloom_filter_data.size());
   std::transform(bloom_filter_data.begin(),
@@ -524,8 +663,20 @@ aggregate_reader_metadata::apply_bloom_filters(
       }
       equality_col_idx++;
     });
-
-  return {std::move(bloom_filter_membership_columns), std::move(equality_literals)};
+  auto bloom_filter_membership_table = cudf::table(std::move(bloom_filter_membership_columns));
+
+  // Convert AST to BloomfilterAST expression with reference to bloom filter membership
+  // in above `bloom_filter_membership_table`
+  bloom_filter_expression_converter bloom_filter_expr{
+    filter.get(), num_input_columns, equality_literals};
+
+  // Filter bloom filter membership table with the BloomfilterAST expression and collect
+  // filtered row group indices
+  return collect_filtered_row_group_indices(bloom_filter_membership_table,
+                                            bloom_filter_expr.get_bloom_filter_expr(),
+                                            input_row_group_indices,
+                                            stream,
+                                            mr);
 }
 
 }  // namespace cudf::io::parquet::detail
diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp
index 57c168d4c56..93edbb161ed 100644
--- a/cpp/src/io/parquet/predicate_pushdown.cpp
+++ b/cpp/src/io/parquet/predicate_pushdown.cpp
@@ -246,6 +246,150 @@ struct stats_caster {
   }
 };
 
+/**
+ * @brief Converts AST expression to StatsAST for comparing with column statistics
+ * This is used in row group filtering based on predicate.
+ * statistics min value of a column is referenced by column_index*2
+ * statistics max value of a column is referenced by column_index*2+1
+ *
+ */
+class stats_expression_converter : public ast::detail::expression_transformer {
+ public:
+  stats_expression_converter(ast::expression const& expr, size_type const& num_columns)
+    : _num_columns{num_columns}
+  {
+    expr.accept(*this);
+  }
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::literal const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(ast::literal const& expr) override
+  {
+    _stats_expr = std::reference_wrapper<ast::expression const>(expr);
+    return expr;
+  }
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::column_reference const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(ast::column_reference const& expr) override
+  {
+    CUDF_EXPECTS(expr.get_table_source() == ast::table_reference::LEFT,
+                 "Statistics AST supports only left table");
+    CUDF_EXPECTS(expr.get_column_index() < _num_columns,
+                 "Column index cannot be more than number of columns in the table");
+    _stats_expr = std::reference_wrapper<ast::expression const>(expr);
+    return expr;
+  }
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::column_name_reference const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(
+    ast::column_name_reference const& expr) override
+  {
+    CUDF_FAIL("Column name reference is not supported in statistics AST");
+  }
+
+  /**
+   * @copydoc ast::detail::expression_transformer::visit(ast::operation const& )
+   */
+  std::reference_wrapper<ast::expression const> visit(ast::operation const& expr) override
+  {
+    using cudf::ast::ast_operator;
+    auto const operands = expr.get_operands();
+    auto const op       = expr.get_operator();
+
+    if (auto* v = dynamic_cast<ast::column_reference const*>(&operands[0].get())) {
+      // First operand should be column reference, second should be literal.
+      CUDF_EXPECTS(cudf::ast::detail::ast_operator_arity(op) == 2,
+                   "Only binary operations are supported on column reference");
+      CUDF_EXPECTS(dynamic_cast<ast::literal const*>(&operands[1].get()) != nullptr,
+                   "Second operand of binary operation with column reference must be a literal");
+      v->accept(*this);
+      auto const col_index = v->get_column_index();
+      switch (op) {
+        /* transform to stats conditions. op(col, literal)
+        col1 == val --> vmin <= val && vmax >= val
+        col1 != val --> !(vmin == val && vmax == val)
+        col1 >  val --> vmax > val
+        col1 <  val --> vmin < val
+        col1 >= val --> vmax >= val
+        col1 <= val --> vmin <= val
+        */
+        case ast_operator::EQUAL: {
+          auto const& vmin = _col_ref.emplace_back(col_index * 2);
+          auto const& vmax = _col_ref.emplace_back(col_index * 2 + 1);
+          auto const& op1 =
+            _operators.emplace_back(ast_operator::LESS_EQUAL, vmin, operands[1].get());
+          auto const& op2 =
+            _operators.emplace_back(ast_operator::GREATER_EQUAL, vmax, operands[1].get());
+          _operators.emplace_back(ast::ast_operator::LOGICAL_AND, op1, op2);
+          break;
+        }
+        case ast_operator::NOT_EQUAL: {
+          auto const& vmin = _col_ref.emplace_back(col_index * 2);
+          auto const& vmax = _col_ref.emplace_back(col_index * 2 + 1);
+          auto const& op1  = _operators.emplace_back(ast_operator::NOT_EQUAL, vmin, vmax);
+          auto const& op2 =
+            _operators.emplace_back(ast_operator::NOT_EQUAL, vmax, operands[1].get());
+          _operators.emplace_back(ast_operator::LOGICAL_OR, op1, op2);
+          break;
+        }
+        case ast_operator::LESS: [[fallthrough]];
+        case ast_operator::LESS_EQUAL: {
+          auto const& vmin = _col_ref.emplace_back(col_index * 2);
+          _operators.emplace_back(op, vmin, operands[1].get());
+          break;
+        }
+        case ast_operator::GREATER: [[fallthrough]];
+        case ast_operator::GREATER_EQUAL: {
+          auto const& vmax = _col_ref.emplace_back(col_index * 2 + 1);
+          _operators.emplace_back(op, vmax, operands[1].get());
+          break;
+        }
+        default: CUDF_FAIL("Unsupported operation in Statistics AST");
+      };
+    } else {
+      auto new_operands = visit_operands(operands);
+      if (cudf::ast::detail::ast_operator_arity(op) == 2) {
+        _operators.emplace_back(op, new_operands.front(), new_operands.back());
+      } else if (cudf::ast::detail::ast_operator_arity(op) == 1) {
+        _operators.emplace_back(op, new_operands.front());
+      }
+    }
+    _stats_expr = std::reference_wrapper<ast::expression const>(_operators.back());
+    return std::reference_wrapper<ast::expression const>(_operators.back());
+  }
+
+  /**
+   * @brief Returns the AST to apply on Column chunk statistics.
+   *
+   * @return AST operation expression
+   */
+  [[nodiscard]] std::reference_wrapper<ast::expression const> get_stats_expr() const
+  {
+    return _stats_expr.value().get();
+  }
+
+ private:
+  std::vector<std::reference_wrapper<ast::expression const>> visit_operands(
+    cudf::host_span<std::reference_wrapper<ast::expression const> const> operands)
+  {
+    std::vector<std::reference_wrapper<ast::expression const>> transformed_operands;
+    for (auto const& operand : operands) {
+      auto const new_operand = operand.get().accept(*this);
+      transformed_operands.push_back(new_operand);
+    }
+    return transformed_operands;
+  }
+  std::optional<std::reference_wrapper<ast::expression const>> _stats_expr;
+  size_type _num_columns;
+  std::list<ast::column_reference> _col_ref;
+  std::list<ast::operation> _operators;
+};
+
 }  // namespace
 
 std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::filter_row_groups(
@@ -256,9 +400,6 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
   std::reference_wrapper<ast::expression const> filter,
   rmm::cuda_stream_view stream) const
 {
-  // Number of input table columns
-  auto const num_input_columns = static_cast<cudf::size_type>(output_dtypes.size());
-
   auto mr = cudf::get_current_device_resource_ref();
   // Create row group indices.
   std::vector<std::vector<size_type>> all_row_group_indices;
@@ -309,183 +450,39 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
     columns.push_back(std::move(min_col));
     columns.push_back(std::move(max_col));
   }
+  auto stats_table = cudf::table(std::move(columns));
 
-  // Apply bloom filter membership to row groups for each equality predicate column, literal pair
-  // and get corresponding boolean columns.
-  auto [bloom_filter_membership_cols, equality_literals] =
-    apply_bloom_filters(sources,
-                        input_row_group_indices,
-                        output_dtypes,
-                        output_column_schemas,
-                        filter,
-                        total_row_groups,
-                        stream);
-
-  // Check if we have any bloom filter membership columns
-  auto const has_bloom_filters = not bloom_filter_membership_cols.empty();
-
-  // Append bloom filter membership columns to stats columns to get combined columns if needed
-  if (has_bloom_filters) {
-    columns.insert(columns.end(),
-                   std::make_move_iterator(bloom_filter_membership_cols.begin()),
-                   std::make_move_iterator(bloom_filter_membership_cols.end()));
-  }
-
-  auto combined_table = cudf::table(std::move(columns));
-
-  // Convert AST to a CombinedAST (StatsAST and BloomfilterAST) expression
-  combined_expression_converter combined_expr{
-    filter.get(), num_input_columns, equality_literals, has_bloom_filters};
-
-  // Filter combined table with the AST expression and collect filtered row group indices
-  return collect_filtered_row_group_indices(
-    combined_table, combined_expr.get_converted_expr(), input_row_group_indices, stream, mr);
-}
-
-// Convert AST expression to a CombinedAST (StatsAST and BloomfilterAST)
-combined_expression_converter::combined_expression_converter(
-  ast::expression const& expr,
-  size_type num_input_columns,
-  std::vector<std::vector<ast::literal*>> const& equality_literals,
-  bool has_bloom_filters)
-  : _has_bloom_filters{has_bloom_filters}
-{
-  // Set the num columns and copy equality literals
-  _num_input_columns = num_input_columns;
-  _equality_literals = equality_literals;
-
-  // Compute and store columns literals offsets
-  _col_literals_offsets.reserve(_num_input_columns + 1);
-  _col_literals_offsets.emplace_back(0);
-
-  std::transform(equality_literals.begin(),
-                 equality_literals.end(),
-                 std::back_inserter(_col_literals_offsets),
-                 [&](auto const& col_literal_map) {
-                   return _col_literals_offsets.back() +
-                          static_cast<cudf::size_type>(col_literal_map.size());
-                 });
-
-  // Add this visitor
-  expr.accept(*this);
-}
-
-std::reference_wrapper<ast::expression const> combined_expression_converter::visit(
-  ast::literal const& expr)
-{
-  _converted_expr = std::reference_wrapper<ast::expression const>(expr);
-  return expr;
-}
-
-std::reference_wrapper<ast::expression const> combined_expression_converter::visit(
-  ast::column_reference const& expr)
-{
-  CUDF_EXPECTS(expr.get_table_source() == ast::table_reference::LEFT,
-               "CombinedAST (Stats and Bloomfilter) supports only left table");
-  CUDF_EXPECTS(expr.get_column_index() < _num_input_columns,
-               "Column index cannot be more than number of columns in the table");
-  _converted_expr = std::reference_wrapper<ast::expression const>(expr);
-  return expr;
-}
-
-std::reference_wrapper<ast::expression const> combined_expression_converter::visit(
-  ast::operation const& expr)
-{
-  using cudf::ast::ast_operator;
-  auto const operands = expr.get_operands();
-  auto const op       = expr.get_operator();
-
-  if (auto* v = dynamic_cast<ast::column_reference const*>(&operands[0].get())) {
-    // First operand should be column reference, second should be literal.
-    CUDF_EXPECTS(cudf::ast::detail::ast_operator_arity(op) == 2,
-                 "Only binary operations are supported on column reference");
-    CUDF_EXPECTS(dynamic_cast<ast::literal const*>(&operands[1].get()) != nullptr,
-                 "Second operand of binary operation with column reference must be a literal");
-    v->accept(*this);
-    auto const col_index = v->get_column_index();
-    switch (op) {
-      /* transform to stats conditions. op(col, literal)
-      col1 == val --> vmin <= val && vmax >= val && bloom_filter[col1, val].contains(val)
-      col1 != val --> !(vmin == val && vmax == val)
-      col1 >  val --> vmax > val
-      col1 <  val --> vmin < val
-      col1 >= val --> vmax >= val
-      col1 <= val --> vmin <= val
-      */
-      case ast_operator::EQUAL: {
-        auto const& vmin = _col_ref.emplace_back(col_index * 2);
-        auto const& vmax = _col_ref.emplace_back(col_index * 2 + 1);
-        auto const& op1 =
-          _operators.emplace_back(ast_operator::LESS_EQUAL, vmin, operands[1].get());
-        auto const& op2 =
-          _operators.emplace_back(ast_operator::GREATER_EQUAL, vmax, operands[1].get());
-        auto const& stats_op = _operators.emplace_back(ast::ast_operator::LOGICAL_AND, op1, op2);
-
-        // Use this input column's bloom filter membership column as well if available.
-        if (_has_bloom_filters) {
-          auto const& equality_literals = _equality_literals[col_index];
-          auto col_literal_offset = (_num_input_columns * 2) + _col_literals_offsets[col_index];
-          auto const literal_iter =
-            std::find(equality_literals.cbegin(),
-                      equality_literals.cend(),
-                      dynamic_cast<ast::literal const*>(&operands[1].get()));
-          CUDF_EXPECTS(literal_iter != equality_literals.end(), "Could not find the literal ptr");
-          col_literal_offset += std::distance(equality_literals.cbegin(), literal_iter);
-
-          // Evaluate boolean is_true(value) expression as NOT(NOT(value))
-          auto const& value           = _col_ref.emplace_back(col_literal_offset);
-          auto const& op              = _operators.emplace_back(ast_operator::NOT, value);
-          auto const& bloom_filter_op = _operators.emplace_back(ast_operator::NOT, op);
-
-          // Logical and between stats and bloom filter operators
-          _operators.emplace_back(ast_operator::LOGICAL_AND, stats_op, bloom_filter_op);
-        }
-        break;
-      }
-      case ast_operator::NOT_EQUAL: {
-        auto const& vmin = _col_ref.emplace_back(col_index * 2);
-        auto const& vmax = _col_ref.emplace_back(col_index * 2 + 1);
-        auto const& op1  = _operators.emplace_back(ast_operator::NOT_EQUAL, vmin, vmax);
-        auto const& op2 = _operators.emplace_back(ast_operator::NOT_EQUAL, vmax, operands[1].get());
-        _operators.emplace_back(ast_operator::LOGICAL_OR, op1, op2);
-        break;
-      }
-      case ast_operator::LESS: [[fallthrough]];
-      case ast_operator::LESS_EQUAL: {
-        auto const& vmin = _col_ref.emplace_back(col_index * 2);
-        _operators.emplace_back(op, vmin, operands[1].get());
-        break;
-      }
-      case ast_operator::GREATER: [[fallthrough]];
-      case ast_operator::GREATER_EQUAL: {
-        auto const& vmax = _col_ref.emplace_back(col_index * 2 + 1);
-        _operators.emplace_back(op, vmax, operands[1].get());
-        break;
-      }
-      default: CUDF_FAIL("Unsupported operation in CombinedAST");
-    };
-  } else {
-    auto new_operands = visit_operands(operands);
-    if (cudf::ast::detail::ast_operator_arity(op) == 2) {
-      _operators.emplace_back(op, new_operands.front(), new_operands.back());
-    } else if (cudf::ast::detail::ast_operator_arity(op) == 1) {
-      _operators.emplace_back(op, new_operands.front());
-    }
-  }
-  _converted_expr = std::reference_wrapper<ast::expression const>(_operators.back());
-  return std::reference_wrapper<ast::expression const>(_operators.back());
-}
+  // Converts AST to StatsAST with reference to min, max columns in above `stats_table`.
+  stats_expression_converter const stats_expr{filter.get(),
+                                              static_cast<size_type>(output_dtypes.size())};
+  auto stats_ast     = stats_expr.get_stats_expr();
+  auto predicate_col = cudf::detail::compute_column(stats_table, stats_ast.get(), stream, mr);
+  auto predicate     = predicate_col->view();
+  CUDF_EXPECTS(predicate.type().id() == cudf::type_id::BOOL8,
+               "Filter expression must return a boolean column");
 
-std::vector<std::reference_wrapper<ast::expression const>>
-combined_expression_converter::visit_operands(
-  cudf::host_span<std::reference_wrapper<ast::expression const> const> operands)
-{
-  std::vector<std::reference_wrapper<ast::expression const>> transformed_operands;
-  for (auto const& operand : operands) {
-    auto const new_operand = operand.get().accept(*this);
-    transformed_operands.push_back(new_operand);
-  }
-  return transformed_operands;
+  // Filter stats table with StatsAST expression and collect filtered row group indices
+  auto const filtered_row_group_indices = collect_filtered_row_group_indices(
+    stats_table, stats_expr.get_stats_expr(), input_row_group_indices, stream, mr);
+
+  // Span of row groups to apply bloom filtering on.
+  auto const bloom_filter_input_row_groups =
+    filtered_row_group_indices.has_value()
+      ? host_span<std::vector<size_type> const>(filtered_row_group_indices.value())
+      : input_row_group_indices;
+
+  // Apply bloom filtering on the bloom filter input row groups
+  auto const bloom_filtered_row_groups = apply_bloom_filters(sources,
+                                                             bloom_filter_input_row_groups,
+                                                             output_dtypes,
+                                                             output_column_schemas,
+                                                             filter,
+                                                             total_row_groups,
+                                                             stream);
+
+  // Return bloom filtered row group indices iff collected
+  return bloom_filtered_row_groups.has_value() ? bloom_filtered_row_groups
+                                               : filtered_row_group_indices;
 }
 
 // convert column named expression to column index reference expression
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index 859d9aadc94..e717ee5c126 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -372,28 +372,26 @@ class aggregate_reader_metadata {
     rmm::cuda_stream_view stream) const;
 
   /**
-   * @brief Computes bloom filter membership for the row groups based on predicate filter
+   * @brief Filters the row groups using bloom filters
    *
    * @param sources Dataset sources
    * @param row_group_indices Lists of input row groups to read, one per source
    * @param output_dtypes Datatypes of of output columns
    * @param output_column_schemas schema indices of output columns
    * @param filter AST expression to filter row groups based on bloom filter membership
-   * @param total_row_groups Total number of row groups across all input sources.
+   * @param total_row_groups Total number of row groups across all data sources
    * @param stream CUDA stream used for device memory operations and kernel launches
    *
-   * @return A pair of list of bloom filter membership columns and a list of pointers to (equality
-   * predicate) literals associated with each input column.
+   * @return Filtered row group indices, if any is filtered
    */
-  [[nodiscard]] std::pair<std::vector<std::unique_ptr<cudf::column>>,
-                          std::vector<std::vector<ast::literal*>>>
-  apply_bloom_filters(host_span<std::unique_ptr<datasource> const> sources,
-                      host_span<std::vector<size_type> const> input_row_group_indices,
-                      host_span<data_type const> output_dtypes,
-                      host_span<int const> output_column_schemas,
-                      std::reference_wrapper<ast::expression const> filter,
-                      size_t total_row_groups,
-                      rmm::cuda_stream_view stream) const;
+  [[nodiscard]] std::optional<std::vector<std::vector<size_type>>> apply_bloom_filters(
+    host_span<std::unique_ptr<datasource> const> sources,
+    host_span<std::vector<size_type> const> input_row_group_indices,
+    host_span<data_type const> output_dtypes,
+    host_span<int const> output_column_schemas,
+    std::reference_wrapper<ast::expression const> filter,
+    size_t total_row_groups,
+    rmm::cuda_stream_view stream) const;
 
   /**
    * @brief Filters and reduces down to a selection of row groups
@@ -445,71 +443,6 @@ class aggregate_reader_metadata {
                  type_id timestamp_type_id);
 };
 
-/**
- * @brief Converts AST expression to a CombinedAST (StatsAST and BloomfilterAST) for comparing with
- * column statistics and testing bloom filter membership altogether. This is used in row group
- * filtering based on predicate.
- *
- * statistics min value of a column is referenced by column_index*2
- * statistics max value of a column is referenced by column_index*2+1
- * bloom filter membership of each (column, literal) pair is appended to the end of stats.
- *
- */
-class combined_expression_converter : public ast::detail::expression_transformer {
- public:
-  combined_expression_converter() = default;
-  combined_expression_converter(ast::expression const& expr,
-                                size_type num_input_columns,
-                                std::vector<std::vector<ast::literal*>> const& equality_literals,
-                                bool has_bloom_filters);
-  /**
-   * @copydoc ast::detail::expression_transformer::visit(ast::literal const& )
-   */
-  std::reference_wrapper<ast::expression const> visit(ast::literal const& expr) override;
-
-  /**
-   * @copydoc ast::detail::expression_transformer::visit(ast::column_reference const& )
-   */
-  std::reference_wrapper<ast::expression const> visit(ast::column_reference const& expr) override;
-
-  /**
-   * @copydoc ast::detail::expression_transformer::visit(ast::column_name_reference const& )
-   */
-  std::reference_wrapper<ast::expression const> visit(
-    ast::column_name_reference const& expr) override
-  {
-    CUDF_FAIL("Column name reference is not supported in CombinedAST");
-  }
-  /**
-   * @copydoc ast::detail::expression_transformer::visit(ast::operation const& )
-   */
-  std::reference_wrapper<ast::expression const> visit(ast::operation const& expr) override;
-  /**
-   * @brief Returns the AST to apply Column chunk statistics and bloom filter membership
-   *
-   * @return AST operation expression
-   */
-  [[nodiscard]] std::reference_wrapper<ast::expression const> get_converted_expr() const
-  {
-    return _converted_expr.value().get();
-  }
-
- protected:
-  std::vector<std::reference_wrapper<ast::expression const>> visit_operands(
-    cudf::host_span<std::reference_wrapper<ast::expression const> const> operands);
-
-  std::optional<std::reference_wrapper<ast::expression const>> _converted_expr;
-  size_type _num_columns;
-  std::list<ast::column_reference> _col_ref;
-  std::list<ast::operation> _operators;
-  std::vector<std::vector<ast::literal*>> _equality_literals;
-  size_type _num_input_columns;
-
- private:
-  bool _has_bloom_filters;
-  std::vector<cudf::size_type> _col_literals_offsets;
-};
-
 /**
  * @brief Converts named columns to index reference columns
  *

From 442de80211a17dde95e1d970ca4afd5a0c7f0047 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 4 Dec 2024 20:09:52 +0000
Subject: [PATCH 56/85] Revert an extra eol

---
 cpp/src/io/parquet/predicate_pushdown.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp
index 93edbb161ed..7ae671fbf96 100644
--- a/cpp/src/io/parquet/predicate_pushdown.cpp
+++ b/cpp/src/io/parquet/predicate_pushdown.cpp
@@ -389,7 +389,6 @@ class stats_expression_converter : public ast::detail::expression_transformer {
   std::list<ast::column_reference> _col_ref;
   std::list<ast::operation> _operators;
 };
-
 }  // namespace
 
 std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::filter_row_groups(

From f7952d45bd339c743bfd813441cb5f01e0e057da Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 4 Dec 2024 20:10:51 +0000
Subject: [PATCH 57/85] Revert extra eol

---
 cpp/src/io/parquet/reader_impl_helpers.cpp | 1 -
 1 file changed, 1 deletion(-)

diff --git a/cpp/src/io/parquet/reader_impl_helpers.cpp b/cpp/src/io/parquet/reader_impl_helpers.cpp
index b9ed0a8c65b..27280de25eb 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.cpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.cpp
@@ -1049,7 +1049,6 @@ aggregate_reader_metadata::select_row_groups(
         host_span<std::vector<size_type> const>(filtered_row_group_indices.value());
     }
   }
-
   std::vector<row_group_info> selection;
   auto [rows_to_skip, rows_to_read] = [&]() {
     if (not row_group_indices.empty()) { return std::pair<int64_t, size_type>{}; }

From 4d0c57031f6bc441063bf2e3b42601d274ab1144 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 4 Dec 2024 22:02:15 +0000
Subject: [PATCH 58/85] Read bloom filter data sync

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 44 +++++++++++------------
 1 file changed, 20 insertions(+), 24 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index d01ff0c1c63..0485321bc44 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -366,7 +366,7 @@ class bloom_filter_expression_converter : public equality_literals_collector {
 };
 
 /**
- * @brief Asynchronously reads bloom filters data to device.
+ * @brief Reads bloom filters data to device.
  *
  * @param sources Dataset sources
  * @param num_chunks Number of total column chunks to read
@@ -375,17 +375,14 @@ class bloom_filter_expression_converter : public equality_literals_collector {
  * @param bloom_filter_sizes Bloom filter sizes for all chunks
  * @param chunk_source_map Association between each column chunk and its source
  * @param stream CUDA stream used for device memory operations and kernel launches
- *
- * @return A future object for reading synchronization
  */
-std::future<void> read_bloom_filter_data_async(
-  host_span<std::unique_ptr<datasource> const> sources,
-  size_t num_chunks,
-  cudf::host_span<rmm::device_buffer> bloom_filter_data,
-  cudf::host_span<std::optional<int64_t>> bloom_filter_offsets,
-  cudf::host_span<std::optional<int32_t>> bloom_filter_sizes,
-  std::vector<size_type> const& chunk_source_map,
-  rmm::cuda_stream_view stream)
+void read_bloom_filter_data(host_span<std::unique_ptr<datasource> const> sources,
+                            size_t num_chunks,
+                            cudf::host_span<rmm::device_buffer> bloom_filter_data,
+                            cudf::host_span<std::optional<int64_t>> bloom_filter_offsets,
+                            cudf::host_span<std::optional<int32_t>> bloom_filter_sizes,
+                            std::vector<size_type> const& chunk_source_map,
+                            rmm::cuda_stream_view stream)
 {
   // Read tasks for bloom filter data
   std::vector<std::future<size_t>> read_tasks;
@@ -421,9 +418,9 @@ std::future<void> read_bloom_filter_data_async(
 
       // Get the hardcoded words_per_block value from `cuco::arrow_filter_policy` using a temporary
       // `std::byte` key type.
-      auto constexpr words_per_block =
-        cuco::arrow_filter_policy<std::byte,
-                                  cudf::hashing::detail::XXHash_64<std::byte>>::words_per_block;
+      auto constexpr words_per_block = cuco::arrow_filter_policy<
+        cuda::std::byte,
+        cudf::hashing::detail::XXHash_64<cuda::std::byte>>::words_per_block;
 
       // Check if the bloom filter header is valid.
       auto const is_header_valid =
@@ -475,7 +472,7 @@ std::future<void> read_bloom_filter_data_async(
     }
   };
 
-  return std::async(std::launch::async, sync_fn, std::move(read_tasks));
+  std::async(std::launch::async, sync_fn, std::move(read_tasks)).wait();
 }
 
 }  // namespace
@@ -532,15 +529,14 @@ std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
     // Vector to hold bloom filter data
     std::vector<rmm::device_buffer> bloom_filter_data(num_chunks);
 
-    // Wait on bloom filter data read tasks
-    read_bloom_filter_data_async(sources,
-                                 num_chunks,
-                                 bloom_filter_data,
-                                 bloom_filter_offsets,
-                                 bloom_filter_sizes,
-                                 chunk_source_map,
-                                 stream)
-      .wait();
+    // Read bloom filter data
+    read_bloom_filter_data(sources,
+                           num_chunks,
+                           bloom_filter_data,
+                           bloom_filter_offsets,
+                           bloom_filter_sizes,
+                           chunk_source_map,
+                           stream);
 
     // Return bloom filter data
     return bloom_filter_data;

From 67c6247fbce934ea5c94cc0a9bdfd966090bbaa2 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <14217455+mhaseeb123@users.noreply.github.com>
Date: Wed, 4 Dec 2024 14:11:04 -0800
Subject: [PATCH 59/85] Update cpp/src/io/parquet/bloom_filter_reader.cu

Co-authored-by: Yunsong Wang <yunsongw@nvidia.com>
---
 cpp/src/io/parquet/bloom_filter_reader.cu | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 0485321bc44..f982b143949 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -82,8 +82,8 @@ struct bloom_filter_caster {
     // Query literal in bloom filters from each column chunk (row group).
     thrust::for_each(
       rmm::exec_policy_nosync(stream),
-      thrust::make_counting_iterator<size_t>(0),
-      thrust::make_counting_iterator(total_row_groups),
+      thrust::counting_iterator<size_t>{0},
+      thrust::counting_iterator{total_row_groups},
       [filter_span          = bloom_filter_spans.data(),
        d_scalar             = literal->get_value(),
        col_idx              = equality_col_idx,

From 40c80b7f89ccd02655ed71e6c7a143490ebaaa37 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 4 Dec 2024 22:17:55 +0000
Subject: [PATCH 60/85] strong type for int96 timestamp

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 0485321bc44..0f44c93dc93 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -55,7 +55,9 @@ struct bloom_filter_caster {
   size_t total_row_groups;
   size_t num_equality_columns;
 
-  template <typename T, bool timestamp_is_int96 = false>
+  enum class is_int96_timestamp : bool { YES, NO };
+
+  template <typename T, is_int96_timestamp IS_INT96_TIMESTAMP = is_int96_timestamp::NO>
   std::unique_ptr<cudf::column> query_bloom_filter(cudf::size_type equality_col_idx,
                                                    cudf::data_type dtype,
                                                    ast::literal const* const literal,
@@ -116,7 +118,8 @@ struct bloom_filter_caster {
 
         // If int96_timestamp type, convert literal to string_view and query bloom
         // filter
-        if constexpr (cuda::std::is_same_v<T, cudf::string_view> and timestamp_is_int96) {
+        if constexpr (cuda::std::is_same_v<T, cudf::string_view> and
+                      IS_INT96_TIMESTAMP == is_int96_timestamp::YES) {
           auto const int128_key = static_cast<__int128_t>(d_scalar.value<int64_t>());
           cudf::string_view probe_key{reinterpret_cast<char const*>(&int128_key), 12};
           results[row_group_idx] = filter.contains(probe_key);
@@ -146,8 +149,8 @@ struct bloom_filter_caster {
       CUDF_FAIL("Compound types don't support equality predicate");
     } else if constexpr (cudf::is_timestamp<T>()) {
       if (parquet_types[equality_col_idx] == Type::INT96) {
-        // For INT96 timestamps, use cudf::string_view type and set timestamp_is_int96
-        return query_bloom_filter<cudf::string_view, true>(
+        // For INT96 timestamps, use cudf::string_view type and set is_int96_timestamp to YES
+        return query_bloom_filter<cudf::string_view, bloom_filter_caster::is_int96_timestamp::YES>(
           equality_col_idx, dtype, literal, stream, mr);
       } else {
         return query_bloom_filter<T>(equality_col_idx, dtype, literal, stream, mr);

From c5f8150408c2258be8d7ea8d079d982d909a89a0 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Wed, 4 Dec 2024 22:22:22 +0000
Subject: [PATCH 61/85] Remove unused header

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 1 -
 1 file changed, 1 deletion(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index a58dd557b75..f03e919e806 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -38,7 +38,6 @@
 #include <thrust/iterator/counting_iterator.h>
 
 #include <future>
-#include <limits>
 #include <numeric>
 #include <optional>
 

From 44652775979d47a6656e4a41aad47a31245c5d68 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <14217455+mhaseeb123@users.noreply.github.com>
Date: Mon, 9 Dec 2024 12:11:49 -0800
Subject: [PATCH 62/85] Apply suggestions from code review

Co-authored-by: Vukasin Milovanovic <vmilovanovic@nvidia.com>
---
 cpp/src/io/parquet/bloom_filter_reader.cu | 18 ++++++++----------
 1 file changed, 8 insertions(+), 10 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index f03e919e806..605389ff75f 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -440,7 +440,7 @@ void read_bloom_filter_data(host_span<std::unique_ptr<datasource> const> sources
 
       // Bloom filter header size
       auto const bloom_filter_header_size = static_cast<int64_t>(cp.bytecount());
-      size_t const bitset_size            = static_cast<size_t>(header.num_bytes);
+      auto const bitset_size            = static_cast<size_t>(header.num_bytes);
 
       // Check if we already read in the filter bitset in the initial read.
       if (initial_read_size >= bloom_filter_header_size + bitset_size) {
@@ -593,14 +593,12 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
 
   // Collect schema indices of columns with equality predicate(s)
   std::vector<cudf::size_type> equality_col_schemas;
-  std::for_each(thrust::make_counting_iterator<size_t>(0),
-                thrust::make_counting_iterator(output_column_schemas.size()),
-                [&](auto col_idx) {
-                  // Only for columns that have a non-empty list of literals associated with it
-                  if (equality_literals[col_idx].size()) {
-                    equality_col_schemas.emplace_back(output_column_schemas[col_idx]);
-                  }
-                });
+  thrust::copy_if(thrust::host,
+                  output_column_schemas.begin(), 
+                  output_column_schemas.end(),
+                  equality_literals.begin(),
+                  std::back_inserter(equality_col_schemas),
+                  [](auto& eq_literals) { not return eq_literals.empty(); });
 
   // Read bloom filters and add literal membership columns.
   std::vector<std::unique_ptr<cudf::column>> bloom_filter_membership_columns;
@@ -608,7 +606,7 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
   // Return early if no column with equality predicate(s)
   if (equality_col_schemas.empty()) { return std::nullopt; }
 
-  // Read a vector of bloom filter bitset device buffers for all column with equality
+  // Read a vector of bloom filter bitset device buffers for all columns with equality
   // predicate(s) across all row groups
   auto bloom_filter_data = read_bloom_filters(
     sources, input_row_group_indices, equality_col_schemas, total_row_groups, stream);

From 38887328f6f03ec8c800544dd1b670152acf4093 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Mon, 9 Dec 2024 20:28:10 +0000
Subject: [PATCH 63/85] Apply suggestions

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 605389ff75f..6aa688aefb2 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -440,7 +440,7 @@ void read_bloom_filter_data(host_span<std::unique_ptr<datasource> const> sources
 
       // Bloom filter header size
       auto const bloom_filter_header_size = static_cast<int64_t>(cp.bytecount());
-      auto const bitset_size            = static_cast<size_t>(header.num_bytes);
+      auto const bitset_size              = static_cast<size_t>(header.num_bytes);
 
       // Check if we already read in the filter bitset in the initial read.
       if (initial_read_size >= bloom_filter_header_size + bitset_size) {
@@ -594,15 +594,12 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
   // Collect schema indices of columns with equality predicate(s)
   std::vector<cudf::size_type> equality_col_schemas;
   thrust::copy_if(thrust::host,
-                  output_column_schemas.begin(), 
+                  output_column_schemas.begin(),
                   output_column_schemas.end(),
                   equality_literals.begin(),
                   std::back_inserter(equality_col_schemas),
                   [](auto& eq_literals) { not return eq_literals.empty(); });
 
-  // Read bloom filters and add literal membership columns.
-  std::vector<std::unique_ptr<cudf::column>> bloom_filter_membership_columns;
-
   // Return early if no column with equality predicate(s)
   if (equality_col_schemas.empty()) { return std::nullopt; }
 
@@ -632,13 +629,14 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
   auto const bloom_filter_spans =
     cudf::detail::make_device_uvector_async(h_bloom_filter_spans, stream, mr);
 
-  // Create a bloom filter query table caster.
+  // Create a bloom filter query table caster
   bloom_filter_caster const bloom_filter_col{
     bloom_filter_spans, parquet_types, total_row_groups, equality_col_schemas.size()};
 
   // Converts bloom filter membership for equality predicate columns to a table
   // containing a column for each `col[i] == literal` predicate to be evaluated.
   // The table contains #sources * #column_chunks_per_src rows.
+  std::vector<std::unique_ptr<cudf::column>> bloom_filter_membership_columns;
   size_t equality_col_idx = 0;
   std::for_each(
     thrust::make_counting_iterator<size_t>(0),
@@ -659,6 +657,8 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
       }
       equality_col_idx++;
     });
+
+  // Create a table from columns
   auto bloom_filter_membership_table = cudf::table(std::move(bloom_filter_membership_columns));
 
   // Convert AST to BloomfilterAST expression with reference to bloom filter membership

From 8bc8927af3241a0da36a02b9b67585ec8db73460 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <14217455+mhaseeb123@users.noreply.github.com>
Date: Mon, 9 Dec 2024 12:32:24 -0800
Subject: [PATCH 64/85] Update cpp/src/io/parquet/reader_impl_helpers.hpp

Co-authored-by: Vukasin Milovanovic <vmilovanovic@nvidia.com>
---
 cpp/src/io/parquet/reader_impl_helpers.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index e717ee5c126..d61ae241504 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -357,7 +357,7 @@ class aggregate_reader_metadata {
    *
    * @param sources Lists of input datasources
    * @param row_group_indices Lists of row groups to read, one per source
-   * @param output_dtypes Datatypes of of output columns
+   * @param output_dtypes Datatypes of output columns
    * @param output_column_schemas schema indices of output columns
    * @param filter AST expression to filter row groups based on Column chunk statistics
    * @param stream CUDA stream used for device memory operations and kernel launches

From d719e65757aaf117945111a041e59df3b7698030 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <14217455+mhaseeb123@users.noreply.github.com>
Date: Mon, 9 Dec 2024 12:32:33 -0800
Subject: [PATCH 65/85] Update cpp/src/io/parquet/reader_impl_helpers.hpp

Co-authored-by: Vukasin Milovanovic <vmilovanovic@nvidia.com>
---
 cpp/src/io/parquet/reader_impl_helpers.hpp | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index d61ae241504..b670c1a63d9 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -376,7 +376,7 @@ class aggregate_reader_metadata {
    *
    * @param sources Dataset sources
    * @param row_group_indices Lists of input row groups to read, one per source
-   * @param output_dtypes Datatypes of of output columns
+   * @param output_dtypes Datatypes of output columns
    * @param output_column_schemas schema indices of output columns
    * @param filter AST expression to filter row groups based on bloom filter membership
    * @param total_row_groups Total number of row groups across all data sources

From 03cf07f08b96d414d6555723163f96b5f0f437e0 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Mon, 9 Dec 2024 21:02:43 +0000
Subject: [PATCH 66/85] Move equality_literals instead of copying

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 6aa688aefb2..80e9b5b315e 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -246,7 +246,7 @@ class equality_literals_collector : public ast::detail::expression_transformer {
    *
    * @return Vectors of equality literals, one per input table column
    */
-  [[nodiscard]] std::vector<std::vector<ast::literal*>> const get_equality_literals() const
+  [[nodiscard]] std::vector<std::vector<ast::literal*>> get_equality_literals() const
   {
     return _equality_literals;
   }

From c92d3265b6e530af3a581d205efc25de44c4c432 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Mon, 9 Dec 2024 21:19:06 +0000
Subject: [PATCH 67/85] Minor

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 80e9b5b315e..48f82c6e3d2 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -598,7 +598,7 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
                   output_column_schemas.end(),
                   equality_literals.begin(),
                   std::back_inserter(equality_col_schemas),
-                  [](auto& eq_literals) { not return eq_literals.empty(); });
+                  [](auto& eq_literals) { return not eq_literals.empty(); });
 
   // Return early if no column with equality predicate(s)
   if (equality_col_schemas.empty()) { return std::nullopt; }

From 82083f994e8d34eed15a875c4e3c8d33dfcef2ce Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 10 Dec 2024 01:52:35 +0000
Subject: [PATCH 68/85] Use spans instead of passing around vectors

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 22 +++++++++++++---------
 1 file changed, 13 insertions(+), 9 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 48f82c6e3d2..0b16332fa0a 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -246,11 +246,14 @@ class equality_literals_collector : public ast::detail::expression_transformer {
    *
    * @return Vectors of equality literals, one per input table column
    */
-  [[nodiscard]] std::vector<std::vector<ast::literal*>> get_equality_literals() const
+  [[nodiscard]] cudf::host_span<std::vector<ast::literal*> const> get_equality_literals() const
   {
-    return _equality_literals;
+    return {_equality_literals};
   }
 
+ private:
+  std::vector<std::vector<ast::literal*>> _equality_literals;
+
  protected:
   std::vector<std::reference_wrapper<ast::expression const>> visit_operands(
     cudf::host_span<std::reference_wrapper<ast::expression const> const> operands)
@@ -263,7 +266,6 @@ class equality_literals_collector : public ast::detail::expression_transformer {
     return transformed_operands;
   }
   std::optional<std::reference_wrapper<ast::expression const>> _bloom_filter_expr;
-  std::vector<std::vector<ast::literal*>> _equality_literals;
   std::list<ast::column_reference> _col_ref;
   std::list<ast::operation> _operators;
   size_type _num_input_columns;
@@ -278,11 +280,11 @@ class bloom_filter_expression_converter : public equality_literals_collector {
   bloom_filter_expression_converter(
     ast::expression const& expr,
     size_type num_input_columns,
-    std::vector<std::vector<ast::literal*>> const& equality_literals)
+    cudf::host_span<std::vector<ast::literal*> const> equality_literals)
+    : _equality_literals{equality_literals}
   {
-    // Set the num columns and copy equality literals
+    // Set the num columns
     _num_input_columns = num_input_columns;
-    _equality_literals = equality_literals;
 
     // Compute and store columns literals offsets
     _col_literals_offsets.reserve(_num_input_columns + 1);
@@ -303,7 +305,8 @@ class bloom_filter_expression_converter : public equality_literals_collector {
   /**
    * @brief Delete equality literals getter as no longer needed
    */
-  [[nodiscard]] std::vector<std::vector<ast::literal*>> get_equality_literals() = delete;
+  [[nodiscard]] cudf::host_span<std::vector<ast::literal*> const> get_equality_literals() const =
+    delete;
 
   // Bring all overloads of `visit` from equality_predicate_collector into scope
   using equality_literals_collector::visit;
@@ -365,6 +368,7 @@ class bloom_filter_expression_converter : public equality_literals_collector {
 
  private:
   std::vector<cudf::size_type> _col_literals_offsets;
+  cudf::host_span<std::vector<ast::literal*> const> _equality_literals;
 };
 
 /**
@@ -588,8 +592,8 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
   auto mr = cudf::get_current_device_resource_ref();
 
   // Collect equality literals for each input table column
-  auto const equality_literals =
-    equality_literals_collector{filter.get(), num_input_columns}.get_equality_literals();
+  auto const eq_literals_collector = equality_literals_collector{filter.get(), num_input_columns};
+  auto const equality_literals     = eq_literals_collector.get_equality_literals();
 
   // Collect schema indices of columns with equality predicate(s)
   std::vector<cudf::size_type> equality_col_schemas;

From 6918a4070528e1aa2330263e1155cf72808b1a19 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 10 Dec 2024 02:08:45 +0000
Subject: [PATCH 69/85] Minor

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 13 ++++++-------
 1 file changed, 6 insertions(+), 7 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 0b16332fa0a..f9f236a6cec 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -246,9 +246,9 @@ class equality_literals_collector : public ast::detail::expression_transformer {
    *
    * @return Vectors of equality literals, one per input table column
    */
-  [[nodiscard]] cudf::host_span<std::vector<ast::literal*> const> get_equality_literals() const
+  [[nodiscard]] std::vector<std::vector<ast::literal*>> get_equality_literals()
   {
-    return {_equality_literals};
+    return std::move(_equality_literals);
   }
 
  private:
@@ -305,8 +305,7 @@ class bloom_filter_expression_converter : public equality_literals_collector {
   /**
    * @brief Delete equality literals getter as no longer needed
    */
-  [[nodiscard]] cudf::host_span<std::vector<ast::literal*> const> get_equality_literals() const =
-    delete;
+  [[nodiscard]] std::vector<std::vector<ast::literal*>> get_equality_literals() = delete;
 
   // Bring all overloads of `visit` from equality_predicate_collector into scope
   using equality_literals_collector::visit;
@@ -592,8 +591,8 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
   auto mr = cudf::get_current_device_resource_ref();
 
   // Collect equality literals for each input table column
-  auto const eq_literals_collector = equality_literals_collector{filter.get(), num_input_columns};
-  auto const equality_literals     = eq_literals_collector.get_equality_literals();
+  auto const equality_literals =
+    equality_literals_collector{filter.get(), num_input_columns}.get_equality_literals();
 
   // Collect schema indices of columns with equality predicate(s)
   std::vector<cudf::size_type> equality_col_schemas;
@@ -668,7 +667,7 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
   // Convert AST to BloomfilterAST expression with reference to bloom filter membership
   // in above `bloom_filter_membership_table`
   bloom_filter_expression_converter bloom_filter_expr{
-    filter.get(), num_input_columns, equality_literals};
+    filter.get(), num_input_columns, {equality_literals}};
 
   // Filter bloom filter membership table with the BloomfilterAST expression and collect
   // filtered row group indices

From 85cdc0099f8f29b2644382c13077a25c98fdfb12 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 10 Dec 2024 02:22:02 +0000
Subject: [PATCH 70/85] Make `get_equality_literals()` safe again

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index f9f236a6cec..0b720419fad 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -246,7 +246,7 @@ class equality_literals_collector : public ast::detail::expression_transformer {
    *
    * @return Vectors of equality literals, one per input table column
    */
-  [[nodiscard]] std::vector<std::vector<ast::literal*>> get_equality_literals()
+  [[nodiscard]] std::vector<std::vector<ast::literal*>> get_equality_literals() &&
   {
     return std::move(_equality_literals);
   }
@@ -305,7 +305,7 @@ class bloom_filter_expression_converter : public equality_literals_collector {
   /**
    * @brief Delete equality literals getter as no longer needed
    */
-  [[nodiscard]] std::vector<std::vector<ast::literal*>> get_equality_literals() = delete;
+  [[nodiscard]] std::vector<std::vector<ast::literal*>> get_equality_literals() && = delete;
 
   // Bring all overloads of `visit` from equality_predicate_collector into scope
   using equality_literals_collector::visit;

From fdf8fc87a2a30a75e252aadc032cabab5920e081 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 10 Dec 2024 02:46:15 +0000
Subject: [PATCH 71/85] Update counting_iterator

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 0b720419fad..ba47156a993 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -394,8 +394,8 @@ void read_bloom_filter_data(host_span<std::unique_ptr<datasource> const> sources
 
   // Read bloom filters for all column chunks
   std::for_each(
-    thrust::make_counting_iterator<size_t>(0),
-    thrust::make_counting_iterator<size_t>(num_chunks),
+    thrust::counting_iterator<size_t>(0),
+    thrust::counting_iterator(num_chunks),
     [&](auto const chunk) {
       // If bloom filter offset absent, fill in an empty buffer and skip ahead
       if (not bloom_filter_offsets[chunk].has_value()) {
@@ -504,8 +504,8 @@ std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
   size_type chunk_count = 0;
 
   // For all data sources
-  std::for_each(thrust::make_counting_iterator<size_t>(0),
-                thrust::make_counting_iterator(row_group_indices.size()),
+  std::for_each(thrust::counting_iterator<size_t>(0),
+                thrust::counting_iterator(row_group_indices.size()),
                 [&](auto const src_index) {
                   // Get all row group indices in the data source
                   auto const& rg_indices = row_group_indices[src_index];
@@ -642,8 +642,8 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
   std::vector<std::unique_ptr<cudf::column>> bloom_filter_membership_columns;
   size_t equality_col_idx = 0;
   std::for_each(
-    thrust::make_counting_iterator<size_t>(0),
-    thrust::make_counting_iterator(output_dtypes.size()),
+    thrust::counting_iterator<size_t>(0),
+    thrust::counting_iterator(output_dtypes.size()),
     [&](auto input_col_idx) {
       auto const& dtype = output_dtypes[input_col_idx];
 

From 10a8f5a0b2d45761401551125f89f76bbba6bb58 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 10 Dec 2024 22:07:57 +0000
Subject: [PATCH 72/85] Minor changes

---
 cpp/include/cudf/hashing/detail/xxhash_64.cuh |  3 +--
 cpp/src/io/parquet/arrow_filter_policy.cuh    | 16 +++++++---------
 2 files changed, 8 insertions(+), 11 deletions(-)

diff --git a/cpp/include/cudf/hashing/detail/xxhash_64.cuh b/cpp/include/cudf/hashing/detail/xxhash_64.cuh
index d57cd84efa8..d77d040b365 100644
--- a/cpp/include/cudf/hashing/detail/xxhash_64.cuh
+++ b/cpp/include/cudf/hashing/detail/xxhash_64.cuh
@@ -29,8 +29,7 @@ namespace cudf::hashing::detail {
 
 template <typename Key>
 struct XXHash_64 {
-  using argument_type = Key;
-  using result_type   = std::uint64_t;
+  using result_type = std::uint64_t;
 
   CUDF_HOST_DEVICE constexpr XXHash_64(uint64_t seed = cudf::DEFAULT_HASH_SEED) : _impl{seed} {}
 
diff --git a/cpp/src/io/parquet/arrow_filter_policy.cuh b/cpp/src/io/parquet/arrow_filter_policy.cuh
index dfb6745bed8..74923b46a4a 100644
--- a/cpp/src/io/parquet/arrow_filter_policy.cuh
+++ b/cpp/src/io/parquet/arrow_filter_policy.cuh
@@ -30,8 +30,6 @@ namespace cuco {
  * @brief A policy that defines how Arrow Block-Split Bloom Filter generates and stores a key's
  * fingerprint.
  *
- * @note: This file is a part of cuCollections. Copied here until we get a cuco bump for cudf.
- *
  * Reference:
  * https://github.com/apache/arrow/blob/be1dcdb96b030639c0b56955c4c62f9d6b03f473/cpp/src/parquet/bloom_filter.cc#L219-L230
  *
@@ -41,14 +39,14 @@ namespace cuco {
  * void bulk_insert_and_eval_arrow_policy_bloom_filter(device_vector<KeyType> const& positive_keys,
  *                                                 device_vector<KeyType> const& negative_keys)
  * {
- *     using policy_type = cuco::arrow_filter_policy<key_type>;
+ *     using policy_type = cuco::arrow_filter_policy<KeyType, cuco::xxhash_64>;
  *
  *     // Warn or throw if the number of filter blocks is greater than maximum used by Arrow policy.
  *     static_assert(NUM_FILTER_BLOCKS <= policy_type::max_filter_blocks, "NUM_FILTER_BLOCKS must be
  *                                                                         in range: [1, 4194304]");
  *
  *     // Create a bloom filter with Arrow policy
- *     cuco::bloom_filter<key_type, cuco::extent<size_t>,
+ *     cuco::bloom_filter<KeyType, cuco::extent<size_t>,
  *         cuda::thread_scope_device, policy_type> filter{NUM_FILTER_BLOCKS};
  *
  *     // Add positive keys to the bloom filter
@@ -79,15 +77,15 @@ namespace cuco {
  * @endcode
  *
  * @tparam Key The type of the values to generate a fingerprint for.
+ * @tparam XXHash64 64-bit XXHash hasher implementation for fingerprint generation.
  */
-template <class Key, class Hash>
+template <class Key, template <typename> class XXHash64>
 class arrow_filter_policy {
  public:
-  using hasher             = Hash;           ///< Hash function for Arrow bloom filter policy
+  using hasher             = XXHash64<Key>;  ///< 64-bit XXHash hasher for Arrow bloom filter policy
   using word_type          = std::uint32_t;  ///< uint32_t for Arrow bloom filter policy
-  using hash_argument_type = typename hasher::argument_type;  ///< Hash function input type
-  using hash_result_type   = decltype(std::declval<hasher>()(
-    std::declval<hash_argument_type>()));  ///< hash function output type
+  using hash_argument_type = Key;            ///< Hash function input type
+  using hash_result_type   = std::uint64_t;  ///< hash function output type
 
   static constexpr uint32_t bits_set_per_block = 8;  ///< hardcoded bits set per Arrow filter block
   static constexpr uint32_t words_per_block    = 8;  ///< hardcoded words per Arrow filter block

From d46504fef4253f0b09b7d2d46d584b3c9adf9d91 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 10 Dec 2024 22:12:37 +0000
Subject: [PATCH 73/85] Minor

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 9 ++++-----
 cpp/tests/io/parquet_bloom_filter_test.cu | 5 ++---
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index ba47156a993..c4c512f7a6f 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -64,8 +64,7 @@ struct bloom_filter_caster {
                                                    rmm::device_async_resource_ref mr) const
   {
     using key_type    = T;
-    using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
-    using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
+    using policy_type = cuco::arrow_filter_policy<key_type, cudf::hashing::detail::XXHash_64>;
     using word_type   = typename policy_type::word_type;
 
     // Check if the literal has the same type as the predicate column
@@ -423,9 +422,9 @@ void read_bloom_filter_data(host_span<std::unique_ptr<datasource> const> sources
 
       // Get the hardcoded words_per_block value from `cuco::arrow_filter_policy` using a temporary
       // `std::byte` key type.
-      auto constexpr words_per_block = cuco::arrow_filter_policy<
-        cuda::std::byte,
-        cudf::hashing::detail::XXHash_64<cuda::std::byte>>::words_per_block;
+      auto constexpr words_per_block =
+        cuco::arrow_filter_policy<cuda::std::byte,
+                                  cudf::hashing::detail::XXHash_64>::words_per_block;
 
       // Check if the bloom filter header is valid.
       auto const is_header_valid =
diff --git a/cpp/tests/io/parquet_bloom_filter_test.cu b/cpp/tests/io/parquet_bloom_filter_test.cu
index c290de4568a..827fc4b03b4 100644
--- a/cpp/tests/io/parquet_bloom_filter_test.cu
+++ b/cpp/tests/io/parquet_bloom_filter_test.cu
@@ -36,8 +36,7 @@ class ParquetBloomFilterTest : public cudf::test::BaseFixture {};
 TEST_F(ParquetBloomFilterTest, TestStrings)
 {
   using key_type    = StringType;
-  using hasher_type = cudf::hashing::detail::XXHash_64<key_type>;
-  using policy_type = cuco::arrow_filter_policy<key_type, hasher_type>;
+  using policy_type = cuco::arrow_filter_policy<key_type, cudf::hashing::detail::XXHash_64>;
   using word_type   = policy_type::word_type;
 
   std::size_t constexpr num_filter_blocks = 4;
@@ -65,7 +64,7 @@ TEST_F(ParquetBloomFilterTest, TestStrings)
                      cudf::detail::cuco_allocator<char>>
     filter{num_filter_blocks,
            cuco::thread_scope_device,
-           {hasher_type{cudf::DEFAULT_HASH_SEED}},
+           {{cudf::DEFAULT_HASH_SEED}},
            cudf::detail::cuco_allocator<char>{rmm::mr::polymorphic_allocator<char>{}, stream},
            stream};
 

From c94ce86c84a4289ba18b886c1894cee66acd65a1 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 10 Dec 2024 22:21:51 +0000
Subject: [PATCH 74/85] Sync arrow filter policy with cuco

---
 cpp/src/io/parquet/arrow_filter_policy.cuh | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/cpp/src/io/parquet/arrow_filter_policy.cuh b/cpp/src/io/parquet/arrow_filter_policy.cuh
index 74923b46a4a..01f20e86e6c 100644
--- a/cpp/src/io/parquet/arrow_filter_policy.cuh
+++ b/cpp/src/io/parquet/arrow_filter_policy.cuh
@@ -82,10 +82,10 @@ namespace cuco {
 template <class Key, template <typename> class XXHash64>
 class arrow_filter_policy {
  public:
-  using hasher             = XXHash64<Key>;  ///< 64-bit XXHash hasher for Arrow bloom filter policy
-  using word_type          = std::uint32_t;  ///< uint32_t for Arrow bloom filter policy
-  using hash_argument_type = Key;            ///< Hash function input type
-  using hash_result_type   = std::uint64_t;  ///< hash function output type
+  using hasher          = XXHash64<Key>;  ///< 64-bit XXHash hasher for Arrow bloom filter policy
+  using word_type       = std::uint32_t;  ///< uint32_t for Arrow bloom filter policy
+  using key_type        = Key;            ///< Hash function input type
+  using hash_value_type = std::uint64_t;  ///< hash function output type
 
   static constexpr uint32_t bits_set_per_block = 8;  ///< hardcoded bits set per Arrow filter block
   static constexpr uint32_t words_per_block    = 8;  ///< hardcoded words per Arrow filter block
@@ -132,10 +132,7 @@ class arrow_filter_policy {
    *
    * @return The hash value of the key
    */
-  __device__ constexpr hash_result_type hash(hash_argument_type const& key) const
-  {
-    return hash_(key);
-  }
+  __device__ constexpr hash_value_type hash(key_type const& key) const { return hash_(key); }
 
   /**
    * @brief Determines the filter block a key is added into.
@@ -152,7 +149,7 @@ class arrow_filter_policy {
    * @return The block index for the given key's hash value
    */
   template <class Extent>
-  __device__ constexpr auto block_index(hash_result_type hash, Extent num_blocks) const
+  __device__ constexpr auto block_index(hash_value_type hash, Extent num_blocks) const
   {
     constexpr auto hash_bits = cuda::std::numeric_limits<word_type>::digits;
     // TODO: assert if num_blocks > max_filter_blocks
@@ -170,7 +167,7 @@ class arrow_filter_policy {
    *
    * @return The bit pattern for the word/segment in the filter block
    */
-  __device__ constexpr word_type word_pattern(hash_result_type hash, std::uint32_t word_index) const
+  __device__ constexpr word_type word_pattern(hash_value_type hash, std::uint32_t word_index) const
   {
     // SALT array to calculate bit indexes for the current word
     auto constexpr salt = SALT();

From d95a1781019952ec5e5c454a7045e1b77cd037ac Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Thu, 12 Dec 2024 10:59:48 +0000
Subject: [PATCH 75/85] Address partial reviewer comments and fix new logger
 header

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index c4c512f7a6f..07a93cde21c 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -24,8 +24,8 @@
 #include <cudf/ast/expressions.hpp>
 #include <cudf/detail/cuco_helpers.hpp>
 #include <cudf/detail/transform.hpp>
-#include <cudf/detail/utilities/logger.hpp>
 #include <cudf/hashing/detail/xxhash_64.cuh>
+#include <cudf/logger.hpp>
 #include <cudf/utilities/span.hpp>
 #include <cudf/utilities/traits.hpp>
 #include <cudf/utilities/type_checks.hpp>
@@ -74,8 +74,7 @@ struct bloom_filter_caster {
       "Mismatched predicate column and literal types");
 
     // Filter properties
-    auto constexpr word_size       = sizeof(word_type);
-    auto constexpr words_per_block = policy_type::words_per_block;
+    auto constexpr bytes_per_block = sizeof(word_type) * policy_type::words_per_block;
 
     rmm::device_buffer results{total_row_groups, stream, mr};
 
@@ -100,7 +99,7 @@ struct bloom_filter_caster {
         }
 
         // Number of filter blocks
-        auto const num_filter_blocks = filter_size / (word_size * words_per_block);
+        auto const num_filter_blocks = filter_size / bytes_per_block;
 
         // Create a bloom filter view.
         cuco::bloom_filter_ref<key_type,

From 840c6e70cbe35ee318564f3d8630de24e1482031 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Thu, 12 Dec 2024 22:14:58 +0000
Subject: [PATCH 76/85] Revert to direct dtype check until I find a way to get
 scalar from literal

---
 cpp/src/io/parquet/bloom_filter_reader.cu  | 38 ++++++++++------------
 cpp/src/io/parquet/reader_impl_helpers.hpp |  3 +-
 2 files changed, 20 insertions(+), 21 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 07a93cde21c..f0d8b09640f 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -36,6 +36,7 @@
 
 #include <cuco/bloom_filter_ref.cuh>
 #include <thrust/iterator/counting_iterator.h>
+#include <thrust/tabulate.h>
 
 #include <future>
 #include <numeric>
@@ -68,35 +69,30 @@ struct bloom_filter_caster {
     using word_type   = typename policy_type::word_type;
 
     // Check if the literal has the same type as the predicate column
-    CUDF_EXPECTS(
-      cudf::have_same_types(cudf::column_view{dtype, 0, {}, {}, 0, 0, {}},
-                            cudf::column_view{literal->get_data_type(), 0, {}, {}, 0, 0, {}}),
-      "Mismatched predicate column and literal types");
+    CUDF_EXPECTS(dtype == literal->get_data_type(),
+                 "Mismatched predicate column and literal types");
 
     // Filter properties
     auto constexpr bytes_per_block = sizeof(word_type) * policy_type::words_per_block;
 
     rmm::device_buffer results{total_row_groups, stream, mr};
+    cudf::device_span<bool> results_span{static_cast<bool*>(results.data()), total_row_groups};
 
     // Query literal in bloom filters from each column chunk (row group).
-    thrust::for_each(
+    thrust::tabulate(
       rmm::exec_policy_nosync(stream),
-      thrust::counting_iterator<size_t>{0},
-      thrust::counting_iterator{total_row_groups},
+      results_span.begin(),
+      results_span.end(),
       [filter_span          = bloom_filter_spans.data(),
        d_scalar             = literal->get_value(),
        col_idx              = equality_col_idx,
-       num_equality_columns = num_equality_columns,
-       results = reinterpret_cast<bool*>(results.data())] __device__(auto row_group_idx) {
+       num_equality_columns = num_equality_columns] __device__(auto row_group_idx) {
         // Filter bitset buffer index
         auto const filter_idx  = col_idx + (num_equality_columns * row_group_idx);
         auto const filter_size = filter_span[filter_idx].size();
 
         // If no bloom filter, then fill in `true` as membership cannot be determined
-        if (filter_size == 0) {
-          results[row_group_idx] = true;
-          return;
-        }
+        if (filter_size == 0) { return true; }
 
         // Number of filter blocks
         auto const num_filter_blocks = filter_size / bytes_per_block;
@@ -119,10 +115,10 @@ struct bloom_filter_caster {
                       IS_INT96_TIMESTAMP == is_int96_timestamp::YES) {
           auto const int128_key = static_cast<__int128_t>(d_scalar.value<int64_t>());
           cudf::string_view probe_key{reinterpret_cast<char const*>(&int128_key), 12};
-          results[row_group_idx] = filter.contains(probe_key);
+          return filter.contains(probe_key);
         } else {
           // Query the bloom filter and store results
-          results[row_group_idx] = filter.contains(d_scalar.value<T>());
+          return filter.contains(d_scalar.value<T>());
         }
       });
 
@@ -144,17 +140,19 @@ struct bloom_filter_caster {
     // List, Struct, Dictionary types are not supported
     if constexpr (cudf::is_compound<T>() and not std::is_same_v<T, string_view>) {
       CUDF_FAIL("Compound types don't support equality predicate");
-    } else if constexpr (cudf::is_timestamp<T>()) {
+    }
+
+    // For INT96 timestamps, use cudf::string_view type and set is_int96_timestamp to YES
+    if constexpr (cudf::is_timestamp<T>()) {
       if (parquet_types[equality_col_idx] == Type::INT96) {
         // For INT96 timestamps, use cudf::string_view type and set is_int96_timestamp to YES
         return query_bloom_filter<cudf::string_view, bloom_filter_caster::is_int96_timestamp::YES>(
           equality_col_idx, dtype, literal, stream, mr);
-      } else {
-        return query_bloom_filter<T>(equality_col_idx, dtype, literal, stream, mr);
       }
-    } else {
-      return query_bloom_filter<T>(equality_col_idx, dtype, literal, stream, mr);
     }
+
+    // For all other cases
+    return query_bloom_filter<T>(equality_col_idx, dtype, literal, stream, mr);
   }
 };
 
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index b670c1a63d9..8b9370cb499 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -513,7 +513,8 @@ class named_to_reference_converter : public ast::detail::expression_transformer
  * @param stream CUDA stream used for device memory operations and kernel launches
  * @param mr Device memory resource used to be used in cudf::compute_column
  *
- * @return Collected filtered row group indices, if any.
+ * @return Collected filtered row group indices, one vector per source, if any. A std::nullopt if
+ * all row groups are required or if the computed predicate is all nulls
  */
 [[nodiscard]] std::optional<std::vector<std::vector<size_type>>> collect_filtered_row_group_indices(
   cudf::table_view ast_table,

From 9d8c0714198106941c8eea02eaf616e95d25f0b3 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Thu, 12 Dec 2024 22:21:21 +0000
Subject: [PATCH 77/85] Create a dummy scalar of type T and compare with dtype

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 18 ++++++++++--------
 1 file changed, 10 insertions(+), 8 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index f0d8b09640f..326665089c5 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -68,9 +68,16 @@ struct bloom_filter_caster {
     using policy_type = cuco::arrow_filter_policy<key_type, cudf::hashing::detail::XXHash_64>;
     using word_type   = typename policy_type::word_type;
 
-    // Check if the literal has the same type as the predicate column
-    CUDF_EXPECTS(dtype == literal->get_data_type(),
-                 "Mismatched predicate column and literal types");
+    // List, Struct, Dictionary types are not supported
+    if constexpr (cudf::is_compound<T>() and not std::is_same_v<T, string_view>) {
+      CUDF_FAIL("Compound types don't support equality predicate");
+    } else {
+      // Check if the literal has the same type as the predicate column
+      auto const scalar = cudf::scalar_type_t<T>(T{}, false, stream, mr);
+      CUDF_EXPECTS(dtype == literal->get_data_type() and
+                     cudf::have_same_types(cudf::column_view{dtype, 0, {}, {}, 0, 0, {}}, scalar),
+                   "Mismatched predicate column and literal types");
+    }
 
     // Filter properties
     auto constexpr bytes_per_block = sizeof(word_type) * policy_type::words_per_block;
@@ -137,11 +144,6 @@ struct bloom_filter_caster {
                                            rmm::cuda_stream_view stream,
                                            rmm::device_async_resource_ref mr) const
   {
-    // List, Struct, Dictionary types are not supported
-    if constexpr (cudf::is_compound<T>() and not std::is_same_v<T, string_view>) {
-      CUDF_FAIL("Compound types don't support equality predicate");
-    }
-
     // For INT96 timestamps, use cudf::string_view type and set is_int96_timestamp to YES
     if constexpr (cudf::is_timestamp<T>()) {
       if (parquet_types[equality_col_idx] == Type::INT96) {

From 3b8aea0b457cc65ff292ff8ecef7e2ed3c5efdf4 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Thu, 12 Dec 2024 22:23:05 +0000
Subject: [PATCH 78/85] Use a temporary scalar

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 326665089c5..9fe1fc3fce9 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -73,9 +73,9 @@ struct bloom_filter_caster {
       CUDF_FAIL("Compound types don't support equality predicate");
     } else {
       // Check if the literal has the same type as the predicate column
-      auto const scalar = cudf::scalar_type_t<T>(T{}, false, stream, mr);
       CUDF_EXPECTS(dtype == literal->get_data_type() and
-                     cudf::have_same_types(cudf::column_view{dtype, 0, {}, {}, 0, 0, {}}, scalar),
+                     cudf::have_same_types(cudf::column_view{dtype, 0, {}, {}, 0, 0, {}},
+                                           cudf::scalar_type_t<T>(T{}, false, stream, mr)),
                    "Mismatched predicate column and literal types");
     }
 

From c385537c847ec03a77f67bc519f9b0592c83423e Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Fri, 13 Dec 2024 00:58:38 +0000
Subject: [PATCH 79/85] Recalculate `total_row_groups` in apply_bloom_filter

---
 cpp/src/io/parquet/bloom_filter_reader.cu  | 12 +++++++++++-
 cpp/src/io/parquet/predicate_pushdown.cpp  |  9 ++-------
 cpp/src/io/parquet/reader_impl_helpers.hpp |  2 --
 3 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 9fe1fc3fce9..0d919ed8e78 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -580,12 +580,22 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::ap
   host_span<data_type const> output_dtypes,
   host_span<int const> output_column_schemas,
   std::reference_wrapper<ast::expression const> filter,
-  size_t total_row_groups,
   rmm::cuda_stream_view stream) const
 {
   // Number of input table columns
   auto const num_input_columns = static_cast<cudf::size_type>(output_dtypes.size());
 
+  // Total number of row groups after StatsAST filtration
+  auto const total_row_groups = std::accumulate(
+    input_row_group_indices.begin(),
+    input_row_group_indices.end(),
+    size_t{0},
+    [](size_t sum, auto const& per_file_row_groups) { return sum + per_file_row_groups.size(); });
+
+  // Check if we have less than 2B total row groups.
+  CUDF_EXPECTS(total_row_groups <= std::numeric_limits<cudf::size_type>::max(),
+               "Total number of row groups exceed the size_type's limit");
+
   auto mr = cudf::get_current_device_resource_ref();
 
   // Collect equality literals for each input table column
diff --git a/cpp/src/io/parquet/predicate_pushdown.cpp b/cpp/src/io/parquet/predicate_pushdown.cpp
index 7ae671fbf96..a4eb210c9f0 100644
--- a/cpp/src/io/parquet/predicate_pushdown.cpp
+++ b/cpp/src/io/parquet/predicate_pushdown.cpp
@@ -471,13 +471,8 @@ std::optional<std::vector<std::vector<size_type>>> aggregate_reader_metadata::fi
       : input_row_group_indices;
 
   // Apply bloom filtering on the bloom filter input row groups
-  auto const bloom_filtered_row_groups = apply_bloom_filters(sources,
-                                                             bloom_filter_input_row_groups,
-                                                             output_dtypes,
-                                                             output_column_schemas,
-                                                             filter,
-                                                             total_row_groups,
-                                                             stream);
+  auto const bloom_filtered_row_groups = apply_bloom_filters(
+    sources, bloom_filter_input_row_groups, output_dtypes, output_column_schemas, filter, stream);
 
   // Return bloom filtered row group indices iff collected
   return bloom_filtered_row_groups.has_value() ? bloom_filtered_row_groups
diff --git a/cpp/src/io/parquet/reader_impl_helpers.hpp b/cpp/src/io/parquet/reader_impl_helpers.hpp
index 8b9370cb499..57ff8954a23 100644
--- a/cpp/src/io/parquet/reader_impl_helpers.hpp
+++ b/cpp/src/io/parquet/reader_impl_helpers.hpp
@@ -379,7 +379,6 @@ class aggregate_reader_metadata {
    * @param output_dtypes Datatypes of output columns
    * @param output_column_schemas schema indices of output columns
    * @param filter AST expression to filter row groups based on bloom filter membership
-   * @param total_row_groups Total number of row groups across all data sources
    * @param stream CUDA stream used for device memory operations and kernel launches
    *
    * @return Filtered row group indices, if any is filtered
@@ -390,7 +389,6 @@ class aggregate_reader_metadata {
     host_span<data_type const> output_dtypes,
     host_span<int const> output_column_schemas,
     std::reference_wrapper<ast::expression const> filter,
-    size_t total_row_groups,
     rmm::cuda_stream_view stream) const;
 
   /**

From 3693ad1222f22ad3445af03e398333e40076f9f0 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Fri, 13 Dec 2024 22:46:24 +0000
Subject: [PATCH 80/85] Simplify bloom filter expression with ast::tree and
 handle non-equality operators in the expression

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 41 +++++++++++------------
 1 file changed, 20 insertions(+), 21 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 0d919ed8e78..7e10f59853b 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -178,7 +178,6 @@ class equality_literals_collector : public ast::detail::expression_transformer {
    */
   std::reference_wrapper<ast::expression const> visit(ast::literal const& expr) override
   {
-    _bloom_filter_expr = std::reference_wrapper<ast::expression const>(expr);
     return expr;
   }
 
@@ -191,7 +190,6 @@ class equality_literals_collector : public ast::detail::expression_transformer {
                  "BloomfilterAST supports only left table");
     CUDF_EXPECTS(expr.get_column_index() < _num_input_columns,
                  "Column index cannot be more than number of columns in the table");
-    _bloom_filter_expr = std::reference_wrapper<ast::expression const>(expr);
     return expr;
   }
 
@@ -228,15 +226,11 @@ class equality_literals_collector : public ast::detail::expression_transformer {
         _equality_literals[col_idx].emplace_back(const_cast<ast::literal*>(literal_ptr));
       }
     } else {
-      auto new_operands = visit_operands(operands);
-      if (cudf::ast::detail::ast_operator_arity(op) == 2) {
-        _operators.emplace_back(op, new_operands.front(), new_operands.back());
-      } else if (cudf::ast::detail::ast_operator_arity(op) == 1) {
-        _operators.emplace_back(op, new_operands.front());
-      }
+      // Just visit the operands and ignore any output
+      std::ignore = visit_operands(operands);
     }
-    _bloom_filter_expr = std::reference_wrapper<ast::expression const>(_operators.back());
-    return std::reference_wrapper<ast::expression const>(_operators.back());
+
+    return expr;
   }
 
   /**
@@ -263,9 +257,6 @@ class equality_literals_collector : public ast::detail::expression_transformer {
     }
     return transformed_operands;
   }
-  std::optional<std::reference_wrapper<ast::expression const>> _bloom_filter_expr;
-  std::list<ast::column_reference> _col_ref;
-  std::list<ast::operation> _operators;
   size_type _num_input_columns;
 };
 
@@ -337,20 +328,25 @@ class bloom_filter_expression_converter : public equality_literals_collector {
         col_literal_offset += std::distance(equality_literals.cbegin(), literal_iter);
 
         // Evaluate boolean is_true(value) expression as NOT(NOT(value))
-        auto const& value = _col_ref.emplace_back(col_literal_offset);
-        auto const& op    = _operators.emplace_back(ast_operator::NOT, value);
-        _operators.emplace_back(ast_operator::NOT, op);
+        auto const& value = _bloom_filter_expr.push(ast::column_reference{col_literal_offset});
+        _bloom_filter_expr.push(ast::operation{
+          ast_operator::NOT, _bloom_filter_expr.push(ast::operation{ast_operator::NOT, value})});
+      }
+      // For all other expressions, push an always true expression
+      else {
+        _bloom_filter_expr.push(
+          ast::operation{ast_operator::NOT,
+                         _bloom_filter_expr.push(ast::operation{ast_operator::NOT, _always_true})});
       }
     } else {
       auto new_operands = visit_operands(operands);
       if (cudf::ast::detail::ast_operator_arity(op) == 2) {
-        _operators.emplace_back(op, new_operands.front(), new_operands.back());
+        _bloom_filter_expr.push(ast::operation{op, new_operands.front(), new_operands.back()});
       } else if (cudf::ast::detail::ast_operator_arity(op) == 1) {
-        _operators.emplace_back(op, new_operands.front());
+        _bloom_filter_expr.push(ast::operation{op, new_operands.front()});
       }
     }
-    _bloom_filter_expr = std::reference_wrapper<ast::expression const>(_operators.back());
-    return std::reference_wrapper<ast::expression const>(_operators.back());
+    return _bloom_filter_expr.back();
   }
 
   /**
@@ -360,12 +356,15 @@ class bloom_filter_expression_converter : public equality_literals_collector {
    */
   [[nodiscard]] std::reference_wrapper<ast::expression const> get_bloom_filter_expr() const
   {
-    return _bloom_filter_expr.value().get();
+    return _bloom_filter_expr.back();
   }
 
  private:
   std::vector<cudf::size_type> _col_literals_offsets;
   cudf::host_span<std::vector<ast::literal*> const> _equality_literals;
+  ast::tree _bloom_filter_expr;
+  cudf::numeric_scalar<bool> _always_true_scalar{true};
+  ast::literal const _always_true{_always_true_scalar};
 };
 
 /**

From c2de9fb0f474f01842bb1bb894ec7f3ba28021c0 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <14217455+mhaseeb123@users.noreply.github.com>
Date: Fri, 13 Dec 2024 15:17:03 -0800
Subject: [PATCH 81/85] Apply suggestions from code review

Co-authored-by: Vukasin Milovanovic <vmilovanovic@nvidia.com>
---
 cpp/src/io/parquet/bloom_filter_reader.cu | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index 7e10f59853b..bd4f90c9e73 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -292,7 +292,7 @@ class bloom_filter_expression_converter : public equality_literals_collector {
   }
 
   /**
-   * @brief Delete equality literals getter as no longer needed
+   * @brief Delete equality literals getter as it's not needed in the derived class
    */
   [[nodiscard]] std::vector<std::vector<ast::literal*>> get_equality_literals() && = delete;
 
@@ -468,13 +468,9 @@ void read_bloom_filter_data(host_span<std::unique_ptr<datasource> const> sources
     });
 
   // Read task sync function
-  auto sync_fn = [](decltype(read_tasks) read_tasks) {
-    for (auto& task : read_tasks) {
-      task.wait();
-    }
-  };
-
-  std::async(std::launch::async, sync_fn, std::move(read_tasks)).wait();
+  for (auto& task : read_tasks) {
+    task.wait();
+  }
 }
 
 }  // namespace

From 344851c176798fd74093b0111a8395fc0b6f37af Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Sat, 14 Dec 2024 00:11:29 +0000
Subject: [PATCH 82/85] Minor optimization: Set `have_bloom_filters` while
 populating `bloom_filter_offsets`

---
 cpp/src/io/parquet/bloom_filter_reader.cu | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index bd4f90c9e73..cc399494fc9 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -496,6 +496,9 @@ std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
   // Gather all bloom filter offsets and sizes.
   size_type chunk_count = 0;
 
+  // Flag to check if we have at least one valid bloom filter offset
+  auto have_bloom_filters = false;
+
   // For all data sources
   std::for_each(thrust::counting_iterator<size_t>(0),
                 thrust::counting_iterator(row_group_indices.size()),
@@ -513,6 +516,9 @@ std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
                         bloom_filter_offsets[chunk_count] = col_meta.bloom_filter_offset;
                         bloom_filter_sizes[chunk_count]   = col_meta.bloom_filter_length;
 
+                        // Set `have_bloom_filters` if `bloom_filter_offset` is valid
+                        if (col_meta.bloom_filter_offset.has_value()) { have_bloom_filters = true; }
+
                         // Map each column chunk to its source index
                         chunk_source_map[chunk_count] = src_index;
                         chunk_count++;
@@ -521,9 +527,7 @@ std::vector<rmm::device_buffer> aggregate_reader_metadata::read_bloom_filters(
                 });
 
   // Do we have any bloom filters
-  if (std::any_of(bloom_filter_offsets.cbegin(),
-                  bloom_filter_offsets.cend(),
-                  [](auto const offset) { return offset.has_value(); })) {
+  if (have_bloom_filters) {
     // Vector to hold bloom filter data
     std::vector<rmm::device_buffer> bloom_filter_data(num_chunks);
 

From 4522afaa306f9917d5588901fdf91a4cf396e1ec Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Mon, 16 Dec 2024 17:52:47 +0000
Subject: [PATCH 83/85] Add pytest to test logical or with non == expr

---
 python/cudf/cudf/tests/test_parquet.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/python/cudf/cudf/tests/test_parquet.py b/python/cudf/cudf/tests/test_parquet.py
index 5bb47864949..98c02ebe799 100644
--- a/python/cudf/cudf/tests/test_parquet.py
+++ b/python/cudf/cudf/tests/test_parquet.py
@@ -4392,6 +4392,7 @@ def test_parquet_reader_mismatched_nullability_structs(tmpdir):
         ([[("str", "==", "FINDME")], [("fp64", "==", float(500))]], 2),
         ([("fixed_pt", "==", decimal.Decimal(float(500)))], 2),
         ([[("ui32", "==", np.uint32(500)), ("str", "==", "FINDME")]], 2),
+        ([[("str", "==", "FINDME")], [("ui32", ">=", np.uint32(0))]], 1000),
         (
             [
                 ("str", "!=", "FINDME"),

From f509148c53709518f2d3329ab27aa64035ba1c43 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 17 Dec 2024 04:35:21 +0000
Subject: [PATCH 84/85] Remove temporary arrow_filter_policy.cuh and use cuco
 directly.

---
 cpp/src/io/parquet/arrow_filter_policy.cuh | 182 ---------------------
 cpp/src/io/parquet/bloom_filter_reader.cu  |   2 +-
 cpp/tests/io/parquet_bloom_filter_test.cu  |   4 +-
 3 files changed, 2 insertions(+), 186 deletions(-)
 delete mode 100644 cpp/src/io/parquet/arrow_filter_policy.cuh

diff --git a/cpp/src/io/parquet/arrow_filter_policy.cuh b/cpp/src/io/parquet/arrow_filter_policy.cuh
deleted file mode 100644
index 01f20e86e6c..00000000000
--- a/cpp/src/io/parquet/arrow_filter_policy.cuh
+++ /dev/null
@@ -1,182 +0,0 @@
-/*
- * Copyright (c) 2024, NVIDIA CORPORATION.
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <cuco/hash_functions.cuh>
-#include <cuda/functional>
-#include <cuda/std/bit>
-#include <cuda/std/limits>
-
-#include <cstdint>
-#include <nv/target>
-
-namespace cuco {
-
-/**
- * @brief A policy that defines how Arrow Block-Split Bloom Filter generates and stores a key's
- * fingerprint.
- *
- * Reference:
- * https://github.com/apache/arrow/blob/be1dcdb96b030639c0b56955c4c62f9d6b03f473/cpp/src/parquet/bloom_filter.cc#L219-L230
- *
- * Example:
- * @code{.cpp}
- * template <typename KeyType, std::uint32_t NUM_FILTER_BLOCKS>
- * void bulk_insert_and_eval_arrow_policy_bloom_filter(device_vector<KeyType> const& positive_keys,
- *                                                 device_vector<KeyType> const& negative_keys)
- * {
- *     using policy_type = cuco::arrow_filter_policy<KeyType, cuco::xxhash_64>;
- *
- *     // Warn or throw if the number of filter blocks is greater than maximum used by Arrow policy.
- *     static_assert(NUM_FILTER_BLOCKS <= policy_type::max_filter_blocks, "NUM_FILTER_BLOCKS must be
- *                                                                         in range: [1, 4194304]");
- *
- *     // Create a bloom filter with Arrow policy
- *     cuco::bloom_filter<KeyType, cuco::extent<size_t>,
- *         cuda::thread_scope_device, policy_type> filter{NUM_FILTER_BLOCKS};
- *
- *     // Add positive keys to the bloom filter
- *     filter.add(positive_keys.begin(), positive_keys.end());
- *
- *     auto const num_tp = positive_keys.size();
- *     auto const num_tn = negative_keys.size();
- *
- *     // Vectors to store query results.
- *     thrust::device_vector<bool> true_positive_result(num_tp, false);
- *     thrust::device_vector<bool> true_negative_result(num_tn, false);
- *
- *     // Query the bloom filter for the inserted keys.
- *     filter.contains(positive_keys.begin(), positive_keys.end(), true_positive_result.begin());
- *
- *     // We should see a true-positive rate of 1.
- *     float true_positive_rate = float(thrust::count(thrust::device,
- *          true_positive_result.begin(), true_positive_result.end(), true)) / float(num_tp);
- *
- *     // Query the bloom filter for the non-inserted keys.
- *     filter.contains(negative_keys.begin(), negative_keys.end(), true_negative_result.begin());
- *
- *     // We may see a false-positive rate > 0 depending on the number of bits in the
- *     // filter and the number of hashes used per key.
- *     float false_positive_rate = float(thrust::count(thrust::device,
- *          true_negative_result.begin(), true_negative_result.end(), true)) / float(num_tn);
- * }
- * @endcode
- *
- * @tparam Key The type of the values to generate a fingerprint for.
- * @tparam XXHash64 64-bit XXHash hasher implementation for fingerprint generation.
- */
-template <class Key, template <typename> class XXHash64>
-class arrow_filter_policy {
- public:
-  using hasher          = XXHash64<Key>;  ///< 64-bit XXHash hasher for Arrow bloom filter policy
-  using word_type       = std::uint32_t;  ///< uint32_t for Arrow bloom filter policy
-  using key_type        = Key;            ///< Hash function input type
-  using hash_value_type = std::uint64_t;  ///< hash function output type
-
-  static constexpr uint32_t bits_set_per_block = 8;  ///< hardcoded bits set per Arrow filter block
-  static constexpr uint32_t words_per_block    = 8;  ///< hardcoded words per Arrow filter block
-
-  static constexpr std::uint32_t bytes_per_filter_block =
-    32;  ///< Number of bytes in one Arrow filter block
-  static constexpr std::uint32_t max_arrow_filter_bytes =
-    128 * 1024 * 1024;  ///< Max bytes in Arrow bloom filter
-  static constexpr std::uint32_t max_filter_blocks =
-    (max_arrow_filter_bytes /
-     bytes_per_filter_block);  ///< Max sub-filter blocks allowed in Arrow bloom filter
-
- private:
-  // Arrow's block-based bloom filter algorithm needs these eight odd SALT values to calculate
-  // eight indexes of bit to set, one bit in each 32-bit (uint32_t) word.
-  __device__ static constexpr cuda::std::array<std::uint32_t, 8> SALT()
-  {
-    return {0x47b6137bU,
-            0x44974d91U,
-            0x8824ad5bU,
-            0xa2b7289dU,
-            0x705495c7U,
-            0x2df1424bU,
-            0x9efc4947U,
-            0x5c6bfb31U};
-  }
-
- public:
-  /**
-   * @brief Constructs the `arrow_filter_policy` object.
-   *
-   * @note The number of filter blocks with Arrow policy must be in the
-   * range of [1, 4194304]. If the bloom filter is constructed with a larger
-   * number of blocks, only the first 4194304 (128MB) blocks will be used.
-   *
-   * @param hash Hash function used to generate a key's fingerprint
-   */
-  __host__ __device__ constexpr arrow_filter_policy(hasher hash = {}) : hash_{hash} {}
-
-  /**
-   * @brief Generates the hash value for a given key.
-   *
-   * @param key The key to hash
-   *
-   * @return The hash value of the key
-   */
-  __device__ constexpr hash_value_type hash(key_type const& key) const { return hash_(key); }
-
-  /**
-   * @brief Determines the filter block a key is added into.
-   *
-   * @note The number of filter blocks with Arrow policy must be in the
-   * range of [1, 4194304]. Passing a larger `num_blocks` will still
-   * upperbound the number of blocks used to the mentioned range.
-   *
-   * @tparam Extent Size type that is used to determine the number of blocks in the filter
-   *
-   * @param hash Hash value of the key
-   * @param num_blocks Number of block in the filter
-   *
-   * @return The block index for the given key's hash value
-   */
-  template <class Extent>
-  __device__ constexpr auto block_index(hash_value_type hash, Extent num_blocks) const
-  {
-    constexpr auto hash_bits = cuda::std::numeric_limits<word_type>::digits;
-    // TODO: assert if num_blocks > max_filter_blocks
-    auto const max_blocks = cuda::std::min<Extent>(num_blocks, max_filter_blocks);
-    // Make sure we are only contained withing the `max_filter_blocks` blocks
-    return static_cast<word_type>(((hash >> hash_bits) * max_blocks) >> hash_bits) % max_blocks;
-  }
-
-  /**
-   * @brief Determines the fingerprint pattern for a word/segment within the filter block for a
-   * given key's hash value.
-   *
-   * @param hash Hash value of the key
-   * @param word_index Target word/segment within the filter block
-   *
-   * @return The bit pattern for the word/segment in the filter block
-   */
-  __device__ constexpr word_type word_pattern(hash_value_type hash, std::uint32_t word_index) const
-  {
-    // SALT array to calculate bit indexes for the current word
-    auto constexpr salt = SALT();
-    word_type const key = static_cast<word_type>(hash);
-    return word_type{1} << ((key * salt[word_index]) >> 27);
-  }
-
- private:
-  hasher hash_;
-};
-
-}  // namespace cuco
diff --git a/cpp/src/io/parquet/bloom_filter_reader.cu b/cpp/src/io/parquet/bloom_filter_reader.cu
index cc399494fc9..fc1112f6a55 100644
--- a/cpp/src/io/parquet/bloom_filter_reader.cu
+++ b/cpp/src/io/parquet/bloom_filter_reader.cu
@@ -14,7 +14,6 @@
  * limitations under the License.
  */
 
-#include "arrow_filter_policy.cuh"
 #include "compact_protocol_reader.hpp"
 #include "io/parquet/parquet.hpp"
 #include "reader_impl_helpers.hpp"
@@ -34,6 +33,7 @@
 #include <rmm/device_buffer.hpp>
 #include <rmm/exec_policy.hpp>
 
+#include <cuco/bloom_filter_policies.cuh>
 #include <cuco/bloom_filter_ref.cuh>
 #include <thrust/iterator/counting_iterator.h>
 #include <thrust/tabulate.h>
diff --git a/cpp/tests/io/parquet_bloom_filter_test.cu b/cpp/tests/io/parquet_bloom_filter_test.cu
index 827fc4b03b4..7d7f17d944a 100644
--- a/cpp/tests/io/parquet_bloom_filter_test.cu
+++ b/cpp/tests/io/parquet_bloom_filter_test.cu
@@ -14,9 +14,6 @@
  * limitations under the License.
  */
 
-// Remove this after cuco bump
-#include "src/io/parquet/arrow_filter_policy.cuh"
-
 #include <cudf_test/base_fixture.hpp>
 #include <cudf_test/column_utilities.hpp>
 #include <cudf_test/column_wrapper.hpp>
@@ -27,6 +24,7 @@
 #include <cudf/hashing/detail/xxhash_64.cuh>
 #include <cudf/utilities/default_stream.hpp>
 
+#include <cuco/bloom_filter_policies.cuh>
 #include <cuco/bloom_filter.cuh>
 
 using StringType = cudf::string_view;

From 4194d303312015d9f846735e5c83bbad14ab7f01 Mon Sep 17 00:00:00 2001
From: Muhammad Haseeb <mhaseeb@nvidia.com>
Date: Tue, 17 Dec 2024 22:39:20 +0000
Subject: [PATCH 85/85] MInor style fix

---
 cpp/tests/io/parquet_bloom_filter_test.cu | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/cpp/tests/io/parquet_bloom_filter_test.cu b/cpp/tests/io/parquet_bloom_filter_test.cu
index 7d7f17d944a..45fd2ef3f92 100644
--- a/cpp/tests/io/parquet_bloom_filter_test.cu
+++ b/cpp/tests/io/parquet_bloom_filter_test.cu
@@ -24,8 +24,8 @@
 #include <cudf/hashing/detail/xxhash_64.cuh>
 #include <cudf/utilities/default_stream.hpp>
 
-#include <cuco/bloom_filter_policies.cuh>
 #include <cuco/bloom_filter.cuh>
+#include <cuco/bloom_filter_policies.cuh>
 
 using StringType = cudf::string_view;