You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@avro.apache.org by "sarutak (via GitHub)" <gi...@apache.org> on 2023/09/20 14:15:15 UTC

[GitHub] [avro] sarutak opened a new pull request, #2505: AVRO-3862: [Rust] Add aliases and doc methods to Schema in Rust SDK

sarutak opened a new pull request, #2505:
URL: https://github.com/apache/avro/pull/2505

   AVRO-3862
   
   ## What is the purpose of the change
   This PR proposes to add `fn aliases` and `fn doc` to `Schema`.
   
   Named types (Record, Enum and Fixed) have common attributes `name`, `aliases` and `doc`.
   We have already have `fn name` in Schema so it's nice to have `fn aliases` and `fn doc` too.
   
   ## Verifying this change
   Add new tests.
   
   ## Documentation
   
   - Does this pull request introduce a new feature? (no)


-- 
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: dev-unsubscribe@avro.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


[GitHub] [avro] martin-g merged pull request #2505: AVRO-3862: [Rust] Add aliases and doc methods to Schema in Rust SDK

Posted by "martin-g (via GitHub)" <gi...@apache.org>.
martin-g merged PR #2505:
URL: https://github.com/apache/avro/pull/2505


-- 
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: dev-unsubscribe@avro.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


[GitHub] [avro] martin-g commented on pull request #2505: AVRO-3862: [Rust] Add aliases and doc methods to Schema in Rust SDK

Posted by "martin-g (via GitHub)" <gi...@apache.org>.
martin-g commented on PR #2505:
URL: https://github.com/apache/avro/pull/2505#issuecomment-1729432814

   Thank you, @sarutak !


-- 
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: issues-unsubscribe@avro.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org


[GitHub] [avro] martin-g commented on a diff in pull request #2505: AVRO-3862: [Rust] Add aliases and doc methods to Schema in Rust SDK

Posted by "martin-g (via GitHub)" <gi...@apache.org>.
martin-g commented on code in PR #2505:
URL: https://github.com/apache/avro/pull/2505#discussion_r1332550531


