in work

waralexrom · waralexrom · commit a09a60704d6f · 2025-07-24T11:22:17.000+02:00
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/builder.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/builder.rs
@@ -78,7 +78,9 @@ impl PhysicalPlanBuilder {
         let mut select_builder = SelectBuilder::new(from);
         select_builder.add_count_all(TOTAL_COUNT.to_string());
         let context_factory = context.make_sql_nodes_factory()?;
-        Ok(Rc::new(select_builder.build(context_factory)))
+        Ok(Rc::new(
+            select_builder.build(self.query_tools.clone(), context_factory),
+        ))
     }
 
     fn build_impl(
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/aggregate_multiplied_subquery.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/aggregate_multiplied_subquery.rs
@@ -1,10 +1,9 @@
 use super::super::{LogicalNodeProcessor, ProcessableNode, PushDownBuilderContext};
-use crate::logical_plan::{
-    AggregateMultipliedSubquery, AggregateMultipliedSubquerySouce,
-};
+use crate::logical_plan::{AggregateMultipliedSubquery, AggregateMultipliedSubquerySouce};
 use crate::physical_plan_builder::PhysicalPlanBuilder;
 use crate::plan::{
-    Expr, From, JoinBuilder, JoinCondition, MemberExpression, QualifiedColumnName, Select, SelectBuilder,
+    Expr, From, JoinBuilder, JoinCondition, MemberExpression, QualifiedColumnName, Select,
+    SelectBuilder,
 };
 use crate::planner::sql_evaluator::ReferencesBuilder;
 use crate::planner::BaseMember;
@@ -178,7 +177,9 @@ impl<'a> LogicalNodeProcessor<'a, AggregateMultipliedSubquery>
                 .multiplied_measures
                 .clone(),
         );
-        Ok(Rc::new(select_builder.build(context_factory)))
+        Ok(Rc::new(
+            select_builder.build(query_tools.clone(), context_factory),
+        ))
     }
 }
 
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
@@ -1,11 +1,9 @@
 use super::super::{LogicalNodeProcessor, ProcessableNode, PushDownBuilderContext};
-use crate::logical_plan::{
-    pretty_print, FullKeyAggregate, ResolvedMultipliedMeasures,
-};
+use crate::logical_plan::{pretty_print, FullKeyAggregate, ResolvedMultipliedMeasures};
 use crate::physical_plan_builder::PhysicalPlanBuilder;
 use crate::plan::{
-    Expr, From, FromSource, JoinBuilder, JoinCondition,
-    QualifiedColumnName, SelectBuilder, SingleAliasedSource, Union,
+    Expr, From, FromSource, JoinBuilder, JoinCondition, QualifiedColumnName, SelectBuilder,
+    SingleAliasedSource, Union,
 };
 use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
 use crate::planner::sql_evaluator::ReferencesBuilder;
@@ -95,12 +93,13 @@ impl<'a> FullKeyAggregateStrategy for KeysFullKeyAggregateStrategy<'a> {
             }
             let sql_context = SqlNodesFactory::new();
             keys_select_builder.set_distinct();
-            let keys_select = Rc::new(keys_select_builder.build(sql_context.clone()));
+            let keys_select =
+                Rc::new(keys_select_builder.build(query_tools.clone(), sql_context.clone()));
             keys_queries.push(keys_select);
 
             let data_select_builder =
                 SelectBuilder::new(From::new(FromSource::Single(multi_stage_source)));
