You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@avro.apache.org by mg...@apache.org on 2022/04/18 19:57:19 UTC
[avro] branch avro-3492-derive-aliases-for-enum created (now 491bb626b)
This is an automated email from the ASF dual-hosted git repository.
mgrigorov pushed a change to branch avro-3492-derive-aliases-for-enum
in repository https://gitbox.apache.org/repos/asf/avro.git
at 491bb626b AVRO-3492: Add logic to derive the aliases for Schema::Enum
This branch includes the following new commits:
new 491bb626b AVRO-3492: Add logic to derive the aliases for Schema::Enum
The 1 revisions listed above as "new" are entirely new to this
repository and will be described in separate emails. The revisions
listed as "add" were already present in the repository and have only
been added to this reference.
[avro] 01/01: AVRO-3492: Add logic to derive the aliases for Schema::Enum
Posted by mg...@apache.org.
This is an automated email from the ASF dual-hosted git repository.
mgrigorov pushed a commit to branch avro-3492-derive-aliases-for-enum
in repository https://gitbox.apache.org/repos/asf/avro.git
commit 491bb626b0de75f38609e5b07eba53c13fb3aa44
Author: Martin Tzvetanov Grigorov <mg...@apache.org>
AuthorDate: Mon Apr 18 22:56:25 2022 +0300
AVRO-3492: Add logic to derive the aliases for Schema::Enum
Signed-off-by: Martin Tzvetanov Grigorov <mg...@apache.org>
---
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);
}
}