sql_parser: is_null and not_null expression refactored

Author: Almaz-KG

src/ast/expression/mod.rs

@@ -60,18 +60,18 @@ pub enum Expression {
     /// Is, e.g. $expression IS $expression
     IsExpression(AnIsExpression),
 
+    /// Is Null, e.g. $expression IS NULL
+    IsNull(Box<Expression>),
+
+    /// Is Not Null, e.g. $expression IS NOT NULL
+    IsNotNull(Box<Expression>),
+
     /// In, e.g. $expression IN $expression
     InExpression(InExpression),
 
     /// Between
     BetweenExpression(BetweenExpression),
 
-    /// A binary matching expressions (e.g. $expr1 NOT MATCH $expr2)
-    BinaryMatchingExpression(Box<Expression>, BinaryMatchingExpression),
-
-    /// A unary matching expression (e.g. expression IS NOT NULL)
-    UnaryMatchingExpression(Box<Expression>, UnaryMatchingExpression),
-
     /// An exists statement
     ExistsStatement(ExistsStatement),
 
@@ -133,22 +133,6 @@ pub enum DataType {
     BoundedDataType(DataTypeName, String, String),
 }
 
-/// An unary matching expression type
-#[derive(Debug, PartialEq, Clone)]
-pub enum UnaryMatchingExpression {
-    /// Is Null
-    IsNull,
-    /// Is Not Null
-    IsNotNull,
-}
-
-/// A binary matching expression
-#[derive(Debug, PartialEq, Clone)]
-pub enum BinaryMatchingExpression {
-    /// For NOT $BinaryMatchingExpression use cases
-    Not(Box<BinaryMatchingExpression>),
-}
-
 /// A like expression type
 #[derive(Debug, PartialEq, Clone)]
 pub struct LikeExpressionType {

src/parser/expression/mod.rs

@@ -11,10 +11,7 @@ mod precedence;
 mod raise_expr;
 mod regexp_match_expr;
 use crate::parser::errors::ParsingError;
-use crate::{
-    BinaryOp, Expression, Keyword, LiteralValue, Parser, TokenType, UnaryMatchingExpression,
-    UnaryOp,
-};
+use crate::{BinaryOp, Expression, Keyword, LiteralValue, Parser, TokenType, UnaryOp};
 use between_expr::BetweenExpressionParser;
 use case_expr::CaseExpressionParser;
 use cast_expr::CastExpressionParser;
@@ -141,27 +138,18 @@ impl ExpressionParser for Parser<'_> {
             return RegexpMatchExpressionParser::parse_regexp_match_expression(self, left, false);
         } else if let Ok(Keyword::Isnull) = self.peek_as_keyword() {
             self.consume_as_keyword(Keyword::Isnull)?;
-            Ok(Expression::UnaryMatchingExpression(
-                Box::new(left),
-                UnaryMatchingExpression::IsNull,
-            ))
+            Ok(Expression::IsNull(Box::new(left)))
         } else if let Ok(Keyword::Notnull) = self.peek_as_keyword() {
             self.consume_as_keyword(Keyword::Notnull)?;
-            Ok(Expression::UnaryMatchingExpression(
-                Box::new(left),
-                UnaryMatchingExpression::IsNotNull,
-            ))
+            Ok(Expression::IsNotNull(Box::new(left)))
         } else if let Ok(Keyword::Not) = self.peek_as_keyword() {
             self.consume_as_keyword(Keyword::Not)?;
 
             if let Ok(nested_keyword) = self.peek_as_keyword() {
                 match nested_keyword {
                     Keyword::Null => {
                         self.consume_as_keyword(Keyword::Null)?;
-                        Ok(Expression::UnaryMatchingExpression(
-                            Box::new(left),
-                            UnaryMatchingExpression::IsNotNull,
-                        ))
+                        Ok(Expression::IsNotNull(Box::new(left)))
                     }
                     Keyword::Between => {
                         BetweenExpressionParser::parse_between_expression(self, left, true)
@@ -695,50 +683,31 @@ mod binary_op_tests {
 }
 
 #[cfg(test)]
-mod unary_matching_expression_tests {
+mod null_expression_tests {
     use crate::parser::test_utils::run_sunny_day_test;
     use crate::select::test_utils::select_expr;
-    use crate::{Expression, UnaryMatchingExpression};
+    use crate::Expression;
 
     use crate::parser::expression::test_utils::*;
 
-    fn unary_matching_expression(
-        expression: Expression,
-        unary_matching_expression: UnaryMatchingExpression,
-    ) -> Expression {
-        Expression::UnaryMatchingExpression(Box::new(expression), unary_matching_expression)
-    }
-
     #[test]
     fn isnull() {
         run_sunny_day_test(
             "SELECT 1 ISNULL;",
-            select_expr(unary_matching_expression(
-                numeric_expr("1"),
-                UnaryMatchingExpression::IsNull,
-            ))
-            .into(),
+            select_expr(Expression::IsNull(Box::new(numeric_expr("1")))).into(),
         );
     }
 
     #[test]
     fn notnull() {
         run_sunny_day_test(
             "SELECT 1 NOTNULL;",
-            select_expr(unary_matching_expression(
-                numeric_expr("1"),
-                UnaryMatchingExpression::IsNotNull,
-            ))
-            .into(),
+            select_expr(Expression::IsNotNull(Box::new(numeric_expr("1")))).into(),
         );
 
         run_sunny_day_test(
             "SELECT 1 NOT NULL;",
-            select_expr(unary_matching_expression(
-                numeric_expr("1"),
-                UnaryMatchingExpression::IsNotNull,
-            ))
-            .into(),
+            select_expr(Expression::IsNotNull(Box::new(numeric_expr("1")))).into(),
         );
     }
 }