You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@avro.apache.org by mg...@apache.org on 2025/03/12 12:44:20 UTC
(avro-rs) branch rename-DirectSerializer-to-SchemaAwareWriteSerializer created (now ab5f059)
This is an automated email from the ASF dual-hosted git repository.
mgrigorov pushed a change to branch rename-DirectSerializer-to-SchemaAwareWriteSerializer
in repository https://gitbox.apache.org/repos/asf/avro-rs.git
at ab5f059 Issue #139: Rename DirectSerializer to SchemaAwareWriteSerializer
This branch includes the following new commits:
new ab5f059 Issue #139: Rename DirectSerializer to SchemaAwareWriteSerializer
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
(avro-rs) 01/01: Issue #139: Rename DirectSerializer to SchemaAwareWriteSerializer
Posted by mg...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
mgrigorov pushed a commit to branch rename-DirectSerializer-to-SchemaAwareWriteSerializer
in repository https://gitbox.apache.org/repos/asf/avro-rs.git
commit ab5f059c635ef2c6b225eccd2ac0d763d4bacdad
Author: Martin Tzvetanov Grigorov <mg...@apache.org>
AuthorDate: Wed Mar 12 14:43:01 2025 +0200
Issue #139: Rename DirectSerializer to SchemaAwareWriteSerializer
Deprecate the old Serializer impl (apache_avro::ser::Serializer)
Signed-off-by: Martin Tzvetanov Grigorov <mg...@apache.org>
---
avro/src/lib.rs | 2 +-
avro/src/ser.rs | 6 ++
avro/src/{ser_direct.rs => ser_schema.rs} | 107 +++++++++++++++---------------
avro/src/types.rs | 3 +
avro/src/writer.rs | 18 +++--
5 files changed, 75 insertions(+), 61 deletions(-)
diff --git a/avro/src/lib.rs b/avro/src/lib.rs
index f72a7cf..4b95bb5 100644
--- a/avro/src/lib.rs
+++ b/avro/src/lib.rs
@@ -869,7 +869,7 @@ mod encode;
mod error;
mod reader;
mod ser;
-mod ser_direct;
+mod ser_schema;
mod util;
mod writer;
diff --git a/avro/src/ser.rs b/avro/src/ser.rs
index 2d636fe..aae1353 100644
--- a/avro/src/ser.rs
+++ b/avro/src/ser.rs
@@ -15,6 +15,8 @@
// specific language governing permissions and limitations
// under the License.
+#![allow(deprecated)]
+
//! Logic for serde-compatible serialization.
use crate::{
bytes::{BytesType, SER_BYTES_TYPE},
@@ -24,6 +26,10 @@ use crate::{
use serde::{ser, Serialize};
use std::{collections::HashMap, iter::once};
+#[deprecated(
+ since = "0.18.0",
+ note = "Use `crate::ser_schema::SchemaAwareWriteSerializer` instead"
+)]
#[derive(Clone, Default)]
pub struct Serializer {}
diff --git a/avro/src/ser_direct.rs b/avro/src/ser_schema.rs
similarity index 95%
rename from avro/src/ser_direct.rs
rename to avro/src/ser_schema.rs
index ee4222e..4081629 100644
--- a/avro/src/ser_direct.rs
+++ b/avro/src/ser_schema.rs
@@ -18,29 +18,28 @@
//! Logic for serde-compatible schema-aware serialization
//! which writes directly to a `Write` stream
-use bigdecimal::BigDecimal;
-use serde::ser;
-use std::{borrow::Cow, collections::LinkedList, io::Write, str::FromStr};
-
use crate::{
bigdecimal::big_decimal_as_bytes,
encode::{encode_int, encode_long},
error::Error,
schema::{Name, NamesRef, Namespace, RecordSchema, Schema},
};
+use bigdecimal::BigDecimal;
+use serde::ser;
+use std::{borrow::Cow, collections::LinkedList, io::Write, str::FromStr};
const RECORD_FIELD_INIT_BUFFER_SIZE: usize = 64;
const COLLECTION_SERIALIZER_ITEM_LIMIT: usize = 1024;
const COLLECTION_SERIALIZER_DEFAULT_INIT_ITEM_CAPACITY: usize = 32;
const SINGLE_VALUE_INIT_BUFFER_SIZE: usize = 128;
-/// The sequence serializer for `DirectSerializer`. `DirectSerializeSeq` may break large arrays up
+/// The sequence serializer for `SchemaAwareWriteSerializer`. `DirectSerializeSeq` may break large arrays up
/// into multiple blocks to avoid having to obtain the length of the entire array before being able
/// to write any data to the underlying [`std::fmt::Write`] stream. (See the [Data Seralization and
/// Deserialization](https://avro.apache.org/docs/1.12.0/specification/#data-serialization-and-deserialization)
/// section of the Avro spec for more info.)
pub struct DirectSerializeSeq<'a, 's, W: Write> {
- ser: &'a mut DirectSerializer<'s, W>,
+ ser: &'a mut SchemaAwareWriteSerializer<'s, W>,
item_schema: &'s Schema,
item_buffer_size: usize,
item_buffers: Vec<Vec<u8>>,
@@ -49,7 +48,7 @@ pub struct DirectSerializeSeq<'a, 's, W: Write> {
impl<'a, 's, W: Write> DirectSerializeSeq<'a, 's, W> {
fn new(
- ser: &'a mut DirectSerializer<'s, W>,
+ ser: &'a mut SchemaAwareWriteSerializer<'s, W>,
item_schema: &'s Schema,
len: Option<usize>,
) -> DirectSerializeSeq<'a, 's, W> {
@@ -82,7 +81,7 @@ impl<'a, 's, W: Write> DirectSerializeSeq<'a, 's, W> {
fn serialize_element<T: ser::Serialize>(&mut self, value: &T) -> Result<(), Error> {
let mut item_buffer: Vec<u8> = Vec::with_capacity(self.item_buffer_size);
- let mut item_ser = DirectSerializer::new(
+ let mut item_ser = SchemaAwareWriteSerializer::new(
&mut item_buffer,
self.item_schema,
self.ser.names,
@@ -141,13 +140,13 @@ impl<W: Write> ser::SerializeTuple for DirectSerializeSeq<'_, '_, W> {
}
}
-/// The map serializer for `DirectSerializer`. `DirectSerializeMap` may break large maps up
+/// The map serializer for `SchemaAwareWriteSerializer`. `DirectSerializeMap` may break large maps up
/// into multiple blocks to avoid having to obtain the size of the entire map before being able
/// to write any data to the underlying [`std::fmt::Write`] stream. (See the [Data Seralization and
/// Deserialization](https://avro.apache.org/docs/1.12.0/specification/#data-serialization-and-deserialization)
/// section of the Avro spec for more info.)
pub struct DirectSerializeMap<'a, 's, W: Write> {
- ser: &'a mut DirectSerializer<'s, W>,
+ ser: &'a mut SchemaAwareWriteSerializer<'s, W>,
item_schema: &'s Schema,
item_buffer_size: usize,
item_buffers: Vec<Vec<u8>>,
@@ -156,7 +155,7 @@ pub struct DirectSerializeMap<'a, 's, W: Write> {
impl<'a, 's, W: Write> DirectSerializeMap<'a, 's, W> {
fn new(
- ser: &'a mut DirectSerializer<'s, W>,
+ ser: &'a mut SchemaAwareWriteSerializer<'s, W>,
item_schema: &'s Schema,
len: Option<usize>,
) -> DirectSerializeMap<'a, 's, W> {
@@ -198,7 +197,7 @@ impl<W: Write> ser::SerializeMap for DirectSerializeMap<'_, '_, W> {
{
let mut element_buffer: Vec<u8> = Vec::with_capacity(self.item_buffer_size);
let string_schema = Schema::String;
- let mut key_ser = DirectSerializer::new(
+ let mut key_ser = SchemaAwareWriteSerializer::new(
&mut element_buffer,
&string_schema,
self.ser.names,
@@ -217,7 +216,7 @@ impl<W: Write> ser::SerializeMap for DirectSerializeMap<'_, '_, W> {
{
let last_index = self.item_buffers.len() - 1;
let element_buffer = &mut self.item_buffers[last_index];
- let mut val_ser = DirectSerializer::new(
+ let mut val_ser = SchemaAwareWriteSerializer::new(
element_buffer,
self.item_schema,
self.ser.names,
@@ -242,11 +241,11 @@ impl<W: Write> ser::SerializeMap for DirectSerializeMap<'_, '_, W> {
}
}
-/// The struct serializer for `DirectSerializer`, which can serialize Avro records. `DirectSerializeStruct`
+/// The struct serializer for `SchemaAwareWriteSerializer`, which can serialize Avro records. `DirectSerializeStruct`
/// can accept fields out of order, but doing so incurs a performance penalty, since it requires
/// `DirectSerializeStruct` to buffer serialized values in order to write them to the stream in order.
pub struct DirectSerializeStruct<'a, 's, W: Write> {
- ser: &'a mut DirectSerializer<'s, W>,
+ ser: &'a mut SchemaAwareWriteSerializer<'s, W>,
record_schema: &'s RecordSchema,
item_count: usize,
buffered_fields: Vec<Option<Vec<u8>>>,
@@ -255,7 +254,7 @@ pub struct DirectSerializeStruct<'a, 's, W: Write> {
impl<'a, 's, W: Write> DirectSerializeStruct<'a, 's, W> {
fn new(
- ser: &'a mut DirectSerializer<'s, W>,
+ ser: &'a mut SchemaAwareWriteSerializer<'s, W>,
record_schema: &'s RecordSchema,
len: usize,
) -> DirectSerializeStruct<'a, 's, W> {
@@ -277,7 +276,7 @@ impl<'a, 's, W: Write> DirectSerializeStruct<'a, 's, W> {
);
// If we receive fields in order, write them directly to the main writer
- let mut value_ser = DirectSerializer::new(
+ let mut value_ser = SchemaAwareWriteSerializer::new(
&mut *self.ser.writer,
&next_field.schema,
self.ser.names,
@@ -357,7 +356,7 @@ impl<W: Write> ser::SerializeStruct for DirectSerializeStruct<'_, '_, W> {
if field_matches {
let mut buffer: Vec<u8> = Vec::with_capacity(RECORD_FIELD_INIT_BUFFER_SIZE);
- let mut value_ser = DirectSerializer::new(
+ let mut value_ser = SchemaAwareWriteSerializer::new(
&mut buffer,
&field.schema,
self.ser.names,
@@ -403,7 +402,7 @@ impl<W: Write> ser::SerializeStructVariant for DirectSerializeStruct<'_, '_, W>
}
}
-/// The tuple struct serializer for `DirectSerializer`. `DirectSerializeTupleStruct` can serialize to an Avro
+/// The tuple struct serializer for `SchemaAwareWriteSerializer`. `DirectSerializeTupleStruct` can serialize to an Avro
/// array, record, or big-decimal. When serializing to a record, fields must be provided in the correct order,
/// since no names are provided.
pub enum DirectSerializeTupleStruct<'a, 's, W: Write> {
@@ -465,11 +464,11 @@ impl<W: Write> ser::SerializeTupleVariant for DirectSerializeTupleStruct<'_, '_,
}
/// A `serde::se::Serializer` implementation that serializes directly to a [`std::fmt::Write`] using the provided
-/// schema. If `DirectSerializer` isn't able to match the incoming data with its schema, it will return an error.
+/// schema. If `SchemaAwareWriteSerializer` isn't able to match the incoming data with its schema, it will return an error.
///
-/// A `DirectSerializer` instance can be re-used to serialize multiple values matching the schema to its
+/// A `SchemaAwareWriteSerializer` instance can be re-used to serialize multiple values matching the schema to its
/// [`std::fmt::Write`] stream.
-pub struct DirectSerializer<'s, W: Write> {
+pub struct SchemaAwareWriteSerializer<'s, W: Write> {
writer: &'s mut W,
root_schema: &'s Schema,
names: &'s NamesRef<'s>,
@@ -477,8 +476,8 @@ pub struct DirectSerializer<'s, W: Write> {
schema_stack: LinkedList<&'s Schema>,
}
-impl<'s, W: Write> DirectSerializer<'s, W> {
- /// Create a new `DirectSerializer`.
+impl<'s, W: Write> SchemaAwareWriteSerializer<'s, W> {
+ /// Create a new `SchemaAwareWriteSerializer`.
///
/// `writer` is the [`std::fmt::Write`] stream to be written to.
///
@@ -492,8 +491,8 @@ impl<'s, W: Write> DirectSerializer<'s, W> {
schema: &'s Schema,
names: &'s NamesRef<'s>,
enclosing_namespace: Namespace,
- ) -> DirectSerializer<'s, W> {
- DirectSerializer {
+ ) -> SchemaAwareWriteSerializer<'s, W> {
+ SchemaAwareWriteSerializer {
writer,
root_schema: schema,
names,
@@ -526,7 +525,7 @@ impl<'s, W: Write> DirectSerializer<'s, W> {
}
}
-impl<'a, 's, W: Write> ser::Serializer for &'a mut DirectSerializer<'s, W> {
+impl<'a, 's, W: Write> ser::Serializer for &'a mut SchemaAwareWriteSerializer<'s, W> {
type Ok = usize;
type Error = Error;
type SerializeSeq = DirectSerializeSeq<'a, 's, W>;
@@ -1634,7 +1633,7 @@ mod tests {
let schema = Schema::Null;
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
().serialize(&mut serializer)?;
None::<()>.serialize(&mut serializer)?;
@@ -1653,7 +1652,7 @@ mod tests {
let schema = Schema::Boolean;
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
true.serialize(&mut serializer)?;
false.serialize(&mut serializer)?;
@@ -1670,7 +1669,7 @@ mod tests {
let schema = Schema::Int;
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
4u8.serialize(&mut serializer)?;
31u16.serialize(&mut serializer)?;
@@ -1691,7 +1690,7 @@ mod tests {
let schema = Schema::Long;
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
4u8.serialize(&mut serializer)?;
31u16.serialize(&mut serializer)?;
@@ -1717,7 +1716,7 @@ mod tests {
let schema = Schema::Float;
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
4.7f32.serialize(&mut serializer)?;
(-14.1f64).serialize(&mut serializer)?;
@@ -1734,7 +1733,7 @@ mod tests {
let schema = Schema::Float;
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
4.7f32.serialize(&mut serializer)?;
(-14.1f64).serialize(&mut serializer)?;
@@ -1751,7 +1750,7 @@ mod tests {
let schema = Schema::Bytes;
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
'a'.serialize(&mut serializer)?;
"test".serialize(&mut serializer)?;
@@ -1772,7 +1771,7 @@ mod tests {
let schema = Schema::String;
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
'a'.serialize(&mut serializer)?;
"test".serialize(&mut serializer)?;
@@ -1817,7 +1816,7 @@ mod tests {
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
let good_record = GoodTestRecord {
string_field: String::from("test"),
@@ -1851,7 +1850,7 @@ mod tests {
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
#[derive(Serialize)]
struct EmptyRecord;
@@ -1907,7 +1906,7 @@ mod tests {
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
Suit::Spades.serialize(&mut serializer)?;
Suit::Hearts.serialize(&mut serializer)?;
@@ -1942,7 +1941,7 @@ mod tests {
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
let arr: Vec<i64> = vec![10, 5, 400];
arr.serialize(&mut serializer)?;
@@ -1976,7 +1975,7 @@ mod tests {
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
let mut map: BTreeMap<String, i64> = BTreeMap::new();
map.insert(String::from("item1"), 10);
@@ -2026,7 +2025,7 @@ mod tests {
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
Some(10i64).serialize(&mut serializer)?;
None::<i64>.serialize(&mut serializer)?;
@@ -2071,7 +2070,7 @@ mod tests {
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
LongOrString::Null.serialize(&mut serializer)?;
LongOrString::Long(400).serialize(&mut serializer)?;
@@ -2113,7 +2112,7 @@ mod tests {
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
Bytes::new(&[10, 124, 31, 97, 14, 201, 3, 88]).serialize(&mut serializer)?;
@@ -2180,7 +2179,7 @@ mod tests {
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
let val = Decimal::from(&[251, 155]);
val.serialize(&mut serializer)?;
@@ -2218,7 +2217,7 @@ mod tests {
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
let val = Decimal::from(&[0, 0, 0, 0, 0, 0, 251, 155]);
val.serialize(&mut serializer)?;
@@ -2254,7 +2253,7 @@ mod tests {
crate::util::SERDE_HUMAN_READABLE.store(true, Ordering::Release);
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
let val = BigDecimal::new(BigInt::new(Sign::Plus, vec![50024]), 2);
val.serialize(&mut serializer)?;
@@ -2277,7 +2276,7 @@ mod tests {
crate::util::SERDE_HUMAN_READABLE.store(true, Ordering::Release);
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
"8c28da81-238c-4326-bddd-4e3d00cc5099"
.parse::<Uuid>()?
@@ -2319,7 +2318,7 @@ mod tests {
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
100_u8.serialize(&mut serializer)?;
1000_u16.serialize(&mut serializer)?;
@@ -2359,7 +2358,7 @@ mod tests {
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
100_u8.serialize(&mut serializer)?;
1000_u16.serialize(&mut serializer)?;
@@ -2399,7 +2398,7 @@ mod tests {
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
100_u8.serialize(&mut serializer)?;
1000_u16.serialize(&mut serializer)?;
@@ -2441,7 +2440,8 @@ mod tests {
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer =
+ SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
100_u8.serialize(&mut serializer)?;
1000_u16.serialize(&mut serializer)?;
@@ -2495,7 +2495,7 @@ mod tests {
let mut buffer: Vec<u8> = Vec::new();
let names = HashMap::new();
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer, &schema, &names, None);
let duration_bytes =
ByteArray::new(Duration::new(Months::new(3), Days::new(2), Millis::new(1200)).into());
@@ -2553,7 +2553,8 @@ mod tests {
crate::util::SERDE_HUMAN_READABLE.store(true, Ordering::Release);
let mut buffer: Vec<u8> = Vec::new();
let rs = ResolvedSchema::try_from(&schema)?;
- let mut serializer = DirectSerializer::new(&mut buffer, &schema, rs.get_names(), None);
+ let mut serializer =
+ SchemaAwareWriteSerializer::new(&mut buffer, &schema, rs.get_names(), None);
let good_record = TestRecord {
string_field: String::from("test"),
diff --git a/avro/src/types.rs b/avro/src/types.rs
index d5fa174..1741e31 100644
--- a/avro/src/types.rs
+++ b/avro/src/types.rs
@@ -2687,6 +2687,7 @@ Field with name '"b"' is not a member of the map items"#,
Ok(())
}
+ #[allow(deprecated)]
#[test]
fn test_avro_3460_validation_with_refs_real_struct() -> TestResult {
use crate::ser::Serializer;
@@ -2777,6 +2778,7 @@ Field with name '"b"' is not a member of the map items"#,
Ok(())
}
+ #[allow(deprecated)]
fn avro_3674_with_or_without_namespace(with_namespace: bool) -> TestResult {
use crate::ser::Serializer;
use serde::Serialize;
@@ -2870,6 +2872,7 @@ Field with name '"b"' is not a member of the map items"#,
avro_3674_with_or_without_namespace(true)
}
+ #[allow(deprecated)]
fn avro_3688_schema_resolution_panic(set_field_b: bool) -> TestResult {
use crate::ser::Serializer;
use serde::{Deserialize, Serialize};
diff --git a/avro/src/writer.rs b/avro/src/writer.rs
index 898c432..1ff1339 100644
--- a/avro/src/writer.rs
+++ b/avro/src/writer.rs
@@ -20,7 +20,7 @@ use crate::{
encode::{encode, encode_internal, encode_to_vec},
rabin::Rabin,
schema::{AvroSchema, Name, ResolvedOwnedSchema, ResolvedSchema, Schema},
- ser_direct::DirectSerializer,
+ ser_schema::SchemaAwareWriteSerializer,
types::Value,
AvroResult, Codec, Error,
};
@@ -202,8 +202,12 @@ impl<'a, W: Write> Writer<'a, W> {
match self.resolved_schema {
Some(ref rs) => {
- let mut serializer =
- DirectSerializer::new(&mut self.buffer, self.schema, rs.get_names(), None);
+ let mut serializer = SchemaAwareWriteSerializer::new(
+ &mut self.buffer,
+ self.schema,
+ rs.get_names(),
+ None,
+ );
value.serialize(&mut serializer)?;
self.num_values += 1;
@@ -442,16 +446,16 @@ impl<'a, W: Write> Writer<'a, W> {
///
/// This is an internal function which gets the bytes buffer where to write as parameter instead of
/// creating a new one like `to_avro_datum`.
-fn write_avro_datum<T: Into<Value>>(
+fn write_avro_datum<T: Into<Value>, W: Write>(
schema: &Schema,
value: T,
- buffer: &mut Vec<u8>,
+ writer: &mut W,
) -> Result<(), Error> {
let avro = value.into();
if !avro.validate(schema) {
return Err(Error::Validation);
}
- encode(&avro, schema, buffer)?;
+ encode(&avro, schema, writer)?;
Ok(())
}
@@ -580,7 +584,7 @@ where
}
let names: HashMap<Name, &Schema> = HashMap::new();
- let mut serializer = DirectSerializer::new(writer, &self.schema, &names, None);
+ let mut serializer = SchemaAwareWriteSerializer::new(writer, &self.schema, &names, None);
bytes_written += data.serialize(&mut serializer)?;
Ok(bytes_written)