Snowflake: ORDER/NOORDER as a real sequence property; CREATE SEQUENCE WITH/comma options; ALTER SEQUENCE SET ORDER|NOORDER

Author: hovaesco

src/ast/dcl.rs

@@ -428,7 +428,11 @@ impl fmt::Display for CreateRole {
             write!(f, " AUTHORIZATION {owner}")?;
         }
         if !self.with_tags.is_empty() {
-            write!(f, " WITH TAG ({})", display_comma_separated(&self.with_tags))?;
+            write!(
+                f,
+                " WITH TAG ({})",
+                display_comma_separated(&self.with_tags)
+            )?;
         }
         Ok(())
     }

src/ast/mod.rs

@@ -8567,6 +8567,8 @@ pub enum SequenceOptions {
     Cache(Expr),
     /// `CYCLE` or `NO CYCLE` option.
     Cycle(bool),
+    /// `ORDER` or `NOORDER` option (Snowflake); `true` = `ORDER`, `false` = `NOORDER`.
+    Order(bool),
 }
 
 impl fmt::Display for SequenceOptions {
@@ -8606,6 +8608,9 @@ impl fmt::Display for SequenceOptions {
             SequenceOptions::Cycle(no) => {
                 write!(f, " {}CYCLE", if *no { "NO " } else { "" })
             }
+            SequenceOptions::Order(order) => {
+                write!(f, " {}", if *order { "ORDER" } else { "NOORDER" })
+            }
         }
     }
 }
@@ -13795,6 +13800,8 @@ pub enum AlterSequenceOperation {
     SetComment(String),
     /// `UNSET COMMENT`
     UnsetComment,
+    /// `SET ORDER` or `SET NOORDER`; `true` = `ORDER`, `false` = `NOORDER`.
+    SetOrder(bool),
 }
 
 impl fmt::Display for AlterSequenceOperation {
@@ -13804,6 +13811,9 @@ impl fmt::Display for AlterSequenceOperation {
             AlterSequenceOperation::SetIncrement(value) => write!(f, "SET INCREMENT BY {value}"),
             AlterSequenceOperation::SetComment(value) => write!(f, "SET COMMENT = '{value}'"),
             AlterSequenceOperation::UnsetComment => write!(f, "UNSET COMMENT"),
+            AlterSequenceOperation::SetOrder(order) => {
+                write!(f, "SET {}", if *order { "ORDER" } else { "NOORDER" })
+            }
         }
     }
 }

src/parser/mod.rs

@@ -12231,9 +12231,13 @@ impl<'a> Parser<'a> {
                 let _ = self.parse_keyword(Keyword::BY);
                 let _ = self.consume_token(&Token::Eq);
                 AlterSequenceOperation::SetIncrement(self.parse_number()?)
+            } else if self.parse_keyword(Keyword::ORDER) {
+                AlterSequenceOperation::SetOrder(true)
+            } else if self.parse_keyword(Keyword::NOORDER) {
+                AlterSequenceOperation::SetOrder(false)
             } else {
                 return self.expected(
-                    "RENAME TO, INCREMENT, SET COMMENT, or UNSET COMMENT after ALTER SEQUENCE",
+                    "RENAME TO, INCREMENT, ORDER, NOORDER, SET COMMENT, or UNSET COMMENT after ALTER SEQUENCE",
                     self.peek_token(),
                 );
             }
@@ -21288,10 +21292,14 @@ impl<'a> Parser<'a> {
 
     fn parse_create_sequence_options(&mut self) -> Result<Vec<SequenceOptions>, ParserError> {
         // Options may appear in any order (Snowflake) and each keyword may use an
-        // optional `=` assignment form (`START = 1`, `INCREMENT = 1`). Snowflake's
-        // `ORDER`/`NOORDER` ordering guarantee is accepted and ignored.
+        // optional `=` assignment form (`START = 1`, `INCREMENT = 1`). A leading
+        // `WITH` and comma separators between options are both accepted.
         let mut sequence_options = vec![];
+        let _ = self.parse_keyword(Keyword::WITH);
         loop {
+            if !sequence_options.is_empty() {
+                let _ = self.consume_token(&Token::Comma);
+            }
             if self.parse_keyword(Keyword::INCREMENT) {
                 //[ INCREMENT [ BY ] [ = ] increment ]
                 let by = self.parse_keyword(Keyword::BY);
@@ -21322,8 +21330,10 @@ impl<'a> Parser<'a> {
                 sequence_options.push(SequenceOptions::Cycle(true));
             } else if self.parse_keyword(Keyword::CYCLE) {
                 sequence_options.push(SequenceOptions::Cycle(false));
-            } else if self.parse_keyword(Keyword::ORDER) || self.parse_keyword(Keyword::NOORDER) {
-                // Snowflake ordering guarantee — accepted, no effect on emulation.
+            } else if self.parse_keyword(Keyword::ORDER) {
+                sequence_options.push(SequenceOptions::Order(true));
+            } else if self.parse_keyword(Keyword::NOORDER) {
+                sequence_options.push(SequenceOptions::Order(false));
             } else {
                 break;
             }

tests/sqlparser_snowflake.rs

@@ -137,7 +137,10 @@ fn parse_sf_create_stream_append_only() {
     // and on an `ON VIEW` source.
     for (sql, expected) in [
         ("CREATE STREAM s ON TABLE t APPEND_ONLY = TRUE", Some(true)),
-        ("CREATE STREAM s ON TABLE t APPEND_ONLY = FALSE", Some(false)),
+        (
+            "CREATE STREAM s ON TABLE t APPEND_ONLY = FALSE",
+            Some(false),
+        ),
         ("CREATE STREAM s ON VIEW v APPEND_ONLY = TRUE", Some(true)),
         (
             "CREATE STREAM s ON TABLE t AT(STREAM => 'S_BASE') APPEND_ONLY = TRUE",
@@ -1885,6 +1888,12 @@ fn parse_create_sequence_snowflake_options() {
         "CREATE SEQUENCE seq0 START = 1 INCREMENT = 1 ORDER",
         "CREATE SEQUENCE seq0 INCREMENT = 2 START = 5 NOORDER",
         "CREATE SEQUENCE seq0 START WITH 1 INCREMENT 1",
+        "CREATE SEQUENCE seq0 WITH START = 1, INCREMENT = 1",
+        "CREATE SEQUENCE seq0 WITH START = 1, INCREMENT = 1, ORDER",
+        "CREATE SEQUENCE seq0 WITH NOORDER",
+        "ALTER SEQUENCE seq0 SET ORDER",
+        "ALTER SEQUENCE seq0 SET NOORDER",
+        "ALTER SEQUENCE IF EXISTS seq0 SET NOORDER",
     ] {
         snowflake()
             .parse_sql_statements(sql)