Struct RowGroupReaderBuilder 

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

Builder to build a [ParquetRecordBatchStream] 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.

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.

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 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 [ParquetRecordBatchStream] 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. Tag and timestamp predicates that flow through [SimpleFilterEvaluator] are an exception — the engine enforces them precisely, so the prefilter pass is the only place they execute. See build_reader_filter_plan for the bucketing rules.

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.

fn make_projected_stream( &self, stream: ParquetRecordBatchStream<SstAsyncFileReader>, ) -> 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<ParquetRecordBatchStream<SstAsyncFileReader>>

Builds a [ParquetRecordBatchStream] with a custom projection mask.