databricks: RLIKE, raw strings, single quote escapes

Author: lustefaniak

src/ast/mod.rs

@@ -555,6 +555,13 @@ pub enum Expr {
         pattern: Box<Expr>,
         escape_char: Option<char>,
     },
+    /// RLIKE
+    RLike {
+        negated: bool,
+        expr: Box<Expr>,
+        pattern: Box<Expr>,
+        escape_char: Option<char>,
+    },
     /// REGEXP
     /// Snowflake: <subject> REGEXP <pattern>
     /// https://docs.snowflake.com/en/sql-reference/functions/regexp
@@ -878,6 +885,28 @@ impl fmt::Display for Expr {
                     pattern
                 ),
             },
+            Expr::RLike {
+                negated,
+                expr,
+                pattern,
+                escape_char,
+            } => match escape_char {
+                Some(ch) => write!(
+                    f,
+                    "{} {}RLIKE {} ESCAPE '{}'",
+                    expr,
+                    if *negated { "NOT " } else { "" },
+                    pattern,
+                    ch
+                ),
+                _ => write!(
+                    f,
+                    "{} {}RLIKE {}",
+                    expr,
+                    if *negated { "NOT " } else { "" },
+                    pattern
+                ),
+            },
             Expr::ILike {
                 negated,
                 expr,

src/keywords.rs

@@ -540,6 +540,7 @@ define_keywords!(
     RETURNS,
     REVOKE,
     RIGHT,
+    RLIKE,
     ROLE,
     ROLLBACK,
     ROLLUP,

src/parser/mod.rs

@@ -2056,6 +2056,7 @@ impl<'a> Parser<'a> {
                 | Keyword::BETWEEN
                 | Keyword::LIKE
                 | Keyword::ILIKE
+                | Keyword::RLIKE
                 | Keyword::SIMILAR
                 | Keyword::REGEXP => {
                     self.prev_token();
@@ -2084,6 +2085,13 @@ impl<'a> Parser<'a> {
                             pattern: Box::new(self.parse_subexpr(Self::LIKE_PREC)?),
                             escape_char: self.parse_escape_char()?,
                         })
+                    } else if self.parse_keyword(Keyword::RLIKE) {
+                        Ok(Expr::RLike {
+                            negated,
+                            expr: Box::new(expr),
+                            pattern: Box::new(self.parse_subexpr(Self::LIKE_PREC)?),
+                            escape_char: self.parse_escape_char()?,
+                        })
                     } else if self.parse_keywords(&[Keyword::SIMILAR, Keyword::TO]) {
                         Ok(Expr::SimilarTo {
                             negated,
@@ -2377,6 +2385,7 @@ impl<'a> Parser<'a> {
                 Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(Self::BETWEEN_PREC),
                 Token::Word(w) if w.keyword == Keyword::LIKE => Ok(Self::LIKE_PREC),
                 Token::Word(w) if w.keyword == Keyword::ILIKE => Ok(Self::LIKE_PREC),
+                Token::Word(w) if w.keyword == Keyword::RLIKE => Ok(Self::LIKE_PREC),
                 Token::Word(w) if w.keyword == Keyword::SIMILAR => Ok(Self::LIKE_PREC),
                 Token::Word(w) if w.keyword == Keyword::REGEXP => Ok(Self::LIKE_PREC),
                 _ => Ok(0),
@@ -2386,6 +2395,7 @@ impl<'a> Parser<'a> {
             Token::Word(w) if w.keyword == Keyword::BETWEEN => Ok(Self::BETWEEN_PREC),
             Token::Word(w) if w.keyword == Keyword::LIKE => Ok(Self::LIKE_PREC),
             Token::Word(w) if w.keyword == Keyword::ILIKE => Ok(Self::LIKE_PREC),
+            Token::Word(w) if w.keyword == Keyword::RLIKE => Ok(Self::LIKE_PREC),
             Token::Word(w) if w.keyword == Keyword::SIMILAR => Ok(Self::LIKE_PREC),
             Token::Word(w) if w.keyword == Keyword::REGEXP => Ok(Self::LIKE_PREC),
             Token::Word(w) if w.keyword == Keyword::OPERATOR => Ok(Self::BETWEEN_PREC),

src/tokenizer.rs

@@ -38,8 +38,8 @@ use sqlparser_derive::{Visit, VisitMut};
 
 use crate::ast::DollarQuotedString;
 use crate::dialect::{
-    BigQueryDialect, DuckDbDialect, GenericDialect, HiveDialect, RedshiftSqlDialect,
-    SnowflakeDialect,
+    BigQueryDialect, DatabricksDialect, DuckDbDialect, GenericDialect, HiveDialect,
+    RedshiftSqlDialect, SnowflakeDialect,
 };
 use crate::dialect::{Dialect, MySqlDialect};
 use crate::keywords::{Keyword, ALL_KEYWORDS, ALL_KEYWORDS_INDEX};
@@ -731,7 +731,8 @@ impl<'a> Tokenizer<'a> {
                     }
                 }
                 // BigQuery uses r or R for raw string literal
-                b @ 'R' | b @ 'r' if dialect_of!(self is BigQueryDialect | GenericDialect) => {
+                b @ 'R' | b @ 'r' if dialect_of!(self is BigQueryDialect | GenericDialect | DatabricksDialect) =>
+                {
                     chars.next(); // consume
                     match chars.peek() {
                         Some('\'') => {
@@ -1366,7 +1367,8 @@ impl<'a> Tokenizer<'a> {
                     // consume
                     chars.next();
                     // slash escaping is specific to MySQL / BigQuery dialect.
-                    if dialect_of!(self is MySqlDialect | BigQueryDialect | RedshiftSqlDialect) {
+                    if dialect_of!(self is MySqlDialect | BigQueryDialect | RedshiftSqlDialect | DatabricksDialect)
+                    {
                         if let Some(next) = chars.peek() {
                             if !self.unescape {
                                 // In no-escape mode, the given query has to be saved completely including backslashes.

tests/sqlparser_databricks.rs

@@ -18,6 +18,7 @@
 use pretty_assertions::assert_eq;
 use sqlparser::ast::*;
 use sqlparser::dialect::{DatabricksDialect, GenericDialect};
+use sqlparser::parser::ParserOptions;
 use test_utils::*;
 
 #[macro_use]
@@ -37,6 +38,13 @@ fn databricks_and_generic() -> TestedDialects {
     }
 }
 
+fn databricks_unescaped() -> TestedDialects {
+    TestedDialects {
+        dialects: vec![Box::new(DatabricksDialect {})],
+        options: Some(ParserOptions::new().with_unescape(false)),
+    }
+}
+
 #[test]
 fn test_databricks_create_table() {
     let sql = "CREATE TABLE main.dbt_lukasz.customers (customer_id BIGINT, customer_lifetime_value DOUBLE) USING delta TBLPROPERTIES ('delta.minReaderVersion' = '3', 'delta.minWriterVersion' = '7')";
@@ -53,3 +61,20 @@ fn test_identifiers() {
     let sql = "SELECT * FROM `main`.`dbt_lukasz`.`raw_orders`";
     databricks().verified_stmt(sql);
 }
+
+#[test]
+fn test_string_escape() {
+    databricks().one_statement_parses_to(r#"SELECT 'O\'Connell'"#, r#"SELECT 'O''Connell'"#);
+}
+
+#[test]
+fn test_string_raw_literal() {
+    let sql = r#"SELECT R'Some\nText'"#;
+    databricks_unescaped().verified_stmt(sql);
+}
+
+#[test]
+fn test_rlike() {
+    let sql = r#"SELECT R'%SystemDrive%\Users\John' RLIKE R'%SystemDrive%\\Users.*'"#;
+    databricks_unescaped().verified_stmt(sql);
+}