rapids-bot · Jul 15, 2026 · Jun 12, 2026 · Jun 12, 2026 · Jun 12, 2026 · Jun 12, 2026
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -249,6 +249,35 @@ class hybrid_scan_multifile {
     cudf::host_span<std::vector<size_type> const> row_group_indices,
     std::size_t pass_read_limit) const;
 
+  /**
+   * @brief Get byte ranges of column chunk dictionary pages for row group pruning
+   *
+   * @param row_group_indices Input row group indices, one per source
+   * @param options Parquet reader options
+   * @return Pair of flattened byte ranges to column chunk dictionary pages subject to the filter
+   *         predicate and their corresponding source indices
+   */
+  [[nodiscard]] std::pair<std::vector<byte_range_info>, std::vector<size_type>>
+  dictionary_pages_byte_ranges(cudf::host_span<std::vector<size_type> const> row_group_indices,
+                               parquet_reader_options const& options) const;
+
+  /**
+   * @brief Filter the row groups using column chunk dictionary pages
+   *
+   * @param dictionary_page_data Device spans of dictionary page data of column chunks with an
+   *                             (in)equality predicate, ordered to match the dictionary page byte
+   *                             ranges returned by `dictionary_pages_byte_ranges`
+   * @param row_group_indices Input row group indices, one per source
+   * @param options Parquet reader options
+   * @param stream CUDA stream used for device memory operations and kernel launches
+   * @return Filtered per-source row group indices (one inner vector per source)
+   */
+  [[nodiscard]] std::vector<std::vector<size_type>> filter_row_groups_with_dictionary_pages(
+    cudf::host_span<cudf::device_span<uint8_t const> const> dictionary_page_data,
+    cudf::host_span<std::vector<size_type> const> row_group_indices,
+    parquet_reader_options const& options,
+    rmm::cuda_stream_view stream) const;
+
  private:
   std::unique_ptr<detail::hybrid_scan_reader_impl> _impl;
 };

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -9,6 +9,7 @@
 #include "io/parquet/compact_protocol_reader.hpp"
 #include "io/parquet/expression_transform_helpers.hpp"
 #include "io/parquet/reader_impl_helpers.hpp"
+#include "page_index_filter_utils.hpp"
 
 #include <cudf/detail/nvtx/ranges.hpp>
 #include <cudf/logger.hpp>
@@ -443,7 +444,8 @@ std::vector<byte_range_info> aggregate_reader_metadata::get_bloom_filter_bytes(
   return bloom_filter_bytes;
 }
 
