Refactor eventhubs peer (#30)

* refactor eventhub peer

* lint 1

* remove another vec

* make it a list of configs

* format test

* fmt lint

Author: Amogh-Bharadwaj

src/ast/mod.rs

@@ -2372,11 +2372,10 @@ pub enum PeerType {
     Mongo,
     Snowflake,
     Postgres,
-    EventHub,
-    EventHubGroup,
     S3,
     SQLServer,
     Kafka,
+    Eventhubs,
 }
 
 impl fmt::Display for PeerType {
@@ -2386,11 +2385,10 @@ impl fmt::Display for PeerType {
             PeerType::Mongo => write!(f, "MONGO"),
             PeerType::Snowflake => write!(f, "SNOWFLAKE"),
             PeerType::Postgres => write!(f, "POSTGRES"),
-            PeerType::EventHub => write!(f, "EVENTHUB"),
-            PeerType::EventHubGroup => write!(f, "EVENTHUBGROUP"),
             PeerType::S3 => write!(f, "S3"),
             PeerType::SQLServer => write!(f, "SQLSERVER"),
             PeerType::Kafka => write!(f, "KAFKA"),
+            PeerType::Eventhubs => write!(f, "EVENTHUBS"),
         }
     }
 }

src/keywords.rs

@@ -254,8 +254,7 @@ define_keywords!(
     ERROR,
     ESCAPE,
     EVENT,
-    EVENTHUB,
-    EVENTHUBGROUP,
+    EVENTHUBS,
     EVERY,
     EXCEPT,
     EXCLUDE,

src/parser/mod.rs

@@ -8396,18 +8396,16 @@ impl<'a> Parser<'a> {
             Keyword::KAFKA,
             Keyword::S3,
             Keyword::SQLSERVER,
-            Keyword::EVENTHUB,
-            Keyword::EVENTHUBGROUP,
+            Keyword::EVENTHUBS,
         ]) {
             Some(Keyword::BIGQUERY) => Ok(PeerType::Bigquery),
             Some(Keyword::MONGO) => Ok(PeerType::Mongo),
             Some(Keyword::SNOWFLAKE) => Ok(PeerType::Snowflake),
             Some(Keyword::POSTGRES) => Ok(PeerType::Postgres),
             Some(Keyword::KAFKA) => Ok(PeerType::Kafka),
             Some(Keyword::S3) => Ok(PeerType::S3),
-            Some(Keyword::EVENTHUB) => Ok(PeerType::EventHub),
             Some(Keyword::SQLSERVER) => Ok(PeerType::SQLServer),
-            Some(Keyword::EVENTHUBGROUP) => Ok(PeerType::EventHubGroup),
+            Some(Keyword::EVENTHUBS) => Ok(PeerType::Eventhubs),
             other => {
                 let supported_peer_types = [
                     "BIGQUERY",
@@ -8417,8 +8415,7 @@ impl<'a> Parser<'a> {
                     "KAFKA",
                     "S3",
                     "SQLSERVER",
-                    "EVENTHUB",
-                    "EVENTHUBGROUP",
+                    "EVENTHUBS",
                 ];
                 let err = format!(
                     "expected peertype as one of {}, got {:#?}",

tests/sqlparser_mysql.rs

@@ -202,7 +202,7 @@ fn parse_show_extended_full() {
 fn parse_show_create() {
     let obj_name = ObjectName(vec![Ident::new("myident")]);
 
-    for obj_type in &vec![
+    for obj_type in &[
         ShowCreateObject::Table,
         ShowCreateObject::Trigger,
         ShowCreateObject::Event,

tests/sqlparser_postgres.rs

@@ -3415,22 +3415,59 @@ fn parse_create_single_mirror_no_options() {
 }
 
 #[test]
-fn parse_create_eventhub_group_peer() {
-    match pg()
-        .verified_stmt("CREATE PEER eventhub_group_1 FROM EVENTHUBGROUP WITH (customer_1 = true)")
-    {
+fn parse_create_eventhubs_peer() {
+    match pg().verified_stmt(
+        r#"CREATE PEER eventhubs_1 FROM EVENTHUBS WITH (eventhubs = '[
+                    {
+                        "subscription_id":"mysubscriptionid1",
+                        "resource_group":"my-resource-1",
+                        "namespace":"test-namespace-1",
+                        "location":"eastus",
+                        "partition_count":5,
+                        "message_retention_in_days":2
+                    },
+                    {
+                        "subscription_id":"mysubscriptionid2",
+                        "resource_group":"my-resource-2",
+                        "namespace":"test-namespace-2",
+                        "location":"eastus",
+                        "partition_count":5,
+                        "message_retention_in_days":2
+                    }
+                    ]')"#,
+    ) {
         Statement::CreatePeer {
             if_not_exists: _,
             peer_name: _,
             peer_type,
             with_options,
         } => {
-            assert_eq!(peer_type, PeerType::EventHubGroup);
+            assert_eq!(peer_type, PeerType::Eventhubs);
             assert_eq!(
                 with_options,
                 vec![SqlOption {
-                    name: Ident::new("customer_1"),
-                    value: sqlparser::ast::Value::Boolean(true)
+                    name: Ident::new("eventhubs"),
+                    value: Value::SingleQuotedString(
+                        r#"[
+                    {
+                        "subscription_id":"mysubscriptionid1",
+                        "resource_group":"my-resource-1",
+                        "namespace":"test-namespace-1",
+                        "location":"eastus",
+                        "partition_count":5,
+                        "message_retention_in_days":2
+                    },
+                    {
+                        "subscription_id":"mysubscriptionid2",
+                        "resource_group":"my-resource-2",
+                        "namespace":"test-namespace-2",
+                        "location":"eastus",
+                        "partition_count":5,
+                        "message_retention_in_days":2
+                    }
+                    ]"#
+                        .into(),
+                    )
                 }]
             );
         }

tests/sqlparser_snowflake.rs

@@ -1031,7 +1031,7 @@ fn test_snowflake_stage_object_names() {
         "@namespace.stage_name/path",
         "@~/path",
     ];
-    let mut allowed_object_names = vec![
+    let mut allowed_object_names = [
         ObjectName(vec![Ident::new("my_company"), Ident::new("emp_basic")]),
         ObjectName(vec![Ident::new("@namespace"), Ident::new("%table_name")]),
         ObjectName(vec![