squawk-cli 2.12.0__tar.gz → 2.13.0__tar.gz

{squawk_cli-2.12.0 → squawk_cli-2.13.0}/Cargo.lock

@@ -2543,7 +2543,7 @@ checksum = "6e63cff320ae2c57904679ba7cb63280a3dc4613885beafb148ee7bf9aa9042d"
 
 [[package]]
 name = "squawk"
-version = "2.12.0"
+version = "2.13.0"
 dependencies = [
  "annotate-snippets",
  "anyhow",

{squawk_cli-2.12.0 → squawk_cli-2.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: squawk-cli
-Version: 2.12.0
+Version: 2.13.0
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: MacOS

{squawk_cli-2.12.0 → squawk_cli-2.13.0}/crates/squawk/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "squawk"
-version = "2.12.0"
+version = "2.13.0"
 default-run = "squawk"
 
 authors.workspace = true

{squawk_cli-2.12.0 → squawk_cli-2.13.0}/crates/squawk_parser/src/generated/syntax_kind.rs

@@ -799,6 +799,13 @@ pub enum SyntaxKind {
     IS_NOT_JSON_VALUE,
     IS_NOT_NORMALIZED,
     JOIN,
+    JOIN_CROSS,
+    JOIN_EXPR,
+    JOIN_FULL,
+    JOIN_INNER,
+    JOIN_LEFT,
+    JOIN_RIGHT,
+    JOIN_TYPE,
     JSON_BEHAVIOR_CLAUSE,
     JSON_FORMAT_CLAUSE,
     JSON_KEYS_UNIQUE_CLAUSE,
@@ -848,6 +855,7 @@ pub enum SyntaxKind {
     NULL_CONSTRAINT,
     OFFSET_CLAUSE,
     OF_TYPE,
+    ON_CLAUSE,
     ON_DELETE_ACTION,
     ON_UPDATE_ACTION,
     OP,

{squawk_cli-2.12.0 → squawk_cli-2.13.0}/crates/squawk_parser/src/grammar.rs

@@ -68,7 +68,7 @@ fn array_expr(p: &mut Parser<'_>, m: Option<Marker>) -> CompletedMarker {
     m.complete(p, ARRAY_EXPR)
 }
 
-fn paren_select(p: &mut Parser<'_>) -> Option<CompletedMarker> {
+fn opt_paren_select(p: &mut Parser<'_>) -> Option<CompletedMarker> {
     let m = p.start();
     if !p.eat(L_PAREN) {
         m.abandon(p);
@@ -81,7 +81,7 @@ fn paren_select(p: &mut Parser<'_>) -> Option<CompletedMarker> {
         if p.at_ts(SELECT_FIRST) && (select(p, None).is_none() || p.at(EOF) || p.at(R_PAREN)) {
             break;
         }
-        if paren_select(p).is_none() {
+        if opt_paren_select(p).is_none() {
             break;
         }
         if !p.at(R_PAREN) {
@@ -89,7 +89,14 @@ fn paren_select(p: &mut Parser<'_>) -> Option<CompletedMarker> {
         }
     }
     p.expect(R_PAREN);
-    Some(m.complete(p, PAREN_SELECT))
+    let cm = m.complete(p, PAREN_SELECT);
+    let cm = if p.at_ts(COMPOUND_SELECT_FIRST) {
+        compound_select(p, cm)
+    } else {
+        cm
+    };
+    select_trailing_clauses(p);
+    Some(cm)
 }
 
 const SELECT_FIRST: TokenSet = TokenSet::new(&[SELECT_KW, TABLE_KW, WITH_KW, VALUES_KW]);
@@ -2436,7 +2443,7 @@ fn compound_select(p: &mut Parser<'_>, cm: CompletedMarker) -> CompletedMarker {
         p.eat(DISTINCT_KW);
     }
     if p.at(L_PAREN) {
-        tuple_expr(p);
+        opt_paren_select(p);
     } else {
         if p.at_ts(SELECT_FIRST) {
             select(p, None);
@@ -2488,6 +2495,11 @@ fn select(p: &mut Parser, m: Option<Marker>) -> Option<CompletedMarker> {
         let cm = m.complete(p, SELECT);
         return Some(compound_select(p, cm));
     }
+    select_trailing_clauses(p);
+    Some(m.complete(p, out_kind))
+}
+
+fn select_trailing_clauses(p: &mut Parser<'_>) {
     opt_order_by_clause(p);
     let mut has_locking_clause = false;
     while p.at(FOR_KW) {
@@ -2505,7 +2517,6 @@ fn select(p: &mut Parser, m: Option<Marker>) -> Option<CompletedMarker> {
             opt_locking_clause(p);
         }
     }
-    Some(m.complete(p, out_kind))
 }
 
 // INTO [ TEMPORARY | TEMP | UNLOGGED ] [ TABLE ] new_table
@@ -2625,32 +2636,61 @@ fn opt_order_by_clause(p: &mut Parser<'_>) -> bool {
     true
 }
 
-const JOIN_TYPE_FIRST: TokenSet = TokenSet::new(&[INNER_KW, JOIN_KW, LEFT_KW, RIGHT_KW, FULL_KW]);
+const JOIN_TYPE_FIRST: TokenSet =
+    TokenSet::new(&[INNER_KW, JOIN_KW, LEFT_KW, RIGHT_KW, FULL_KW, CROSS_KW]);
 
 // where join_type is:
 //   [ INNER ] JOIN
 //   LEFT [ OUTER ] JOIN
 //   RIGHT [ OUTER ] JOIN
 //   FULL [ OUTER ] JOIN
-fn join_type(p: &mut Parser<'_>) -> bool {
+fn join_type(p: &mut Parser<'_>) -> Option<CompletedMarker> {
     assert!(p.at_ts(JOIN_TYPE_FIRST));
-    if p.eat(INNER_KW) {
-        p.expect(JOIN_KW)
-    } else if p.eat(LEFT_KW) || p.eat(RIGHT_KW) || p.eat(FULL_KW) {
-        p.eat(OUTER_KW);
-        p.expect(JOIN_KW)
-    } else {
-        p.expect(JOIN_KW)
-    }
+    let m = p.start();
+    let kind = match p.current() {
+        CROSS_KW => {
+            p.bump(CROSS_KW);
+            p.expect(JOIN_KW);
+            JOIN_CROSS
+        }
+        INNER_KW | JOIN_KW => {
+            p.eat(INNER_KW);
+            p.expect(JOIN_KW);
+            JOIN_INNER
+        }
+        LEFT_KW => {
+            p.bump(LEFT_KW);
+            p.eat(OUTER_KW);
+            p.expect(JOIN_KW);
+            JOIN_LEFT
+        }
+        RIGHT_KW => {
+            p.bump(RIGHT_KW);
+            p.eat(OUTER_KW);
+            p.expect(JOIN_KW);
+            JOIN_RIGHT
+        }
+        FULL_KW => {
+            p.bump(FULL_KW);
+            p.eat(OUTER_KW);
+            p.expect(JOIN_KW);
+            JOIN_FULL
+        }
+        _ => {
+            p.error("expected join type");
+            return None;
+        }
+    };
+    Some(m.complete(p, kind))
 }
 
 const JOIN_FIRST: TokenSet = TokenSet::new(&[NATURAL_KW, CROSS_KW]).union(JOIN_TYPE_FIRST);
 
-fn opt_from_clause(p: &mut Parser<'_>) -> bool {
+fn opt_from_clause(p: &mut Parser<'_>) -> Option<CompletedMarker> {
     let m = p.start();
     if !p.eat(FROM_KW) {
         m.abandon(p);
-        return false;
+        return None;
     }
     if !opt_from_item(p) {
         p.error(format!("expected from item, got {:?}", p.current()));
@@ -2661,8 +2701,7 @@ fn opt_from_clause(p: &mut Parser<'_>) -> bool {
             break;
         }
     }
-    m.complete(p, FROM_CLAUSE);
-    true
+    Some(m.complete(p, FROM_CLAUSE))
 }
 
 // https://github.com/postgres/postgres/blob/b3219c69fc1e161df8d380c464b3f2cce3b6cab9/src/backend/parser/gram.y#L18042
@@ -2750,11 +2789,14 @@ const FUNC_EXPR_COMMON_SUBEXPR_FIRST: TokenSet = TokenSet::new(&[
     GREATEST_KW,
     JSON_KW,
     JSON_ARRAY_KW,
+    JSON_ARRAYAGG_KW,
     JSON_EXISTS_KW,
     JSON_OBJECT_KW,
+    JSON_OBJECTAGG_KW,
     JSON_QUERY_KW,
     JSON_SCALAR_KW,
     JSON_SERIALIZE_KW,
+    JSON_TABLE_KW,
     JSON_VALUE_KW,
     LEAST_KW,
     LOCALTIME_KW,
@@ -2778,6 +2820,7 @@ const FUNC_EXPR_COMMON_SUBEXPR_FIRST: TokenSet = TokenSet::new(&[
     XMLPI_KW,
     XMLROOT_KW,
     XMLSERIALIZE_KW,
+    XMLTABLE_KW,
 ]);
 
 const FROM_ITEM_KEYWORDS_FIRST: TokenSet = TokenSet::new(&[])
@@ -2965,36 +3008,30 @@ fn xml_namespace_element(p: &mut Parser<'_>) {
     }
 }
 
-fn paren_data_source(p: &mut Parser<'_>) -> CompletedMarker {
+fn paren_data_source(p: &mut Parser<'_>) -> Option<CompletedMarker> {
     assert!(p.at(L_PAREN));
+    if p.at(L_PAREN) && p.nth_at_ts(1, SELECT_FIRST) {
+        return opt_paren_select(p);
+    }
     let m = p.start();
     p.bump(L_PAREN);
-
-    // Try to parse as a SELECT statement first
-    if p.at_ts(SELECT_FIRST) {
-        if select(p, None).is_some() {
-            p.expect(R_PAREN);
-            return m.complete(p, PAREN_SELECT);
-        }
-    }
-
     // Then try to parse as a FROM_ITEM (which includes table references and joins)
     if opt_from_item(p) {
         p.expect(R_PAREN);
-        return m.complete(p, PAREN_EXPR);
+        return Some(m.complete(p, PAREN_EXPR));
     } else {
         p.error("expected table name or SELECT");
     }
 
     p.expect(R_PAREN);
-    m.complete(p, PAREN_EXPR)
+    Some(m.complete(p, PAREN_EXPR))
 }
 
 // USING data_source ON join_condition
 fn merge_using_clause(p: &mut Parser<'_>) {
     let m = p.start();
     p.expect(USING_KW);
-    data_source(p);
+    opt_from_item(p);
     p.expect(ON_KW);
     // join_condition
     if expr(p).is_none() {
@@ -3037,17 +3074,18 @@ fn merge_using_clause(p: &mut Parser<'_>) {
 //    RIGHT [ OUTER ] JOIN
 //    FULL [ OUTER ] JOIN
 //
-#[must_use]
 fn opt_from_item(p: &mut Parser<'_>) -> bool {
     if !p.at_ts(FROM_ITEM_FIRST) {
         return false;
     }
     let m = p.start();
     data_source(p);
+    let mut cm = m.complete(p, FROM_ITEM);
     while p.at_ts(JOIN_FIRST) {
+        let m = cm.precede(p);
         join(p);
+        cm = m.complete(p, JOIN_EXPR);
     }
-    m.complete(p, FROM_ITEM);
     true
 }
 
@@ -3066,52 +3104,40 @@ fn opt_from_item(p: &mut Parser<'_>) -> bool {
 fn join(p: &mut Parser<'_>) {
     assert!(p.at_ts(JOIN_FIRST));
     let m = p.start();
-    if p.eat(NATURAL_KW) {
-        if !join_type(p) {
-            p.error("expected join type");
-        }
-        if !opt_from_item(p) {
-            p.error("expected from_item");
-        }
-    } else if p.eat(CROSS_KW) {
-        p.expect(JOIN_KW);
-        if !opt_from_item(p) {
-            p.error("expected from_item");
-        }
-    } else {
-        if !join_type(p) {
-            p.error("expected join type");
-        }
-        if !opt_from_item(p) {
-            p.error("expected from_item");
+    p.eat(NATURAL_KW);
+    if join_type(p).is_none() {
+        p.error("expected join type");
+    }
+    if !opt_from_item(p) {
+        p.error("expected from_item");
+    }
+    if p.at(ON_KW) {
+        let m = p.start();
+        p.bump(ON_KW);
+        if expr(p).is_none() {
+            p.error("expected an expression");
         }
-        if p.eat(ON_KW) {
-            if expr(p).is_none() {
-                p.error("expected an expression");
-            }
+        m.complete(p, ON_CLAUSE);
+    } else if p.at(USING_KW) {
+        let m = p.start();
+        // USING ( join_column [, ...] )
+        p.expect(USING_KW);
+        if p.at(L_PAREN) {
+            column_list(p);
         } else {
-            {
-                let m = p.start();
-                // USING ( join_column [, ...] )
-                p.expect(USING_KW);
-                if p.at(L_PAREN) {
-                    column_list(p);
-                } else {
-                    p.error("expected L_PAREN");
-                }
-                m.complete(p, USING_CLAUSE);
-            }
-            {
-                let m = p.start();
-                // [ AS join_using_alias ]
-                if p.eat(AS_KW) {
-                    name(p);
-                    m.complete(p, ALIAS);
-                } else {
-                    m.abandon(p);
-                }
+            p.error("expected L_PAREN");
+        }
+        {
+            let m = p.start();
+            // [ AS join_using_alias ]
+            if p.eat(AS_KW) {
+                name(p);
+                m.complete(p, ALIAS);
+            } else {
+                m.abandon(p);
             }
         }
+        m.complete(p, USING_CLAUSE);
     }
     m.complete(p, JOIN);
 }
@@ -5272,17 +5298,7 @@ fn stmt(p: &mut Parser, r: &StmtRestrictions) -> Option<CompletedMarker> {
         (INSERT_KW, _) => Some(insert(p, None)),
         (L_PAREN, _) if p.nth_at_ts(1, SELECT_FIRST) || p.at(L_PAREN) => {
             // can have select nested in parens, i.e., ((select 1));
-            let cm = paren_select(p)?;
-            let cm = if p.at_ts(COMPOUND_SELECT_FIRST) {
-                compound_select(p, cm)
-            } else {
-                cm
-            };
-            // TODO: this needs to be rethinked
-            if p.at(ORDER_KW) {
-                opt_order_by_clause(p);
-            }
-            Some(cm)
+            opt_paren_select(p)
         }
         (LISTEN_KW, _) => Some(listen(p)),
         (LOAD_KW, _) => Some(load(p)),
@@ -11970,7 +11986,7 @@ fn create_schema(p: &mut Parser<'_>) -> CompletedMarker {
 
 fn query(p: &mut Parser<'_>) {
     // TODO: this needs to be more general
-    if (!p.at_ts(SELECT_FIRST) || select(p, None).is_none()) && paren_select(p).is_none() {
+    if (!p.at_ts(SELECT_FIRST) || select(p, None).is_none()) && opt_paren_select(p).is_none() {
         p.error("expected select stmt")
     }
 }

{squawk_cli-2.12.0 → squawk_cli-2.13.0}/crates/squawk_parser/tests/data/regression_suite/merge.sql

@@ -42,11 +42,11 @@ WHEN MATCHED THEN
 --
 -- Errors
 --
-MERGE INTO target t RANDOMWORD
-USING source AS s
-ON t.tid = s.sid
-WHEN MATCHED THEN
-	UPDATE SET balance = 0;
+-- MERGE INTO target t RANDOMWORD
+-- USING source AS s
+-- ON t.tid = s.sid
+-- WHEN MATCHED THEN
+-- 	UPDATE SET balance = 0;
 -- MATCHED/INSERT error
 MERGE INTO target t
 USING source AS s
@@ -60,41 +60,41 @@ ON t.tid = s.sid
 WHEN NOT MATCHED BY SOURCE THEN
 	INSERT DEFAULT VALUES;
 -- incorrectly specifying INTO target
-MERGE INTO target t
-USING source AS s
-ON t.tid = s.sid
-WHEN NOT MATCHED THEN
-	INSERT INTO target DEFAULT VALUES;
+-- MERGE INTO target t
+-- USING source AS s
+-- ON t.tid = s.sid
+-- WHEN NOT MATCHED THEN
+-- 	INSERT INTO target DEFAULT VALUES;
 -- Multiple VALUES clause
-MERGE INTO target t
-USING source AS s
-ON t.tid = s.sid
-WHEN NOT MATCHED THEN
-	INSERT VALUES (1,1), (2,2);
+-- MERGE INTO target t
+-- USING source AS s
+-- ON t.tid = s.sid
+-- WHEN NOT MATCHED THEN
+-- 	INSERT VALUES (1,1), (2,2);
 -- SELECT query for INSERT
-MERGE INTO target t
-USING source AS s
-ON t.tid = s.sid
-WHEN NOT MATCHED THEN
-	INSERT SELECT (1, 1);
+-- MERGE INTO target t
+-- USING source AS s
+-- ON t.tid = s.sid
+-- WHEN NOT MATCHED THEN
+-- 	INSERT SELECT (1, 1);
 -- NOT MATCHED/UPDATE
-MERGE INTO target t
-USING source AS s
-ON t.tid = s.sid
-WHEN NOT MATCHED THEN
-	UPDATE SET balance = 0;
+-- MERGE INTO target t
+-- USING source AS s
+-- ON t.tid = s.sid
+-- WHEN NOT MATCHED THEN
+-- 	UPDATE SET balance = 0;
 -- NOT MATCHED BY TARGET/UPDATE
-MERGE INTO target t
-USING source AS s
-ON t.tid = s.sid
-WHEN NOT MATCHED BY TARGET THEN
-	UPDATE SET balance = 0;
+-- MERGE INTO target t
+-- USING source AS s
+-- ON t.tid = s.sid
+-- WHEN NOT MATCHED BY TARGET THEN
+-- 	UPDATE SET balance = 0;
 -- UPDATE tablename
-MERGE INTO target t
-USING source AS s
-ON t.tid = s.sid
-WHEN MATCHED THEN
-	UPDATE target SET balance = 0;
+-- MERGE INTO target t
+-- USING source AS s
+-- ON t.tid = s.sid
+-- WHEN MATCHED THEN
+-- 	UPDATE target SET balance = 0;
 -- source and target names the same
 MERGE INTO target
 USING target

{squawk_cli-2.12.0 → squawk_cli-2.13.0}/crates/squawk_parser/tests/data/regression_suite/tuplesort.sql

@@ -296,12 +296,12 @@ SELECT $$
 $$ AS qry ;
 
 -- test mark/restore with in-memory sorts
-EXPLAIN (COSTS OFF) 'qry';
-'qry';
+-- EXPLAIN (COSTS OFF) 'qry';
+-- 'qry';
 
 -- test mark/restore with on-disk sorts
 SET LOCAL work_mem = '100kB';
-EXPLAIN (COSTS OFF) 'qry';
-'qry';
+-- EXPLAIN (COSTS OFF) 'qry';
+-- 'qry';
 
 COMMIT;

{squawk_cli-2.12.0 → squawk_cli-2.13.0}/crates/squawk_parser/tests/snapshots/tests__delete_ok.snap

@@ -208,18 +208,20 @@ SOURCE_FILE
     USING_CLAUSE
       USING_KW "using"
       WHITESPACE " "
-      FROM_ITEM
-        NAME_REF
-          IDENT "order_items"
-        WHITESPACE " "
-        ALIAS
-          NAME
-            IDENT "oi"
+      JOIN_EXPR
+        FROM_ITEM
+          NAME_REF
+            IDENT "order_items"
+          WHITESPACE " "
+          ALIAS
+            NAME
+              IDENT "oi"
         WHITESPACE "\n  "
         JOIN
-          LEFT_KW "left"
-          WHITESPACE " "
-          JOIN_KW "join"
+          JOIN_LEFT
+            LEFT_KW "left"
+            WHITESPACE " "
+            JOIN_KW "join"
           WHITESPACE " "
           FROM_ITEM
             NAME_REF
@@ -229,24 +231,25 @@ SOURCE_FILE
               NAME
                 IDENT "o"
           WHITESPACE " "
-          ON_KW "on"
-          WHITESPACE " "
-          BIN_EXPR
-            FIELD_EXPR
-              NAME_REF
-                IDENT "oi"
-              DOT "."
-              NAME_REF
-                IDENT "order_id"
+          ON_CLAUSE
+            ON_KW "on"
             WHITESPACE " "
-            EQ "="
-            WHITESPACE " "
-            FIELD_EXPR
-              NAME_REF
-                IDENT "o"
-              DOT "."
-              NAME_REF
-                IDENT "id"
+            BIN_EXPR
+              FIELD_EXPR
+                NAME_REF
+                  IDENT "oi"
+                DOT "."
+                NAME_REF
+                  IDENT "order_id"
+              WHITESPACE " "
+              EQ "="
+              WHITESPACE " "
+              FIELD_EXPR
+                NAME_REF
+                  IDENT "o"
+                DOT "."
+                NAME_REF
+                  IDENT "id"
   SEMICOLON ";"
   WHITESPACE "\n\n"
   DELETE