feat: ColumnOptions enum

Author: eliaperantoni

src/ast/ddl.rs

@@ -1421,8 +1421,24 @@ impl fmt::Display for ColumnDef {
 pub struct ViewColumnDef {
     pub name: Ident,
     pub data_type: Option<DataType>,
-    pub options: Option<Vec<ColumnOption>>,
-    pub options_comma_separated: bool,
+    pub options: Option<ColumnOptions>,
+}
+
+#[derive(Debug, Clone, PartialEq, PartialOrd, Eq, Ord, Hash)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(feature = "visitor", derive(Visit, VisitMut))]
+pub enum ColumnOptions {
+    CommaSeparated(Vec<ColumnOption>),
+    SpaceSeparated(Vec<ColumnOption>),
+}
+
+impl ColumnOptions {
+    pub fn as_slice(&self) -> &[ColumnOption] {
+        match self {
+            ColumnOptions::CommaSeparated(options) => options.as_slice(),
+            ColumnOptions::SpaceSeparated(options) => options.as_slice(),
+        }
+    }
 }
 
 impl fmt::Display for ViewColumnDef {
@@ -1432,10 +1448,10 @@ impl fmt::Display for ViewColumnDef {
             write!(f, " {}", data_type)?;
         }
         if let Some(options) = self.options.as_ref() {
-            if self.options_comma_separated {
+            if matches!(options, ColumnOptions::CommaSeparated(_)) {
                 write!(f, " {}", display_comma_separated(options.as_slice()))?;
             } else {
-                write!(f, " {}", display_separated(options.as_slice(), " "))?;
+                write!(f, " {}", display_separated(options.as_slice(), " "))?
             }
         }
         Ok(())

src/ast/mod.rs

@@ -60,13 +60,14 @@ pub use self::ddl::{
     AlterColumnOperation, AlterConnectorOwner, AlterIndexOperation, AlterPolicyOperation,
     AlterTableAlgorithm, AlterTableLock, AlterTableOperation, AlterType, AlterTypeAddValue,
     AlterTypeAddValuePosition, AlterTypeOperation, AlterTypeRename, AlterTypeRenameValue,
-    ClusteredBy, ColumnDef, ColumnOption, ColumnOptionDef, ColumnPolicy, ColumnPolicyProperty,
-    ConstraintCharacteristics, CreateConnector, CreateDomain, CreateFunction, Deduplicate,
-    DeferrableInitial, DropBehavior, GeneratedAs, GeneratedExpressionMode, IdentityParameters,
-    IdentityProperty, IdentityPropertyFormatKind, IdentityPropertyKind, IdentityPropertyOrder,
-    IndexOption, IndexType, KeyOrIndexDisplay, NullsDistinctOption, Owner, Partition,
-    ProcedureParam, ReferentialAction, ReplicaIdentity, TableConstraint, TagsColumnOption,
-    UserDefinedTypeCompositeAttributeDef, UserDefinedTypeRepresentation, ViewColumnDef,
+    ClusteredBy, ColumnDef, ColumnOption, ColumnOptionDef, ColumnOptions, ColumnPolicy,
+    ColumnPolicyProperty, ConstraintCharacteristics, CreateConnector, CreateDomain, CreateFunction,
+    Deduplicate, DeferrableInitial, DropBehavior, GeneratedAs, GeneratedExpressionMode,
+    IdentityParameters, IdentityProperty, IdentityPropertyFormatKind, IdentityPropertyKind,
+    IdentityPropertyOrder, IndexOption, IndexType, KeyOrIndexDisplay, NullsDistinctOption, Owner,
+    Partition, ProcedureParam, ReferentialAction, ReplicaIdentity, TableConstraint,
+    TagsColumnOption, UserDefinedTypeCompositeAttributeDef, UserDefinedTypeRepresentation,
+    ViewColumnDef,
 };
 pub use self::dml::{CreateIndex, CreateTable, Delete, IndexColumn, Insert};
 pub use self::operator::{BinaryOperator, UnaryOperator};

src/ast/spans.rs

@@ -982,12 +982,14 @@ impl Spanned for ViewColumnDef {
             name,
             data_type: _, // todo, DataType
             options,
-            options_comma_separated: _,
         } = self;
 
         union_spans(
-            core::iter::once(name.span)
-                .chain(options.iter().flat_map(|i| i.iter().map(|k| k.span()))),
+            core::iter::once(name.span).chain(
+                options
+                    .iter()
+                    .flat_map(|i| i.as_slice().iter().map(|k| k.span())),
+            ),
         )
     }
 }
@@ -1049,7 +1051,9 @@ impl Spanned for CreateTableOptions {
         match self {
             CreateTableOptions::None => Span::empty(),
             CreateTableOptions::With(vec) => union_spans(vec.iter().map(|i| i.span())),
-            CreateTableOptions::Options(vec) => union_spans(vec.iter().map(|i| i.span())),
+            CreateTableOptions::Options(vec) => {
+                union_spans(vec.as_slice().iter().map(|i| i.span()))
+            }
             CreateTableOptions::Plain(vec) => union_spans(vec.iter().map(|i| i.span())),
             CreateTableOptions::TableProperties(vec) => union_spans(vec.iter().map(|i| i.span())),
         }

src/parser/mod.rs

@@ -10580,11 +10580,10 @@ impl<'a> Parser<'a> {
             name,
             data_type,
             options,
-            options_comma_separated: !dialect_of!(self is SnowflakeDialect),
         })
     }
 
