Use CubeRewrite type alias in common rules

Author: mcheshkov

rust/cubesql/cubesql/src/compile/rewrite/rules/case.rs

@@ -1,4 +1,4 @@
-use egg::{Rewrite, Subst};
+use egg::Subst;
 
 use crate::{
     compile::rewrite::{
@@ -8,17 +8,17 @@ use crate::{
         case_expr_when_then_expr_empty_tail, column_expr, group_aggregate_split_replacer,
         group_expr_split_replacer, inner_aggregate_split_replacer, is_not_null_expr, is_null_expr,
         literal_expr, outer_aggregate_split_replacer, rewrite,
-        rewriter::{CubeEGraph, RewriteRules},
+        rewriter::{CubeEGraph, CubeRewrite, RewriteRules},
         transforming_rewrite, CaseExprReplacerAliasToCube, InnerAggregateSplitReplacerAliasToCube,
-        LogicalPlanAnalysis, LogicalPlanLanguage,
+        LogicalPlanLanguage,
     },
     var, var_iter,
 };
 
 pub struct CaseRules {}
 
 impl RewriteRules for CaseRules {
-    fn rewrite_rules(&self) -> Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>> {
+    fn rewrite_rules(&self) -> Vec<CubeRewrite> {
         vec![
             // Case replacer takes place of inner replacer
             transforming_rewrite(

rust/cubesql/cubesql/src/compile/rewrite/rules/common.rs

@@ -1,25 +1,25 @@
 use crate::{
     compile::rewrite::{
         agg_fun_expr, alias_expr,
-        analysis::{ConstantFolding, LogicalPlanAnalysis, OriginalExpr},
+        analysis::{ConstantFolding, OriginalExpr},
         binary_expr, column_expr, fun_expr,
-        rewriter::{CubeEGraph, RewriteRules, Rewriter},
+        rewriter::{CubeEGraph, CubeRewrite, RewriteRules, Rewriter},
         transform_original_expr_to_alias, transforming_rewrite_with_root, udf_expr, AliasExprAlias,
         LogicalPlanLanguage,
     },
     config::ConfigObj,
     var,
 };
 use datafusion::{logical_plan::DFSchema, scalar::ScalarValue};
-use egg::{Id, Rewrite, Subst};
+use egg::{Id, Subst};
 use std::{fmt::Display, sync::Arc};
 
 pub struct CommonRules {
     config_obj: Arc<dyn ConfigObj>,
 }
 
 impl RewriteRules for CommonRules {
-    fn rewrite_rules(&self) -> Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>> {
+    fn rewrite_rules(&self) -> Vec<CubeRewrite> {
         let mut rules = vec![];
 
         if Rewriter::sql_push_down_enabled() {

rust/cubesql/cubesql/src/compile/rewrite/rules/dates.rs

@@ -2,10 +2,10 @@ use super::utils;
 use crate::{
     compile::rewrite::{
         alias_expr,
-        analysis::{ConstantFolding, LogicalPlanAnalysis, OriginalExpr},
+        analysis::{ConstantFolding, OriginalExpr},
         binary_expr, cast_expr, cast_expr_explicit, column_expr, fun_expr, literal_expr,
         literal_int, literal_string, negative_expr, original_expr_name, rewrite,
-        rewriter::{CubeEGraph, RewriteRules},
+        rewriter::{CubeEGraph, CubeRewrite, RewriteRules},
         rules::utils::DeltaTimeUnitToken,
         to_day_interval_expr, transform_original_expr_to_alias, transforming_rewrite,
         transforming_rewrite_with_root, udf_expr, AliasExprAlias, CastExprDataType,
@@ -19,15 +19,15 @@ use datafusion::{
     logical_plan::DFSchema,
     scalar::ScalarValue,
 };
-use egg::{Id, Rewrite, Subst};
+use egg::{Id, Subst};
 use std::{convert::TryFrom, fmt::Display, sync::Arc};
 
 pub struct DateRules {
     config_obj: Arc<dyn ConfigObj>,
 }
 
 impl RewriteRules for DateRules {
-    fn rewrite_rules(&self) -> Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>> {
+    fn rewrite_rules(&self) -> Vec<CubeRewrite> {
         vec![
             // TODO ?interval
             rewrite(

rust/cubesql/cubesql/src/compile/rewrite/rules/filters.rs

@@ -2,15 +2,15 @@ use super::utils;
 use crate::{
     compile::rewrite::{
         alias_expr,
-        analysis::{ConstantFolding, LogicalPlanAnalysis, Member, OriginalExpr},
+        analysis::{ConstantFolding, Member, OriginalExpr},
         between_expr, binary_expr, case_expr, case_expr_var_arg, cast_expr, change_user_member,
         column_expr, cube_scan, cube_scan_filters, cube_scan_filters_empty_tail, cube_scan_members,
         dimension_expr, expr_column_name, filter, filter_member, filter_op, filter_op_filters,
         filter_op_filters_empty_tail, filter_replacer, filter_simplify_replacer, fun_expr,
         fun_expr_args_legacy, fun_expr_var_arg, inlist_expr, inlist_expr_list, is_not_null_expr,
         is_null_expr, like_expr, limit, list_rewrite, literal_bool, literal_expr, literal_int,
         literal_string, measure_expr, negative_expr, not_expr, projection, rewrite,
-        rewriter::{CubeEGraph, RewriteRules},
+        rewriter::{CubeEGraph, CubeRewrite, RewriteRules},
         scalar_fun_expr_args_empty_tail, segment_member, time_dimension_date_range_replacer,
         time_dimension_expr, transform_original_expr_to_alias, transforming_chain_rewrite,
         transforming_rewrite, transforming_rewrite_with_root, udf_expr, udf_expr_var_arg,
@@ -45,7 +45,7 @@ use datafusion::{
     logical_plan::{Column, Expr, Operator},
     scalar::ScalarValue,
 };
-use egg::{Rewrite, Subst, Var};
+use egg::{Subst, Var};
 use std::{
     collections::HashSet,
     fmt::Display,
@@ -66,7 +66,7 @@ impl FilterRules {
 }
 
 impl RewriteRules for FilterRules {
-    fn rewrite_rules(&self) -> Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>> {
+    fn rewrite_rules(&self) -> Vec<CubeRewrite> {
         let mut rules = vec![
             transforming_rewrite(
                 "push-down-filter",
@@ -4992,9 +4992,7 @@ impl FilterRules {
     }
 }
 
-fn filter_simplify_push_down(
-    node_type: impl Display,
-) -> Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis> {
+fn filter_simplify_push_down(node_type: impl Display) -> CubeRewrite {
     rewrite(
         &format!("filter-simplify-{}-push-down", node_type),
         filter_simplify_replacer(format!("({} ?left ?right)", node_type)),
@@ -5007,9 +5005,7 @@ fn filter_simplify_push_down(
     )
 }
 
-fn filter_simplify_push_down_tail(
-    node_type: impl Display,
-) -> Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis> {
+fn filter_simplify_push_down_tail(node_type: impl Display) -> CubeRewrite {
     rewrite(
         &format!("filter-simplify-{}-empty-tail-push-down", node_type),
         filter_simplify_replacer(node_type.to_string()),

rust/cubesql/cubesql/src/compile/rewrite/rules/members.rs

@@ -1,16 +1,14 @@
 use crate::{
     compile::rewrite::{
         agg_fun_expr, aggregate, alias_expr, all_members,
-        analysis::{
-            ConstantFolding, LogicalPlanAnalysis, LogicalPlanData, MemberNamesToExpr, OriginalExpr,
-        },
+        analysis::{ConstantFolding, LogicalPlanData, MemberNamesToExpr, OriginalExpr},
         binary_expr, cast_expr, change_user_expr, column_expr, cross_join, cube_scan,
         cube_scan_filters_empty_tail, cube_scan_members, cube_scan_members_empty_tail,
         cube_scan_order_empty_tail, dimension_expr, expr_column_name, fun_expr, join, like_expr,
         limit, list_concat_pushdown_replacer, list_concat_pushup_replacer, literal_expr,
         literal_member, measure_expr, member_pushdown_replacer, member_replacer,
         merged_members_replacer, original_expr_name, projection, referenced_columns, rewrite,
-        rewriter::{CubeEGraph, RewriteRules},
+        rewriter::{CubeEGraph, CubeRewrite, RewriteRules},
         rules::{
             replacer_flat_push_down_node_substitute_rules, replacer_push_down_node,
             replacer_push_down_node_substitute_rules, utils,
@@ -40,7 +38,7 @@ use datafusion::{
     physical_plan::aggregates::AggregateFunction,
     scalar::ScalarValue,
 };
-use egg::{Id, Rewrite, Subst, Var};
+use egg::{Id, Subst, Var};
 use itertools::{EitherOrBoth, Itertools};
 use std::{
     collections::{HashMap, HashSet},
@@ -56,7 +54,7 @@ pub struct MemberRules {
 }
 
 impl RewriteRules for MemberRules {
-    fn rewrite_rules(&self) -> Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>> {
+    fn rewrite_rules(&self) -> Vec<CubeRewrite> {
         let mut rules = vec![
             transforming_rewrite(
                 "cube-scan",
@@ -442,7 +440,7 @@ impl MemberRules {
         name: &str,
         member_fn: impl Fn(&str) -> String,
         relation: Option<&'static str>,
-    ) -> Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>> {
+    ) -> Vec<CubeRewrite> {
         vec![
             transforming_rewrite(
                 &format!("member-pushdown-replacer-column-{}", name),
@@ -477,7 +475,7 @@ impl MemberRules {
         ]
     }
 
-    fn member_pushdown_rules(&self) -> Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>> {
+    fn member_pushdown_rules(&self) -> Vec<CubeRewrite> {
         let mut rules = Vec::new();
         let member_replacer_fn = |members| {
             member_pushdown_replacer(
@@ -931,10 +929,7 @@ impl MemberRules {
             ),
         ));
 
-        fn list_concat_terminal(
-            name: &str,
-            member_fn: String,
-        ) -> Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis> {
+        fn list_concat_terminal(name: &str, member_fn: String) -> CubeRewrite {
             rewrite(
                 &format!("list-concat-terminal-{}", name),
                 list_concat_pushdown_replacer(member_fn.to_string()),
@@ -1001,7 +996,7 @@ impl MemberRules {
     }
 
     pub fn measure_rewrites(
-        rules: &mut Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>>,
+        rules: &mut Vec<CubeRewrite>,
         pushdown_measure_rewrite: impl Fn(
             &'static str,
             String,
@@ -1010,7 +1005,7 @@ impl MemberRules {
             Option<&'static str>,
             Option<&'static str>,
             Option<&'static str>,
-        ) -> Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>,
+        ) -> CubeRewrite,
     ) {
         rules.push(pushdown_measure_rewrite(
             "member-pushdown-replacer-agg-fun",
@@ -1760,7 +1755,7 @@ impl MemberRules {
         distinct_var: Option<&'static str>,
         fun_var: Option<&'static str>,
         cast_data_type_var: Option<&'static str>,
-    ) -> Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis> {
+    ) -> CubeRewrite {
         transforming_chain_rewrite(
             &format!("measure-{}", name),
             member_replacer("?aggr_expr", "?alias_to_cube", "?aliases"),
@@ -2761,7 +2756,7 @@ impl MemberRules {
         right_members_expr: String,
         left_members: &'static str,
         right_members: &'static str,
-    ) -> Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis> {
+    ) -> CubeRewrite {
         transforming_rewrite(
             &format!("push-down-cross-join-to-cube-scan-{}", name),
             cross_join(

rust/cubesql/cubesql/src/compile/rewrite/rules/mod.rs

@@ -1,9 +1,7 @@
 use crate::compile::rewrite::{
-    analysis::LogicalPlanAnalysis, list_rewrite, list_rewrite_with_lists,
-    list_rewrite_with_lists_and_vars, rewrite, ListApplierListPattern, ListPattern, ListType,
-    LogicalPlanLanguage,
+    list_rewrite, list_rewrite_with_lists, list_rewrite_with_lists_and_vars, rewrite,
+    rewriter::CubeRewrite, ListApplierListPattern, ListPattern, ListType,
 };
-use egg::Rewrite;
 
 pub mod case;
 pub mod common;
@@ -22,7 +20,7 @@ pub fn replacer_push_down_node(
     list_node: &str,
     replacer_node: impl Fn(String) -> String,
     include_tail: bool,
-) -> Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>> {
+) -> Vec<CubeRewrite> {
     let push_down_rule = rewrite(
         &format!("{}-push-down", name),
         replacer_node(format!("({} ?left ?right)", list_node)),
@@ -52,7 +50,7 @@ pub fn replacer_flat_push_down_node(
     list_type: ListType,
     replacer_node: impl Fn(String) -> String,
     include_tail: bool,
-) -> Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>> {
+) -> Vec<CubeRewrite> {
     let push_down_rule = list_rewrite(
         &format!("{}-push-down", name),
         list_type.clone(),
@@ -86,7 +84,7 @@ pub fn replacer_pull_up_node(
     list_node: &str,
     substitute_list_node: &str,
     replacer_node: impl Fn(String) -> String,
-) -> Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>> {
+) -> Vec<CubeRewrite> {
     let pull_up_rule = rewrite(
         &format!("{}-pull-up", name),
         format!(
@@ -106,7 +104,7 @@ pub fn replacer_flat_pull_up_node(
     substitute_list_type: ListType,
     replacer_node: impl Fn(String) -> String,
     top_level_elem_vars: &[&str],
-) -> Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>> {
+) -> Vec<CubeRewrite> {
     let pull_up_rule = list_rewrite_with_lists_and_vars(
         &format!("{}-pull-up", name),
         list_type,
@@ -131,7 +129,7 @@ pub fn replacer_push_down_node_substitute_rules(
     list_node: &str,
     substitute_node: &str,
     replacer_node: impl Fn(String) -> String,
-) -> Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>> {
+) -> Vec<CubeRewrite> {
     vec![
         rewrite(
             &format!("{}-push-down", name),
@@ -156,7 +154,7 @@ pub fn replacer_flat_push_down_node_substitute_rules(
     list_type: ListType,
     substitute_type: ListType,
     replacer_node: impl Fn(String) -> String,
-) -> Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>> {
+) -> Vec<CubeRewrite> {
     vec![
         list_rewrite_with_lists(
             &format!("{}-push-down", name),

rust/cubesql/cubesql/src/compile/rewrite/rules/old_split.rs

@@ -4,14 +4,14 @@ use crate::{
         agg_fun_expr, aggr_aggr_expr_empty_tail, aggr_aggr_expr_legacy as aggr_aggr_expr,
         aggr_group_expr_empty_tail, aggr_group_expr_legacy as aggr_group_expr, aggregate,
         alias_expr,
-        analysis::{ConstantFolding, LogicalPlanAnalysis, OriginalExpr},
+        analysis::{ConstantFolding, OriginalExpr},
         binary_expr, cast_expr, cast_expr_explicit, column_expr, cube_scan, event_notification,
         fun_expr, group_aggregate_split_replacer, group_expr_split_replacer,
         inner_aggregate_split_replacer, is_not_null_expr, is_null_expr, literal_expr,
         literal_float, literal_int, literal_string, original_expr_name,
         outer_aggregate_split_replacer, outer_projection_split_replacer, projection,
         projection_expr_empty_tail, projection_expr_legacy as projection_expr, rewrite,
-        rewriter::{CubeEGraph, RewriteRules},
+        rewriter::{CubeEGraph, CubeRewrite, RewriteRules},
         rules::members::MemberRules,
         transforming_chain_rewrite, transforming_rewrite, udf_expr, AggregateFunctionExprDistinct,
         AggregateFunctionExprFun, AliasExprAlias, BinaryExprOp, CastExprDataType, ColumnExprColumn,
@@ -30,7 +30,7 @@ use datafusion::{
     physical_plan::{aggregates::AggregateFunction, functions::BuiltinScalarFunction},
     scalar::ScalarValue,
 };
-use egg::{Id, Rewrite, Subst, Var};
+use egg::{Id, Subst, Var};
 use std::{fmt::Display, ops::Index, sync::Arc};
 
 pub struct OldSplitRules {
@@ -39,7 +39,7 @@ pub struct OldSplitRules {
 }
 
 impl RewriteRules for OldSplitRules {
-    fn rewrite_rules(&self) -> Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>> {
+    fn rewrite_rules(&self) -> Vec<CubeRewrite> {
         let mut rules = vec![
             transforming_rewrite(
                 "split-projection-aggregate",
@@ -4667,7 +4667,7 @@ impl OldSplitRules {
         is_measure: bool,
         is_dimension: bool,
         unwrap_agg_chain: Option<Vec<(&'a str, String)>>,
-    ) -> Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>>
+    ) -> Vec<CubeRewrite>
     where
         M: Fn(fn(D, DD) -> String) -> String,
         C: Fn(fn(D, DD) -> String) -> Vec<(&'a str, String)>,

rust/cubesql/cubesql/src/compile/rewrite/rules/order.rs

@@ -1,21 +1,21 @@
 use crate::{
     compile::rewrite::{
-        analysis::{LogicalPlanAnalysis, OriginalExpr},
+        analysis::OriginalExpr,
         column_name_to_member_vec, cube_scan, cube_scan_order, cube_scan_order_empty_tail,
         expr_column_name, order, order_replacer, referenced_columns, rewrite,
-        rewriter::{CubeEGraph, RewriteRules},
+        rewriter::{CubeEGraph, CubeRewrite, RewriteRules},
         sort, sort_exp, sort_exp_empty_tail, sort_expr, transforming_rewrite, LogicalPlanLanguage,
         OrderAsc, OrderMember, OrderReplacerColumnNameToMember, SortExprAsc,
     },
     var, var_iter,
 };
-use egg::{Rewrite, Subst};
+use egg::Subst;
 use std::ops::{Index, IndexMut};
 
 pub struct OrderRules {}
 
 impl RewriteRules for OrderRules {
-    fn rewrite_rules(&self) -> Vec<Rewrite<LogicalPlanLanguage, LogicalPlanAnalysis>> {
+    fn rewrite_rules(&self) -> Vec<CubeRewrite> {
         vec![
             transforming_rewrite(
                 "push-down-sort",