martin-g commented on code in PR #414:
URL: https://github.com/apache/avro-rs/pull/414#discussion_r2704921308
##########
avro/src/serde/ser_schema.rs:
##########
@@ -783,6 +785,40 @@ impl<'s, W: Write> SchemaAwareWriteSerializer<'s, W> {
expected => Err(create_error(format!("Expected: {expected}. Got:
Int/Long"))),
}
}
+ fn serialize_i128_with_schema(&mut self, value: i128, schema: &Schema) ->
Result<usize, Error> {
+ let create_error = |cause: String| {
+ Error::new(Details::SerializeValueWithSchema {
+ value_type: "i128",
+ value: format!("{value}. Cause: {cause}"),
+ schema: schema.clone(),
+ })
+ };
+
+ match schema {
+ Schema::Fixed(fixed) if fixed.size == 16 && fixed.name.name ==
"i128" => {
+ self.writer
+ .write_all(&value.to_le_bytes())
+ .map_err(Details::WriteBytes)?;
+ Ok(8)
Review Comment:
```suggestion
Ok(16)
```
##########
avro/src/serde/de.rs:
##########
@@ -385,23 +386,45 @@ impl<'de> de::Deserializer<'de> for &Deserializer<'de> {
bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64
}
- fn deserialize_char<V>(self, _: V) -> Result<V::Value, Self::Error>
+ fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
- Err(de::Error::custom("avro does not support char"))
+ match self.input {
+ Value::String(s) => {
+ if s.chars().count() == 1 {
+ visitor.visit_char(s.chars().next().expect("There is
exactly one char"))
+ } else {
+ Err(de::Error::custom("Tried to deserialize char from
string, but string was longer than one char"))
Review Comment:
```suggestion
Err(de::Error::custom("Tried to deserialize char from
string, but the string was longer than one char: {s}"))
```
##########
avro/src/serde/de.rs:
##########
@@ -385,23 +386,45 @@ impl<'de> de::Deserializer<'de> for &Deserializer<'de> {
bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64
}
- fn deserialize_char<V>(self, _: V) -> Result<V::Value, Self::Error>
+ fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
- Err(de::Error::custom("avro does not support char"))
+ match self.input {
+ Value::String(s) => {
+ if s.chars().count() == 1 {
+ visitor.visit_char(s.chars().next().expect("There is
exactly one char"))
+ } else {
+ Err(de::Error::custom("Tried to deserialize char from
string, but string was longer than one char"))
+ }
+ }
+ Value::Bytes(bytes) => std::str::from_utf8(bytes)
+ .map_err(|e| de::Error::custom(e.to_string()))
+ .and_then(|s| {
+ if s.chars().count() == 1 {
+ visitor.visit_char(s.chars().next().expect("There is
exactly one char"))
+ } else {
+ Err(de::Error::custom("Tried to deserialize char from
bytes, but bytes was longer than one char"))
Review Comment:
```suggestion
Err(de::Error::custom("Tried to deserialize char
from a byte array, but the byte array was longer than one char: {}", s.len()))
```
##########
avro/src/serde/ser_schema.rs:
##########
@@ -3146,4 +3245,250 @@ mod tests {
);
Ok(())
}
+
+ #[test]
+ fn avro_rs_414_serialize_char_as_string() -> TestResult {
+ let schema = Schema::String;
+
+ let mut buffer: Vec<u8> = Vec::new();
+ let names = HashMap::new();
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer,
&schema, &names, None);
+
+ 'a'.serialize(&mut serializer)?;
+
+ assert_eq!(buffer.as_slice(), &[2, b'a']);
+
+ Ok(())
+ }
+
+ #[test]
+ fn avro_rs_414_serialize_char_as_bytes() -> TestResult {
+ let schema = Schema::Bytes;
+
+ let mut buffer: Vec<u8> = Vec::new();
+ let names = HashMap::new();
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer,
&schema, &names, None);
+
+ 'a'.serialize(&mut serializer)?;
+
+ assert_eq!(buffer.as_slice(), &[2, b'a']);
+
+ Ok(())
+ }
+
+ #[test]
+ fn avro_rs_414_serialize_char_as_fixed() -> TestResult {
+ let schema = Schema::Fixed(FixedSchema {
+ name: Name::new("char")?,
+ aliases: None,
+ doc: None,
+ size: 4,
+ default: None,
+ attributes: Default::default(),
+ });
+
+ let mut buffer: Vec<u8> = Vec::new();
+ let names = HashMap::new();
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer,
&schema, &names, None);
+
+ 'a'.serialize(&mut serializer)?;
+
+ assert_eq!(buffer.as_slice(), &[b'a', 0, 0, 0]);
+
+ Ok(())
+ }
+
+ #[test]
+ fn avro_rs_414_serialize_char_as_fixed_wrong_name() -> TestResult {
+ let schema = Schema::Fixed(FixedSchema {
+ name: Name::new("characters")?,
+ aliases: None,
+ doc: None,
+ size: 4,
+ default: None,
+ attributes: Default::default(),
+ });
+
+ let mut buffer: Vec<u8> = Vec::new();
+ let names = HashMap::new();
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer,
&schema, &names, None);
+
+ assert!(matches!(
+ 'a'.serialize(&mut serializer).unwrap_err().details(),
+ Details::SerializeValueWithSchema { .. }
+ ));
+
+ Ok(())
+ }
+
+ #[test]
+ fn avro_rs_414_serialize_char_as_fixed_wrong_size() -> TestResult {
+ let schema = Schema::Fixed(FixedSchema {
+ name: Name::new("char")?,
+ aliases: None,
+ doc: None,
+ size: 1,
+ default: None,
+ attributes: Default::default(),
+ });
+
+ let mut buffer: Vec<u8> = Vec::new();
+ let names = HashMap::new();
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer,
&schema, &names, None);
+
+ assert!(matches!(
+ 'a'.serialize(&mut serializer).unwrap_err().details(),
+ Details::SerializeValueWithSchema { .. }
+ ));
+
+ Ok(())
+ }
+
+ #[test]
+ fn avro_rs_414_serialize_i128_as_fixed() -> TestResult {
+ let schema = Schema::Fixed(FixedSchema {
+ name: Name::new("i128")?,
+ aliases: None,
+ doc: None,
+ size: 16,
+ default: None,
+ attributes: Default::default(),
+ });
+
+ let mut buffer: Vec<u8> = Vec::new();
+ let names = HashMap::new();
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer,
&schema, &names, None);
+
+ i128::MAX.serialize(&mut serializer)?;
+
+ assert_eq!(
+ buffer.as_slice(),
+ &[
+ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF,
+ 0xFF, 0x7F
+ ]
+ );
+
+ Ok(())
+ }
+
+ #[test]
+ fn avro_rs_414_serialize_i128_as_fixed_wrong_name() -> TestResult {
+ let schema = Schema::Fixed(FixedSchema {
+ name: Name::new("onehundredtwentyeight")?,
+ aliases: None,
+ doc: None,
+ size: 16,
+ default: None,
+ attributes: Default::default(),
+ });
+
+ let mut buffer: Vec<u8> = Vec::new();
+ let names = HashMap::new();
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer,
&schema, &names, None);
+
+ assert!(matches!(
+ i128::MAX.serialize(&mut serializer).unwrap_err().details(),
+ Details::SerializeValueWithSchema { .. }
+ ));
+
+ Ok(())
+ }
+
+ #[test]
+ fn avro_rs_414_serialize_i128_as_fixed_wrong_size() -> TestResult {
+ let schema = Schema::Fixed(FixedSchema {
+ name: Name::new("i128")?,
+ aliases: None,
+ doc: None,
+ size: 8,
+ default: None,
+ attributes: Default::default(),
+ });
+
+ let mut buffer: Vec<u8> = Vec::new();
+ let names = HashMap::new();
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer,
&schema, &names, None);
+
+ assert!(matches!(
+ i128::MAX.serialize(&mut serializer).unwrap_err().details(),
+ Details::SerializeValueWithSchema { .. }
+ ));
+
+ Ok(())
+ }
+
+ #[test]
+ fn avro_rs_414_serialize_u128_as_fixed() -> TestResult {
+ let schema = Schema::Fixed(FixedSchema {
+ name: Name::new("u128")?,
+ aliases: None,
+ doc: None,
+ size: 16,
+ default: None,
+ attributes: Default::default(),
+ });
+
+ let mut buffer: Vec<u8> = Vec::new();
+ let names = HashMap::new();
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer,
&schema, &names, None);
+
+ u128::MAX.serialize(&mut serializer)?;
Review Comment:
```suggestion
let bytes_written = u128::MAX.serialize(&mut serializer)?;
assert_eq!(bytes_written, 16);
```
##########
avro/src/serde/ser_schema.rs:
##########
@@ -3146,4 +3245,250 @@ mod tests {
);
Ok(())
}
+
+ #[test]
+ fn avro_rs_414_serialize_char_as_string() -> TestResult {
+ let schema = Schema::String;
+
+ let mut buffer: Vec<u8> = Vec::new();
+ let names = HashMap::new();
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer,
&schema, &names, None);
+
+ 'a'.serialize(&mut serializer)?;
Review Comment:
Let's also add a test with non-ASCII character (a character that is made
from more than 1 byte).
##########
avro/src/serde/ser_schema.rs:
##########
@@ -941,6 +987,40 @@ impl<'s, W: Write> SchemaAwareWriteSerializer<'s, W> {
expected => Err(create_error(format!("Expected {expected}. Got:
Int/Long"))),
}
}
+ fn serialize_u128_with_schema(&mut self, value: u128, schema: &Schema) ->
Result<usize, Error> {
+ let create_error = |cause: String| {
+ Error::new(Details::SerializeValueWithSchema {
+ value_type: "u128",
+ value: format!("{value}. Cause: {cause}"),
+ schema: schema.clone(),
+ })
+ };
+
+ match schema {
+ Schema::Fixed(fixed) if fixed.size == 16 && fixed.name.name ==
"u128" => {
+ self.writer
+ .write_all(&value.to_le_bytes())
+ .map_err(Details::WriteBytes)?;
+ Ok(8)
Review Comment:
```suggestion
Ok(16)
```
##########
avro/src/serde/ser_schema.rs:
##########
@@ -783,6 +785,40 @@ impl<'s, W: Write> SchemaAwareWriteSerializer<'s, W> {
expected => Err(create_error(format!("Expected: {expected}. Got:
Int/Long"))),
}
}
+ fn serialize_i128_with_schema(&mut self, value: i128, schema: &Schema) ->
Result<usize, Error> {
+ let create_error = |cause: String| {
+ Error::new(Details::SerializeValueWithSchema {
+ value_type: "i128",
+ value: format!("{value}. Cause: {cause}"),
+ schema: schema.clone(),
+ })
+ };
+
+ match schema {
+ Schema::Fixed(fixed) if fixed.size == 16 && fixed.name.name ==
"i128" => {
Review Comment:
What if the user application uses `#[serde(rename="my_name")]` for the field
?
##########
avro/src/serde/ser_schema.rs:
##########
@@ -3146,4 +3245,250 @@ mod tests {
);
Ok(())
}
+
+ #[test]
+ fn avro_rs_414_serialize_char_as_string() -> TestResult {
+ let schema = Schema::String;
+
+ let mut buffer: Vec<u8> = Vec::new();
+ let names = HashMap::new();
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer,
&schema, &names, None);
+
+ 'a'.serialize(&mut serializer)?;
+
+ assert_eq!(buffer.as_slice(), &[2, b'a']);
+
+ Ok(())
+ }
+
+ #[test]
+ fn avro_rs_414_serialize_char_as_bytes() -> TestResult {
+ let schema = Schema::Bytes;
+
+ let mut buffer: Vec<u8> = Vec::new();
+ let names = HashMap::new();
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer,
&schema, &names, None);
+
+ 'a'.serialize(&mut serializer)?;
+
+ assert_eq!(buffer.as_slice(), &[2, b'a']);
+
+ Ok(())
+ }
+
+ #[test]
+ fn avro_rs_414_serialize_char_as_fixed() -> TestResult {
+ let schema = Schema::Fixed(FixedSchema {
+ name: Name::new("char")?,
+ aliases: None,
+ doc: None,
+ size: 4,
+ default: None,
+ attributes: Default::default(),
+ });
+
+ let mut buffer: Vec<u8> = Vec::new();
+ let names = HashMap::new();
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer,
&schema, &names, None);
+
+ 'a'.serialize(&mut serializer)?;
+
+ assert_eq!(buffer.as_slice(), &[b'a', 0, 0, 0]);
+
+ Ok(())
+ }
+
+ #[test]
+ fn avro_rs_414_serialize_char_as_fixed_wrong_name() -> TestResult {
+ let schema = Schema::Fixed(FixedSchema {
+ name: Name::new("characters")?,
+ aliases: None,
+ doc: None,
+ size: 4,
+ default: None,
+ attributes: Default::default(),
+ });
+
+ let mut buffer: Vec<u8> = Vec::new();
+ let names = HashMap::new();
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer,
&schema, &names, None);
+
+ assert!(matches!(
+ 'a'.serialize(&mut serializer).unwrap_err().details(),
+ Details::SerializeValueWithSchema { .. }
+ ));
+
+ Ok(())
+ }
+
+ #[test]
+ fn avro_rs_414_serialize_char_as_fixed_wrong_size() -> TestResult {
+ let schema = Schema::Fixed(FixedSchema {
+ name: Name::new("char")?,
+ aliases: None,
+ doc: None,
+ size: 1,
+ default: None,
+ attributes: Default::default(),
+ });
+
+ let mut buffer: Vec<u8> = Vec::new();
+ let names = HashMap::new();
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer,
&schema, &names, None);
+
+ assert!(matches!(
+ 'a'.serialize(&mut serializer).unwrap_err().details(),
+ Details::SerializeValueWithSchema { .. }
+ ));
+
+ Ok(())
+ }
+
+ #[test]
+ fn avro_rs_414_serialize_i128_as_fixed() -> TestResult {
+ let schema = Schema::Fixed(FixedSchema {
+ name: Name::new("i128")?,
+ aliases: None,
+ doc: None,
+ size: 16,
+ default: None,
+ attributes: Default::default(),
+ });
+
+ let mut buffer: Vec<u8> = Vec::new();
+ let names = HashMap::new();
+ let mut serializer = SchemaAwareWriteSerializer::new(&mut buffer,
&schema, &names, None);
+
+ i128::MAX.serialize(&mut serializer)?;
Review Comment:
```suggestion
let bytes_written = i128::MAX.serialize(&mut serializer)?;
assert_eq!(bytes_written, 16);
```
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]
