create table parsing - comment parsing to generic parameter parsing

Author: tomershaniii

src/ast/dml.rs

@@ -160,7 +160,10 @@ pub struct CreateTable {
     pub without_rowid: bool,
     pub like: Option<ObjectName>,
     pub clone: Option<ObjectName>,
-    pub comment: Option<CommentDef>,
+    // For Hive dialect, the table comment is after the column definitions without `=`,
+    // so we need to add an extra variant to allow to identify this case when displaying.
+    // [Hive](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-CreateTable)
+    pub comment_after_column_def: Option<CommentDef>,
     pub on_commit: Option<OnCommit>,
     /// ClickHouse "ON CLUSTER" clause:
     /// <https://clickhouse.com/docs/en/sql-reference/distributed-ddl/>
@@ -276,7 +279,7 @@ impl Display for CreateTable {
 
         // Hive table comment should be after column definitions, please refer to:
         // [Hive](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-CreateTable)
-        if let Some(CommentDef::AfterColumnDefsWithoutEq(comment)) = &self.comment {
+        if let Some(comment) = &self.comment_after_column_def {
             write!(f, " COMMENT '{comment}'")?;
         }
 
@@ -384,19 +387,6 @@ impl Display for CreateTable {
             write!(f, " {}", display_separated(&self.plain_options, " "))?;
         }
 
-        if let Some(comment_def) = &self.comment {
-            match comment_def {
-                CommentDef::WithEq(comment) => {
-                    write!(f, " COMMENT = '{comment}'")?;
-                }
-                CommentDef::WithoutEq(comment) => {
-                    write!(f, " COMMENT '{comment}'")?;
-                }
-                // For CommentDef::AfterColumnDefsWithoutEq will be displayed after column definition
-                CommentDef::AfterColumnDefsWithoutEq(_) => (),
-            }
-        }
-
         if let Some(primary_key) = &self.primary_key {
             write!(f, " PRIMARY KEY {}", primary_key)?;
         }

src/ast/helpers/stmt_create_table.rs

@@ -87,7 +87,7 @@ pub struct CreateTableBuilder {
     pub without_rowid: bool,
     pub like: Option<ObjectName>,
     pub clone: Option<ObjectName>,
-    pub comment: Option<CommentDef>,
+    pub comment_after_column_def: Option<CommentDef>,
     pub on_commit: Option<OnCommit>,
     pub on_cluster: Option<Ident>,
     pub primary_key: Option<Box<Expr>>,
@@ -137,7 +137,7 @@ impl CreateTableBuilder {
             without_rowid: false,
             like: None,
             clone: None,
-            comment: None,
+            comment_after_column_def: None,
             on_commit: None,
             on_cluster: None,
             primary_key: None,
@@ -261,8 +261,8 @@ impl CreateTableBuilder {
         self
     }
 
-    pub fn comment(mut self, comment: Option<CommentDef>) -> Self {
-        self.comment = comment;
+    pub fn comment_after_column_def(mut self, comment: Option<CommentDef>) -> Self {
+        self.comment_after_column_def = comment;
         self
     }
 
@@ -418,7 +418,7 @@ impl CreateTableBuilder {
             without_rowid: self.without_rowid,
             like: self.like,
             clone: self.clone,
-            comment: self.comment,
+            comment_after_column_def: self.comment_after_column_def,
             on_commit: self.on_commit,
             on_cluster: self.on_cluster,
             primary_key: self.primary_key,
@@ -476,7 +476,7 @@ impl TryFrom<Statement> for CreateTableBuilder {
                 without_rowid,
                 like,
                 clone,
-                comment,
+                comment_after_column_def: comment,
                 on_commit,
                 on_cluster,
                 primary_key,
@@ -521,7 +521,7 @@ impl TryFrom<Statement> for CreateTableBuilder {
                 without_rowid,
                 like,
                 clone,
-                comment,
+                comment_after_column_def: comment,
                 on_commit,
                 on_cluster,
                 primary_key,

src/ast/mod.rs

@@ -7293,6 +7293,8 @@ pub enum SqlOption {
         for_values: Vec<Expr>,
     },
 
+    Comment(CommentDef),
+
     TableSpace(TablespaceOption),
 
     Union(Vec<Ident>),
@@ -7349,6 +7351,14 @@ impl fmt::Display for SqlOption {
                 )
             }
             SqlOption::TableEngine(table_engine) => write!(f, "ENGINE = {}", table_engine),
+            SqlOption::Comment(comment) => match comment {
+                CommentDef::WithEq(comment) => {
+                    write!(f, "COMMENT = '{comment}'")
+                }
+                CommentDef::WithoutEq(comment) => {
+                    write!(f, "COMMENT '{comment}'")
+                }
+            },
         }
     }
 }
@@ -8672,18 +8682,12 @@ pub enum CommentDef {
     /// Does not include `=` when printing the comment, as `COMMENT 'comment'`
     WithEq(String),
     WithoutEq(String),
-    // For Hive dialect, the table comment is after the column definitions without `=`,
-    // so we need to add an extra variant to allow to identify this case when displaying.
-    // [Hive](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-CreateTable)
-    AfterColumnDefsWithoutEq(String),
 }
 
 impl Display for CommentDef {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            CommentDef::WithEq(comment)
-            | CommentDef::WithoutEq(comment)
-            | CommentDef::AfterColumnDefsWithoutEq(comment) => write!(f, "{comment}"),
+            CommentDef::WithEq(comment) | CommentDef::WithoutEq(comment) => write!(f, "{comment}"),
         }
     }
 }

src/ast/spans.rs

@@ -566,7 +566,7 @@ impl Spanned for CreateTable {
             without_rowid: _, // bool
             like,
             clone,
-            comment: _, // todo, no span
+            comment_after_column_def: _, // todo, no span
             on_commit: _,
             on_cluster: _,                      // todo, clickhouse specific
             primary_key: _,                     // todo, clickhouse specific
@@ -973,6 +973,7 @@ impl Spanned for SqlOption {
             SqlOption::Union(idents) => union_spans(idents.iter().map(|i| i.span)),
             SqlOption::TableSpace(_) => Span::empty(),
             SqlOption::TableEngine(_) => Span::empty(),
+            SqlOption::Comment(_) => Span::empty(),
         }
     }
 }

src/dialect/snowflake.rs

@@ -25,8 +25,8 @@ use crate::ast::helpers::stmt_data_loading::{
 use crate::ast::{
     ColumnOption, ColumnPolicy, ColumnPolicyProperty, CopyIntoSnowflakeKind, Ident,
     IdentityParameters, IdentityProperty, IdentityPropertyFormatKind, IdentityPropertyKind,
-    IdentityPropertyOrder, ObjectName, RowAccessPolicy, ShowObjects, Statement, TagsColumnOption,
-    WrappedCollection,
+    IdentityPropertyOrder, ObjectName, RowAccessPolicy, ShowObjects, SqlOption, Statement,
+    TagsColumnOption, WrappedCollection,
 };
 use crate::dialect::{Dialect, Precedence};
 use crate::keywords::Keyword;
@@ -411,6 +411,8 @@ pub fn parse_create_table(
     // "CREATE TABLE x COPY GRANTS (c INT)" and "CREATE TABLE x (c INT) COPY GRANTS" are both
     // accepted by Snowflake
 
+    let mut plain_options = vec![];
+
     loop {
         let next_token = parser.next_token();
         match &next_token.token {
@@ -422,7 +424,9 @@ pub fn parse_create_table(
                 Keyword::COMMENT => {
                     // Rewind the COMMENT keyword
                     parser.prev_token();
-                    builder = builder.comment(parser.parse_optional_inline_comment()?);
+                    if let Some(comment_def) = parser.parse_optional_inline_comment()? {
+                        plain_options.push(SqlOption::Comment(comment_def))
+                    }
                 }
                 Keyword::AS => {
                     let query = parser.parse_query()?;
@@ -584,6 +588,8 @@ pub fn parse_create_table(
         }
     }
 
+    builder = builder.plain_options(plain_options);
+
     if iceberg && builder.base_location.is_none() {
         return Err(ParserError::ParserError(
             "BASE_LOCATION is required for ICEBERG tables".to_string(),

src/parser/mod.rs

@@ -6878,17 +6878,16 @@ impl<'a> Parser<'a> {
 
         // parse optional column list (schema)
         let (columns, constraints) = self.parse_columns()?;
-        let mut comment = if dialect_of!(self is HiveDialect)
-            && self.parse_keyword(Keyword::COMMENT)
-        {
-            let next_token = self.next_token();
-            match next_token.token {
-                Token::SingleQuotedString(str) => Some(CommentDef::AfterColumnDefsWithoutEq(str)),
-                _ => self.expected("comment", next_token)?,
-            }
-        } else {
-            None
-        };
+        let comment_after_column_def =
+            if dialect_of!(self is HiveDialect) && self.parse_keyword(Keyword::COMMENT) {
+                let next_token = self.next_token();
+                match next_token.token {
+                    Token::SingleQuotedString(str) => Some(CommentDef::WithoutEq(str)),
+                    _ => self.expected("comment", next_token)?,
+                }
+            } else {
+                None
+            };
 
         // SQLite supports `WITHOUT ROWID` at the end of `CREATE TABLE`
         let without_rowid = self.parse_keywords(&[Keyword::WITHOUT, Keyword::ROWID]);
@@ -6936,13 +6935,6 @@ impl<'a> Parser<'a> {
 
         let strict = self.parse_keyword(Keyword::STRICT);
 
-        // Excludes Hive dialect here since it has been handled after table column definitions.
-        if !dialect_of!(self is HiveDialect) && self.parse_keyword(Keyword::COMMENT) {
-            // rewind the COMMENT keyword
-            self.prev_token();
-            comment = self.parse_optional_inline_comment()?
-        };
-
         // Parse optional `AS ( query )`
         let query = if self.parse_keyword(Keyword::AS) {
             Some(self.parse_query()?)
@@ -6971,7 +6963,7 @@ impl<'a> Parser<'a> {
             .without_rowid(without_rowid)
             .like(like)
             .clone_clause(clone)
-            .comment(comment)
+            .comment_after_column_def(comment_after_column_def)
             .order_by(order_by)
             .on_commit(on_commit)
             .on_cluster(on_cluster)
@@ -7032,7 +7024,11 @@ impl<'a> Parser<'a> {
             };
         }
 
-        let plain_options = self.parse_plain_options()?;
+        let plain_options = if dialect_of!(self is HiveDialect) {
+            vec![]
+        } else {
+            self.parse_plain_options()?
+        };
 
         Ok(CreateTableConfiguration {
             partition_by,
@@ -7055,11 +7051,19 @@ impl<'a> Parser<'a> {
             Keyword::CHARSET,
             Keyword::COLLATE,
             Keyword::INSERT_METHOD,
+            Keyword::COMMENT,
         ]) {
-            let _ = self.consume_token(&Token::Eq);
+            let has_eq = self.consume_token(&Token::Eq);
             let value = self.next_token();
 
             match (keyword, value.token) {
+                (Keyword::COMMENT, Token::SingleQuotedString(s)) => {
+                    let comment = match has_eq {
+                        true => CommentDef::WithEq(s),
+                        false => CommentDef::WithoutEq(s),
+                    };
+                    return Ok(Some(SqlOption::Comment(comment)));
+                }
                 (Keyword::AUTO_INCREMENT, Token::Number(n, l)) => {
                     // validation
                     let _ = Some(Self::parse::<u32>(n.clone(), value.span.start)?);

tests/sqlparser_common.rs

@@ -11369,7 +11369,9 @@ fn test_parse_inline_comment() {
     // [Hive](https://cwiki.apache.org/confluence/display/Hive/LanguageManual+DDL#LanguageManualDDL-CreateTable)
     match all_dialects_except(|d| d.is::<HiveDialect>()).verified_stmt(sql) {
         Statement::CreateTable(CreateTable {
-            columns, comment, ..
+            columns,
+            plain_options,
+            ..
         }) => {
             assert_eq!(
                 columns,
@@ -11383,8 +11385,10 @@ fn test_parse_inline_comment() {
                 }]
             );
             assert_eq!(
-                comment.unwrap(),
-                CommentDef::WithEq("comment with equal".to_string())
+                plain_options,
+                vec![SqlOption::Comment(CommentDef::WithEq(
+                    "comment with equal".to_string()
+                ))]
             );
         }
         _ => unreachable!(),

tests/sqlparser_duckdb.rs

@@ -717,7 +717,7 @@ fn test_duckdb_union_datatype() {
             without_rowid: Default::default(),
             like: Default::default(),
             clone: Default::default(),
-            comment: Default::default(),
+            comment_after_column_def: Default::default(),
             on_commit: Default::default(),
             on_cluster: Default::default(),
             primary_key: Default::default(),

tests/sqlparser_hive.rs

@@ -130,12 +130,13 @@ fn create_table_with_comment() {
         " INTO 4 BUCKETS"
     );
     match hive().verified_stmt(sql) {
-        Statement::CreateTable(CreateTable { comment, .. }) => {
+        Statement::CreateTable(CreateTable {
+            comment_after_column_def: comment,
+            ..
+        }) => {
             assert_eq!(
                 comment,
-                Some(CommentDef::AfterColumnDefsWithoutEq(
-                    "table comment".to_string()
-                ))
+                Some(CommentDef::WithoutEq("table comment".to_string()))
             )
         }
         _ => unreachable!(),

tests/sqlparser_mssql.rs

@@ -1581,7 +1581,7 @@ fn parse_create_table_with_valid_options() {
                 without_rowid: false,
                 like: None,
                 clone: None,
-                comment: None,
+                comment_after_column_def: None,
                 on_commit: None,
                 on_cluster: None,
                 primary_key: None,
@@ -1748,7 +1748,7 @@ fn parse_create_table_with_identity_column() {
                 without_rowid: false,
                 like: None,
                 clone: None,
-                comment: None,
+                comment_after_column_def: None,
                 on_commit: None,
                 on_cluster: None,
                 primary_key: None,