fix(syntax): name DELETE USING subqueries, semantic views and FIRST/LAST join aliases as what they are

A DELETE USING subquery was a table with an empty name and the query in
its hints; it is now a derived table in using_items, as a FROM subquery
is, with its alias, column aliases and AS spelling. A semantic view's
name was a column node; it is now a table reference, and an explicit AS
in its clauses is recorded. On a join with no ON or USING, FIRST or LAST
followed by parentheses is the joined table's alias and column aliases,
as Snowflake reads it, not a read-order clause.

Author: kvlonge

crates/sqlquack-syntax-snowflake/src/parser/_helpers/queries/joins.rs

@@ -36,6 +36,36 @@ impl Parser {
         Ok((Some(side.to_owned()), Some(alias)))
     }
 
+    /// The read-order clause after a join; with no ON, USING or MATCH_CONDITION (`conditionless`), Snowflake reads `FIRST ( x )` or `LAST ( x )` as the joined table's alias and column alias instead.
+    fn parse_snowflake_join_read_order(
+        &mut self,
+        table: Expression,
+        conditionless: bool,
+    ) -> Result<(Expression, Option<String>, Option<Identifier>)> {
+        let first_last_at = self.current;
+        let (first_last, first_last_alias) = self.parse_snowflake_join_first_last()?;
+        if !conditionless || first_last.is_none() {
+            return Ok((table, first_last, first_last_alias));
+        }
+        let keyword = &self.tokens[first_last_at];
+        let mut alias = Identifier::new(keyword.text.to_string());
+        alias.span = Some(keyword.span);
+        let columns: Vec<Identifier> = first_last_alias.iter().cloned().collect();
+        Ok(match table {
+            Expression::Table(mut reference) if reference.alias.is_none() => {
+                reference.alias = Some(alias);
+                reference.column_aliases = columns;
+                (Expression::Table(reference), None, None)
+            }
+            Expression::Subquery(mut derived) if derived.alias.is_none() => {
+                derived.alias = Some(alias);
+                derived.column_aliases = columns;
+                (Expression::Subquery(derived), None, None)
+            }
+            other => (other, first_last, first_last_alias),
+        })
+    }
+
     /// Parses joins; chained ON/USING clauses bind right to left, as `a JOIN b JOIN c ON x ON y`.
     pub(crate) fn parse_joins(&mut self) -> Result<Vec<Join>> {
         let mut joins = Vec::with_capacity(2);
@@ -127,7 +157,9 @@ impl Parser {
                 } else {
                     (None, Vec::new())
                 };
-                let (first_last, first_last_alias) = self.parse_snowflake_join_first_last()?;
+                let conditionless = on.is_none() && using.is_empty() && match_condition.is_none();
+                let (table, first_last, first_last_alias) =
+                    self.parse_snowflake_join_read_order(table, conditionless)?;
 
                 joins.push(Join {
                     using_alias: None,

crates/sqlquack-syntax-snowflake/src/parser/_helpers/statements/dml.rs

@@ -14,6 +14,7 @@ use sqlquack_syntax::expressions::names::models::TableRef;
 use sqlquack_syntax::expressions::operators::models::ConditionalInsert;
 use sqlquack_syntax::expressions::operators::models::MultitableInserts;
 use sqlquack_syntax::expressions::queries::models::Join;
+use sqlquack_syntax::expressions::queries::models::Subquery;
 use sqlquack_syntax::expressions::queries::models::Where;
 use sqlquack_syntax::expressions::schema_objects::models::FunctionSecurity;
 use sqlquack_syntax::expressions::statements::models::Delete;
@@ -110,8 +111,8 @@ impl Parser {
 
         let mut joins = self.parse_joins()?;
 
-        let using;
-        (using, joins) = self.parse_delete_using(joins)?;
+        let (using, using_items);
+        (using, using_items, joins) = self.parse_delete_using(joins)?;
 
         let output = if early_output.is_some() {
             early_output
@@ -148,7 +149,7 @@ impl Parser {
         };
 
         Ok(Expression::Delete(Box::new(Delete {
-            using_items: Vec::new(),
+            using_items,
             using_joins: Vec::new(),
             table,
             hint,
@@ -208,8 +209,31 @@ impl Parser {
         )
     }
 
-    fn parse_delete_using(&mut self, mut joins: Vec<Join>) -> Result<(Vec<TableRef>, Vec<Join>)> {
-        let mut using: Vec<TableRef> = Vec::new();
+    /// The tables after DELETE's USING, or, when any is a derived table, every item instead; then the joins after them.
+    fn parse_delete_using(
+        &mut self,
+        joins: Vec<Join>,
+    ) -> Result<(Vec<TableRef>, Vec<Expression>, Vec<Join>)> {
+        let (items, joins) = self.parse_delete_using_items(joins)?;
+        let tables: Option<Vec<TableRef>> = items
+            .iter()
+            .map(|item| match item {
+                Expression::Table(table) => Some((**table).clone()),
+                _ => None,
+            })
+            .collect();
+        Ok(match tables {
+            Some(tables) => (tables, Vec::new(), joins),
+            None => (Vec::new(), items, joins),
+        })
+    }
+
+    /// The items after DELETE's USING, each a table or a derived table, and the joins after them.
+    fn parse_delete_using_items(
+        &mut self,
+        mut joins: Vec<Join>,
+    ) -> Result<(Vec<Expression>, Vec<Join>)> {
+        let mut using: Vec<Expression> = Vec::new();
         if self.match_token(TokenType::Using) {
             loop {
                 if self.check(TokenType::LParen) {
@@ -237,6 +261,11 @@ impl Parser {
                         self.parse_primary()?
                     };
                     let using_alias = if self.match_token(TokenType::As) {
+                        let token = self.previous();
+                        let keyword = match self.source.is_some() {
+                            true => self.source_text_range(token.span.start, token.span.end),
+                            false => token.text.to_string(),
+                        };
                         let alias_name = self.expect_identifier_with_quoted()?;
                         let col_aliases = if self.match_token(TokenType::LParen) {
                             let aliases = self.parse_identifier_list()?;
@@ -245,24 +274,45 @@ impl Parser {
                         } else {
                             Vec::new()
                         };
-                        Some((alias_name, col_aliases))
+                        Some((keyword, alias_name, col_aliases))
                     } else {
                         None
                     };
-                    let mut tref = TableRef::new("");
-                    if let Some((alias_name, col_aliases)) = using_alias {
-                        tref.alias = Some(alias_name);
-                        tref.alias_explicit_as = true;
-                        tref.column_aliases = col_aliases;
+                    let mut derived = match subquery {
+                        Expression::Subquery(derived) => *derived,
+                        Expression::Paren(values) => Subquery {
+                            this: values.this,
+                            alias: None,
+                            column_aliases: Vec::new(),
+                            alias_explicit_as: false,
+                            alias_keyword: None,
+                            order_by: None,
+                            limit: None,
+                            offset: None,
+                            distribute_by: None,
+                            sort_by: None,
+                            cluster_by: None,
+                            lateral: false,
+                            modifiers_inside: false,
+                            trailing_comments: values.trailing_comments,
+                            inferred_type: None,
+                            span: values.span,
+                        },
+                        _ => return Err(self.parse_error("Expected a query in DELETE USING ( )")),
+                    };
+                    if let Some((keyword, alias_name, col_aliases)) = using_alias {
+                        derived.alias = Some(alias_name);
+                        derived.alias_explicit_as = true;
+                        derived.alias_keyword = Some(keyword);
+                        derived.column_aliases = col_aliases;
                     }
-                    tref.hints = vec![subquery];
-                    using.push(tref);
+                    using.push(Expression::Subquery(Box::new(derived)));
                 } else {
                     let using_table = self.expect_identifier_with_quoted()?;
                     let mut using_ref = TableRef::from_identifier(using_table);
 
                     if self.check_join_keyword() {
-                        using.push(using_ref);
+                        using.push(Expression::Table(Box::new(using_ref)));
                         let mut using_joins = self.parse_joins()?;
                         joins.append(&mut using_joins);
                         break;
@@ -277,7 +327,7 @@ impl Parser {
                     {
                         using_ref.alias = Some(self.expect_identifier_with_quoted()?);
                     }
-                    using.push(using_ref);
+                    using.push(Expression::Table(Box::new(using_ref)));
                 }
                 if !self.match_token(TokenType::Comma) {
                     break;

crates/sqlquack-syntax-snowflake/src/parser/_helpers/statements/sessions.rs

@@ -1841,7 +1841,10 @@ impl Parser {
         if self.is_snowflake() && self.check(TokenType::String) {
             return Err(self.parse_error("Expected a semantic view name"));
         }
-        let this = self.parse_primary()?;
+        let this = match self.is_snowflake() {
+            true => Expression::Table(Box::new(self.parse_object_name()?)),
+            false => self.parse_primary()?,
+        };
 
         let mut metrics = None;
         let mut dimensions = None;
@@ -1916,16 +1919,24 @@ impl Parser {
                 || !crate::parser::constants::SNOWFLAKE_SEMANTIC_VIEW_CLAUSES
                     .iter()
                     .any(|word| self.peek_text().eq_ignore_ascii_case(word)));
-        if bare_alias || self.match_token(TokenType::As) {
+        let explicit_as = !bare_alias && self.match_token(TokenType::As);
+        if bare_alias || explicit_as {
+            let alias_keyword = explicit_as.then(|| {
+                let token = self.previous();
+                match self.source.is_some() {
+                    true => self.source_text_range(token.span.start, token.span.end),
+                    false => token.text.to_string(),
+                }
+            });
             let alias = self.expect_identifier_or_keyword_with_quoted()?;
             Ok(Expression::Alias(Box::new(
                 sqlquack_syntax::expressions::operators::models::Alias {
                     span: SourceSpan::default(),
                     this: expr,
                     alias,
                     column_aliases: Vec::new(),
-                    alias_explicit_as: false,
-                    alias_keyword: None,
+                    alias_explicit_as: explicit_as,
+                    alias_keyword,
                     pre_alias_comments: Vec::new(),
                     trailing_comments: Vec::new(),
                     inferred_type: None,

crates/sqlquack-syntax-snowflake/tests/parser/test_faithful.rs

@@ -214,3 +214,81 @@ fn given_an_interval_qualifier_with_precisions_when_parsing_faithfully_then_both
         );
     }
 }
+
+#[test]
+fn given_snowflake_derived_tables_join_aliases_and_semantic_views_when_parsing_then_the_tree_names_what_they_are(
+) {
+    let test_cases = [
+        ProjectionTestCase {
+            description: "a DELETE USING subquery is a derived table with its alias",
+            sql: "DELETE FROM v1 USING ( SELECT 1 ) AS s ( c ) , t2 WHERE TRUE ;",
+            pointer: "/0/delete/using_items/0/subquery/alias/name",
+            expected_value: json!("s"),
+        },
+        ProjectionTestCase {
+            description: "a DELETE USING subquery keeps its column aliases",
+            sql: "DELETE FROM v1 USING ( SELECT 1 ) AS s ( c ) , t2 WHERE TRUE ;",
+            pointer: "/0/delete/using_items/0/subquery/column_aliases/0/name",
+            expected_value: json!("c"),
+        },
+        ProjectionTestCase {
+            description: "a table beside a DELETE USING subquery stays a table",
+            sql: "DELETE FROM v1 USING ( SELECT 1 ) AS s ( c ) , t2 WHERE TRUE ;",
+            pointer: "/0/delete/using_items/1/table/name/name",
+            expected_value: json!("t2"),
+        },
+        ProjectionTestCase {
+            description: "a DELETE USING only tables keeps its table list",
+            sql: "DELETE FROM v1 USING t2 , t3 AS x ;",
+            pointer: "/0/delete/using/1/alias/name",
+            expected_value: json!("x"),
+        },
+        ProjectionTestCase {
+            description: "FIRST on a join with no condition is the joined table's alias",
+            sql: "SELECT 1 FROM t1 JOIN t2 FIRST ( v1 ) ;",
+            pointer: "/0/select/joins/0/this/table/alias/name",
+            expected_value: json!("FIRST"),
+        },
+        ProjectionTestCase {
+            description: "the parenthesised name after a FIRST alias is a column alias",
+            sql: "SELECT 1 FROM t1 JOIN t2 FIRST ( v1 ) ;",
+            pointer: "/0/select/joins/0/this/table/column_aliases/0/name",
+            expected_value: json!("v1"),
+        },
+        ProjectionTestCase {
+            description: "FIRST after ON stays the read-order clause",
+            sql: "SELECT 1 FROM t1 INNER DIRECTED JOIN t2 ON TRUE FIRST ( v1 ) ;",
+            pointer: "/0/select/joins/0/first_last",
+            expected_value: json!("FIRST"),
+        },
+        ProjectionTestCase {
+            description: "a semantic view's qualified name is a table reference",
+            sql: "SELECT * FROM SEMANTIC_VIEW ( d1 . v1 METRICS 1 AS v1 DIMENSIONS 1 v1 ) ;",
+            pointer: "/0/select/from/expressions/0/semantic_view/this/table/schema/name",
+            expected_value: json!("d1"),
+        },
+        ProjectionTestCase {
+            description: "an explicit AS in a semantic view clause is recorded",
+            sql: "SELECT * FROM SEMANTIC_VIEW ( d1 . v1 METRICS 1 AS v1 DIMENSIONS 1 v1 ) ;",
+            pointer: "/0/select/from/expressions/0/semantic_view/metrics/tuple/expressions/0/alias/alias_explicit_as",
+            expected_value: json!(true),
+        },
+        ProjectionTestCase {
+            description: "a bare alias in a semantic view clause has no AS",
+            sql: "SELECT * FROM SEMANTIC_VIEW ( d1 . v1 METRICS 1 AS v1 DIMENSIONS 1 v1 ) ;",
+            pointer: "/0/select/from/expressions/0/semantic_view/dimensions/tuple/expressions/0/alias/alias_explicit_as",
+            expected_value: json!(false),
+        },
+    ];
+    for test_case in test_cases {
+        assert_eq!(
+            statements(test_case.sql, Dialect::Snowflake, CallMode::Faithful)
+                .pointer(test_case.pointer)
+                .cloned()
+                .unwrap_or_default(),
+            test_case.expected_value,
+            "{}",
+            test_case.description
+        );
+    }
+}