chore: expression types names consolidating

Author: Almaz-KG

src/ast/expression/mod.rs

@@ -46,29 +46,29 @@ pub enum Expression {
     CollateExpression(CollateExpression),
 
     /// Like, e.g. $expression LIKE $expression [ESCAPE $expression]
-    LikeExpression(LikeExpressionType),
+    LikeExpression(LikeExpression),
 
     /// Glob, e.g. $expression GLOB $expression
     GlobExpression(GlobExpression),
 
     /// Regexp, e.g. $expression REGEXP $expression
-    RegexpExpression(RegexpMatchingExpression),
+    RegexpExpression(RegexpExpression),
 
     /// Match, e.g. $expression MATCH $expression
     MatchExpression(MatchExpression),
 
     /// Is, e.g. $expression IS $expression
-    IsExpression(AnIsExpression),
+    IsExpression(IsExpression),
+
+    /// In, e.g. $expression IN $expression
+    InExpression(InExpression),
 
     /// 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),
 
@@ -135,7 +135,7 @@ pub enum DataType {
 
 /// A like expression type
 #[derive(Debug, PartialEq, Clone)]
-pub struct LikeExpressionType {
+pub struct LikeExpression {
     /// An expression
     pub expression: Box<Expression>,
 
@@ -149,8 +149,8 @@ pub struct LikeExpressionType {
     pub escape_expression: Option<Box<Expression>>,
 }
 
-impl From<LikeExpressionType> for Expression {
-    fn from(like_expr: LikeExpressionType) -> Self {
+impl From<LikeExpression> for Expression {
+    fn from(like_expr: LikeExpression) -> Self {
         Expression::LikeExpression(like_expr)
     }
 }
@@ -171,16 +171,16 @@ impl From<GlobExpression> for Expression {
 }
 
 #[derive(Debug, PartialEq, Clone)]
-pub struct RegexpMatchingExpression {
+pub struct RegexpExpression {
     pub expression: Box<Expression>,
 
     pub not: bool,
 
     pub pattern: Box<Expression>,
 }
 
-impl From<RegexpMatchingExpression> for Expression {
-    fn from(regexp_expr: RegexpMatchingExpression) -> Self {
+impl From<RegexpExpression> for Expression {
+    fn from(regexp_expr: RegexpExpression) -> Self {
         Expression::RegexpExpression(regexp_expr)
     }
 }
@@ -202,7 +202,7 @@ impl From<MatchExpression> for Expression {
 
 /// An IS expression
 #[derive(Debug, PartialEq, Clone)]
-pub struct AnIsExpression {
+pub struct IsExpression {
     /// The expression
     pub expression: Box<Expression>,
 
@@ -216,8 +216,8 @@ pub struct AnIsExpression {
     pub matching_expression: Box<Expression>,
 }
 
-impl From<AnIsExpression> for Expression {
-    fn from(is_expr: AnIsExpression) -> Self {
+impl From<IsExpression> for Expression {
+    fn from(is_expr: IsExpression) -> Self {
         Expression::IsExpression(is_expr)
     }
 }

src/parser/expression/is_expr.rs

@@ -1,5 +1,5 @@
 use crate::parser::errors::ParsingError;
-use crate::{AnIsExpression, Expression, Keyword, Parser};
+use crate::{Expression, IsExpression, Keyword, Parser};
 
 use super::ExpressionParser;
 
@@ -22,7 +22,7 @@ impl IsExpressionParser for Parser<'_> {
             self.consume_as_keyword(Keyword::From)?;
         }
 
-        let is_expression = AnIsExpression {
+        let is_expression = IsExpression {
             expression: Box::new(expression),
             not: is_not,
             distinct,
@@ -37,7 +37,7 @@ impl IsExpressionParser for Parser<'_> {
 mod is_expression_tests {
     use crate::parser::test_utils::run_sunny_day_test;
     use crate::select::test_utils::select_expr;
-    use crate::{AnIsExpression, Expression};
+    use crate::{Expression, IsExpression};
 
     use crate::parser::expression::test_utils::*;
 
@@ -47,7 +47,7 @@ mod is_expression_tests {
         distinct: bool,
         is_not: bool,
     ) -> Expression {
-        Expression::IsExpression(AnIsExpression {
+        Expression::IsExpression(IsExpression {
             expression: Box::new(expression),
             distinct,
             not: is_not,

src/parser/expression/like_expr.rs

@@ -1,5 +1,5 @@
 use crate::parser::errors::ParsingError;
-use crate::{Expression, Keyword, LikeExpressionType, Parser};
+use crate::{Expression, Keyword, LikeExpression, Parser};
 
 use super::ExpressionParser;
 
@@ -26,7 +26,7 @@ impl LikeExpressionParser for Parser<'_> {
             escape_expression = Some(Box::new(self.parse_expression()?));
         }
 
-        let like_expression = LikeExpressionType {
+        let like_expression = LikeExpression {
             expression: Box::new(expression),
             not: is_not,
             like_expression: Box::new(pattern),
@@ -41,12 +41,12 @@ impl LikeExpressionParser for Parser<'_> {
 mod like_expression_tests {
     use crate::parser::test_utils::run_sunny_day_test;
     use crate::select::test_utils::select_expr;
-    use crate::{Expression, LikeExpressionType};
+    use crate::{Expression, LikeExpression};
 
     use crate::parser::expression::test_utils::*;
 
-    fn like_expr(expr: Expression, like_expr: Expression) -> LikeExpressionType {
-        LikeExpressionType {
+    fn like_expr(expr: Expression, like_expr: Expression) -> LikeExpression {
+        LikeExpression {
             expression: Box::new(expr),
             not: false,
             like_expression: Box::new(like_expr),

src/parser/expression/regexp_match_expr.rs

@@ -1,7 +1,5 @@
 use crate::parser::errors::ParsingError;
-use crate::{
-    Expression, GlobExpression, Keyword, MatchExpression, Parser, RegexpMatchingExpression,
-};
+use crate::{Expression, GlobExpression, Keyword, MatchExpression, Parser, RegexpExpression};
 
 use super::ExpressionParser;
 
@@ -37,7 +35,7 @@ impl RegexpMatchExpressionParser for Parser<'_> {
                 not: is_not,
                 pattern: Box::new(pattern),
             }),
-            Keyword::Regexp => Expression::RegexpExpression(RegexpMatchingExpression {
+            Keyword::Regexp => Expression::RegexpExpression(RegexpExpression {
                 expression: Box::new(expression),
                 not: is_not,
                 pattern: Box::new(pattern),
@@ -58,7 +56,7 @@ impl RegexpMatchExpressionParser for Parser<'_> {
 mod regexp_match_expression_tests {
     use crate::parser::test_utils::run_sunny_day_test;
     use crate::select::test_utils::select_expr;
-    use crate::{Expression, GlobExpression, MatchExpression, RegexpMatchingExpression};
+    use crate::{Expression, GlobExpression, MatchExpression, RegexpExpression};
 
     use crate::parser::expression::test_utils::*;
 
@@ -70,8 +68,8 @@ mod regexp_match_expression_tests {
         }
     }
 
-    fn regexp_expr(expression: Expression, pattern: Expression) -> RegexpMatchingExpression {
-        RegexpMatchingExpression {
+    fn regexp_expr(expression: Expression, pattern: Expression) -> RegexpExpression {
+        RegexpExpression {
             expression: Box::new(expression),
             not: false,
             pattern: Box::new(pattern),