create table parsing - consolidate SqlOption::Union & SqlOption::TableEngine into SqlOption::NamedParenthesizedList

Author: tomershaniii

src/ast/mod.rs

@@ -7315,9 +7315,11 @@ pub enum SqlOption {
 
     TableSpace(TablespaceOption),
 
-    Union(Vec<Ident>),
-
-    TableEngine(TableEngine),
+    // Advanced parameter formations
+    // UNION  = (tbl_name[,tbl_name]...)
+    // ENGINE = ReplicatedMergeTree('/table_name','{replica}', ver)
+    // ENGINE = SummingMergeTree([columns])
+    NamedParenthesizedList(NamedParenthesizedList),
 }
 
 impl fmt::Display for SqlOption {
@@ -7357,18 +7359,7 @@ impl fmt::Display for SqlOption {
                     _ => Ok(()),
                 }
             }
-            SqlOption::Union(tables) => {
-                write!(
-                    f,
-                    "UNION = ({})",
-                    tables
-                        .iter()
-                        .map(|table| table.to_string())
-                        .collect::<Vec<String>>()
-                        .join(", ")
-                )
-            }
-            SqlOption::TableEngine(table_engine) => write!(f, "ENGINE = {}", table_engine),
+
             SqlOption::Comment(comment) => match comment {
                 CommentDef::WithEq(comment) => {
                     write!(f, "COMMENT = '{comment}'")
@@ -7377,6 +7368,16 @@ impl fmt::Display for SqlOption {
                     write!(f, "COMMENT '{comment}'")
                 }
             },
+            SqlOption::NamedParenthesizedList(value) => {
+                write!(f, "{} = ", value.key)?;
+                if let Some(key) = &value.value {
+                    write!(f, "{}", key)?;
+                }
+                if !value.parameters.is_empty() {
+                    write!(f, "({})", display_comma_separated(&value.parameters))?
+                }
+                Ok(())
+            }
         }
     }
 }
@@ -8616,27 +8617,13 @@ impl Display for CreateViewParams {
     }
 }
 
-/// Engine of DB. Some warehouse has parameters of engine, e.g. [clickhouse]
-///
-/// [clickhouse]: https://clickhouse.com/docs/en/engines/table-engines
 #[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
-pub struct TableEngine {
-    pub name: String,
-    pub parameters: Option<Vec<Ident>>,
-}
-
-impl Display for TableEngine {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{}", self.name)?;
-
-        if let Some(parameters) = self.parameters.as_ref() {
-            write!(f, "({})", display_comma_separated(parameters))?;
-        }
-
-        Ok(())
-    }
+pub struct NamedParenthesizedList {
+    pub key: Ident,
+    pub value: Option<Ident>,
+    pub parameters: Vec<Ident>,
 }
 
 /// Snowflake `WITH ROW ACCESS POLICY policy_name ON (identifier, ...)`

src/ast/spans.rs

