Fix for Postgres regex and like binary operators (#1928)

src/parser/mod.rs

@@ -3486,10 +3486,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

@@ -2187,21 +2187,39 @@ fn parse_pg_regex_match_ops() {
         ("!~*", BinaryOperator::PGRegexNotIMatch),
     ];
 
+    // Match against a single value
     for (str_op, op) in pg_regex_match_ops {
-        let select = pg().verified_only_select(&format!("SELECT 'abc' {} '^a'", &str_op));
+        let select = pg().verified_only_select(&format!("SELECT 'abc' {str_op} '^a'"));
         assert_eq!(
             SelectItem::UnnamedExpr(Expr::BinaryOp {
-                left: Box::new(Expr::Value(
+                left: Box::new(Expr::Value(single_quoted_string("abc").with_empty_span(),)),
-                    (Value::SingleQuotedString("abc".into())).with_empty_span()
-                )),
                 op: op.clone(),
-                right: Box::new(Expr::Value(
+                right: Box::new(Expr::Value(single_quoted_string("^a").with_empty_span(),)),
-                    (Value::SingleQuotedString("^a".into())).with_empty_span()
-                )),
             }),
             select.projection[0]
         );
     }
+
+    // Match against any value from an array
+    for (str_op, op) in pg_regex_match_ops {
+        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]
+        )
+    }
 }
 
 #[test]
@@ -2213,21 +2231,35 @@ fn parse_pg_like_match_ops() {
         ("!~~*", BinaryOperator::PGNotILikeMatch),
     ];
 
+    // Match against a single value
     for (str_op, op) in pg_like_match_ops {
-        let select = pg().verified_only_select(&format!("SELECT 'abc' {} 'a_c%'", &str_op));
+        let select = pg().verified_only_select(&format!("SELECT 'abc' {str_op} 'a_c%'"));
         assert_eq!(
             SelectItem::UnnamedExpr(Expr::BinaryOp {
-                left: Box::new(Expr::Value(
+                left: Box::new(Expr::Value(single_quoted_string("abc").with_empty_span(),)),
-                    (Value::SingleQuotedString("abc".into())).with_empty_span()
-                )),
                 op: op.clone(),
-                right: Box::new(Expr::Value(
+                right: Box::new(Expr::Value(single_quoted_string("a_c%").with_empty_span(),)),
-                    (Value::SingleQuotedString("a_c%".into())).with_empty_span()
-                )),
             }),
             select.projection[0]
         );
     }
+
+    // Match against all values from an array
+    for (str_op, op) in pg_like_match_ops {
+        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]
+        )
+    }
 }
 
 #[test]