feat(parser): parse [!]~~[*] operators to [NOT] [I]LIKE (#11748)

Signed-off-by: TennyZhuang <[email protected]>

Author: TennyZhuang

src/sqlparser/src/parser.rs

@@ -1333,6 +1333,10 @@ impl Parser {
             Token::TildeAsterisk => Some(BinaryOperator::PGRegexIMatch),
             Token::ExclamationMarkTilde => Some(BinaryOperator::PGRegexNotMatch),
             Token::ExclamationMarkTildeAsterisk => Some(BinaryOperator::PGRegexNotIMatch),
+            Token::DoubleTilde => Some(BinaryOperator::Like),
+            Token::DoubleTildeAsterisk => Some(BinaryOperator::ILike),
+            Token::ExclamationMarkDoubleTilde => Some(BinaryOperator::NotLike),
+            Token::ExclamationMarkDoubleTildeAsterisk => Some(BinaryOperator::NotILike),
             Token::Arrow => Some(BinaryOperator::Arrow),
             Token::LongArrow => Some(BinaryOperator::LongArrow),
             Token::HashArrow => Some(BinaryOperator::HashArrow),
@@ -1625,6 +1629,10 @@ impl Parser {
             | Token::TildeAsterisk
             | Token::ExclamationMarkTilde
             | Token::ExclamationMarkTildeAsterisk
+            | Token::DoubleTilde
+            | Token::DoubleTildeAsterisk
+            | Token::ExclamationMarkDoubleTilde
+            | Token::ExclamationMarkDoubleTildeAsterisk
             | Token::Concat
             | Token::Prefix
             | Token::Arrow

src/sqlparser/src/tokenizer.rs

@@ -134,6 +134,14 @@ pub enum Token {
     ExclamationMarkTilde,
     /// `!~*` , a case insensitive not match regular expression operator in PostgreSQL
     ExclamationMarkTildeAsterisk,
+    /// `~~`, a case sensitive LIKE expression operator in PostgreSQL
+    DoubleTilde,
+    /// `~~*` , a case insensitive ILIKE regular expression operator in PostgreSQL
+    DoubleTildeAsterisk,
+    /// `!~~` , a case sensitive NOT LIKE regular expression operator in PostgreSQL
+    ExclamationMarkDoubleTilde,
+    /// `!~~*` , a case insensitive NOT ILIKE regular expression operator in PostgreSQL
+    ExclamationMarkDoubleTildeAsterisk,
     /// `<<`, a bitwise shift left operator in PostgreSQL
     ShiftLeft,
     /// `>>`, a bitwise shift right operator in PostgreSQL
@@ -210,6 +218,10 @@ impl fmt::Display for Token {
             Token::TildeAsterisk => f.write_str("~*"),
             Token::ExclamationMarkTilde => f.write_str("!~"),
             Token::ExclamationMarkTildeAsterisk => f.write_str("!~*"),
+            Token::DoubleTilde => f.write_str("~~"),
+            Token::DoubleTildeAsterisk => f.write_str("~~*"),
+            Token::ExclamationMarkDoubleTilde => f.write_str("!~~"),
+            Token::ExclamationMarkDoubleTildeAsterisk => f.write_str("!~~*"),
             Token::AtSign => f.write_str("@"),
             Token::ShiftLeft => f.write_str("<<"),
             Token::ShiftRight => f.write_str(">>"),
@@ -651,6 +663,16 @@ impl<'a> Tokenizer<'a> {
                         Some('~') => {
                             chars.next();
                             match chars.peek() {
+                                Some('~') => {
+                                    chars.next();
+                                    match chars.peek() {
+                                        Some('*') => self.consume_and_return(
+                                            chars,
+                                            Token::ExclamationMarkDoubleTildeAsterisk,
+                                        ),
+                                        _ => Ok(Some(Token::ExclamationMarkDoubleTilde)),
+                                    }
+                                }
                                 Some('*') => self
                                     .consume_and_return(chars, Token::ExclamationMarkTildeAsterisk),
                                 _ => Ok(Some(Token::ExclamationMarkTilde)),
@@ -707,6 +729,15 @@ impl<'a> Tokenizer<'a> {
                 '~' => {
                     chars.next(); // consume
                     match chars.peek() {
+                        Some('~') => {
+                            chars.next();
+                            match chars.peek() {
+                                Some('*') => {
+                                    self.consume_and_return(chars, Token::DoubleTildeAsterisk)
+                                }
+                                _ => Ok(Some(Token::DoubleTilde)),
+                            }
+                        }
                         Some('*') => self.consume_and_return(chars, Token::TildeAsterisk),
                         _ => Ok(Some(Token::Tilde)),
                     }

src/sqlparser/tests/testdata/select.yaml

@@ -105,3 +105,15 @@
   formatted_ast: 'Query(Query { with: None, body: Select(Select { distinct: All, projection: [UnnamedExpr(Function(Function { name: ObjectName([Ident { value: "percentile_cont", quote_style: None }]), args: [Unnamed(Expr(Value(Number("0.3"))))], over: None, distinct: false, order_by: [], filter: None, within_group: Some(OrderByExpr { expr: Identifier(Ident { value: "x", quote_style: None }), asc: Some(false), nulls_first: None }) }))], from: [TableWithJoins { relation: TableFunction { name: ObjectName([Ident { value: "unnest", quote_style: None }]), alias: Some(TableAlias { name: Ident { value: "x", quote_style: None }, columns: [] }), args: [Unnamed(Expr(Array(Array { elem: [Value(Number("1")), Value(Number("2")), Value(Number("4")), Value(Number("5")), Value(Number("10"))], named: true })))] }, joins: [] }], lateral_views: [], selection: None, group_by: [], having: None }), order_by: [], limit: None, offset: None, fetch: None })'
 - input: select percentile_cont(0.3) within group (order by x, y desc) from t
   error_msg: 'sql parser error: only one arg in order by is expected here'
+- input: select 'apple' ~~ 'app%'
+  formatted_sql: SELECT 'apple' LIKE 'app%'
+  formatted_ast: 'Query(Query { with: None, body: Select(Select { distinct: All, projection: [UnnamedExpr(BinaryOp { left: Value(SingleQuotedString("apple")), op: Like, right: Value(SingleQuotedString("app%")) })], from: [], lateral_views: [], selection: None, group_by: [], having: None }), order_by: [], limit: None, offset: None, fetch: None })'
+- input: select 'apple' ~~* 'App%'
+  formatted_sql: SELECT 'apple' ILIKE 'App%'
+  formatted_ast: 'Query(Query { with: None, body: Select(Select { distinct: All, projection: [UnnamedExpr(BinaryOp { left: Value(SingleQuotedString("apple")), op: ILike, right: Value(SingleQuotedString("App%")) })], from: [], lateral_views: [], selection: None, group_by: [], having: None }), order_by: [], limit: None, offset: None, fetch: None })'
+- input: select 'apple' !~~ 'app%'
+  formatted_sql: SELECT 'apple' NOT LIKE 'app%'
+  formatted_ast: 'Query(Query { with: None, body: Select(Select { distinct: All, projection: [UnnamedExpr(BinaryOp { left: Value(SingleQuotedString("apple")), op: NotLike, right: Value(SingleQuotedString("app%")) })], from: [], lateral_views: [], selection: None, group_by: [], having: None }), order_by: [], limit: None, offset: None, fetch: None })'
+- input: select 'apple' !~~* 'app%'
+  formatted_sql: SELECT 'apple' NOT ILIKE 'app%'
+  formatted_ast: 'Query(Query { with: None, body: Select(Select { distinct: All, projection: [UnnamedExpr(BinaryOp { left: Value(SingleQuotedString("apple")), op: NotILike, right: Value(SingleQuotedString("app%")) })], from: [], lateral_views: [], selection: None, group_by: [], having: None }), order_by: [], limit: None, offset: None, fetch: None })'

src/tests/regress/data/sql/arrays.sql

@@ -420,8 +420,8 @@ select 'foo' like all (array['f%', '%o']); -- t
 select 'foo' like all (array['f%', '%b']); -- f
 select 'foo' not like any (array['%a', '%b']); -- t
 select 'foo' not like all (array['%a', '%o']); -- f
---@ select 'foo' ilike any (array['%A', '%O']); -- t
---@ select 'foo' ilike all (array['F%', '%O']); -- t
+select 'foo' ilike any (array['%A', '%O']); -- t
+select 'foo' ilike all (array['F%', '%O']); -- t
 
 --
 -- General array parser tests

src/tests/regress/data/sql/strings.sql

@@ -369,18 +369,18 @@ SELECT 'indio' NOT LIKE 'in_o' AS "true";
 -- Be sure to form every test as an ILIKE/NOT ILIKE pair.
 --
 
---@ SELECT 'hawkeye' ILIKE 'h%' AS "true";
---@ SELECT 'hawkeye' NOT ILIKE 'h%' AS "false";
---@ 
---@ SELECT 'hawkeye' ILIKE 'H%' AS "true";
---@ SELECT 'hawkeye' NOT ILIKE 'H%' AS "false";
---@ 
---@ SELECT 'hawkeye' ILIKE 'H%Eye' AS "true";
---@ SELECT 'hawkeye' NOT ILIKE 'H%Eye' AS "false";
---@ 
---@ SELECT 'Hawkeye' ILIKE 'h%' AS "true";
---@ SELECT 'Hawkeye' NOT ILIKE 'h%' AS "false";
---@ 
+SELECT 'hawkeye' ILIKE 'h%' AS "true";
+SELECT 'hawkeye' NOT ILIKE 'h%' AS "false";
+
+SELECT 'hawkeye' ILIKE 'H%' AS "true";
+SELECT 'hawkeye' NOT ILIKE 'H%' AS "false";
+
+SELECT 'hawkeye' ILIKE 'H%Eye' AS "true";
+SELECT 'hawkeye' NOT ILIKE 'H%Eye' AS "false";
+
+SELECT 'Hawkeye' ILIKE 'h%' AS "true";
+SELECT 'Hawkeye' NOT ILIKE 'h%' AS "false";
+
 --@ SELECT 'ABC'::name ILIKE '_b_' AS "true";
 --@ SELECT 'ABC'::name NOT ILIKE '_b_' AS "false";