499: feat: Replace to_datum* functions with GenericDatumWriter

avro/benches/single.rs

@@ -15,12 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use apache_avro::writer::datum::GenericDatumWriter;
 use apache_avro::{
     schema::Schema,
-    to_avro_datum,
     types::{Record, Value},
 };
 use criterion::{Criterion, criterion_group, criterion_main};
+use std::time::Duration;
 
 const RAW_SMALL_SCHEMA: &str = r#"
 {
@@ -174,20 +175,74 @@ fn make_big_record() -> Result<(Schema, Value), Box<dyn std::error::Error>> {
 fn bench_small_schema_write_record(c: &mut Criterion) {
     let (schema, record) = make_small_record().unwrap();
     c.bench_function("small record", |b| {
-        b.iter(|| to_avro_datum(&schema, record.clone()))
+        b.iter(|| {
+            GenericDatumWriter::builder(&schema)
+                .build()
+                .unwrap()
+                .write_value_to_vec(record.clone())
+        })
     });
 }
 
 fn bench_big_schema_write_record(c: &mut Criterion) {
     let (schema, record) = make_big_record().unwrap();
     c.bench_function("big record", |b| {
-        b.iter(|| to_avro_datum(&schema, record.clone()))
+        b.iter(|| {
+            GenericDatumWriter::builder(&schema)
+                .build()
+                .unwrap()
+                .write_value_to_vec(record.clone())
+        })
+    });
+}
+
+fn bench_small_schema_write_record_reuse_datum_writer(c: &mut Criterion) {
+    let (schema, record) = make_small_record().unwrap();
+    let writer = GenericDatumWriter::builder(&schema).build().unwrap();
+    c.bench_function("small record (reused writer)", |b| {
+        b.iter(|| writer.write_value_ref(&mut Vec::new(), &record))
+    });
+}
+
+fn bench_big_schema_write_record_reuse_datum_writer(c: &mut Criterion) {
+    let (schema, record) = make_big_record().unwrap();
+    let writer = GenericDatumWriter::builder(&schema).build().unwrap();
+    c.bench_function("big record (reused writer)", |b| {
+        b.iter(|| writer.write_value_ref(&mut Vec::new(), &record))
+    });
+}
+
+fn bench_small_schema_write_record_no_validation(c: &mut Criterion) {
+    let (schema, record) = make_small_record().unwrap();
+    let writer = GenericDatumWriter::builder(&schema)
+        .validate(false)
+        .build()
+        .unwrap();
+    c.bench_function("small record (no validation)", |b| {
+        b.iter(|| writer.write_value_ref(&mut Vec::new(), &record))
+    });
+}
+
+fn bench_big_schema_write_record_no_validation(c: &mut Criterion) {
+    let (schema, record) = make_big_record().unwrap();
+    let writer = GenericDatumWriter::builder(&schema)
+        .validate(false)
+        .build()
+        .unwrap();
+    c.bench_function("big record (no validation)", |b| {
+        b.iter(|| writer.write_value_ref(&mut Vec::new(), &record))
     });
 }
 
 criterion_group!(
-    benches,
-    bench_small_schema_write_record,
-    bench_big_schema_write_record
+    name = benches;
+    config = Criterion::default().sample_size(200).measurement_time(Duration::from_secs(10));
+    targets =
+        bench_small_schema_write_record,
+        bench_big_schema_write_record,
+        bench_small_schema_write_record_reuse_datum_writer,
+        bench_big_schema_write_record_reuse_datum_writer,
+        bench_small_schema_write_record_no_validation,
+        bench_big_schema_write_record_no_validation,
 );
 criterion_main!(benches);

avro/src/lib.rs

@@ -57,7 +57,6 @@ mod decode;
 mod duration;
 mod encode;
 mod reader;
-mod writer;
 
 #[cfg(doc)]
 pub mod documentation;
@@ -71,6 +70,7 @@ pub mod serde;
 pub mod types;
 pub mod util;
 pub mod validator;
+pub mod writer;
 
 #[expect(deprecated)]
 pub use crate::{
@@ -98,6 +98,10 @@ pub use reader::{
 pub use schema::Schema;
 pub use serde::{AvroSchema, AvroSchemaComponent, from_value, to_value};
 pub use uuid::Uuid;
+#[expect(
+    deprecated,
+    reason = "Still need to export it until we remove it completely"
+)]
 pub use writer::{
     Clearable, Writer, WriterBuilder,
     datum::{to_avro_datum, to_avro_datum_schemata, write_avro_datum_ref},

avro/src/schema/mod.rs

@@ -1168,6 +1168,7 @@ fn field_ordering_position(field: &str) -> Option<usize> {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::writer::datum::GenericDatumWriter;
     use crate::{error::Details, rabin::Rabin};
     use apache_avro_test_helper::{
         TestResult,
@@ -2992,7 +2993,9 @@ mod tests {
             avro_value.validate(&writer_schema),
             "value is valid for schema",
         );
-        let datum = crate::to_avro_datum(&writer_schema, avro_value)?;
+        let datum = GenericDatumWriter::builder(&writer_schema)
+            .build()?
+            .write_value_to_vec(avro_value)?;
         let mut x = &datum[..];
         let reader_schema = Schema::parse_str(reader_schema)?;
         let deser_value = crate::from_avro_datum(&writer_schema, &mut x, Some(&reader_schema))?;
@@ -3573,7 +3576,9 @@ mod tests {
             avro_value.validate(&writer_schema),
             "value is valid for schema",
         );
-        let datum = crate::to_avro_datum(&writer_schema, avro_value)?;
+        let datum = GenericDatumWriter::builder(&writer_schema)
+            .build()?
+            .write_value_to_vec(avro_value)?;
 
         // Now, attempt to deserialize using the reader schema.
         let reader_schema = Schema::parse(&reader_schema)?;

avro/src/serde/de.rs

@@ -954,6 +954,7 @@ mod tests {
 
     use super::*;
     use crate::Decimal;
+    use crate::writer::datum::GenericDatumWriter;
 
     #[derive(PartialEq, Eq, Serialize, Deserialize, Debug)]
     pub struct StringEnum {
@@ -989,7 +990,11 @@ mod tests {
         // encode into avro
         let value = crate::to_value(&data)?;
 
-        let mut buf = std::io::Cursor::new(crate::to_avro_datum(&schema, value)?);
+        let mut buf = std::io::Cursor::new(
+            GenericDatumWriter::builder(&schema)
+                .build()?
+                .write_value_to_vec(value)?,
+        );
 
         // decode from avro
         let value = crate::from_avro_datum(&schema, &mut buf, None)?;
@@ -1031,7 +1036,9 @@ mod tests {
         let value = crate::to_value(data)?;
 
         // The following sentence have to fail has the data is wrong.
-        let encoded_data = crate::to_avro_datum(&schema, value);
+        let encoded_data = GenericDatumWriter::builder(&schema)
+            .build()?
+            .write_value_to_vec(value);
 
         assert!(encoded_data.is_err());