fix lint

Author: waralexrom

rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs

@@ -1,5 +1,5 @@
 use super::query_tools::QueryTools;
-use super::sql_evaluator::{MemberExpressionSymbol, MemberSymbol, SqlCall, MeasureTimeShift};
+use super::sql_evaluator::{MeasureTimeShift, MemberExpressionSymbol, MemberSymbol, SqlCall};
 use super::{evaluate_with_context, BaseMember, BaseMemberHelper, VisitorContext};
 use crate::cube_bridge::measure_definition::{
     MeasureDefinition, RollingWindow, TimeShiftReference,
@@ -9,7 +9,6 @@ use cubenativeutils::CubeError;
 use std::fmt::{Debug, Formatter};
 use std::rc::Rc;
 
-
 pub struct BaseMeasure {
     measure: String,
     query_tools: Rc<QueryTools>,
@@ -219,9 +218,7 @@ impl BaseMeasure {
 
     pub fn time_shifts(&self) -> Vec<MeasureTimeShift> {
         match self.member_evaluator.as_ref() {
-            MemberSymbol::Measure(measure_symbol) => {
-                measure_symbol.time_shifts().clone()
-            },
+            MemberSymbol::Measure(measure_symbol) => measure_symbol.time_shifts().clone(),
             _ => vec![],
         }
     }

rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/applied_state.rs

@@ -67,8 +67,7 @@ impl MultiStageAppliedState {
             if let Some(exists) = self.time_shifts.get_mut(&ts.dimension.full_name()) {
                 exists.interval += ts.interval;
             } else {
-                self.time_shifts
-                    .insert(ts.dimension.full_name(), ts);
+                self.time_shifts.insert(ts.dimension.full_name(), ts);
             }
         }
     }

rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member.rs

@@ -1,4 +1,4 @@
-use crate::planner::sql_evaluator::{MemberSymbol, MeasureTimeShift};
+use crate::planner::sql_evaluator::{MeasureTimeShift, MemberSymbol};
 use crate::planner::BaseTimeDimension;
 use std::rc::Rc;
 

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/find_owned_by_cube.rs

@@ -2,8 +2,7 @@ use crate::planner::sql_evaluator::MemberSymbol;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
-pub struct FindOwnedByCubeChildCollector {
-}
+pub struct FindOwnedByCubeChildCollector {}
 
 impl FindOwnedByCubeChildCollector {
     pub fn new() -> Self {
@@ -12,50 +11,56 @@ impl FindOwnedByCubeChildCollector {
 
     pub fn find(&self, node: &Rc<MemberSymbol>) -> Result<Rc<MemberSymbol>, CubeError> {
         self.find_impl(node, &node.full_name())
-
     }
 
-    fn find_impl(&self, node: &Rc<MemberSymbol>, origin_node_name: &String) -> Result<Rc<MemberSymbol>, CubeError> {
+    fn find_impl(
+        &self,
+        node: &Rc<MemberSymbol>,
+        origin_node_name: &String,
+    ) -> Result<Rc<MemberSymbol>, CubeError> {
         match node.as_ref() {
             MemberSymbol::Dimension(dimension_symbol) => {
                 if dimension_symbol.owned_by_cube() {
                     Ok(node.clone())
                 } else {
                     self.process_deps(&node, origin_node_name)
                 }
-            },
+            }
             MemberSymbol::TimeDimension(time_dimension_symbol) => {
                 self.find_impl(time_dimension_symbol.base_symbol(), origin_node_name)
-            },
+            }
             MemberSymbol::Measure(measure_symbol) => {
                 if measure_symbol.owned_by_cube() {
                     Ok(node.clone())
                 } else {
                     self.process_deps(&node, origin_node_name)
                 }
-
-            },
-            _ => {
-
-                Err(CubeError::internal(format!("FindOwnedByCubeChild cannot be processed on node {}", node.full_name())))
             }
+            _ => Err(CubeError::internal(format!(
+                "FindOwnedByCubeChild cannot be processed on node {}",
+                node.full_name()
+            ))),
         }
-
     }
 
-    fn process_deps(&self, node: &Rc<MemberSymbol>, origin_node_name: &String) -> Result<Rc<MemberSymbol>, CubeError> {
+    fn process_deps(
+        &self,
+        node: &Rc<MemberSymbol>,
+        origin_node_name: &String,
+    ) -> Result<Rc<MemberSymbol>, CubeError> {
         let deps = node.get_dependencies();
         if deps.len() == 1 {
             self.find_impl(&deps[0], origin_node_name)
         } else {
-            Err(CubeError::internal(format!("Cannot find owned by cube child for {}", origin_node_name)))
+            Err(CubeError::internal(format!(
+                "Cannot find owned by cube child for {}",
+                origin_node_name
+            )))
         }
-        
     }
 }
 
-
 pub fn find_owned_by_cube_child(node: &Rc<MemberSymbol>) -> Result<Rc<MemberSymbol>, CubeError> {
     let visitor = FindOwnedByCubeChildCollector::new();
     visitor.find(node)
-}
+}

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/mod.rs

@@ -1,13 +1,14 @@
 mod cube_names_collector;
+mod find_owned_by_cube;
 mod has_cumulative_members;
 mod has_multi_stage_members;
 mod join_hints_collector;
 mod member_childs_collector;
 mod multiplied_measures_collector;
 mod sub_query_dimensions;
-mod find_owned_by_cube;
 
 pub use cube_names_collector::collect_cube_names;
+pub use find_owned_by_cube::*;
 pub use has_cumulative_members::{has_cumulative_members, HasCumulativeMembersCollector};
 pub use has_multi_stage_members::{has_multi_stage_members, HasMultiStageMembersCollector};
 pub use join_hints_collector::{
@@ -19,4 +20,3 @@ pub use sub_query_dimensions::{
     collect_sub_query_dimensions, collect_sub_query_dimensions_from_members,
     collect_sub_query_dimensions_from_symbols,
 };
-pub use find_owned_by_cube::*;

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs

@@ -16,7 +16,7 @@ pub use sql_visitor::SqlEvaluatorVisitor;
 pub use symbols::{
     CubeNameSymbol, CubeNameSymbolFactory, CubeTableSymbol, CubeTableSymbolFactory,
     DimensionCaseDefinition, DimensionCaseWhenItem, DimensionSymbol, DimensionSymbolFactory,
-    DimenstionCaseLabel, MeasureSymbol, MeasureSymbolFactory, MemberExpressionSymbol, MemberSymbol,
-    SymbolFactory, TimeDimensionSymbol, MeasureTimeShift
+    DimenstionCaseLabel, MeasureSymbol, MeasureSymbolFactory, MeasureTimeShift,
+    MemberExpressionSymbol, MemberSymbol, SymbolFactory, TimeDimensionSymbol,
 };
 pub use visitor::TraversalVisitor;

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs

@@ -4,8 +4,8 @@ use super::{
     RenderReferencesSqlNode, RollingWindowNode, RootSqlNode, SqlNode, TimeDimensionNode,
     TimeShiftSqlNode, UngroupedMeasureSqlNode, UngroupedQueryFinalMeasureSqlNode,
 };
-use crate::planner::sql_evaluator::MeasureTimeShift;
 use crate::plan::schema::QualifiedColumnName;
+use crate::planner::sql_evaluator::MeasureTimeShift;
 use std::collections::{HashMap, HashSet};
 use std::rc::Rc;
 

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/time_shift.rs

@@ -1,7 +1,7 @@
 use super::SqlNode;
 use crate::planner::query_tools::QueryTools;
-use crate::planner::sql_evaluator::{MemberSymbol, MeasureTimeShift};
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use crate::planner::sql_evaluator::{MeasureTimeShift, MemberSymbol};
 use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::any::Any;

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs

@@ -3,18 +3,17 @@ use crate::cube_bridge::evaluator::CubeEvaluator;
 use crate::cube_bridge::measure_definition::{
     MeasureDefinition, RollingWindow, TimeShiftReference,
 };
-use crate::planner::sql_evaluator::collectors::find_owned_by_cube_child;
 use crate::cube_bridge::member_sql::MemberSql;
 use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::collectors::find_owned_by_cube_child;
 use crate::planner::sql_evaluator::{sql_nodes::SqlNode, Compiler, SqlCall, SqlEvaluatorVisitor};
 use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::SqlInterval;
 use cubenativeutils::CubeError;
 use itertools::Itertools;
+use std::cmp::{Eq, PartialEq};
 use std::collections::HashMap;
 use std::rc::Rc;
-use std::cmp::{PartialEq, Eq};
-
 
 #[derive(Clone)]
 pub struct MeasureOrderBy {
@@ -51,9 +50,7 @@ impl PartialEq for MeasureTimeShift {
     }
 }
 
-impl Eq for MeasureTimeShift {
-
-}
+impl Eq for MeasureTimeShift {}
 
 #[derive(Clone)]
 pub struct MeasureSymbol {
@@ -383,34 +380,42 @@ impl SymbolFactory for MeasureSymbolFactory {
             None
         };
 
-        let time_shifts = if let Some(time_shift_references) = &definition.static_data().time_shift_references {
-            let mut shifts: HashMap<String, MeasureTimeShift> = HashMap::new();
-            for shift_ref in time_shift_references.iter() {
-                let interval = shift_ref.interval.parse::<SqlInterval>()?;
-                let interval = if shift_ref.shift_type.as_ref().unwrap_or(&format!("prior")) == "next" {
-                    -interval 
-                } else {
-                    interval
-                };
-                let dimension = compiler.add_dimension_evaluator(shift_ref.time_dimension.clone())?;
-                let dimension = find_owned_by_cube_child(&dimension)?;
-                let dimension_name = dimension.full_name();
-                if let Some(exists) = shifts.get(&dimension_name) {
-                    if exists.interval != interval {
-                        return Err(CubeError::user(format!("Different time shifts for one dimension {} not allowed", dimension_name)))
-                    }
-                } else {
-                    shifts.insert(dimension_name, MeasureTimeShift {
-                        interval: interval.clone(),
-                        dimension: dimension.clone()
-                    });
-
-                };
-            }
-            shifts.into_values().collect_vec()
-        } else {
-            vec![]
-        };
+        let time_shifts =
+            if let Some(time_shift_references) = &definition.static_data().time_shift_references {
+                let mut shifts: HashMap<String, MeasureTimeShift> = HashMap::new();
+                for shift_ref in time_shift_references.iter() {
+                    let interval = shift_ref.interval.parse::<SqlInterval>()?;
+                    let interval =
+                        if shift_ref.shift_type.as_ref().unwrap_or(&format!("prior")) == "next" {
+                            -interval
+                        } else {
+                            interval
+                        };
+                    let dimension =
+                        compiler.add_dimension_evaluator(shift_ref.time_dimension.clone())?;
+                    let dimension = find_owned_by_cube_child(&dimension)?;
+                    let dimension_name = dimension.full_name();
+                    if let Some(exists) = shifts.get(&dimension_name) {
+                        if exists.interval != interval {
+                            return Err(CubeError::user(format!(
+                                "Different time shifts for one dimension {} not allowed",
+                                dimension_name
+                            )));
+                        }
+                    } else {
+                        shifts.insert(
+                            dimension_name,
+                            MeasureTimeShift {
+                                interval: interval.clone(),
+                                dimension: dimension.clone(),
+                            },
+                        );
+                    };
+                }
+                shifts.into_values().collect_vec()
+            } else {
+                vec![]
+            };
 
         Ok(MemberSymbol::new_measure(MeasureSymbol::new(
             cube_name,

rust/cubesqlplanner/cubesqlplanner/src/planner/time_dimension/sql_interval.rs

@@ -1,7 +1,7 @@
 use cubenativeutils::CubeError;
 use itertools::Itertools;
+use std::ops::{Add, AddAssign, Neg, Sub};
 use std::str::FromStr;
-use std::ops::{Add, Sub, Neg, AddAssign};
 
 #[derive(Debug, PartialEq, Clone, Hash, Eq)]
 pub struct SqlInterval {
@@ -152,7 +152,7 @@ impl Neg for SqlInterval {
             -self.second,
         )
     }
-}   
+}
 
 impl Default for SqlInterval {
     fn default() -> Self {
@@ -210,8 +210,17 @@ mod tests {
     }
     #[test]
     fn test_arithmetic() {
-        assert_eq!(SqlInterval::new(1, 3, 4, 2, 4, 2, 1) + SqlInterval::new(1, 3, 4, 2, 4, 2, 1), SqlInterval::new(2, 6, 8, 4, 8, 4, 2));
-        assert_eq!(SqlInterval::new(1, 3, 4, 2, 4, 2, 1) - SqlInterval::new(1, 4, 4, 2, 2, 2, 1), SqlInterval::new(0, -1, 0, 0, 2, 0, 0));
-        assert_eq!(-SqlInterval::new(1, 3, -4, 2, 4, 2, 1), SqlInterval::new(-1, -3, 4, -2, -4, -2, -1));
+        assert_eq!(
+            SqlInterval::new(1, 3, 4, 2, 4, 2, 1) + SqlInterval::new(1, 3, 4, 2, 4, 2, 1),
+            SqlInterval::new(2, 6, 8, 4, 8, 4, 2)
+        );
+        assert_eq!(
+            SqlInterval::new(1, 3, 4, 2, 4, 2, 1) - SqlInterval::new(1, 4, 4, 2, 2, 2, 1),
+            SqlInterval::new(0, -1, 0, 0, 2, 0, 0)
+        );
+        assert_eq!(
+            -SqlInterval::new(1, 3, -4, 2, 4, 2, 1),
+            SqlInterval::new(-1, -3, 4, -2, -4, -2, -1)
+        );
     }
 }