remove unsused files

waralexrom · waralexrom · commit 61fce14d51ef · 2025-07-23T01:05:03.000+02:00
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/common.rs b/rust/cubesqlplanner/cubesqlplanner/src/logical_plan/multistage/common.rs
@@ -1,7 +1,6 @@
 use crate::logical_plan::pretty_print::*;
 use crate::planner::planners::multi_stage::MultiStageAppliedState;
 
-use itertools::Itertools;
 
 impl PrettyPrint for MultiStageAppliedState {
     fn pretty_print(&self, result: &mut PrettyPrintResult, state: &PrettyPrintState) {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/builder.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/builder.rs
@@ -33,10 +33,6 @@ impl PhysicalPlanBuilder {
         &self.query_tools
     }
 
-    pub(super) fn plan_sql_templates(&self) -> &PlanSqlTemplates {
-        &self.plan_sql_templates
-    }
-
     pub(super) fn qtools_and_templates(&self) -> (&Rc<QueryTools>, &PlanSqlTemplates) {
         (&self.query_tools, &self.plan_sql_templates)
     }
@@ -101,12 +97,7 @@ impl PhysicalPlanBuilder {
         if let Some(required_measures) = &context.required_measures {
             required_measures
                 .iter()
-                .map(|member| {
-                    (
-                        member.clone(),
-                        node_measures.iter().find(|m| m == &member).is_some(),
-                    )
-                })
+                .map(|member| (member.clone(), node_measures.iter().any(|m| m == member)))
                 .collect_vec()
         } else {
             node_measures
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/full_key_aggregate.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/full_key_aggregate.rs
@@ -28,7 +28,7 @@ impl<'a> KeysFullKeyAggregateStrategy<'a> {
     }
 }
 
-impl<'a> FullKeyAggregateStrategy for KeysFullKeyAggregateStrategy<'a> {
+impl FullKeyAggregateStrategy for KeysFullKeyAggregateStrategy<'_> {
     fn process(
         &self,
         full_key_aggregate: &FullKeyAggregate,
@@ -72,7 +72,7 @@ impl<'a> FullKeyAggregateStrategy for KeysFullKeyAggregateStrategy<'a> {
                         data_queries.push(query);
                     }
                 }
-                ResolvedMultipliedMeasures::PreAggregation(simple_query) => todo!(),
+                ResolvedMultipliedMeasures::PreAggregation(_simple_query) => todo!(),
             }
         }
         for multi_stage_ref in full_key_aggregate.multi_stage_subquery_refs.iter() {
@@ -184,7 +184,7 @@ impl<'a> InnerJoinFullKeyAggregateStrategy<'a> {
     }
 }
 
-impl<'a> FullKeyAggregateStrategy for InnerJoinFullKeyAggregateStrategy<'a> {
+impl FullKeyAggregateStrategy for InnerJoinFullKeyAggregateStrategy<'_> {
     fn process(
         &self,
         full_key_aggregate: &FullKeyAggregate,
@@ -217,7 +217,7 @@ impl<'a> FullKeyAggregateStrategy for InnerJoinFullKeyAggregateStrategy<'a> {
                         data_queries.push(query);
                     }
                 }
-                ResolvedMultipliedMeasures::PreAggregation(simple_query) => todo!(),
+                ResolvedMultipliedMeasures::PreAggregation(_simple_query) => todo!(),
             }
         }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/logical_join.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/logical_join.rs
@@ -21,7 +21,6 @@ impl<'a> LogicalNodeProcessor<'a, LogicalJoin> for LogicalJoinProcessor<'a> {
         logical_join: &LogicalJoin,
         context: &PushDownBuilderContext,
     ) -> Result<Self::PhysycalNode, CubeError> {
-        let query_tools = self.builder.query_tools();
         let root = logical_join.root.cube.clone();
         if logical_join.joins.is_empty() && logical_join.dimension_subqueries.is_empty() {
             Ok(From::new_from_cube(
@@ -52,7 +51,6 @@ impl<'a> LogicalNodeProcessor<'a, LogicalJoin> for LogicalJoinProcessor<'a> {
                             cube.cube.clone(),
                             Some(cube.cube.default_alias_with_prefix(&context.alias_prefix)),
                             JoinCondition::new_base_join(SqlJoinCondition::try_new(
-                                query_tools.clone(),
                                 on_sql.clone(),
                             )?),
                         );
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/multi_stage_time_series.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/multi_stage_time_series.rs
@@ -19,7 +19,7 @@ impl<'a> LogicalNodeProcessor<'a, MultiStageTimeSeries> for MultiStageTimeSeries
     fn process(
         &self,
         time_series: &MultiStageTimeSeries,
-        context: &PushDownBuilderContext,
+        _context: &PushDownBuilderContext,
     ) -> Result<Self::PhysycalNode, CubeError> {
         let (query_tools, plan_sql_templates) = self.builder.qtools_and_templates();
         let time_dimension = time_series.time_dimension.clone();
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/query.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/query.rs
@@ -11,7 +11,7 @@ pub struct QueryProcessor<'a> {
     builder: &'a PhysicalPlanBuilder,
 }
 
-impl<'a> QueryProcessor<'a> {
+impl QueryProcessor<'_> {
     fn is_over_full_aggregated_source(&self, logical_plan: &Query) -> bool {
         match logical_plan.source {
             QuerySource::FullKeyAggregate(_) => true,
@@ -61,7 +61,7 @@ impl<'a> LogicalNodeProcessor<'a, Query> for QueryProcessor<'a> {
             QuerySource::FullKeyAggregate(full_key_aggregate) => self
                 .builder
                 .process_node(full_key_aggregate.as_ref(), &context)?,
-            QuerySource::PreAggregation(pre_aggregation) => {
+            QuerySource::PreAggregation(_pre_aggregation) => {
                 todo!()
                 /* let res = self.process_pre_aggregation(
                     pre_aggregation,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/resolved_multiplied_measures.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/resolved_multiplied_measures.rs
@@ -21,13 +21,12 @@ impl<'a> LogicalNodeProcessor<'a, ResolvedMultipliedMeasures>
         resolved_multiplied_measures: &ResolvedMultipliedMeasures,
         context: &PushDownBuilderContext,
     ) -> Result<Self::PhysycalNode, CubeError> {
-        let query_tools = self.builder.query_tools();
         match resolved_multiplied_measures {
             ResolvedMultipliedMeasures::ResolveMultipliedMeasures(resolve_multiplied_measures) => {
                 self.builder
                     .process_node(resolve_multiplied_measures.as_ref(), context)
             }
-            ResolvedMultipliedMeasures::PreAggregation(pre_aggregation_query) => {
+            ResolvedMultipliedMeasures::PreAggregation(_pre_aggregation_query) => {
                 todo!()
                 /* let pre_aggregation_query =
                     self.build_simple_query(pre_aggregation_query, context)?;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_join_condition.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_join_condition.rs
@@ -1,4 +1,3 @@
-use super::query_tools::QueryTools;
 use super::sql_evaluator::SqlCall;
 use super::{evaluate_sql_call_with_context, VisitorContext};
 use crate::planner::sql_templates::PlanSqlTemplates;
@@ -13,17 +12,10 @@ pub trait BaseJoinCondition {
 }
 pub struct SqlJoinCondition {
     sql_call: Rc<SqlCall>,
-    query_tools: Rc<QueryTools>,
 }
 impl SqlJoinCondition {
-    pub fn try_new(
-        query_tools: Rc<QueryTools>,
-        sql_call: Rc<SqlCall>,
-    ) -> Result<Rc<Self>, CubeError> {
-        Ok(Rc::new(Self {
-            sql_call,
-            query_tools,
-        }))
+    pub fn try_new(sql_call: Rc<SqlCall>) -> Result<Rc<Self>, CubeError> {
+        Ok(Rc::new(Self { sql_call }))
     }
 }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_segment.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_segment.rs
@@ -9,7 +9,6 @@ use std::rc::Rc;
 
 pub struct BaseSegment {
     full_name: String,
-    query_tools: Rc<QueryTools>,
     member_evaluator: Rc<MemberSymbol>,
     cube_name: String,
     name: String,
@@ -41,7 +40,6 @@ impl BaseSegment {
 
         Ok(Rc::new(Self {
             full_name,
-            query_tools,
             member_evaluator,
             cube_name,
             name,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multiplied_measures_query_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multiplied_measures_query_planner.rs
@@ -134,12 +134,8 @@ impl MultipliedMeasuresQueryPlanner {
         measures: &Vec<Rc<MemberSymbol>>,
         key_join: Rc<dyn JoinDefinition>,
     ) -> Result<Rc<AggregateMultipliedSubquery>, CubeError> {
-        let subquery_dimensions = collect_sub_query_dimensions_from_symbols(
-            &measures,
-            &self.join_planner,
-            &key_join,
-            self.query_tools.clone(),
-        )?;
+        let subquery_dimensions =
+            collect_sub_query_dimensions_from_symbols(&measures, &self.join_planner, &key_join)?;
 
         let dimension_subquery_planner = DimensionSubqueryPlanner::try_new(
             &subquery_dimensions,
@@ -228,12 +224,8 @@ impl MultipliedMeasuresQueryPlanner {
         measures: &Vec<Rc<MemberSymbol>>,
         primary_keys_dimensions: &Vec<Rc<MemberSymbol>>,
     ) -> Result<Rc<MeasureSubquery>, CubeError> {
-        let subquery_dimensions = collect_sub_query_dimensions_from_members(
-            &measures,
-            &self.join_planner,
-            &key_join,
-            self.query_tools.clone(),
-        )?;
+        let subquery_dimensions =
+            collect_sub_query_dimensions_from_members(&measures, &self.join_planner, &key_join)?;
         let dimension_subquery_planner = DimensionSubqueryPlanner::try_new(
             &subquery_dimensions,
             self.query_tools.clone(),
@@ -264,12 +256,8 @@ impl MultipliedMeasuresQueryPlanner {
             .query_properties
             .get_member_symbols(true, true, false, true, &measures);
 
-        let subquery_dimensions = collect_sub_query_dimensions_from_symbols(
-            &all_symbols,
-            &self.join_planner,
-            &join,
-            self.query_tools.clone(),
-        )?;
+        let subquery_dimensions =
+            collect_sub_query_dimensions_from_symbols(&all_symbols, &self.join_planner, &join)?;
 
         let dimension_subquery_planner = DimensionSubqueryPlanner::try_new(
             &subquery_dimensions,
@@ -326,12 +314,8 @@ impl MultipliedMeasuresQueryPlanner {
             self.query_properties
                 .get_member_symbols(true, true, false, true, &dimensions);
 
-        let subquery_dimensions = collect_sub_query_dimensions_from_symbols(
-            &all_symbols,
-            &self.join_planner,
-            &key_join,
-            self.query_tools.clone(),
-        )?;
+        let subquery_dimensions =
+            collect_sub_query_dimensions_from_symbols(&all_symbols, &self.join_planner, &key_join)?;
 
         let dimension_subquery_planner = DimensionSubqueryPlanner::try_new(
             &subquery_dimensions,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/simple_query_planer.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/simple_query_planer.rs
@@ -61,7 +61,6 @@ impl SimpleQueryPlanner {
             &self.query_properties.all_member_symbols(false),
             &self.join_planner,
             &join,
-            self.query_tools.clone(),
         )?;
         let dimension_subquery_planner = DimensionSubqueryPlanner::try_new(
             &subquery_dimensions,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
@@ -12,9 +12,9 @@ use super::sql_evaluator::MemberSymbol;
 use crate::cube_bridge::base_query_options::BaseQueryOptions;
 use crate::cube_bridge::join_definition::JoinDefinition;
 use crate::cube_bridge::options_member::OptionsMember;
-use crate::plan::{Expr, Filter, FilterItem, MemberExpression};
+use crate::plan::{Filter, FilterItem};
 use crate::planner::sql_evaluator::collectors::{
-    collect_multiplied_measures, has_cumulative_members, has_multi_stage_members,
+    collect_multiplied_measures, has_multi_stage_members,
 };
 use cubenativeutils::CubeError;
 use itertools::Itertools;
@@ -152,7 +152,6 @@ impl QueryProperties {
                             member_expression.static_data().definition.clone(),
                             query_tools.base_tools().clone(),
                         )?;
-                        let full_name = member_expression_symbol.full_name();
                         Ok(MemberSymbol::new_member_expression(
                             member_expression_symbol,
                         ))
@@ -818,7 +817,7 @@ impl QueryProperties {
                     .expect("No join groups returned for single measure multi-fact join group")
                     .0
                     .clone();
-                for item in collect_multiplied_measures(self.query_tools.clone(), m, join)? {
+                for item in collect_multiplied_measures(m, join)? {
                     if item.multiplied {
                         result
                             .rendered_as_multiplied_measures
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/multiplied_measures_collector.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/multiplied_measures_collector.rs
@@ -1,5 +1,4 @@
 use crate::cube_bridge::join_definition::JoinDefinition;
-use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::{MemberSymbol, TraversalVisitor};
 use cubenativeutils::CubeError;
 use std::collections::HashSet;
@@ -67,20 +66,14 @@ pub struct MeasureResult {
 }
 
 pub struct MultipliedMeasuresCollector {
-    query_tools: Rc<QueryTools>,
     composite_measures: HashSet<String>,
     colllected_measures: Vec<MeasureResult>,
     join: Rc<dyn JoinDefinition>,
 }
 
 impl MultipliedMeasuresCollector {
-    pub fn new(
-        query_tools: Rc<QueryTools>,
-        composite_measures: HashSet<String>,
-        join: Rc<dyn JoinDefinition>,
-    ) -> Self {
+    pub fn new(composite_measures: HashSet<String>, join: Rc<dyn JoinDefinition>) -> Self {
         Self {
-            query_tools,
             composite_measures,
             join,
             colllected_measures: vec![],
@@ -134,7 +127,6 @@ impl TraversalVisitor for MultipliedMeasuresCollector {
 }
 
 pub fn collect_multiplied_measures(
-    query_tools: Rc<QueryTools>,
     node: &Rc<MemberSymbol>,
     join: Rc<dyn JoinDefinition>,
 ) -> Result<Vec<MeasureResult>, CubeError> {
@@ -174,8 +166,7 @@ pub fn collect_multiplied_measures(
     let mut composite_collector = CompositeMeasuresCollector::new();
     composite_collector.apply(node, &CompositeMeasureCollectorState::new(None))?;
     let composite_measures = composite_collector.extract_result();
-    let mut visitor =
-        MultipliedMeasuresCollector::new(query_tools.clone(), composite_measures, join.clone());
+    let mut visitor = MultipliedMeasuresCollector::new(composite_measures, join.clone());
     visitor.apply(node, &())?;
     let result = visitor.extract_result();
     Ok(result)
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
@@ -1,6 +1,5 @@
 use crate::cube_bridge::join_definition::JoinDefinition;
 use crate::planner::planners::JoinPlanner;
-use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::{DimensionSymbol, MemberSymbol, TraversalVisitor};
 use cubenativeutils::CubeError;
 use itertools::Itertools;
@@ -65,16 +64,14 @@ pub fn collect_sub_query_dimensions_from_members(
     members: &Vec<Rc<MemberSymbol>>,
     join_planner: &JoinPlanner,
     join: &Rc<dyn JoinDefinition>,
-    query_tools: Rc<QueryTools>,
 ) -> Result<Vec<Rc<MemberSymbol>>, CubeError> {
-    collect_sub_query_dimensions_from_symbols(&members, join_planner, join, query_tools)
+    collect_sub_query_dimensions_from_symbols(&members, join_planner, join)
 }
 
 pub fn collect_sub_query_dimensions_from_symbols(
     members: &Vec<Rc<MemberSymbol>>,
     join_planner: &JoinPlanner,
     join: &Rc<dyn JoinDefinition>,
-    query_tools: Rc<QueryTools>,
 ) -> Result<Vec<Rc<MemberSymbol>>, CubeError> {
     let mut visitor = SubQueryDimensionsCollector::new();
     for member in members.iter() {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/references_builder.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/references_builder.rs
@@ -1,5 +1,5 @@
 use crate::plan::{
-    Filter, FilterItem, From, Join, QualifiedColumnName, SingleAliasedSource, SingleSource, Union,
+    Filter, FilterItem, From, Join, QualifiedColumnName, SingleAliasedSource, SingleSource,
 };
 use cubenativeutils::CubeError;
 use std::collections::HashMap;
@@ -251,15 +251,6 @@ impl ReferencesBuilder {
         column_name.map(|col| QualifiedColumnName::new(Some(source.alias.clone()), col))
     }
 
-    fn find_reference_column_for_member_in_union(
-        &self,
-        union: &Union,
-        member_name: &String,
-    ) -> Option<QualifiedColumnName> {
-        let column_name = union.schema().resolve_member_reference(member_name);
-        column_name.map(|col| QualifiedColumnName::new(None, col))
-    }
-
     fn find_reference_column_for_member_in_join(
         &self,
         join: &Rc<Join>,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_symbol.rs
@@ -4,7 +4,6 @@ use super::{
     CubeNameSymbol, CubeTableSymbol, DimensionSymbol, MeasureSymbol, MemberExpressionSymbol,
     TimeDimensionSymbol,
 };
-use crate::planner::query_tools::QueryTools;
 use std::fmt::Debug;
 use std::rc::Rc;
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/time_dimension/granularity_helper.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/time_dimension/granularity_helper.rs
@@ -1,5 +1,4 @@
 use crate::cube_bridge::evaluator::CubeEvaluator;
-use crate::logical_plan::Cube;
 use crate::planner::sql_evaluator::Compiler;
 use crate::planner::sql_evaluator::TimeDimensionSymbol;
 use crate::planner::Granularity;

Original file line number	Diff line number	Diff line change
`@@ -28,7 +28,7 @@ impl<'a> KeysFullKeyAggregateStrategy<'a> {`
`28`	`28`	`}`
`29`	`29`	`}`
`30`	`30`
`31`		`-impl<'a> FullKeyAggregateStrategy for KeysFullKeyAggregateStrategy<'a> {`
	`31`	`+impl FullKeyAggregateStrategy for KeysFullKeyAggregateStrategy<'_> {`
`32`	`32`	`fn process(`
`33`	`33`	`&self,`
`34`	`34`	`full_key_aggregate: &FullKeyAggregate,`
`@@ -72,7 +72,7 @@ impl<'a> FullKeyAggregateStrategy for KeysFullKeyAggregateStrategy<'a> {`
`72`	`72`	`data_queries.push(query);`
`73`	`73`	`}`
`74`	`74`	`}`
`75`		`- ResolvedMultipliedMeasures::PreAggregation(simple_query) => todo!(),`
	`75`	`+ ResolvedMultipliedMeasures::PreAggregation(_simple_query) => todo!(),`
`76`	`76`	`}`
`77`	`77`	`}`
`78`	`78`	`for multi_stage_ref in full_key_aggregate.multi_stage_subquery_refs.iter() {`
`@@ -184,7 +184,7 @@ impl<'a> InnerJoinFullKeyAggregateStrategy<'a> {`
`184`	`184`	`}`
`185`	`185`	`}`
`186`	`186`
`187`		`-impl<'a> FullKeyAggregateStrategy for InnerJoinFullKeyAggregateStrategy<'a> {`
	`187`	`+impl FullKeyAggregateStrategy for InnerJoinFullKeyAggregateStrategy<'_> {`
`188`	`188`	`fn process(`
`189`	`189`	`&self,`
`190`	`190`	`full_key_aggregate: &FullKeyAggregate,`
`@@ -217,7 +217,7 @@ impl<'a> FullKeyAggregateStrategy for InnerJoinFullKeyAggregateStrategy<'a> {`
`217`	`217`	`data_queries.push(query);`
`218`	`218`	`}`
`219`	`219`	`}`
`220`		`- ResolvedMultipliedMeasures::PreAggregation(simple_query) => todo!(),`
	`220`	`+ ResolvedMultipliedMeasures::PreAggregation(_simple_query) => todo!(),`
`221`	`221`	`}`
`222`	`222`	`}`
`223`	`223`
Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,3 @@`
`1`		`-use super::query_tools::QueryTools;`
`2`	`1`	`use super::sql_evaluator::SqlCall;`
`3`	`2`	`use super::{evaluate_sql_call_with_context, VisitorContext};`
`4`	`3`	`use crate::planner::sql_templates::PlanSqlTemplates;`
`@@ -13,17 +12,10 @@ pub trait BaseJoinCondition {`
`13`	`12`	`}`
`14`	`13`	`pub struct SqlJoinCondition {`
`15`	`14`	`sql_call: Rc<SqlCall>,`
`16`		`- query_tools: Rc<QueryTools>,`
`17`	`15`	`}`
`18`	`16`	`impl SqlJoinCondition {`
`19`		`- pub fn try_new(`
`20`		`- query_tools: Rc<QueryTools>,`
`21`		`- sql_call: Rc<SqlCall>,`
`22`		`- ) -> Result<Rc<Self>, CubeError> {`
`23`		`- Ok(Rc::new(Self {`
`24`		`- sql_call,`
`25`		`- query_tools,`
`26`		`- }))`
	`17`	`+ pub fn try_new(sql_call: Rc<SqlCall>) -> Result<Rc<Self>, CubeError> {`
	`18`	`+ Ok(Rc::new(Self { sql_call }))`
`27`	`19`	`}`
`28`	`20`	`}`
`29`	`21`