Snowflake parser: keep SELECT ALL, aggregate DISTINCT, NTZ, transaction names and role lists

From the omission audit after #46 and #48:
- SELECT ALL sets select.all; it was consumed and dropped.
- An aggregate of several arguments, such as APPROX_COUNT_DISTINCT
  ( DISTINCT a , b ), keeps distinct; the generic call dropped it.
- TIMESTAMP [ ( p ) ] WITHOUT TIME ZONE is TIMESTAMP_NTZ, as its synonyms
  are, not bare TIMESTAMP (whose meaning follows TIMESTAMP_TYPE_MAPPING).
- START TRANSACTION NAME n keeps n as the name, quoting kept, apart from NAME.
- USE SECONDARY ROLES lists each role with its quoting in use.roles.

Author: kvlonge

crates/sqlquack-core/src/classification/_helpers/clauses.rs

@@ -56,6 +56,7 @@ fn select_clauses(select: &Select) -> Vec<String> {
         limit_by,
         fetch,
         distinct,
+        all: _,
         distinct_on,
         top,
         with,

crates/sqlquack-syntax/src/expressions/queries/models.rs

@@ -44,6 +44,9 @@ pub struct Select {
     pub limit_by: Option<Vec<Expression>>,
     pub fetch: Option<Fetch>,
     pub distinct: bool,
+    /// Whether ALL was written where DISTINCT could be: it changes nothing, but was written.
+    #[serde(default, skip_serializing_if = "std::ops::Not::not")]
+    pub all: bool,
     pub distinct_on: Option<Vec<Expression>>,
     pub top: Option<Top>,
     pub with: Option<With>,
@@ -130,6 +133,7 @@ impl Select {
             limit_by: None,
             fetch: None,
             distinct: false,
+            all: false,
             distinct_on: None,
             top: None,
             with: None,

crates/sqlquack-syntax/src/expressions/statements/models.rs

@@ -506,6 +506,9 @@ pub struct Use {
     pub kind: Option<UseKind>,
     /// The name of the object
     pub this: Identifier,
+    /// Snowflake's secondary roles one by one, quoting kept; empty for ALL, NONE and other kinds.
+    #[serde(default, skip_serializing_if = "Vec::is_empty")]
+    pub roles: Vec<Identifier>,
 }
 
 /// Kind of USE statement

crates/sqlquack-syntax/src/parser/_helpers/ddl/alter.rs

@@ -1424,8 +1424,10 @@ impl Parser {
                 self.skip();
                 let snowflake = self.is_snowflake();
                 let mut roles: Vec<String> = Vec::new();
+                let mut listed: Vec<Identifier> = Vec::new();
                 loop {
                     if snowflake && self.check(TokenType::QuotedIdentifier) {
+                        listed.push(Identifier::quoted(self.peek_text()));
                         roles.push(self.parse_quoted_role()?);
                         if !self.match_token(TokenType::Comma) {
                             break;
@@ -1435,6 +1437,7 @@ impl Parser {
                         || self.check(TokenType::Identifier)
                     {
                         let role = self.advance_text()?;
+                        listed.push(Identifier::new(role.clone()));
                         roles.push(role);
                         if !self.match_token(TokenType::Comma) {
                             break;
@@ -1451,9 +1454,14 @@ impl Parser {
                 } else {
                     roles.join(", ")
                 };
+                let keyword = matches!(roles.as_slice(), [role] if role.eq_ignore_ascii_case("ALL") || role.eq_ignore_ascii_case("NONE"));
                 return Ok(Expression::Use(Box::new(Use {
                     kind: Some(UseKind::SecondaryRoles),
                     this: Identifier::new(name),
+                    roles: match snowflake && !keyword {
+                        true => listed,
+                        false => Vec::new(),
+                    },
                 })));
             }
         }
@@ -1483,7 +1491,11 @@ impl Parser {
             ident.name = format!("{}.{}", ident.name, second_part.name);
         }
 
-        Ok(Expression::Use(Box::new(Use { kind, this: ident })))
+        Ok(Expression::Use(Box::new(Use {
+            kind,
+            this: ident,
+            roles: Vec::new(),
+        })))
     }
 
     /// Parses BigQuery EXPORT DATA [WITH CONNECTION c] OPTIONS (...) AS SELECT ...

crates/sqlquack-syntax/src/parser/_helpers/ddl/transactions.rs

@@ -19,6 +19,16 @@ impl Parser {
 
         self.expect_token(TokenType::Transaction)?;
         self.refuse_snowflake_nameless_transaction()?;
+        if self.is_snowflake() && self.match_identifier("NAME") {
+            let name = self.expect_identifier_or_safe_keyword_with_quoted()?;
+            return Ok(Expression::Transaction(Box::new(Transaction {
+                this: Some(Box::new(Expression::Identifier(name))),
+                modes: None,
+                mark: Some(Box::new(Expression::Identifier(Identifier::new(
+                    "START".to_string(),
+                )))),
+            })));
+        }
 
         let mut mode_parts: Vec<String> = Vec::new();
         while self.is_identifier_token()

crates/sqlquack-syntax/src/parser/_helpers/functions/typed.rs

@@ -851,7 +851,7 @@ impl Parser {
 
                     name: name.to_string(),
                     args,
-                    distinct: false,
+                    distinct,
                     trailing_comments: Vec::new(),
                     use_bracket_syntax: false,
                     no_parens: false,

crates/sqlquack-syntax/src/parser/_helpers/queries/select.rs

@@ -446,6 +446,7 @@ impl Parser {
             limit_by: None,
             fetch: None,
             distinct: false,
+            all: false,
             distinct_on: None,
             top: None,
             with: None,

crates/sqlquack-syntax/src/parser/_helpers/statements/entry.rs

@@ -1180,6 +1180,8 @@ impl Parser {
         let top = self.parse_select_top()?;
 
         let is_distinct_token = self.match_token(TokenType::Distinct);
+        let all =
+            !is_distinct_token && self.check(TokenType::All) && !self.check_next(TokenType::Dot);
         let (distinct, distinct_on) = if is_distinct_token {
             if self.match_token(TokenType::On) {
                 self.expect_token(TokenType::LParen)?;
@@ -1311,6 +1313,7 @@ impl Parser {
             hint,
             top,
             distinct,
+            all,
             distinct_on,
             kind,
             operation_modifiers,
@@ -1539,6 +1542,7 @@ impl Parser {
             hint,
             top,
             distinct,
+            all,
             distinct_on,
             kind,
             operation_modifiers,
@@ -1575,6 +1579,7 @@ impl Parser {
             limit_by,
             fetch,
             distinct,
+            all,
             distinct_on,
             top,
             with: None,

crates/sqlquack-syntax/src/parser/_helpers/types/cast_base_types.rs

@@ -346,10 +346,7 @@ impl Parser {
                 }
             } else if self.match_keyword("WITHOUT") {
                 self.match_time_zone_words()?;
-                DataType::Timestamp {
-                    precision,
-                    timezone: false,
-                }
+                self.timestamp_without_time_zone(precision)
             } else {
                 DataType::Timestamp {
                     precision,
@@ -359,6 +356,22 @@ impl Parser {
         })
     }
 
+    /// `TIMESTAMP WITHOUT TIME ZONE`: Snowflake's TIMESTAMP_NTZ, whatever TIMESTAMP maps to.
+    pub(crate) fn timestamp_without_time_zone(&self, precision: Option<u32>) -> DataType {
+        match (self.is_snowflake(), precision) {
+            (true, Some(precision)) => DataType::Custom {
+                name: format!("TIMESTAMPNTZ({precision})"),
+            },
+            (true, None) => DataType::Custom {
+                name: "TIMESTAMPNTZ".to_owned(),
+            },
+            (false, _) => DataType::Timestamp {
+                precision,
+                timezone: false,
+            },
+        }
+    }
+
     pub(crate) fn parse_cast_timestamp_tz_type(&mut self) -> Result<DataType> {
         Ok({
             let precision = if self.match_token(TokenType::LParen) {

crates/sqlquack-syntax/src/parser/_helpers/types/casts.rs

@@ -784,10 +784,7 @@ impl Parser {
             }
         } else if self.match_keyword("WITHOUT") {
             self.match_time_zone_words()?;
-            Ok(DataType::Timestamp {
-                precision,
-                timezone: false,
-            })
+            Ok(self.timestamp_without_time_zone(precision))
         } else {
             Ok(DataType::Timestamp {
                 precision,