-            let data_select = Rc::new(data_select_builder.build(sql_context));
+            let data_select = Rc::new(data_select_builder.build(query_tools.clone(), sql_context));
             data_queries.push(data_select);
         }
         if data_queries.is_empty() {
@@ -138,7 +137,7 @@ impl<'a> FullKeyAggregateStrategy for KeysFullKeyAggregateStrategy<'a> {
         keys_select_builder.set_distinct();
 
         let sql_context = SqlNodesFactory::new();
-        let keys_select = Rc::new(keys_select_builder.build(sql_context));
+        let keys_select = Rc::new(keys_select_builder.build(query_tools.clone(), sql_context));
 
         let keys_alias = "fk_aggregate_keys".to_string();
 
@@ -238,7 +237,7 @@ impl<'a> FullKeyAggregateStrategy for InnerJoinFullKeyAggregateStrategy<'a> {
 
             let data_select_builder =
                 SelectBuilder::new(From::new(FromSource::Single(multi_stage_source)));
-            let data_select = Rc::new(data_select_builder.build(sql_context));
+            let data_select = Rc::new(data_select_builder.build(query_tools.clone(), sql_context));
             data_queries.push(data_select);
         }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/keys_sub_query.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/keys_sub_query.rs
@@ -59,7 +59,7 @@ impl<'a> LogicalNodeProcessor<'a, KeysSubQuery> for KeysSubQueryProcessor<'a> {
         select_builder.set_filter(keys_subquery.filter.all_filters());
         let mut context_factory = context.make_sql_nodes_factory()?;
         context_factory.set_render_references(render_references);
-        let res = Rc::new(select_builder.build(context_factory));
+        let res = Rc::new(select_builder.build(query_tools.clone(), context_factory));
         Ok(res)
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/measure_subquery.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/measure_subquery.rs
@@ -22,7 +22,7 @@ impl<'a> LogicalNodeProcessor<'a, MeasureSubquery> for MeasureSubqueryProcessor<
         measure_subquery: &MeasureSubquery,
         context: &PushDownBuilderContext,
     ) -> Result<Self::PhysycalNode, CubeError> {
-        let _query_tools = self.builder.query_tools();
+        let query_tools = self.builder.query_tools();
         let mut render_references = HashMap::new();
         let from = self
             .builder
@@ -47,17 +47,17 @@ impl<'a> LogicalNodeProcessor<'a, MeasureSubquery> for MeasureSubqueryProcessor<
         )?;
         for dim in measure_subquery.schema.dimensions.iter() {
             select_builder
-                .add_projection_member(&dim.clone().as_base_member(_query_tools.clone())?, None);
+                .add_projection_member(&dim.clone().as_base_member(query_tools.clone())?, None);
         }
         for meas in measure_subquery.schema.measures.iter() {
             select_builder
-                .add_projection_member(&meas.clone().as_base_member(_query_tools.clone())?, None);
+                .add_projection_member(&meas.clone().as_base_member(query_tools.clone())?, None);
         }
 
         context_factory.set_ungrouped_measure(true);
         context_factory.set_render_references(render_references);
 
-        let select = Rc::new(select_builder.build(context_factory));
+        let select = Rc::new(select_builder.build(query_tools.clone(), context_factory));
         Ok(select)
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/multi_stage_get_date_range.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/multi_stage_get_date_range.rs
@@ -53,7 +53,7 @@ impl<'a> LogicalNodeProcessor<'a, MultiStageGetDateRange> for MultiStageGetDateR
             &mut render_references,
         )?;
         context_factory.set_render_references(render_references);
-        let select = Rc::new(select_builder.build(context_factory));
+        let select = Rc::new(select_builder.build(query_tools.clone(), context_factory));
         Ok(QueryPlan::Select(select))
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/multi_stage_measure_calculation.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/multi_stage_measure_calculation.rs
@@ -105,7 +105,7 @@ impl<'a> LogicalNodeProcessor<'a, MultiStageMeasureCalculation>
             MultiStageCalculationWindowFunction::None => {}
         }
         context_factory.set_render_references(render_references);
-        let select = Rc::new(select_builder.build(context_factory));
+        let select = Rc::new(select_builder.build(query_tools.clone(), context_factory));
         Ok(QueryPlan::Select(select))
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/multi_stage_rolling_window.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/multi_stage_rolling_window.rs
@@ -165,7 +165,7 @@ impl<'a> LogicalNodeProcessor<'a, MultiStageRollingWindow>
         }
 
         context_factory.set_render_references(render_references);
-        let select = Rc::new(select_builder.build(context_factory));
+        let select = Rc::new(select_builder.build(query_tools.clone(), context_factory));
         Ok(QueryPlan::Select(select))
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/query.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/processors/query.rs
@@ -149,7 +149,7 @@ impl<'a> LogicalNodeProcessor<'a, Query> for QueryProcessor<'a> {
                 .make_order_by(&logical_plan.schema, &logical_plan.modifers.order_by)?,
         );
 
-        let res = Rc::new(select_builder.build(context_factory));
+        let res = Rc::new(select_builder.build(query_tools.clone(), context_factory));
         Ok(res)
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs
@@ -4,6 +4,7 @@ use crate::plan::{
 };
 
 use crate::plan::expression::FunctionExpression;
+use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
 use crate::planner::{BaseMember, VisitorContext};
 use cubenativeutils::CubeError;
@@ -299,7 +300,7 @@ impl SelectBuilder {
         schema
     }
 
