Reader takes a reference to schema

Author: creativcoder

examples/recursive_record.rs

@@ -46,7 +46,7 @@ fn main() -> Result<(), Error> {
     let buf = writer.into_inner()?;
 
     // read
-    let reader = Reader::with_schema(buf.as_slice(), schema)?;
+    let reader = Reader::with_schema(buf.as_slice(), &schema)?;
     for i in reader {
         let a: LongList = from_value(&i)?;
         dbg!(a);

examples/writer_builder.rs

@@ -14,7 +14,7 @@ fn main() -> Result<(), Error> {
     writer.serialize(())?;
     let v = writer.into_inner()?;
 
-    let reader = Reader::with_schema(v.as_slice(), schema)?;
+    let reader = Reader::with_schema(v.as_slice(), &schema)?;
     for i in reader {
         dbg!(i?);
     }

src/reader.rs

@@ -25,15 +25,15 @@ use std::str::FromStr;
 use value::{FieldValue, Record, Value};
 
 /// Reader is the primary interface for reading data from an avro datafile.
-pub struct Reader<R> {
+pub struct Reader<'a, R> {
     source: R,
     header: Header,
-    reader_schema: Option<Schema>,
+    reader_schema: Option<&'a Schema>,
     block_buffer: Cursor<Vec<u8>>,
     entries_in_block: u64,
 }
 
-impl<R> Reader<R>
+impl<'a, R> Reader<'a, R>
 where
     R: Read,
 {
@@ -50,7 +50,7 @@ where
     }
 
     /// Create a Reader with the given reader schema and a readable buffer.
-    pub fn with_schema(mut source: R, reader_schema: Schema) -> Result<Self, AvrowErr> {
+    pub fn with_schema(mut source: R, reader_schema: &'a Schema) -> Result<Self, AvrowErr> {
         let header = Header::from_reader(&mut source)?;
 
         Ok(Reader {
@@ -121,7 +121,7 @@ pub fn from_value<'de, D: Deserialize<'de>>(
     }
 }
 
-impl<'a, 's, R: Read> Iterator for Reader<R> {
+impl<'a, 's, R: Read> Iterator for Reader<'_, R> {
     type Item = Result<Value, AvrowErr>;
 
     fn next(&mut self) -> Option<Self::Item> {

src/writer.rs

@@ -291,7 +291,7 @@ mod tests {
         writer.serialize(()).unwrap();
         let _v = writer.into_inner().unwrap();
 
-        let reader = Reader::with_schema(_v.as_slice(), schema).unwrap();
+        let reader = Reader::with_schema(_v.as_slice(), &schema).unwrap();
         for i in reader {
             let _: () = from_value(&i).unwrap();
         }
@@ -312,7 +312,7 @@ mod tests {
         writer.serialize(()).unwrap();
         let _v = writer.into_inner().unwrap();
 
-        let reader = Reader::with_schema(_v.as_slice(), schema).unwrap();
+        let reader = Reader::with_schema(_v.as_slice(), &schema).unwrap();
         assert!(reader.meta().contains_key("hello"));
     }
 }

tests/common.rs

@@ -40,7 +40,7 @@ pub(crate) fn writer_from_schema<'a>(schema: &'a Schema, codec: Codec) -> Writer
     writer
 }
 
-pub(crate) fn reader_with_schema<'a>(schema: Schema, buffer: Vec<u8>) -> Reader<Cursor<Vec<u8>>> {
+pub(crate) fn reader_with_schema<'a>(schema: &Schema, buffer: Vec<u8>) -> Reader<Cursor<Vec<u8>>> {
     let reader = Reader::with_schema(Cursor::new(buffer), schema).unwrap();
     reader
 }

tests/read_write.rs

@@ -83,7 +83,8 @@ fn read_write_primitive() {
             let buf = writer.into_inner().unwrap();
 
             // read
-            let reader = Reader::with_schema(buf.as_slice(), MockSchema.prim(name)).unwrap();
+            let schema = MockSchema.prim(name);
+            let reader = Reader::with_schema(buf.as_slice(), &schema).unwrap();
             for i in reader {
                 match primitive {
                     Primitive::Null => {
@@ -166,7 +167,7 @@ fn io_read_write_self_referential_record() {
         let buf = writer.into_inner().unwrap();
 
         // read
-        let reader = Reader::with_schema(buf.as_slice(), schema).unwrap();
+        let reader = Reader::with_schema(buf.as_slice(), &schema).unwrap();
         for i in reader {
             let _: LongList = from_value(&i).unwrap();
         }
@@ -204,7 +205,7 @@ fn enum_read_write() {
         let buf = writer.into_inner().unwrap();
 
         // read
-        let reader = Reader::with_schema(buf.as_slice(), schema).unwrap();
+        let reader = Reader::with_schema(buf.as_slice(), &schema).unwrap();
         for i in reader {
             let _: Suit = from_value(&i).unwrap();
         }
@@ -230,7 +231,7 @@ fn array_read_write() {
         let buf = writer.into_inner().unwrap();
 
         // read
-        let reader = Reader::with_schema(buf.as_slice(), schema).unwrap();
+        let reader = Reader::with_schema(buf.as_slice(), &schema).unwrap();
         for i in reader {
             let _: Vec<&str> = from_value(&i).unwrap();
         }
@@ -258,7 +259,7 @@ fn map_read_write() {
         let buf = writer.into_inner().unwrap();
 
         // read
-        let reader = Reader::with_schema(buf.as_slice(), schema).unwrap();
+        let reader = Reader::with_schema(buf.as_slice(), &schema).unwrap();
         for i in reader {
             let _: HashMap<String, i64> = from_value(&i).unwrap();
         }
@@ -284,7 +285,7 @@ fn union_read_write() {
         let buf = writer.into_inner().unwrap();
 
         // read
-        let reader = Reader::with_schema(buf.as_slice(), schema).unwrap();
+        let reader = Reader::with_schema(buf.as_slice(), &schema).unwrap();
         for i in reader {
             let val = i.as_ref().unwrap();
             match val {
@@ -322,7 +323,7 @@ fn fixed_read_write() {
         let buf = writer.into_inner().unwrap();
 
         // read
-        let reader = Reader::with_schema(buf.as_slice(), schema).unwrap();
+        let reader = Reader::with_schema(buf.as_slice(), &schema).unwrap();
         for i in reader {
             let a: [u8; 16] = from_value(&i).unwrap();
             assert_eq!(a.len(), 16);
@@ -341,7 +342,7 @@ fn bytes_read_write() {
     let buf = writer.into_inner().unwrap();
     // let mut v: Vec<u8> = vec![];
 
-    let reader = Reader::with_schema(buf.as_slice(), schema).unwrap();
+    let reader = Reader::with_schema(buf.as_slice(), &schema).unwrap();
     for i in reader {
         // dbg!(i);
         let b: &[u8] = from_value(&i).unwrap();

tests/schema_resolution.rs

@@ -21,7 +21,7 @@ fn null_fails_with_other_primitive_schema() {
     let buf = writer.into_inner().unwrap();
 
     let reader_schema = MockSchema.prim("boolean");
-    let reader = Reader::with_schema(buf.as_slice(), reader_schema).unwrap();
+    let reader = Reader::with_schema(buf.as_slice(), &reader_schema).unwrap();
 
     for i in reader {
         let _ = i.unwrap();
@@ -41,7 +41,7 @@ fn writer_to_reader_promotion_primitives() {
         let buf = writer.into_inner().unwrap();
 
         let reader_schema = MockSchema.prim(reader_schema);
-        let reader = Reader::with_schema(buf.as_slice(), reader_schema).unwrap();
+        let reader = Reader::with_schema(buf.as_slice(), &reader_schema).unwrap();
         for i in reader {
             assert!(i.is_ok());
             let _a = i.unwrap();
@@ -59,7 +59,7 @@ fn writer_to_reader_promotion_primitives() {
         let buf = writer.into_inner().unwrap();
 
         let reader_schema = MockSchema.prim(reader_schema);
-        let reader = Reader::with_schema(buf.as_slice(), reader_schema).unwrap();
+        let reader = Reader::with_schema(buf.as_slice(), &reader_schema).unwrap();
         for i in reader {
             assert!(i.is_ok());
         }
@@ -76,7 +76,7 @@ fn writer_to_reader_promotion_primitives() {
         let buf = writer.into_inner().unwrap();
 
         let reader_schema = MockSchema.prim(reader_schema);
-        let reader = Reader::with_schema(buf.as_slice(), reader_schema).unwrap();
+        let reader = Reader::with_schema(buf.as_slice(), &reader_schema).unwrap();
         for i in reader {
             assert!(i.is_ok());
         }
@@ -93,7 +93,7 @@ fn writer_to_reader_promotion_primitives() {
         let buf = writer.into_inner().unwrap();
 
         let reader_schema = MockSchema.prim(reader_schema);
-        let reader = Reader::with_schema(buf.as_slice(), reader_schema).unwrap();
+        let reader = Reader::with_schema(buf.as_slice(), &reader_schema).unwrap();
         for i in reader {
             assert!(i.is_ok());
             let a = i.unwrap();
@@ -112,7 +112,7 @@ fn writer_to_reader_promotion_primitives() {
         let buf = writer.into_inner().unwrap();
 
         let reader_schema = MockSchema.prim(reader_schema);
-        let reader = Reader::with_schema(buf.as_slice(), reader_schema).unwrap();
+        let reader = Reader::with_schema(buf.as_slice(), &reader_schema).unwrap();
         for i in reader {
             assert!(i.is_ok());
             let a = i.unwrap();
@@ -144,7 +144,7 @@ fn enum_fails_schema_resolution() {
     // Reading a symbol which does not exist in writer's schema should fail
     let reader_schema =
         Schema::from_str(r##"{"type": "enum", "name": "Foo", "symbols": ["F"] }"##).unwrap();
-    let reader = Reader::with_schema(buf.as_slice(), reader_schema).unwrap();
+    let reader = Reader::with_schema(buf.as_slice(), &reader_schema).unwrap();
 
     // let reader = reader_with_schema(reader_schema, name);
     for i in reader {
@@ -167,7 +167,7 @@ fn schema_resolution_map() {
     // // Reading a symbol which does not exist in writer's schema should fail
     let reader_schema = Schema::from_str(r##"{"type": "map", "values": "int"}"##).unwrap();
 
-    let reader = reader_with_schema(reader_schema, buf);
+    let reader = reader_with_schema(&reader_schema, buf);
     for i in reader {
         let _ = i.unwrap();
     }
@@ -200,7 +200,7 @@ fn record_schema_resolution_with_default_value() {
     let buf = writer.into_inner().unwrap();
 
     let schema = MockSchema.record_default();
-    let reader = reader_with_schema(schema, buf);
+    let reader = reader_with_schema(&schema, buf);
     for i in reader {
         let rec: Result<LongListDefault, _> = from_value(&i);
         assert!(rec.is_ok());
@@ -219,7 +219,7 @@ fn writer_is_a_union_but_reader_is_not() {
 
     let schema_str = r##""int""##;
     let reader_schema = Schema::from_str(schema_str).unwrap();
-    let mut reader = reader_with_schema(reader_schema, buf);
+    let mut reader = reader_with_schema(&reader_schema, buf);
     assert!(reader.next().unwrap().is_err());
     assert!(reader.next().unwrap().is_ok());
 }
@@ -234,12 +234,12 @@ fn reader_is_a_union_but_writer_is_not() {
 
     // err
     let reader_schema = Schema::from_str(r##"["null", "string"]"##).unwrap();
-    let mut reader = reader_with_schema(reader_schema, buf.clone());
+    let mut reader = reader_with_schema(&reader_schema, buf.clone());
     assert!(reader.next().unwrap().is_err());
 
     // ok
     let reader_schema = Schema::from_str(r##"["null", "int"]"##).unwrap();
-    let mut reader = reader_with_schema(reader_schema, buf);
+    let mut reader = reader_with_schema(&reader_schema, buf);
     assert!(reader.next().unwrap().is_ok());
 }
 
@@ -252,7 +252,7 @@ fn both_are_unions_but_different() {
     let buf = writer.into_inner().unwrap();
 
     let reader_schema = Schema::from_str(r##"["boolean", "string"]"##).unwrap();
-    let mut reader = reader_with_schema(reader_schema, buf);
+    let mut reader = reader_with_schema(&reader_schema, buf);
 
     // err
     assert!(reader.next().unwrap().is_err());
@@ -271,7 +271,7 @@ fn both_are_map() {
     // let reader_schema =
     //     Schema::from_str(r##"["boolean", {"type":"map", "values": "string"}]"##).unwrap();
     let reader_schema = Schema::from_str(r##"{"type": "map", "values": "string"}"##).unwrap();
-    let mut reader = reader_with_schema(reader_schema, buf);
+    let mut reader = reader_with_schema(&reader_schema, buf);
     assert!(reader.next().unwrap().is_ok());
 }
 
@@ -284,7 +284,7 @@ fn both_are_arrays() {
     let buf = writer.into_inner().unwrap();
 
     let reader_schema = Schema::from_str(r##"{"type": "array", "items": "int"}"##).unwrap();
-    let mut reader = reader_with_schema(reader_schema, buf);
+    let mut reader = reader_with_schema(&reader_schema, buf);
     assert!(reader.next().unwrap().is_ok());
 }
 
@@ -297,7 +297,7 @@ fn both_are_enums() {
     let buf = writer.into_inner().unwrap();
 
     let reader_schema = Schema::from_str(r##"{"type": "array", "items": "int"}"##).unwrap();
-    let mut reader = reader_with_schema(reader_schema, buf);
+    let mut reader = reader_with_schema(&reader_schema, buf);
     assert!(reader.next().unwrap().is_ok());
 }
 
@@ -310,6 +310,6 @@ fn null() {
     let buf = writer.into_inner().unwrap();
 
     let reader_schema = Schema::from_str(r##"{"type": "null"}"##).unwrap();
-    let mut reader = reader_with_schema(reader_schema, buf);
+    let mut reader = reader_with_schema(&reader_schema, buf);
     assert!(reader.next().unwrap().is_ok());
 }