fix some clippy warnings and allow the rest.

KSDaemon · KSDaemon · commit c2e21f1662f9 · 2025-06-06T18:16:38.000+03:00
diff --git a/rust/cubesqlplanner/cubesqlplanner/Cargo.toml b/rust/cubesqlplanner/cubesqlplanner/Cargo.toml
@@ -56,3 +56,11 @@ too-many-arguments = "allow"
 useless_conversion = "allow"
 useless_format = "allow"
 vec_init_then_push = "allow"
+type_complexity = "allow"
+if_same_then_else = "allow"
+to_string_trait_impl = "allow"
+field_reassign_with_default = "allow"
+collapsible_match = "allow"
+wrong_self_convention = "allow"
+module_inception = "allow"
+comparison_chain = "allow"
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/optimizers/pre_aggregation/measure_matcher.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/optimizers/pre_aggregation/measure_matcher.rs
@@ -24,10 +24,8 @@ impl MeasureMatcher {
     pub fn try_match(&self, symbol: &Rc<MemberSymbol>) -> Result<bool, CubeError> {
         match symbol.as_ref() {
             MemberSymbol::Measure(measure) => {
-                if self.pre_aggregation_measures.contains(&measure.full_name()) {
-                    if !self.only_addictive || measure.is_addictive() {
-                        return Ok(true);
-                    }
+                if self.pre_aggregation_measures.contains(&measure.full_name()) && (!self.only_addictive || measure.is_addictive()) {
+                    return Ok(true);
                 }
             }
             MemberSymbol::MemberExpression(_) => {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/optimizers/pre_aggregation/optimizer.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/optimizers/pre_aggregation/optimizer.rs
@@ -23,7 +23,7 @@ impl MatchState {
         if matches!(self, MatchState::Partial) || matches!(other, MatchState::Partial) {
             return MatchState::Partial;
         }
-        return MatchState::Full;
+        MatchState::Full
     }
 }
 
@@ -233,9 +233,7 @@ impl PreAggregationOptimizer {
         }
 
         if let Some(multi_stage_item) = multi_stage_queries
-            .iter()
-            .cloned()
-            .find(|query| &query.name == multi_stage_name)
+            .iter().find(|&query| &query.name == multi_stage_name).cloned()
         {
             match &multi_stage_item.member_type {
                 MultiStageMemberLogicalType::LeafMeasure(multi_stage_leaf_measure) => self
@@ -432,7 +430,7 @@ impl PreAggregationOptimizer {
                             .map(|(d, _)| d.clone()),
                     )
                     .collect(),
-                measures: pre_aggregation.measures.iter().cloned().collect(),
+                measures: pre_aggregation.measures.to_vec(),
                 multiplied_measures: HashSet::new(),
             };
             let pre_aggregation = PreAggregation {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/builder.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/builder.rs
@@ -16,10 +16,11 @@ use itertools::Itertools;
 use std::collections::HashMap;
 use std::collections::HashSet;
 use std::rc::Rc;
-const TOTAL_COUNT: &'static str = "total_count";
-const ORIGINAL_QUERY: &'static str = "original_query";
+const TOTAL_COUNT: &str = "total_count";
+const ORIGINAL_QUERY: &str = "original_query";
 
 #[derive(Clone, Debug)]
+#[derive(Default)]
 struct PhysicalPlanBuilderContext {
     pub alias_prefix: Option<String>,
     pub render_measure_as_state: bool, //Render measure as state, for example hll state for count_approx
@@ -28,17 +29,6 @@ struct PhysicalPlanBuilderContext {
     pub original_sql_pre_aggregations: HashMap<String, String>,
 }
 
-impl Default for PhysicalPlanBuilderContext {
-    fn default() -> Self {
-        Self {
-            alias_prefix: None,
-            render_measure_as_state: false,
-            render_measure_for_ungrouped: false,
-            time_shifts: HashMap::new(),
-            original_sql_pre_aggregations: HashMap::new(),
-        }
-    }
-}
 
 impl PhysicalPlanBuilderContext {
     pub fn make_sql_nodes_factory(&self) -> SqlNodesFactory {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs
@@ -203,11 +203,8 @@ impl SelectBuilder {
         source: &SingleAliasedSource,
         refs: &mut HashMap<String, String>,
     ) {
-        match &source.source {
-            SingleSource::Cube(cube) => {
-                refs.insert(cube.name().clone(), source.alias.clone());
-            }
-            _ => {}
+        if let SingleSource::Cube(cube) = &source.source {
+            refs.insert(cube.name().clone(), source.alias.clone());
         }
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs
@@ -178,11 +178,11 @@ impl BaseDimension {
     pub fn is_sub_query(&self) -> bool {
         self.definition
             .as_ref()
-            .map_or(false, |def| def.static_data().sub_query.unwrap_or(false))
+            .is_some_and(|def| def.static_data().sub_query.unwrap_or(false))
     }
 
     pub fn propagate_filters_to_sub_query(&self) -> bool {
-        self.definition.as_ref().map_or(false, |def| {
+        self.definition.as_ref().is_some_and(|def| {
             def.static_data()
                 .propagate_filters_to_sub_query
                 .unwrap_or(false)
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
@@ -185,19 +185,19 @@ impl BaseMeasure {
     pub fn reduce_by(&self) -> Option<Vec<String>> {
         self.definition
             .as_ref()
-            .map_or(None, |d| d.static_data().reduce_by_references.clone())
+            .and_then(|d| d.static_data().reduce_by_references.clone())
     }
 
     pub fn add_group_by(&self) -> Option<Vec<String>> {
         self.definition
             .as_ref()
-            .map_or(None, |d| d.static_data().add_group_by_references.clone())
+            .and_then(|d| d.static_data().add_group_by_references.clone())
     }
 
     pub fn group_by(&self) -> Option<Vec<String>> {
         self.definition
             .as_ref()
-            .map_or(None, |d| d.static_data().group_by_references.clone())
+            .and_then(|d| d.static_data().group_by_references.clone())
     }
 
     //FIXME dublicate with symbol
@@ -218,13 +218,13 @@ impl BaseMeasure {
     pub fn is_multi_stage(&self) -> bool {
         self.definition
             .as_ref()
-            .map_or(false, |d| d.static_data().multi_stage.unwrap_or(false))
+            .is_some_and(|d| d.static_data().multi_stage.unwrap_or(false))
     }
 
     pub fn rolling_window(&self) -> Option<RollingWindow> {
         self.definition
             .as_ref()
-            .map_or(None, |d| d.static_data().rolling_window.clone())
+            .and_then(|d| d.static_data().rolling_window.clone())
     }
 
     pub fn is_rolling_window(&self) -> bool {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
@@ -8,9 +8,9 @@ use crate::planner::{evaluate_with_context, FiltersContext, VisitorContext};
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
-const FROM_PARTITION_RANGE: &'static str = "__FROM_PARTITION_RANGE";
+const FROM_PARTITION_RANGE: &str = "__FROM_PARTITION_RANGE";
 
-const TO_PARTITION_RANGE: &'static str = "__TO_PARTITION_RANGE";
+const TO_PARTITION_RANGE: &str = "__TO_PARTITION_RANGE";
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum FilterType {
@@ -589,7 +589,7 @@ impl BaseFilter {
         }
         let from = self.format_from_date(value)?;
 
-        let res = if use_db_time_zone && &from != FROM_PARTITION_RANGE {
+        let res = if use_db_time_zone && from != FROM_PARTITION_RANGE {
             self.query_tools.base_tools().in_db_time_zone(from)?
         } else {
             from
@@ -607,7 +607,7 @@ impl BaseFilter {
         }
         let from = self.format_to_date(value)?;
 
-        let res = if use_db_time_zone && &from != TO_PARTITION_RANGE {
+        let res = if use_db_time_zone && from != TO_PARTITION_RANGE {
             self.query_tools.base_tools().in_db_time_zone(from)?
         } else {
             from
@@ -705,10 +705,10 @@ impl BaseFilter {
                     as_date_time,
                 )
             } else {
-                return Err(CubeError::user(format!(
+                Err(CubeError::user(format!(
                     "Arguments for timestamp parameter for operator {} is not valid",
                     self.filter_operator().to_string()
-                )));
+                )))
             }
         }
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/rolling_window_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/rolling_window_planner.rs
@@ -63,7 +63,7 @@ impl RollingWindowPlanner {
                     }
                 }
 
-                if time_dimensions.len() == 0 {
+                if time_dimensions.is_empty() {
                     let rolling_base = self.add_rolling_window_base(
                         member.clone(),
                         state.clone(),
@@ -254,7 +254,7 @@ impl RollingWindowPlanner {
         let is_to_date = rolling_window
             .rolling_type
             .as_ref()
-            .map_or(false, |tp| tp == "to_date");
+            .is_some_and(|tp| tp == "to_date");
 
         if is_to_date {
             if let Some(granularity) = &rolling_window.granularity {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
@@ -479,7 +479,7 @@ impl QueryProperties {
             .into_values()
             .map(|measures_and_join| {
                 (
-                    measures_and_join.iter().next().unwrap().1 .1.clone(),
+                    measures_and_join.first().unwrap().1 .1.clone(),
                     measures_and_join
                         .into_iter()
                         .flat_map(|m| m.0)
@@ -506,7 +506,7 @@ impl QueryProperties {
                     .join(", ")
             )));
         }
-        Ok(self.multi_fact_join_groups.iter().next().unwrap().0.clone())
+        Ok(self.multi_fact_join_groups.first().unwrap().0.clone())
     }
 
     pub fn measures(&self) -> &Vec<Rc<BaseMeasure>> {
@@ -796,9 +796,7 @@ impl QueryProperties {
                 result.multi_stage_measures.push(m.clone())
             } else {
                 let join = self
-                    .compute_join_multi_fact_groups_with_measures(&vec![m.clone()])?
-                    .iter()
-                    .next()
+                    .compute_join_multi_fact_groups_with_measures(&vec![m.clone()])?.first()
                     .expect("No join groups returned for single measure multi-fact join group")
                     .0
                     .clone();
@@ -845,10 +843,8 @@ impl QueryProperties {
             }
             FilterItem::Item(item) => {
                 let item_member_name = item.member_name();
-                if measures
-                    .iter()
-                    .find(|m| m.full_name() == item_member_name)
-                    .is_none()
+                if !measures
+                    .iter().any(|m| m.full_name() == item_member_name)
                 {
                     measures.push(BaseMeasure::try_new_required(
                         item.member_evaluator().clone(),
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/has_cumulative_members.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/has_cumulative_members.rs
@@ -26,13 +26,10 @@ impl TraversalVisitor for HasCumulativeMembersCollector {
         _path: &Vec<String>,
         _: &Self::State,
     ) -> Result<Option<Self::State>, CubeError> {
-        match node.as_ref() {
-            MemberSymbol::Measure(s) => {
-                if s.is_rolling_window() {
-                    self.has_cumulative_members = true;
-                }
+        if let MemberSymbol::Measure(s) = node.as_ref() {
+            if s.is_rolling_window() {
+                self.has_cumulative_members = true;
             }
-            _ => {}
         };
         if self.has_cumulative_members {
             Ok(None)
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/sub_query_dimensions.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/sub_query_dimensions.rs
@@ -27,12 +27,9 @@ impl SubQueryDimensionsCollector {
 
     fn check_dim_has_measures(&self, dim: &DimensionSymbol) -> bool {
         for dep in dim.get_dependencies().iter() {
-            match dep.as_ref() {
-                MemberSymbol::Measure(_) => return true,
-                _ => {}
-            }
+            if let MemberSymbol::Measure(_) = dep.as_ref() { return true }
         }
-        return false;
+        false
     }
 }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs
@@ -60,7 +60,7 @@ impl SqlCall {
             .collect::<Result<Vec<_>, _>>()?;
         let eval_result = self.member_sql.call(args)?;
 
-        Ok(eval_result.trim() == &reference_candidate.full_name())
+        Ok(eval_result.trim() == reference_candidate.full_name())
     }
 
     pub fn get_dependencies(&self) -> Vec<Rc<MemberSymbol>> {
@@ -180,11 +180,8 @@ impl SqlCall {
         result.push(cube_dep.cube_symbol.name());
 
         for (_, v) in cube_dep.properties.iter() {
-            match v {
-                CubeDepProperty::CubeDependency(cube_dep) => {
-                    self.extract_cube_deps_from_cube_dep(cube_dep, result)
-                }
-                _ => {}
+            if let CubeDepProperty::CubeDependency(cube_dep) = v {
+                self.extract_cube_deps_from_cube_dep(cube_dep, result)
             };
         }
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/plan.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/plan.rs
@@ -15,7 +15,7 @@ pub struct PlanSqlTemplates {
 pub const UNDERSCORE_UPPER_BOUND: Boundary = Boundary {
     name: "UnderscoreUpper",
     condition: |s, _| {
-        s.get(0) == Some(&"_")
+        s.first() == Some(&"_")
             && s.get(1)
                 .map(|c| c.to_uppercase() != c.to_lowercase() && *c == c.to_uppercase())
                 == Some(true)
@@ -32,7 +32,7 @@ fn grapheme_is_uppercase(c: &&str) -> bool {
 pub const UPPER_UPPER_BOUND: Boundary = Boundary {
     name: "UpperUpper",
     condition: |s, _| {
-        s.get(0).map(grapheme_is_uppercase) == Some(true)
+        s.first().map(grapheme_is_uppercase) == Some(true)
             && s.get(1).map(grapheme_is_uppercase) == Some(true)
     },
     arg: None,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/time_dimension/date_time.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/time_dimension/date_time.rs
@@ -117,7 +117,7 @@ impl QueryDateTime {
 
     pub fn add_duration(&self, duration: Duration) -> Result<Self, CubeError> {
         let mut native = self.naive_local();
-        native = native + duration;
+        native += duration;
         Self::from_local_date_time(self.date_time.timezone(), native)
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/time_dimension/date_time_helper.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/time_dimension/date_time_helper.rs
@@ -63,7 +63,7 @@ impl QueryDateTimeHelper {
 
         // Ensure `high` is a valid local time (expand if needed)
         while let LocalResult::None = tz.from_local_datetime(&high) {
-            high = high + max_offset;
+            high += max_offset;
         }
 
         // Binary search for the first valid local time >= `naive`
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/time_dimension/granularity_helper.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/time_dimension/granularity_helper.rs
@@ -72,15 +72,15 @@ impl GranularityHelper {
 
     pub fn granularity_from_interval(interval: &Option<String>) -> Option<String> {
         if let Some(interval) = interval {
-            if interval.find("day").is_some() {
+            if interval.contains("day") {
                 Some("day".to_string())
-            } else if interval.find("month").is_some() {
+            } else if interval.contains("month") {
                 Some("month".to_string())
-            } else if interval.find("year").is_some() {
+            } else if interval.contains("year") {
                 Some("year".to_string())
-            } else if interval.find("week").is_some() {
+            } else if interval.contains("week") {
                 Some("week".to_string())
-            } else if interval.find("hour").is_some() {
+            } else if interval.contains("hour") {
                 Some("hour".to_string())
             } else {
                 None
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/time_dimension/sql_interval.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/time_dimension/sql_interval.rs
@@ -4,6 +4,7 @@ use std::ops::{Add, AddAssign, Neg, Sub};
 use std::str::FromStr;
 
 #[derive(Debug, PartialEq, Clone, Hash, Eq)]
+#[derive(Default)]
 pub struct SqlInterval {
     pub year: i32,
     pub month: i32,
@@ -154,20 +155,6 @@ impl Neg for SqlInterval {
     }
 }
 
-impl Default for SqlInterval {
-    fn default() -> Self {
-        Self {
-            second: 0,
-            minute: 0,
-            hour: 0,
-            day: 0,
-            week: 0,
-            month: 0,
-            year: 0,
-        }
-    }
-}
-
 impl FromStr for SqlInterval {
     type Err = CubeError;
     fn from_str(s: &str) -> Result<Self, Self::Err> {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/visitor_context.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/visitor_context.rs

Original file line number	Diff line number	Diff line change
`@@ -24,10 +24,8 @@ impl MeasureMatcher {`
`24`	`24`	`pub fn try_match(&self, symbol: &Rc<MemberSymbol>) -> Result<bool, CubeError> {`
`25`	`25`	`match symbol.as_ref() {`
`26`	`26`	`MemberSymbol::Measure(measure) => {`
`27`		`- if self.pre_aggregation_measures.contains(&measure.full_name()) {`
`28`		`- if !self.only_addictive \|\| measure.is_addictive() {`
`29`		`- return Ok(true);`
`30`		`- }`
	`27`	`+ if self.pre_aggregation_measures.contains(&measure.full_name()) && (!self.only_addictive \|\| measure.is_addictive()) {`
	`28`	`+ return Ok(true);`
`31`	`29`	`}`
`32`	`30`	`}`
`33`	`31`	`MemberSymbol::MemberExpression(_) => {`
Original file line number	Diff line number	Diff line change
`@@ -23,7 +23,7 @@ impl MatchState {`
`23`	`23`	`if matches!(self, MatchState::Partial) \|\| matches!(other, MatchState::Partial) {`
`24`	`24`	`return MatchState::Partial;`
`25`	`25`	`}`
`26`		`- return MatchState::Full;`
	`26`	`+ MatchState::Full`
`27`	`27`	`}`
`28`	`28`	`}`
`29`	`29`
`@@ -233,9 +233,7 @@ impl PreAggregationOptimizer {`
`233`	`233`	`}`
`234`	`234`
`235`	`235`	`if let Some(multi_stage_item) = multi_stage_queries`
`236`		`- .iter()`
`237`		`- .cloned()`
`238`		`- .find(\|query\| &query.name == multi_stage_name)`
	`236`	`+ .iter().find(\|&query\| &query.name == multi_stage_name).cloned()`
`239`	`237`	`{`
`240`	`238`	`match &multi_stage_item.member_type {`
`241`	`239`	`MultiStageMemberLogicalType::LeafMeasure(multi_stage_leaf_measure) => self`
`@@ -432,7 +430,7 @@ impl PreAggregationOptimizer {`
`432`	`430`	`.map(\|(d, _)\| d.clone()),`
`433`	`431`	`)`
`434`	`432`	`.collect(),`
`435`		`- measures: pre_aggregation.measures.iter().cloned().collect(),`
	`433`	`+ measures: pre_aggregation.measures.to_vec(),`
`436`	`434`	`multiplied_measures: HashSet::new(),`
`437`	`435`	`};`
`438`	`436`	`let pre_aggregation = PreAggregation {`
Original file line number	Diff line number	Diff line change
`@@ -203,11 +203,8 @@ impl SelectBuilder {`
`203`	`203`	`source: &SingleAliasedSource,`
`204`	`204`	`refs: &mut HashMap<String, String>,`
`205`	`205`	`) {`
`206`		`- match &source.source {`
`207`		`- SingleSource::Cube(cube) => {`
`208`		`- refs.insert(cube.name().clone(), source.alias.clone());`
`209`		`- }`
`210`		`- _ => {}`
	`206`	`+ if let SingleSource::Cube(cube) = &source.source {`
	`207`	`+ refs.insert(cube.name().clone(), source.alias.clone());`
`211`	`208`	`}`
`212`	`209`	`}`
`213`	`210`