Snowflake: parse LIKE/ILIKE ANY/ALL multi-pattern lists

Add an additive Expr::LikeAnyAll variant modelling
<subj> [NOT] {LIKE|ILIKE} {ANY|ALL} (p1, ..., pN) [ESCAPE e],
leaving the single-pattern Expr::Like / Expr::ILike shape untouched.
The LIKE/ILIKE infix parser now routes a parenthesized {ANY|ALL} (...)
list into the new variant.

Author: hovaesco

src/ast/mod.rs

@@ -1031,6 +1031,23 @@ pub enum Expr {
         /// Optional escape character.
         escape_char: Option<ValueWithSpan>,
     },
+    /// Snowflake `<expr> [NOT] {LIKE|ILIKE} {ANY|ALL} (<p1>, ..., <pN>) [ESCAPE <char>]`
+    /// matching a subject against a parenthesized list of patterns.
+    /// <https://docs.snowflake.com/en/sql-reference/functions/like_any>
+    LikeAnyAll {
+        /// `true` when `NOT` is present.
+        negated: bool,
+        /// `true` for `ILIKE`, `false` for `LIKE`.
+        ilike: bool,
+        /// `true` for the `ALL` quantifier, `false` for `ANY`.
+        all: bool,
+        /// Subject expression to match.
+        expr: Box<Expr>,
+        /// List of pattern expressions.
+        patterns: Vec<Expr>,
+        /// Optional escape character applied to every pattern.
+        escape_char: Option<ValueWithSpan>,
+    },
     /// `SIMILAR TO` regex
     SimilarTo {
         /// `true` when `NOT` is present.
@@ -1853,6 +1870,28 @@ impl fmt::Display for Expr {
                     pattern
                 ),
             },
+            Expr::LikeAnyAll {
+                negated,
+                ilike,
+                all,
+                expr,
+                patterns,
+                escape_char,
+            } => {
+                write!(
+                    f,
+                    "{} {}{} {} ({})",
+                    expr,
+                    if *negated { "NOT " } else { "" },
+                    if *ilike { "ILIKE" } else { "LIKE" },
+                    if *all { "ALL" } else { "ANY" },
+                    display_comma_separated(patterns),
+                )?;
+                if let Some(ch) = escape_char {
+                    write!(f, " ESCAPE {ch}")?;
+                }
+                Ok(())
+            }
             Expr::RLike {
                 negated,
                 expr,

src/ast/spans.rs

@@ -1645,6 +1645,16 @@ impl Spanned for Expr {
                 escape_char: _,
                 any: _,
             } => expr.span().union(&pattern.span()),
+            Expr::LikeAnyAll {
+                negated: _,
+                ilike: _,
+                all: _,
+                expr,
+                patterns,
+                escape_char: _,
+            } => union_spans(
+                core::iter::once(expr.span()).chain(patterns.iter().map(|p| p.span())),
+            ),
             Expr::RLike { .. } => Span::empty(),
             Expr::IsNormalized {
                 expr,

src/parser/mod.rs

@@ -4365,25 +4365,9 @@ impl<'a> Parser<'a> {
                     } else if self.parse_keyword(Keyword::BETWEEN) {
                         self.parse_between(expr, negated)
                     } else if self.parse_keyword(Keyword::LIKE) {
-                        Ok(Expr::Like {
-                            negated,
-                            any: self.parse_keyword(Keyword::ANY),
-                            expr: Box::new(expr),
-                            pattern: Box::new(
-                                self.parse_subexpr(self.dialect.prec_value(Precedence::Like))?,
-                            ),
-                            escape_char: self.parse_escape_char()?,
-                        })
+                        self.parse_like_expr(negated, false, expr)
                     } else if self.parse_keyword(Keyword::ILIKE) {
-                        Ok(Expr::ILike {
-                            negated,
-                            any: self.parse_keyword(Keyword::ANY),
-                            expr: Box::new(expr),
-                            pattern: Box::new(
-                                self.parse_subexpr(self.dialect.prec_value(Precedence::Like))?,
-                            ),
-                            escape_char: self.parse_escape_char()?,
-                        })
+                        self.parse_like_expr(negated, true, expr)
                     } else if self.parse_keywords(&[Keyword::SIMILAR, Keyword::TO]) {
                         Ok(Expr::SimilarTo {
                             negated,
@@ -4446,6 +4430,54 @@ impl<'a> Parser<'a> {
         }
     }
 
+    /// Parse the tail of a `LIKE` / `ILIKE` predicate after the keyword has
+    /// been consumed. Handles Snowflake's `{ANY|ALL} (<p1>, ..., <pN>)`
+    /// multi-pattern list form as well as the ordinary single-pattern form.
+    fn parse_like_expr(
+        &mut self,
+        negated: bool,
+        ilike: bool,
+        expr: Expr,
+    ) -> Result<Expr, ParserError> {
+        let quantifier = self.parse_one_of_keywords(&[Keyword::ANY, Keyword::ALL]);
+        if let Some(kw) = quantifier {
+            if self.consume_token(&Token::LParen) {
+                let patterns = self.parse_comma_separated0(Parser::parse_expr, Token::RParen)?;
+                self.expect_token(&Token::RParen)?;
+                return Ok(Expr::LikeAnyAll {
+                    negated,
+                    ilike,
+                    all: kw == Keyword::ALL,
+                    expr: Box::new(expr),
+                    patterns,
+                    escape_char: self.parse_escape_char()?,
+                });
+            }
+            // `ANY` without a parenthesized list falls back to the legacy
+            // single-pattern form (`ALL` has no single-pattern meaning here).
+        }
+        let any = quantifier == Some(Keyword::ANY);
+        let pattern = Box::new(self.parse_subexpr(self.dialect.prec_value(Precedence::Like))?);
+        let escape_char = self.parse_escape_char()?;
+        if ilike {
+            Ok(Expr::ILike {
+                negated,
+                any,
+                expr: Box::new(expr),
+                pattern,
+                escape_char,
+            })
+        } else {
+            Ok(Expr::Like {
+                negated,
+                any,
+                expr: Box::new(expr),
+                pattern,
+                escape_char,
+            })
+        }
+    }
+
     /// Parse the `ESCAPE CHAR` portion of `LIKE`, `ILIKE`, and `SIMILAR TO`
     pub fn parse_escape_char(&mut self) -> Result<Option<ValueWithSpan>, ParserError> {
         if self.parse_keyword(Keyword::ESCAPE) {