This is an automated email from the ASF dual-hosted git repository.
mgrigorov pushed a commit to branch branch-1.11
in repository https://gitbox.apache.org/repos/asf/avro.git
The following commit(s) were added to refs/heads/branch-1.11 by this push:
new 67f6a4cdf AVRO-3492: Add logic to derive the aliases for Schema::Enum
(#1649)
67f6a4cdf is described below
commit 67f6a4cdf19579dcf3e87de89e5164efdff4343b
Author: Martin Grigorov <[email protected]>
AuthorDate: Tue Apr 19 00:06:13 2022 +0300
AVRO-3492: Add logic to derive the aliases for Schema::Enum (#1649)
Signed-off-by: Martin Tzvetanov Grigorov <[email protected]>
(cherry picked from commit e4521514c76a3b501612f376c9e6db356e28836d)
---
lang/rust/avro_derive/src/lib.rs | 5 +-
lang/rust/avro_derive/tests/derive.rs | 104 ++++++++++++++++++++++++++++------
2 files changed, 92 insertions(+), 17 deletions(-)
diff --git a/lang/rust/avro_derive/src/lib.rs b/lang/rust/avro_derive/src/lib.rs
index 11ab7a616..0055249cb 100644
--- a/lang/rust/avro_derive/src/lib.rs
+++ b/lang/rust/avro_derive/src/lib.rs
@@ -75,6 +75,7 @@ fn derive_avro_schema(input: &mut DeriveInput) ->
Result<TokenStream, Vec<syn::E
named_type_options
.doc
.or_else(|| extract_outer_doc(&input.attrs)),
+ named_type_options.alias,
e,
input.ident.span(),
)?,
@@ -168,10 +169,12 @@ fn get_data_struct_schema_def(
fn get_data_enum_schema_def(
full_schema_name: &str,
doc: Option<String>,
+ aliases: Vec<String>,
e: &syn::DataEnum,
error_span: Span,
) -> Result<TokenStream, Vec<syn::Error>> {
let doc = preserve_optional(doc);
+ let enum_aliases = preserve_vec(aliases);
if e.variants.iter().all(|v| syn::Fields::Unit == v.fields) {
let symbols: Vec<String> = e
.variants
@@ -181,7 +184,7 @@ fn get_data_enum_schema_def(
Ok(quote! {
apache_avro::schema::Schema::Enum {
name:
apache_avro::schema::Name::new(#full_schema_name).expect(&format!("Unable to
parse enum name for schema {}", #full_schema_name)[..]),
- aliases: None,
+ aliases: #enum_aliases,
doc: #doc,
symbols: vec![#(#symbols.to_owned()),*]
}
diff --git a/lang/rust/avro_derive/tests/derive.rs
b/lang/rust/avro_derive/tests/derive.rs
index c058c44c1..284323a2a 100644
--- a/lang/rust/avro_derive/tests/derive.rs
+++ b/lang/rust/avro_derive/tests/derive.rs
@@ -1066,16 +1066,16 @@ mod test_derive {
#[derive(Debug, Serialize, Deserialize, AvroSchema, Clone, PartialEq)]
#[avro(alias = "a", alias = "b", alias = "c")]
- struct TestBasicWithAliases {
+ struct TestBasicStructWithAliases {
a: i32,
}
#[test]
- fn test_basic_with_aliases() {
+ fn test_basic_struct_with_aliases() {
let schema = r#"
{
"type":"record",
- "name":"TestBasicWithAliases",
+ "name":"TestBasicStructWithAliases",
"aliases":["a", "b", "c"],
"fields":[
{
@@ -1086,34 +1086,34 @@ mod test_derive {
}
"#;
let schema = Schema::parse_str(schema).unwrap();
- if let Schema::Record { name, aliases, .. } =
TestBasicWithAliases::get_schema() {
- assert_eq!("TestBasicWithAliases", name.fullname(None));
+ if let Schema::Record { name, aliases, .. } =
TestBasicStructWithAliases::get_schema() {
+ assert_eq!("TestBasicStructWithAliases", name.fullname(None));
assert_eq!(
Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]),
aliases
);
} else {
- panic!("TestBasicWithAliases schema must be a record schema")
+ panic!("TestBasicStructWithAliases schema must be a record schema")
}
- assert_eq!(schema, TestBasicWithAliases::get_schema());
+ assert_eq!(schema, TestBasicStructWithAliases::get_schema());
- serde_assert(TestBasicWithAliases { a: i32::MAX });
+ serde_assert(TestBasicStructWithAliases { a: i32::MAX });
}
#[derive(Debug, Serialize, Deserialize, AvroSchema, Clone, PartialEq)]
#[avro(alias = "d")]
#[avro(alias = "e")]
#[avro(alias = "f")]
- struct TestBasicWithAliases2 {
+ struct TestBasicStructWithAliases2 {
a: i32,
}
#[test]
- fn test_basic_with_aliases2() {
+ fn test_basic_struct_with_aliases2() {
let schema = r#"
{
"type":"record",
- "name":"TestBasicWithAliases2",
+ "name":"TestBasicStructWithAliases2",
"aliases":["d", "e", "f"],
"fields":[
{
@@ -1124,17 +1124,89 @@ mod test_derive {
}
"#;
let schema = Schema::parse_str(schema).unwrap();
- if let Schema::Record { name, aliases, .. } =
TestBasicWithAliases2::get_schema() {
- assert_eq!("TestBasicWithAliases2", name.fullname(None));
+ if let Schema::Record { name, aliases, .. } =
TestBasicStructWithAliases2::get_schema() {
+ assert_eq!("TestBasicStructWithAliases2", name.fullname(None));
assert_eq!(
Some(vec!["d".to_owned(), "e".to_owned(), "f".to_owned()]),
aliases
);
} else {
- panic!("TestBasicWithAliases2 schema must be a record schema")
+ panic!("TestBasicStructWithAliases2 schema must be a record
schema")
}
- assert_eq!(schema, TestBasicWithAliases2::get_schema());
+ assert_eq!(schema, TestBasicStructWithAliases2::get_schema());
- serde_assert(TestBasicWithAliases2 { a: i32::MAX });
+ serde_assert(TestBasicStructWithAliases2 { a: i32::MAX });
+ }
+
+ #[derive(Debug, Serialize, Deserialize, AvroSchema, Clone, PartialEq)]
+ #[avro(alias = "a", alias = "b", alias = "c")]
+ enum TestBasicEnumWithAliases {
+ A,
+ B,
+ }
+
+ #[test]
+ fn test_basic_enum_with_aliases() {
+ let schema = r#"
+ {
+ "type":"enum",
+ "name":"TestBasicEnumWithAliases",
+ "aliases":["a", "b", "c"],
+ "symbols":[
+ "A",
+ "B"
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema).unwrap();
+ if let Schema::Enum { name, aliases, .. } =
TestBasicEnumWithAliases::get_schema() {
+ assert_eq!("TestBasicEnumWithAliases", name.fullname(None));
+ assert_eq!(
+ Some(vec!["a".to_owned(), "b".to_owned(), "c".to_owned()]),
+ aliases
+ );
+ } else {
+ panic!("TestBasicEnumWithAliases schema must be an enum schema")
+ }
+ assert_eq!(schema, TestBasicEnumWithAliases::get_schema());
+
+ serde_assert(TestBasicEnumWithAliases::A);
+ }
+
+ #[derive(Debug, Serialize, Deserialize, AvroSchema, Clone, PartialEq)]
+ #[avro(alias = "d")]
+ #[avro(alias = "e")]
+ #[avro(alias = "f")]
+ enum TestBasicEnumWithAliases2 {
+ A,
+ B,
+ }
+
+ #[test]
+ fn test_basic_enum_with_aliases2() {
+ let schema = r#"
+ {
+ "type":"enum",
+ "name":"TestBasicEnumWithAliases2",
+ "aliases":["d", "e", "f"],
+ "symbols":[
+ "A",
+ "B"
+ ]
+ }
+ "#;
+ let schema = Schema::parse_str(schema).unwrap();
+ if let Schema::Enum { name, aliases, .. } =
TestBasicEnumWithAliases2::get_schema() {
+ assert_eq!("TestBasicEnumWithAliases2", name.fullname(None));
+ assert_eq!(
+ Some(vec!["d".to_owned(), "e".to_owned(), "f".to_owned()]),
+ aliases
+ );
+ } else {
+ panic!("TestBasicEnumWithAliases2 schema must be an enum schema")
+ }
+ assert_eq!(schema, TestBasicEnumWithAliases2::get_schema());
+
+ serde_assert(TestBasicEnumWithAliases2::B);
}
}