-    pub fn build(self, mut nodes_factory: SqlNodesFactory) -> Select {
+    pub fn build(self, query_tools: Rc<QueryTools>, mut nodes_factory: SqlNodesFactory) -> Select {
         let cube_references = Self::make_cube_references(self.from.clone());
         nodes_factory.set_cube_name_references(cube_references);
         let schema = if self.projection_columns.is_empty() {
@@ -314,7 +315,11 @@ impl SelectBuilder {
             group_by: self.group_by,
             having: self.having,
             order_by: self.order_by,
-            context: Rc::new(VisitorContext::new(&nodes_factory, self.filter)),
+            context: Rc::new(VisitorContext::new(
+                query_tools,
+                &nodes_factory,
+                self.filter,
+            )),
             ctes: self.ctes,
             is_distinct: self.is_distinct,
             limit: self.limit,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_cube.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_cube.rs
@@ -43,12 +43,7 @@ impl BaseCube {
         context: Rc<VisitorContext>,
         templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
-        let cube_sql = evaluate_with_context(
-            &self.member_evaluator,
-            self.query_tools.clone(),
-            context,
-            templates,
-        )?;
+        let cube_sql = evaluate_with_context(&self.member_evaluator, context, templates)?;
         Ok(cube_sql)
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs
@@ -25,12 +25,7 @@ impl BaseMember for BaseDimension {
         context: Rc<VisitorContext>,
         templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
-        evaluate_with_context(
-            &self.member_evaluator,
-            self.query_tools.clone(),
-            context,
-            templates,
-        )
+        evaluate_with_context(&self.member_evaluator, context, templates)
     }
 
     fn full_name(&self) -> String {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_join_condition.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_join_condition.rs
@@ -33,6 +33,6 @@ impl BaseJoinCondition for SqlJoinCondition {
         context: Rc<VisitorContext>,
         templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
-        evaluate_sql_call_with_context(&self.sql_call, self.query_tools.clone(), context, templates)
+        evaluate_sql_call_with_context(&self.sql_call, context, templates)
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
@@ -34,12 +34,7 @@ impl BaseMember for BaseMeasure {
         context: Rc<VisitorContext>,
         templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
-        evaluate_with_context(
-            &self.member_evaluator,
-            self.query_tools.clone(),
-            context,
-            templates,
-        )
+        evaluate_with_context(&self.member_evaluator, context, templates)
     }
 
     fn alias_name(&self) -> String {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
@@ -67,12 +67,7 @@ impl BaseMember for MemberSymbolRef {
         context: Rc<VisitorContext>,
         templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
-        evaluate_with_context(
-            &self.member_evaluator,
-            self.query_tools.clone(),
-            context,
-            templates,
-        )
+        evaluate_with_context(&self.member_evaluator, context, templates)
     }
 
     fn alias_name(&self) -> String {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
@@ -26,12 +26,7 @@ impl BaseMember for BaseTimeDimension {
         context: Rc<VisitorContext>,
         templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
-        evaluate_with_context(
-            &self.member_evaluator,
-            self.query_tools.clone(),
-            context,
-            templates,
-        )
+        evaluate_with_context(&self.member_evaluator, context, templates)
     }
 
     fn alias_name(&self) -> String {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
@@ -121,12 +121,7 @@ impl BaseFilter {
             self.measure_filter_where(context, plan_templates)
         } else {
             let symbol = self.member_evaluator();
-            let member_sql = evaluate_with_context(
-                &symbol,
-                self.query_tools.clone(),
-                context.clone(),
-                plan_templates,
-            )?;
+            let member_sql = evaluate_with_context(&symbol, context.clone(), plan_templates)?;
 
             let member_type = match symbol.as_ref() {
                 MemberSymbol::Dimension(dimension_symbol) => Some(
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_segment.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_segment.rs
@@ -52,12 +52,7 @@ impl BaseSegment {
         context: Rc<VisitorContext>,
         plan_templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
-        evaluate_with_context(
-            &self.member_evaluator,
-            self.query_tools.clone(),
-            context,
-            plan_templates,
-        )
+        evaluate_with_context(&self.member_evaluator, context, plan_templates)
     }
 
     pub fn full_name(&self) -> String {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/visitor_context.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/visitor_context.rs
@@ -13,17 +13,23 @@ pub struct FiltersContext {
 }
 
 pub struct VisitorContext {
+    query_tools: Rc<QueryTools>,
     node_processor: Rc<dyn SqlNode>,
     all_filters: Option<Filter>, //To pass to FILTER_PARAMS and FILTER_GROUP
     filters_context: FiltersContext,
 }
 
 impl VisitorContext {
-    pub fn new(nodes_factory: &SqlNodesFactory, all_filters: Option<Filter>) -> Self {
+    pub fn new(
+        query_tools: Rc<QueryTools>,
+        nodes_factory: &SqlNodesFactory,
+        all_filters: Option<Filter>,
+    ) -> Self {
         let filters_context = FiltersContext {
             use_local_tz: nodes_factory.use_local_tz_in_date_range(),
         };
         Self {
+            query_tools,
             node_processor: nodes_factory.default_node_processor(),
             all_filters,
             filters_context,
@@ -41,27 +47,29 @@ impl VisitorContext {
     pub fn filters_context(&self) -> &FiltersContext {
         &self.filters_context
     }
+
+    pub fn query_tools(&self) -> Rc<QueryTools> {
+        self.query_tools.clone()
+    }
 }
 
 pub fn evaluate_with_context(
     node: &Rc<MemberSymbol>,
-    query_tools: Rc<QueryTools>,
     context: Rc<VisitorContext>,
     templates: &PlanSqlTemplates,
 ) -> Result<String, CubeError> {
-    let visitor = context.make_visitor(query_tools);
+    let visitor = context.make_visitor(context.query_tools());
     let node_processor = context.node_processor();
 
     visitor.apply(node, node_processor, templates)
 }
 
 pub fn evaluate_sql_call_with_context(
     sql_call: &Rc<SqlCall>,
-    query_tools: Rc<QueryTools>,
     context: Rc<VisitorContext>,
     templates: &PlanSqlTemplates,
 ) -> Result<String, CubeError> {
-    let visitor = context.make_visitor(query_tools.clone());
+    let visitor = context.make_visitor(context.query_tools());
     let node_processor = context.node_processor();
-    sql_call.eval(&visitor, node_processor, query_tools, templates)
+    sql_call.eval(&visitor, node_processor, context.query_tools(), templates)
 }

Original file line number	Diff line number	Diff line change
`@@ -59,7 +59,7 @@ impl<'a> LogicalNodeProcessor<'a, KeysSubQuery> for KeysSubQueryProcessor<'a> {`
`59`	`59`	`select_builder.set_filter(keys_subquery.filter.all_filters());`
`60`	`60`	`let mut context_factory = context.make_sql_nodes_factory()?;`
`61`	`61`	`context_factory.set_render_references(render_references);`
`62`		`- let res = Rc::new(select_builder.build(context_factory));`
	`62`	`+ let res = Rc::new(select_builder.build(query_tools.clone(), context_factory));`
`63`	`63`	`Ok(res)`
`64`	`64`	`}`
`65`	`65`	`}`
Original file line number	Diff line number	Diff line change
`@@ -53,7 +53,7 @@ impl<'a> LogicalNodeProcessor<'a, MultiStageGetDateRange> for MultiStageGetDateR`
`53`	`53`	`&mut render_references,`
`54`	`54`	`)?;`
`55`	`55`	`context_factory.set_render_references(render_references);`
`56`		`- let select = Rc::new(select_builder.build(context_factory));`
	`56`	`+ let select = Rc::new(select_builder.build(query_tools.clone(), context_factory));`
`57`	`57`	`Ok(QueryPlan::Select(select))`
`58`	`58`	`}`
`59`	`59`	`}`
Original file line number	Diff line number	Diff line change
`@@ -105,7 +105,7 @@ impl<'a> LogicalNodeProcessor<'a, MultiStageMeasureCalculation>`
`105`	`105`	`MultiStageCalculationWindowFunction::None => {}`
`106`	`106`	`}`
`107`	`107`	`context_factory.set_render_references(render_references);`
`108`		`- let select = Rc::new(select_builder.build(context_factory));`
	`108`	`+ let select = Rc::new(select_builder.build(query_tools.clone(), context_factory));`
`109`	`109`	`Ok(QueryPlan::Select(select))`
`110`	`110`	`}`
`111`	`111`	`}`
Original file line number	Diff line number	Diff line change
`@@ -165,7 +165,7 @@ impl<'a> LogicalNodeProcessor<'a, MultiStageRollingWindow>`
`165`	`165`	`}`
`166`	`166`
`167`	`167`	`context_factory.set_render_references(render_references);`
`168`		`- let select = Rc::new(select_builder.build(context_factory));`
	`168`	`+ let select = Rc::new(select_builder.build(query_tools.clone(), context_factory));`
`169`	`169`	`Ok(QueryPlan::Select(select))`
`170`	`170`	`}`
`171`	`171`	`}`
Original file line number	Diff line number	Diff line change
`@@ -149,7 +149,7 @@ impl<'a> LogicalNodeProcessor<'a, Query> for QueryProcessor<'a> {`
`149`	`149`	`.make_order_by(&logical_plan.schema, &logical_plan.modifers.order_by)?,`
`150`	`150`	`);`
`151`	`151`
`152`		`- let res = Rc::new(select_builder.build(context_factory));`
	`152`	`+ let res = Rc::new(select_builder.build(query_tools.clone(), context_factory));`
`153`	`153`	`Ok(res)`
`154`	`154`	`}`
`155`	`155`	`}`