Struct RowGroupReaderBuilder 

pub(crate) struct RowGroupReaderBuilder {
    file_handle: FileHandle,
    file_path: String,
    parquet_meta: Arc<ParquetMetaData>,
    parquet_metadata_size: usize,
    arrow_metadata: ArrowReaderMetadata,
    output_schema: SchemaRef,
    object_store: ObjectStore,
    projection: ProjectionMaskPlan,
    has_nested_projection: bool,
    cache_strategy: CacheStrategy,
    prefilter_builder: Option<PrefilterContextBuilder>,
    batch_size: usize,
}

Builder to build a parquet record batch stream for a row group.

Fields

file_handle: FileHandle

SST file to read.

Holds the file handle to avoid the file purge it.

file_path: String

Path of the file.

parquet_meta: Arc<ParquetMetaData>

Metadata of the parquet file.

parquet_metadata_size: usize

Immutable metadata size, computed once when the footer is decoded.

arrow_metadata: ArrowReaderMetadata

Arrow reader metadata for building async stream.

output_schema: SchemaRef

Projected output schema aligned with projection.projected_root_presence.

object_store: ObjectStore

Object store as an Operator.

projection: ProjectionMaskPlan

Projection mask.

has_nested_projection: bool

Whether projected read columns include nested paths.

cache_strategy: CacheStrategy

Cache.

prefilter_builder: Option<PrefilterContextBuilder>

Pre-built prefilter state. None if prefiltering is not applicable.

batch_size: usize

Hint for rows in a decoded batch.

Implementations

impl RowGroupReaderBuilder

pub(crate) fn file_path(&self) -> &str

Path of the file to read.

pub(crate) fn file_handle(&self) -> &FileHandle

Handle of the file to read.

pub(crate) fn parquet_metadata(&self) -> &Arc<ParquetMetaData>

pub(crate) fn parquet_metadata_size(&self) -> usize

pub(crate) fn cache_strategy(&self) -> &CacheStrategy

pub(crate) fn has_predicate_prefilter(&self) -> bool

pub(crate) async fn build( &self, build_ctx: RowGroupBuildContext<'_>, ) -> Result<BoxStream<'static, Result<RecordBatch>>>

Builds a parquet record batch stream to read the row group at row_group_idx.

If prefiltering is applicable (based on build_ctx), this performs a two-phase read:

1. Reads only the prefilter columns (e.g. PK column), applies filters to get a refined row selection
2. Reads the full projection with the refined row selection

The prefilter pass is best-effort pruning, not the precise filter for the query. Predicates that cannot be lowered to prefilter columns (column not projected, expression not supported, etc.) are silently skipped. Correctness rests on the DataFusion FilterExec above this reader, which always re-applies the original predicate. With predicate prefiltering enabled, tag and timestamp predicates that flow through [SimpleFilterEvaluator] are enforced precisely in this pass. See build_reader_filter_plan for the bucketing rules and disabled mode.

When the prefilter result selects no rows, the second read still issues but parquet-rs short-circuits before any column-chunk IO: the row-group state machine jumps to Finished once it sees num_rows_selected() == 0, so no fast path is added here.

pub(crate) async fn build_without_prefilter( &self, build_ctx: RowGroupBuildContext<'_>, ) -> Result<BoxStream<'static, Result<RecordBatch>>>

Builds the normal projection without running the generic predicate prefilter.

The series reader uses this after computing its own primary-key-only row selection.

pub(crate) async fn build_primary_key( &self, build_ctx: RowGroupBuildContext<'_>, ) -> Result<BoxStream<'static, Result<RecordBatch>>>

Builds a stream that reads only the encoded primary-key column.

It preserves the normal reader’s binary-or-dictionary decision. This path deliberately skips the normal prefilter pass: the caller reads __primary_key once and applies all encoded-primary-key filters to the returned batches.

fn make_projected_stream( &self, stream: BoxStream<'static, Result<RecordBatch>>, ) -> Result<BoxStream<'static, Result<RecordBatch>>>

pub(crate) async fn build_with_projection( &self, row_group_idx: usize, row_selection: Option<RowSelection>, projection: ProjectionMask, fetch_metrics: Option<&ParquetFetchMetrics>, ) -> Result<BoxStream<'static, Result<RecordBatch>>>

Builds a parquet record batch stream with a custom projection mask.