@@ -30,13 +30,14 @@ use super::{
     FunctionArgumentClause, FunctionArgumentList, FunctionArguments, GroupByExpr, HavingBound,
     IfStatement, IlikeSelectItem, Insert, Interpolate, InterpolateExpr, Join, JoinConstraint,
     JoinOperator, JsonPath, JsonPathElem, LateralView, LimitClause, MatchRecognizePattern, Measure,
-    NamedWindowDefinition, ObjectName, ObjectNamePart, Offset, OnConflict, OnConflictAction,
-    OnInsert, OrderBy, OrderByExpr, OrderByKind, Partition, PivotValueSource, ProjectionSelect,
-    Query, RaiseStatement, RaiseStatementValue, ReferentialAction, RenameSelectItem,
-    ReplaceSelectElement, ReplaceSelectItem, Select, SelectInto, SelectItem, SetExpr, SqlOption,
-    Statement, Subscript, SymbolDefinition, TableAlias, TableAliasColumnDef, TableConstraint,
-    TableFactor, TableObject, TableOptionsClustered, TableWithJoins, UpdateTableFromKind, Use,
-    Value, Values, ViewColumnDef, WildcardAdditionalOptions, With, WithFill,
+    NamedParenthesizedList, NamedWindowDefinition, ObjectName, ObjectNamePart, Offset, OnConflict,
+    OnConflictAction, OnInsert, OrderBy, OrderByExpr, OrderByKind, Partition, PivotValueSource,
+    ProjectionSelect, Query, RaiseStatement, RaiseStatementValue, ReferentialAction,
+    RenameSelectItem, ReplaceSelectElement, ReplaceSelectItem, Select, SelectInto, SelectItem,
+    SetExpr, SqlOption, Statement, Subscript, SymbolDefinition, TableAlias, TableAliasColumnDef,
+    TableConstraint, TableFactor, TableObject, TableOptionsClustered, TableWithJoins,
+    UpdateTableFromKind, Use, Value, Values, ViewColumnDef, WildcardAdditionalOptions, With,
+    WithFill,
 };
 
 /// Given an iterator of spans, return the [Span::union] of all spans.
@@ -965,10 +966,14 @@ impl Spanned for SqlOption {
             } => union_spans(
                 core::iter::once(column_name.span).chain(for_values.iter().map(|i| i.span())),
             ),
-            SqlOption::Union(idents) => union_spans(idents.iter().map(|i| i.span)),
             SqlOption::TableSpace(_) => Span::empty(),
-            SqlOption::TableEngine(_) => Span::empty(),
             SqlOption::Comment(_) => Span::empty(),
+            SqlOption::NamedParenthesizedList(NamedParenthesizedList {
+                key: name,
+                value,
+                parameters: values,
+            }) => union_spans(core::iter::once(name.span).chain(values.iter().map(|i| i.span)))
+                .union_opt(&value.as_ref().map(|i| i.span)),
         }
     }
 }

src/parser/mod.rs

