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

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

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

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

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

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

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

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

@@ -848,6 +848,7 @@ pub enum SyntaxKind {
     NOT_LIKE,
     NOT_NULL_CONSTRAINT,
     NOT_OF,
+    NOT_SIMILAR_TO,
     NOT_VALID,
     NO_ACTION,
     NO_FORCE_RLS,
@@ -993,6 +994,10 @@ pub enum SyntaxKind {
     WITH_CLAUSE,
     WITH_TABLE,
     WITH_TIMEZONE,
+    XML_COLUMN_OPTION,
+    XML_COLUMN_OPTION_LIST,
+    XML_TABLE_COLUMN,
+    XML_TABLE_COLUMN_LIST,
 
     #[doc(hidden)]
     __LAST,

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

@@ -27,10 +27,15 @@ fn literal(p: &mut Parser<'_>) -> Option<CompletedMarker> {
         return None;
     }
     let m = p.start();
+    if p.eat(BYTE_STRING) {
+        if p.eat(UESCAPE_KW) {
+            p.eat(STRING);
+        }
+    }
     // E021-03 string continuation syntax
     // If two string literals are next to each other, and don't have a comment
     // between them, then they are automatically combined.
-    if p.eat(STRING) {
+    else if p.eat(STRING) {
         while !p.at(EOF) && p.eat(STRING) {}
     } else {
         p.bump_any();
@@ -50,7 +55,11 @@ fn array_expr(p: &mut Parser<'_>, m: Option<Marker>) -> CompletedMarker {
         R_BRACK
     };
     while !p.at(EOF) && !p.at(closing) {
-        if p.at_ts(SELECT_FIRST) && (select(p, None).is_none() || p.at(EOF) || p.at(closing)) {
+        if p.at_ts(SELECT_FIRST)
+            && (select(p, None, &SelectRestrictions::default()).is_none()
+                || p.at(EOF)
+                || p.at(closing))
+        {
             break;
         }
         if expr(p).is_none() {
@@ -68,6 +77,18 @@ fn array_expr(p: &mut Parser<'_>, m: Option<Marker>) -> CompletedMarker {
     m.complete(p, ARRAY_EXPR)
 }
 
+struct SelectRestrictions {
+    trailing_clauses: bool,
+}
+
+impl Default for SelectRestrictions {
+    fn default() -> Self {
+        Self {
+            trailing_clauses: true,
+        }
+    }
+}
+
 fn opt_paren_select(p: &mut Parser<'_>) -> Option<CompletedMarker> {
     let m = p.start();
     if !p.eat(L_PAREN) {
@@ -78,7 +99,11 @@ fn opt_paren_select(p: &mut Parser<'_>) -> Option<CompletedMarker> {
         // saw_expr = true;
         // we want to check for select stuff before we get the the expr stuff maybe? Although select is an expr so maybe fine? but it's not prefix or postfix so maybe right here is good?
         //
-        if p.at_ts(SELECT_FIRST) && (select(p, None).is_none() || p.at(EOF) || p.at(R_PAREN)) {
+        if p.at_ts(SELECT_FIRST)
+            && (select(p, None, &SelectRestrictions::default()).is_none()
+                || p.at(EOF)
+                || p.at(R_PAREN))
+        {
             break;
         }
         if opt_paren_select(p).is_none() {
@@ -89,14 +114,13 @@ fn opt_paren_select(p: &mut Parser<'_>) -> Option<CompletedMarker> {
         }
     }
     p.expect(R_PAREN);
-    let cm = m.complete(p, PAREN_SELECT);
-    let cm = if p.at_ts(COMPOUND_SELECT_FIRST) {
-        compound_select(p, cm)
+    if p.at_ts(COMPOUND_SELECT_FIRST) {
+        let cm = m.complete(p, PAREN_SELECT);
+        Some(compound_select(p, cm))
     } else {
-        cm
-    };
-    select_trailing_clauses(p);
-    Some(cm)
+        select_trailing_clauses(p);
+        Some(m.complete(p, PAREN_SELECT))
+    }
 }
 
 const SELECT_FIRST: TokenSet = TokenSet::new(&[SELECT_KW, TABLE_KW, WITH_KW, VALUES_KW]);
@@ -116,7 +140,11 @@ fn tuple_expr(p: &mut Parser<'_>) -> CompletedMarker {
         saw_expr = true;
         // we want to check for select stuff before we get the the expr stuff maybe? Although select is an expr so maybe fine? but it's not prefix or postfix so maybe right here is good?
         //
-        if p.at_ts(SELECT_FIRST) && (select(p, None).is_none() || p.at(EOF) || p.at(R_PAREN)) {
+        if p.at_ts(SELECT_FIRST)
+            && (select(p, None, &SelectRestrictions::default()).is_none()
+                || p.at(EOF)
+                || p.at(R_PAREN))
+        {
             break;
         }
         if expr(p).is_none() {
@@ -362,10 +390,6 @@ fn substring_fn(p: &mut Parser<'_>) -> CompletedMarker {
                 if expr(p).is_none() {
                     p.error("expected an expression");
                 }
-                p.expect(ESCAPE_KW);
-                if expr(p).is_none() {
-                    p.error("expected an expression");
-                }
             }
             _ if p.eat(COMMA) => {
                 // normal function call
@@ -690,7 +714,10 @@ fn json_array_fn_arg_list(p: &mut Parser<'_>) {
     // 1, 2, 3, 4
     while !p.at(EOF) && !p.at(R_PAREN) && !p.at(RETURNING_KW) {
         if p.at_ts(SELECT_FIRST) {
-            if select(p, None).is_none() || p.at(EOF) || p.at(R_PAREN) {
+            if select(p, None, &SelectRestrictions::default()).is_none()
+                || p.at(EOF)
+                || p.at(R_PAREN)
+            {
                 break;
             }
             opt_json_format_clause(p);
@@ -731,7 +758,7 @@ fn some_any_all_fn(p: &mut Parser<'_>) -> CompletedMarker {
     // args
     p.expect(L_PAREN);
     if p.at_ts(SELECT_FIRST) {
-        select(p, None);
+        select(p, None, &SelectRestrictions::default());
     } else {
         if expr(p).is_none() {
             p.error("expected expression or select");
@@ -825,7 +852,7 @@ fn exists_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(EXISTS_KW));
     custom_fn(p, EXISTS_KW, |p| {
         if p.at_ts(SELECT_FIRST) {
-            select(p, None);
+            select(p, None, &SelectRestrictions::default());
         } else {
             p.error("expected select")
         }
@@ -882,9 +909,6 @@ fn opt_xml_passing_mech(p: &mut Parser<'_>) -> bool {
 }
 
 fn xmlexists_arg(p: &mut Parser<'_>) {
-    if expr(p).is_none() {
-        p.error("expected expression");
-    }
     p.expect(PASSING_KW);
     opt_xml_passing_mech(p);
     if expr(p).is_none() {
@@ -905,6 +929,9 @@ fn xmlexists_arg(p: &mut Parser<'_>) {
 fn xmlexists_fn(p: &mut Parser<'_>) -> CompletedMarker {
     assert!(p.at(XMLEXISTS_KW));
     custom_fn(p, XMLEXISTS_KW, |p| {
+        if expr(p).is_none() {
+            p.error("expected expression");
+        }
         xmlexists_arg(p);
     })
 }
@@ -979,7 +1006,7 @@ fn xmlserialize_fn(p: &mut Parser<'_>) -> CompletedMarker {
             p.error("expected expression");
         }
         p.expect(AS_KW);
-        simple_type_name(p);
+        type_name(p);
         if p.eat(NO_KW) {
             p.expect(INDENT_KW);
         } else {
@@ -1462,7 +1489,13 @@ fn opt_name(p: &mut Parser<'_>) -> Option<CompletedMarker> {
         return None;
     }
     let m = p.start();
-    p.bump_any();
+    if p.eat(IDENT) {
+        if p.eat(UESCAPE_KW) {
+            p.expect(STRING);
+        }
+    } else {
+        p.bump_any();
+    }
     Some(m.complete(p, NAME))
 }
 
@@ -2156,10 +2189,14 @@ fn current_op(p: &Parser<'_>, r: &Restrictions) -> (u8, SyntaxKind, Associativit
         PLUS if p.next_not_joined_op(0) => (8, PLUS, Left), // symbol
         // overlaps
         OVERLAPS_KW => (7, OVERLAPS_KW, Left),
+        // escape
+        ESCAPE_KW => (7, ESCAPE_KW, Left),
         // like
         LIKE_KW => (6, LIKE_KW, Left),
         // ilike
         ILIKE_KW => (6, ILIKE_KW, Left),
+        // not similar to
+        NOT_KW if !r.not_disabled && p.at(NOT_SIMILAR_TO) => (6, NOT_SIMILAR_TO, Left),
         // not like
         NOT_KW if !r.not_disabled && p.at(NOT_LIKE) => (6, NOT_LIKE, Left),
         // not ilike
@@ -2446,18 +2483,25 @@ fn compound_select(p: &mut Parser<'_>, cm: CompletedMarker) -> CompletedMarker {
         opt_paren_select(p);
     } else {
         if p.at_ts(SELECT_FIRST) {
-            select(p, None);
+            select(
+                p,
+                None,
+                &SelectRestrictions {
+                    trailing_clauses: false,
+                },
+            );
         } else {
             p.error("expected start of a select statement")
         }
     }
+    select_trailing_clauses(p);
     m.complete(p, COMPOUND_SELECT)
 }
 
 // error recovery:
 // - <https://youtu.be/0HlrqwLjCxA?feature=shared&t=2172>
 /// <https://www.postgresql.org/docs/17/sql-select.html>
-fn select(p: &mut Parser, m: Option<Marker>) -> Option<CompletedMarker> {
+fn select(p: &mut Parser, m: Option<Marker>, r: &SelectRestrictions) -> Option<CompletedMarker> {
     assert!(p.at_ts(SELECT_FIRST));
     let m = m.unwrap_or_else(|| p.start());
 
@@ -2495,7 +2539,9 @@ 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);
+    if r.trailing_clauses {
+        select_trailing_clauses(p);
+    }
     Some(m.complete(p, out_kind))
 }
 
@@ -2898,14 +2944,15 @@ fn data_source(p: &mut Parser<'_>) {
                 p.expect(L_PAREN);
                 xml_namespace_list(p);
                 p.expect(R_PAREN);
+                p.expect(COMMA);
             }
             if expr(p).is_none() {
                 p.error("expected expression");
             }
             xmlexists_arg(p);
-            p.expect(COLUMNS_KW);
             xmltable_column_list(p);
             p.expect(R_PAREN);
+            opt_alias(p);
         }
         ROWS_KW if p.nth_at(1, FROM_KW) => {
             p.bump(ROWS_KW);
@@ -2940,13 +2987,17 @@ fn data_source(p: &mut Parser<'_>) {
 }
 
 fn xmltable_column_list(p: &mut Parser<'_>) {
+    let m = p.start();
+    p.expect(COLUMNS_KW);
     xmltable_column_el(p);
     while !p.at(EOF) && p.eat(COMMA) {
         xmltable_column_el(p);
     }
+    m.complete(p, XML_TABLE_COLUMN_LIST);
 }
 
 fn xmltable_column_el(p: &mut Parser<'_>) {
+    let m = p.start();
     name(p);
     if p.eat(FOR_KW) {
         p.expect(ORDINALITY_KW);
@@ -2954,20 +3005,21 @@ fn xmltable_column_el(p: &mut Parser<'_>) {
         type_name(p);
         opt_xmltable_column_option_list(p);
     }
+    m.complete(p, XML_TABLE_COLUMN);
 }
 
 fn opt_xmltable_column_option_list(p: &mut Parser<'_>) {
-    if opt_xmltable_column_option_el(p) {
+    let m = p.start();
+    if opt_xmltable_column_option_el(p).is_none() {
+        m.abandon(p);
         return;
     }
-    while !p.at(EOF) && p.eat(COMMA) {
-        if !opt_xmltable_column_option_el(p) {
-            p.error("expected column option");
-        }
-    }
+    while !p.at(EOF) && opt_xmltable_column_option_el(p).is_some() {}
+    m.complete(p, XML_COLUMN_OPTION_LIST);
 }
 
-fn opt_xmltable_column_option_el(p: &mut Parser<'_>) -> bool {
+fn opt_xmltable_column_option_el(p: &mut Parser<'_>) -> Option<CompletedMarker> {
+    let m = p.start();
     match p.current() {
         DEFAULT_KW | PATH_KW | IDENT => {
             p.bump_any();
@@ -2982,9 +3034,12 @@ fn opt_xmltable_column_option_el(p: &mut Parser<'_>) -> bool {
         NULL_KW => {
             p.bump(NULL_KW);
         }
-        _ => return false,
+        _ => {
+            m.abandon(p);
+            return None;
+        }
     }
-    true
+    Some(m.complete(p, XML_COLUMN_OPTION))
 }
 
 fn xml_namespace_list(p: &mut Parser<'_>) {
@@ -5319,7 +5374,7 @@ fn stmt(p: &mut Parser, r: &StmtRestrictions) -> Option<CompletedMarker> {
         (ROLLBACK_KW, _) => Some(rollback(p)),
         (SAVEPOINT_KW, _) => Some(savepoint(p)),
         (SECURITY_KW, LABEL_KW) => Some(security_label(p)),
-        (SELECT_KW | TABLE_KW | VALUES_KW, _) => select(p, None),
+        (SELECT_KW | TABLE_KW | VALUES_KW, _) => select(p, None, &SelectRestrictions::default()),
         (SET_KW, CONSTRAINTS_KW) => Some(set_constraints(p)),
         (SET_KW, LOCAL_KW) => match p.nth(2) {
             ROLE_KW => Some(set_role(p)),
@@ -11986,7 +12041,9 @@ 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()) && opt_paren_select(p).is_none() {
+    if (!p.at_ts(SELECT_FIRST) || select(p, None, &SelectRestrictions::default()).is_none())
+        && opt_paren_select(p).is_none()
+    {
         p.error("expected select stmt")
     }
 }
@@ -12107,7 +12164,7 @@ fn set_clause(p: &mut Parser<'_>) {
             if p.eat(L_PAREN) {
                 // ( sub-SELECT )
                 if p.at(SELECT_KW) && !found_row {
-                    if select(p, None).is_none() {
+                    if select(p, None, &SelectRestrictions::default()).is_none() {
                         p.error("expected sub-SELECT");
                     }
                 } else {
@@ -12202,7 +12259,7 @@ fn with(p: &mut Parser<'_>, m: Option<Marker>) -> Option<CompletedMarker> {
     with_query_clause(p);
     match p.current() {
         DELETE_KW => Some(delete(p, Some(m))),
-        SELECT_KW | TABLE_KW | VALUES_KW => select(p, Some(m)),
+        SELECT_KW | TABLE_KW | VALUES_KW => select(p, Some(m), &SelectRestrictions::default()),
         INSERT_KW => Some(insert(p, Some(m))),
         UPDATE_KW => Some(update(p, Some(m))),
         MERGE_KW => Some(merge(p, Some(m))),
@@ -13098,6 +13155,10 @@ fn set(p: &mut Parser<'_>) -> CompletedMarker {
     let m = p.start();
     p.bump(SET_KW);
     let _ = p.eat(SESSION_KW) || p.eat(LOCAL_KW);
+    if p.eat(XML_KW) {
+        p.expect(OPTION_KW);
+        let _ = p.eat(DOCUMENT_KW) || p.eat(CONTENT_KW);
+    } else
     // TIME ZONE { value | 'value' | LOCAL | DEFAULT }
     if p.eat(TIME_KW) {
         p.expect(ZONE_KW);
@@ -13714,7 +13775,13 @@ fn alter_table_action(p: &mut Parser<'_>) -> Option<SyntaxKind> {
 fn opt_col_label(p: &mut Parser<'_>) -> bool {
     if p.at_ts(COL_LABEL_FIRST) {
         let m = p.start();
-        p.bump_any();
+        if p.eat(IDENT) {
+            if p.eat(UESCAPE_KW) {
+                p.expect(STRING);
+            }
+        } else {
+            p.bump_any();
+        }
         m.complete(p, NAME);
         true
     } else {

{squawk_cli-2.13.0 → squawk_cli-2.14.0}/crates/squawk_parser/src/lib.rs

@@ -343,6 +343,14 @@ impl<'t> Parser<'t> {
                 m.complete(self, SyntaxKind::IS_JSON_SCALAR);
                 return true;
             }
+            SyntaxKind::NOT_SIMILAR_TO => {
+                let m = self.start();
+                self.bump(SyntaxKind::NOT_KW);
+                self.bump(SyntaxKind::SIMILAR_KW);
+                self.bump(SyntaxKind::TO_KW);
+                m.complete(self, SyntaxKind::NOT_SIMILAR_TO);
+                return true;
+            }
             SyntaxKind::IS_NOT_DISTINCT_FROM => {
                 let m = self.start();
                 self.bump(SyntaxKind::IS_KW);
@@ -767,6 +775,12 @@ impl<'t> Parser<'t> {
                 }
                 return false;
             }
+            SyntaxKind::NOT_SIMILAR_TO => self.at_composite3(
+                n,
+                SyntaxKind::NOT_KW,
+                SyntaxKind::SIMILAR_KW,
+                SyntaxKind::TO_KW,
+            ),
             // similar to
             SyntaxKind::SIMILAR_TO => self.at_composite2(
                 n,

{squawk_cli-2.13.0 → squawk_cli-2.14.0}/crates/squawk_parser/tests/data/ok/precedence.sql

@@ -3,7 +3,6 @@ SELECT (((SELECT 2)) + 3);
 SELECT (((SELECT 2)) UNION SELECT 2);
 
 
--- TODO!
 SELECT foo UNION SELECT bar ORDER BY baz;
 -- equal to:
 (SELECT foo UNION SELECT bar) ORDER BY baz;

{squawk_cli-2.13.0 → squawk_cli-2.14.0}/crates/squawk_parser/tests/data/ok/select_operators.sql

@@ -180,9 +180,17 @@ select U&'\0061\0308bc' is not nfd normalized;
 -- pattern_matching
 -- like
 select 'foo' like 'bar';
-
+select 'foo' like 'bar' escape '#';
 -- not like
 select 'foo' not like 'bar';
+select 'foo' not like 'bar' escape '#';
+
+-- ilike
+select 'foo' ilike 'bar';
+select 'foo' ilike 'bar' escape '#';
+-- not ilike
+select 'foo' not ilike 'bar';
+select 'foo' not ilike 'bar' escape '#';
 
 -- ~~
 select 'a' ~~ 'b';
@@ -192,6 +200,10 @@ select 'a' !~~ 'b';
 
 -- similar to
 select 'abc' similar to 'abc';
+select 'abc' similar to 'abc' escape '#';
+
+select 'abc' not similar to 'abc';
+select 'abc' not similar to 'abc' escape '#';
 
 -- posix regex
 -- string matches regex case sensitive

{squawk_cli-2.13.0 → squawk_cli-2.14.0}/crates/squawk_parser/tests/data/regression_suite/strings.sql

@@ -28,7 +28,7 @@ SELECT 'tricky' AS U&"\" UESCAPE '!';
 
 SELECT U&'wrong: \061';
 SELECT U&'wrong: \+0061';
-SELECT U&'wrong: +0061' UESCAPE +;
+-- SELECT U&'wrong: +0061' UESCAPE +;
 SELECT U&'wrong: +0061' UESCAPE '+';
 
 SELECT U&'wrong: \db99';

{squawk_cli-2.13.0 → squawk_cli-2.14.0}/crates/squawk_parser/tests/snapshots/tests__precedence_ok.snap

@@ -73,8 +73,6 @@ SOURCE_FILE
             R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n\n"
-  COMMENT "-- TODO!"
-  WHITESPACE "\n"
   COMPOUND_SELECT
     SELECT
       SELECT_CLAUSE
@@ -95,14 +93,14 @@ SOURCE_FILE
           TARGET
             NAME_REF
               IDENT "bar"
+    WHITESPACE " "
+    ORDER_BY_CLAUSE
+      ORDER_KW "ORDER"
       WHITESPACE " "
-      ORDER_BY_CLAUSE
-        ORDER_KW "ORDER"
-        WHITESPACE " "
-        BY_KW "BY"
-        WHITESPACE " "
-        NAME_REF
-          IDENT "baz"
+      BY_KW "BY"
+      WHITESPACE " "
+      NAME_REF
+        IDENT "baz"
   SEMICOLON ";"
   WHITESPACE "\n"
   COMMENT "-- equal to:"
@@ -130,13 +128,13 @@ SOURCE_FILE
               NAME_REF
                 IDENT "bar"
     R_PAREN ")"
-  WHITESPACE " "
-  ORDER_BY_CLAUSE
-    ORDER_KW "ORDER"
-    WHITESPACE " "
-    BY_KW "BY"
     WHITESPACE " "
-    NAME_REF
-      IDENT "baz"
+    ORDER_BY_CLAUSE
+      ORDER_KW "ORDER"
+      WHITESPACE " "
+      BY_KW "BY"
+      WHITESPACE " "
+      NAME_REF
+        IDENT "baz"
   SEMICOLON ";"
   WHITESPACE "\n"

squawk_cli-2.14.0/crates/squawk_parser/tests/snapshots/tests__regression_strings.snap

@@ -0,0 +1,5 @@
+---
+source: crates/squawk_parser/tests/tests.rs
+input_file: crates/squawk_parser/tests/data/regression_suite/strings.sql
+---
+

squawk_cli-2.14.0/crates/squawk_parser/tests/snapshots/tests__regression_suite_errors.snap

@@ -0,0 +1,5 @@
+---
+source: crates/squawk_parser/tests/tests.rs
+expression: "out.join(\"\\n\")"
+---
+

squawk_cli-2.14.0/crates/squawk_parser/tests/snapshots/tests__regression_xml.snap

@@ -0,0 +1,5 @@
+---
+source: crates/squawk_parser/tests/tests.rs
+input_file: crates/squawk_parser/tests/data/regression_suite/xml.sql
+---
+

{squawk_cli-2.13.0 → squawk_cli-2.14.0}/crates/squawk_parser/tests/snapshots/tests__select_compound_union_select_ok.snap

@@ -236,22 +236,22 @@ SOURCE_FILE
                     WHITESPACE " "
                     LITERAL
                       STRING "'nl-NL'"
+              WHITESPACE " "
+              ORDER_BY_CLAUSE
+                ORDER_KW "ORDER"
                 WHITESPACE " "
-                ORDER_BY_CLAUSE
-                  ORDER_KW "ORDER"
-                  WHITESPACE " "
-                  BY_KW "BY"
-                  WHITESPACE " "
-                  NAME_REF
-                    IDENT "\"id\""
-                  WHITESPACE " "
-                  ASC_KW "ASC"
+                BY_KW "BY"
                 WHITESPACE " "
-                LIMIT_CLAUSE
-                  LIMIT_KW "LIMIT"
-                  WHITESPACE " "
-                  LITERAL
-                    INT_NUMBER "1"
+                NAME_REF
+                  IDENT "\"id\""
+                WHITESPACE " "
+                ASC_KW "ASC"
+              WHITESPACE " "
+              LIMIT_CLAUSE
+                LIMIT_KW "LIMIT"
+                WHITESPACE " "
+                LITERAL
+                  INT_NUMBER "1"
             WHITESPACE "\n"
             R_PAREN ")"
     WHITESPACE " "

{squawk_cli-2.13.0 → squawk_cli-2.14.0}/crates/squawk_parser/tests/snapshots/tests__select_funcs_ok.snap

@@ -730,13 +730,14 @@ SOURCE_FILE
               WHITESPACE " "
               SIMILAR_KW "similar"
               WHITESPACE " "
-              NAME_REF
-                IDENT "b"
-              WHITESPACE " "
-              ESCAPE_KW "escape"
-              WHITESPACE " "
-              NAME_REF
-                IDENT "c"
+              BIN_EXPR
+                NAME_REF
+                  IDENT "b"
+                WHITESPACE " "
+                ESCAPE_KW "escape"
+                WHITESPACE " "
+                NAME_REF
+                  IDENT "c"
               R_PAREN ")"
   SEMICOLON ";"
   WHITESPACE "\n\n"