Added number to string benches for json_writer (#7864)

# Which issue does this PR close?

- Closes: None

# Rationale for this change

It is suggested to merge benches before merging a speed optimization
(see #7819)

# What changes are included in this PR?

adding the following benches to convert the following type arrays to a
string

- i64
- i32
- f64
- f32
- i64, i32, f64, f32

# Are these changes tested?

I am not sure we are testing benches

# Are there any user-facing changes?

No

Author: abacef

arrow/benches/json_writer.rs

@@ -25,8 +25,9 @@ use arrow::util::bench_util::{
 use arrow::util::test_util::seedable_rng;
 use arrow_array::{Array, ListArray, RecordBatch, StructArray};
 use arrow_buffer::{BooleanBuffer, NullBuffer, OffsetBuffer};
-use arrow_json::LineDelimitedWriter;
+use arrow_json::{LineDelimitedWriter, ReaderBuilder};
 use rand::Rng;
+use serde::Serialize;
 use std::sync::Arc;
 
 const NUM_ROWS: usize = 65536;
@@ -181,6 +182,138 @@ fn bench_struct_list(c: &mut Criterion) {
     do_bench(c, "bench_struct_list", &batch)
 }
 
+fn do_number_to_string_bench<S: Serialize>(
+    name: &str,
+    c: &mut Criterion,
+    schema: Arc<Schema>,
+    rows: Vec<S>,
+) {
+    c.bench_function(name, |b| {
+        b.iter(|| {
+            let mut decoder = ReaderBuilder::new(schema.clone())
+                .with_coerce_primitive(true) // important for coercion
+                .build_decoder()
+                .expect("Failed to build decoder");
+
+            decoder.serialize(&rows).expect("Failed to serialize rows");
+
+            decoder
+                .flush()
+                .expect("Failed to flush")
+                .expect("No RecordBatch produced");
+        })
+    });
+}
+
+fn bench_i64_to_string(c: &mut Criterion) {
+    #[derive(Serialize)]
+    struct TestRow {
+        val: i64,
+    }
+
+    let schema = Arc::new(Schema::new(vec![Field::new("val", DataType::Utf8, false)]));
+
+    let a_bunch_of_numbers = create_primitive_array::<Int64Type>(NUM_ROWS, 0.0);
+
+    let rows: Vec<TestRow> = (0..NUM_ROWS)
+        .map(|i| TestRow {
+            val: a_bunch_of_numbers.value(i),
+        })
+        .collect();
+
+    do_number_to_string_bench("i64_to_string", c, schema, rows)
+}
+
+fn bench_i32_to_string(c: &mut Criterion) {
+    #[derive(Serialize)]
+    struct TestRow {
+        val: i32,
+    }
+
+    let schema = Arc::new(Schema::new(vec![Field::new("val", DataType::Utf8, false)]));
+
+    let a_bunch_of_numbers = create_primitive_array::<Int32Type>(NUM_ROWS, 0.0);
+
+    let rows: Vec<TestRow> = (0..NUM_ROWS)
+        .map(|i| TestRow {
+            val: a_bunch_of_numbers.value(i),
+        })
+        .collect();
+
+    do_number_to_string_bench("i32_to_string", c, schema, rows)
+}
+
+fn bench_f32_to_string(c: &mut Criterion) {
+    #[derive(Serialize)]
+    struct TestRow {
+        val: f32,
+    }
+
+    let schema = Arc::new(Schema::new(vec![Field::new("val", DataType::Utf8, false)]));
+
+    let a_bunch_of_numbers = create_primitive_array::<Float32Type>(NUM_ROWS, 0.0);
+
+    let rows: Vec<TestRow> = (0..NUM_ROWS)
+        .map(|i| TestRow {
+            val: a_bunch_of_numbers.value(i),
+        })
+        .collect();
+
+    do_number_to_string_bench("f32_to_string", c, schema, rows)
+}
+
+fn bench_f64_to_string(c: &mut Criterion) {
+    #[derive(Serialize)]
+    struct TestRow {
+        val: f64,
+    }
+
+    let schema = Arc::new(Schema::new(vec![Field::new("val", DataType::Utf8, false)]));
+
+    let a_bunch_of_numbers = create_primitive_array::<Float64Type>(NUM_ROWS, 0.0);
+
+    let rows: Vec<TestRow> = (0..NUM_ROWS)
+        .map(|i| TestRow {
+            val: a_bunch_of_numbers.value(i),
+        })
+        .collect();
+
+    do_number_to_string_bench("f64_to_string", c, schema, rows)
+}
+
+fn bench_mixed_numbers_to_string(c: &mut Criterion) {
+    #[derive(Serialize)]
+    struct TestRow {
+        val1: f64,
+        val2: f32,
+        val3: i64,
+        val4: i32,
+    }
+
+    let schema = Arc::new(Schema::new(vec![
+        Field::new("val1", DataType::Utf8, false),
+        Field::new("val2", DataType::Utf8, false),
+        Field::new("val3", DataType::Utf8, false),
+        Field::new("val4", DataType::Utf8, false),
+    ]));
+
+    let f64_array = create_primitive_array::<Float64Type>(NUM_ROWS, 0.0);
+    let f32_array = create_primitive_array::<Float32Type>(NUM_ROWS, 0.0);
+    let i64_array = create_primitive_array::<Int64Type>(NUM_ROWS, 0.0);
+    let i32_array = create_primitive_array::<Int32Type>(NUM_ROWS, 0.0);
+
+    let rows: Vec<TestRow> = (0..NUM_ROWS)
+        .map(|i| TestRow {
+            val1: f64_array.value(i),
+            val2: f32_array.value(i),
+            val3: i64_array.value(i),
+            val4: i32_array.value(i),
+        })
+        .collect();
+
+    do_number_to_string_bench("mixed_numbers_to_string", c, schema, rows)
+}
+
 fn criterion_benchmark(c: &mut Criterion) {
     bench_integer(c);
     bench_float(c);
@@ -192,6 +325,11 @@ fn criterion_benchmark(c: &mut Criterion) {
     bench_list(c);
     bench_nullable_list(c);
     bench_struct_list(c);
+    bench_f64_to_string(c);
+    bench_f32_to_string(c);
+    bench_i64_to_string(c);
+    bench_i32_to_string(c);
+    bench_mixed_numbers_to_string(c);
 }
 
 criterion_group!(benches, criterion_benchmark);