-std::vector<byte_range_info> aggregate_reader_metadata::get_dictionary_page_bytes(
+std::pair<std::vector<byte_range_info>, std::vector<cudf::size_type>>
+aggregate_reader_metadata::dictionary_pages_byte_ranges(
   cudf::host_span<std::vector<cudf::size_type> const> row_group_indices,
   host_span<data_type const> output_dtypes,
   host_span<cudf::size_type const> output_column_schemas,
@@ -461,7 +463,7 @@ std::vector<byte_range_info> aggregate_reader_metadata::get_dictionary_page_byte
                   std::back_inserter(dictionary_col_schemas),
                   [](auto& dict_literals) { return not dict_literals.empty(); });
 
-  // No (in)equality literals found, return empty vector
+  // No (in)equality literals found, return empty vectors
   if (dictionary_col_schemas.empty()) { return {}; }
 
   // Compute total number of input row groups
@@ -477,38 +479,41 @@ std::vector<byte_range_info> aggregate_reader_metadata::get_dictionary_page_byte
   // Flag to check if we have at least one valid dictionary page
   auto have_dictionary_pages = false;
 
+  // Association between each dictionary page byte range and its source
+  std::vector<cudf::size_type> dictionary_page_source_map;
+  dictionary_page_source_map.reserve(num_chunks);
+
+  // Cache each dictionary column's chunk offset across sources and row groups
+  std::vector<std::optional<size_type>> colchunk_offsets(dictionary_col_schemas.size());
+
   // For all sources
   std::for_each(
     cuda::counting_iterator<std::size_t>{0},
     cuda::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];
-      std::optional<size_type> colchunk_iter_offset{};
       // For all row groups
       std::for_each(rg_indices.cbegin(), rg_indices.cend(), [&](auto const rg_index) {
-        auto const& row_group = per_file_metadata[src_index].row_groups[rg_index];
-        // For all column chunks
+        auto const& row_group     = per_file_metadata[src_index].row_groups[rg_index];
+        auto const num_col_chunks = static_cast<size_type>(row_group.columns.size());
+        // For all dictionary column chunks
         std::for_each(
-          dictionary_col_schemas.begin(),
-          dictionary_col_schemas.end(),
-          [&](auto const& schema_idx) {
-            // Get the column chunk iterator
-            if (not colchunk_iter_offset.has_value() or
-                row_group.columns[colchunk_iter_offset.value()].schema_idx != schema_idx) {
-              auto const& colchunk_iter = std::find_if(
-                row_group.columns.begin(), row_group.columns.end(), [schema_idx](auto const& col) {
-                  return col.schema_idx == schema_idx;
-                });
-              CUDF_EXPECTS(colchunk_iter != row_group.columns.end(),
-                           "Column chunk with schema index " + std::to_string(schema_idx) +
-                             " not found in row group",
-                           std::invalid_argument);
-              colchunk_iter_offset = std::distance(row_group.columns.begin(), colchunk_iter);
+          cuda::counting_iterator<std::size_t>{0},
+          cuda::counting_iterator{dictionary_col_schemas.size()},
+          [&](auto const col) {
+            // Map the schema index to this source
+            auto const mapped_schema_idx =
+              map_schema_index(dictionary_col_schemas[col], static_cast<int>(src_index));
+            auto& colchunk_offset    = colchunk_offsets[col];
+            auto const cached_offset = colchunk_offset.value_or(-1);
+            if (cached_offset < 0 or cached_offset >= num_col_chunks or
+                row_group.columns[cached_offset].schema_idx != mapped_schema_idx) {
+              colchunk_offset = find_colchunk_iter_offset(row_group, mapped_schema_idx);
             }
-            auto const colchunk_iter = row_group.columns.begin() + colchunk_iter_offset.value();
-            auto const& col_chunk    = *colchunk_iter;
-            auto const& col_meta     = col_chunk.meta_data;
+
+            auto const& col_chunk = row_group.columns[colchunk_offset.value()];
+            auto const& col_meta  = col_chunk.meta_data;
 
             // Make sure that we have page index and the column chunk doesn't have any
             // non-dictionary encoded pages
@@ -564,13 +569,14 @@ std::vector<byte_range_info> aggregate_reader_metadata::get_dictionary_page_byte
             }
 
             dictionary_page_bytes.emplace_back(dictionary_offset, dictionary_size);
+            dictionary_page_source_map.emplace_back(static_cast<size_type>(src_index));
           });
       });
     });
 
   if (not have_dictionary_pages) { return {}; }
 
