Fix for Postgres regex and like binary operators

Author: solontsev

src/parser/mod.rs

@@ -3478,10 +3478,18 @@ impl<'a> Parser<'a> {
                         | BinaryOperator::LtEq
                         | BinaryOperator::Eq
                         | BinaryOperator::NotEq
+                        | BinaryOperator::PGRegexMatch
+                        | BinaryOperator::PGRegexIMatch
+                        | BinaryOperator::PGRegexNotMatch
+                        | BinaryOperator::PGRegexNotIMatch
+                        | BinaryOperator::PGLikeMatch
+                        | BinaryOperator::PGILikeMatch
+                        | BinaryOperator::PGNotLikeMatch
+                        | BinaryOperator::PGNotILikeMatch
                 ) {
                     return parser_err!(
                         format!(
-                        "Expected one of [=, >, <, =>, =<, !=] as comparison operator, found: {op}"
+                        "Expected one of [=, >, <, =>, =<, !=, ~, ~*, !~, !~*, ~~, ~~*, !~~, !~~*] as comparison operator, found: {op}"
                     ),
                         span.start
                     );

tests/sqlparser_postgres.rs

@@ -2181,19 +2181,35 @@ fn parse_pg_regex_match_ops() {
     ];
 
     for (str_op, op) in pg_regex_match_ops {
-        let select = pg().verified_only_select(&format!("SELECT 'abc' {} '^a'", &str_op));
+        // Basic binary operation usage
+        let select = pg().verified_only_select(&format!("SELECT 'abc' {str_op} '^a'"));
         assert_eq!(
             SelectItem::UnnamedExpr(Expr::BinaryOp {
-                left: Box::new(Expr::Value(
-                    (Value::SingleQuotedString("abc".into())).with_empty_span()
-                )),
+                left: Box::new(Expr::Value(single_quoted_string("abc").with_empty_span(),)),
                 op: op.clone(),
-                right: Box::new(Expr::Value(
-                    (Value::SingleQuotedString("^a".into())).with_empty_span()
-                )),
+                right: Box::new(Expr::Value(single_quoted_string("^a").with_empty_span(),)),
             }),
-            select.projection[0]
+            select.projection[0],
         );
+
+        // Binary operator with ANY operator
+        let select =
+            pg().verified_only_select(&format!("SELECT 'abc' {str_op} ANY(ARRAY['^a', 'x'])"));
+        assert_eq!(
+            SelectItem::UnnamedExpr(Expr::AnyOp {
+                left: Box::new(Expr::Value(single_quoted_string("abc").with_empty_span(),)),
+                compare_op: op.clone(),
+                right: Box::new(Expr::Array(Array {
+                    elem: vec![
+                        Expr::Value(single_quoted_string("^a").with_empty_span()),
+                        Expr::Value(single_quoted_string("x").with_empty_span()),
+                    ],
+                    named: true,
+                })),
+                is_some: false,
+            }),
+            select.projection[0],
+        )
     }
 }
 
@@ -2207,19 +2223,31 @@ fn parse_pg_like_match_ops() {
     ];
 
     for (str_op, op) in pg_like_match_ops {
-        let select = pg().verified_only_select(&format!("SELECT 'abc' {} 'a_c%'", &str_op));
+        // Basic binary operation usage
+        let select = pg().verified_only_select(&format!("SELECT 'abc' {str_op} 'a_c%'"));
         assert_eq!(
             SelectItem::UnnamedExpr(Expr::BinaryOp {
-                left: Box::new(Expr::Value(
-                    (Value::SingleQuotedString("abc".into())).with_empty_span()
-                )),
+                left: Box::new(Expr::Value(single_quoted_string("abc").with_empty_span(),)),
                 op: op.clone(),
-                right: Box::new(Expr::Value(
-                    (Value::SingleQuotedString("a_c%".into())).with_empty_span()
-                )),
+                right: Box::new(Expr::Value(single_quoted_string("a_c%").with_empty_span(),)),
             }),
-            select.projection[0]
+            select.projection[0],
         );
+
+        // Binary operator with ALL operator
+        let select =
+            pg().verified_only_select(&format!("SELECT 'abc' {str_op} ALL(ARRAY['a_c%'])"));
+        assert_eq!(
+            SelectItem::UnnamedExpr(Expr::AllOp {
+                left: Box::new(Expr::Value(single_quoted_string("abc").with_empty_span(),)),
+                compare_op: op.clone(),
+                right: Box::new(Expr::Array(Array {
+                    elem: vec![Expr::Value(single_quoted_string("a_c%").with_empty_span())],
+                    named: true,
+                })),
+            }),
+            select.projection[0],
+        )
     }
 }