sql_parser: glob|regexp|match expression refactored

Author: Almaz-KG

src/ast/expression/mod.rs

@@ -51,13 +51,13 @@ pub enum Expression {
     LikeExpression(LikeExpressionType),
 
     /// Glob
-    GlobExpression(Box<Expression>),
+    GlobExpression(GlobExpression),
 
     /// Regexp
-    RegexpExpression(Box<Expression>),
+    RegexpExpression(RegexpMatchingExpression),
 
     /// Match
-    MatchExpression(Box<Expression>),
+    MatchExpression(MatchExpression),
 
     /// Is
     IsExpression(AnIsExpression),
@@ -150,15 +150,6 @@ pub enum BinaryMatchingExpression {
     /// For NOT $BinaryMatchingExpression use cases
     Not(Box<BinaryMatchingExpression>),
 
-    /// Glob
-    Glob(Box<Expression>),
-
-    /// Regexp
-    Regexp(Box<Expression>),
-
-    /// Match
-    Match(Box<Expression>),
-
     /// Is
     Is(AnIsExpression),
 
@@ -191,6 +182,51 @@ impl From<LikeExpressionType> for Expression {
     }
 }
 
+#[derive(Debug, PartialEq, Clone)]
+pub struct GlobExpression {
+    pub expression: Box<Expression>,
+
+    pub not: bool,
+
+    pub pattern: Box<Expression>,
+}
+
+impl From<GlobExpression> for Expression {
+    fn from(glob_expr: GlobExpression) -> Self {
+        Expression::GlobExpression(glob_expr)
+    }
+}
+
+#[derive(Debug, PartialEq, Clone)]
+pub struct RegexpMatchingExpression {
+    pub expression: Box<Expression>,
+
+    pub not: bool,
+
+    pub pattern: Box<Expression>,
+}
+
+impl From<RegexpMatchingExpression> for Expression {
+    fn from(regexp_expr: RegexpMatchingExpression) -> Self {
+        Expression::RegexpExpression(regexp_expr)
+    }
+}
+
+#[derive(Debug, PartialEq, Clone)]
+pub struct MatchExpression {
+    pub expression: Box<Expression>,
+
+    pub not: bool,
+
+    pub pattern: Box<Expression>,
+}
+
+impl From<MatchExpression> for Expression {
+    fn from(match_expr: MatchExpression) -> Self {
+        Expression::MatchExpression(match_expr)
+    }
+}
+
 /// An IS expression
 #[derive(Debug, PartialEq, Clone)]
 pub struct AnIsExpression {

src/parser/expression/regexp_match_expr.rs

@@ -1,5 +1,7 @@
 use crate::parser::errors::ParsingError;
-use crate::{BinaryMatchingExpression, Expression, Keyword, Parser};
+use crate::{
+    Expression, GlobExpression, Keyword, MatchExpression, Parser, RegexpMatchingExpression,
+};
 
 use super::ExpressionParser;
 
@@ -30,91 +32,96 @@ impl RegexpMatchExpressionParser for Parser<'_> {
         let pattern = self.parse_expression()?;
 
         let matching_expression = match match_type {
-            Keyword::Glob => BinaryMatchingExpression::Glob(Box::new(pattern)),
-            Keyword::Regexp => BinaryMatchingExpression::Regexp(Box::new(pattern)),
-            Keyword::Match => BinaryMatchingExpression::Match(Box::new(pattern)),
+            Keyword::Glob => Expression::GlobExpression(GlobExpression {
+                expression: Box::new(expression),
+                not: is_not,
+                pattern: Box::new(pattern),
+            }),
+            Keyword::Regexp => Expression::RegexpExpression(RegexpMatchingExpression {
+                expression: Box::new(expression),
+                not: is_not,
+                pattern: Box::new(pattern),
+            }),
+            Keyword::Match => Expression::MatchExpression(MatchExpression {
+                expression: Box::new(expression),
+                not: is_not,
+                pattern: Box::new(pattern),
+            }),
             _ => unreachable!(),
         };
 
-        if is_not {
-            Ok(Expression::BinaryMatchingExpression(
-                Box::new(expression),
-                BinaryMatchingExpression::Not(Box::new(matching_expression)),
-            ))
-        } else {
-            Ok(Expression::BinaryMatchingExpression(
-                Box::new(expression),
-                matching_expression,
-            ))
-        }
+        Ok(matching_expression)
     }
 }
 
 #[cfg(test)]
 mod regexp_match_expression_tests {
     use crate::parser::test_utils::run_sunny_day_test;
     use crate::select::test_utils::select_expr;
-    use crate::{BinaryMatchingExpression, Expression, Keyword};
+    use crate::{Expression, GlobExpression, MatchExpression, RegexpMatchingExpression};
 
     use crate::parser::expression::test_utils::*;
 
-    fn binary_matching_expr(pattern: Expression, keyword: Keyword) -> BinaryMatchingExpression {
-        match keyword {
-            Keyword::Glob => BinaryMatchingExpression::Glob(Box::new(pattern)),
-            Keyword::Regexp => BinaryMatchingExpression::Regexp(Box::new(pattern)),
-            Keyword::Match => BinaryMatchingExpression::Match(Box::new(pattern)),
-            _ => panic!("Invalid keyword: {}", keyword),
+    fn glob_expr(expression: Expression, pattern: Expression) -> GlobExpression {
+        GlobExpression {
+            expression: Box::new(expression),
+            not: false,
+            pattern: Box::new(pattern),
         }
     }
 
-    fn regexp_match_expr(
-        expression: Expression,
-        pattern: Expression,
-        keyword: Keyword,
-        is_not: bool,
-    ) -> Expression {
-        let binary_matching_expression = if is_not {
-            BinaryMatchingExpression::Not(Box::new(binary_matching_expr(pattern, keyword)))
-        } else {
-            binary_matching_expr(pattern, keyword)
-        };
+    fn regexp_expr(expression: Expression, pattern: Expression) -> RegexpMatchingExpression {
+        RegexpMatchingExpression {
+            expression: Box::new(expression),
+            not: false,
+            pattern: Box::new(pattern),
+        }
+    }
 
-        Expression::BinaryMatchingExpression(Box::new(expression), binary_matching_expression)
+    fn match_expr(expression: Expression, pattern: Expression) -> MatchExpression {
+        MatchExpression {
+            expression: Box::new(expression),
+            not: false,
+            pattern: Box::new(pattern),
+        }
     }
 
     #[test]
-    fn regexp_match() {
-        let keywords = vec![Keyword::Glob, Keyword::Regexp, Keyword::Match];
-
-        for keyword in keywords {
-            run_sunny_day_test(
-                &format!("SELECT 1 {} 'a*';", keyword),
-                select_expr(regexp_match_expr(
-                    numeric_expr("1"),
-                    string_expr("'a*'"),
-                    keyword,
-                    false,
-                ))
-                .into(),
-            );
-        }
+    fn glob_expr_test() {
+        let expected = glob_expr(numeric_expr("1"), string_expr("'a*'"));
+        run_sunny_day_test("SELECT 1 GLOB 'a*';", select_expr(expected.into()).into());
+
+        let mut expected = glob_expr(numeric_expr("1"), string_expr("'a*'"));
+        expected.not = true;
+        run_sunny_day_test(
+            "SELECT 1 NOT GLOB 'a*';",
+            select_expr(expected.into()).into(),
+        );
     }
 
     #[test]
-    fn not_regexp_match() {
-        let keywords = vec![Keyword::Glob, Keyword::Regexp, Keyword::Match];
-
-        for keyword in keywords {
-            run_sunny_day_test(
-                &format!("SELECT 1 NOT {} 'a*';", keyword),
-                select_expr(regexp_match_expr(
-                    numeric_expr("1"),
-                    string_expr("'a*'"),
-                    keyword,
-                    true,
-                ))
-                .into(),
-            );
-        }
+    fn regexp_expr_test() {
+        let expected = regexp_expr(numeric_expr("1"), string_expr("'a*'"));
+        run_sunny_day_test("SELECT 1 REGEXP 'a*';", select_expr(expected.into()).into());
+
+        let mut expected = regexp_expr(numeric_expr("1"), string_expr("'a*'"));
+        expected.not = true;
+        run_sunny_day_test(
+            "SELECT 1 NOT REGEXP 'a*';",
+            select_expr(expected.into()).into(),
+        );
+    }
+
+    #[test]
+    fn match_expr_test() {
+        let expected = match_expr(numeric_expr("1"), string_expr("'a*'"));
+        run_sunny_day_test("SELECT 1 MATCH 'a*';", select_expr(expected.into()).into());
+
+        let mut expected = match_expr(numeric_expr("1"), string_expr("'a*'"));
+        expected.not = true;
+        run_sunny_day_test(
+            "SELECT 1 NOT MATCH 'a*';",
+            select_expr(expected.into()).into(),
+        );
     }
 }