-  return dictionary_page_bytes;
+  return {std::move(dictionary_page_bytes), std::move(dictionary_page_source_map)};
 }
 
 std::vector<std::vector<cudf::size_type>>

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -238,13 +238,15 @@ class aggregate_reader_metadata : public aggregate_reader_metadata_base {
    * @param output_column_schemas schema indices of output columns
    * @param filter AST expression to filter row groups based on dictionary pages
    *
-   * @return Byte ranges of dictionary pages, one input column chunk with (in)equality predicate
+   * @return A pair of vectors containing dictionary page byte ranges and corresponding source
+   *         indices
    */
-  [[nodiscard]] std::vector<cudf::io::text::byte_range_info> get_dictionary_page_bytes(
-    cudf::host_span<std::vector<size_type> const> row_group_indices,
-    cudf::host_span<data_type const> output_dtypes,
-    cudf::host_span<cudf::size_type const> output_column_schemas,
-    std::reference_wrapper<ast::expression const> filter);
+  [[nodiscard]] std::pair<std::vector<cudf::io::text::byte_range_info>,
+                          std::vector<cudf::size_type>>
+  dictionary_pages_byte_ranges(cudf::host_span<std::vector<size_type> const> row_group_indices,
+                               cudf::host_span<data_type const> output_dtypes,
+                               cudf::host_span<cudf::size_type const> output_column_schemas,
+                               std::reference_wrapper<ast::expression const> filter);
 
   /**
    * @brief Filter the row groups using dictionaries based on predicate filter

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -289,14 +289,30 @@ hybrid_scan_reader_impl::secondary_filters_byte_ranges(
                                                _output_column_schemas,
                                                expr_conv.get_converted_expr().value());
   auto const dictionary_page_bytes =
-    _extended_metadata->get_dictionary_page_bytes(row_group_indices,
-                                                  output_dtypes,
-                                                  _output_column_schemas,
-                                                  expr_conv.get_converted_expr().value());
+    _extended_metadata
+      ->dictionary_pages_byte_ranges(row_group_indices,
+                                     output_dtypes,
+                                     _output_column_schemas,
+                                     expr_conv.get_converted_expr().value())
+      .first;
 
   return {bloom_filter_bytes, dictionary_page_bytes};
 }
 
+std::pair<std::vector<byte_range_info>, std::vector<cudf::size_type>>
+hybrid_scan_reader_impl::dictionary_pages_byte_ranges(
+  cudf::host_span<std::vector<size_type> const> row_group_indices,
+  parquet_reader_options const& options)
+{
+  CUDF_EXPECTS(not row_group_indices.empty(), "Empty input row group indices encountered");
+  auto [expr_conv, output_dtypes] = prepare_filter_and_output_types(options);
+
+  return _extended_metadata->dictionary_pages_byte_ranges(row_group_indices,
+                                                          output_dtypes,
+                                                          _output_column_schemas,
+                                                          expr_conv.get_converted_expr().value());
+}
+
 std::vector<std::vector<size_type>>
 hybrid_scan_reader_impl::filter_row_groups_with_dictionary_pages(
   cudf::host_span<cudf::device_span<uint8_t const> const> dictionary_page_data,

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -113,6 +113,13 @@ class hybrid_scan_reader_impl : public parquet::detail::reader_impl {
   secondary_filters_byte_ranges(cudf::host_span<std::vector<size_type> const> row_group_indices,
                                 parquet_reader_options const& options);
 
+  /**
+   * @copydoc cudf::io::experimental::hybrid_scan_multifile::dictionary_pages_byte_ranges
+   */
+  [[nodiscard]] std::pair<std::vector<byte_range_info>, std::vector<cudf::size_type>>
+  dictionary_pages_byte_ranges(cudf::host_span<std::vector<size_type> const> row_group_indices,
+                               parquet_reader_options const& options);
+
   /**
    * @copydoc cudf::io::experimental::hybrid_scan::filter_row_groups_with_dictionary_pages
    */

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -165,4 +165,24 @@ std::vector<std::vector<std::vector<size_type>>> hybrid_scan_multifile::construc
   return source_passes;
 }
 
+std::pair<std::vector<text::byte_range_info>, std::vector<size_type>>
+hybrid_scan_multifile::dictionary_pages_byte_ranges(
+  cudf::host_span<std::vector<size_type> const> row_group_indices,
+  parquet_reader_options const& options) const
+{
+  CUDF_FUNC_RANGE();
+  return _impl->dictionary_pages_byte_ranges(row_group_indices, options);
+}
+
+std::vector<std::vector<size_type>> hybrid_scan_multifile::filter_row_groups_with_dictionary_pages(
+  cudf::host_span<cudf::device_span<uint8_t const> const> dictionary_page_data,
+  cudf::host_span<std::vector<size_type> const> row_group_indices,
+  parquet_reader_options const& options,
+  rmm::cuda_stream_view stream) const
+{
+  CUDF_FUNC_RANGE();
+  return _impl->filter_row_groups_with_dictionary_pages(
+    dictionary_page_data, row_group_indices, options, stream);
+}
+
 }  // namespace cudf::io::parquet::experimental
@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -18,6 +18,7 @@
 #include <thrust/gather.h>
 
 #include <algorithm>
+#include <format>
 #include <numeric>
 #include <vector>
 
@@ -29,10 +30,9 @@ size_type find_colchunk_iter_offset(RowGroup const& row_group, size_type schema_
     std::find_if(row_group.columns.begin(), row_group.columns.end(), [schema_idx](auto const& col) {
       return col.schema_idx == schema_idx;
     });
-  CUDF_EXPECTS(
-    colchunk_iter != row_group.columns.end(),
-    "Column chunk with schema index " + std::to_string(schema_idx) + " not found in row group",
-    std::invalid_argument);
+  CUDF_EXPECTS(colchunk_iter != row_group.columns.end(),
+               std::format("Column chunk with schema index {} not found in row group", schema_idx),
+               std::invalid_argument);
   return std::distance(row_group.columns.begin(), colchunk_iter);
 }
 

