snowflake: handle like ... escape ...

Author: donhcd

src/ast/mod.rs

@@ -184,6 +184,14 @@ pub enum Expr {
         low: Box<Expr>,
         high: Box<Expr>,
     },
+    /// `<expr> [I]LIKE <pattern> [ ESCAPE <escape> ]`
+    Like {
+        expr: Box<Expr>,
+        case_sensitive: bool,
+        negated: bool,
+        pat: Box<Expr>,
+        esc: Option<Box<Expr>>,
+    },
     /// Binary operation e.g. `1 + 1` or `foo > bar`
     BinaryOp {
         left: Box<Expr>,
@@ -286,6 +294,27 @@ impl fmt::Display for Expr {
                 low,
                 high
             ),
+            Expr::Like {
+                expr,
+                case_sensitive,
+                negated,
+                pat,
+                esc,
+            } => {
+                write!(
+                    f,
+                    "{} {}{}LIKE {}",
+                    expr,
+                    if *negated { "NOT " } else { "" },
+                    if *case_sensitive { "" } else { "I" },
+                    pat,
+                )?;
+                if let Some(esc) = esc {
+                    write!(f, "ESCAPE {}", esc)
+                } else {
+                    Ok(())
+                }
+            }
             Expr::BinaryOp { left, op, right } => write!(f, "{} {} {}", left, op, right),
             Expr::UnaryOp { op, expr } => {
                 if op == &UnaryOperator::PGPostfixFactorial {

src/ast/operator.rs

@@ -69,10 +69,8 @@ pub enum BinaryOperator {
     NotEq,
     And,
     Or,
-    Ilike,
-    Like,
-    NotLike,
-    NotIlike,
+    Rlike,
+    NotRlike,
     JsonIndex,
     BitwiseOr,
     BitwiseAnd,
@@ -99,10 +97,8 @@ impl fmt::Display for BinaryOperator {
             BinaryOperator::NotEq => "<>",
             BinaryOperator::And => "AND",
             BinaryOperator::Or => "OR",
-            BinaryOperator::Like => "LIKE",
-            BinaryOperator::Ilike => "ILIKE",
-            BinaryOperator::NotLike => "NOT LIKE",
-            BinaryOperator::NotIlike => "NOT ILIKE",
+            BinaryOperator::Rlike => "RLIKE",
+            BinaryOperator::NotRlike => "NOT RLIKE",
             BinaryOperator::JsonIndex => ":",
             BinaryOperator::BitwiseOr => "|",
             BinaryOperator::BitwiseAnd => "&",

src/dialect/keywords.rs

@@ -363,6 +363,7 @@ define_keywords!(
     RETURNS,
     REVOKE,
     RIGHT,
+    RLIKE,
     ROLLBACK,
     ROLLUP,
     ROW,

src/parser.rs

@@ -729,13 +729,10 @@ impl<'a> Parser<'a> {
             Token::Word(w) => match w.keyword {
                 Keyword::AND => Some(BinaryOperator::And),
                 Keyword::OR => Some(BinaryOperator::Or),
-                Keyword::LIKE => Some(BinaryOperator::Like),
-                Keyword::ILIKE => Some(BinaryOperator::Ilike),
+                Keyword::RLIKE => Some(BinaryOperator::Rlike),
                 Keyword::NOT => {
-                    if self.parse_keyword(Keyword::LIKE) {
-                        Some(BinaryOperator::NotLike)
-                    } else if self.parse_keyword(Keyword::ILIKE) {
-                        Some(BinaryOperator::NotIlike)
+                    if self.parse_keyword(Keyword::RLIKE) {
+                        Some(BinaryOperator::NotRlike)
                     } else {
                         None
                     }
@@ -762,15 +759,19 @@ impl<'a> Parser<'a> {
                         self.expected("NULL or NOT NULL after IS", self.peek_token())
                     }
                 }
-                Keyword::NOT | Keyword::IN | Keyword::BETWEEN => {
+                Keyword::NOT | Keyword::IN | Keyword::BETWEEN | Keyword::LIKE | Keyword::ILIKE => {
                     self.prev_token();
                     let negated = self.parse_keyword(Keyword::NOT);
                     if self.parse_keyword(Keyword::IN) {
                         self.parse_in(expr, negated)
                     } else if self.parse_keyword(Keyword::BETWEEN) {
                         self.parse_between(expr, negated)
+                    } else if self.parse_keyword(Keyword::LIKE) {
+                        self.parse_like(expr, true, negated)
+                    } else if self.parse_keyword(Keyword::ILIKE) {
+                        self.parse_like(expr, false, negated)
                     } else {
-                        self.expected("IN or BETWEEN after NOT", self.peek_token())
+                        self.expected("IN or BETWEEN or [I]LIKE after NOT", self.peek_token())
                     }
                 }
                 // Can only happen if `get_next_precedence` got out of sync with this function
@@ -826,6 +827,29 @@ impl<'a> Parser<'a> {
         })
     }
 
+    /// Parses [I]LIKE <pattern> [ ESCAPE <escape> ]
+    /// https://docs.snowflake.com/en/sql-reference/functions/ilike.html
+    pub fn parse_like(
+        &mut self,
+        expr: Expr,
+        case_sensitive: bool,
+        negated: bool,
+    ) -> Result<Expr, ParserError> {
+        let pat = self.parse_expr()?;
+        let esc = if self.parse_keyword(Keyword::ESCAPE) {
+            Some(self.parse_expr()?)
+        } else {
+            None
+        };
+        Ok(Expr::Like {
+            expr: Box::new(expr),
+            case_sensitive,
+            negated,
+            pat: Box::new(pat),
+            esc: esc.map(Box::new),
+        })
+    }
+
     /// Parse a postgresql casting style which is in the form of `expr::datatype`
     pub fn parse_pg_cast(&mut self, expr: Expr) -> Result<Expr, ParserError> {
         Ok(Expr::Cast {
@@ -853,15 +877,23 @@ impl<'a> Parser<'a> {
                 // precedence.
                 Token::Word(w) if w.keyword == Keyword::IN => Ok(Self::BETWEEN_PREC),
                 Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(Self::BETWEEN_PREC),
-                Token::Word(w) if w.keyword == Keyword::LIKE || w.keyword == Keyword::ILIKE => {
+                Token::Word(w)
+                    if w.keyword == Keyword::LIKE
+                        || w.keyword == Keyword::ILIKE
+                        || w.keyword == Keyword::RLIKE =>
+                {
                     Ok(Self::BETWEEN_PREC)
                 }
                 _ => Ok(0),
             },
             Token::Word(w) if w.keyword == Keyword::IS => Ok(17),
             Token::Word(w) if w.keyword == Keyword::IN => Ok(Self::BETWEEN_PREC),
             Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(Self::BETWEEN_PREC),
-            Token::Word(w) if w.keyword == Keyword::LIKE || w.keyword == Keyword::ILIKE => {
+            Token::Word(w)
+                if w.keyword == Keyword::LIKE
+                    || w.keyword == Keyword::ILIKE
+                    || w.keyword == Keyword::RLIKE =>
+            {
                 Ok(Self::BETWEEN_PREC)
             }
             Token::Eq | Token::Lt | Token::LtEq | Token::Neq | Token::Gt | Token::GtEq => Ok(20),