@@ -7082,15 +7082,18 @@ impl<'a> Parser<'a> {
             let engine = match value.token {
                 Token::Word(w) => {
                     let parameters = if self.peek_token() == Token::LParen {
-                        Some(self.parse_parenthesized_identifiers()?)
+                        self.parse_parenthesized_identifiers()?
                     } else {
-                        None
+                        vec![]
                     };
 
-                    Ok(Some(SqlOption::TableEngine(TableEngine {
-                        name: w.value,
-                        parameters,
-                    })))
+                    Ok(Some(SqlOption::NamedParenthesizedList(
+                        NamedParenthesizedList {
+                            key: Ident::new("ENGINE"),
+                            value: Some(Ident::new(w.value)),
+                            parameters,
+                        },
+                    )))
                 }
                 _ => {
                     return self.expected("Token::Word", value)?;
@@ -7148,7 +7151,13 @@ impl<'a> Parser<'a> {
                         self.parse_comma_separated0(Parser::parse_identifier, Token::RParen)?;
                     self.expect_token(&Token::RParen)?;
 
-                    return Ok(Some(SqlOption::Union(tables)));
+                    return Ok(Some(SqlOption::NamedParenthesizedList(
+                        NamedParenthesizedList {
+                            key: Ident::new("UNION"),
+                            value: None,
+                            parameters: tables,
+                        },
+                    )));
                 }
                 _ => {
                     return self.expected("Token::LParen", value)?;

tests/sqlparser_clickhouse.rs

@@ -748,13 +748,16 @@ fn parse_create_table_with_primary_key() {
                 _ => unreachable!(),
             };
 
-            assert!(plain_options.contains(&SqlOption::TableEngine(TableEngine {
-                name: "SharedMergeTree".to_owned(),
-                parameters: Some(vec![
-                    Ident::with_quote('\'', "/clickhouse/tables/{uuid}/{shard}"),
-                    Ident::with_quote('\'', "{replica}"),
-                ])
-            })));
+            assert!(plain_options.contains(&SqlOption::NamedParenthesizedList(
+                NamedParenthesizedList {
+                    key: Ident::new("ENGINE"),
+                    value: Some(Ident::new("SharedMergeTree")),
+                    parameters: vec![
+                        Ident::with_quote('\'', "/clickhouse/tables/{uuid}/{shard}"),
+                        Ident::with_quote('\'', "{replica}"),
+                    ]
+                }
+            )));
 
             fn assert_function(actual: &Function, name: &str, arg: &str) -> bool {
                 assert_eq!(actual.name, ObjectName::from(vec![Ident::new(name)]));

tests/sqlparser_mysql.rs

@@ -924,10 +924,14 @@ fn parse_create_table_multiple_options_order_independent() {
                     _ => unreachable!(),
                 };
 
-                assert!(plain_options.contains(&SqlOption::TableEngine(TableEngine {
-                    name: "InnoDB".to_owned(),
-                    parameters: None
-                })));
+                assert!(plain_options.contains(&SqlOption::NamedParenthesizedList(
+                    NamedParenthesizedList {
+                        key: Ident::new("ENGINE"),
+                        value: Some(Ident::new("InnoDB")),
+                        parameters: vec![]
+                    }
+                )));
+
                 assert!(plain_options.contains(&SqlOption::KeyValue {
                     key: Ident::new("KEY_BLOCK_SIZE"),
                     value: Expr::Value(
@@ -972,10 +976,14 @@ fn parse_create_table_with_all_table_options() {
                 _ => unreachable!(),
             };
 
-            assert!(plain_options.contains(&SqlOption::TableEngine(TableEngine {
-                name: "InnoDB".to_owned(),
-                parameters: None
-            })));
+            assert!(plain_options.contains(&SqlOption::NamedParenthesizedList(
+                NamedParenthesizedList {
+                    key: Ident::new("ENGINE"),
+                    value: Some(Ident::new("InnoDB")),
+                    parameters: vec![]
+                }
+            )));
+
             assert!(plain_options.contains(&SqlOption::KeyValue {
                 key: Ident::new("COLLATE"),
                 value: Expr::Identifier(Ident::new("utf8mb4_0900_ai_ci".to_owned()))
@@ -1109,11 +1117,19 @@ fn parse_create_table_with_all_table_options() {
                     storage: Some(StorageType::Disk),
                 }))
             );
-            assert!(plain_options.contains(&SqlOption::Union(vec![
-                Ident::new("table1".to_string()),
-                Ident::new("table2".to_string()),
-                Ident::new("table3".to_string())
-            ])));
+
+            assert!(plain_options.contains(&SqlOption::NamedParenthesizedList(
+                NamedParenthesizedList {
+                    key: Ident::new("UNION"),
+                    value: None,
+                    parameters: vec![
+                        Ident::new("table1".to_string()),
+                        Ident::new("table2".to_string()),
+                        Ident::new("table3".to_string())
+                    ]
+                }
+            )));
+
             assert!(plain_options.contains(&SqlOption::KeyValue {
                 key: Ident::new("DATA DIRECTORY"),
                 value: Expr::value(Value::SingleQuotedString("/var/lib/mysql/data".to_owned()))
@@ -1189,10 +1205,13 @@ fn parse_create_table_engine_default_charset() {
                 value: Expr::Identifier(Ident::new("utf8mb3".to_owned()))
             }));
 
-            assert!(plain_options.contains(&SqlOption::TableEngine(TableEngine {
-                name: "InnoDB".to_owned(),
-                parameters: None
-            })));
+            assert!(plain_options.contains(&SqlOption::NamedParenthesizedList(
+                NamedParenthesizedList {
+                    key: Ident::new("ENGINE"),
+                    value: Some(Ident::new("InnoDB")),
+                    parameters: vec![]
+                }
+            )));
         }
         _ => unreachable!(),
     }