This is an automated email from the ASF dual-hosted git repository. kriskras99 pushed a commit to branch feat/full_enum_support in repository https://gitbox.apache.org/repos/asf/avro-rs.git
commit 5cee352242e403f2e7c6f7c7f3a4589f556b3ccd Author: Kriskras99 <[email protected]> AuthorDate: Thu Mar 19 17:29:34 2026 +0100 wip --- avro/src/bigdecimal.rs | 25 ++++--- avro/src/serde/deser_schema/mod.rs | 17 ++--- avro/src/serde/ser_schema/mod.rs | 27 +++++++- avro/src/serde/ser_schema/record/mod.rs | 89 +++++++++++++++++++------ avro/tests/avro-rs-226.rs | 22 +++--- avro/tests/avro-rs-285-bytes_deserialization.rs | 17 ++--- avro/tests/schema.rs | 13 ++-- avro/tests/union_schema.rs | 81 ++++++++++------------ avro_derive/tests/derive.rs | 30 ++++----- avro_derive/tests/serde.rs | 20 +++--- 10 files changed, 191 insertions(+), 150 deletions(-) diff --git a/avro/src/bigdecimal.rs b/avro/src/bigdecimal.rs index ee26ee1..28eeb51 100644 --- a/avro/src/bigdecimal.rs +++ b/avro/src/bigdecimal.rs @@ -70,13 +70,16 @@ pub(crate) fn deserialize_big_decimal(mut bytes: &[u8]) -> AvroResult<BigDecimal #[cfg(test)] mod tests { use super::*; - use crate::{Codec, Reader, Schema, Writer, error::Error, from_value, types::Record}; + use crate::{ + Codec, Reader, Schema, Writer, error::Error, reader::datum::GenericDatumReader, + types::Record, writer::datum::GenericDatumWriter, + }; use apache_avro_test_helper::TestResult; use bigdecimal::{One, Zero}; use pretty_assertions::assert_eq; use std::{ fs::File, - io::BufReader, + io::{BufReader, Cursor}, ops::{Div, Mul}, str::FromStr, }; @@ -206,18 +209,14 @@ mod tests { let test = Test::default(); - // write a record - let mut writer = Writer::new(&schema, Vec::new())?; - writer.append_ser(test.clone())?; - - let wrote_data = writer.into_inner()?; - - // read record - let mut reader = Reader::new(&wrote_data[..])?; - - let value = reader.next().unwrap()?; + let serialized = GenericDatumWriter::builder(&schema) + .build()? + .write_ser_to_vec(&test)?; + let value: Test = GenericDatumReader::builder(&schema) + .build()? + .read_deser(&mut Cursor::new(serialized))?; - assert_eq!(test, from_value::<Test>(&value)?); + assert_eq!(value, test); Ok(()) } diff --git a/avro/src/serde/deser_schema/mod.rs b/avro/src/serde/deser_schema/mod.rs index f7c8dc6..d32e4fa 100644 --- a/avro/src/serde/deser_schema/mod.rs +++ b/avro/src/serde/deser_schema/mod.rs @@ -694,26 +694,21 @@ impl<'de, 's, 'r, R: Read, S: Borrow<Schema>> Deserializer<'de> fn deserialize_enum<V>( self, _name: &'static str, - variants: &'static [&'static str], + // This also includes aliases, so can't be used to check the amount of symbols + _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value, Self::Error> where V: Visitor<'de>, { match self.schema { - Schema::Enum(schema) if schema.symbols.len() == variants.len() => { + Schema::Enum(schema) => { visitor.visit_enum(PlainEnumDeserializer::new(self.reader, schema)) } - Schema::Union(union) if union.variants().len() == variants.len() => { + Schema::Union(union) => { visitor.visit_enum(UnionEnumDeserializer::new(self.reader, union, self.config)) } - _ => Err(self.error( - "enum", - format!( - "Expected Schema::Enum(symbols.len() == {}) | Schema::Union(variants.len() == {}", - variants.len(), variants.len() - ), - )), + _ => Err(self.error("enum", "Expected Schema::Enum | Schema::Union")), } } @@ -1570,7 +1565,7 @@ mod tests { assert_roundtrip(uuid, &schema, Vec::new())?; let buf = GenericDatumWriter::builder(&alt_schema) - // .human_readable(true) + .human_readable(true) .build()? .write_ser_to_vec(&uuid)?; diff --git a/avro/src/serde/ser_schema/mod.rs b/avro/src/serde/ser_schema/mod.rs index c971bff..2ba62a6 100644 --- a/avro/src/serde/ser_schema/mod.rs +++ b/avro/src/serde/ser_schema/mod.rs @@ -1928,6 +1928,9 @@ mod tests { struct Foo { a: String, b: String, + c: i64, + d: f64, + e: i64, } let schema = Schema::parse_str( r#" @@ -1942,6 +1945,18 @@ mod tests { { "name":"a", "type":"string" + }, + { + "name":"d", + "type":"double" + }, + { + "name":"e", + "type":"long" + }, + { + "name":"c", + "type":"long" } ] } @@ -1952,13 +1967,19 @@ mod tests { let foo = Foo { a: "Hello".into(), b: "World".into(), + c: 42, + d: std::f64::consts::PI, + e: 5, }; - // Serializing fields out of order is NOT supported - assert_serialize_err( + + assert_serialize( foo, &schema, &names, - r#"Missing default for skipped field 'b' of schema RecordSchema { name: Name { name: "Foo", .. }, fields: [RecordField { name: "b", schema: String, .. }, RecordField { name: "a", schema: String, .. }], .. }"#, + &[ + 10, b'W', b'o', b'r', b'l', b'd', 10, b'H', b'e', b'l', b'l', b'o', 24, 45, 68, 84, + 251, 33, 9, 64, 10, 84, + ], ); Ok(()) diff --git a/avro/src/serde/ser_schema/record/mod.rs b/avro/src/serde/ser_schema/record/mod.rs index 0d44828..ac31391 100644 --- a/avro/src/serde/ser_schema/record/mod.rs +++ b/avro/src/serde/ser_schema/record/mod.rs @@ -26,12 +26,18 @@ use crate::{Error, Schema}; use serde::Serialize; use serde::ser::{SerializeMap, SerializeStruct, SerializeStructVariant}; use std::borrow::Borrow; +use std::cmp::Ordering; +use std::collections::HashMap; use std::io::Write; pub struct RecordSerializer<'s, 'w, W: Write, S: Borrow<Schema>> { writer: &'w mut W, record: &'s RecordSchema, config: Config<'s, S>, + /// Cache fields received out-of-order + cache: HashMap<usize, Vec<u8>>, + /// The position of the current map entry being written + map_position: Option<usize>, /// The field that should be written now. field_position: usize, bytes_written: usize, @@ -48,6 +54,8 @@ impl<'s, 'w, W: Write, S: Borrow<Schema>> RecordSerializer<'s, 'w, W, S> { writer, record, config, + cache: HashMap::new(), + map_position: None, field_position: 0, bytes_written: bytes_written.unwrap_or(0), } @@ -89,21 +97,49 @@ impl<'s, 'w, W: Write, S: Borrow<Schema>> RecordSerializer<'s, 'w, W, S> { position: usize, value: &T, ) -> Result<(), Error> { - // Serialize any skipped fields using their default value - while self.field_position < position { - self.serialize_default(self.field_position)?; - } let field = &self.record.fields[position]; - self.bytes_written += value - .serialize(SchemaAwareSerializer::new( - self.writer, - &field.schema, - self.config, - )?) - .map_err(|e| self.field_error(self.field_position, e))?; - self.field_position += 1; - - Ok(()) + match self.field_position.cmp(&position) { + Ordering::Equal => { + // Field received in the right order + self.bytes_written += value + .serialize(SchemaAwareSerializer::new( + self.writer, + &field.schema, + self.config, + )?) + .map_err(|e| self.field_error(self.field_position, e))?; + self.field_position += 1; + + // Write any fields that were already received and can now be written + while let Some(bytes) = self.cache.remove(&self.field_position) { + self.writer.write_all(&bytes).map_err(Details::WriteBytes)?; + self.bytes_written += bytes.len(); + self.field_position += 1; + } + + Ok(()) + } + Ordering::Less => { + // Another field needs to be written first, so cache this field + let mut bytes = Vec::new(); + value + .serialize(SchemaAwareSerializer::new( + &mut bytes, + &field.schema, + self.config, + )?) + .map_err(|e| self.field_error(self.field_position, e))?; + if self.cache.insert(position, bytes).is_some() { + Err(Details::FieldNameDuplicate(field.name.clone()).into()) + } else { + Ok(()) + } + } + Ordering::Greater => { + // This field is already written to the writer so we got a duplicate + Err(Details::FieldNameDuplicate(field.name.clone()).into()) + } + } } fn serialize_default(&mut self, position: usize) -> Result<(), Error> { @@ -171,10 +207,7 @@ impl<'s, 'w, W: Write, S: Borrow<Schema>> SerializeMap for RecordSerializer<'s, { let name = key.serialize(StringSerializer)?; if let Some(position) = self.record.lookup.get(&name).copied() { - // Write any skipped fields now, so that `serialize_value` can just call `serialize_next_field` - while self.field_position < position { - self.serialize_default(self.field_position)?; - } + self.map_position = Some(position); Ok(()) } else { Err(Details::FieldName(name.to_string()).into()) @@ -185,13 +218,29 @@ impl<'s, 'w, W: Write, S: Borrow<Schema>> SerializeMap for RecordSerializer<'s, where T: ?Sized + Serialize, { - // `serialize_key` made sure that all skipped fields have been written - self.serialize_next_field(self.field_position, value) + self.serialize_next_field( + self.map_position + .expect("serialze_value called without calling serialize_key"), + value, + ) } fn end(self) -> Result<Self::Ok, Self::Error> { self.end() } + + fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error> + where + K: ?Sized + Serialize, + V: ?Sized + Serialize, + { + let name = key.serialize(StringSerializer)?; + if let Some(position) = self.record.lookup.get(&name).copied() { + self.serialize_next_field(position, value) + } else { + Err(Details::FieldName(name.to_string()).into()) + } + } } impl<'s, 'w, W: Write, S: Borrow<Schema>> SerializeStructVariant diff --git a/avro/tests/avro-rs-226.rs b/avro/tests/avro-rs-226.rs index fd1b6d2..45d6f1e 100644 --- a/avro/tests/avro-rs-226.rs +++ b/avro/tests/avro-rs-226.rs @@ -15,7 +15,9 @@ // specific language governing permissions and limitations // under the License. -use apache_avro::{AvroSchema, Schema, Writer, from_value}; +use apache_avro::{ + AvroSchema, Schema, reader::datum::GenericDatumReader, writer::datum::GenericDatumWriter, +}; use apache_avro_test_helper::TestResult; use serde::{Deserialize, Serialize, de::DeserializeOwned}; use std::fmt::Debug; @@ -24,17 +26,13 @@ fn ser_deser<T>(schema: &Schema, record: T) -> TestResult where T: Serialize + DeserializeOwned + Debug + PartialEq + Clone, { - let record2 = record.clone(); - let mut writer = Writer::new(schema, vec![])?; - writer.append_ser(record)?; - let bytes_written = writer.into_inner()?; - - let reader = apache_avro::Reader::new(&bytes_written[..])?; - for value in reader { - let value = value?; - let deserialized = from_value::<T>(&value)?; - assert_eq!(deserialized, record2); - } + let serialized = GenericDatumWriter::builder(schema) + .build()? + .write_ser_to_vec(&record)?; + let deserialized: T = GenericDatumReader::builder(schema) + .build()? + .read_deser(&mut &serialized[..])?; + assert_eq!(deserialized, record); Ok(()) } diff --git a/avro/tests/avro-rs-285-bytes_deserialization.rs b/avro/tests/avro-rs-285-bytes_deserialization.rs index b9ebe80..5dd5e4e 100644 --- a/avro/tests/avro-rs-285-bytes_deserialization.rs +++ b/avro/tests/avro-rs-285-bytes_deserialization.rs @@ -15,10 +15,12 @@ // specific language governing permissions and limitations // under the License. +use apache_avro::Reader; use apache_avro_test_helper::TestResult; use serde::{Deserialize, Serialize}; #[derive(Debug, Deserialize, PartialEq, Serialize)] +#[serde(rename = "SimpleRecord")] struct ExampleByteArray { #[serde(with = "apache_avro::serde::bytes_opt")] data_bytes: Option<Vec<u8>>, @@ -26,6 +28,7 @@ struct ExampleByteArray { } #[derive(Deserialize, Serialize)] +#[serde(rename = "SimpleRecord")] struct ExampleByteArrayFiltered { description: Option<String>, } @@ -70,10 +73,9 @@ fn avro_rs_285_bytes_deserialization_round_trip() -> TestResult { let avro_data = writer.into_inner()?; // deserialize Avro binary data back into ExampleByteArray structs - let reader = apache_avro::Reader::new(&avro_data[..])?; - let deserialized_records: Vec<ExampleByteArray> = reader - .map(|value| apache_avro::from_value::<ExampleByteArray>(&value.unwrap()).unwrap()) - .collect(); + let deserialized_records = Reader::new(&avro_data[..])? + .into_deser_iter() + .collect::<Result<Vec<ExampleByteArray>, _>>()?; assert_eq!(records, deserialized_records); Ok(()) @@ -118,10 +120,9 @@ fn avro_rs_285_bytes_deserialization_filtered_round_trip() -> TestResult { let avro_data = writer.into_inner()?; // deserialize Avro binary data back into ExampleByteArrayFiltered structs - let reader = apache_avro::Reader::new(&avro_data[..])?; - let deserialized_records: Vec<ExampleByteArrayFiltered> = reader - .map(|value| apache_avro::from_value::<ExampleByteArrayFiltered>(&value.unwrap()).unwrap()) - .collect(); + let deserialized_records = Reader::new(&avro_data[..])? + .into_deser_iter() + .collect::<Result<Vec<ExampleByteArrayFiltered>, _>>()?; assert_eq!(records.len(), deserialized_records.len()); diff --git a/avro/tests/schema.rs b/avro/tests/schema.rs index 89e328a..0c322aa 100644 --- a/avro/tests/schema.rs +++ b/avro/tests/schema.rs @@ -15,14 +15,13 @@ // specific language governing permissions and limitations // under the License. +use apache_avro::to_value; use apache_avro::writer::datum::GenericDatumWriter; use apache_avro::{ Codec, Error, Reader, Schema, Writer, error::Details, - from_value, reader::datum::GenericDatumReader, schema::{EnumSchema, FixedSchema, Name, RecordField, RecordSchema}, - to_value, types::{Record, Value}, }; use apache_avro_test_helper::{ @@ -837,7 +836,7 @@ fn avro_old_issue_47() -> TestResult { let schema_str = r#" { "type": "record", - "name": "my_record", + "name": "MyRecord", "fields": [ {"name": "a", "type": "long"}, {"name": "b", "type": "string"} @@ -858,15 +857,13 @@ fn avro_old_issue_47() -> TestResult { a: 1, }; - let ser_value = to_value(record.clone())?; let serialized_bytes = GenericDatumWriter::builder(&schema) .build()? - .write_value_to_vec(ser_value)?; + .write_ser_to_vec(&record)?; - let de_value = GenericDatumReader::builder(&schema) + let deserialized_record: MyRecord = GenericDatumReader::builder(&schema) .build()? - .read_value(&mut &*serialized_bytes)?; - let deserialized_record = from_value::<MyRecord>(&de_value)?; + .read_deser(&mut &*serialized_bytes)?; assert_eq!(record, deserialized_record); Ok(()) diff --git a/avro/tests/union_schema.rs b/avro/tests/union_schema.rs index 892b69b..04a9709 100644 --- a/avro/tests/union_schema.rs +++ b/avro/tests/union_schema.rs @@ -15,8 +15,11 @@ // specific language governing permissions and limitations // under the License. -use apache_avro::{AvroResult, Codec, Reader, Schema, Writer, from_value}; +use apache_avro::{Schema, reader::datum::GenericDatumReader, writer::datum::GenericDatumWriter}; +use apache_avro_test_helper::TestResult; +use pretty_assertions::assert_eq; use serde::{Deserialize, Serialize, de::DeserializeOwned}; +use std::fmt::Debug; static SCHEMA_A_STR: &str = r#"{ "name": "A", @@ -65,26 +68,25 @@ struct C { field_c: String, } -fn encode_decode<T>(input: &T, schema: &Schema, schemata: &[Schema]) -> AvroResult<T> +#[track_caller] +fn assert_roundtrip<T>(input: &T, schema: &Schema, schemata: &[Schema]) -> TestResult where - T: DeserializeOwned + Serialize, + T: DeserializeOwned + Serialize + PartialEq + Debug, { - let mut encoded: Vec<u8> = Vec::new(); - let mut writer = - Writer::with_schemata(schema, schemata.iter().collect(), &mut encoded, Codec::Null)?; - writer.append_ser(input)?; - writer.flush()?; - drop(writer); //drop the writer so that `encoded` is no more referenced mutably - - let mut reader = Reader::builder(encoded.as_slice()) - .reader_schema(schema) - .schemata(schemata.iter().collect()) - .build()?; - from_value::<T>(&reader.next().expect("")?) + let serialized = GenericDatumWriter::builder(schema) + .schemata(schemata.iter().collect())? + .build()? + .write_ser_to_vec(input)?; + let deserialized: T = GenericDatumReader::builder(schema) + .writer_schemata(schemata.iter().collect())? + .build()? + .read_deser(&mut &serialized[..])?; + assert_eq!(&deserialized, input); + Ok(()) } #[test] -fn test_avro_3901_union_schema_round_trip_no_null() -> AvroResult<()> { +fn test_avro_3901_union_schema_round_trip_no_null() -> TestResult { let schemata: Vec<Schema> = Schema::parse_list([SCHEMA_A_STR, SCHEMA_B_STR, SCHEMA_C_STR]).expect("parsing schemata"); @@ -92,15 +94,13 @@ fn test_avro_3901_union_schema_round_trip_no_null() -> AvroResult<()> { field_union: (UnionAB::A(A { field_a: 45.5 })), field_c: "foo".to_string(), }; - let output = encode_decode(&input, &schemata[2], &schemata)?; - assert_eq!(input, output); + assert_roundtrip(&input, &schemata[2], &schemata)?; let input = C { field_union: (UnionAB::B(B { field_b: 73 })), field_c: "bar".to_string(), }; - let output = encode_decode(&input, &schemata[2], &schemata)?; - assert_eq!(input, output); + assert_roundtrip(&input, &schemata[2], &schemata)?; Ok(()) } @@ -128,7 +128,7 @@ struct D { } #[test] -fn test_avro_3901_union_schema_round_trip_null_at_start() -> AvroResult<()> { +fn test_avro_3901_union_schema_round_trip_null_at_start() -> TestResult { let schemata: Vec<Schema> = Schema::parse_list([SCHEMA_A_STR, SCHEMA_B_STR, SCHEMA_D_STR]).expect("parsing schemata"); @@ -136,22 +136,19 @@ fn test_avro_3901_union_schema_round_trip_null_at_start() -> AvroResult<()> { field_union: UnionNoneAB::A(A { field_a: 54.25 }), field_d: "fooy".to_string(), }; - let output = encode_decode(&input, &schemata[2], &schemata)?; - assert_eq!(input, output); + assert_roundtrip(&input, &schemata[2], &schemata)?; let input = D { field_union: UnionNoneAB::None, field_d: "fooyy".to_string(), }; - let output = encode_decode(&input, &schemata[2], &schemata)?; - assert_eq!(input, output); + assert_roundtrip(&input, &schemata[2], &schemata)?; let input = D { field_union: UnionNoneAB::B(B { field_b: 103 }), field_d: "foov".to_string(), }; - let output = encode_decode(&input, &schemata[2], &schemata)?; - assert_eq!(input, output); + assert_roundtrip(&input, &schemata[2], &schemata)?; Ok(()) } @@ -179,7 +176,7 @@ struct E { } #[test] -fn test_avro_3901_union_schema_round_trip_with_out_of_order_null() -> AvroResult<()> { +fn test_avro_3901_union_schema_round_trip_with_out_of_order_null() -> TestResult { let schemata: Vec<Schema> = Schema::parse_list([SCHEMA_A_STR, SCHEMA_B_STR, SCHEMA_E_STR]).expect("parsing schemata"); @@ -187,22 +184,19 @@ fn test_avro_3901_union_schema_round_trip_with_out_of_order_null() -> AvroResult field_union: UnionANoneB::A(A { field_a: 23.75 }), field_e: "barme".to_string(), }; - let output = encode_decode(&input, &schemata[2], &schemata)?; - assert_eq!(input, output); + assert_roundtrip(&input, &schemata[2], &schemata)?; let input = E { field_union: UnionANoneB::None, field_e: "barme2".to_string(), }; - let output = encode_decode(&input, &schemata[2], &schemata)?; - assert_eq!(input, output); + assert_roundtrip(&input, &schemata[2], &schemata)?; let input = E { field_union: UnionANoneB::B(B { field_b: 89 }), field_e: "barme3".to_string(), }; - let output = encode_decode(&input, &schemata[2], &schemata)?; - assert_eq!(input, output); + assert_roundtrip(&input, &schemata[2], &schemata)?; Ok(()) } @@ -230,7 +224,7 @@ struct F { } #[test] -fn test_avro_3901_union_schema_round_trip_with_end_null() -> AvroResult<()> { +fn test_avro_3901_union_schema_round_trip_with_end_null() -> TestResult { let schemata: Vec<Schema> = Schema::parse_list([SCHEMA_A_STR, SCHEMA_B_STR, SCHEMA_F_STR]).expect("parsing schemata"); @@ -238,22 +232,19 @@ fn test_avro_3901_union_schema_round_trip_with_end_null() -> AvroResult<()> { field_union: UnionABNone::A(A { field_a: 23.75 }), field_f: "aoe".to_string(), }; - let output = encode_decode(&input, &schemata[2], &schemata)?; - assert_eq!(input, output); + assert_roundtrip(&input, &schemata[2], &schemata)?; let input = F { field_union: UnionABNone::B(B { field_b: 89 }), field_f: "aoe3".to_string(), }; - let output = encode_decode(&input, &schemata[2], &schemata)?; - assert_eq!(input, output); + assert_roundtrip(&input, &schemata[2], &schemata)?; let input = F { field_union: UnionABNone::None, field_f: "aoee2".to_string(), }; - let output = encode_decode(&input, &schemata[2], &schemata)?; - assert_eq!(input, output); + assert_roundtrip(&input, &schemata[2], &schemata)?; Ok(()) } @@ -321,22 +312,20 @@ struct H { } #[test] -fn test_avro_3901_union_schema_as_optional() -> AvroResult<()> { +fn test_avro_3901_union_schema_as_optional() -> TestResult { let schemata: Vec<Schema> = Schema::parse_list([SCHEMA_H_STR]).expect("parsing schemata"); let input = H { field_union: Some(23), field_h: "aaa".to_string(), }; - let output = encode_decode(&input, &schemata[0], &schemata)?; - assert_eq!(input, output); + assert_roundtrip(&input, &schemata[0], &schemata)?; let input = H { field_union: None, field_h: "bbb".to_string(), }; - let output = encode_decode(&input, &schemata[0], &schemata)?; - assert_eq!(input, output); + assert_roundtrip(&input, &schemata[0], &schemata)?; Ok(()) } diff --git a/avro_derive/tests/derive.rs b/avro_derive/tests/derive.rs index 66d179e..b76163f 100644 --- a/avro_derive/tests/derive.rs +++ b/avro_derive/tests/derive.rs @@ -16,7 +16,7 @@ // under the License. use apache_avro::{ - AvroSchema, AvroSchemaComponent, Reader, Schema, Writer, from_value, + AvroSchema, AvroSchemaComponent, Schema, Writer, schema::{Alias, EnumSchema, FixedSchema, Name, RecordSchema}, }; use proptest::prelude::*; @@ -29,7 +29,9 @@ use std::{ }; use uuid::Uuid; +use apache_avro::reader::datum::GenericDatumReader; use apache_avro::schema::NamespaceRef; +use apache_avro::writer::datum::GenericDatumWriter; use pretty_assertions::assert_eq; /// Takes in a type that implements the right combination of traits and runs it through a Serde Cycle and asserts the result is the same @@ -55,11 +57,11 @@ where T: Serialize + AvroSchema, { let schema = T::get_schema(); - let mut writer = Writer::new(&schema, Vec::new()).unwrap(); - if let Err(e) = writer.append_ser(obj) { - panic!("{e:?}"); - } - writer.into_inner().unwrap() + GenericDatumWriter::builder(&schema) + .build() + .unwrap() + .write_ser_to_vec(&obj) + .unwrap() } #[track_caller] @@ -69,19 +71,11 @@ where { assert!(!encoded.is_empty()); let schema = T::get_schema(); - let mut reader = Reader::builder(&encoded[..]) - .reader_schema(&schema) + GenericDatumReader::builder(&schema) .build() - .unwrap(); - if let Some(res) = reader.next() { - match res { - Ok(value) => { - return from_value::<T>(&value).unwrap(); - } - Err(e) => panic!("{e:?}"), - } - } - unreachable!() + .unwrap() + .read_deser(&mut &encoded[..]) + .unwrap() } #[derive(Debug, Serialize, Deserialize, AvroSchema, Clone, PartialEq, Eq)] diff --git a/avro_derive/tests/serde.rs b/avro_derive/tests/serde.rs index 448d59f..a3574b2 100644 --- a/avro_derive/tests/serde.rs +++ b/avro_derive/tests/serde.rs @@ -15,7 +15,9 @@ // specific language governing permissions and limitations // under the License. -use apache_avro::{AvroSchema, Error, Reader, Schema, Writer, from_value}; +use apache_avro::reader::datum::GenericDatumReader; +use apache_avro::writer::datum::GenericDatumWriter; +use apache_avro::{AvroSchema, Error, Schema}; use serde::{Deserialize, Serialize, de::DeserializeOwned}; /// Takes in a type that implements the right combination of traits and runs it through a Serde @@ -51,9 +53,9 @@ where T: Serialize + AvroSchema, { let schema = T::get_schema(); - let mut writer = Writer::new(&schema, Vec::new())?; - writer.append_ser(obj)?; - writer.into_inner() + GenericDatumWriter::builder(&schema) + .build()? + .write_ser_to_vec(&obj) } fn de<T>(encoded: Vec<u8>) -> Result<T, Error> @@ -62,13 +64,9 @@ where { assert!(!encoded.is_empty()); let schema = T::get_schema(); - let mut reader = Reader::builder(&encoded[..]) - .reader_schema(&schema) - .build()?; - if let Some(res) = reader.next() { - return res.and_then(|v| from_value::<T>(&v)); - } - panic!("Nothing was encoded!") + GenericDatumReader::builder(&schema) + .build()? + .read_deser(&mut &encoded[..]) } mod container_attributes {
