Update the structure of Statements to use taged union

Author: AmrDeveloper

crates/gitql-ast/src/query.rs

@@ -12,7 +12,7 @@ pub enum Query {
 }
 
 pub struct SelectQuery {
-    pub statements: HashMap<&'static str, Box<dyn Statement>>,
+    pub statements: HashMap<&'static str, Statement>,
     pub alias_table: HashMap<String, String>,
     pub has_aggregation_function: bool,
     pub has_group_by_statement: bool,

crates/gitql-ast/src/statement.rs

@@ -1,29 +1,19 @@
-use std::any::Any;
 use std::collections::HashMap;
 
-use dyn_clone::DynClone;
-
 use crate::expression::Expr;
 
-pub enum StatementKind {
-    Select,
-    Where,
-    Having,
-    Limit,
-    Offset,
-    OrderBy,
-    GroupBy,
-    AggregateFunction,
-    WindowFunction,
-    Qualify,
-    Into,
-}
-
-dyn_clone::clone_trait_object!(Statement);
-
-pub trait Statement: DynClone {
-    fn kind(&self) -> StatementKind;
-    fn as_any(&self) -> &dyn Any;
+pub enum Statement {
+    Select(SelectStatement),
+    Where(WhereStatement),
+    Having(HavingStatement),
+    Limit(LimitStatement),
+    Offset(OffsetStatement),
+    OrderBy(OrderByStatement),
+    GroupBy(GroupByStatement),
+    AggregateFunction(AggregationsStatement),
+    WindowFunction(WindowFunctionsStatement),
+    Qualify(QualifyStatement),
+    Into(IntoStatement),
 }
 
 #[derive(Clone)]
@@ -72,76 +62,26 @@ pub struct SelectStatement {
     pub distinct: Distinct,
 }
 
-impl Statement for SelectStatement {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn kind(&self) -> StatementKind {
-        StatementKind::Select
-    }
-}
-
 #[derive(Clone)]
 pub struct WhereStatement {
     pub condition: Box<dyn Expr>,
 }
 
-impl Statement for WhereStatement {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn kind(&self) -> StatementKind {
-        StatementKind::Where
-    }
-}
-
 #[derive(Clone)]
 pub struct HavingStatement {
     pub condition: Box<dyn Expr>,
 }
 
-impl Statement for HavingStatement {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn kind(&self) -> StatementKind {
-        StatementKind::Having
-    }
-}
-
 #[derive(Clone)]
 pub struct LimitStatement {
     pub count: usize,
 }
 
-impl Statement for LimitStatement {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn kind(&self) -> StatementKind {
-        StatementKind::Limit
-    }
-}
-
 #[derive(Clone)]
 pub struct OffsetStatement {
     pub start: Box<dyn Expr>,
 }
 
-impl Statement for OffsetStatement {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn kind(&self) -> StatementKind {
-        StatementKind::Offset
-    }
-}
-
 #[derive(Clone, PartialEq)]
 pub enum SortingOrder {
     Ascending,
@@ -161,32 +101,12 @@ pub struct OrderByStatement {
     pub nulls_order_policies: Vec<NullsOrderPolicy>,
 }
 
-impl Statement for OrderByStatement {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn kind(&self) -> StatementKind {
-        StatementKind::OrderBy
-    }
-}
-
 #[derive(Clone)]
 pub struct GroupByStatement {
     pub values: Vec<Box<dyn Expr>>,
     pub has_with_roll_up: bool,
 }
 
-impl Statement for GroupByStatement {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn kind(&self) -> StatementKind {
-        StatementKind::GroupBy
-    }
-}
-
 #[derive(Clone)]
 pub struct WindowPartitioningClause {
     pub expr: Box<dyn Expr>,
@@ -229,31 +149,11 @@ pub struct WindowFunctionsStatement {
     pub window_values: HashMap<String, WindowValue>,
 }
 
-impl Statement for WindowFunctionsStatement {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn kind(&self) -> StatementKind {
-        StatementKind::WindowFunction
-    }
-}
-
 #[derive(Clone)]
 pub struct QualifyStatement {
     pub condition: Box<dyn Expr>,
 }
 
-impl Statement for QualifyStatement {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn kind(&self) -> StatementKind {
-        StatementKind::Qualify
-    }
-}
-
 #[derive(Clone)]
 pub enum AggregateValue {
     Expression(Box<dyn Expr>),
@@ -265,30 +165,10 @@ pub struct AggregationsStatement {
     pub aggregations: HashMap<String, AggregateValue>,
 }
 
-impl Statement for AggregationsStatement {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn kind(&self) -> StatementKind {
-        StatementKind::AggregateFunction
-    }
-}
-
 #[derive(Clone)]
 pub struct IntoStatement {
     pub file_path: String,
     pub lines_terminated: String,
     pub fields_terminated: String,
     pub enclosed: String,
 }
-
-impl Statement for IntoStatement {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn kind(&self) -> StatementKind {
-        StatementKind::Into
-    }
-}

crates/gitql-engine/src/engine.rs

@@ -7,7 +7,7 @@ use gitql_ast::query::GlobalVariableDeclQuery;
 use gitql_ast::query::Query;
 use gitql_ast::query::SelectQuery;
 use gitql_ast::statement::Distinct;
-use gitql_ast::statement::SelectStatement;
+use gitql_ast::statement::Statement;
 use gitql_core::environment::Environment;
 use gitql_core::object::GitQLObject;
 use gitql_core::object::Group;
@@ -90,42 +90,23 @@ fn evaluate_select_query(
     let mut distinct: Option<Distinct> = None;
     for logical_node_name in FIXED_LOGICAL_PLAN {
         if let Some(statement) = statements_map.get_mut(logical_node_name) {
-            match logical_node_name {
-                "select" => {
-                    // Select statement should be performed on all repositories, can be executed in parallel
-                    let select_statement = statement
-                        .as_any()
-                        .downcast_ref::<SelectStatement>()
-                        .unwrap();
-
-                    execute_statement(
-                        env,
-                        statement,
-                        data_provider,
-                        &mut gitql_object,
-                        &mut alias_table,
-                        &hidden_selections_map,
-                        has_group_by_statement,
-                    )?;
-
-                    // If the main group is empty, no need to perform other statements
-                    if gitql_object.is_empty() || gitql_object.groups[0].is_empty() {
-                        return Ok(EvaluationResult::SelectedGroups(gitql_object));
-                    }
-
-                    distinct = Some(select_statement.distinct.to_owned());
-                }
-                _ => {
-                    execute_statement(
-                        env,
-                        statement,
-                        data_provider,
-                        &mut gitql_object,
-                        &mut alias_table,
-                        &hidden_selections_map,
-                        has_group_by_statement,
-                    )?;
+            execute_statement(
+                env,
+                statement,
+                data_provider,
+                &mut gitql_object,
+                &mut alias_table,
+                &hidden_selections_map,
+                has_group_by_statement,
+            )?;
+
+            if let Statement::Select(select_statement) = statement {
+                // If the main group is empty, no need to perform other statements
+                if gitql_object.is_empty() || gitql_object.groups[0].is_empty() {
+                    return Ok(EvaluationResult::SelectedGroups(gitql_object));
                 }
+
+                distinct = Some(select_statement.distinct.to_owned());
             }
         }
     }