-    fn parse_view_column_options(&mut self) -> Result<Option<Vec<ColumnOption>>, ParserError> {
+    fn parse_view_column_options(&mut self) -> Result<Option<ColumnOptions>, ParserError> {
         let mut options = Vec::new();
         loop {
             let option = self.parse_optional_column_option()?;
@@ -10594,7 +10593,14 @@ impl<'a> Parser<'a> {
                 break;
             }
         }
-        Ok(options.is_empty().not().then_some(options))
+        Ok(options
+            .is_empty()
+            .not()
+            .then_some(if dialect_of!(self is SnowflakeDialect) {
+                ColumnOptions::SpaceSeparated(options)
+            } else {
+                ColumnOptions::CommaSeparated(options)
+            }))
     }
 
     /// Parses a parenthesized comma-separated list of unqualified, possibly quoted identifiers.

tests/sqlparser_bigquery.rs

@@ -348,20 +348,20 @@ fn parse_create_view_with_options() {
                         name: Ident::new("name"),
                         data_type: None,
                         options: None,
-                        options_comma_separated: true,
                     },
                     ViewColumnDef {
                         name: Ident::new("age"),
                         data_type: None,
-                        options: Some(vec![ColumnOption::Options(vec![SqlOption::KeyValue {
-                            key: Ident::new("description"),
-                            value: Expr::Value(
-                                Value::DoubleQuotedString("field age".to_string()).with_span(
-                                    Span::new(Location::new(1, 42), Location::new(1, 52))
-                                )
-                            ),
-                        }])]),
-                        options_comma_separated: true,
+                        options: Some(ColumnOptions::CommaSeparated(vec![ColumnOption::Options(
+                            vec![SqlOption::KeyValue {
+                                key: Ident::new("description"),
+                                value: Expr::Value(
+                                    Value::DoubleQuotedString("field age".to_string()).with_span(
+                                        Span::new(Location::new(1, 42), Location::new(1, 52))
+                                    )
+                                ),
+                            }]
+                        )])),
                     },
                 ],
                 columns

tests/sqlparser_clickhouse.rs

@@ -915,7 +915,6 @@ fn parse_create_view_with_fields_data_types() {
                             vec![]
                         )),
                         options: None,
-                        options_comma_separated: true,
                     },
                     ViewColumnDef {
                         name: "f".into(),
@@ -928,7 +927,6 @@ fn parse_create_view_with_fields_data_types() {
                             vec![]
                         )),
                         options: None,
-                        options_comma_separated: true,
                     },
                 ]
             );

tests/sqlparser_common.rs

