Use Vec instead of VecDeque

Author: alamb

parquet/src/arrow/arrow_reader/read_plan.rs

@@ -25,7 +25,6 @@ use crate::arrow::arrow_reader::{
 use crate::errors::{ParquetError, Result};
 use arrow_array::Array;
 use arrow_select::filter::prep_null_mask_filter;
-use std::collections::VecDeque;
 
 /// A builder for [`ReadPlan`]
 #[derive(Clone)]
@@ -162,14 +161,19 @@ pub(crate) struct SelectionIterator {
     /// how many records have been read by RowSelection in the "current" batch
     read_records: usize,
     /// Input selectors to read from
-    input_selectors: VecDeque<RowSelector>,
+    input_selectors: Vec<RowSelector>,
+    /// index into `input_selectors` of the next selector to read
+    index: usize,
 }
 
 impl Iterator for SelectionIterator {
     type Item = RowSelector;
 
     fn next(&mut self) -> Option<Self::Item> {
-        while let Some(mut front) = self.input_selectors.pop_front() {
+        while self.index < self.input_selectors.len() {
+            let mut front = self.input_selectors[self.index];
+            self.index += 1;
+
             // RowSelectors with row_count = 0 terminate the read, so skip such
             // entries. See https://github.com/apache/arrow-rs/issues/2669
             if front.row_count == 0 {
@@ -187,8 +191,8 @@ impl Iterator for SelectionIterator {
             if front.row_count > need_read {
                 // Part 1: return remaining rows to the front of the queue
                 let remaining = front.row_count - need_read;
-                self.input_selectors
-                    .push_front(RowSelector::select(remaining));
+                self.index -= 1;
+                self.input_selectors[self.index] = RowSelector::select(remaining);
                 // Part 2: adjust the current selector to read the rows we need
                 front.row_count = need_read;
             }
@@ -207,16 +211,17 @@ impl Iterator for SelectionIterator {
 }
 
 impl SelectionIterator {
-    fn new(batch_size: usize, mut input_selectors: VecDeque<RowSelector>) -> Self {
+    fn new(batch_size: usize, mut input_selectors: Vec<RowSelector>) -> Self {
         // trim any trailing empty selectors
-        while input_selectors.back().map(|x| x.skip).unwrap_or(false) {
-            input_selectors.pop_back();
+        while input_selectors.last().map(|x| x.skip).unwrap_or(false) {
+            input_selectors.pop();
         }
 
         Self {
             batch_size,
             read_records: 0,
             input_selectors,
+            index: 0,
         }
     }