Could we add total_row_count to check this selection is valid(maybe like continuous)

Is it actually an issue if it isn't, e.g. if I only want the first 100 rows?

yes, got it, it should check in user side.

👍 really need this abstraction！

👍 pass mask here not each col is more reasonable 😂

Is there we only need offset index, without the min max index?🤔

I think so

Is this for the situation a page which has been read_records but left some unreaded buffer?

Sorry, i don't get this point, why not directly call column_reader.skip_records(num_records)
could you give me some hint?

RecordReader is a bit of an odd cookie, let me try to explain what it is doing.

In the absence of repetition levels, it can simply read batch size levels, and the corresponding number of values.

However, if repetition levels are present, it will likely need to read more than batch_size levels in order to read batch_size actual records (rows).

To achieve this it reads to its internal buffer and then splits off the data corresponding to batch_size rows, leaving the excess behind.

It is this excess of data that has been read to its buffers but not yielded to the caller yet, which we must consume here

👍 nice write up ! Save me some time 😄!
So, i got it. More specific details to ask:
This is a part of skip, we need to read the rp ,dp to skip some records in the page(maybe have been readed or never readed ).

let (buffered_records, buffered_values) = self.count_records(num_records);
        self.num_records += buffered_records;
        self.num_values += buffered_values;

        self.consume_def_levels();
        self.consume_rep_levels();
        self.consume_record_data();
        self.consume_bitmap();
        self.reset();

        let remaining = buffered_records - num_records;

This also part of skip, remaining > 0, I think this we skip start at a new page

        if remaining == 0 {
            return Ok(buffered_records);
        }

        let skipped = match self.column_reader.as_mut() {
            Some(column_reader) => column_reader.skip_records(remaining)?,
            None => 0,
        };

This is a part of skip, we need to read the rp ,dp to skip some records in the page(maybe have been readed or never readed ).

Yes, this is just to consume the data that has been read to the internal buffers of RecordReader if any

This also part of skip, remaining > 0, I think this we skip start at a new page

Not necessarily, the only thing RecordReader needs to handle is skipping any data that has already been read from ColumnReader into its own buffers. It can then delegate to ColumnReader to skip the remaining rows, with no requirement that this is done at a page boundary - ColumnReader must be able to handle any case.

I think adding a ticket reference here like
unimplemented!("See https://github.com/apache/arrow-rs/.....") would help future readers

Bonus points for returning ArrowError::Unimplemented

This comment applies to everything below as well

perhaps worth a ticket?

You probably already have thought about this, but I would expect that in certain scenarios, non contiguous rows / skips would be desired

Like "fetch the first 100 rows, skip the next 200, and then fetch the remaining"

Would this interface handle that case?

See with_row_selection which takes a Vec to allow for this use-case

ditto returning "not yet implemented" would probably be nicer

I this rename a public API change as well? It does not appear in the docs

https://docs.rs/parquet/17.0.0/parquet/?search=DefinitionLevelDecoder

No it is crate local