code review improvements

Author: kumarlokesh

arrow-avro/benches/avro_reader.rs

@@ -110,7 +110,7 @@ fn read_avro_test_file(
         ints.push(i32::from_le_bytes(int_bytes));
     }
 
-    let string_array: ArrayRef = if options.use_utf8view {
+    let string_array: ArrayRef = if options.use_utf8view() {
         Arc::new(StringViewArray::from_iter(
             strings.iter().map(|s| Some(s.as_str())),
         ))
@@ -123,7 +123,7 @@ fn read_avro_test_file(
     let int_array: ArrayRef = Arc::new(Int32Array::from(ints));
 
     let schema = Arc::new(Schema::new(vec![
-        if options.use_utf8view {
+        if options.use_utf8view() {
             Field::new("string_field", DataType::Utf8View, false)
         } else {
             Field::new("string_field", DataType::Utf8, false)
@@ -244,19 +244,15 @@ fn bench_avro_reader(c: &mut Criterion) {
 
         group.bench_function(format!("string_array_{}_chars", str_length), |b| {
             b.iter(|| {
-                let options = ReadOptions {
-                    use_utf8view: false,
-                };
-
+                let options = ReadOptions::default();
                 let batch = read_avro_test_file(file_path, &options).unwrap();
                 criterion::black_box(batch)
             })
         });
 
         group.bench_function(format!("string_view_{}_chars", str_length), |b| {
             b.iter(|| {
-                let options = ReadOptions { use_utf8view: true };
-
+                let options = ReadOptions::default().with_utf8view(true);
                 let batch = read_avro_test_file(file_path, &options).unwrap();
                 criterion::black_box(batch)
             })

arrow-avro/examples/read_with_utf8view.rs

@@ -50,7 +50,7 @@ fn main() -> Result<(), Box<dyn std::error::Error>> {
     reader.seek(SeekFrom::Start(0))?;
 
     let start = Instant::now();
-    let options = ReadOptions { use_utf8view: true };
+    let options = ReadOptions::default().with_utf8view(true);
     let batch_view = read_avro_with_options(&mut reader, &options)?;
     let view_duration = start.elapsed();
 
@@ -108,7 +108,7 @@ fn read_avro_with_options(
     let string_data = vec!["avro1", "avro2", "avro3", "avro4", "avro5"];
     let int_data = vec![1, 2, 3, 4, 5];
 
-    let string_array: ArrayRef = if options.use_utf8view {
+    let string_array: ArrayRef = if options.use_utf8view() {
         Arc::new(StringViewArray::from(string_data))
     } else {
         Arc::new(StringArray::from(string_data))

arrow-avro/src/lib.rs

@@ -33,10 +33,10 @@
 /// Implements the primary reader interface and record decoding logic.
 pub mod reader;
 
-/// Avro schema parsing and representation
-///
-/// Provides types for parsing and representing Avro schema definitions.
-pub mod schema;
+// Avro schema parsing and representation
+//
+// Provides types for parsing and representing Avro schema definitions.
+mod schema;
 
 /// Compression codec implementations for Avro
 ///

arrow-avro/src/reader/mod.rs

@@ -42,20 +42,33 @@ mod vlq;
 /// let default_options = ReadOptions::default();
 ///
 /// // Enable Utf8View support for better string performance
-/// let options = ReadOptions {
-///     use_utf8view: true,
-///     ..ReadOptions::default()
-/// };
+/// let options = ReadOptions::default()
+///     .with_utf8view(true);
 /// ```
-#[derive(Default)]
+#[derive(Default, Debug, Clone)]
 pub struct ReadOptions {
-    /// If true, use StringViewArray instead of StringArray for string data
-    ///
-    /// When this option is enabled, string data from Avro files will be loaded
-    /// into Arrow's StringViewArray instead of the standard StringArray.
+    use_utf8view: bool,
+}
+
+impl ReadOptions {
+    /// Create a new `ReadOptions` with default values
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set whether to use StringViewArray for string data
     ///
-    /// Default: false
-    pub use_utf8view: bool,
+    /// When enabled, string data from Avro files will be loaded into
+    /// Arrow's StringViewArray instead of the standard StringArray.
+    pub fn with_utf8view(mut self, use_utf8view: bool) -> Self {
+        self.use_utf8view = use_utf8view;
+        self
+    }
+
+    /// Get whether StringViewArray is enabled for string data
+    pub fn use_utf8view(&self) -> bool {
+        self.use_utf8view
+    }
 }
 
 /// Read a [`Header`] from the provided [`BufRead`]
@@ -131,11 +144,8 @@ mod test {
         let schema = header.schema().unwrap().unwrap();
         let root = AvroField::try_from(&schema).unwrap();
 
-        let mut decoder = if options.use_utf8view {
-            RecordDecoder::try_new_with_options(root.data_type(), true).unwrap()
-        } else {
-            RecordDecoder::try_new(root.data_type()).unwrap()
-        };
+        let mut decoder =
+            RecordDecoder::try_new_with_options(root.data_type(), options.clone()).unwrap();
 
         for result in read_blocks(reader) {
             let block = result.unwrap();

arrow-avro/src/reader/record.rs

@@ -19,6 +19,7 @@ use crate::codec::{AvroDataType, Codec, Nullability};
 use crate::reader::block::{Block, BlockDecoder};
 use crate::reader::cursor::AvroCursor;
 use crate::reader::header::Header;
+use crate::reader::ReadOptions;
 use crate::schema::*;
 use arrow_array::types::*;
 use arrow_array::*;
@@ -38,28 +39,27 @@ pub struct RecordDecoder {
 }
 
 impl RecordDecoder {
-    /// Create a new [`RecordDecoder`] from the provided [`AvroDataType`]
+    /// Create a new [`RecordDecoder`] from the provided [`AvroDataType`] with default options
     pub fn try_new(data_type: &AvroDataType) -> Result<Self, ArrowError> {
-        Self::try_new_with_options(data_type, false)
+        Self::try_new_with_options(data_type, ReadOptions::default())
     }
 
     /// Create a new [`RecordDecoder`] from the provided [`AvroDataType`] with additional options
     ///
     /// This method allows you to customize how the Avro data is decoded into Arrow arrays.
-    /// In particular, it allows enabling Utf8View support for better string performance.
     ///
     /// # Parameters
     /// * `data_type` - The Avro data type to decode
-    /// * `use_utf8view` - If true, use StringViewArray instead of StringArray for string data
+    /// * `options` - Configuration options for decoding
     pub fn try_new_with_options(
         data_type: &AvroDataType,
-        use_utf8view: bool,
+        options: ReadOptions,
     ) -> Result<Self, ArrowError> {
         match Decoder::try_new(data_type)? {
             Decoder::Record(fields, encodings) => Ok(Self {
                 schema: Arc::new(ArrowSchema::new(fields)),
                 fields: encodings,
-                use_utf8view,
+                use_utf8view: options.use_utf8view(),
             }),
             encoding => Err(ArrowError::ParseError(format!(
                 "Expected record got {encoding:?}"