##########
lang/rust/avro/src/schema.rs:
##########
@@ -5851,4 +5871,220 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_avro_3862_get_aliases() -> TestResult {
+        // Test for Record
+        let schema_str = r#"
+        {
+            "name": "record1",
+            "namespace": "ns1",
+            "type": "record",
+            "aliases": ["r1", "ns2.r2"],
+            "fields": [
+                { "name": "f1", "type": "int" },
+                { "name": "f2", "type": "string" }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = vec![Alias::new("ns1.r1")?, Alias::new("ns2.r2")?];
+        match schema.aliases() {
+            Some(s) => assert_eq!(s, &expected),

Review Comment:
   ```suggestion
               Some(aliases) => assert_eq!(aliases, &expected),
   ```



##########
lang/rust/avro/src/schema.rs:
##########
@@ -5851,4 +5871,220 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_avro_3862_get_aliases() -> TestResult {
+        // Test for Record
+        let schema_str = r#"
+        {
+            "name": "record1",
+            "namespace": "ns1",
+            "type": "record",
+            "aliases": ["r1", "ns2.r2"],
+            "fields": [
+                { "name": "f1", "type": "int" },
+                { "name": "f2", "type": "string" }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = vec![Alias::new("ns1.r1")?, Alias::new("ns2.r2")?];
+        match schema.aliases() {
+            Some(s) => assert_eq!(s, &expected),
+            None => panic!("Expected Some({:?}), got None", expected),
+        }
+
+        let schema_str = r#"
+        {
+            "name": "record1",
+            "namespace": "ns1",
+            "type": "record",
+            "fields": [
+                { "name": "f1", "type": "int" },
+                { "name": "f2", "type": "string" }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        match schema.aliases() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        // Test for Enum
+        let schema_str = r#"
+        {
+            "name": "enum1",
+            "namespace": "ns1",
+            "type": "enum",
+            "aliases": ["en1", "ns2.en2"],
+            "symbols": ["a", "b", "c"]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = vec![Alias::new("ns1.en1")?, Alias::new("ns2.en2")?];
+        match schema.aliases() {
+            Some(s) => assert_eq!(s, &expected),
+            None => panic!("Expected Some({:?}), got None", expected),
+        }
+
+        let schema_str = r#"
+        {
+            "name": "enum1",
+            "namespace": "ns1",
+            "type": "enum",
+            "symbols": ["a", "b", "c"]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        match schema.aliases() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        // Test for Fixed
+        let schema_str = r#"
+        {
+            "name": "fixed1",
+            "namespace": "ns1",
+            "type": "fixed",
+            "aliases": ["fx1", "ns2.fx2"],
+            "size": 10
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = vec![Alias::new("ns1.fx1")?, Alias::new("ns2.fx2")?];
+        match schema.aliases() {
+            Some(s) => assert_eq!(s, &expected),
+            None => panic!("Expected Some({:?}), got None", expected),
+        }
+
+        let schema_str = r#"
+        {
+            "name": "fixed1",
+            "namespace": "ns1",
+            "type": "fixed",
+            "size": 10
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        match schema.aliases() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        // Test for non-named type
+        let schema = Schema::Int;
+        match schema.aliases() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_avro_3862_get_doc() -> TestResult {
+        // Test for Record
+        let schema_str = r#"
+        {
+            "name": "record1",
+            "type": "record",
+            "doc": "Record Document",
+            "fields": [
+                { "name": "f1", "type": "int" },
+                { "name": "f2", "type": "string" }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = "Record Document";
+        match schema.doc() {
+            Some(s) => assert_eq!(s, expected),
+            None => panic!("Expected Some({:?}), got None", expected),
+        }
+
+        let schema_str = r#"
+        {
+            "name": "record1",
+            "type": "record",
+            "fields": [
+                { "name": "f1", "type": "int" },
+                { "name": "f2", "type": "string" }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        match schema.doc() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        // Test for Enum
+        let schema_str = r#"
+        {
+            "name": "enum1",
+            "type": "enum",
+            "doc": "Enum Document",
+            "symbols": ["a", "b", "c"]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = "Enum Document";
+        match schema.doc() {
+            Some(s) => assert_eq!(s, expected),

Review Comment:
   ```suggestion
               Some(aliases) => assert_eq!(aliases, expected),
   ```



##########
lang/rust/avro/src/schema.rs:
##########
@@ -5851,4 +5871,220 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_avro_3862_get_aliases() -> TestResult {
+        // Test for Record
+        let schema_str = r#"
+        {
+            "name": "record1",
+            "namespace": "ns1",
+            "type": "record",
+            "aliases": ["r1", "ns2.r2"],
+            "fields": [
+                { "name": "f1", "type": "int" },
+                { "name": "f2", "type": "string" }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = vec![Alias::new("ns1.r1")?, Alias::new("ns2.r2")?];
+        match schema.aliases() {
+            Some(s) => assert_eq!(s, &expected),
+            None => panic!("Expected Some({:?}), got None", expected),
+        }
+
+        let schema_str = r#"
+        {
+            "name": "record1",
+            "namespace": "ns1",
+            "type": "record",
+            "fields": [
+                { "name": "f1", "type": "int" },
+                { "name": "f2", "type": "string" }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        match schema.aliases() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        // Test for Enum
+        let schema_str = r#"
+        {
+            "name": "enum1",
+            "namespace": "ns1",
+            "type": "enum",
+            "aliases": ["en1", "ns2.en2"],
+            "symbols": ["a", "b", "c"]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = vec![Alias::new("ns1.en1")?, Alias::new("ns2.en2")?];
+        match schema.aliases() {
+            Some(s) => assert_eq!(s, &expected),
+            None => panic!("Expected Some({:?}), got None", expected),
+        }
+
+        let schema_str = r#"
+        {
+            "name": "enum1",
+            "namespace": "ns1",
+            "type": "enum",
+            "symbols": ["a", "b", "c"]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        match schema.aliases() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        // Test for Fixed
+        let schema_str = r#"
+        {
+            "name": "fixed1",
+            "namespace": "ns1",
+            "type": "fixed",
+            "aliases": ["fx1", "ns2.fx2"],
+            "size": 10
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = vec![Alias::new("ns1.fx1")?, Alias::new("ns2.fx2")?];
+        match schema.aliases() {
+            Some(s) => assert_eq!(s, &expected),
+            None => panic!("Expected Some({:?}), got None", expected),
+        }
+
+        let schema_str = r#"
+        {
+            "name": "fixed1",
+            "namespace": "ns1",
+            "type": "fixed",
+            "size": 10
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        match schema.aliases() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        // Test for non-named type
+        let schema = Schema::Int;
+        match schema.aliases() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_avro_3862_get_doc() -> TestResult {
+        // Test for Record
+        let schema_str = r#"
+        {
+            "name": "record1",
+            "type": "record",
+            "doc": "Record Document",
+            "fields": [
+                { "name": "f1", "type": "int" },
+                { "name": "f2", "type": "string" }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = "Record Document";
+        match schema.doc() {
+            Some(s) => assert_eq!(s, expected),
+            None => panic!("Expected Some({:?}), got None", expected),
+        }
+
+        let schema_str = r#"
+        {
+            "name": "record1",
+            "type": "record",
+            "fields": [
+                { "name": "f1", "type": "int" },
+                { "name": "f2", "type": "string" }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        match schema.doc() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        // Test for Enum
+        let schema_str = r#"
+        {
+            "name": "enum1",
+            "type": "enum",
+            "doc": "Enum Document",
+            "symbols": ["a", "b", "c"]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = "Enum Document";
+        match schema.doc() {
+            Some(s) => assert_eq!(s, expected),
+            None => panic!("Expected Some({:?}), got None", expected),
+        }
+
+        let schema_str = r#"
+        {
+            "name": "enum1",
+            "type": "enum",
+            "symbols": ["a", "b", "c"]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        match schema.doc() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        // Test for Fixed
+        let schema_str = r#"
+        {
+            "name": "fixed1",
+            "type": "fixed",
+            "doc": "Fixed Document",
+            "size": 10
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = "Fixed Document";
+        match schema.doc() {
+            Some(s) => assert_eq!(s, expected),

Review Comment:
   ```suggestion
               Some(aliases) => assert_eq!(aliases, expected),
   ```



##########
lang/rust/avro/src/schema.rs:
##########
@@ -5851,4 +5871,220 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_avro_3862_get_aliases() -> TestResult {
+        // Test for Record
+        let schema_str = r#"
+        {
+            "name": "record1",
+            "namespace": "ns1",
+            "type": "record",
+            "aliases": ["r1", "ns2.r2"],
+            "fields": [
+                { "name": "f1", "type": "int" },
+                { "name": "f2", "type": "string" }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = vec![Alias::new("ns1.r1")?, Alias::new("ns2.r2")?];
+        match schema.aliases() {
+            Some(s) => assert_eq!(s, &expected),
+            None => panic!("Expected Some({:?}), got None", expected),
+        }
+
+        let schema_str = r#"
+        {
+            "name": "record1",
+            "namespace": "ns1",
+            "type": "record",
+            "fields": [
+                { "name": "f1", "type": "int" },
+                { "name": "f2", "type": "string" }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        match schema.aliases() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        // Test for Enum
+        let schema_str = r#"
+        {
+            "name": "enum1",
+            "namespace": "ns1",
+            "type": "enum",
+            "aliases": ["en1", "ns2.en2"],
+            "symbols": ["a", "b", "c"]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = vec![Alias::new("ns1.en1")?, Alias::new("ns2.en2")?];
+        match schema.aliases() {
+            Some(s) => assert_eq!(s, &expected),
+            None => panic!("Expected Some({:?}), got None", expected),
+        }
+
+        let schema_str = r#"
+        {
+            "name": "enum1",
+            "namespace": "ns1",
+            "type": "enum",
+            "symbols": ["a", "b", "c"]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        match schema.aliases() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        // Test for Fixed
+        let schema_str = r#"
+        {
+            "name": "fixed1",
+            "namespace": "ns1",
+            "type": "fixed",
+            "aliases": ["fx1", "ns2.fx2"],
+            "size": 10
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = vec![Alias::new("ns1.fx1")?, Alias::new("ns2.fx2")?];
+        match schema.aliases() {
+            Some(s) => assert_eq!(s, &expected),

Review Comment:
   ```suggestion
               Some(aliases) => assert_eq!(aliases, &expected),
   ```



##########
lang/rust/avro/src/schema.rs:
##########
@@ -5851,4 +5871,220 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_avro_3862_get_aliases() -> TestResult {
+        // Test for Record
+        let schema_str = r#"
+        {
+            "name": "record1",
+            "namespace": "ns1",
+            "type": "record",
+            "aliases": ["r1", "ns2.r2"],
+            "fields": [
+                { "name": "f1", "type": "int" },
+                { "name": "f2", "type": "string" }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = vec![Alias::new("ns1.r1")?, Alias::new("ns2.r2")?];
+        match schema.aliases() {
+            Some(s) => assert_eq!(s, &expected),
+            None => panic!("Expected Some({:?}), got None", expected),
+        }
+
+        let schema_str = r#"
+        {
+            "name": "record1",
+            "namespace": "ns1",
+            "type": "record",
+            "fields": [
+                { "name": "f1", "type": "int" },
+                { "name": "f2", "type": "string" }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        match schema.aliases() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        // Test for Enum
+        let schema_str = r#"
+        {
+            "name": "enum1",
+            "namespace": "ns1",
+            "type": "enum",
+            "aliases": ["en1", "ns2.en2"],
+            "symbols": ["a", "b", "c"]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = vec![Alias::new("ns1.en1")?, Alias::new("ns2.en2")?];
+        match schema.aliases() {
+            Some(s) => assert_eq!(s, &expected),
+            None => panic!("Expected Some({:?}), got None", expected),
+        }
+
+        let schema_str = r#"
+        {
+            "name": "enum1",
+            "namespace": "ns1",
+            "type": "enum",
+            "symbols": ["a", "b", "c"]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        match schema.aliases() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        // Test for Fixed
+        let schema_str = r#"
+        {
+            "name": "fixed1",
+            "namespace": "ns1",
+            "type": "fixed",
+            "aliases": ["fx1", "ns2.fx2"],
+            "size": 10
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = vec![Alias::new("ns1.fx1")?, Alias::new("ns2.fx2")?];
+        match schema.aliases() {
+            Some(s) => assert_eq!(s, &expected),
+            None => panic!("Expected Some({:?}), got None", expected),
+        }
+
+        let schema_str = r#"
+        {
+            "name": "fixed1",
+            "namespace": "ns1",
+            "type": "fixed",
+            "size": 10
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        match schema.aliases() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        // Test for non-named type
+        let schema = Schema::Int;
+        match schema.aliases() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_avro_3862_get_doc() -> TestResult {
+        // Test for Record
+        let schema_str = r#"
+        {
+            "name": "record1",
+            "type": "record",
+            "doc": "Record Document",
+            "fields": [
+                { "name": "f1", "type": "int" },
+                { "name": "f2", "type": "string" }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = "Record Document";
+        match schema.doc() {
+            Some(s) => assert_eq!(s, expected),

Review Comment:
   ```suggestion
               Some(aliases) => assert_eq!(aliases, expected),
   ```



##########
lang/rust/avro/src/schema.rs:
##########
@@ -5851,4 +5871,220 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_avro_3862_get_aliases() -> TestResult {
+        // Test for Record
+        let schema_str = r#"
+        {
+            "name": "record1",
+            "namespace": "ns1",
+            "type": "record",
+            "aliases": ["r1", "ns2.r2"],
+            "fields": [
+                { "name": "f1", "type": "int" },
+                { "name": "f2", "type": "string" }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = vec![Alias::new("ns1.r1")?, Alias::new("ns2.r2")?];
+        match schema.aliases() {
+            Some(s) => assert_eq!(s, &expected),
+            None => panic!("Expected Some({:?}), got None", expected),
+        }
+
+        let schema_str = r#"
+        {
+            "name": "record1",
+            "namespace": "ns1",
+            "type": "record",
+            "fields": [
+                { "name": "f1", "type": "int" },
+                { "name": "f2", "type": "string" }
+            ]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        match schema.aliases() {
+            None => (),
+            some => panic!("Expected None, got {some:?}"),
+        }
+
+        // Test for Enum
+        let schema_str = r#"
+        {
+            "name": "enum1",
+            "namespace": "ns1",
+            "type": "enum",
+            "aliases": ["en1", "ns2.en2"],
+            "symbols": ["a", "b", "c"]
+        }
+        "#;
+        let schema = Schema::parse_str(schema_str)?;
+        let expected = vec![Alias::new("ns1.en1")?, Alias::new("ns2.en2")?];
+        match schema.aliases() {
+            Some(s) => assert_eq!(s, &expected),

Review Comment:
   ```suggestion
               Some(aliases) => assert_eq!(aliases, &expected),
   ```



-- 
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: issues-unsubscribe@avro.apache.org

For queries about this service, please contact Infrastructure at:
users@infra.apache.org