feat: encode FixedSizeBinary in JSON as hex

Adds encoding support to the JSON writer for the FixedSizeBinary DataType

A test was added as well

Author: hiltontj

arrow-json/Cargo.toml

@@ -56,6 +56,7 @@ tokio = { version = "1.27", default-features = false, features = ["io-util"] }
 bytes = "1.4"
 criterion = { version = "0.5", default-features = false }
 rand = { version = "0.8", default-features = false, features = ["std", "std_rng"] }
+hex = "0.4.3"
 
 [[bench]]
 name = "serde"

arrow-json/src/writer.rs

@@ -833,7 +833,9 @@ mod tests {
 
     use serde_json::json;
 
-    use arrow_array::builder::{Int32Builder, Int64Builder, MapBuilder, StringBuilder};
+    use arrow_array::builder::{
+        FixedSizeBinaryBuilder, Int32Builder, Int64Builder, MapBuilder, StringBuilder,
+    };
     use arrow_buffer::{Buffer, NullBuffer, OffsetBuffer, ToByteSlice};
     use arrow_data::ArrayData;
 
@@ -2137,4 +2139,32 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_writer_fixed_size_binary() {
+        let size = 32;
+        let schema = SchemaRef::new(Schema::new(vec![Field::new(
+            "bytes",
+            DataType::FixedSizeBinary(size),
+            false,
+        )]));
+
+        let mut builder = FixedSizeBinaryBuilder::new(size);
+        let v = hex::decode("a948904f2f0f479b8f8197694b30184b0d2ed1c1cd2a1ec0fb85d299a192a447")
+            .unwrap();
+        builder.append_value(v).unwrap();
+        let array = Arc::new(builder.finish()) as ArrayRef;
+        let batch = RecordBatch::try_new(schema, vec![array]).unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write(&batch).unwrap();
+        }
+
+        assert_eq!(
+            "{\"bytes\":a948904f2f0f479b8f8197694b30184b0d2ed1c1cd2a1ec0fb85d299a192a447}\n",
+            String::from_utf8(buf).unwrap()
+        );
+    }
 }

arrow-json/src/writer/encoder.rs

@@ -99,6 +99,11 @@ fn make_encoder_impl<'a>(
             (Box::new(MapEncoder::try_new(array, options)?) as _,  array.nulls().cloned())
         }
 
+        DataType::FixedSizeBinary(_) => {
+            let array = array.as_any().downcast_ref::<FixedSizeBinaryArray>().unwrap();
+            (Box::new(FixedSizeBinaryEncoder(array.clone())) as _, array.nulls().cloned())
+        }
+
         DataType::Struct(fields) => {
             let array = array.as_struct();
             let encoders = fields.iter().zip(array.columns()).map(|(field, array)| {
@@ -443,3 +448,15 @@ impl<'a> Encoder for MapEncoder<'a> {
         out.push(b'}');
     }
 }
+
+struct FixedSizeBinaryEncoder(FixedSizeBinaryArray);
+
+impl Encoder for FixedSizeBinaryEncoder {
+    fn encode(&mut self, idx: usize, out: &mut Vec<u8>) {
+        let v = self.0.value(idx);
+        for byte in v {
+            // this write is infallible
+            write!(out, "{byte:02x}").unwrap();
+        }
+    }
+}