@@ -7960,64 +7960,52 @@ fn parse_create_view_with_options() {
 #[test]
 fn parse_create_view_with_columns() {
     let sql = "CREATE VIEW v (has, cols) AS SELECT 1, 2";
-    fn assert_stmt_as_expected(stmt: Statement, options_comma_separated: bool) {
-        match stmt {
-            Statement::CreateView {
-                or_alter,
-                name,
+    // TODO: why does this fail for ClickHouseDialect? (#1449)
+    // match all_dialects().verified_stmt(sql) {
+    match all_dialects_where(|d| !d.is::<ClickHouseDialect>()).verified_stmt(sql) {
+        Statement::CreateView {
+            or_alter,
+            name,
+            columns,
+            or_replace,
+            options,
+            query,
+            materialized,
+            cluster_by,
+            comment,
+            with_no_schema_binding: late_binding,
+            if_not_exists,
+            temporary,
+            to,
+            params,
+        } => {
+            assert_eq!(or_alter, false);
+            assert_eq!("v", name.to_string());
+            assert_eq!(
                 columns,
-                or_replace,
-                options,
-                query,
-                materialized,
-                cluster_by,
-                comment,
-                with_no_schema_binding: late_binding,
-                if_not_exists,
-                temporary,
-                to,
-                params,
-            } => {
-                assert_eq!(or_alter, false);
-                assert_eq!("v", name.to_string());
-                assert_eq!(
-                    columns,
-                    vec![Ident::new("has"), Ident::new("cols"),]
-                        .into_iter()
-                        .map(|name| ViewColumnDef {
-                            name,
-                            data_type: None,
-                            options: None,
-                            options_comma_separated,
-                        })
-                        .collect::<Vec<_>>()
-                );
-                assert_eq!(options, CreateTableOptions::None);
-                assert_eq!("SELECT 1, 2", query.to_string());
-                assert!(!materialized);
-                assert!(!or_replace);
-                assert_eq!(cluster_by, vec![]);
-                assert!(comment.is_none());
-                assert!(!late_binding);
-                assert!(!if_not_exists);
-                assert!(!temporary);
-                assert!(to.is_none());
-                assert!(params.is_none());
-            }
-            _ => unreachable!(),
+                vec![Ident::new("has"), Ident::new("cols"),]
+                    .into_iter()
+                    .map(|name| ViewColumnDef {
+                        name,
+                        data_type: None,
+                        options: None,
+                    })
+                    .collect::<Vec<_>>()
+            );
+            assert_eq!(options, CreateTableOptions::None);
+            assert_eq!("SELECT 1, 2", query.to_string());
+            assert!(!materialized);
+            assert!(!or_replace);
+            assert_eq!(cluster_by, vec![]);
+            assert!(comment.is_none());
+            assert!(!late_binding);
+            assert!(!if_not_exists);
+            assert!(!temporary);
+            assert!(to.is_none());
+            assert!(params.is_none());
         }
+        _ => unreachable!(),
     }
-    // TODO: why does this fail for ClickHouseDialect? (#1449)
-    // match all_dialects().verified_stmt(sql) {
-    assert_stmt_as_expected(
-        all_dialects_where(|d| !d.is::<ClickHouseDialect>() && !d.is::<SnowflakeDialect>())
-            .verified_stmt(sql),
-        true,
-    );
-    assert_stmt_as_expected(
-        all_dialects_where(|d| d.is::<SnowflakeDialect>()).verified_stmt(sql),
-        false,
-    );
 }
 
 #[test]

tests/sqlparser_snowflake.rs

@@ -3142,14 +3142,14 @@ fn parse_view_column_descriptions() {
                     ViewColumnDef {
                         name: Ident::new("a"),
                         data_type: None,
-                        options: Some(vec![ColumnOption::Comment("Comment".to_string())]),
-                        options_comma_separated: false,
+                        options: Some(ColumnOptions::SpaceSeparated(vec![ColumnOption::Comment(
+                            "Comment".to_string()
+                        )])),
                     },
                     ViewColumnDef {
                         name: Ident::new("b"),
                         data_type: None,
                         options: None,
-                        options_comma_separated: false,
                     }
                 ]
             );
@@ -4087,13 +4087,7 @@ fn parse_connect_by_root_operator() {
 
 #[test]
 fn test_snowflake_create_view_with_tag() {
-    let create_view_with_tag = r#"CREATE VIEW X (COL WITH TAG (pii='email')) AS SELECT * FROM Y"#;
-    snowflake().verified_stmt(create_view_with_tag);
-}
-
-#[test]
-fn test_snowflake_create_view_with_tag_and_comment() {
-    let create_view_with_tag_and_comment =
+    let create_view_with_tag =
         r#"CREATE VIEW X (COL WITH TAG (pii='email') COMMENT 'foobar') AS SELECT * FROM Y"#;
-    snowflake().verified_stmt(create_view_with_tag_and_comment);
+    snowflake().verified_stmt(create_view_with_tag);
 }