From 1cdab6f071e3b4553cd4aed049650c3a2b37a422 Mon Sep 17 00:00:00 2001 From: Ritchie Vink Date: Tue, 21 May 2024 09:11:43 +0200 Subject: [PATCH] perf: Reduce error bubbling in parquet hybrid_rle (#16348) --- .../arrow/read/deserialize/boolean/basic.rs | 2 - .../src/arrow/read/deserialize/utils.rs | 4 +- .../src/parquet/deserialize/filtered_rle.rs | 33 ++++------ .../src/parquet/deserialize/hybrid_rle.rs | 44 ++++--------- .../encoding/delta_bitpacked/decoder.rs | 10 +-- .../parquet/encoding/hybrid_rle/decoder.rs | 18 ++---- .../src/parquet/encoding/hybrid_rle/mod.rs | 2 +- .../src/parquet/encoding/uleb128.rs | 22 +++---- .../src/parquet/encoding/zigzag_leb128.rs | 11 ++-- .../tests/it/io/parquet/read/deserialize.rs | 64 +++++++++---------- .../it/io/parquet/read/primitive_nested.rs | 2 +- .../polars/tests/it/io/parquet/read/utils.rs | 2 +- 12 files changed, 87 insertions(+), 127 deletions(-) diff --git a/crates/polars-parquet/src/arrow/read/deserialize/boolean/basic.rs b/crates/polars-parquet/src/arrow/read/deserialize/boolean/basic.rs index aab7a6e91be9..6c40608c954c 100644 --- a/crates/polars-parquet/src/arrow/read/deserialize/boolean/basic.rs +++ b/crates/polars-parquet/src/arrow/read/deserialize/boolean/basic.rs @@ -5,7 +5,6 @@ use arrow::bitmap::utils::BitmapIter; use arrow::bitmap::MutableBitmap; use arrow::datatypes::ArrowDataType; use polars_error::PolarsResult; -use polars_utils::iter::FallibleIterator; use super::super::utils::{ extend_from_decoder, get_selected_rows, next, DecodedState, Decoder, @@ -201,7 +200,6 @@ impl<'a> Decoder<'a> for BooleanDecoder { values, &mut *page_values, ); - page_values.get_result()?; }, } Ok(()) diff --git a/crates/polars-parquet/src/arrow/read/deserialize/utils.rs b/crates/polars-parquet/src/arrow/read/deserialize/utils.rs index 6919dd88dd74..32d4e1d5dcbf 100644 --- a/crates/polars-parquet/src/arrow/read/deserialize/utils.rs +++ b/crates/polars-parquet/src/arrow/read/deserialize/utils.rs @@ -73,7 +73,7 @@ impl<'a> PageValidity<'a> for FilteredOptionalPageValidity<'a> { (run, offset) } else { // a new run - let run = self.iter.next()?.unwrap(); // no run -> None + let run = self.iter.next()?; // no run -> None self.current = Some((run, 0)); return self.next_limited(limit); }; @@ -181,7 +181,7 @@ impl<'a> OptionalPageValidity<'a> { (run, offset) } else { // a new run - let run = self.iter.next()?.unwrap(); // no run -> None + let run = self.iter.next()?; // no run -> None self.current = Some((run, 0)); return self.next_limited(limit); }; diff --git a/crates/polars-parquet/src/parquet/deserialize/filtered_rle.rs b/crates/polars-parquet/src/parquet/deserialize/filtered_rle.rs index 7549b7de3738..e9c71ee5468a 100644 --- a/crates/polars-parquet/src/parquet/deserialize/filtered_rle.rs +++ b/crates/polars-parquet/src/parquet/deserialize/filtered_rle.rs @@ -2,7 +2,6 @@ use std::collections::VecDeque; use super::{HybridDecoderBitmapIter, HybridEncoded}; use crate::parquet::encoding::hybrid_rle::BitmapIter; -use crate::parquet::error::Error; use crate::parquet::indexes::Interval; /// Type definition of a [`FilteredHybridBitmapIter`] of [`HybridDecoderBitmapIter`]. @@ -54,7 +53,7 @@ impl<'a> FilteredHybridEncoded<'a> { /// /// This iterator adapter is used in combination with #[derive(Debug, Clone, PartialEq, Eq)] -pub struct FilteredHybridBitmapIter<'a, I: Iterator, Error>>> { +pub struct FilteredHybridBitmapIter<'a, I: Iterator>> { iter: I, current: Option<(HybridEncoded<'a>, usize)>, // a run may end in the middle of an interval, in which case we must @@ -66,7 +65,7 @@ pub struct FilteredHybridBitmapIter<'a, I: Iterator, Error>>> FilteredHybridBitmapIter<'a, I> { +impl<'a, I: Iterator>> FilteredHybridBitmapIter<'a, I> { pub fn new(iter: I, selected_rows: VecDeque) -> Self { let total_items = selected_rows.iter().map(|x| x.length).sum(); Self { @@ -99,10 +98,8 @@ impl<'a, I: Iterator, Error>>> FilteredHybridBit } } -impl<'a, I: Iterator, Error>>> Iterator - for FilteredHybridBitmapIter<'a, I> -{ - type Item = Result, Error>; +impl<'a, I: Iterator>> Iterator for FilteredHybridBitmapIter<'a, I> { + type Item = FilteredHybridEncoded<'a>; fn next(&mut self) -> Option { let interval = if let Some(interval) = self.current_interval { @@ -116,14 +113,8 @@ impl<'a, I: Iterator, Error>>> Iterator let (run, offset) = if let Some((run, offset)) = self.current { (run, offset) } else { + self.current = Some((self.iter.next()?, 0)); // a new run - let run = self.iter.next()?; // no run => something wrong since intervals should only slice items up all runs' length - match run { - Ok(run) => { - self.current = Some((run, 0)); - }, - Err(e) => return Some(Err(e)), - } return self.next(); }; @@ -157,7 +148,7 @@ impl<'a, I: Iterator, Error>>> Iterator Some((run, offset + to_skip)) }; - return Some(Ok(FilteredHybridEncoded::Skipped(set))); + return Some(FilteredHybridEncoded::Skipped(set)); }; // slice the bitmap according to current interval @@ -170,7 +161,7 @@ impl<'a, I: Iterator, Error>>> Iterator self.advance_current_interval(run_length); self.current_items_in_runs += run_length; self.current = None; - Some(Ok(FilteredHybridEncoded::Skipped(set))) + Some(FilteredHybridEncoded::Skipped(set)) } else { let length = if run_length > interval.length { // interval is fully consumed @@ -196,7 +187,7 @@ impl<'a, I: Iterator, Error>>> Iterator self.current = None; length }; - Some(Ok(FilteredHybridEncoded::Repeated { is_set, length })) + Some(FilteredHybridEncoded::Repeated { is_set, length }) } }, HybridEncoded::Bitmap(values, full_run_length) => { @@ -223,7 +214,7 @@ impl<'a, I: Iterator, Error>>> Iterator Some((run, offset + to_skip)) }; - return Some(Ok(FilteredHybridEncoded::Skipped(set))); + return Some(FilteredHybridEncoded::Skipped(set)); }; // slice the bitmap according to current interval @@ -236,7 +227,7 @@ impl<'a, I: Iterator, Error>>> Iterator self.advance_current_interval(run_length); self.current_items_in_runs += run_length; self.current = None; - Some(Ok(FilteredHybridEncoded::Skipped(set))) + Some(FilteredHybridEncoded::Skipped(set)) } else { let length = if run_length > interval.length { // interval is fully consumed @@ -262,11 +253,11 @@ impl<'a, I: Iterator, Error>>> Iterator self.current = None; length }; - Some(Ok(FilteredHybridEncoded::Bitmap { + Some(FilteredHybridEncoded::Bitmap { values, offset: new_offset, length, - })) + }) } }, } diff --git a/crates/polars-parquet/src/parquet/deserialize/hybrid_rle.rs b/crates/polars-parquet/src/parquet/deserialize/hybrid_rle.rs index 4ceab84b850e..ecc1b6144caa 100644 --- a/crates/polars-parquet/src/parquet/deserialize/hybrid_rle.rs +++ b/crates/polars-parquet/src/parquet/deserialize/hybrid_rle.rs @@ -1,7 +1,4 @@ -use polars_utils::iter::FallibleIterator; - use crate::parquet::encoding::hybrid_rle::{self, BitmapIter}; -use crate::parquet::error::Error; /// The decoding state of the hybrid-RLE decoder with a maximum definition level of 1 #[derive(Debug, Clone, Copy, PartialEq, Eq)] @@ -29,7 +26,7 @@ impl<'a> HybridEncoded<'a> { } } -pub trait HybridRleRunsIterator<'a>: Iterator, Error>> { +pub trait HybridRleRunsIterator<'a>: Iterator> { /// Number of elements remaining. This may not be the items of the iterator - an item /// of the iterator may contain more than one element. fn number_of_elements(&self) -> usize; @@ -39,7 +36,7 @@ pub trait HybridRleRunsIterator<'a>: Iterator, E #[derive(Debug, Clone)] pub struct HybridRleIter<'a, I> where - I: Iterator, Error>>, + I: Iterator>, { iter: I, length: usize, @@ -48,7 +45,7 @@ where impl<'a, I> HybridRleIter<'a, I> where - I: Iterator, Error>>, + I: Iterator>, { /// Returns a new [`HybridRleIter`] #[inline] @@ -74,7 +71,7 @@ where impl<'a, I> HybridRleRunsIterator<'a> for HybridRleIter<'a, I> where - I: Iterator, Error>>, + I: Iterator>, { fn number_of_elements(&self) -> usize { self.len() @@ -83,18 +80,18 @@ where impl<'a, I> Iterator for HybridRleIter<'a, I> where - I: Iterator, Error>>, + I: Iterator>, { - type Item = Result, Error>; + type Item = HybridEncoded<'a>; #[inline] fn next(&mut self) -> Option { if self.consumed == self.length { return None; }; - let run = self.iter.next()?; + let run = self.iter.next(); - Some(run.map(|run| match run { + run.map(|run| match run { hybrid_rle::HybridEncoded::Bitpacked(pack) => { // a pack has at most `pack.len() * 8` bits let pack_size = pack.len() * 8; @@ -112,7 +109,7 @@ where self.consumed += additional; HybridEncoded::Repeated(is_set, additional) }, - })) + }) } fn size_hint(&self) -> (usize, Option) { @@ -137,11 +134,10 @@ enum HybridBooleanState<'a> { #[derive(Debug)] pub struct HybridRleBooleanIter<'a, I> where - I: Iterator, Error>>, + I: Iterator>, { iter: I, current_run: Option>, - result: Result<(), Error>, } impl<'a, I> HybridRleBooleanIter<'a, I> @@ -152,19 +148,10 @@ where Self { iter, current_run: None, - result: Ok(()), } } - fn set_new_run(&mut self, run: Result, Error>) -> Option { - let run = match run { - Err(e) => { - self.result = Err(e); - return None; - }, - Ok(r) => r, - }; - + fn set_new_run(&mut self, run: HybridEncoded<'a>) -> Option { let run = match run { HybridEncoded::Bitmap(bitmap, length) => { HybridBooleanState::Bitmap(BitmapIter::new(bitmap, 0, length)) @@ -217,14 +204,5 @@ where } } -impl<'a, I> FallibleIterator for HybridRleBooleanIter<'a, I> -where - I: HybridRleRunsIterator<'a>, -{ - fn get_result(&mut self) -> Result<(), Error> { - self.result.clone() - } -} - /// Type definition for a [`HybridRleBooleanIter`] using [`hybrid_rle::Decoder`]. pub type HybridRleDecoderIter<'a> = HybridRleBooleanIter<'a, HybridDecoderBitmapIter<'a>>; diff --git a/crates/polars-parquet/src/parquet/encoding/delta_bitpacked/decoder.rs b/crates/polars-parquet/src/parquet/encoding/delta_bitpacked/decoder.rs index 378706541e55..a614cb8f287c 100644 --- a/crates/polars-parquet/src/parquet/encoding/delta_bitpacked/decoder.rs +++ b/crates/polars-parquet/src/parquet/encoding/delta_bitpacked/decoder.rs @@ -30,7 +30,7 @@ impl<'a> Block<'a> { let length = std::cmp::min(length, num_mini_blocks * values_per_mini_block); let mut consumed_bytes = 0; - let (min_delta, consumed) = zigzag_leb128::decode(values)?; + let (min_delta, consumed) = zigzag_leb128::decode(values); consumed_bytes += consumed; values = &values[consumed..]; @@ -133,19 +133,19 @@ pub struct Decoder<'a> { impl<'a> Decoder<'a> { pub fn try_new(mut values: &'a [u8]) -> Result { let mut consumed_bytes = 0; - let (block_size, consumed) = uleb128::decode(values)?; + let (block_size, consumed) = uleb128::decode(values); consumed_bytes += consumed; assert_eq!(block_size % 128, 0); values = &values[consumed..]; - let (num_mini_blocks, consumed) = uleb128::decode(values)?; + let (num_mini_blocks, consumed) = uleb128::decode(values); let num_mini_blocks = num_mini_blocks as usize; consumed_bytes += consumed; values = &values[consumed..]; - let (total_count, consumed) = uleb128::decode(values)?; + let (total_count, consumed) = uleb128::decode(values); let total_count = total_count as usize; consumed_bytes += consumed; values = &values[consumed..]; - let (first_value, consumed) = zigzag_leb128::decode(values)?; + let (first_value, consumed) = zigzag_leb128::decode(values); consumed_bytes += consumed; values = &values[consumed..]; diff --git a/crates/polars-parquet/src/parquet/encoding/hybrid_rle/decoder.rs b/crates/polars-parquet/src/parquet/encoding/hybrid_rle/decoder.rs index 3a867aa6b1bc..64ff4dd25a06 100644 --- a/crates/polars-parquet/src/parquet/encoding/hybrid_rle/decoder.rs +++ b/crates/polars-parquet/src/parquet/encoding/hybrid_rle/decoder.rs @@ -2,7 +2,6 @@ use polars_utils::slice::GetSaferUnchecked; use super::super::{ceil8, uleb128}; use super::HybridEncoded; -use crate::parquet::error::Error; /// An [`Iterator`] of [`HybridEncoded`]. #[derive(Debug, Clone)] @@ -25,14 +24,11 @@ impl<'a> Decoder<'a> { } impl<'a> Iterator for Decoder<'a> { - type Item = Result, Error>; + type Item = HybridEncoded<'a>; #[inline] // -18% improvement in bench fn next(&mut self) -> Option { - let (indicator, consumed) = match uleb128::decode(self.values) { - Ok((indicator, consumed)) => (indicator, consumed), - Err(e) => return Some(Err(e)), - }; + let (indicator, consumed) = uleb128::decode(self.values); self.values = unsafe { self.values.get_unchecked_release(consumed..) }; // We want to early return if consumed == 0 OR num_bits == 0, so combine into a single branch. @@ -46,7 +42,7 @@ impl<'a> Iterator for Decoder<'a> { let bytes = std::cmp::min(bytes, self.values.len()); let (result, remaining) = self.values.split_at(bytes); self.values = remaining; - Some(Ok(HybridEncoded::Bitpacked(result))) + Some(HybridEncoded::Bitpacked(result)) } else { // is rle let run_length = indicator as usize >> 1; @@ -54,7 +50,7 @@ impl<'a> Iterator for Decoder<'a> { let rle_bytes = ceil8(self.num_bits); let (result, remaining) = self.values.split_at(rle_bytes); self.values = remaining; - Some(Ok(HybridEncoded::Rle(result, run_length))) + Some(HybridEncoded::Rle(result, run_length)) } } } @@ -77,7 +73,7 @@ mod tests { let run = decoder.next().unwrap(); - if let HybridEncoded::Bitpacked(values) = run.unwrap() { + if let HybridEncoded::Bitpacked(values) = run { assert_eq!(values, &[0b00001011]); let result = bitpacked::Decoder::::try_new(values, bit_width, length) .unwrap() @@ -103,7 +99,7 @@ mod tests { let run = decoder.next().unwrap(); - if let HybridEncoded::Bitpacked(values) = run.unwrap() { + if let HybridEncoded::Bitpacked(values) = run { assert_eq!(values, &[0b11101011, 0b00000010]); let result = bitpacked::Decoder::::try_new(values, bit_width, 10) .unwrap() @@ -128,7 +124,7 @@ mod tests { let run = decoder.next().unwrap(); - if let HybridEncoded::Rle(values, items) = run.unwrap() { + if let HybridEncoded::Rle(values, items) = run { assert_eq!(values, &[0b00000001]); assert_eq!(items, length); } else { diff --git a/crates/polars-parquet/src/parquet/encoding/hybrid_rle/mod.rs b/crates/polars-parquet/src/parquet/encoding/hybrid_rle/mod.rs index 89816f87fb54..1a34f6c19e5e 100644 --- a/crates/polars-parquet/src/parquet/encoding/hybrid_rle/mod.rs +++ b/crates/polars-parquet/src/parquet/encoding/hybrid_rle/mod.rs @@ -41,7 +41,7 @@ pub struct HybridRleDecoder<'a> { #[inline] fn read_next<'a>(decoder: &mut Decoder<'a>, remaining: usize) -> Result, Error> { - Ok(match decoder.next().transpose()? { + Ok(match decoder.next() { Some(HybridEncoded::Bitpacked(packed)) => { let num_bits = decoder.num_bits(); let length = std::cmp::min(packed.len() * 8 / num_bits, remaining); diff --git a/crates/polars-parquet/src/parquet/encoding/uleb128.rs b/crates/polars-parquet/src/parquet/encoding/uleb128.rs index c91568e2ee86..50341304c813 100644 --- a/crates/polars-parquet/src/parquet/encoding/uleb128.rs +++ b/crates/polars-parquet/src/parquet/encoding/uleb128.rs @@ -1,15 +1,13 @@ -use crate::parquet::error::Error; - -pub fn decode(values: &[u8]) -> Result<(u64, usize), Error> { +pub fn decode(values: &[u8]) -> (u64, usize) { let mut result = 0; let mut shift = 0; let mut consumed = 0; for byte in values { consumed += 1; - if shift == 63 && *byte > 1 { - panic!() - }; + + #[cfg(debug_assertions)] + debug_assert!(!(shift == 63 && *byte > 1)); result |= u64::from(byte & 0b01111111) << shift; @@ -19,7 +17,7 @@ pub fn decode(values: &[u8]) -> Result<(u64, usize), Error> { shift += 7; } - Ok((result, consumed)) + (result, consumed) } /// Encodes `value` in ULEB128 into `container`. The exact number of bytes written @@ -52,7 +50,7 @@ mod tests { #[test] fn decode_1() { let data = vec![0xe5, 0x8e, 0x26, 0xDE, 0xAD, 0xBE, 0xEF]; - let (value, len) = decode(&data).unwrap(); + let (value, len) = decode(&data); assert_eq!(value, 624_485); assert_eq!(len, 3); } @@ -60,7 +58,7 @@ mod tests { #[test] fn decode_2() { let data = vec![0b00010000, 0b00000001, 0b00000011, 0b00000011]; - let (value, len) = decode(&data).unwrap(); + let (value, len) = decode(&data); assert_eq!(value, 16); assert_eq!(len, 1); } @@ -70,7 +68,7 @@ mod tests { let original = 123124234u64; let mut container = [0u8; 10]; let encoded_len = encode(original, &mut container); - let (value, len) = decode(&container).unwrap(); + let (value, len) = decode(&container); assert_eq!(value, original); assert_eq!(len, encoded_len); } @@ -80,7 +78,7 @@ mod tests { let original = u64::MIN; let mut container = [0u8; 10]; let encoded_len = encode(original, &mut container); - let (value, len) = decode(&container).unwrap(); + let (value, len) = decode(&container); assert_eq!(value, original); assert_eq!(len, encoded_len); } @@ -90,7 +88,7 @@ mod tests { let original = u64::MAX; let mut container = [0u8; 10]; let encoded_len = encode(original, &mut container); - let (value, len) = decode(&container).unwrap(); + let (value, len) = decode(&container); assert_eq!(value, original); assert_eq!(len, encoded_len); } diff --git a/crates/polars-parquet/src/parquet/encoding/zigzag_leb128.rs b/crates/polars-parquet/src/parquet/encoding/zigzag_leb128.rs index 0a673136cc73..63ab565cf8bd 100644 --- a/crates/polars-parquet/src/parquet/encoding/zigzag_leb128.rs +++ b/crates/polars-parquet/src/parquet/encoding/zigzag_leb128.rs @@ -1,9 +1,8 @@ use super::uleb128; -use crate::parquet::error::Error; -pub fn decode(values: &[u8]) -> Result<(i64, usize), Error> { - let (u, consumed) = uleb128::decode(values)?; - Ok(((u >> 1) as i64 ^ -((u & 1) as i64), consumed)) +pub fn decode(values: &[u8]) -> (i64, usize) { + let (u, consumed) = uleb128::decode(values); + ((u >> 1) as i64 ^ -((u & 1) as i64), consumed) } pub fn encode(value: i64) -> ([u8; 10], usize) { @@ -33,7 +32,7 @@ mod tests { (9, -5), ]; for (data, expected) in cases { - let (result, _) = decode(&[data]).unwrap(); + let (result, _) = decode(&[data]); assert_eq!(result, expected) } } @@ -63,7 +62,7 @@ mod tests { fn test_roundtrip() { let value = -1001212312; let (data, size) = encode(value); - let (result, _) = decode(&data[..size]).unwrap(); + let (result, _) = decode(&data[..size]); assert_eq!(value, result); } } diff --git a/crates/polars/tests/it/io/parquet/read/deserialize.rs b/crates/polars/tests/it/io/parquet/read/deserialize.rs index 1b5cf18b1452..90e16a24683a 100644 --- a/crates/polars/tests/it/io/parquet/read/deserialize.rs +++ b/crates/polars/tests/it/io/parquet/read/deserialize.rs @@ -6,10 +6,10 @@ use polars_parquet::parquet::indexes::Interval; #[test] fn bitmap_incomplete() { let mut iter = FilteredHybridBitmapIter::new( - vec![Ok(HybridEncoded::Bitmap(&[0b01000011], 7))].into_iter(), + vec![HybridEncoded::Bitmap(&[0b01000011], 7)].into_iter(), vec![Interval::new(1, 2)].into(), ); - let a = iter.by_ref().collect::, _>>().unwrap(); + let a = iter.by_ref().collect::>(); assert_eq!(iter.len(), 0); assert_eq!( a, @@ -27,10 +27,10 @@ fn bitmap_incomplete() { #[test] fn bitmap_complete() { let mut iter = FilteredHybridBitmapIter::new( - vec![Ok(HybridEncoded::Bitmap(&[0b01000011], 8))].into_iter(), + vec![HybridEncoded::Bitmap(&[0b01000011], 8)].into_iter(), vec![Interval::new(0, 8)].into(), ); - let a = iter.by_ref().collect::, _>>().unwrap(); + let a = iter.by_ref().collect::>(); assert_eq!(iter.len(), 0); assert_eq!( a, @@ -46,13 +46,13 @@ fn bitmap_complete() { fn bitmap_interval_incomplete() { let mut iter = FilteredHybridBitmapIter::new( vec![ - Ok(HybridEncoded::Bitmap(&[0b01000011], 8)), - Ok(HybridEncoded::Bitmap(&[0b11111111], 8)), + HybridEncoded::Bitmap(&[0b01000011], 8), + HybridEncoded::Bitmap(&[0b11111111], 8), ] .into_iter(), vec![Interval::new(0, 10)].into(), ); - let a = iter.by_ref().collect::, _>>().unwrap(); + let a = iter.by_ref().collect::>(); assert_eq!(iter.len(), 0); assert_eq!( a, @@ -75,13 +75,13 @@ fn bitmap_interval_incomplete() { fn bitmap_interval_run_incomplete() { let mut iter = FilteredHybridBitmapIter::new( vec![ - Ok(HybridEncoded::Bitmap(&[0b01100011], 8)), - Ok(HybridEncoded::Bitmap(&[0b11111111], 8)), + HybridEncoded::Bitmap(&[0b01100011], 8), + HybridEncoded::Bitmap(&[0b11111111], 8), ] .into_iter(), vec![Interval::new(0, 5), Interval::new(7, 4)].into(), ); - let a = iter.by_ref().collect::, _>>().unwrap(); + let a = iter.by_ref().collect::>(); assert_eq!(iter.len(), 0); assert_eq!( a, @@ -110,13 +110,13 @@ fn bitmap_interval_run_incomplete() { fn bitmap_interval_run_skipped() { let mut iter = FilteredHybridBitmapIter::new( vec![ - Ok(HybridEncoded::Bitmap(&[0b01100011], 8)), - Ok(HybridEncoded::Bitmap(&[0b11111111], 8)), + HybridEncoded::Bitmap(&[0b01100011], 8), + HybridEncoded::Bitmap(&[0b11111111], 8), ] .into_iter(), vec![Interval::new(9, 2)].into(), ); - let a = iter.by_ref().collect::, _>>().unwrap(); + let a = iter.by_ref().collect::>(); assert_eq!(iter.len(), 0); assert_eq!( a, @@ -136,13 +136,13 @@ fn bitmap_interval_run_skipped() { fn bitmap_interval_run_offset_skipped() { let mut iter = FilteredHybridBitmapIter::new( vec![ - Ok(HybridEncoded::Bitmap(&[0b01100011], 8)), - Ok(HybridEncoded::Bitmap(&[0b11111111], 8)), + HybridEncoded::Bitmap(&[0b01100011], 8), + HybridEncoded::Bitmap(&[0b11111111], 8), ] .into_iter(), vec![Interval::new(0, 1), Interval::new(9, 2)].into(), ); - let a = iter.by_ref().collect::, _>>().unwrap(); + let a = iter.by_ref().collect::>(); assert_eq!(iter.len(), 0); assert_eq!( a, @@ -166,10 +166,10 @@ fn bitmap_interval_run_offset_skipped() { #[test] fn repeated_incomplete() { let mut iter = FilteredHybridBitmapIter::new( - vec![Ok(HybridEncoded::Repeated(true, 7))].into_iter(), + vec![HybridEncoded::Repeated(true, 7)].into_iter(), vec![Interval::new(1, 2)].into(), ); - let a = iter.by_ref().collect::, _>>().unwrap(); + let a = iter.by_ref().collect::>(); assert_eq!(iter.len(), 0); assert_eq!( a, @@ -186,10 +186,10 @@ fn repeated_incomplete() { #[test] fn repeated_complete() { let mut iter = FilteredHybridBitmapIter::new( - vec![Ok(HybridEncoded::Repeated(true, 8))].into_iter(), + vec![HybridEncoded::Repeated(true, 8)].into_iter(), vec![Interval::new(0, 8)].into(), ); - let a = iter.by_ref().collect::, _>>().unwrap(); + let a = iter.by_ref().collect::>(); assert_eq!(iter.len(), 0); assert_eq!( a, @@ -204,13 +204,13 @@ fn repeated_complete() { fn repeated_interval_incomplete() { let mut iter = FilteredHybridBitmapIter::new( vec![ - Ok(HybridEncoded::Repeated(true, 8)), - Ok(HybridEncoded::Repeated(false, 8)), + HybridEncoded::Repeated(true, 8), + HybridEncoded::Repeated(false, 8), ] .into_iter(), vec![Interval::new(0, 10)].into(), ); - let a = iter.by_ref().collect::, _>>().unwrap(); + let a = iter.by_ref().collect::>(); assert_eq!(iter.len(), 0); assert_eq!( a, @@ -231,13 +231,13 @@ fn repeated_interval_incomplete() { fn repeated_interval_run_incomplete() { let mut iter = FilteredHybridBitmapIter::new( vec![ - Ok(HybridEncoded::Repeated(true, 8)), - Ok(HybridEncoded::Repeated(false, 8)), + HybridEncoded::Repeated(true, 8), + HybridEncoded::Repeated(false, 8), ] .into_iter(), vec![Interval::new(0, 5), Interval::new(7, 4)].into(), ); - let a = iter.by_ref().collect::, _>>().unwrap(); + let a = iter.by_ref().collect::>(); assert_eq!(iter.len(), 0); assert_eq!( a, @@ -263,13 +263,13 @@ fn repeated_interval_run_incomplete() { fn repeated_interval_run_skipped() { let mut iter = FilteredHybridBitmapIter::new( vec![ - Ok(HybridEncoded::Repeated(true, 8)), - Ok(HybridEncoded::Repeated(false, 8)), + HybridEncoded::Repeated(true, 8), + HybridEncoded::Repeated(false, 8), ] .into_iter(), vec![Interval::new(9, 2)].into(), ); - let a = iter.by_ref().collect::, _>>().unwrap(); + let a = iter.by_ref().collect::>(); assert_eq!(iter.len(), 0); assert_eq!( a, @@ -288,13 +288,13 @@ fn repeated_interval_run_skipped() { fn repeated_interval_run_offset_skipped() { let mut iter = FilteredHybridBitmapIter::new( vec![ - Ok(HybridEncoded::Repeated(true, 8)), - Ok(HybridEncoded::Repeated(false, 8)), + HybridEncoded::Repeated(true, 8), + HybridEncoded::Repeated(false, 8), ] .into_iter(), vec![Interval::new(0, 1), Interval::new(9, 2)].into(), ); - let a = iter.by_ref().collect::, _>>().unwrap(); + let a = iter.by_ref().collect::>(); assert_eq!(iter.len(), 0); assert_eq!( a, diff --git a/crates/polars/tests/it/io/parquet/read/primitive_nested.rs b/crates/polars/tests/it/io/parquet/read/primitive_nested.rs index f8036b3fe17f..bc95a14381bd 100644 --- a/crates/polars/tests/it/io/parquet/read/primitive_nested.rs +++ b/crates/polars/tests/it/io/parquet/read/primitive_nested.rs @@ -175,7 +175,7 @@ fn read_dict_array( let bit_width = values[0]; let values = &values[1..]; - let (_, consumed) = uleb128::decode(values)?; + let (_, consumed) = uleb128::decode(values); let values = &values[consumed..]; let indices = bitpacked::Decoder::::try_new(values, bit_width as usize, length as usize)?; diff --git a/crates/polars/tests/it/io/parquet/read/utils.rs b/crates/polars/tests/it/io/parquet/read/utils.rs index 81492e60936e..409844b3b380 100644 --- a/crates/polars/tests/it/io/parquet/read/utils.rs +++ b/crates/polars/tests/it/io/parquet/read/utils.rs @@ -22,7 +22,7 @@ fn deserialize_bitmap>>( ) -> Result>, Error> { let mut deserialized = Vec::with_capacity(validity.len()); - validity.try_for_each(|run| match run? { + validity.try_for_each(|run| match run { HybridEncoded::Bitmap(bitmap, length) => { BitmapIter::new(bitmap, 0, length).try_for_each(|x| { if x {