@@ -1,5 +1,5 @@
 /*
- * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION.
+ * SPDX-FileCopyrightText: Copyright (c) 2025-2026, NVIDIA CORPORATION & AFFILIATES. All rights reserved.
  * SPDX-License-Identifier: Apache-2.0
  */
 
@@ -14,12 +14,14 @@
 #include <cudf/table/table.hpp>
 #include <cudf/types.hpp>
 #include <cudf/utilities/default_stream.hpp>
+#include <cudf/utilities/error.hpp>
 #include <cudf/utilities/traits.hpp>
 
 #include <rmm/device_buffer.hpp>
 
 #include <cuda/iterator>
 
+#include <algorithm>
 #include <format>
 #include <random>
 #include <string>
@@ -144,6 +146,11 @@ cudf::test::fixed_width_column_wrapper<T> descending_low_cardinality()
  *
  * @param str_col_value Value for the constant string column used when IsConstantStrings is true
  * @param compression Compression type
+ * @param column_names Top-level column names assigned in `column_order` order (default
+ *        {"col0", "col1", "col2"})
+ * @param column_order Physical emit order of the base [col0, col1, col2] columns (default
+ *        {0, 1, 2}). Reordering emits the same logical columns at different schema positions, which
+ *        is used to build mismatched per-source schemas for the row-group filtering tests.
  * @param stream CUDA stream
  *
  * @return Tuple of table and Parquet host buffer
@@ -153,11 +160,27 @@ template <typename T,
           bool IsConstantStrings = true,
           bool IsNullable        = false>
 auto create_parquet_with_stats(
-  cudf::size_type str_col_value          = 100,
-  cudf::io::compression_type compression = cudf::io::compression_type::AUTO,
-  rmm::cuda_stream_view stream           = cudf::get_default_stream())
+  cudf::size_type str_col_value             = 100,
+  cudf::io::compression_type compression    = cudf::io::compression_type::AUTO,
+  std::vector<std::string> column_names     = {"col0", "col1", "col2"},
+  std::vector<cudf::size_type> column_order = {0, 1, 2},
+  rmm::cuda_stream_view stream              = cudf::get_default_stream())
 {
   static_assert(NumTableConcats >= 1, "Concatenated table must contain at least one table");
+  CUDF_EXPECTS(column_names.size() == column_order.size(),
+               "Column names and column order must have the same size");
+  CUDF_EXPECTS(column_order.size() == 3, "Column order must include all three test columns");
+  CUDF_EXPECTS(std::all_of(column_order.begin(),
+                           column_order.end(),
+                           [](auto const col_idx) { return col_idx >= 0 and col_idx < 3; }),
+               "Column order contains an out-of-bounds column index");
+  CUDF_EXPECTS(std::all_of(cuda::counting_iterator<cudf::size_type>{0},
+                           cuda::counting_iterator<cudf::size_type>{3},
+                           [&](auto const col_idx) {
+                             return std::count(column_order.begin(), column_order.end(), col_idx) ==
+                                    1;
+                           }),
+               "Column order must be a permutation of the three test columns");
 
   auto col0 = testdata::ascending<T>();
   auto col1 = []() {
@@ -209,12 +232,21 @@ auto create_parquet_with_stats(
     output = table_view{{columns[0]->view(), columns[1]->view(), columns[2]->view()}};
   }
 
+  // Reorder the base [col0, col1, col2] columns into the requested physical order, naming them in
+  // that new order.
+  std::vector<cudf::column_view> reordered_columns;
+  reordered_columns.reserve(column_order.size());
+  for (auto const col_idx : column_order) {
+    reordered_columns.emplace_back(output.column(col_idx));
+  }
+  output = table_view{reordered_columns};
+
   auto table = cudf::concatenate(std::vector<table_view>(NumTableConcats, output));
   output     = table->view();
   cudf::io::table_input_metadata output_metadata(output);
-  output_metadata.column_metadata[0].set_name("col0");
-  output_metadata.column_metadata[1].set_name("col1");
-  output_metadata.column_metadata[2].set_name("col2");
+  for (std::size_t i = 0; i < column_names.size(); ++i) {
+    output_metadata.column_metadata[i].set_name(column_names[i]);
+  }
 
   std::vector<char> buffer;
   cudf::io::parquet_writer_options out_opts =