From 9aa99795829ee0bdb29483102326fe36d2a4787b Mon Sep 17 00:00:00 2001
From: Alexandr Romanenko <alex.romanenko@cube.dev>
Date: Thu, 16 Jan 2025 23:01:50 +0100
Subject: [PATCH 01/16] feat(tesseract): Subqueries support

---
 .../postgres/sql-generation-logic.test.ts     |   4 +-
 .../src/cube_bridge/dimension_definition.rs   |   4 +
 .../cubesqlplanner/src/plan/builder/select.rs |  16 ++
 .../cubesqlplanner/src/plan/filter.rs         |   1 +
 .../cubesqlplanner/src/plan/order.rs          |   1 +
 .../cubesqlplanner/src/plan/schema/schema.rs  |   2 +-
 .../cubesqlplanner/src/plan/select.rs         |   2 +
 .../src/planner/base_dimension.rs             |  25 ++-
 .../src/planner/base_measure.rs               |  76 +++++--
 .../cubesqlplanner/src/planner/base_query.rs  |  47 +---
 .../src/planner/base_time_dimension.rs        |  22 +-
 .../src/planner/planners/common_utils.rs      |   6 +-
 .../planners/dimension_subquery_planner.rs    | 203 ++++++++++++++++++
 .../full_key_query_aggregate_planner.rs       |   6 +-
 .../src/planner/planners/join_planner.rs      |  10 +-
 .../src/planner/planners/mod.rs               |   4 +
 .../multi_stage/member_query_planner.rs       |   2 +-
 .../multiplied_measures_query_planner.rs      |  88 ++++++--
 .../src/planner/planners/query_planner.rs     |  70 ++++++
 .../planner/planners/simple_query_planer.rs   |  37 ++--
 .../collectors/cube_names_collector.rs        |   9 +
 .../collectors/join_hints_collector.rs        |   9 +
 .../planner/sql_evaluator/collectors/mod.rs   |   4 +
 .../collectors/sub_query_dimensions.rs        |  79 +++++++
 .../src/planner/sql_evaluator/mod.rs          |   2 +-
 .../src/planner/sql_evaluator/sql_call.rs     |  12 ++
 .../sql_evaluator/sql_nodes/evaluate_sql.rs   |  15 ++
 .../sql_evaluator/sql_nodes/factory.rs        |  13 --
 .../sql_nodes/leaf_time_dimension.rs          |  55 -----
 .../planner/sql_evaluator/sql_nodes/mod.rs    |   1 -
 .../sql_evaluator/symbols/dimension_symbol.rs |  13 ++
 .../sql_evaluator/symbols/member_symbol.rs    |  21 +-
 .../src/planner/sql_evaluator/symbols/mod.rs  |   3 +
 .../symbols/time_dimension_symbol.rs          |  44 ++++
 34 files changed, 721 insertions(+), 185 deletions(-)
 create mode 100644 rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs
 create mode 100644 rust/cubesqlplanner/cubesqlplanner/src/planner/planners/query_planner.rs
 create mode 100644 rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/sub_query_dimensions.rs
 delete mode 100644 rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/leaf_time_dimension.rs
 create mode 100644 rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs

diff --git a/packages/cubejs-schema-compiler/test/integration/postgres/sql-generation-logic.test.ts b/packages/cubejs-schema-compiler/test/integration/postgres/sql-generation-logic.test.ts
index c902b7d1faf37..e8d6d6e4b2aac 100644
--- a/packages/cubejs-schema-compiler/test/integration/postgres/sql-generation-logic.test.ts
+++ b/packages/cubejs-schema-compiler/test/integration/postgres/sql-generation-logic.test.ts
@@ -453,7 +453,7 @@ describe('SQL Generation', () => {
     }
   });
 
-  it('having filter with operator OR 1', async () => {
+  it('having filter with operator OR', async () => {
     await compiler.compile();
 
     const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
@@ -648,7 +648,7 @@ describe('SQL Generation', () => {
     });
   });
 
-  it('where filter with operators OR & AND 1', async () => {
+  it('where filter with operators OR & AND', async () => {
     await compiler.compile();
 
     const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/dimension_definition.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/dimension_definition.rs
index c4936c31259ac..ed99896573500 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/dimension_definition.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/dimension_definition.rs
@@ -17,6 +17,10 @@ pub struct DimenstionDefinitionStatic {
     pub owned_by_cube: Option<bool>,
     #[serde(rename = "multiStage")]
     pub multi_stage: Option<bool>,
+    #[serde(rename = "subQuery")]
+    pub sub_query: Option<bool>,
+    #[serde(rename = "propagateFiltersToSubQuery")]
+    pub propagate_filters_to_sub_query: Option<bool>,
 }
 
 #[nativebridge::native_bridge(DimenstionDefinitionStatic)]
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs
index 1a9482f68715f..0631a868cec13 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs
@@ -40,6 +40,22 @@ impl SelectBuilder {
         }
     }
 
+    pub fn new_from_select(select: Rc<Select>) -> Self {
+        Self {
+            projection_columns: select.projection_columns.clone(),
+            from: select.from.clone(),
+            filter: select.filter.clone(),
+            group_by: select.group_by.clone(),
+            having: select.having.clone(),
+            order_by: select.order_by.clone(),
+            ctes: select.ctes.clone(),
+            is_distinct: select.is_distinct,
+            limit: select.limit,
+            offset: select.offset,
+            result_schema: Schema::clone(&select.schema),
+        }
+    }
+
     pub fn add_projection_member(&mut self, member: &Rc<dyn BaseMember>, alias: Option<String>) {
         let alias = if let Some(alias) = alias {
             alias
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs
index 123463e24075f..e996179229c94 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs
@@ -36,6 +36,7 @@ pub enum FilterItem {
     Item(Rc<BaseFilter>),
 }
 
+#[derive(Clone)]
 pub struct Filter {
     pub items: Vec<FilterItem>,
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/order.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/order.rs
index c9db9a6b4b3de..1596a359826e0 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/order.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/order.rs
@@ -1,5 +1,6 @@
 use super::Expr;
 
+#[derive(Clone)]
 pub struct OrderBy {
     pub expr: Expr,
     pub pos: usize,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/schema/schema.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/schema/schema.rs
index 52ed83390c10e..cfbc4a43b75f7 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/schema/schema.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/schema/schema.rs
@@ -3,7 +3,7 @@ use crate::planner::BaseMember;
 use itertools::Itertools;
 use std::rc::Rc;
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Schema {
     columns: Vec<SchemaColumn>,
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/select.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/select.rs
index 2c37717014cf9..ef0dd3cc4749f 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/select.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/select.rs
@@ -7,6 +7,7 @@ use crate::planner::VisitorContext;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
+#[derive(Clone)]
 pub struct AliasedExpr {
     pub expr: Expr,
     pub alias: String,
@@ -32,6 +33,7 @@ impl AliasedExpr {
     }
 }
 
+#[derive(Clone)]
 pub struct Select {
     pub(super) projection_columns: Vec<AliasedExpr>,
     pub(super) from: Rc<From>,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs
index bca6d99ca2a34..160f3a1ec2b3a 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs
@@ -1,6 +1,7 @@
 use super::query_tools::QueryTools;
-use super::sql_evaluator::MemberSymbol;
+use super::sql_evaluator::{MemberSymbol, SqlCall};
 use super::{evaluate_with_context, BaseMember, BaseMemberHelper, VisitorContext};
+use crate::cube_bridge::dimension_definition::DimensionDefinition;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
@@ -8,6 +9,7 @@ pub struct BaseDimension {
     dimension: String,
     query_tools: Rc<QueryTools>,
     member_evaluator: Rc<MemberSymbol>,
+    definition: Rc<dyn DimensionDefinition>,
     cube_name: String,
     name: String,
     default_alias: String,
@@ -58,6 +60,7 @@ impl BaseDimension {
                     member_evaluator: evaluation_node.clone(),
                     cube_name: s.cube_name().clone(),
                     name: s.name().clone(),
+                    definition: s.definition().clone(),
                     default_alias,
                 }))
             }
@@ -83,7 +86,27 @@ impl BaseDimension {
         self.member_evaluator.clone()
     }
 
+    pub fn sql_call(&self) -> Result<Rc<SqlCall>, CubeError> {
+        match self.member_evaluator.as_ref() {
+            MemberSymbol::Dimension(d) => Ok(d.member_sql().clone()),
+            _ => Err(CubeError::internal(format!(
+                "MemberSymbol::Dimension expected"
+            ))),
+        }
+    }
+
     pub fn dimension(&self) -> &String {
         &self.dimension
     }
+
+    pub fn is_sub_query(&self) -> bool {
+        self.definition.static_data().sub_query.unwrap_or(false)
+    }
+
+    pub fn propagate_filters_to_sub_query(&self) -> bool {
+        self.definition
+            .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
index e61724563d367..16cd3bd7f0676 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
@@ -1,5 +1,5 @@
 use super::query_tools::QueryTools;
-use super::sql_evaluator::MemberSymbol;
+use super::sql_evaluator::{MemberSymbol, SqlCall};
 use super::{evaluate_with_context, BaseMember, BaseMemberHelper, VisitorContext};
 use crate::cube_bridge::measure_definition::{
     MeasureDefinition, RollingWindow, TimeShiftReference,
@@ -66,7 +66,7 @@ pub struct BaseMeasure {
     measure: String,
     query_tools: Rc<QueryTools>,
     member_evaluator: Rc<MemberSymbol>,
-    definition: Rc<dyn MeasureDefinition>,
+    definition: Option<Rc<dyn MeasureDefinition>>,
     time_shifts: Vec<MeasureTimeShift>,
     cube_name: String,
     name: String,
@@ -100,6 +100,10 @@ impl BaseMember for BaseMeasure {
         self.clone()
     }
 
+    fn full_name(&self) -> String {
+        format!("{}.{}", self.cube_name, self.name)
+    }
+
     fn cube_name(&self) -> &String {
         &self.cube_name
     }
@@ -127,7 +131,7 @@ impl BaseMeasure {
                     measure: s.full_name(),
                     query_tools: query_tools.clone(),
                     member_evaluator: evaluation_node.clone(),
-                    definition: s.definition().clone(),
+                    definition: Some(s.definition().clone()),
                     cube_name: s.cube_name().clone(),
                     name: s.name().clone(),
                     time_shifts,
@@ -152,6 +156,28 @@ impl BaseMeasure {
         }
     }
 
+    pub fn try_new_from_expression(
+        expression: Rc<SqlCall>,
+        cube_name: String,
+        name: String,
+        query_tools: Rc<QueryTools>,
+    ) -> Result<Self, CubeError> {
+        let full_name = format!("{}.{}", cube_name, name);
+        let member_evaluator = Rc::new(MemberSymbol::SqlCall(expression));
+        let default_alias =
+            BaseMemberHelper::default_alias(&cube_name, &name, &None, query_tools.clone())?;
+        Ok(Self {
+            measure: full_name,
+            query_tools,
+            member_evaluator,
+            definition: None,
+            cube_name,
+            name,
+            default_alias,
+            time_shifts: vec![],
+        })
+    }
+
     fn parse_time_shifts(
         definition: &Rc<dyn MeasureDefinition>,
     ) -> Result<Vec<MeasureTimeShift>, CubeError> {
@@ -177,28 +203,36 @@ impl BaseMeasure {
         &self.cube_name
     }
 
-    pub fn reduce_by(&self) -> &Option<Vec<String>> {
-        &self.definition.static_data().reduce_by_references
+    pub fn reduce_by(&self) -> Option<Vec<String>> {
+        self.definition
+            .as_ref()
+            .map_or(None, |d| d.static_data().reduce_by_references.clone())
     }
 
-    pub fn add_group_by(&self) -> &Option<Vec<String>> {
-        &self.definition.static_data().add_group_by_references
+    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())
     }
 
-    pub fn group_by(&self) -> &Option<Vec<String>> {
-        &self.definition.static_data().group_by_references
+    pub fn group_by(&self) -> Option<Vec<String>> {
+        self.definition
+            .as_ref()
+            .map_or(None, |d| d.static_data().group_by_references.clone())
     }
 
     //FIXME dublicate with symbol
     pub fn is_calculated(&self) -> bool {
-        match self.definition.static_data().measure_type.as_str() {
+        match self.measure_type() {
             "number" | "string" | "time" | "boolean" => true,
             _ => false,
         }
     }
 
-    pub fn time_shift_references(&self) -> &Option<Vec<TimeShiftReference>> {
-        &self.definition.static_data().time_shift_references
+    pub fn time_shift_references(&self) -> Option<Vec<TimeShiftReference>> {
+        self.definition
+            .as_ref()
+            .map_or(None, |d| d.static_data().time_shift_references.clone())
     }
 
     pub fn time_shifts(&self) -> &Vec<MeasureTimeShift> {
@@ -206,11 +240,15 @@ impl BaseMeasure {
     }
 
     pub fn is_multi_stage(&self) -> bool {
-        self.definition.static_data().multi_stage.unwrap_or(false)
+        self.definition
+            .as_ref()
+            .map_or(false, |d| d.static_data().multi_stage.unwrap_or(false))
     }
 
-    pub fn rolling_window(&self) -> &Option<RollingWindow> {
-        &self.definition.static_data().rolling_window
+    pub fn rolling_window(&self) -> Option<RollingWindow> {
+        self.definition
+            .as_ref()
+            .map_or(None, |d| d.static_data().rolling_window.clone())
     }
 
     pub fn is_rolling_window(&self) -> bool {
@@ -226,11 +264,13 @@ impl BaseMeasure {
     }
 
     //FIXME dublicate with symbol
-    pub fn measure_type(&self) -> &String {
-        &self.definition.static_data().measure_type
+    pub fn measure_type(&self) -> &str {
+        self.definition
+            .as_ref()
+            .map_or("number", |d| &d.static_data().measure_type)
     }
 
     pub fn is_multi_stage_ungroupped(&self) -> bool {
-        self.is_calculated() || self.definition.static_data().measure_type == "rank"
+        self.is_calculated() || self.measure_type() == "rank"
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
index 6e59585e4fbbf..1b1613e77d725 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
@@ -1,12 +1,7 @@
-use super::planners::{
-    FullKeyAggregateQueryPlanner, MultiStageQueryPlanner, MultipliedMeasuresQueryPlanner,
-    SimpleQueryPlanner,
-};
+use super::planners::QueryPlanner;
 use super::query_tools::QueryTools;
 use super::QueryProperties;
 use crate::cube_bridge::base_query_options::BaseQueryOptions;
-use crate::plan::Select;
-use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
 use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::wrappers::inner_types::InnerTypes;
 use cubenativeutils::wrappers::object::NativeArray;
@@ -45,7 +40,8 @@ impl<IT: InnerTypes> BaseQuery<IT> {
 
     pub fn build_sql_and_params(&self) -> Result<NativeObjectHandle<IT>, CubeError> {
         let templates = PlanSqlTemplates::new(self.query_tools.templates_render());
-        let plan = self.build_sql_and_params_impl(templates.clone())?;
+        let query_planner = QueryPlanner::new(self.request.clone(), self.query_tools.clone());
+        let plan = query_planner.build_sql()?;
 
         let sql = plan.to_sql(&templates)?;
         let (result_sql, params) = self.query_tools.build_sql_and_params(&sql, true)?;
@@ -57,41 +53,4 @@ impl<IT: InnerTypes> BaseQuery<IT> {
 
         Ok(result)
     }
-
-    fn build_sql_and_params_impl(&self, templates: PlanSqlTemplates) -> Result<Select, CubeError> {
-        let mut nodes_factory = SqlNodesFactory::new();
-
-        if self.request.ungrouped() {
-            nodes_factory.set_ungrouped(true)
-        }
-
-        if self.request.is_simple_query()? {
-            let planner = SimpleQueryPlanner::new(
-                self.query_tools.clone(),
-                self.request.clone(),
-                nodes_factory.clone(),
-            );
-            planner.plan()
-        } else {
-            let request = self.request.clone();
-            let multiplied_measures_query_planner = MultipliedMeasuresQueryPlanner::new(
-                self.query_tools.clone(),
-                request.clone(),
-                nodes_factory.clone(),
-            );
-            let multi_stage_query_planner =
-                MultiStageQueryPlanner::new(self.query_tools.clone(), request.clone());
-            let full_key_aggregate_planner = FullKeyAggregateQueryPlanner::new(
-                request.clone(),
-                nodes_factory.clone(),
-                templates,
-            );
-            let mut subqueries = multiplied_measures_query_planner.plan_queries()?;
-            let (multi_stage_ctes, multi_stage_subqueries) =
-                multi_stage_query_planner.plan_queries()?;
-            subqueries.extend(multi_stage_subqueries.into_iter());
-            let result = full_key_aggregate_planner.plan(subqueries, multi_stage_ctes)?;
-            Ok(result)
-        }
-    }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
index cd0ad89812f1d..462709995e525 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
@@ -1,12 +1,13 @@
 use super::query_tools::QueryTools;
-use super::sql_evaluator::MemberSymbol;
+use super::sql_evaluator::{MemberSymbol, TimeDimensionSymbol};
 use super::BaseDimension;
-use super::{BaseMember, BaseMemberHelper, VisitorContext};
+use super::{evaluate_with_context, BaseMember, BaseMemberHelper, VisitorContext};
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
 pub struct BaseTimeDimension {
     dimension: Rc<BaseDimension>,
+    member_evaluator: Rc<MemberSymbol>,
     query_tools: Rc<QueryTools>,
     granularity: Option<String>,
     date_range: Option<Vec<String>>,
@@ -16,7 +17,7 @@ pub struct BaseTimeDimension {
 
 impl BaseMember for BaseTimeDimension {
     fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
-        self.dimension.to_sql(context)
+        evaluate_with_context(&self.member_evaluator, self.query_tools.clone(), context)
     }
 
     fn alias_name(&self) -> String {
@@ -24,7 +25,7 @@ impl BaseMember for BaseTimeDimension {
     }
 
     fn member_evaluator(&self) -> Rc<MemberSymbol> {
-        self.dimension.member_evaluator()
+        self.member_evaluator.clone()
     }
 
     fn as_base_member(self: Rc<Self>) -> Rc<dyn BaseMember> {
@@ -56,13 +57,18 @@ impl BaseTimeDimension {
         } else {
             "day".to_string()
         };
-        let dimension = BaseDimension::try_new_required(member_evaluator, query_tools.clone())?;
+        let dimension =
+            BaseDimension::try_new_required(member_evaluator.clone(), query_tools.clone())?;
         let default_alias = BaseMemberHelper::default_alias(
             &dimension.cube_name(),
             &dimension.name(),
             &Some(alias_suffix.clone()),
             query_tools.clone(),
         )?;
+        let member_evaluator = Rc::new(MemberSymbol::TimeDimension(TimeDimensionSymbol::new(
+            member_evaluator.clone(),
+            granularity.clone(),
+        )));
         Ok(Rc::new(Self {
             dimension,
             query_tools,
@@ -70,10 +76,15 @@ impl BaseTimeDimension {
             date_range,
             alias_suffix,
             default_alias,
+            member_evaluator,
         }))
     }
 
     pub fn change_granularity(&self, new_granularity: Option<String>) -> Rc<Self> {
+        let member_evaluator = Rc::new(MemberSymbol::TimeDimension(TimeDimensionSymbol::new(
+            self.dimension.member_evaluator(),
+            new_granularity.clone(),
+        )));
         Rc::new(Self {
             dimension: self.dimension.clone(),
             query_tools: self.query_tools.clone(),
@@ -81,6 +92,7 @@ impl BaseTimeDimension {
             date_range: self.date_range.clone(),
             alias_suffix: self.alias_suffix.clone(),
             default_alias: self.default_alias.clone(),
+            member_evaluator,
         })
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/common_utils.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/common_utils.rs
index 442700dca052d..ab32cb81284ab 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/common_utils.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/common_utils.rs
@@ -1,5 +1,5 @@
 use crate::planner::query_tools::QueryTools;
-use crate::planner::{BaseCube, BaseDimension, BaseMember};
+use crate::planner::{BaseCube, BaseDimension};
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
@@ -23,7 +23,7 @@ impl CommonUtils {
     pub fn primary_keys_dimensions(
         &self,
         cube_name: &String,
-    ) -> Result<Vec<Rc<dyn BaseMember>>, CubeError> {
+    ) -> Result<Vec<Rc<BaseDimension>>, CubeError> {
         let evaluator_compiler_cell = self.query_tools.evaluator_compiler().clone();
         let mut evaluator_compiler = evaluator_compiler_cell.borrow_mut();
         let primary_keys = self
@@ -40,7 +40,7 @@ impl CommonUtils {
                 let full_name = format!("{}.{}", cube_name, d);
                 let evaluator = evaluator_compiler.add_dimension_evaluator(full_name.clone())?;
                 let dim = BaseDimension::try_new_required(evaluator, self.query_tools.clone())?;
-                Ok(dim.as_base_member())
+                Ok(dim)
             })
             .collect::<Result<Vec<_>, _>>()?;
         Ok(dims)
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs
new file mode 100644
index 0000000000000..5b6fee5cdd235
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs
@@ -0,0 +1,203 @@
+use super::{CommonUtils, QueryPlanner};
+use crate::plan::{Expr, FilterItem, JoinBuilder, JoinCondition, QualifiedColumnName};
+use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::collectors::collect_sub_query_dimensions;
+use crate::planner::QueryProperties;
+use crate::planner::{BaseDimension, BaseMeasure, BaseMember};
+use cubenativeutils::CubeError;
+use itertools::Itertools;
+use std::cell::{Ref, RefCell};
+use std::collections::HashMap;
+use std::rc::Rc;
+
+pub struct DimensionSubqueryPlanner {
+    utils: CommonUtils,
+    query_tools: Rc<QueryTools>,
+    query_properties: Rc<QueryProperties>,
+    sub_query_dims: HashMap<String, Vec<Rc<BaseDimension>>>,
+    dimensions_refs: RefCell<HashMap<String, QualifiedColumnName>>,
+}
+
+impl DimensionSubqueryPlanner {
+    pub fn empty(query_tools: Rc<QueryTools>, query_properties: Rc<QueryProperties>) -> Self {
+        Self {
+            sub_query_dims: HashMap::new(),
+            utils: CommonUtils::new(query_tools.clone()),
+            query_tools,
+            query_properties,
+            dimensions_refs: RefCell::new(HashMap::new()),
+        }
+    }
+    pub fn try_new(
+        dimensions: &Vec<Rc<BaseDimension>>,
+        query_tools: Rc<QueryTools>,
+        query_properties: Rc<QueryProperties>,
+    ) -> Result<Self, CubeError> {
+        let mut sub_query_dims: HashMap<String, Vec<Rc<BaseDimension>>> = HashMap::new();
+        for subquery_dimension in dimensions.iter() {
+            let cube_name = subquery_dimension.cube_name().clone();
+            sub_query_dims
+                .entry(cube_name.clone())
+                .or_default()
+                .push(subquery_dimension.clone());
+        }
+
+        Ok(Self {
+            sub_query_dims,
+            utils: CommonUtils::new(query_tools.clone()),
+            query_tools,
+            query_properties,
+            dimensions_refs: RefCell::new(HashMap::new()),
+        })
+    }
+
+    pub fn add_joins_for_cube(
+        &self,
+        builder: &mut JoinBuilder,
+        cube_name: &String,
+    ) -> Result<(), CubeError> {
+        if let Some(sub_query_dims) = self.sub_query_dims.get(cube_name) {
+            let primary_keys_dimensions = self.utils.primary_keys_dimensions(cube_name)?;
+            for dim in sub_query_dims.iter() {
+                self.add_join_impl(builder, cube_name, &primary_keys_dimensions, dim.clone())?
+            }
+        }
+        Ok(())
+    }
+
+    pub fn add_join(
+        &self,
+        builder: &mut JoinBuilder,
+        subquery_dimension: Rc<BaseDimension>,
+    ) -> Result<(), CubeError> {
+        let cube_name = subquery_dimension.cube_name();
+        let primary_keys_dimensions = self.utils.primary_keys_dimensions(cube_name)?;
+        self.add_join_impl(
+            builder,
+            cube_name,
+            &primary_keys_dimensions,
+            subquery_dimension.clone(),
+        )
+    }
+
+    fn add_join_impl(
+        &self,
+        builder: &mut JoinBuilder,
+        cube_name: &String,
+        primary_keys_dimensions: &Vec<Rc<BaseDimension>>,
+        subquery_dimension: Rc<BaseDimension>,
+    ) -> Result<(), CubeError> {
+        let dim_name = subquery_dimension.name();
+        let dim_full_name = subquery_dimension.full_name();
+        let expression = subquery_dimension.sql_call()?;
+        let measure = BaseMeasure::try_new_from_expression(
+            expression,
+            cube_name.clone(),
+            dim_name.clone(),
+            self.query_tools.clone(),
+        )?;
+
+        let (dimensions_filters, time_dimensions_filters) = if subquery_dimension
+            .propagate_filters_to_sub_query()
+        {
+            let dimensions_filters = self
+                .extract_filters_without_subqueries(self.query_properties.dimensions_filters())?;
+            let time_dimensions_filters = self.extract_filters_without_subqueries(
+                self.query_properties.time_dimensions_filters(),
+            )?;
+            (dimensions_filters, time_dimensions_filters)
+        } else {
+            (vec![], vec![])
+        };
+
+        let sub_query_properties = QueryProperties::try_new_from_precompiled(
+            self.query_tools.clone(),
+            vec![Rc::new(measure)], //measures,
+            primary_keys_dimensions.clone(),
+            vec![],
+            time_dimensions_filters,
+            dimensions_filters,
+            vec![],
+            vec![],
+            None,
+            None,
+            true,
+            false,
+        )?;
+        let query_planner = QueryPlanner::new(sub_query_properties, self.query_tools.clone());
+        let sub_query = query_planner.build_sql()?;
+        let sub_query_alias = format!("{cube_name}_{dim_name}_subquery");
+
+        let conditions = primary_keys_dimensions
+            .iter()
+            .map(|dim| {
+                let dim = dim.clone().as_base_member();
+                let alias_in_sub_query = sub_query.schema().resolve_member_alias(&dim);
+                let sub_query_ref = Expr::Reference(QualifiedColumnName::new(
+                    Some(sub_query_alias.clone()),
+                    alias_in_sub_query.clone(),
+                ));
+
+                vec![(sub_query_ref, Expr::new_member(dim))]
+            })
+            .collect_vec();
+
+        if let Some(dim_ref) = sub_query.schema().resolve_member_reference(&dim_full_name) {
+            let qualified_column_name =
+                QualifiedColumnName::new(Some(sub_query_alias.clone()), dim_ref);
+            self.dimensions_refs
+                .borrow_mut()
+                .insert(dim_full_name.clone(), qualified_column_name);
+        } else {
+            return Err(CubeError::internal(format!(
+                "Can't find source for subquery dimension {}",
+                dim_name
+            )));
+        }
+
+        builder.left_join_subselect(
+            sub_query,
+            sub_query_alias,
+            JoinCondition::new_dimension_join(conditions, false),
+        );
+        Ok(())
+    }
+
+    fn extract_filters_without_subqueries(
+        &self,
+        filters: &Vec<FilterItem>,
+    ) -> Result<Vec<FilterItem>, CubeError> {
+        let mut result = vec![];
+        for item in filters.iter() {
+            if self.is_filter_without_subqueries(item)? {
+                result.push(item.clone());
+            }
+        }
+
+        Ok(result)
+    }
+
+    fn is_filter_without_subqueries(&self, filter_item: &FilterItem) -> Result<bool, CubeError> {
+        match filter_item {
+            FilterItem::Group(group) => {
+                for item in group.items.iter() {
+                    if !self.is_filter_without_subqueries(item)? {
+                        return Ok(false);
+                    }
+                }
+                Ok(true)
+            }
+            FilterItem::Item(filter_item) => {
+                Ok(collect_sub_query_dimensions(&filter_item.member_evaluator())?.is_empty())
+            }
+        }
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.sub_query_dims.is_empty()
+    }
+
+    pub fn dimensions_refs(&self) -> Ref<HashMap<String, QualifiedColumnName>> {
+        self.dimensions_refs.borrow()
+    }
+}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/full_key_query_aggregate_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/full_key_query_aggregate_planner.rs
index fdb91795548d2..0569382056f38 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/full_key_query_aggregate_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/full_key_query_aggregate_planner.rs
@@ -35,7 +35,7 @@ impl FullKeyAggregateQueryPlanner {
         }
     }
 
-    pub fn plan(self, joins: Vec<Rc<Select>>, ctes: Vec<Rc<Cte>>) -> Result<Select, CubeError> {
+    pub fn plan(self, joins: Vec<Rc<Select>>, ctes: Vec<Rc<Cte>>) -> Result<Rc<Select>, CubeError> {
         if self.query_properties.is_simple_query()? {
             return Err(CubeError::internal(format!(
                 "FullKeyAggregateQueryPlanner should not be used for simple query"
@@ -56,7 +56,7 @@ impl FullKeyAggregateQueryPlanner {
         outer_measures: &Vec<Rc<BaseMeasure>>,
         joins: Vec<Rc<Select>>,
         ctes: Vec<Rc<Cte>>,
-    ) -> Result<Select, CubeError> {
+    ) -> Result<Rc<Select>, CubeError> {
         let mut join_builder = JoinBuilder::new_from_subselect(joins[0].clone(), format!("q_0"));
         let dimensions_to_select = self.query_properties.dimensions_for_select();
         for (i, join) in joins.iter().enumerate().skip(1) {
@@ -161,6 +161,6 @@ impl FullKeyAggregateQueryPlanner {
         let mut context_factory = self.context_factory.clone();
         context_factory.set_render_references(render_references);
 
-        Ok(select_builder.build(context_factory))
+        Ok(Rc::new(select_builder.build(context_factory)))
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs
index 6a0bab5378db3..cb3daafad4973 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs
@@ -1,4 +1,4 @@
-use super::CommonUtils;
+use super::{CommonUtils, DimensionSubqueryPlanner};
 use crate::cube_bridge::join_definition::JoinDefinition;
 use crate::cube_bridge::memeber_sql::MemberSql;
 use crate::plan::{From, JoinBuilder, JoinCondition};
@@ -25,25 +25,28 @@ impl JoinPlanner {
         &self,
         alias_prefix: &Option<String>, /*TODO dimensions for subqueries*/
         join_hints: Vec<String>,
+        dimension_subquery_planner: &DimensionSubqueryPlanner,
     ) -> Result<Rc<From>, CubeError> {
         let join = self.query_tools.join_graph().build_join(join_hints)?;
-        self.make_join_node_impl(alias_prefix, join)
+        self.make_join_node_impl(alias_prefix, join, dimension_subquery_planner)
     }
 
     pub fn make_join_node_impl(
         &self,
         alias_prefix: &Option<String>,
         join: Rc<dyn JoinDefinition>,
+        dimension_subquery_planner: &DimensionSubqueryPlanner,
     ) -> Result<Rc<From>, CubeError> {
         let root = self.utils.cube_from_path(join.static_data().root.clone())?;
         let joins = join.joins()?;
-        if joins.items().is_empty() {
+        if joins.items().is_empty() && dimension_subquery_planner.is_empty() {
             Ok(From::new_from_cube(root, None))
         } else {
             let mut join_builder = JoinBuilder::new_from_cube(
                 root.clone(),
                 Some(root.default_alias_with_prefix(alias_prefix)),
             );
+            dimension_subquery_planner.add_joins_for_cube(&mut join_builder, root.name())?;
             for join in joins.items().iter() {
                 let definition = join.join()?;
                 let sql_call = self
@@ -60,6 +63,7 @@ impl JoinPlanner {
                     Some(cube.default_alias_with_prefix(alias_prefix)),
                     on,
                 );
+                dimension_subquery_planner.add_joins_for_cube(&mut join_builder, cube.name())?;
             }
             let result = From::new_from_join(join_builder.build());
             Ok(result)
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/mod.rs
index 8356778b08ac6..72f0fba465109 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/mod.rs
@@ -1,16 +1,20 @@
 pub mod common_utils;
+pub mod dimension_subquery_planner;
 pub mod full_key_query_aggregate_planner;
 pub mod join_planner;
 pub mod multi_stage;
 pub mod multi_stage_query_planner;
 pub mod multiplied_measures_query_planner;
 pub mod order_planner;
+pub mod query_planner;
 pub mod simple_query_planer;
 
 pub use common_utils::CommonUtils;
+pub use dimension_subquery_planner::DimensionSubqueryPlanner;
 pub use full_key_query_aggregate_planner::FullKeyAggregateQueryPlanner;
 pub use join_planner::JoinPlanner;
 pub use multi_stage_query_planner::MultiStageQueryPlanner;
 pub use multiplied_measures_query_planner::MultipliedMeasuresQueryPlanner;
 pub use order_planner::OrderPlanner;
+pub use query_planner::QueryPlanner;
 pub use simple_query_planer::SimpleQueryPlanner;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs
index fd0c237164271..199017ab1b8ce 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs
@@ -393,7 +393,7 @@ impl MultiStageMemberQueryPlanner {
             let result = full_key_aggregate_planner.plan(subqueries, vec![])?;
             result
         };
-        let result = Cte::new_from_select(Rc::new(cte_select), self.description.alias().clone());
+        let result = Cte::new_from_select(cte_select, self.description.alias().clone());
         Ok(Rc::new(result))
     }
 
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
index 14ecfd86aa0e5..490b9a86dd689 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multiplied_measures_query_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multiplied_measures_query_planner.rs
@@ -1,4 +1,4 @@
-use super::{CommonUtils, JoinPlanner};
+use super::{CommonUtils, DimensionSubqueryPlanner, JoinPlanner};
 use crate::cube_bridge::join_definition::JoinDefinition;
 use crate::plan::{
     Expr, From, JoinBuilder, JoinCondition, MemberExpression, QualifiedColumnName, Select,
@@ -7,6 +7,7 @@ use crate::plan::{
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::collectors::{
     collect_cube_names, collect_join_hints, collect_join_hints_for_measures,
+    collect_sub_query_dimensions_from_members,
 };
 use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
 use crate::planner::sql_evaluator::ReferencesBuilder;
@@ -101,7 +102,23 @@ impl MultipliedMeasuresQueryPlanner {
         measures: &Vec<Rc<BaseMeasure>>,
         key_join: Rc<dyn JoinDefinition>,
     ) -> Result<Rc<Select>, CubeError> {
-        let primary_keys_dimensions = self.common_utils.primary_keys_dimensions(key_cube_name)?;
+        let subquery_dimensions = collect_sub_query_dimensions_from_members(
+            &BaseMemberHelper::iter_as_base_member(measures).collect_vec(),
+            self.query_tools.clone(),
+        )?;
+
+        let dimension_subquery_planner = DimensionSubqueryPlanner::try_new(
+            &subquery_dimensions,
+            self.query_tools.clone(),
+            self.query_properties.clone(),
+        )?;
+
+        let primary_keys_dimensions = self
+            .common_utils
+            .primary_keys_dimensions(key_cube_name)?
+            .into_iter()
+            .map(|d| d.as_base_member())
+            .collect_vec();
         let keys_query = self.key_query(&primary_keys_dimensions, key_join, key_cube_name)?;
         let keys_query_alias = format!("keys");
         let should_build_join_for_measure_select =
@@ -119,6 +136,7 @@ impl MultipliedMeasuresQueryPlanner {
                 key_cube_name,
                 &measures,
                 &primary_keys_dimensions,
+                &dimension_subquery_planner,
             )?;
 
             let conditions = primary_keys_dimensions
@@ -173,12 +191,15 @@ impl MultipliedMeasuresQueryPlanner {
                 Some(pk_cube_alias.clone()),
                 JoinCondition::new_dimension_join(conditions, false),
             );
+            for sub_dim in subquery_dimensions.iter() {
+                dimension_subquery_planner.add_join(&mut join_builder, sub_dim.clone())?;
+            }
         };
 
         let from = From::new_from_join(join_builder.build());
         let references_builder = ReferencesBuilder::new(from.clone());
         let mut select_builder = SelectBuilder::new(from.clone());
-        let mut render_references = HashMap::new();
+        let mut render_references = dimension_subquery_planner.dimensions_refs().clone();
         for member in self
             .query_properties
             .all_dimensions_and_measures(&vec![])?
@@ -241,13 +262,19 @@ impl MultipliedMeasuresQueryPlanner {
         _key_cube_name: &String,
         measures: &Vec<Rc<BaseMeasure>>,
         primary_keys_dimensions: &Vec<Rc<dyn BaseMember>>,
+        dimension_subquery_planner: &DimensionSubqueryPlanner,
     ) -> Result<Rc<Select>, CubeError> {
         let join_hints = collect_join_hints_for_measures(measures)?;
         let from = self
             .join_planner
-            .make_join_node_with_prefix_and_join_hints(&None, join_hints)?;
+            .make_join_node_with_prefix_and_join_hints(
+                &None,
+                join_hints,
+                &dimension_subquery_planner,
+            )?;
         let mut context_factory = self.context_factory.clone();
         context_factory.set_ungrouped_measure(true);
+        context_factory.set_render_references(dimension_subquery_planner.dimensions_refs().clone());
         let mut select_builder = SelectBuilder::new(from);
         for dim in primary_keys_dimensions.iter() {
             select_builder.add_projection_member(dim, None);
@@ -264,17 +291,24 @@ impl MultipliedMeasuresQueryPlanner {
         join: Rc<dyn JoinDefinition>,
         alias_prefix: String,
     ) -> Result<Rc<Select>, CubeError> {
-        let source = self
-            .join_planner
-            .make_join_node_impl(&Some(alias_prefix), join)?;
+        let subquery_dimensions = collect_sub_query_dimensions_from_members(
+            &self.query_properties.all_members(false),
+            self.query_tools.clone(),
+        )?;
+
+        let dimension_subquery_planner = DimensionSubqueryPlanner::try_new(
+            &subquery_dimensions,
+            self.query_tools.clone(),
+            self.query_properties.clone(),
+        )?;
+        let source = self.join_planner.make_join_node_impl(
+            &Some(alias_prefix),
+            join,
+            &dimension_subquery_planner,
+        )?;
 
         let mut select_builder = SelectBuilder::new(source.clone());
         let mut context_factory = self.context_factory.clone();
-        for time_dim in self.query_properties.time_dimensions() {
-            if let Some(granularity) = time_dim.get_granularity() {
-                context_factory.add_leaf_time_dimension(&time_dim.full_name(), &granularity);
-            }
-        }
 
         for member in self
             .query_properties
@@ -286,6 +320,10 @@ impl MultipliedMeasuresQueryPlanner {
         let filter = self.query_properties.all_filters();
         select_builder.set_filter(filter);
         select_builder.set_group_by(self.query_properties.group_by());
+
+        let render_references = dimension_subquery_planner.dimensions_refs().clone();
+        context_factory.set_render_references(render_references);
+
         Ok(Rc::new(select_builder.build(context_factory)))
     }
 
@@ -295,20 +333,30 @@ impl MultipliedMeasuresQueryPlanner {
         key_join: Rc<dyn JoinDefinition>,
         key_cube_name: &String,
     ) -> Result<Rc<Select>, CubeError> {
-        let source = self
-            .join_planner
-            .make_join_node_impl(&Some(format!("{}_key", key_cube_name)), key_join)?;
         let dimensions = self
             .query_properties
             .dimensions_for_select_append(dimensions);
 
+        let subquery_dimensions =
+            collect_sub_query_dimensions_from_members(&dimensions, self.query_tools.clone())?;
+
+        let dimension_subquery_planner = DimensionSubqueryPlanner::try_new(
+            &subquery_dimensions,
+            self.query_tools.clone(),
+            self.query_properties.clone(),
+        )?;
+
+        let source = self.join_planner.make_join_node_impl(
+            &Some(format!("{}_key", key_cube_name)),
+            key_join,
+            &dimension_subquery_planner,
+        )?;
+
         let mut select_builder = SelectBuilder::new(source);
         let mut context_factory = self.context_factory.clone();
-        for time_dim in self.query_properties.time_dimensions() {
-            if let Some(granularity) = time_dim.get_granularity() {
-                context_factory.add_leaf_time_dimension(&time_dim.full_name(), &granularity);
-            }
-        }
+
+        context_factory.set_render_references(dimension_subquery_planner.dimensions_refs().clone());
+
         for member in dimensions.iter() {
             select_builder.add_projection_member(&member, None);
         }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/query_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/query_planner.rs
new file mode 100644
index 0000000000000..80bfd57e98a24
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/query_planner.rs
@@ -0,0 +1,70 @@
+use super::{
+    FullKeyAggregateQueryPlanner, MultiStageQueryPlanner, MultipliedMeasuresQueryPlanner,
+    SimpleQueryPlanner,
+};
+use crate::plan::Select;
+use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
+use crate::planner::sql_templates::PlanSqlTemplates;
+use crate::planner::QueryProperties;
+use cubenativeutils::CubeError;
+use std::rc::Rc;
+
+pub struct QueryPlanner {
+    query_tools: Rc<QueryTools>,
+    request: Rc<QueryProperties>,
+}
+
+impl QueryPlanner {
+    pub fn new(request: Rc<QueryProperties>, query_tools: Rc<QueryTools>) -> Self {
+        Self {
+            request,
+            query_tools,
+        }
+    }
+
+    pub fn build_sql(&self) -> Result<Rc<Select>, CubeError> {
+        let templates = PlanSqlTemplates::new(self.query_tools.templates_render());
+        self.build_sql_and_params_impl(templates)
+    }
+
+    fn build_sql_and_params_impl(
+        &self,
+        templates: PlanSqlTemplates,
+    ) -> Result<Rc<Select>, CubeError> {
+        let mut nodes_factory = SqlNodesFactory::new();
+
+        if self.request.ungrouped() {
+            nodes_factory.set_ungrouped(true)
+        }
+
+        if self.request.is_simple_query()? {
+            let planner = SimpleQueryPlanner::new(
+                self.query_tools.clone(),
+                self.request.clone(),
+                nodes_factory.clone(),
+            );
+            planner.plan()
+        } else {
+            let request = self.request.clone();
+            let multiplied_measures_query_planner = MultipliedMeasuresQueryPlanner::new(
+                self.query_tools.clone(),
+                request.clone(),
+                nodes_factory.clone(),
+            );
+            let multi_stage_query_planner =
+                MultiStageQueryPlanner::new(self.query_tools.clone(), request.clone());
+            let full_key_aggregate_planner = FullKeyAggregateQueryPlanner::new(
+                request.clone(),
+                nodes_factory.clone(),
+                templates,
+            );
+            let mut subqueries = multiplied_measures_query_planner.plan_queries()?;
+            let (multi_stage_ctes, multi_stage_subqueries) =
+                multi_stage_query_planner.plan_queries()?;
+            subqueries.extend(multi_stage_subqueries.into_iter());
+            let result = full_key_aggregate_planner.plan(subqueries, multi_stage_ctes)?;
+            Ok(result)
+        }
+    }
+}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/simple_query_planer.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/simple_query_planer.rs
index 9ed024a96dd04..b67d5ceca5c9e 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/simple_query_planer.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/simple_query_planer.rs
@@ -1,12 +1,14 @@
-use super::{JoinPlanner, OrderPlanner};
+use super::{DimensionSubqueryPlanner, JoinPlanner, OrderPlanner};
 use crate::plan::{Filter, Select, SelectBuilder};
 use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::collectors::collect_sub_query_dimensions_from_members;
 use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
-use crate::planner::{BaseMember, QueryProperties};
+use crate::planner::QueryProperties;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
 pub struct SimpleQueryPlanner {
+    query_tools: Rc<QueryTools>,
     query_properties: Rc<QueryProperties>,
     join_planner: JoinPlanner,
     order_planner: OrderPlanner,
@@ -23,10 +25,21 @@ impl SimpleQueryPlanner {
             order_planner: OrderPlanner::new(query_properties.clone()),
             query_properties,
             context_factory,
+            query_tools,
         }
     }
 
-    pub fn plan(&self) -> Result<Select, CubeError> {
+    pub fn plan(&self) -> Result<Rc<Select>, CubeError> {
+        let subquery_dimensions = collect_sub_query_dimensions_from_members(
+            &self.query_properties.all_members(false),
+            self.query_tools.clone(),
+        )?;
+        let dimension_subquery_planner = DimensionSubqueryPlanner::try_new(
+            &subquery_dimensions,
+            self.query_tools.clone(),
+            self.query_properties.clone(),
+        )?;
+
         let filter = self.query_properties.all_filters();
         let having = if self.query_properties.measures_filters().is_empty() {
             None
@@ -36,15 +49,13 @@ impl SimpleQueryPlanner {
             })
         };
         let mut context_factory = self.context_factory.clone();
-        let from = self
-            .join_planner
-            .make_join_node_impl(&None, self.query_properties.simple_query_join()?)?;
+        let from = self.join_planner.make_join_node_impl(
+            &None,
+            self.query_properties.simple_query_join()?,
+            &dimension_subquery_planner,
+        )?;
         let mut select_builder = SelectBuilder::new(from.clone());
-        for time_dim in self.query_properties.time_dimensions() {
-            if let Some(granularity) = time_dim.get_granularity() {
-                context_factory.add_leaf_time_dimension(&time_dim.full_name(), &granularity);
-            }
-        }
+
         for member in self
             .query_properties
             .all_dimensions_and_measures(self.query_properties.measures())?
@@ -52,13 +63,15 @@ impl SimpleQueryPlanner {
         {
             select_builder.add_projection_member(member, None);
         }
+        let render_references = dimension_subquery_planner.dimensions_refs().clone();
+        context_factory.set_render_references(render_references);
         select_builder.set_filter(filter);
         select_builder.set_group_by(self.query_properties.group_by());
         select_builder.set_order_by(self.order_planner.default_order());
         select_builder.set_having(having);
         select_builder.set_limit(self.query_properties.row_limit());
         select_builder.set_offset(self.query_properties.offset());
-        let res = select_builder.build(context_factory);
+        let res = Rc::new(select_builder.build(context_factory));
         Ok(res)
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs
index 73f875a07adc1..fefcd19ac4a25 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs
@@ -31,10 +31,14 @@ impl TraversalVisitor for CubeNamesCollector {
                 if e.owned_by_cube() {
                     self.names.insert(e.cube_name().clone());
                 }
+                if e.is_sub_query() {
+                    return Ok(None);
+                }
                 for name in e.get_dependent_cubes().into_iter() {
                     self.names.insert(name);
                 }
             }
+            MemberSymbol::TimeDimension(e) => self.apply(e.base_symbol(), &())?,
             MemberSymbol::Measure(e) => {
                 if e.owned_by_cube() {
                     self.names.insert(e.cube_name().clone());
@@ -49,6 +53,11 @@ impl TraversalVisitor for CubeNamesCollector {
             MemberSymbol::CubeTable(e) => {
                 self.names.insert(e.cube_name().clone());
             }
+            MemberSymbol::SqlCall(s) => {
+                for name in s.get_dependent_cubes().into_iter() {
+                    self.names.insert(name);
+                }
+            }
         };
         Ok(Some(()))
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs
index b33ea186c6083..dc156642ec801 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs
@@ -29,10 +29,14 @@ impl TraversalVisitor for JoinHintsCollector {
                 if e.owned_by_cube() {
                     self.hints.push(e.cube_name().clone());
                 }
+                if e.is_sub_query() {
+                    return Ok(None);
+                }
                 for name in e.get_dependent_cubes().into_iter() {
                     self.hints.push(name);
                 }
             }
+            MemberSymbol::TimeDimension(e) => self.apply(e.base_symbol(), &())?,
             MemberSymbol::Measure(e) => {
                 if e.owned_by_cube() {
                     self.hints.push(e.cube_name().clone());
@@ -47,6 +51,11 @@ impl TraversalVisitor for JoinHintsCollector {
             MemberSymbol::CubeTable(e) => {
                 self.hints.push(e.cube_name().clone());
             }
+            MemberSymbol::SqlCall(s) => {
+                for name in s.get_dependent_cubes().into_iter() {
+                    self.hints.push(name);
+                }
+            }
         };
         Ok(Some(()))
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/mod.rs
index 1a3241bf740c4..8b8b9e3528c3f 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/mod.rs
@@ -4,6 +4,7 @@ mod has_multi_stage_members;
 mod join_hints_collector;
 mod member_childs_collector;
 mod multiplied_measures_collector;
+mod sub_query_dimensions;
 
 pub use cube_names_collector::collect_cube_names;
 pub use has_cumulative_members::{has_cumulative_members, HasCumulativeMembersCollector};
@@ -13,3 +14,6 @@ pub use join_hints_collector::{
 };
 pub use member_childs_collector::{member_childs, MemberChildsCollector};
 pub use multiplied_measures_collector::{collect_multiplied_measures, MultipliedMeasuresCollector};
+pub use sub_query_dimensions::{
+    collect_sub_query_dimensions, collect_sub_query_dimensions_from_members,
+};
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
new file mode 100644
index 0000000000000..b20fe5c8d87aa
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/sub_query_dimensions.rs
@@ -0,0 +1,79 @@
+use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::{DimensionSymbol, MemberSymbol, TraversalVisitor};
+use crate::planner::{BaseDimension, BaseMember};
+use cubenativeutils::CubeError;
+use std::rc::Rc;
+
+pub struct SubQueryDimensionsCollector {
+    pub sub_query_dimensions: Vec<Rc<MemberSymbol>>,
+}
+
+impl SubQueryDimensionsCollector {
+    pub fn new() -> Self {
+        Self {
+            sub_query_dimensions: vec![],
+        }
+    }
+
+    pub fn extract_result(self) -> Vec<Rc<MemberSymbol>> {
+        self.sub_query_dimensions
+    }
+
+    fn check_dim_has_measures(&self, dim: &DimensionSymbol) -> bool {
+        for dep in dim.get_dependencies().iter() {
+            match dep.as_ref() {
+                MemberSymbol::Measure(_) => return true,
+                _ => {}
+            }
+        }
+        return false;
+    }
+}
+
+impl TraversalVisitor for SubQueryDimensionsCollector {
+    type State = ();
+    fn on_node_traverse(
+        &mut self,
+        node: &Rc<MemberSymbol>,
+        _state: &Self::State,
+    ) -> Result<Option<Self::State>, CubeError> {
+        match node.as_ref() {
+            MemberSymbol::Dimension(dim) => {
+                if dim.is_sub_query() {
+                    if !self.check_dim_has_measures(dim) {
+                        return Err(CubeError::user(format!(
+                            "Subquery dimension {} should reference at least one measure",
+                            dim.full_name()
+                        )));
+                    }
+                    self.sub_query_dimensions.push(node.clone());
+                }
+                Ok(Some(()))
+            }
+            _ => Ok(Some(())),
+        }
+    }
+}
+
+pub fn collect_sub_query_dimensions_from_members(
+    members: &Vec<Rc<dyn BaseMember>>,
+    query_tools: Rc<QueryTools>,
+) -> Result<Vec<Rc<BaseDimension>>, CubeError> {
+    let mut visitor = SubQueryDimensionsCollector::new();
+    for member in members.iter() {
+        visitor.apply(&member.member_evaluator(), &())?;
+    }
+    visitor
+        .extract_result()
+        .into_iter()
+        .map(|s| BaseDimension::try_new_required(s, query_tools.clone()))
+        .collect::<Result<Vec<_>, CubeError>>()
+}
+
+pub fn collect_sub_query_dimensions(
+    node: &Rc<MemberSymbol>,
+) -> Result<Vec<Rc<MemberSymbol>>, CubeError> {
+    let mut visitor = SubQueryDimensionsCollector::new();
+    visitor.apply(node, &())?;
+    Ok(visitor.extract_result())
+}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs
index df22f8bc00b64..e5a7e41a7c719 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs
@@ -16,6 +16,6 @@ pub use sql_visitor::SqlEvaluatorVisitor;
 pub use symbols::{
     CubeNameSymbol, CubeNameSymbolFactory, CubeTableSymbol, CubeTableSymbolFactory,
     DimensionSymbol, DimensionSymbolFactory, MeasureSymbol, MeasureSymbolFactory, MemberSymbol,
-    SymbolFactory,
+    SymbolFactory, TimeDimensionSymbol,
 };
 pub use visitor::TraversalVisitor;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs
index 35fed31484c9a..8b48ae359ff49 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs
@@ -32,6 +32,12 @@ impl SqlCall {
         self.member_sql.call(args)
     }
 
+    pub fn get_dependencies(&self) -> Vec<Rc<MemberSymbol>> {
+        let mut deps = Vec::new();
+        self.extract_symbol_deps(&mut deps);
+        deps
+    }
+
     pub fn extract_symbol_deps(&self, result: &mut Vec<Rc<MemberSymbol>>) {
         for dep in self.deps.iter() {
             match dep {
@@ -44,6 +50,12 @@ impl SqlCall {
         }
     }
 
+    pub fn get_dependent_cubes(&self) -> Vec<String> {
+        let mut deps = Vec::new();
+        self.extract_cube_deps(&mut deps);
+        deps
+    }
+
     pub fn extract_cube_deps(&self, result: &mut Vec<String>) {
         for dep in self.deps.iter() {
             match dep {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs
index 63587cb9289ed..0ca063cb9fa15 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs
@@ -26,6 +26,18 @@ impl SqlNode for EvaluateSqlNode {
             MemberSymbol::Dimension(ev) => {
                 ev.evaluate_sql(visitor, node_processor.clone(), query_tools.clone())
             }
+            MemberSymbol::TimeDimension(ev) => {
+                let input_sql = visitor.apply(&ev.base_symbol(), node_processor.clone())?;
+                let res = if let Some(granularity) = ev.granularity() {
+                    let converted_tz = query_tools.base_tools().convert_tz(input_sql)?;
+                    query_tools
+                        .base_tools()
+                        .time_grouped_column(granularity.clone(), converted_tz)?
+                } else {
+                    input_sql
+                };
+                Ok(res)
+            }
             MemberSymbol::Measure(ev) => {
                 ev.evaluate_sql(visitor, node_processor.clone(), query_tools.clone())
             }
@@ -33,6 +45,9 @@ impl SqlNode for EvaluateSqlNode {
                 ev.evaluate_sql(visitor, node_processor.clone(), query_tools.clone())
             }
             MemberSymbol::CubeName(ev) => ev.evaluate_sql(),
+            MemberSymbol::SqlCall(s) => {
+                s.eval(visitor, node_processor.clone(), query_tools.clone())
+            }
         }
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs
index a288558b292e8..144d2d7052807 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs
@@ -1,4 +1,3 @@
-use super::leaf_time_dimension::LeafTimeDimensionNode;
 use super::{
     AutoPrefixSqlNode, EvaluateSqlNode, FinalMeasureSqlNode, MeasureFilterSqlNode,
     MultiStageRankNode, MultiStageWindowNode, RenderReferencesSqlNode, RollingWindowNode,
@@ -16,7 +15,6 @@ pub struct SqlNodesFactory {
     ungrouped_measure: bool,
     render_references: HashMap<String, QualifiedColumnName>,
     ungrouped_measure_references: HashMap<String, QualifiedColumnName>,
-    leaf_time_dimensions: HashMap<String, String>,
     cube_name_references: HashMap<String, String>,
     multi_stage_rank: Option<Vec<String>>,   //partition_by
     multi_stage_window: Option<Vec<String>>, //partition_by
@@ -32,7 +30,6 @@ impl SqlNodesFactory {
             render_references: HashMap::new(),
             ungrouped_measure_references: HashMap::new(),
             cube_name_references: HashMap::new(),
-            leaf_time_dimensions: HashMap::new(),
             multi_stage_rank: None,
             multi_stage_window: None,
             rolling_window: false,
@@ -67,11 +64,6 @@ impl SqlNodesFactory {
         self.multi_stage_rank = Some(partition_by);
     }
 
-    pub fn add_leaf_time_dimension(&mut self, dimension_name: &String, granularity: &String) {
-        self.leaf_time_dimensions
-            .insert(dimension_name.clone(), granularity.clone());
-    }
-
     pub fn set_multi_stage_window(&mut self, partition_by: Vec<String>) {
         self.multi_stage_window = Some(partition_by);
     }
@@ -174,11 +166,6 @@ impl SqlNodesFactory {
             input
         };
 
-        let input = if !&self.leaf_time_dimensions.is_empty() {
-            LeafTimeDimensionNode::new(input, self.leaf_time_dimensions.clone())
-        } else {
-            input
-        };
         input
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/leaf_time_dimension.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/leaf_time_dimension.rs
deleted file mode 100644
index 92c06ec1e6ea1..0000000000000
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/leaf_time_dimension.rs
+++ /dev/null
@@ -1,55 +0,0 @@
-use super::SqlNode;
-use crate::planner::query_tools::QueryTools;
-use crate::planner::sql_evaluator::MemberSymbol;
-use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
-use cubenativeutils::CubeError;
-use std::any::Any;
-use std::collections::HashMap;
-use std::rc::Rc;
-
-pub struct LeafTimeDimensionNode {
-    input: Rc<dyn SqlNode>,
-    leaf_time_dimensions: HashMap<String, String>,
-}
-
-impl LeafTimeDimensionNode {
-    pub fn new(input: Rc<dyn SqlNode>, leaf_time_dimensions: HashMap<String, String>) -> Rc<Self> {
-        Rc::new(Self {
-            input,
-            leaf_time_dimensions,
-        })
-    }
-}
-
-impl SqlNode for LeafTimeDimensionNode {
-    fn to_sql(
-        &self,
-        visitor: &SqlEvaluatorVisitor,
-        node: &Rc<MemberSymbol>,
-        query_tools: Rc<QueryTools>,
-        node_processor: Rc<dyn SqlNode>,
-    ) -> Result<String, CubeError> {
-        let full_name = node.full_name();
-        let input_sql = self
-            .input
-            .to_sql(visitor, node, query_tools.clone(), node_processor)?;
-
-        let res = if let Some(granularity) = self.leaf_time_dimensions.get(&full_name) {
-            let converted_tz = query_tools.base_tools().convert_tz(input_sql)?;
-            query_tools
-                .base_tools()
-                .time_grouped_column(granularity.clone(), converted_tz)?
-        } else {
-            input_sql
-        };
-        Ok(res)
-    }
-
-    fn as_any(self: Rc<Self>) -> Rc<dyn Any> {
-        self.clone()
-    }
-
-    fn childs(&self) -> Vec<Rc<dyn SqlNode>> {
-        vec![self.input.clone()]
-    }
-}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/mod.rs
index 346fb326cc689..60a1c025855c5 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/mod.rs
@@ -2,7 +2,6 @@ pub mod auto_prefix;
 pub mod evaluate_sql;
 pub mod factory;
 pub mod final_measure;
-pub mod leaf_time_dimension;
 pub mod measure_filter;
 pub mod multi_stage_rank;
 pub mod multi_stage_window;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs
index 40ec863b6e8ff..14accc9505af6 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs
@@ -40,6 +40,10 @@ impl DimensionSymbol {
         Ok(sql)
     }
 
+    pub fn member_sql(&self) -> &Rc<SqlCall> {
+        &self.member_sql
+    }
+
     pub fn full_name(&self) -> String {
         format!("{}.{}", self.cube_name, self.name)
     }
@@ -51,6 +55,11 @@ impl DimensionSymbol {
     pub fn is_multi_stage(&self) -> bool {
         self.definition.static_data().multi_stage.unwrap_or(false)
     }
+
+    pub fn is_sub_query(&self) -> bool {
+        self.definition.static_data().sub_query.unwrap_or(false)
+    }
+
     pub fn get_dependencies(&self) -> Vec<Rc<MemberSymbol>> {
         let mut deps = vec![];
         self.member_sql.extract_symbol_deps(&mut deps);
@@ -67,6 +76,10 @@ impl DimensionSymbol {
         &self.cube_name
     }
 
+    pub fn definition(&self) -> &Rc<dyn DimensionDefinition> {
+        &self.definition
+    }
+
     pub fn name(&self) -> &String {
         &self.name
     }
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
index ac62b640e580e..b0e2a97a66853 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_symbol.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_symbol.rs
@@ -1,11 +1,15 @@
-use super::{CubeNameSymbol, CubeTableSymbol, DimensionSymbol, MeasureSymbol};
+use crate::planner::sql_evaluator::SqlCall;
+
+use super::{CubeNameSymbol, CubeTableSymbol, DimensionSymbol, MeasureSymbol, TimeDimensionSymbol};
 use std::rc::Rc;
 
 pub enum MemberSymbol {
     Dimension(DimensionSymbol),
+    TimeDimension(TimeDimensionSymbol),
     Measure(MeasureSymbol),
     CubeName(CubeNameSymbol),
     CubeTable(CubeTableSymbol),
+    SqlCall(Rc<SqlCall>), //FIXME for expressions only
 }
 
 impl MemberSymbol {
@@ -28,49 +32,62 @@ impl MemberSymbol {
     pub fn full_name(&self) -> String {
         match self {
             Self::Dimension(d) => d.full_name(),
+            Self::TimeDimension(d) => d.full_name(),
             Self::Measure(m) => m.full_name(),
             Self::CubeName(c) => c.cube_name().clone(),
             Self::CubeTable(c) => c.cube_name().clone(),
+            Self::SqlCall(_) => format!(""),
         }
     }
     pub fn name(&self) -> String {
         match self {
             Self::Dimension(d) => d.name().clone(),
+            Self::TimeDimension(d) => d.name(),
             Self::Measure(m) => m.name().clone(),
             Self::CubeName(c) => c.cube_name().clone(),
             Self::CubeTable(c) => c.cube_name().clone(),
+            Self::SqlCall(_) => format!(""),
         }
     }
 
     pub fn cube_name(&self) -> String {
         match self {
             Self::Dimension(d) => d.cube_name().clone(),
+            Self::TimeDimension(d) => d.cube_name(),
             Self::Measure(m) => m.cube_name().clone(),
             Self::CubeName(c) => c.cube_name().clone(),
             Self::CubeTable(c) => c.cube_name().clone(),
+            Self::SqlCall(_) => format!(""),
         }
     }
+
     pub fn is_measure(&self) -> bool {
         matches!(self, Self::Measure(_))
     }
+
     pub fn is_dimension(&self) -> bool {
-        matches!(self, Self::Dimension(_))
+        matches!(self, Self::Dimension(_) | Self::TimeDimension(_))
     }
+
     pub fn get_dependencies(&self) -> Vec<Rc<MemberSymbol>> {
         match self {
             Self::Dimension(d) => d.get_dependencies(),
+            Self::TimeDimension(d) => d.get_dependencies(),
             Self::Measure(m) => m.get_dependencies(),
             Self::CubeName(_) => vec![],
             Self::CubeTable(_) => vec![],
+            Self::SqlCall(s) => s.get_dependencies(),
         }
     }
 
     pub fn get_dependent_cubes(&self) -> Vec<String> {
         match self {
             Self::Dimension(d) => d.get_dependent_cubes(),
+            Self::TimeDimension(d) => d.get_dependent_cubes(),
             Self::Measure(m) => m.get_dependent_cubes(),
             Self::CubeName(_) => vec![],
             Self::CubeTable(_) => vec![],
+            Self::SqlCall(s) => s.get_dependent_cubes(),
         }
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/mod.rs
index ddb631648d6f1..bb6f56e663c3a 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/mod.rs
@@ -3,6 +3,7 @@ mod dimension_symbol;
 mod measure_symbol;
 mod member_symbol;
 mod symbol_factory;
+mod time_dimension_symbol;
 
 pub use cube_symbol::{
     CubeNameSymbol, CubeNameSymbolFactory, CubeTableSymbol, CubeTableSymbolFactory,
@@ -11,3 +12,5 @@ pub use dimension_symbol::{DimensionSymbol, DimensionSymbolFactory};
 pub use measure_symbol::{MeasureSymbol, MeasureSymbolFactory};
 pub use member_symbol::MemberSymbol;
 pub use symbol_factory::SymbolFactory;
+pub use time_dimension_symbol::TimeDimensionSymbol;
+
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs
new file mode 100644
index 0000000000000..15a07f06f83c1
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs
@@ -0,0 +1,44 @@
+use super::MemberSymbol;
+use std::rc::Rc;
+
+pub struct TimeDimensionSymbol {
+    base_symbol: Rc<MemberSymbol>,
+    granularity: Option<String>,
+}
+
+impl TimeDimensionSymbol {
+    pub fn new(base_symbol: Rc<MemberSymbol>, granularity: Option<String>) -> Self {
+        Self {
+            base_symbol,
+            granularity,
+        }
+    }
+
+    pub fn base_symbol(&self) -> &Rc<MemberSymbol> {
+        &self.base_symbol
+    }
+
+    pub fn granularity(&self) -> &Option<String> {
+        &self.granularity
+    }
+
+    pub fn full_name(&self) -> String {
+        self.base_symbol.full_name()
+    }
+
+    pub fn get_dependencies(&self) -> Vec<Rc<MemberSymbol>> {
+        self.base_symbol.get_dependencies()
+    }
+
+    pub fn get_dependent_cubes(&self) -> Vec<String> {
+        self.base_symbol.get_dependent_cubes()
+    }
+
+    pub fn cube_name(&self) -> String {
+        self.base_symbol.cube_name()
+    }
+
+    pub fn name(&self) -> String {
+        self.base_symbol.name()
+    }
+}

From c2f3979249156e9c760417c1b5f2d53260347a2f Mon Sep 17 00:00:00 2001
From: Alexandr Romanenko <alex.romanenko@cube.dev>
Date: Fri, 17 Jan 2025 01:18:31 +0100
Subject: [PATCH 02/16] update

---
 .../cubesqlplanner/src/planner/query_properties.rs     |  2 +-
 .../sql_evaluator/collectors/cube_names_collector.rs   |  2 +-
 .../sql_evaluator/collectors/join_hints_collector.rs   |  2 +-
 .../sql_evaluator/collectors/sub_query_dimensions.rs   |  4 ++++
 .../sql_evaluator/symbols/time_dimension_symbol.rs     | 10 +++++++++-
 5 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
index 2b7c2d2f06d15..cb47313aaf6fe 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
@@ -451,7 +451,7 @@ impl QueryProperties {
             let time_dimensions = self
                 .time_dimensions
                 .iter()
-                .map(|d| -> Rc<dyn BaseMember> { d.clone() });
+                .map(|d| -> Rc<dyn BaseMember> { d.base_dimension().clone() });
             dimensions
                 .chain(time_dimensions)
                 .chain(measures)
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs
index fefcd19ac4a25..d3db79c353218 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs
@@ -38,7 +38,7 @@ impl TraversalVisitor for CubeNamesCollector {
                     self.names.insert(name);
                 }
             }
-            MemberSymbol::TimeDimension(e) => self.apply(e.base_symbol(), &())?,
+            MemberSymbol::TimeDimension(e) => return self.on_node_traverse(e.base_symbol(), &()),
             MemberSymbol::Measure(e) => {
                 if e.owned_by_cube() {
                     self.names.insert(e.cube_name().clone());
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs
index dc156642ec801..45b51d3f43fcb 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs
@@ -36,7 +36,7 @@ impl TraversalVisitor for JoinHintsCollector {
                     self.hints.push(name);
                 }
             }
-            MemberSymbol::TimeDimension(e) => self.apply(e.base_symbol(), &())?,
+            MemberSymbol::TimeDimension(e) => return self.on_node_traverse(e.base_symbol(), &()),
             MemberSymbol::Measure(e) => {
                 if e.owned_by_cube() {
                     self.hints.push(e.cube_name().clone());
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
index b20fe5c8d87aa..a195936c5dc29 100644
--- 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
@@ -50,6 +50,10 @@ impl TraversalVisitor for SubQueryDimensionsCollector {
                 }
                 Ok(Some(()))
             }
+            MemberSymbol::TimeDimension(dim) => {
+                self.on_node_traverse(dim.base_symbol(), &())
+
+            }
             _ => Ok(Some(())),
         }
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs
index 15a07f06f83c1..212bffbb95a03 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs
@@ -3,14 +3,22 @@ use std::rc::Rc;
 
 pub struct TimeDimensionSymbol {
     base_symbol: Rc<MemberSymbol>,
+    full_name: String,
     granularity: Option<String>,
 }
 
 impl TimeDimensionSymbol {
     pub fn new(base_symbol: Rc<MemberSymbol>, granularity: Option<String>) -> Self {
+        let name_suffix = if let Some(granularity) = &granularity {
+            granularity.clone()
+        } else {
+            "day".to_string()
+        };
+        let full_name = format!("{}_{}", base_symbol.full_name(), name_suffix);
         Self {
             base_symbol,
             granularity,
+            full_name,
         }
     }
 
@@ -23,7 +31,7 @@ impl TimeDimensionSymbol {
     }
 
     pub fn full_name(&self) -> String {
-        self.base_symbol.full_name()
+        self.full_name.clone()
     }
 
     pub fn get_dependencies(&self) -> Vec<Rc<MemberSymbol>> {

From 4a99df700616cc001f5ebeae1617eabae26bf3ef Mon Sep 17 00:00:00 2001
From: Alexandr Romanenko <alex.romanenko@cube.dev>
Date: Fri, 17 Jan 2025 01:24:33 +0100
Subject: [PATCH 03/16] update

---
 .../planner/sql_evaluator/collectors/sub_query_dimensions.rs | 5 +----
 .../cubesqlplanner/src/planner/sql_evaluator/symbols/mod.rs  | 1 -
 2 files changed, 1 insertion(+), 5 deletions(-)

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
index a195936c5dc29..c97cfc0ea35fe 100644
--- 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
@@ -50,10 +50,7 @@ impl TraversalVisitor for SubQueryDimensionsCollector {
                 }
                 Ok(Some(()))
             }
-            MemberSymbol::TimeDimension(dim) => {
-                self.on_node_traverse(dim.base_symbol(), &())
-
-            }
+            MemberSymbol::TimeDimension(dim) => self.on_node_traverse(dim.base_symbol(), &()),
             _ => Ok(Some(())),
         }
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/mod.rs
index bb6f56e663c3a..39f09d356fdf8 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/mod.rs
@@ -13,4 +13,3 @@ pub use measure_symbol::{MeasureSymbol, MeasureSymbolFactory};
 pub use member_symbol::MemberSymbol;
 pub use symbol_factory::SymbolFactory;
 pub use time_dimension_symbol::TimeDimensionSymbol;
-

From e3f414f9ff0350fb8702b3baf54cf76c08505a08 Mon Sep 17 00:00:00 2001
From: Alexandr Romanenko <alex.romanenko@cube.dev>
Date: Fri, 17 Jan 2025 17:44:36 +0100
Subject: [PATCH 04/16] update

---
 .../src/adapter/BaseQuery.js                  |   2 +
 .../src/cube_bridge/base_tools.rs             |   2 +-
 .../src/cube_bridge/cube_definition.rs        |   2 +-
 .../src/cube_bridge/dimension_definition.rs   |  14 +-
 .../src/cube_bridge/evaluator.rs              |   2 +-
 .../src/cube_bridge/geo_item.rs               |  15 ++
 .../src/cube_bridge/join_item_definition.rs   |   2 +-
 .../src/cube_bridge/measure_definition.rs     |   6 +-
 .../src/cube_bridge/measure_filter.rs         |   2 +-
 .../src/cube_bridge/member_definition.rs      |   2 +-
 .../src/cube_bridge/member_order_by.rs        |   2 +-
 .../{memeber_sql.rs => member_sql.rs}         |  39 ++++++
 .../cubesqlplanner/src/cube_bridge/mod.rs     |   3 +-
 .../cubesqlplanner/src/plan/expression.rs     |   4 +-
 .../cubesqlplanner/src/plan/filter.rs         |   2 +-
 .../cubesqlplanner/src/plan/from.rs           |   2 +-
 .../cubesqlplanner/src/plan/join.rs           |   2 +-
 .../cubesqlplanner/src/planner/base_cube.rs   |  20 ++-
 .../src/planner/base_dimension.rs             |  25 +++-
 .../src/planner/base_join_condition.rs        |  15 +-
 .../src/planner/base_measure.rs               |  30 +++-
 .../cubesqlplanner/src/planner/base_member.rs |   6 +-
 .../src/planner/base_time_dimension.rs        |  14 +-
 .../src/planner/filter/base_filter.rs         | 101 +++++++++++---
 .../src/planner/filter/compiler.rs            |  24 ++--
 .../src/planner/filter/filter_operator.rs     |   5 +-
 .../src/planner/planners/common_utils.rs      |   3 +-
 .../full_key_query_aggregate_planner.rs       |   2 +-
 .../src/planner/planners/join_planner.rs      |   2 +-
 .../multi_stage/member_query_planner.rs       |   4 +-
 .../multiplied_measures_query_planner.rs      |  48 +++++--
 .../src/planner/planners/query_planner.rs     |   4 +-
 .../planner/planners/simple_query_planer.rs   |   6 +-
 .../src/planner/query_properties.rs           |  62 +++++++-
 .../planner/sql_evaluator/collectors/mod.rs   |   1 +
 .../collectors/sub_query_dimensions.rs        |  11 +-
 .../src/planner/sql_evaluator/compiler.rs     |   2 +-
 .../src/planner/sql_evaluator/dependecy.rs    |  11 +-
 .../src/planner/sql_evaluator/sql_call.rs     |  40 ++++--
 .../sql_evaluator/sql_nodes/auto_prefix.rs    |  12 +-
 .../sql_evaluator/sql_nodes/evaluate_sql.rs   |  67 +++++++--
 .../sql_evaluator/sql_nodes/factory.rs        |  23 ++-
 .../sql_evaluator/sql_nodes/final_measure.rs  |  26 +++-
 .../sql_evaluator/sql_nodes/geo_dimension.rs  |  87 ++++++++++++
 .../sql_evaluator/sql_nodes/measure_filter.rs |  15 +-
 .../planner/sql_evaluator/sql_nodes/mod.rs    |   2 +
 .../sql_nodes/multi_stage_rank.rs             |   4 +
 .../sql_nodes/multi_stage_window.rs           |   4 +
 .../sql_nodes/render_references.rs            |  11 +-
 .../sql_evaluator/sql_nodes/rolling_window.rs |  12 +-
 .../sql_evaluator/sql_nodes/root_processor.rs |   6 +
 .../sql_evaluator/sql_nodes/sql_node.rs       |   3 +
 .../sql_evaluator/sql_nodes/time_shift.rs     |  12 +-
 .../sql_nodes/ungroupped_measure.rs           |   3 +
 .../ungroupped_query_final_measure.rs         |   3 +
 .../src/planner/sql_evaluator/sql_visitor.rs  |  11 +-
 .../sql_evaluator/symbols/cube_symbol.rs      |   8 +-
 .../sql_evaluator/symbols/dimension_symbol.rs |  81 +++++++++--
 .../sql_evaluator/symbols/measure_symbol.rs   | 132 +++++++++++++-----
 .../sql_evaluator/symbols/symbol_factory.rs   |   2 +-
 .../src/planner/sql_templates/filter.rs       |   4 +
 .../src/planner/sql_templates/plan.rs         |  37 +++++
 .../src/planner/visitor_context.rs            |   7 +-
 63 files changed, 916 insertions(+), 195 deletions(-)
 create mode 100644 rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/geo_item.rs
 rename rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/{memeber_sql.rs => member_sql.rs} (84%)
 create mode 100644 rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/geo_dimension.rs

diff --git a/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js b/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
index d7863713f6b2a..fac5e4bbc976c 100644
--- a/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
+++ b/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
@@ -3332,6 +3332,7 @@ export class BaseQuery {
         sort: '{{ expr }} {% if asc %}ASC{% else %}DESC{% endif %} NULLS {% if nulls_first %}FIRST{% else %}LAST{% endif %}',
         order_by: '{% if index %} {{ index }} {% else %} {{ expr }} {% endif %} {% if asc %}ASC{% else %}DESC{% endif %}{% if nulls_first %} NULLS FIRST{% endif %}',
         cast: 'CAST({{ expr }} AS {{ data_type }})',
+        cast_to_string: 'CAST({{ expr }} AS TEXT)',
         window_function: '{{ fun_call }} OVER ({% if partition_by_concat %}PARTITION BY {{ partition_by_concat }}{% if order_by_concat or window_frame %} {% endif %}{% endif %}{% if order_by_concat %}ORDER BY {{ order_by_concat }}{% if window_frame %} {% endif %}{% endif %}{% if window_frame %}{{ window_frame }}{% endif %})',
         window_frame_bounds: '{{ frame_type }} BETWEEN {{ frame_start }} AND {{ frame_end }}',
         in_list: '{{ expr }} {% if negated %}NOT {% endif %}IN ({{ in_exprs_concat }})',
@@ -3348,6 +3349,7 @@ export class BaseQuery {
         like: '{{ expr }} {% if negated %}NOT {% endif %}LIKE {{ pattern }}',
         ilike: '{{ expr }} {% if negated %}NOT {% endif %}ILIKE {{ pattern }}',
         like_escape: '{{ like_expr }} ESCAPE {{ escape_char }}',
+        concat_strings: '{{ strings | join(\' || \' ) }}',
       },
       filters: {
         equals: '{{ column }} = {{ value }}{{ is_null_check }}',
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
index ded10dda2e5d4..08accd8e6d776 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
@@ -1,6 +1,6 @@
 use super::filter_group::{FilterGroup, NativeFilterGroup};
 use super::filter_params::{FilterParams, NativeFilterParams};
-use super::memeber_sql::{MemberSql, NativeMemberSql};
+use super::member_sql::{MemberSql, NativeMemberSql};
 use super::security_context::{NativeSecurityContext, SecurityContext};
 use super::sql_templates_render::{NativeSqlTemplatesRender, SqlTemplatesRender};
 use cubenativeutils::wrappers::serializer::{
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/cube_definition.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/cube_definition.rs
index 6fa531ddbce7b..c8d9d9ef76da5 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/cube_definition.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/cube_definition.rs
@@ -1,4 +1,4 @@
-use super::memeber_sql::{MemberSql, NativeMemberSql};
+use super::member_sql::{MemberSql, NativeMemberSql};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/dimension_definition.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/dimension_definition.rs
index ed99896573500..6ca6e193edf42 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/dimension_definition.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/dimension_definition.rs
@@ -1,4 +1,5 @@
-use super::memeber_sql::{MemberSql, NativeMemberSql};
+use super::geo_item::{GeoItem, NativeGeoItem};
+use super::member_sql::{MemberSql, NativeMemberSql};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
@@ -25,6 +26,15 @@ pub struct DimenstionDefinitionStatic {
 
 #[nativebridge::native_bridge(DimenstionDefinitionStatic)]
 pub trait DimensionDefinition {
+    #[optional]
     #[field]
-    fn sql(&self) -> Result<Rc<dyn MemberSql>, CubeError>;
+    fn sql(&self) -> Result<Option<Rc<dyn MemberSql>>, CubeError>;
+
+    #[optional]
+    #[field]
+    fn latitude(&self) -> Result<Option<Rc<dyn GeoItem>>, CubeError>;
+
+    #[optional]
+    #[field]
+    fn longitude(&self) -> Result<Option<Rc<dyn GeoItem>>, CubeError>;
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/evaluator.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/evaluator.rs
index f076c1eb7c708..7c02a6f7a0afd 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/evaluator.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/evaluator.rs
@@ -1,7 +1,7 @@
 use super::cube_definition::{CubeDefinition, NativeCubeDefinition};
 use super::dimension_definition::{DimensionDefinition, NativeDimensionDefinition};
 use super::measure_definition::{MeasureDefinition, NativeMeasureDefinition};
-use super::memeber_sql::{MemberSql, NativeMemberSql};
+use super::member_sql::{MemberSql, NativeMemberSql};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/geo_item.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/geo_item.rs
new file mode 100644
index 0000000000000..8742686db9555
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/geo_item.rs
@@ -0,0 +1,15 @@
+use super::member_sql::{MemberSql, NativeMemberSql};
+use cubenativeutils::wrappers::serializer::{
+    NativeDeserialize, NativeDeserializer, NativeSerialize,
+};
+use cubenativeutils::wrappers::NativeContextHolder;
+use cubenativeutils::wrappers::NativeObjectHandle;
+use cubenativeutils::CubeError;
+use std::any::Any;
+use std::rc::Rc;
+
+#[nativebridge::native_bridge]
+pub trait GeoItem {
+    #[field]
+    fn sql(&self) -> Result<Rc<dyn MemberSql>, CubeError>;
+}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_item_definition.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_item_definition.rs
index 2f532e3b7ee03..cca8d2cce702f 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_item_definition.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_item_definition.rs
@@ -1,4 +1,4 @@
-use super::memeber_sql::{MemberSql, NativeMemberSql};
+use super::member_sql::{MemberSql, NativeMemberSql};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs
index 4c1cdb21f2596..8172b846ffe74 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs
@@ -1,7 +1,7 @@
 use super::cube_definition::{CubeDefinition, NativeCubeDefinition};
 use super::measure_filter::{MeasureFiltersVec, NativeMeasureFiltersVec};
 use super::member_order_by::{MemberOrderByVec, NativeMemberOrderByVec};
-use super::memeber_sql::{MemberSql, NativeMemberSql};
+use super::member_sql::{MemberSql, NativeMemberSql};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
@@ -60,6 +60,10 @@ pub trait MeasureDefinition {
     #[field]
     fn filters(&self) -> Result<Option<Rc<dyn MeasureFiltersVec>>, CubeError>;
 
+    #[optional]
+    #[field]
+    fn drill_filters(&self) -> Result<Option<Rc<dyn MeasureFiltersVec>>, CubeError>;
+
     #[optional]
     #[field]
     fn order_by(&self) -> Result<Option<Rc<dyn MemberOrderByVec>>, CubeError>;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_filter.rs
index a7973e0c6047d..d251630f9683b 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_filter.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_filter.rs
@@ -1,4 +1,4 @@
-use super::memeber_sql::{MemberSql, NativeMemberSql};
+use super::member_sql::{MemberSql, NativeMemberSql};
 use cubenativeutils::wrappers::object::NativeArray;
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_definition.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_definition.rs
index 52d88dfb0cd5c..a0b82971482c9 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_definition.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_definition.rs
@@ -1,4 +1,4 @@
-use super::memeber_sql::{MemberSql, NativeMemberSql};
+use super::member_sql::{MemberSql, NativeMemberSql};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_order_by.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_order_by.rs
index 56905aa825306..b5ddddbc84171 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_order_by.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_order_by.rs
@@ -1,4 +1,4 @@
-use super::memeber_sql::{MemberSql, NativeMemberSql};
+use super::member_sql::{MemberSql, NativeMemberSql};
 use cubenativeutils::wrappers::object::NativeArray;
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/memeber_sql.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_sql.rs
similarity index 84%
rename from rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/memeber_sql.rs
rename to rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_sql.rs
index 3dbf3a967f713..0cb0d8d869f2e 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/memeber_sql.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_sql.rs
@@ -37,9 +37,39 @@ pub enum MemberSqlArg {
 pub trait MemberSql {
     fn call(&self, args: Vec<MemberSqlArg>) -> Result<String, CubeError>;
     fn args_names(&self) -> &Vec<String>;
+    fn need_deps_resolve(&self) -> bool;
     fn as_any(self: Rc<Self>) -> Rc<dyn Any>;
 }
 
+pub struct CustomMemberSql {
+    sql: String,
+    args_names: Vec<String>,
+}
+
+impl CustomMemberSql {
+    pub fn new(sql: String) -> Rc<Self> {
+        Rc::new(Self {
+            sql,
+            args_names: vec![],
+        })
+    }
+}
+
+impl MemberSql for CustomMemberSql {
+    fn call(&self, _args: Vec<MemberSqlArg>) -> Result<String, CubeError> {
+        Ok(self.sql.clone())
+    }
+    fn args_names(&self) -> &Vec<String> {
+        &self.args_names
+    }
+    fn need_deps_resolve(&self) -> bool {
+        false
+    }
+    fn as_any(self: Rc<Self>) -> Rc<dyn Any> {
+        self.clone()
+    }
+}
+
 pub struct NativeMemberSql<IT: InnerTypes> {
     native_object: NativeObjectHandle<IT>,
     args_names: Vec<String>,
@@ -60,6 +90,12 @@ impl<IT: InnerTypes> NativeSerialize<IT> for MemberSqlStruct {
                 NativeObjectHandle::new(context.to_string_fn(to_string_fn.clone()).into_object()),
             )?;
         }
+        if let Some(sql_fn) = &self.sql_fn {
+            res.set_field(
+                "sql",
+                NativeObjectHandle::new(context.to_string_fn(sql_fn.clone()).into_object()),
+            )?;
+        }
         Ok(NativeObjectHandle::new(res.into_object()))
     }
 }
@@ -131,6 +167,9 @@ impl<IT: InnerTypes> MemberSql for NativeMemberSql<IT> {
     fn args_names(&self) -> &Vec<String> {
         &self.args_names
     }
+    fn need_deps_resolve(&self) -> bool {
+        !self.args_names.is_empty()
+    }
 }
 
 impl<IT: InnerTypes> NativeSerialize<IT> for NativeMemberSql<IT> {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs
index c32f95c33c2dd..762e6f8a0553d 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs
@@ -5,6 +5,7 @@ pub mod dimension_definition;
 pub mod evaluator;
 pub mod filter_group;
 pub mod filter_params;
+pub mod geo_item;
 pub mod join_definition;
 pub mod join_graph;
 pub mod join_item;
@@ -13,6 +14,6 @@ pub mod measure_definition;
 pub mod measure_filter;
 pub mod member_definition;
 pub mod member_order_by;
-pub mod memeber_sql;
+pub mod member_sql;
 pub mod security_context;
 pub mod sql_templates_render;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/expression.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/expression.rs
index 34ff7816acb57..57fb6fae5d686 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/expression.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/expression.rs
@@ -16,10 +16,10 @@ impl MemberExpression {
 
     pub fn to_sql(
         &self,
-        _templates: &PlanSqlTemplates,
+        templates: &PlanSqlTemplates,
         context: Rc<VisitorContext>,
     ) -> Result<String, CubeError> {
-        self.member.to_sql(context)
+        self.member.to_sql(context, templates)
     }
 }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs
index e996179229c94..df354bacebcb7 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs
@@ -75,7 +75,7 @@ impl FilterItem {
                 }
             }
             FilterItem::Item(item) => {
-                let sql = item.to_sql(context.clone())?;
+                let sql = item.to_sql(context.clone(), templates)?;
                 format!("({})", sql)
             }
         };
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/from.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/from.rs
index 175fb662ca89b..30a174488a4be 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/from.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/from.rs
@@ -19,7 +19,7 @@ impl SingleSource {
     ) -> Result<String, CubeError> {
         let sql = match &self {
             SingleSource::Cube(cube) => {
-                let cubesql = cube.to_sql(context.clone())?;
+                let cubesql = cube.to_sql(context.clone(), templates)?;
                 format!(" {} ", cubesql)
             }
             SingleSource::Subquery(s) => format!("({})", s.to_sql(templates)?),
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs
index 1ac747410d055..a7b24d17b1dba 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs
@@ -180,7 +180,7 @@ impl JoinCondition {
     ) -> Result<String, CubeError> {
         match &self {
             JoinCondition::DimensionJoinCondition(cond) => cond.to_sql(templates, context),
-            JoinCondition::BaseJoinCondition(cond) => cond.to_sql(context),
+            JoinCondition::BaseJoinCondition(cond) => cond.to_sql(context, templates),
             JoinCondition::RollingWindowJoinCondition(cond) => cond.to_sql(templates, context),
         }
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_cube.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_cube.rs
index 49107d4af1a50..4fb0d0989cd0f 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_cube.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_cube.rs
@@ -2,6 +2,7 @@ use super::query_tools::QueryTools;
 use super::sql_evaluator::MemberSymbol;
 use super::{evaluate_with_context, VisitorContext};
 use crate::cube_bridge::cube_definition::CubeDefinition;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::collections::HashSet;
 use std::rc::Rc;
@@ -37,9 +38,17 @@ impl BaseCube {
         }))
     }
 
-    pub fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
-        let cube_sql =
-            evaluate_with_context(&self.member_evaluator, self.query_tools.clone(), context)?;
+    pub fn to_sql(
+        &self,
+        context: Rc<VisitorContext>,
+        templates: &PlanSqlTemplates,
+    ) -> Result<String, CubeError> {
+        let cube_sql = evaluate_with_context(
+            &self.member_evaluator,
+            self.query_tools.clone(),
+            context,
+            templates,
+        )?;
         Ok(cube_sql)
     }
 
@@ -69,10 +78,11 @@ impl BaseCube {
 
     pub fn default_alias_with_prefix(&self, prefix: &Option<String>) -> String {
         let alias = self.default_alias();
-        if let Some(prefix) = prefix {
+        let res = if let Some(prefix) = prefix {
             format!("{prefix}_{alias}")
         } else {
             alias
-        }
+        };
+        self.query_tools.alias_name(&res)
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs
index 160f3a1ec2b3a..1f95df17bfcac 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs
@@ -2,6 +2,7 @@ use super::query_tools::QueryTools;
 use super::sql_evaluator::{MemberSymbol, SqlCall};
 use super::{evaluate_with_context, BaseMember, BaseMemberHelper, VisitorContext};
 use crate::cube_bridge::dimension_definition::DimensionDefinition;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
@@ -16,8 +17,17 @@ pub struct BaseDimension {
 }
 
 impl BaseMember for BaseDimension {
-    fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
-        evaluate_with_context(&self.member_evaluator, self.query_tools.clone(), context)
+    fn to_sql(
+        &self,
+        context: Rc<VisitorContext>,
+        templates: &PlanSqlTemplates,
+    ) -> Result<String, CubeError> {
+        evaluate_with_context(
+            &self.member_evaluator,
+            self.query_tools.clone(),
+            context,
+            templates,
+        )
     }
 
     fn alias_name(&self) -> String {
@@ -88,7 +98,16 @@ impl BaseDimension {
 
     pub fn sql_call(&self) -> Result<Rc<SqlCall>, CubeError> {
         match self.member_evaluator.as_ref() {
-            MemberSymbol::Dimension(d) => Ok(d.member_sql().clone()),
+            MemberSymbol::Dimension(d) => {
+                if let Some(sql) = d.member_sql() {
+                    Ok(sql.clone())
+                } else {
+                    Err(CubeError::user(format!(
+                        "Dimension {} hasn't sql evaluator",
+                        self.full_name()
+                    )))
+                }
+            }
             _ => Err(CubeError::internal(format!(
                 "MemberSymbol::Dimension expected"
             ))),
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_join_condition.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_join_condition.rs
index c90c901fbca68..29eb21cf1c56a 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_join_condition.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_join_condition.rs
@@ -1,10 +1,15 @@
 use super::query_tools::QueryTools;
 use super::sql_evaluator::SqlCall;
 use super::{evaluate_sql_call_with_context, VisitorContext};
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 pub trait BaseJoinCondition {
-    fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError>;
+    fn to_sql(
+        &self,
+        context: Rc<VisitorContext>,
+        templates: &PlanSqlTemplates,
+    ) -> Result<String, CubeError>;
 }
 pub struct SqlJoinCondition {
     sql_call: Rc<SqlCall>,
@@ -23,7 +28,11 @@ impl SqlJoinCondition {
 }
 
 impl BaseJoinCondition for SqlJoinCondition {
-    fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
-        evaluate_sql_call_with_context(&self.sql_call, self.query_tools.clone(), context)
+    fn to_sql(
+        &self,
+        context: Rc<VisitorContext>,
+        templates: &PlanSqlTemplates,
+    ) -> Result<String, CubeError> {
+        evaluate_sql_call_with_context(&self.sql_call, self.query_tools.clone(), context, templates)
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
index 16cd3bd7f0676..d45c23f97a8b0 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
@@ -4,6 +4,7 @@ use super::{evaluate_with_context, BaseMember, BaseMemberHelper, VisitorContext}
 use crate::cube_bridge::measure_definition::{
     MeasureDefinition, RollingWindow, TimeShiftReference,
 };
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use lazy_static::lazy_static;
 use regex::Regex;
@@ -84,8 +85,17 @@ impl Debug for BaseMeasure {
 }
 
 impl BaseMember for BaseMeasure {
-    fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
-        evaluate_with_context(&self.member_evaluator, self.query_tools.clone(), context)
+    fn to_sql(
+        &self,
+        context: Rc<VisitorContext>,
+        templates: &PlanSqlTemplates,
+    ) -> Result<String, CubeError> {
+        evaluate_with_context(
+            &self.member_evaluator,
+            self.query_tools.clone(),
+            context,
+            templates,
+        )
     }
 
     fn alias_name(&self) -> String {
@@ -178,6 +188,22 @@ impl BaseMeasure {
         })
     }
 
+    pub fn can_used_as_addictive_in_multplied(&self) -> Result<bool, CubeError> {
+        let measure_type = self.measure_type();
+        let res = if measure_type == "countDistinct" {
+            true
+        } else if measure_type == "count" {
+            if let Some(definition) = &self.definition {
+                !definition.has_sql()?
+            } else {
+                false
+            }
+        } else {
+            false
+        };
+        Ok(res)
+    }
+
     fn parse_time_shifts(
         definition: &Rc<dyn MeasureDefinition>,
     ) -> Result<Vec<MeasureTimeShift>, CubeError> {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
index 0618a9101b1f2..394b2a71f2994 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
@@ -7,7 +7,11 @@ use itertools::Itertools;
 use std::rc::Rc;
 
 pub trait BaseMember {
-    fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError>;
+    fn to_sql(
+        &self,
+        context: Rc<VisitorContext>,
+        templates: &PlanSqlTemplates,
+    ) -> Result<String, CubeError>;
     fn alias_name(&self) -> String;
     fn member_evaluator(&self) -> Rc<MemberSymbol>;
     fn full_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
index 462709995e525..ca9d2f5982ae0 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
@@ -2,6 +2,7 @@ use super::query_tools::QueryTools;
 use super::sql_evaluator::{MemberSymbol, TimeDimensionSymbol};
 use super::BaseDimension;
 use super::{evaluate_with_context, BaseMember, BaseMemberHelper, VisitorContext};
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
@@ -16,8 +17,17 @@ pub struct BaseTimeDimension {
 }
 
 impl BaseMember for BaseTimeDimension {
-    fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
-        evaluate_with_context(&self.member_evaluator, self.query_tools.clone(), context)
+    fn to_sql(
+        &self,
+        context: Rc<VisitorContext>,
+        templates: &PlanSqlTemplates,
+    ) -> Result<String, CubeError> {
+        evaluate_with_context(
+            &self.member_evaluator,
+            self.query_tools.clone(),
+            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
index b9e5a8829735d..fa3ccfdcae26e 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
@@ -2,6 +2,7 @@ use super::filter_operator::FilterOperator;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_templates::filter::FilterTemplates;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::{evaluate_with_context, VisitorContext};
 use cubenativeutils::CubeError;
 use lazy_static::lazy_static;
@@ -95,28 +96,84 @@ impl BaseFilter {
         self.member_evaluator.full_name()
     }
 
-    pub fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
-        let member_sql =
-            evaluate_with_context(&self.member_evaluator, self.query_tools.clone(), context)?;
-        let res = match self.filter_operator {
-            FilterOperator::Equal => self.equals_where(&member_sql)?,
-            FilterOperator::NotEqual => self.not_equals_where(&member_sql)?,
-            FilterOperator::InDateRange => self.in_date_range(&member_sql)?,
-            FilterOperator::InDateRangeExtended => self.in_date_range_extended(&member_sql)?,
-            FilterOperator::In => self.in_where(&member_sql)?,
-            FilterOperator::NotIn => self.not_in_where(&member_sql)?,
-            FilterOperator::Set => self.set_where(&member_sql)?,
-            FilterOperator::NotSet => self.not_set_where(&member_sql)?,
-            FilterOperator::Gt => self.gt_where(&member_sql)?,
-            FilterOperator::Gte => self.gte_where(&member_sql)?,
-            FilterOperator::Lt => self.lt_where(&member_sql)?,
-            FilterOperator::Lte => self.lte_where(&member_sql)?,
-            FilterOperator::Contains => self.contains_where(&member_sql)?,
-            FilterOperator::NotContains => self.not_contains_where(&member_sql)?,
-            FilterOperator::StartsWith => self.starts_with_where(&member_sql)?,
-            FilterOperator::NotStartsWith => self.not_starts_with_where(&member_sql)?,
-            FilterOperator::EndsWith => self.ends_with_where(&member_sql)?,
-            FilterOperator::NotEndsWith => self.not_ends_with_where(&member_sql)?,
+    pub fn to_sql(
+        &self,
+        context: Rc<VisitorContext>,
+        plan_templates: &PlanSqlTemplates,
+    ) -> Result<String, CubeError> {
+        if matches!(self.filter_operator, FilterOperator::MeasureFilter) {
+            self.measure_filter_where(context, plan_templates)
+        } else {
+            let member_sql = evaluate_with_context(
+                &self.member_evaluator,
+                self.query_tools.clone(),
+                context,
+                plan_templates,
+            )?;
+            let res = match self.filter_operator {
+                FilterOperator::Equal => self.equals_where(&member_sql)?,
+                FilterOperator::NotEqual => self.not_equals_where(&member_sql)?,
+                FilterOperator::InDateRange => self.in_date_range(&member_sql)?,
+                FilterOperator::InDateRangeExtended => self.in_date_range_extended(&member_sql)?,
+                FilterOperator::In => self.in_where(&member_sql)?,
+                FilterOperator::NotIn => self.not_in_where(&member_sql)?,
+                FilterOperator::Set => self.set_where(&member_sql)?,
+                FilterOperator::NotSet => self.not_set_where(&member_sql)?,
+                FilterOperator::Gt => self.gt_where(&member_sql)?,
+                FilterOperator::Gte => self.gte_where(&member_sql)?,
+                FilterOperator::Lt => self.lt_where(&member_sql)?,
+                FilterOperator::Lte => self.lte_where(&member_sql)?,
+                FilterOperator::Contains => self.contains_where(&member_sql)?,
+                FilterOperator::NotContains => self.not_contains_where(&member_sql)?,
+                FilterOperator::StartsWith => self.starts_with_where(&member_sql)?,
+                FilterOperator::NotStartsWith => self.not_starts_with_where(&member_sql)?,
+                FilterOperator::EndsWith => self.ends_with_where(&member_sql)?,
+                FilterOperator::NotEndsWith => self.not_ends_with_where(&member_sql)?,
+                FilterOperator::MeasureFilter => {
+                    return Err(CubeError::internal(format!(
+                        "Measure filter should be processed separately"
+                    )));
+                }
+            };
+            Ok(res)
+        }
+    }
+
+    fn measure_filter_where(
+        &self,
+        context: Rc<VisitorContext>,
+        plan_templates: &PlanSqlTemplates,
+    ) -> Result<String, CubeError> {
+        let res = match self.member_evaluator.as_ref() {
+            MemberSymbol::Measure(measure_symbol) => {
+                if measure_symbol.measure_filters().is_empty()
+                    && measure_symbol.measure_drill_filters().is_empty()
+                {
+                    self.templates.always_true()?
+                } else {
+                    let visitor = context.make_visitor(self.query_tools.clone());
+                    let node_processor = context.node_processor();
+
+                    measure_symbol
+                        .measure_filters()
+                        .iter()
+                        .chain(measure_symbol.measure_drill_filters().iter())
+                        .map(|filter| -> Result<String, CubeError> {
+                            Ok(format!(
+                                "({})",
+                                filter.eval(
+                                    &visitor,
+                                    node_processor.clone(),
+                                    self.query_tools.clone(),
+                                    plan_templates
+                                )?
+                            ))
+                        })
+                        .collect::<Result<Vec<_>, _>>()?
+                        .join(" AND ")
+                }
+            }
+            _ => self.templates.always_true()?,
         };
         Ok(res)
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/compiler.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/compiler.rs
index 17e8a64a6be20..e918fbb8d1b46 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/compiler.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/compiler.rs
@@ -82,13 +82,13 @@ impl<'a> FilterCompiler<'a> {
             Ok(FilterItem::Group(Rc::new(FilterGroup::new(op, items))))
         } else {
             if let (Some(member), Some(operator)) = (item.member(), &item.operator) {
-                let evaluator = match item_type {
-                    FilterType::Dimension => self
-                        .evaluator_compiler
-                        .add_dimension_evaluator(member.clone())?,
-                    FilterType::Measure => self
-                        .evaluator_compiler
-                        .add_measure_evaluator(member.clone())?,
+                let member_path = member.split(".").map(|m| m.to_string()).collect::<Vec<_>>();
+                let evaluator = if self.query_tools.cube_evaluator().is_measure(member_path)? {
+                    self.evaluator_compiler
+                        .add_measure_evaluator(member.clone())?
+                } else {
+                    self.evaluator_compiler
+                        .add_dimension_evaluator(member.clone())?
                 };
                 Ok(FilterItem::Item(BaseFilter::try_new(
                     self.query_tools.clone(),
@@ -115,16 +115,20 @@ impl<'a> FilterCompiler<'a> {
         } else if let Some(items) = &item.and {
             self.get_item_type_from_vec(&items, expected_type)
         } else {
-            if let Some(member) = item.member() {
+            if let (Some(member), Some(operator)) = (item.member(), &item.operator) {
+                let operator = FilterOperator::from_str(&operator)?;
+                let is_measure_filter_op = matches!(operator, FilterOperator::MeasureFilter);
                 let member_path = member.split(".").map(|m| m.to_string()).collect::<Vec<_>>();
-                if self.query_tools.cube_evaluator().is_measure(member_path)? {
+                if self.query_tools.cube_evaluator().is_measure(member_path)?
+                    && !is_measure_filter_op
+                {
                     Ok(Some(FilterType::Measure))
                 } else {
                     Ok(Some(FilterType::Dimension))
                 }
             } else {
                 Err(CubeError::user(format!(
-                    "Member attribute is required for filter"
+                    "Member and operator attributes is required for filter"
                 ))) //TODO pring condition
             }
         }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/filter_operator.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/filter_operator.rs
index 30e0e39012813..e0865b76c0c44 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/filter_operator.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/filter_operator.rs
@@ -21,19 +21,21 @@ pub enum FilterOperator {
     NotStartsWith,
     NotEndsWith,
     EndsWith,
+    MeasureFilter,
 }
 
 impl FromStr for FilterOperator {
     type Err = CubeError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.to_lowercase().as_str() {
+        match s.to_lowercase().replace("_", "").as_str() {
             "equals" => Ok(Self::Equal),
             "notequals" => Ok(Self::NotEqual),
             "indaterange" => Ok(Self::InDateRange),
             "in" => Ok(Self::In),
             "notin" => Ok(Self::NotIn),
             "set" => Ok(Self::Set),
+            "notset" => Ok(Self::NotSet),
             "gt" => Ok(Self::Gt),
             "gte" => Ok(Self::Gte),
             "lt" => Ok(Self::Lt),
@@ -44,6 +46,7 @@ impl FromStr for FilterOperator {
             "notstartswith" => Ok(Self::NotStartsWith),
             "endswith" => Ok(Self::EndsWith),
             "notendswith" => Ok(Self::NotEndsWith),
+            "measurefilter" => Ok(Self::MeasureFilter),
 
             _ => Err(CubeError::user(format!("Unknown filter operator {}", s))),
         }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/common_utils.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/common_utils.rs
index ab32cb81284ab..ea9ba1d53d24d 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/common_utils.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/common_utils.rs
@@ -32,7 +32,8 @@ impl CommonUtils {
             .static_data()
             .primary_keys
             .get(cube_name)
-            .unwrap();
+            .cloned()
+            .unwrap_or_else(|| vec![]);
 
         let dims = primary_keys
             .iter()
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/full_key_query_aggregate_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/full_key_query_aggregate_planner.rs
index 0569382056f38..a89db3fe234ea 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/full_key_query_aggregate_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/full_key_query_aggregate_planner.rs
@@ -151,7 +151,7 @@ impl FullKeyAggregateQueryPlanner {
         };
 
         select_builder.set_order_by(self.order_planner.default_order());
-        select_builder.set_having(having);
+        select_builder.set_filter(having);
         select_builder.set_limit(self.query_properties.row_limit());
         select_builder.set_offset(self.query_properties.offset());
         if !ctes.is_empty() {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs
index cb3daafad4973..748840c1f3cee 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs
@@ -1,6 +1,6 @@
 use super::{CommonUtils, DimensionSubqueryPlanner};
 use crate::cube_bridge::join_definition::JoinDefinition;
-use crate::cube_bridge::memeber_sql::MemberSql;
+use crate::cube_bridge::member_sql::MemberSql;
 use crate::plan::{From, JoinBuilder, JoinCondition};
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::SqlCall;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs
index 199017ab1b8ce..06fee5c058ecb 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs
@@ -379,11 +379,11 @@ impl MultiStageMemberQueryPlanner {
             );
             planner.plan()?
         } else {
-            let multiplied_measures_query_planner = MultipliedMeasuresQueryPlanner::new(
+            let multiplied_measures_query_planner = MultipliedMeasuresQueryPlanner::try_new(
                 self.query_tools.clone(),
                 cte_query_properties.clone(),
                 node_factory.clone(),
-            );
+            )?;
             let full_key_aggregate_planner = FullKeyAggregateQueryPlanner::new(
                 cte_query_properties.clone(),
                 node_factory.clone(),
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
index 490b9a86dd689..65ad3d132466e 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multiplied_measures_query_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multiplied_measures_query_planner.rs
@@ -7,11 +7,13 @@ use crate::plan::{
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::collectors::{
     collect_cube_names, collect_join_hints, collect_join_hints_for_measures,
-    collect_sub_query_dimensions_from_members,
+    collect_sub_query_dimensions_from_members, collect_sub_query_dimensions_from_symbols,
 };
 use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
 use crate::planner::sql_evaluator::ReferencesBuilder;
-use crate::planner::{BaseMeasure, BaseMember, BaseMemberHelper, QueryProperties};
+use crate::planner::{
+    BaseMeasure, BaseMember, BaseMemberHelper, FullKeyAggregateMeasures, QueryProperties,
+};
 use cubenativeutils::CubeError;
 use itertools::Itertools;
 use std::collections::HashMap;
@@ -23,21 +25,24 @@ pub struct MultipliedMeasuresQueryPlanner {
     join_planner: JoinPlanner,
     common_utils: CommonUtils,
     context_factory: SqlNodesFactory,
+    full_key_aggregate_measures: FullKeyAggregateMeasures,
 }
 
 impl MultipliedMeasuresQueryPlanner {
-    pub fn new(
+    pub fn try_new(
         query_tools: Rc<QueryTools>,
         query_properties: Rc<QueryProperties>,
         context_factory: SqlNodesFactory,
-    ) -> Self {
-        Self {
+    ) -> Result<Self, CubeError> {
+        let full_key_aggregate_measures = query_properties.full_key_aggregate_measures()?;
+        Ok(Self {
             query_tools: query_tools.clone(),
             join_planner: JoinPlanner::new(query_tools.clone()),
             common_utils: CommonUtils::new(query_tools.clone()),
             query_properties,
             context_factory,
-        }
+            full_key_aggregate_measures,
+        })
     }
 
     pub fn plan_queries(&self) -> Result<Vec<Rc<Select>>, CubeError> {
@@ -47,14 +52,16 @@ impl MultipliedMeasuresQueryPlanner {
             )));
         }
 
-        let measures = self.query_properties.full_key_aggregate_measures()?;
+        let full_key_aggregate_measures = &self.full_key_aggregate_measures;
 
         let mut joins = Vec::new();
 
-        if !measures.regular_measures.is_empty() {
+        if !full_key_aggregate_measures.regular_measures.is_empty() {
             let join_multi_fact_groups = self
                 .query_properties
-                .compute_join_multi_fact_groups_with_measures(&measures.regular_measures)?;
+                .compute_join_multi_fact_groups_with_measures(
+                    &full_key_aggregate_measures.regular_measures,
+                )?;
             for (i, (join, measures)) in join_multi_fact_groups.iter().enumerate() {
                 let regular_subquery = self.regular_measures_subquery(
                     measures,
@@ -69,7 +76,7 @@ impl MultipliedMeasuresQueryPlanner {
             }
         }
 
-        for (cube_name, measures) in measures
+        for (cube_name, measures) in full_key_aggregate_measures
             .multiplied_measures
             .clone()
             .into_iter()
@@ -230,6 +237,11 @@ impl MultipliedMeasuresQueryPlanner {
         let mut context_factory = self.context_factory.clone();
         context_factory.set_render_references(render_references);
         context_factory.set_ungrouped_measure_references(ungrouped_measure_references);
+        context_factory.set_rendered_as_multiplied_measures(
+            self.full_key_aggregate_measures
+                .rendered_as_multiplied_measures
+                .clone(),
+        );
         Ok(Rc::new(select_builder.build(context_factory)))
     }
 
@@ -275,6 +287,13 @@ impl MultipliedMeasuresQueryPlanner {
         let mut context_factory = self.context_factory.clone();
         context_factory.set_ungrouped_measure(true);
         context_factory.set_render_references(dimension_subquery_planner.dimensions_refs().clone());
+
+        context_factory.set_rendered_as_multiplied_measures(
+            self.full_key_aggregate_measures
+                .rendered_as_multiplied_measures
+                .clone(),
+        );
+
         let mut select_builder = SelectBuilder::new(from);
         for dim in primary_keys_dimensions.iter() {
             select_builder.add_projection_member(dim, None);
@@ -291,8 +310,8 @@ impl MultipliedMeasuresQueryPlanner {
         join: Rc<dyn JoinDefinition>,
         alias_prefix: String,
     ) -> Result<Rc<Select>, CubeError> {
-        let subquery_dimensions = collect_sub_query_dimensions_from_members(
-            &self.query_properties.all_members(false),
+        let subquery_dimensions = collect_sub_query_dimensions_from_symbols(
+            &self.query_properties.all_member_symbols(false),
             self.query_tools.clone(),
         )?;
 
@@ -323,6 +342,11 @@ impl MultipliedMeasuresQueryPlanner {
 
         let render_references = dimension_subquery_planner.dimensions_refs().clone();
         context_factory.set_render_references(render_references);
+        context_factory.set_rendered_as_multiplied_measures(
+            self.full_key_aggregate_measures
+                .rendered_as_multiplied_measures
+                .clone(),
+        );
 
         Ok(Rc::new(select_builder.build(context_factory)))
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/query_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/query_planner.rs
index 80bfd57e98a24..954a599181e2c 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/query_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/query_planner.rs
@@ -47,11 +47,11 @@ impl QueryPlanner {
             planner.plan()
         } else {
             let request = self.request.clone();
-            let multiplied_measures_query_planner = MultipliedMeasuresQueryPlanner::new(
+            let multiplied_measures_query_planner = MultipliedMeasuresQueryPlanner::try_new(
                 self.query_tools.clone(),
                 request.clone(),
                 nodes_factory.clone(),
-            );
+            )?;
             let multi_stage_query_planner =
                 MultiStageQueryPlanner::new(self.query_tools.clone(), request.clone());
             let full_key_aggregate_planner = FullKeyAggregateQueryPlanner::new(
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/simple_query_planer.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/simple_query_planer.rs
index b67d5ceca5c9e..cf7d79475bf07 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/simple_query_planer.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/simple_query_planer.rs
@@ -1,7 +1,7 @@
 use super::{DimensionSubqueryPlanner, JoinPlanner, OrderPlanner};
 use crate::plan::{Filter, Select, SelectBuilder};
 use crate::planner::query_tools::QueryTools;
-use crate::planner::sql_evaluator::collectors::collect_sub_query_dimensions_from_members;
+use crate::planner::sql_evaluator::collectors::collect_sub_query_dimensions_from_symbols;
 use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
 use crate::planner::QueryProperties;
 use cubenativeutils::CubeError;
@@ -30,8 +30,8 @@ impl SimpleQueryPlanner {
     }
 
     pub fn plan(&self) -> Result<Rc<Select>, CubeError> {
-        let subquery_dimensions = collect_sub_query_dimensions_from_members(
-            &self.query_properties.all_members(false),
+        let subquery_dimensions = collect_sub_query_dimensions_from_symbols(
+            &self.query_properties.all_member_symbols(false),
             self.query_tools.clone(),
         )?;
         let dimension_subquery_planner = DimensionSubqueryPlanner::try_new(
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
index cb47313aaf6fe..d6b07304ae690 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
@@ -1,5 +1,6 @@
 use super::filter::compiler::FilterCompiler;
 use super::query_tools::QueryTools;
+use super::sql_evaluator::MemberSymbol;
 use super::{BaseDimension, BaseMeasure, BaseMember, BaseMemberHelper, BaseTimeDimension};
 use crate::cube_bridge::base_query_options::BaseQueryOptions;
 use crate::cube_bridge::join_definition::JoinDefinition;
@@ -37,6 +38,7 @@ pub struct FullKeyAggregateMeasures {
     pub multiplied_measures: Vec<Rc<BaseMeasure>>,
     pub regular_measures: Vec<Rc<BaseMeasure>>,
     pub multi_stage_measures: Vec<Rc<BaseMeasure>>,
+    pub rendered_as_multiplied_measures: HashSet<String>,
 }
 
 impl FullKeyAggregateMeasures {
@@ -458,6 +460,23 @@ impl QueryProperties {
                 .collect_vec()
         }
     }
+    pub fn all_member_symbols(&self, exclude_time_dimensions: bool) -> Vec<Rc<MemberSymbol>> {
+        let mut members = self
+            .all_members(exclude_time_dimensions)
+            .into_iter()
+            .map(|m| m.member_evaluator())
+            .collect_vec();
+        for filter_item in self.dimensions_filters.iter() {
+            filter_item.find_all_member_evaluators(&mut members);
+        }
+        for filter_item in self.measures_filters.iter() {
+            filter_item.find_all_member_evaluators(&mut members);
+        }
+        members
+            .into_iter()
+            .unique_by(|m| m.full_name())
+            .collect_vec()
+    }
 
     pub fn group_by(&self) -> Vec<Expr> {
         if self.ungrouped {
@@ -541,7 +560,7 @@ impl QueryProperties {
 
     pub fn full_key_aggregate_measures(&self) -> Result<FullKeyAggregateMeasures, CubeError> {
         let mut result = FullKeyAggregateMeasures::default();
-        let measures = self.measures();
+        let measures = self.all_used_measures()?;
         for m in measures.iter() {
             if has_multi_stage_members(m.member_evaluator(), self.ignore_cumulative)? {
                 result.multi_stage_measures.push(m.clone())
@@ -559,6 +578,11 @@ impl QueryProperties {
                     join,
                 )? {
                     if item.multiplied {
+                        result
+                            .rendered_as_multiplied_measures
+                            .insert(item.measure.full_name());
+                    }
+                    if item.multiplied && !item.measure.can_used_as_addictive_in_multplied()? {
                         result.multiplied_measures.push(item.measure.clone());
                     } else {
                         result.regular_measures.push(item.measure.clone());
@@ -569,4 +593,40 @@ impl QueryProperties {
 
         Ok(result)
     }
+
+    fn all_used_measures(&self) -> Result<Vec<Rc<BaseMeasure>>, CubeError> {
+        let mut measures = self.measures.clone();
+        for item in self.measures_filters.iter() {
+            self.fill_missed_measures_from_filter(item, &mut measures)?;
+        }
+        Ok(measures)
+    }
+
+    fn fill_missed_measures_from_filter(
+        &self,
+        item: &FilterItem,
+        measures: &mut Vec<Rc<BaseMeasure>>,
+    ) -> Result<(), CubeError> {
+        match item {
+            FilterItem::Group(group) => {
+                for item in group.items.iter() {
+                    self.fill_missed_measures_from_filter(item, measures)?
+                }
+            }
+            FilterItem::Item(item) => {
+                let item_member_name = item.member_name();
+                if measures
+                    .iter()
+                    .find(|m| m.full_name() == item_member_name)
+                    .is_none()
+                {
+                    measures.push(BaseMeasure::try_new_required(
+                        item.member_evaluator().clone(),
+                        self.query_tools.clone(),
+                    )?);
+                }
+            }
+        }
+        Ok(())
+    }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/mod.rs
index 8b8b9e3528c3f..3315b5dfa2b79 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/mod.rs
@@ -16,4 +16,5 @@ pub use member_childs_collector::{member_childs, MemberChildsCollector};
 pub use multiplied_measures_collector::{collect_multiplied_measures, MultipliedMeasuresCollector};
 pub use sub_query_dimensions::{
     collect_sub_query_dimensions, collect_sub_query_dimensions_from_members,
+    collect_sub_query_dimensions_from_symbols,
 };
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
index c97cfc0ea35fe..fc2b7589ada04 100644
--- 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
@@ -2,6 +2,7 @@ use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::{DimensionSymbol, MemberSymbol, TraversalVisitor};
 use crate::planner::{BaseDimension, BaseMember};
 use cubenativeutils::CubeError;
+use itertools::Itertools;
 use std::rc::Rc;
 
 pub struct SubQueryDimensionsCollector {
@@ -59,10 +60,18 @@ impl TraversalVisitor for SubQueryDimensionsCollector {
 pub fn collect_sub_query_dimensions_from_members(
     members: &Vec<Rc<dyn BaseMember>>,
     query_tools: Rc<QueryTools>,
+) -> Result<Vec<Rc<BaseDimension>>, CubeError> {
+    let symbols = members.iter().map(|m| m.member_evaluator()).collect_vec();
+    collect_sub_query_dimensions_from_symbols(&symbols, query_tools)
+}
+
+pub fn collect_sub_query_dimensions_from_symbols(
+    members: &Vec<Rc<MemberSymbol>>,
+    query_tools: Rc<QueryTools>,
 ) -> Result<Vec<Rc<BaseDimension>>, CubeError> {
     let mut visitor = SubQueryDimensionsCollector::new();
     for member in members.iter() {
-        visitor.apply(&member.member_evaluator(), &())?;
+        visitor.apply(&member, &())?;
     }
     visitor
         .extract_result()
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs
index 9e87582b8c7d1..1b284b5219ca3 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs
@@ -6,7 +6,7 @@ use super::{
     SqlCall, SymbolFactory, TraversalVisitor,
 };
 use crate::cube_bridge::evaluator::CubeEvaluator;
-use crate::cube_bridge::memeber_sql::MemberSql;
+use crate::cube_bridge::member_sql::MemberSql;
 use cubenativeutils::CubeError;
 use std::collections::HashMap;
 use std::rc::Rc;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs
index ce284b26387b3..ee48bb0184b72 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs
@@ -1,7 +1,7 @@
 use super::symbols::MemberSymbol;
 use super::Compiler;
 use crate::cube_bridge::evaluator::{CallDep, CubeEvaluator};
-use crate::cube_bridge::memeber_sql::MemberSql;
+use crate::cube_bridge::member_sql::MemberSql;
 use cubenativeutils::CubeError;
 use std::collections::HashMap;
 use std::rc::Rc;
@@ -68,9 +68,12 @@ impl<'a> DependenciesBuilder<'a> {
         cube_name: String,
         member_sql: Rc<dyn MemberSql>,
     ) -> Result<Vec<Dependency>, CubeError> {
-        let call_deps = self
-            .cube_evaluator
-            .resolve_symbols_call_deps(cube_name.clone(), member_sql)?;
+        let call_deps = if member_sql.need_deps_resolve() {
+            self.cube_evaluator
+                .resolve_symbols_call_deps(cube_name.clone(), member_sql)?
+        } else {
+            vec![]
+        };
 
         let mut childs = Vec::new();
         for (i, dep) in call_deps.iter().enumerate() {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs
index 8b48ae359ff49..6e56d82f2ba28 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs
@@ -1,8 +1,9 @@
 use super::dependecy::{ContextSymbolDep, CubeDepProperty, CubeDependency, Dependency};
 use super::sql_nodes::SqlNode;
 use super::{symbols::MemberSymbol, SqlEvaluatorVisitor};
-use crate::cube_bridge::memeber_sql::{ContextSymbolArg, MemberSql, MemberSqlArg, MemberSqlStruct};
+use crate::cube_bridge::member_sql::{ContextSymbolArg, MemberSql, MemberSqlArg, MemberSqlStruct};
 use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
@@ -21,12 +22,19 @@ impl SqlCall {
         visitor: &SqlEvaluatorVisitor,
         node_processor: Rc<dyn SqlNode>,
         query_tools: Rc<QueryTools>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
         let args = self
             .deps
             .iter()
             .map(|d| {
-                self.evaluate_single_dep(&d, visitor, node_processor.clone(), query_tools.clone())
+                self.evaluate_single_dep(
+                    &d,
+                    visitor,
+                    node_processor.clone(),
+                    query_tools.clone(),
+                    templates,
+                )
             })
             .collect::<Result<Vec<_>, _>>()?;
         self.member_sql.call(args)
@@ -102,14 +110,21 @@ impl SqlCall {
         visitor: &SqlEvaluatorVisitor,
         node_processor: Rc<dyn SqlNode>,
         query_tools: Rc<QueryTools>,
+        templates: &PlanSqlTemplates,
     ) -> Result<MemberSqlArg, CubeError> {
         match dep {
-            Dependency::SymbolDependency(dep) => Ok(MemberSqlArg::String(
-                visitor.apply(dep, node_processor.clone())?,
-            )),
-            Dependency::CubeDependency(dep) => {
-                self.evaluate_cube_dep(dep, visitor, node_processor.clone(), query_tools.clone())
-            }
+            Dependency::SymbolDependency(dep) => Ok(MemberSqlArg::String(visitor.apply(
+                dep,
+                node_processor.clone(),
+                templates,
+            )?)),
+            Dependency::CubeDependency(dep) => self.evaluate_cube_dep(
+                dep,
+                visitor,
+                node_processor.clone(),
+                query_tools.clone(),
+                templates,
+            ),
             Dependency::ContextDependency(contex_symbol) => {
                 self.apply_context_symbol(contex_symbol, query_tools.clone())
             }
@@ -122,24 +137,27 @@ impl SqlCall {
         visitor: &SqlEvaluatorVisitor,
         node_processor: Rc<dyn SqlNode>,
         query_tools: Rc<QueryTools>,
+        templates: &PlanSqlTemplates,
     ) -> Result<MemberSqlArg, CubeError> {
         let mut res = MemberSqlStruct::default();
         if let Some(sql_fn) = &dep.sql_fn {
-            res.sql_fn = Some(visitor.apply(sql_fn, node_processor.clone())?);
+            res.sql_fn = Some(visitor.apply(sql_fn, node_processor.clone(), templates)?);
         }
         if let Some(to_string_fn) = &dep.to_string_fn {
-            res.to_string_fn = Some(visitor.apply(to_string_fn, node_processor.clone())?);
+            res.to_string_fn =
+                Some(visitor.apply(to_string_fn, node_processor.clone(), templates)?);
         }
         for (k, v) in dep.properties.iter() {
             let prop_res = match v {
                 CubeDepProperty::SymbolDependency(dep) => {
-                    MemberSqlArg::String(visitor.apply(&dep, node_processor.clone())?)
+                    MemberSqlArg::String(visitor.apply(&dep, node_processor.clone(), templates)?)
                 }
                 CubeDepProperty::CubeDependency(dep) => self.evaluate_cube_dep(
                     &dep,
                     visitor,
                     node_processor.clone(),
                     query_tools.clone(),
+                    templates,
                 )?,
             };
             res.properties.insert(k.clone(), prop_res);
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/auto_prefix.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/auto_prefix.rs
index 708242bb1bcdc..20d0aab127f12 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/auto_prefix.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/auto_prefix.rs
@@ -3,6 +3,7 @@ use crate::plan::Schema;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::any::Any;
 use std::collections::HashMap;
@@ -63,10 +64,15 @@ impl SqlNode for AutoPrefixSqlNode {
         node: &Rc<MemberSymbol>,
         query_tools: Rc<QueryTools>,
         node_processor: Rc<dyn SqlNode>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
-        let input =
-            self.input
-                .to_sql(visitor, node, query_tools.clone(), node_processor.clone())?;
+        let input = self.input.to_sql(
+            visitor,
+            node,
+            query_tools.clone(),
+            node_processor.clone(),
+            templates,
+        )?;
         let res = match node.as_ref() {
             MemberSymbol::Dimension(ev) => {
                 let cube_alias = self.resolve_cube_alias(&ev.cube_name());
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs
index 0ca063cb9fa15..246d05698366c 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs
@@ -2,6 +2,7 @@ use super::SqlNode;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::any::Any;
 use std::rc::Rc;
@@ -21,13 +22,18 @@ impl SqlNode for EvaluateSqlNode {
         node: &Rc<MemberSymbol>,
         query_tools: Rc<QueryTools>,
         node_processor: Rc<dyn SqlNode>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
         match node.as_ref() {
-            MemberSymbol::Dimension(ev) => {
-                ev.evaluate_sql(visitor, node_processor.clone(), query_tools.clone())
-            }
+            MemberSymbol::Dimension(ev) => ev.evaluate_sql(
+                visitor,
+                node_processor.clone(),
+                query_tools.clone(),
+                templates,
+            ),
             MemberSymbol::TimeDimension(ev) => {
-                let input_sql = visitor.apply(&ev.base_symbol(), node_processor.clone())?;
+                let input_sql =
+                    visitor.apply(&ev.base_symbol(), node_processor.clone(), templates)?;
                 let res = if let Some(granularity) = ev.granularity() {
                     let converted_tz = query_tools.base_tools().convert_tz(input_sql)?;
                     query_tools
@@ -39,15 +45,54 @@ impl SqlNode for EvaluateSqlNode {
                 Ok(res)
             }
             MemberSymbol::Measure(ev) => {
-                ev.evaluate_sql(visitor, node_processor.clone(), query_tools.clone())
-            }
-            MemberSymbol::CubeTable(ev) => {
-                ev.evaluate_sql(visitor, node_processor.clone(), query_tools.clone())
+                let res = if ev.has_sql() {
+                    ev.evaluate_sql(
+                        visitor,
+                        node_processor.clone(),
+                        query_tools.clone(),
+                        templates,
+                    )?
+                } else if ev.pk_sqls().len() > 1 {
+                    let pk_strings = ev
+                        .pk_sqls()
+                        .iter()
+                        .map(|pk| -> Result<_, CubeError> {
+                            let res = pk.eval(
+                                &visitor,
+                                node_processor.clone(),
+                                query_tools.clone(),
+                                templates,
+                            )?;
+                            templates.cast_to_string(&res)
+                        })
+                        .collect::<Result<Vec<_>, _>>()?;
+                    templates.concat_strings(&pk_strings)?
+                } else if ev.pk_sqls().len() == 1 {
+                    let pk_sql = ev.pk_sqls().first().unwrap();
+                    pk_sql.eval(
+                        &visitor,
+                        node_processor.clone(),
+                        query_tools.clone(),
+                        templates,
+                    )?
+                } else {
+                    format!("*")
+                };
+                Ok(res)
             }
+            MemberSymbol::CubeTable(ev) => ev.evaluate_sql(
+                visitor,
+                node_processor.clone(),
+                query_tools.clone(),
+                templates,
+            ),
             MemberSymbol::CubeName(ev) => ev.evaluate_sql(),
-            MemberSymbol::SqlCall(s) => {
-                s.eval(visitor, node_processor.clone(), query_tools.clone())
-            }
+            MemberSymbol::SqlCall(s) => s.eval(
+                visitor,
+                node_processor.clone(),
+                query_tools.clone(),
+                templates,
+            ),
         }
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs
index 144d2d7052807..a341aad761d9d 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs
@@ -1,11 +1,11 @@
 use super::{
-    AutoPrefixSqlNode, EvaluateSqlNode, FinalMeasureSqlNode, MeasureFilterSqlNode,
-    MultiStageRankNode, MultiStageWindowNode, RenderReferencesSqlNode, RollingWindowNode,
-    RootSqlNode, SqlNode, TimeShiftSqlNode, UngroupedMeasureSqlNode,
+    AutoPrefixSqlNode, EvaluateSqlNode, FinalMeasureSqlNode, GeoDimensionSqlNode,
+    MeasureFilterSqlNode, MultiStageRankNode, MultiStageWindowNode, RenderReferencesSqlNode,
+    RollingWindowNode, RootSqlNode, SqlNode, TimeShiftSqlNode, UngroupedMeasureSqlNode,
     UngroupedQueryFinalMeasureSqlNode,
 };
 use crate::plan::schema::QualifiedColumnName;
-use std::collections::HashMap;
+use std::collections::{HashMap, HashSet};
 use std::rc::Rc;
 
 #[derive(Clone)]
@@ -14,6 +14,7 @@ pub struct SqlNodesFactory {
     ungrouped: bool,
     ungrouped_measure: bool,
     render_references: HashMap<String, QualifiedColumnName>,
+    rendered_as_multiplied_measures: HashSet<String>,
     ungrouped_measure_references: HashMap<String, QualifiedColumnName>,
     cube_name_references: HashMap<String, String>,
     multi_stage_rank: Option<Vec<String>>,   //partition_by
@@ -30,6 +31,7 @@ impl SqlNodesFactory {
             render_references: HashMap::new(),
             ungrouped_measure_references: HashMap::new(),
             cube_name_references: HashMap::new(),
+            rendered_as_multiplied_measures: HashSet::new(),
             multi_stage_rank: None,
             multi_stage_window: None,
             rolling_window: false,
@@ -56,6 +58,10 @@ impl SqlNodesFactory {
         &self.render_references
     }
 
+    pub fn set_rendered_as_multiplied_measures(&mut self, value: HashSet<String>) {
+        self.rendered_as_multiplied_measures = value;
+    }
+
     pub fn add_render_reference(&mut self, key: String, value: QualifiedColumnName) {
         self.render_references.insert(key, value);
     }
@@ -108,7 +114,7 @@ impl SqlNodesFactory {
         let measure_processor = self.add_multi_stage_rank_if_needed(measure_processor);
 
         let root_node = RootSqlNode::new(
-            self.dimension_processor(auto_prefix_processor.clone()),
+            self.dimension_processor(evaluate_sql_processor.clone()),
             measure_processor.clone(),
             auto_prefix_processor.clone(),
             evaluate_sql_processor.clone(),
@@ -155,11 +161,16 @@ impl SqlNodesFactory {
         } else if self.rolling_window {
             RollingWindowNode::new(input)
         } else {
-            FinalMeasureSqlNode::new(input)
+            FinalMeasureSqlNode::new(input, self.rendered_as_multiplied_measures.clone())
         }
     }
 
     fn dimension_processor(&self, input: Rc<dyn SqlNode>) -> Rc<dyn SqlNode> {
+        let input: Rc<dyn SqlNode> = GeoDimensionSqlNode::new(input);
+
+        let input: Rc<dyn SqlNode> =
+            AutoPrefixSqlNode::new(input, self.cube_name_references.clone());
+
         let input = if !&self.time_shifts.is_empty() {
             TimeShiftSqlNode::new(self.time_shifts.clone(), input)
         } else {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/final_measure.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/final_measure.rs
index c844c2a786de4..8a39e43ee6872 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/final_measure.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/final_measure.rs
@@ -1,23 +1,41 @@
 use super::SqlNode;
 use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::MeasureSymbol;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::any::Any;
+use std::collections::HashSet;
 use std::rc::Rc;
 
 pub struct FinalMeasureSqlNode {
     input: Rc<dyn SqlNode>,
+    rendered_as_multiplied_measures: HashSet<String>,
 }
 
 impl FinalMeasureSqlNode {
-    pub fn new(input: Rc<dyn SqlNode>) -> Rc<Self> {
-        Rc::new(Self { input })
+    pub fn new(
+        input: Rc<dyn SqlNode>,
+        rendered_as_multiplied_measures: HashSet<String>,
+    ) -> Rc<Self> {
+        Rc::new(Self {
+            input,
+            rendered_as_multiplied_measures,
+        })
     }
 
     pub fn input(&self) -> &Rc<dyn SqlNode> {
         &self.input
     }
+
+    fn is_count_disttinct(&self, symbol: &MeasureSymbol) -> bool {
+        symbol.measure_type() == "countDistinct"
+            || (symbol.measure_type() == "count"
+                && self
+                    .rendered_as_multiplied_measures
+                    .contains(&symbol.full_name()))
+    }
 }
 
 impl SqlNode for FinalMeasureSqlNode {
@@ -27,6 +45,7 @@ impl SqlNode for FinalMeasureSqlNode {
         node: &Rc<MemberSymbol>,
         query_tools: Rc<QueryTools>,
         node_processor: Rc<dyn SqlNode>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
         let res = match node.as_ref() {
             MemberSymbol::Measure(ev) => {
@@ -35,11 +54,14 @@ impl SqlNode for FinalMeasureSqlNode {
                     node,
                     query_tools.clone(),
                     node_processor.clone(),
+                    templates,
                 )?;
                 //};
 
                 if ev.is_calculated() {
                     input
+                } else if self.is_count_disttinct(ev) {
+                    templates.count_distinct(&input)?
                 } else {
                     let measure_type = if ev.measure_type() == "runningTotal" {
                         "sum"
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/geo_dimension.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/geo_dimension.rs
new file mode 100644
index 0000000000000..f74832b81ac50
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/geo_dimension.rs
@@ -0,0 +1,87 @@
+use super::SqlNode;
+use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::MemberSymbol;
+use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use crate::planner::sql_templates::PlanSqlTemplates;
+use cubenativeutils::CubeError;
+use std::any::Any;
+use std::collections::HashMap;
+use std::rc::Rc;
+
+pub struct GeoDimensionSqlNode {
+    input: Rc<dyn SqlNode>,
+}
+
+impl GeoDimensionSqlNode {
+    pub fn new(input: Rc<dyn SqlNode>) -> Rc<Self> {
+        Rc::new(Self { input })
+    }
+
+    pub fn input(&self) -> &Rc<dyn SqlNode> {
+        &self.input
+    }
+}
+
+impl SqlNode for GeoDimensionSqlNode {
+    fn to_sql(
+        &self,
+        visitor: &SqlEvaluatorVisitor,
+        node: &Rc<MemberSymbol>,
+        query_tools: Rc<QueryTools>,
+        node_processor: Rc<dyn SqlNode>,
+        templates: &PlanSqlTemplates,
+    ) -> Result<String, CubeError> {
+        let res = match node.as_ref() {
+            MemberSymbol::Dimension(ev) => {
+                if ev.dimension_type() == "geo" {
+                    if let (Some(latitude), Some(longitude)) = (ev.latitude(), ev.longitude()) {
+                        let latitude_str = latitude.eval(
+                            visitor,
+                            node_processor.clone(),
+                            query_tools.clone(),
+                            templates,
+                        )?;
+                        let longitude_str = longitude.eval(
+                            visitor,
+                            node_processor.clone(),
+                            query_tools.clone(),
+                            templates,
+                        )?;
+                        templates.concat_strings(&vec![
+                            latitude_str,
+                            format!("','"),
+                            longitude_str,
+                        ])?
+                    } else {
+                        return Err(CubeError::user(format!(
+                            "Geo dimension '{}' must have latitude and longitude",
+                            ev.full_name()
+                        )));
+                    }
+                } else {
+                    self.input.to_sql(
+                        visitor,
+                        node,
+                        query_tools.clone(),
+                        node_processor.clone(),
+                        templates,
+                    )?
+                }
+            }
+            _ => {
+                return Err(CubeError::internal(format!(
+                    "GeoDimension node processor called for wrong node",
+                )));
+            }
+        };
+        Ok(res)
+    }
+
+    fn as_any(self: Rc<Self>) -> Rc<dyn Any> {
+        self.clone()
+    }
+
+    fn childs(&self) -> Vec<Rc<dyn SqlNode>> {
+        vec![self.input.clone()]
+    }
+}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/measure_filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/measure_filter.rs
index e9f7c771c77e6..e180959925ec0 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/measure_filter.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/measure_filter.rs
@@ -2,6 +2,7 @@ use super::SqlNode;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::any::Any;
 use std::rc::Rc;
@@ -27,10 +28,15 @@ impl SqlNode for MeasureFilterSqlNode {
         node: &Rc<MemberSymbol>,
         query_tools: Rc<QueryTools>,
         node_processor: Rc<dyn SqlNode>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
-        let input =
-            self.input
-                .to_sql(visitor, node, query_tools.clone(), node_processor.clone())?;
+        let input = self.input.to_sql(
+            visitor,
+            node,
+            query_tools.clone(),
+            node_processor.clone(),
+            templates,
+        )?;
         let res = match node.as_ref() {
             MemberSymbol::Measure(ev) => {
                 let measure_filters = ev.measure_filters();
@@ -43,7 +49,8 @@ impl SqlNode for MeasureFilterSqlNode {
                                 filter.eval(
                                     &visitor,
                                     node_processor.clone(),
-                                    query_tools.clone()
+                                    query_tools.clone(),
+                                    templates
                                 )?
                             ))
                         })
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/mod.rs
index 60a1c025855c5..8b1e16cdf471b 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/mod.rs
@@ -2,6 +2,7 @@ pub mod auto_prefix;
 pub mod evaluate_sql;
 pub mod factory;
 pub mod final_measure;
+pub mod geo_dimension;
 pub mod measure_filter;
 pub mod multi_stage_rank;
 pub mod multi_stage_window;
@@ -17,6 +18,7 @@ pub use auto_prefix::AutoPrefixSqlNode;
 pub use evaluate_sql::EvaluateSqlNode;
 pub use factory::SqlNodesFactory;
 pub use final_measure::FinalMeasureSqlNode;
+pub use geo_dimension::GeoDimensionSqlNode;
 pub use measure_filter::MeasureFilterSqlNode;
 pub use multi_stage_rank::MultiStageRankNode;
 pub use multi_stage_window::MultiStageWindowNode;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/multi_stage_rank.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/multi_stage_rank.rs
index 493de8228d6c9..d1200b8fae00d 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/multi_stage_rank.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/multi_stage_rank.rs
@@ -2,6 +2,7 @@ use super::SqlNode;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::any::Any;
 use std::rc::Rc;
@@ -35,6 +36,7 @@ impl SqlNode for MultiStageRankNode {
         node: &Rc<MemberSymbol>,
         query_tools: Rc<QueryTools>,
         node_processor: Rc<dyn SqlNode>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
         let res = match node.as_ref() {
             MemberSymbol::Measure(m) => {
@@ -48,6 +50,7 @@ impl SqlNode for MultiStageRankNode {
                                     visitor,
                                     node_processor.clone(),
                                     query_tools.clone(),
+                                    templates,
                                 )?;
                                 Ok(format!("{} {}", sql, item.direction()))
                             })
@@ -69,6 +72,7 @@ impl SqlNode for MultiStageRankNode {
                         node,
                         query_tools.clone(),
                         node_processor.clone(),
+                        templates,
                     )?
                 }
             }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/multi_stage_window.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/multi_stage_window.rs
index 4d1fc74c6b2b0..fe41626d666c8 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/multi_stage_window.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/multi_stage_window.rs
@@ -1,6 +1,7 @@
 use super::SqlNode;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::{MemberSymbol, SqlEvaluatorVisitor};
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::any::Any;
 use std::rc::Rc;
@@ -44,6 +45,7 @@ impl SqlNode for MultiStageWindowNode {
         node: &Rc<MemberSymbol>,
         query_tools: Rc<QueryTools>,
         node_processor: Rc<dyn SqlNode>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
         let res = match node.as_ref() {
             MemberSymbol::Measure(m) => {
@@ -53,6 +55,7 @@ impl SqlNode for MultiStageWindowNode {
                         node,
                         query_tools.clone(),
                         node_processor.clone(),
+                        templates,
                     )?;
 
                     let partition_by = if self.partition.is_empty() {
@@ -68,6 +71,7 @@ impl SqlNode for MultiStageWindowNode {
                         node,
                         query_tools.clone(),
                         node_processor.clone(),
+                        templates,
                     )?
                 }
             }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/render_references.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/render_references.rs
index 9d4e17a8687ce..0b3b6934533cd 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/render_references.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/render_references.rs
@@ -3,6 +3,7 @@ use crate::plan::QualifiedColumnName;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::any::Any;
 use std::collections::HashMap;
@@ -33,6 +34,7 @@ impl SqlNode for RenderReferencesSqlNode {
         node: &Rc<MemberSymbol>,
         query_tools: Rc<QueryTools>,
         node_processor: Rc<dyn SqlNode>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
         let full_name = node.full_name();
         if let Some(reference) = self.references.get(&full_name) {
@@ -46,8 +48,13 @@ impl SqlNode for RenderReferencesSqlNode {
                 query_tools.escape_column_name(&reference.name())
             ))
         } else {
-            self.input
-                .to_sql(visitor, node, query_tools.clone(), node_processor.clone())
+            self.input.to_sql(
+                visitor,
+                node,
+                query_tools.clone(),
+                node_processor.clone(),
+                templates,
+            )
         }
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/rolling_window.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/rolling_window.rs
index b6bcc87431855..288375a67a8a5 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/rolling_window.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/rolling_window.rs
@@ -1,6 +1,7 @@
 use super::SqlNode;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::{MemberSymbol, SqlEvaluatorVisitor};
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::any::Any;
 use std::rc::Rc;
@@ -26,12 +27,17 @@ impl SqlNode for RollingWindowNode {
         node: &Rc<MemberSymbol>,
         query_tools: Rc<QueryTools>,
         node_processor: Rc<dyn SqlNode>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
         let res = match node.as_ref() {
             MemberSymbol::Measure(m) => {
-                let input =
-                    self.input
-                        .to_sql(visitor, node, query_tools.clone(), node_processor)?;
+                let input = self.input.to_sql(
+                    visitor,
+                    node,
+                    query_tools.clone(),
+                    node_processor,
+                    templates,
+                )?;
                 if m.is_cumulative() {
                     let aggregate_function = if m.measure_type() == "sum"
                         || m.measure_type() == "count"
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/root_processor.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/root_processor.rs
index 16696687864aa..5aae2dbb2b090 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/root_processor.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/root_processor.rs
@@ -2,6 +2,7 @@ use super::SqlNode;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::any::Any;
 use std::rc::Rc;
@@ -52,6 +53,7 @@ impl SqlNode for RootSqlNode {
         node: &Rc<MemberSymbol>,
         query_tools: Rc<QueryTools>,
         node_processor: Rc<dyn SqlNode>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
         let res = match node.as_ref() {
             MemberSymbol::Dimension(_) => self.dimension_processor.to_sql(
@@ -59,24 +61,28 @@ impl SqlNode for RootSqlNode {
                 node,
                 query_tools.clone(),
                 node_processor.clone(),
+                templates,
             )?,
             MemberSymbol::Measure(_) => self.measure_processor.to_sql(
                 visitor,
                 node,
                 query_tools.clone(),
                 node_processor.clone(),
+                templates,
             )?,
             MemberSymbol::CubeName(_) => self.cube_name_processor.to_sql(
                 visitor,
                 node,
                 query_tools.clone(),
                 node_processor.clone(),
+                templates,
             )?,
             _ => self.default_processor.to_sql(
                 visitor,
                 node,
                 query_tools.clone(),
                 node_processor.clone(),
+                templates,
             )?,
         };
         Ok(res)
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/sql_node.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/sql_node.rs
index 1755c36e2817d..f5c2213caafde 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/sql_node.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/sql_node.rs
@@ -1,5 +1,7 @@
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::{MemberSymbol, SqlEvaluatorVisitor};
+use crate::planner::sql_templates::PlanSqlTemplates;
+
 use cubenativeutils::CubeError;
 use std::any::Any;
 use std::rc::Rc;
@@ -11,6 +13,7 @@ pub trait SqlNode {
         node: &Rc<MemberSymbol>,
         query_tools: Rc<QueryTools>,
         node_processor: Rc<dyn SqlNode>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError>;
 
     fn as_any(self: Rc<Self>) -> Rc<dyn Any>;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/time_shift.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/time_shift.rs
index f3b30dd7f1819..e0777823fe5be 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/time_shift.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/time_shift.rs
@@ -2,6 +2,7 @@ use super::SqlNode;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::any::Any;
 use std::collections::HashMap;
@@ -33,10 +34,15 @@ impl SqlNode for TimeShiftSqlNode {
         node: &Rc<MemberSymbol>,
         query_tools: Rc<QueryTools>,
         node_processor: Rc<dyn SqlNode>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
-        let input =
-            self.input
-                .to_sql(visitor, node, query_tools.clone(), node_processor.clone())?;
+        let input = self.input.to_sql(
+            visitor,
+            node,
+            query_tools.clone(),
+            node_processor.clone(),
+            templates,
+        )?;
         let res = match node.as_ref() {
             MemberSymbol::Dimension(ev) => {
                 if let Some(shift) = self.shifts.get(&ev.full_name()) {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/ungroupped_measure.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/ungroupped_measure.rs
index 1b2f9675a7492..0cad6b0ce0eca 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/ungroupped_measure.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/ungroupped_measure.rs
@@ -2,6 +2,7 @@ use super::SqlNode;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::any::Any;
 use std::rc::Rc;
@@ -27,6 +28,7 @@ impl SqlNode for UngroupedMeasureSqlNode {
         node: &Rc<MemberSymbol>,
         query_tools: Rc<QueryTools>,
         node_processor: Rc<dyn SqlNode>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
         let res = match node.as_ref() {
             MemberSymbol::Measure(_) => {
@@ -35,6 +37,7 @@ impl SqlNode for UngroupedMeasureSqlNode {
                     node,
                     query_tools.clone(),
                     node_processor.clone(),
+                    templates,
                 )?;
 
                 if input == "*" {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/ungroupped_query_final_measure.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/ungroupped_query_final_measure.rs
index c77afa191b65c..305e58a881c93 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/ungroupped_query_final_measure.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/ungroupped_query_final_measure.rs
@@ -2,6 +2,7 @@ use super::SqlNode;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::any::Any;
 use std::rc::Rc;
@@ -27,6 +28,7 @@ impl SqlNode for UngroupedQueryFinalMeasureSqlNode {
         node: &Rc<MemberSymbol>,
         query_tools: Rc<QueryTools>,
         node_processor: Rc<dyn SqlNode>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
         let res = match node.as_ref() {
             MemberSymbol::Measure(ev) => {
@@ -35,6 +37,7 @@ impl SqlNode for UngroupedQueryFinalMeasureSqlNode {
                     node,
                     query_tools.clone(),
                     node_processor.clone(),
+                    templates,
                 )?;
 
                 if input == "*" {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_visitor.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_visitor.rs
index 6a583bd86a135..2d9087c91c6e7 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_visitor.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_visitor.rs
@@ -1,6 +1,7 @@
 use super::sql_nodes::SqlNode;
 use super::MemberSymbol;
 use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
@@ -18,9 +19,15 @@ impl SqlEvaluatorVisitor {
         &self,
         node: &Rc<MemberSymbol>,
         node_processor: Rc<dyn SqlNode>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
-        let result =
-            node_processor.to_sql(self, node, self.query_tools.clone(), node_processor.clone())?;
+        let result = node_processor.to_sql(
+            self,
+            node,
+            self.query_tools.clone(),
+            node_processor.clone(),
+            templates,
+        )?;
         Ok(result)
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/cube_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/cube_symbol.rs
index 263d28e88c7b6..56d55ecd89bc6 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/cube_symbol.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/cube_symbol.rs
@@ -1,9 +1,10 @@
 use super::{MemberSymbol, SymbolFactory};
 use crate::cube_bridge::cube_definition::CubeDefinition;
 use crate::cube_bridge::evaluator::CubeEvaluator;
-use crate::cube_bridge::memeber_sql::MemberSql;
+use crate::cube_bridge::member_sql::MemberSql;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::{sql_nodes::SqlNode, Compiler, SqlCall, SqlEvaluatorVisitor};
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use lazy_static::lazy_static;
 use regex::Regex;
@@ -93,12 +94,15 @@ impl CubeTableSymbol {
         visitor: &SqlEvaluatorVisitor,
         node_processor: Rc<dyn SqlNode>,
         query_tools: Rc<QueryTools>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
         lazy_static! {
             static ref SIMPLE_ASTERIX_RE: Regex =
                 Regex::new(r#"(?i)^\s*select\s+\*\s+from\s+([a-zA-Z0-9_\-`".*]+)\s*$"#).unwrap();
         }
-        let sql = self.member_sql.eval(visitor, node_processor, query_tools)?;
+        let sql = self
+            .member_sql
+            .eval(visitor, node_processor, query_tools, templates)?;
         let res = if self.is_table_sql {
             sql
         } else {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs
index 14accc9505af6..93d6c7a9c1ab3 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs
@@ -1,16 +1,19 @@
 use super::{MemberSymbol, SymbolFactory};
 use crate::cube_bridge::dimension_definition::DimensionDefinition;
 use crate::cube_bridge::evaluator::CubeEvaluator;
-use crate::cube_bridge::memeber_sql::MemberSql;
+use crate::cube_bridge::member_sql::MemberSql;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::{sql_nodes::SqlNode, Compiler, SqlCall, SqlEvaluatorVisitor};
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
 pub struct DimensionSymbol {
     cube_name: String,
     name: String,
-    member_sql: Rc<SqlCall>,
+    member_sql: Option<Rc<SqlCall>>,
+    latitude: Option<Rc<SqlCall>>,
+    longitude: Option<Rc<SqlCall>>,
     #[allow(dead_code)]
     definition: Rc<dyn DimensionDefinition>,
 }
@@ -19,13 +22,17 @@ impl DimensionSymbol {
     pub fn new(
         cube_name: String,
         name: String,
-        member_sql: Rc<SqlCall>,
+        member_sql: Option<Rc<SqlCall>>,
+        latitude: Option<Rc<SqlCall>>,
+        longitude: Option<Rc<SqlCall>>,
         definition: Rc<dyn DimensionDefinition>,
     ) -> Self {
         Self {
             cube_name,
             name,
             member_sql,
+            latitude,
+            longitude,
             definition,
         }
     }
@@ -35,12 +42,28 @@ impl DimensionSymbol {
         visitor: &SqlEvaluatorVisitor,
         node_processor: Rc<dyn SqlNode>,
         query_tools: Rc<QueryTools>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
-        let sql = self.member_sql.eval(visitor, node_processor, query_tools)?;
-        Ok(sql)
+        if let Some(member_sql) = &self.member_sql {
+            let sql = member_sql.eval(visitor, node_processor, query_tools, templates)?;
+            Ok(sql)
+        } else {
+            Err(CubeError::internal(format!(
+                "Dimension {} hasn't sql evaluator",
+                self.full_name()
+            )))
+        }
+    }
+
+    pub fn latitude(&self) -> Option<Rc<SqlCall>> {
+        self.latitude.clone()
+    }
+
+    pub fn longitude(&self) -> Option<Rc<SqlCall>> {
+        self.longitude.clone()
     }
 
-    pub fn member_sql(&self) -> &Rc<SqlCall> {
+    pub fn member_sql(&self) -> &Option<Rc<SqlCall>> {
         &self.member_sql
     }
 
@@ -60,15 +83,23 @@ impl DimensionSymbol {
         self.definition.static_data().sub_query.unwrap_or(false)
     }
 
+    pub fn dimension_type(&self) -> &String {
+        &self.definition.static_data().dimension_type
+    }
+
     pub fn get_dependencies(&self) -> Vec<Rc<MemberSymbol>> {
         let mut deps = vec![];
-        self.member_sql.extract_symbol_deps(&mut deps);
+        if let Some(member_sql) = &self.member_sql {
+            member_sql.extract_symbol_deps(&mut deps);
+        }
         deps
     }
 
     pub fn get_dependent_cubes(&self) -> Vec<String> {
         let mut cubes = vec![];
-        self.member_sql.extract_cube_deps(&mut cubes);
+        if let Some(member_sql) = &self.member_sql {
+            member_sql.extract_cube_deps(&mut cubes);
+        }
         cubes
     }
 
@@ -88,7 +119,7 @@ impl DimensionSymbol {
 pub struct DimensionSymbolFactory {
     cube_name: String,
     name: String,
-    sql: Rc<dyn MemberSql>,
+    sql: Option<Rc<dyn MemberSql>>,
     definition: Rc<dyn DimensionDefinition>,
 }
 
@@ -122,11 +153,15 @@ impl SymbolFactory for DimensionSymbolFactory {
     }
 
     fn deps_names(&self) -> Result<Vec<String>, CubeError> {
-        Ok(self.definition.sql()?.args_names().clone())
+        if let Some(member_sql) = &self.sql {
+            Ok(member_sql.args_names().clone())
+        } else {
+            Ok(vec![])
+        }
     }
 
     fn member_sql(&self) -> Option<Rc<dyn MemberSql>> {
-        Some(self.sql.clone())
+        self.sql.clone()
     }
 
     fn build(self, compiler: &mut Compiler) -> Result<Rc<MemberSymbol>, CubeError> {
@@ -136,9 +171,29 @@ impl SymbolFactory for DimensionSymbolFactory {
             sql,
             definition,
         } = self;
-        let sql = compiler.compile_sql_call(&cube_name, sql)?;
+        let sql = if let Some(sql) = sql {
+            Some(compiler.compile_sql_call(&cube_name, sql)?)
+        } else {
+            None
+        };
+        let (latitude, longitude) = if definition.static_data().dimension_type == "geo" {
+            if let (Some(latitude_item), Some(longitude_item)) =
+                (definition.latitude()?, definition.longitude()?)
+            {
+                let latitude = compiler.compile_sql_call(&cube_name, latitude_item.sql()?)?;
+                let longitude = compiler.compile_sql_call(&cube_name, longitude_item.sql()?)?;
+                (Some(latitude), Some(longitude))
+            } else {
+                return Err(CubeError::user(format!(
+                    "Geo dimension '{}.{}'must have latitude and longitude",
+                    cube_name, name
+                )));
+            }
+        } else {
+            (None, None)
+        };
         Ok(MemberSymbol::new_dimension(DimensionSymbol::new(
-            cube_name, name, sql, definition,
+            cube_name, name, sql, latitude, longitude, definition,
         )))
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs
index 7ef7024e700c6..45168d23749a6 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs
@@ -3,9 +3,10 @@ use crate::cube_bridge::evaluator::CubeEvaluator;
 use crate::cube_bridge::measure_definition::{
     MeasureDefinition, RollingWindow, TimeShiftReference,
 };
-use crate::cube_bridge::memeber_sql::MemberSql;
+use crate::cube_bridge::member_sql::{CustomMemberSql, MemberSql};
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::{sql_nodes::SqlNode, Compiler, SqlCall, SqlEvaluatorVisitor};
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
@@ -38,8 +39,10 @@ pub struct MeasureSymbol {
     name: String,
     definition: Rc<dyn MeasureDefinition>,
     measure_filters: Vec<Rc<SqlCall>>,
+    measure_drill_filters: Vec<Rc<SqlCall>>,
     measure_order_by: Vec<MeasureOrderBy>,
-    member_sql: Rc<SqlCall>,
+    member_sql: Option<Rc<SqlCall>>,
+    pk_sqls: Vec<Rc<SqlCall>>,
     is_splitted_source: bool,
 }
 
@@ -47,17 +50,21 @@ impl MeasureSymbol {
     pub fn new(
         cube_name: String,
         name: String,
-        member_sql: Rc<SqlCall>,
+        member_sql: Option<Rc<SqlCall>>,
+        pk_sqls: Vec<Rc<SqlCall>>,
         definition: Rc<dyn MeasureDefinition>,
         measure_filters: Vec<Rc<SqlCall>>,
+        measure_drill_filters: Vec<Rc<SqlCall>>,
         measure_order_by: Vec<MeasureOrderBy>,
     ) -> Self {
         Self {
             cube_name,
             name,
             member_sql,
+            pk_sqls,
             definition,
             measure_filters,
+            measure_drill_filters,
             measure_order_by,
             is_splitted_source: false,
         }
@@ -71,18 +78,8 @@ impl MeasureSymbol {
         self.is_splitted_source
     }
 
-    pub fn split_with_source(&self, source_name: String) -> (Self, Self) {
-        let mut measure_with_source = self.clone();
-        measure_with_source.is_splitted_source = true;
-        let source = Self::new(
-            self.cube_name.clone(),
-            source_name.clone(),
-            self.member_sql.clone(),
-            self.definition().clone(),
-            self.measure_filters.clone(),
-            self.measure_order_by.clone(),
-        );
-        (measure_with_source, source)
+    pub fn pk_sqls(&self) -> &Vec<Rc<SqlCall>> {
+        &self.pk_sqls
     }
 
     pub fn is_calculated(&self) -> bool {
@@ -97,17 +94,37 @@ impl MeasureSymbol {
         visitor: &SqlEvaluatorVisitor,
         node_processor: Rc<dyn SqlNode>,
         query_tools: Rc<QueryTools>,
+        templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
-        let sql = self.member_sql.eval(visitor, node_processor, query_tools)?;
-        Ok(sql)
+        if let Some(member_sql) = &self.member_sql {
+            let sql = member_sql.eval(visitor, node_processor, query_tools, templates)?;
+            Ok(sql)
+        } else {
+            Err(CubeError::internal(format!(
+                "Measure {} hasn't sql evaluator",
+                self.full_name()
+            )))
+        }
+    }
+
+    pub fn has_sql(&self) -> bool {
+        self.member_sql.is_some()
     }
 
     pub fn get_dependencies(&self) -> Vec<Rc<MemberSymbol>> {
         let mut deps = vec![];
-        self.member_sql.extract_symbol_deps(&mut deps);
+        if let Some(member_sql) = &self.member_sql {
+            member_sql.extract_symbol_deps(&mut deps);
+        }
+        for pk in self.pk_sqls.iter() {
+            pk.extract_symbol_deps(&mut deps);
+        }
         for filter in self.measure_filters.iter() {
             filter.extract_symbol_deps(&mut deps);
         }
+        for filter in self.measure_drill_filters.iter() {
+            filter.extract_symbol_deps(&mut deps);
+        }
         for order in self.measure_order_by.iter() {
             order.sql_call().extract_symbol_deps(&mut deps);
         }
@@ -116,10 +133,18 @@ impl MeasureSymbol {
 
     pub fn get_dependent_cubes(&self) -> Vec<String> {
         let mut cubes = vec![];
-        self.member_sql.extract_cube_deps(&mut cubes);
+        if let Some(member_sql) = &self.member_sql {
+            member_sql.extract_cube_deps(&mut cubes);
+        }
+        for pk in self.pk_sqls.iter() {
+            pk.extract_cube_deps(&mut cubes);
+        }
         for filter in self.measure_filters.iter() {
             filter.extract_cube_deps(&mut cubes);
         }
+        for filter in self.measure_drill_filters.iter() {
+            filter.extract_cube_deps(&mut cubes);
+        }
         for order in self.measure_order_by.iter() {
             order.sql_call().extract_cube_deps(&mut cubes);
         }
@@ -157,6 +182,10 @@ impl MeasureSymbol {
         &self.measure_filters
     }
 
+    pub fn measure_drill_filters(&self) -> &Vec<Rc<SqlCall>> {
+        &self.measure_drill_filters
+    }
+
     pub fn measure_order_by(&self) -> &Vec<MeasureOrderBy> {
         &self.measure_order_by
     }
@@ -184,8 +213,9 @@ impl MeasureSymbol {
 pub struct MeasureSymbolFactory {
     cube_name: String,
     name: String,
-    sql: Rc<dyn MemberSql>,
+    sql: Option<Rc<dyn MemberSql>>,
     definition: Rc<dyn MeasureDefinition>,
+    cube_evaluator: Rc<dyn CubeEvaluator>,
 }
 
 impl MeasureSymbolFactory {
@@ -199,24 +229,13 @@ impl MeasureSymbolFactory {
         let cube_name = iter.next().unwrap();
         let name = iter.next().unwrap();
         let definition = cube_evaluator.measure_by_path(full_name.clone())?;
-        let sql = if let Some(sql) = definition.sql()? {
-            sql
-        } else {
-            let primary_keys = cube_evaluator
-                .static_data()
-                .primary_keys
-                .get(&cube_name)
-                .unwrap();
-            let primary_key = primary_keys.first().unwrap();
-            let key_dimension =
-                cube_evaluator.dimension_by_path(format!("{}.{}", cube_name, primary_key))?;
-            key_dimension.sql()?
-        };
+        let sql = definition.sql()?;
         Ok(Self {
             cube_name,
             name,
             sql,
             definition,
+            cube_evaluator,
         })
     }
 }
@@ -230,11 +249,11 @@ impl SymbolFactory for MeasureSymbolFactory {
     }
 
     fn member_sql(&self) -> Option<Rc<dyn MemberSql>> {
-        Some(self.sql.clone())
+        self.sql.clone()
     }
 
     fn deps_names(&self) -> Result<Vec<String>, CubeError> {
-        if let Some(member_sql) = self.definition.sql()? {
+        if let Some(member_sql) = &self.sql {
             Ok(member_sql.args_names().clone())
         } else {
             Ok(vec![])
@@ -247,7 +266,34 @@ impl SymbolFactory for MeasureSymbolFactory {
             name,
             sql,
             definition,
+            cube_evaluator,
         } = self;
+        let pk_sqls = if sql.is_none() {
+            cube_evaluator
+                .static_data()
+                .primary_keys
+                .get(&cube_name)
+                .cloned()
+                .unwrap_or_else(|| vec![])
+                .into_iter()
+                .map(|primary_key| -> Result<_, CubeError> {
+                    let key_dimension_name = format!("{}.{}", cube_name, primary_key);
+                    let key_dimension =
+                        cube_evaluator.dimension_by_path(key_dimension_name.clone())?;
+                    let key_dimension_sql = if let Some(key_dimension_sql) = key_dimension.sql()? {
+                        Ok(key_dimension_sql)
+                    } else {
+                        Err(CubeError::internal(format!(
+                            "Key dimension {} hasn't sql evaluator",
+                            key_dimension_name
+                        )))
+                    }?;
+                    compiler.compile_sql_call(&cube_name, key_dimension_sql)
+                })
+                .collect::<Result<Vec<_>, _>>()?
+        } else {
+            vec![]
+        };
         let mut measure_filters = vec![];
         if let Some(filters) = definition.filters()? {
             for filter in filters.items().iter() {
@@ -256,6 +302,14 @@ impl SymbolFactory for MeasureSymbolFactory {
             }
         }
 
+        let mut measure_drill_filters = vec![];
+        if let Some(filters) = definition.drill_filters()? {
+            for filter in filters.items().iter() {
+                let node = compiler.compile_sql_call(&cube_name, filter.sql()?)?;
+                measure_drill_filters.push(node);
+            }
+        }
+
         let mut measure_order_by = vec![];
         if let Some(group_by) = definition.order_by()? {
             for item in group_by.items().iter() {
@@ -263,14 +317,20 @@ impl SymbolFactory for MeasureSymbolFactory {
                 measure_order_by.push(MeasureOrderBy::new(node, item.dir()?));
             }
         }
-        let sql = compiler.compile_sql_call(&cube_name, sql)?;
+        let sql = if let Some(sql) = sql {
+            Some(compiler.compile_sql_call(&cube_name, sql)?)
+        } else {
+            None
+        };
 
         Ok(MemberSymbol::new_measure(MeasureSymbol::new(
             cube_name,
             name,
             sql,
+            pk_sqls,
             definition,
             measure_filters,
+            measure_drill_filters,
             measure_order_by,
         )))
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/symbol_factory.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/symbol_factory.rs
index c0e681412ccfb..53e0e6e665dcc 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/symbol_factory.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/symbol_factory.rs
@@ -1,5 +1,5 @@
 use super::MemberSymbol;
-use crate::cube_bridge::memeber_sql::MemberSql;
+use crate::cube_bridge::member_sql::MemberSql;
 use crate::planner::sql_evaluator::Compiler;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/filter.rs
index 6ee5d9a3f66d6..7b12a74ef25ca 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/filter.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/filter.rs
@@ -152,6 +152,10 @@ impl FilterTemplates {
         )
     }
 
+    pub fn always_true(&self) -> Result<String, CubeError> {
+        Ok(self.render.get_template("filters/always_true")?.clone())
+    }
+
     pub fn gte(&self, column: String, param: String) -> Result<String, CubeError> {
         self.render.render_template(
             &"filters/gte",
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/plan.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/plan.rs
index f93a915533c4d..e83ee51d5525c 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/plan.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/plan.rs
@@ -105,6 +105,43 @@ impl PlanSqlTemplates {
         )
     }
 
+    pub fn cast(&self, expr: &str, data_type: &str) -> Result<String, CubeError> {
+        self.render.render_template(
+            "expressions/cast",
+            context! {
+                expr => expr,
+                data_type => data_type,
+            },
+        )
+    }
+
+    pub fn cast_to_string(&self, expr: &str) -> Result<String, CubeError> {
+        self.render.render_template(
+            "expressions/cast_to_string",
+            context! {
+                expr => expr,
+            },
+        )
+    }
+
+    pub fn count_distinct(&self, expr: &str) -> Result<String, CubeError> {
+        self.render.render_template(
+            "functions/COUNT_DISTINCT",
+            context! {
+                args_concat => expr,
+            },
+        )
+    }
+
+    pub fn concat_strings(&self, strings: &Vec<String>) -> Result<String, CubeError> {
+        self.render.render_template(
+            "expressions/concat_strings",
+            context! {
+                strings => strings,
+            },
+        )
+    }
+
     pub fn group_by(&self, items: Vec<TemplateGroupByColumn>) -> Result<String, CubeError> {
         self.render.render_template(
             "statements/group_by_exprs",
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/visitor_context.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/visitor_context.rs
index 7e4cf9137d9f8..0eba5e2f4592a 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/visitor_context.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/visitor_context.rs
@@ -2,6 +2,7 @@ use super::query_tools::QueryTools;
 use super::sql_evaluator::sql_nodes::{SqlNode, SqlNodesFactory};
 use super::sql_evaluator::{MemberSymbol, SqlCall};
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
@@ -29,19 +30,21 @@ 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 node_processor = context.node_processor();
 
-    visitor.apply(node, 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 node_processor = context.node_processor();
-    sql_call.eval(&visitor, node_processor, query_tools)
+    sql_call.eval(&visitor, node_processor, query_tools, templates)
 }

From 3a8969c777832e2814c066dac56f3dae5b583b6c Mon Sep 17 00:00:00 2001
From: Alexandr Romanenko <alex.romanenko@cube.dev>
Date: Fri, 17 Jan 2025 17:46:06 +0100
Subject: [PATCH 05/16] update

---
 .../src/planner/sql_evaluator/sql_nodes/geo_dimension.rs        | 1 -
 .../src/planner/sql_evaluator/symbols/measure_symbol.rs         | 2 +-
 2 files changed, 1 insertion(+), 2 deletions(-)

diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/geo_dimension.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/geo_dimension.rs
index f74832b81ac50..d6691f59d3942 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/geo_dimension.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/geo_dimension.rs
@@ -5,7 +5,6 @@ use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
 use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::any::Any;
-use std::collections::HashMap;
 use std::rc::Rc;
 
 pub struct GeoDimensionSqlNode {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs
index 45168d23749a6..15971ffebdef1 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs
@@ -3,7 +3,7 @@ use crate::cube_bridge::evaluator::CubeEvaluator;
 use crate::cube_bridge::measure_definition::{
     MeasureDefinition, RollingWindow, TimeShiftReference,
 };
-use crate::cube_bridge::member_sql::{CustomMemberSql, MemberSql};
+use crate::cube_bridge::member_sql::MemberSql;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::{sql_nodes::SqlNode, Compiler, SqlCall, SqlEvaluatorVisitor};
 use crate::planner::sql_templates::PlanSqlTemplates;

From 9b5480008dd31a0ffcd4fbd200cd6cb53f79ac02 Mon Sep 17 00:00:00 2001
From: Alexandr Romanenko <alex.romanenko@cube.dev>
Date: Mon, 20 Jan 2025 15:49:03 +0100
Subject: [PATCH 06/16] update

---
 .../src/cube_bridge/measure_definition.rs     |   3 +
 .../cubesqlplanner/src/plan/join.rs           |  77 ++++++++++++-
 .../cubesqlplanner/src/plan/mod.rs            |   2 +-
 .../cubesqlplanner/src/planner/base_member.rs |   4 +
 .../cubesqlplanner/src/planner/base_query.rs  |   2 +-
 .../src/planner/filter/base_filter.rs         |  82 ++++++++++----
 .../src/planner/filter/filter_operator.rs     |   3 +-
 .../planners/dimension_subquery_planner.rs    |   2 +-
 .../planners/multi_stage/applied_state.rs     |  42 ++++---
 .../planner/planners/multi_stage/member.rs    |  65 +++++++++--
 .../multi_stage/member_query_planner.rs       |  97 ++++++++--------
 .../planners/multi_stage_query_planner.rs     | 107 +++++++++++++-----
 .../multiplied_measures_query_planner.rs      |  21 +++-
 .../src/planner/planners/query_planner.rs     |  29 +++--
 .../src/planner/query_properties.rs           |   8 +-
 15 files changed, 400 insertions(+), 144 deletions(-)

diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs
index 8172b846ffe74..e147ec65bea03 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs
@@ -26,6 +26,9 @@ pub struct RollingWindow {
     pub trailing: Option<String>,
     pub leading: Option<String>,
     pub offset: Option<String>,
+    #[serde(rename = "type")]
+    pub rolling_type: Option<String>,
+    pub granularity: Option<String>,
 }
 
 #[derive(Serialize, Deserialize, Debug)]
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs
index a7b24d17b1dba..818cbfed95865 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs
@@ -1,4 +1,5 @@
 use super::{Expr, SingleAliasedSource};
+use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::{BaseJoinCondition, VisitorContext};
 use cubenativeutils::CubeError;
@@ -6,7 +7,7 @@ use lazy_static::lazy_static;
 
 use std::rc::Rc;
 
-pub struct RollingWindowJoinCondition {
+pub struct RegularRollingWindowJoinCondition {
     time_series_source: String,
     trailing_interval: Option<String>,
     leading_interval: Option<String>,
@@ -14,7 +15,7 @@ pub struct RollingWindowJoinCondition {
     time_dimension: Expr,
 }
 
-impl RollingWindowJoinCondition {
+impl RegularRollingWindowJoinCondition {
     pub fn new(
         time_series_source: String,
         trailing_interval: Option<String>,
@@ -87,6 +88,50 @@ impl RollingWindowJoinCondition {
     }
 }
 
+pub struct ToDateRollingWindowJoinCondition {
+    time_series_source: String,
+    granularity: String,
+    time_dimension: Expr,
+    query_tools: Rc<QueryTools>,
+}
+
+impl ToDateRollingWindowJoinCondition {
+    pub fn new(
+        time_series_source: String,
+        granularity: String,
+        time_dimension: Expr,
+        query_tools: Rc<QueryTools>,
+    ) -> Self {
+        Self {
+            time_series_source,
+            granularity,
+            time_dimension,
+            query_tools,
+        }
+    }
+
+    pub fn to_sql(
+        &self,
+        templates: &PlanSqlTemplates,
+        context: Rc<VisitorContext>,
+    ) -> Result<String, CubeError> {
+        let date_column = self.time_dimension.to_sql(templates, context)?;
+
+        //(dateFrom, dateTo, dateField, dimensionDateFrom, dimensionDateTo, isFromStartToEnd) => `${dateField} >= ${this.timeGroupedColumn(granularity, dateFrom)} AND ${dateField} <= ${dateTo}`
+
+        let date_from =
+            templates.column_reference(&Some(self.time_series_source.clone()), "date_to")?;
+        let date_to =
+            templates.column_reference(&Some(self.time_series_source.clone()), "date_from")?;
+        let grouped_from = self
+            .query_tools
+            .base_tools()
+            .time_grouped_column(self.granularity.clone(), date_from)?;
+        let result = format!("{date_column} >= {grouped_from} and {date_column} <= {date_to}");
+        Ok(result)
+    }
+}
+
 pub struct DimensionJoinCondition {
     // AND (... OR ...)
     conditions: Vec<Vec<(Expr, Expr)>>,
@@ -145,7 +190,8 @@ impl DimensionJoinCondition {
 pub enum JoinCondition {
     DimensionJoinCondition(DimensionJoinCondition),
     BaseJoinCondition(Rc<dyn BaseJoinCondition>),
-    RollingWindowJoinCondition(RollingWindowJoinCondition),
+    RegularRollingWindowJoinCondition(RegularRollingWindowJoinCondition),
+    ToDateRollingWindowJoinCondition(ToDateRollingWindowJoinCondition),
 }
 
 impl JoinCondition {
@@ -153,14 +199,14 @@ impl JoinCondition {
         Self::DimensionJoinCondition(DimensionJoinCondition::new(conditions, null_check))
     }
 
-    pub fn new_rolling_join(
+    pub fn new_regular_rolling_join(
         time_series_source: String,
         trailing_interval: Option<String>,
         leading_interval: Option<String>,
         offset: String,
         time_dimension: Expr,
     ) -> Self {
-        Self::RollingWindowJoinCondition(RollingWindowJoinCondition::new(
+        Self::RegularRollingWindowJoinCondition(RegularRollingWindowJoinCondition::new(
             time_series_source,
             trailing_interval,
             leading_interval,
@@ -169,6 +215,20 @@ impl JoinCondition {
         ))
     }
 
+    pub fn new_to_date_rolling_join(
+        time_series_source: String,
+        granularity: String,
+        time_dimension: Expr,
+        query_tools: Rc<QueryTools>,
+    ) -> Self {
+        Self::ToDateRollingWindowJoinCondition(ToDateRollingWindowJoinCondition::new(
+            time_series_source,
+            granularity,
+            time_dimension,
+            query_tools,
+        ))
+    }
+
     pub fn new_base_join(base: Rc<dyn BaseJoinCondition>) -> Self {
         Self::BaseJoinCondition(base)
     }
@@ -181,7 +241,12 @@ impl JoinCondition {
         match &self {
             JoinCondition::DimensionJoinCondition(cond) => cond.to_sql(templates, context),
             JoinCondition::BaseJoinCondition(cond) => cond.to_sql(context, templates),
-            JoinCondition::RollingWindowJoinCondition(cond) => cond.to_sql(templates, context),
+            JoinCondition::RegularRollingWindowJoinCondition(cond) => {
+                cond.to_sql(templates, context)
+            }
+            JoinCondition::ToDateRollingWindowJoinCondition(cond) => {
+                cond.to_sql(templates, context)
+            }
         }
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/mod.rs
index 3799935638bd2..2117bf42d5611 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/mod.rs
@@ -16,7 +16,7 @@ pub use cte::Cte;
 pub use expression::{Expr, MemberExpression};
 pub use filter::{Filter, FilterGroup, FilterItem};
 pub use from::{From, FromSource, SingleAliasedSource, SingleSource};
-pub use join::{Join, JoinCondition, JoinItem, RollingWindowJoinCondition};
+pub use join::{Join, JoinCondition, JoinItem, RegularRollingWindowJoinCondition};
 pub use order::OrderBy;
 pub use query_plan::QueryPlan;
 pub use schema::{QualifiedColumnName, Schema, SchemaColumn};
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
index 394b2a71f2994..47f24a93ba00c 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
@@ -44,6 +44,10 @@ impl BaseMemberHelper {
         members.iter().map(|m| m.alias_name()).collect_vec()
     }
 
+    pub fn extract_symbols_from_members(members: &Vec<Rc<dyn BaseMember>>) -> Vec<Rc<MemberSymbol>> {
+        members.iter().map(|m| m.member_evaluator()).collect_vec()
+    }
+
     pub fn default_alias(
         cube_name: &String,
         member_name: &String,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
index 1b1613e77d725..d9cc10ed41f40 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
@@ -41,7 +41,7 @@ impl<IT: InnerTypes> BaseQuery<IT> {
     pub fn build_sql_and_params(&self) -> Result<NativeObjectHandle<IT>, CubeError> {
         let templates = PlanSqlTemplates::new(self.query_tools.templates_render());
         let query_planner = QueryPlanner::new(self.request.clone(), self.query_tools.clone());
-        let plan = query_planner.build_sql()?;
+        let plan = query_planner.plan()?;
 
         let sql = plan.to_sql(&templates)?;
         let (result_sql, params) = self.query_tools.build_sql_and_params(&sql, true)?;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
index fa3ccfdcae26e..4b77c9eef4e96 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
@@ -114,7 +114,12 @@ impl BaseFilter {
                 FilterOperator::Equal => self.equals_where(&member_sql)?,
                 FilterOperator::NotEqual => self.not_equals_where(&member_sql)?,
                 FilterOperator::InDateRange => self.in_date_range(&member_sql)?,
-                FilterOperator::InDateRangeExtended => self.in_date_range_extended(&member_sql)?,
+                FilterOperator::RegularRollingWindowDateRange => {
+                    self.regular_rolling_window_date_range(&member_sql)?
+                }
+                FilterOperator::ToDateRollingWindowDateRange => {
+                    self.to_date_rolling_window_date_range(&member_sql)?
+                }
                 FilterOperator::In => self.in_where(&member_sql)?,
                 FilterOperator::NotIn => self.not_in_where(&member_sql)?,
                 FilterOperator::Set => self.set_where(&member_sql)?,
@@ -211,7 +216,7 @@ impl BaseFilter {
     }
 
     fn in_date_range(&self, member_sql: &str) -> Result<String, CubeError> {
-        let (from, to) = self.allocate_date_params()?;
+        let (from, to) = self.allocate_date_params(true)?;
         self.templates
             .time_range_filter(member_sql.to_string(), from, to)
     }
@@ -236,8 +241,9 @@ impl BaseFilter {
             Ok(date.to_string())
         }
     }
-    fn in_date_range_extended(&self, member_sql: &str) -> Result<String, CubeError> {
-        let (from, to) = self.allocate_date_params()?;
+
+    fn regular_rolling_window_date_range(&self, member_sql: &str) -> Result<String, CubeError> {
+        let (from, to) = self.allocate_date_params(false)?;
 
         let from = if self.values.len() >= 3 {
             self.extend_date_range_bound(from, &self.values[2], true)?
@@ -251,8 +257,37 @@ impl BaseFilter {
             to
         };
 
-        self.templates
-            .time_range_filter(member_sql.to_string(), from, to)
+        let date_field = self
+            .query_tools
+            .base_tools()
+            .convert_tz(member_sql.to_string())?;
+        self.templates.time_range_filter(date_field, from, to)
+    }
+
+    fn to_date_rolling_window_date_range(&self, member_sql: &str) -> Result<String, CubeError> {
+        let (from, to) = self.allocate_date_params(false)?;
+
+        let from = if self.values.len() >= 3 {
+            if let Some(granularity) = &self.values[2] {
+                self.query_tools
+                    .base_tools()
+                    .time_grouped_column(granularity.clone(), from)?
+            } else {
+                return Err(CubeError::user(format!(
+                    "Granularity required for to_date rolling window"
+                )));
+            }
+        } else {
+            return Err(CubeError::user(format!(
+                "Granularity required for to_date rolling window"
+            )));
+        };
+
+        let date_field = self
+            .query_tools
+            .base_tools()
+            .convert_tz(member_sql.to_string())?;
+        self.templates.time_range_filter(date_field, from, to)
     }
 
     fn in_where(&self, member_sql: &str) -> Result<String, CubeError> {
@@ -353,12 +388,16 @@ impl BaseFilter {
         ))
     }
 
-    fn allocate_date_params(&self) -> Result<(String, String), CubeError> {
+    fn allocate_date_params(&self, use_db_time_zone: bool) -> Result<(String, String), CubeError> {
         if self.values.len() >= 2 {
             let from = if let Some(from_str) = &self.values[0] {
-                self.query_tools
-                    .base_tools()
-                    .in_db_time_zone(self.format_from_date(&from_str)?)?
+                let from = self.format_from_date(&from_str)?;
+
+                if use_db_time_zone {
+                    self.query_tools.base_tools().in_db_time_zone(from)?
+                } else {
+                    from
+                }
             } else {
                 return Err(CubeError::user(format!(
                     "Arguments for date range is not valid"
@@ -366,9 +405,13 @@ impl BaseFilter {
             };
 
             let to = if let Some(to_str) = &self.values[1] {
-                self.query_tools
-                    .base_tools()
-                    .in_db_time_zone(self.format_to_date(&to_str)?)?
+                let to = self.format_to_date(&to_str)?;
+
+                if use_db_time_zone {
+                    self.query_tools.base_tools().in_db_time_zone(to)?
+                } else {
+                    to
+                }
             } else {
                 return Err(CubeError::user(format!(
                     "Arguments for date range is not valid"
@@ -411,11 +454,7 @@ impl BaseFilter {
                 "0".repeat(precision as usize)
             ));
         }
-        //FIXME chrono don't support parsing date without specified format
-        Err(CubeError::user(format!(
-            "Unsupported date format: {}",
-            date
-        )))
+        Ok(date.to_string())
     }
 
     fn format_to_date(&self, date: &str) -> Result<String, CubeError> {
@@ -447,11 +486,8 @@ impl BaseFilter {
                 "9".repeat(precision as usize)
             ));
         }
-        //FIXME chrono don't support parsing date without specified format
-        Err(CubeError::user(format!(
-            "Unsupported date format: {}",
-            date
-        )))
+
+        Ok(date.to_string())
     }
 
     fn allocate_param(&self, param: &str) -> String {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/filter_operator.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/filter_operator.rs
index e0865b76c0c44..99d946e462b98 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/filter_operator.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/filter_operator.rs
@@ -6,7 +6,8 @@ pub enum FilterOperator {
     Equal,
     NotEqual,
     InDateRange,
-    InDateRangeExtended,
+    RegularRollingWindowDateRange,
+    ToDateRollingWindowDateRange,
     In,
     NotIn,
     Set,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs
index 5b6fee5cdd235..7b08972b1c8c2 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs
@@ -125,7 +125,7 @@ impl DimensionSubqueryPlanner {
             false,
         )?;
         let query_planner = QueryPlanner::new(sub_query_properties, self.query_tools.clone());
-        let sub_query = query_planner.build_sql()?;
+        let sub_query = query_planner.plan()?;
         let sub_query_alias = format!("{cube_name}_{dim_name}_subquery");
 
         let conditions = primary_keys_dimensions
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/applied_state.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/applied_state.rs
index 7a4061c43f64d..a60b755293819 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/applied_state.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/applied_state.rs
@@ -160,26 +160,43 @@ impl MultiStageAppliedState {
         false
     }
 
-    pub fn expand_date_range_filter(
+    pub fn replace_regular_date_range_filter(
         &mut self,
         member_name: &String,
         left_interval: Option<String>,
         right_interval: Option<String>,
     ) {
-        self.time_dimensions_filters = self.expand_date_range_filter_impl(
+        let operator = FilterOperator::RegularRollingWindowDateRange;
+        let values = vec![left_interval.clone(), right_interval.clone()];
+        self.time_dimensions_filters = self.change_date_range_filter_impl(
             member_name,
             &self.time_dimensions_filters,
-            &left_interval,
-            &right_interval,
+            &operator,
+            &values,
         );
     }
 
-    fn expand_date_range_filter_impl(
+    pub fn replace_to_date_date_range_filter(
+        &mut self,
+        member_name: &String,
+        granularity: &String,
+    ) {
+        let operator = FilterOperator::ToDateRollingWindowDateRange;
+        let values = vec![Some(granularity.clone())];
+        self.time_dimensions_filters = self.change_date_range_filter_impl(
+            member_name,
+            &self.time_dimensions_filters,
+            &operator,
+            &values,
+        );
+    }
+
+    fn change_date_range_filter_impl(
         &self,
         member_name: &String,
         filters: &Vec<FilterItem>,
-        left_interval: &Option<String>,
-        right_interval: &Option<String>,
+        operator: &FilterOperator,
+        additional_values: &Vec<Option<String>>,
     ) -> Vec<FilterItem> {
         let mut result = Vec::new();
         for item in filters.iter() {
@@ -187,11 +204,11 @@ impl MultiStageAppliedState {
                 FilterItem::Group(group) => {
                     let new_group = FilterItem::Group(Rc::new(FilterGroup::new(
                         group.operator.clone(),
-                        self.expand_date_range_filter_impl(
+                        self.change_date_range_filter_impl(
                             member_name,
                             filters,
-                            left_interval,
-                            right_interval,
+                            operator,
+                            additional_values,
                         ),
                     )));
                     result.push(new_group);
@@ -201,9 +218,8 @@ impl MultiStageAppliedState {
                         && matches!(itm.filter_operator(), FilterOperator::InDateRange)
                     {
                         let mut values = itm.values().clone();
-                        values.push(left_interval.clone());
-                        values.push(right_interval.clone());
-                        itm.change_operator(FilterOperator::InDateRangeExtended, values)
+                        values.extend(additional_values.iter().cloned());
+                        itm.change_operator(operator.clone(), values)
                     } else {
                         itm.clone()
                     };
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member.rs
index e7e97dc849ff3..1801c2538e3d8 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member.rs
@@ -66,13 +66,55 @@ pub enum MultiStageLeafMemberType {
 }
 
 #[derive(Clone)]
-pub struct RollingWindowDescription {
-    pub time_dimension: Rc<dyn BaseMember>,
+pub struct RegularRollingWindow {
     pub trailing: Option<String>,
     pub leading: Option<String>,
     pub offset: String,
 }
 
+#[derive(Clone)]
+pub struct ToDateRollingWindow {
+    pub granularity: String,
+}
+
+#[derive(Clone)]
+pub enum RollingWindowType {
+    Regular(RegularRollingWindow),
+    ToDate(ToDateRollingWindow),
+}
+
+#[derive(Clone)]
+pub struct RollingWindowDescription {
+    pub time_dimension: Rc<dyn BaseMember>,
+    pub rolling_window: RollingWindowType,
+}
+
+impl RollingWindowDescription {
+    pub fn new_regular(
+        time_dimension: Rc<dyn BaseMember>,
+        trailing: Option<String>,
+        leading: Option<String>,
+        offset: String,
+    ) -> Self {
+        let regular_window = RegularRollingWindow {
+            trailing,
+            leading,
+            offset,
+        };
+        Self {
+            time_dimension,
+            rolling_window: RollingWindowType::Regular(regular_window),
+        }
+    }
+
+    pub fn new_to_date(time_dimension: Rc<dyn BaseMember>, granularity: String) -> Self {
+        Self {
+            time_dimension,
+            rolling_window: RollingWindowType::ToDate(ToDateRollingWindow { granularity }),
+        }
+    }
+}
+
 #[derive(Clone)]
 pub struct RunningTotalDescription {
     pub time_dimension: Rc<dyn BaseMember>,
@@ -94,7 +136,6 @@ pub struct MultiStageInodeMember {
     add_group_by: Vec<String>,
     group_by: Option<Vec<String>>,
     time_shifts: Vec<MultiStageTimeShift>,
-    is_ungrupped: bool,
 }
 
 impl MultiStageInodeMember {
@@ -104,7 +145,6 @@ impl MultiStageInodeMember {
         add_group_by: Vec<String>,
         group_by: Option<Vec<String>>,
         time_shifts: Vec<MultiStageTimeShift>,
-        is_ungrupped: bool,
     ) -> Self {
         Self {
             inode_type,
@@ -112,7 +152,6 @@ impl MultiStageInodeMember {
             add_group_by,
             group_by,
             time_shifts,
-            is_ungrupped,
         }
     }
 
@@ -135,10 +174,6 @@ impl MultiStageInodeMember {
     pub fn time_shifts(&self) -> &Vec<MultiStageTimeShift> {
         &self.time_shifts
     }
-
-    pub fn is_ungrupped(&self) -> bool {
-        self.is_ungrupped
-    }
 }
 
 #[derive(Clone)]
@@ -150,13 +185,19 @@ pub enum MultiStageMemberType {
 pub struct MultiStageMember {
     member_type: MultiStageMemberType,
     evaluation_node: Rc<MemberSymbol>,
+    is_ungrupped: bool,
 }
 
 impl MultiStageMember {
-    pub fn new(member_type: MultiStageMemberType, evaluation_node: Rc<MemberSymbol>) -> Rc<Self> {
+    pub fn new(
+        member_type: MultiStageMemberType,
+        evaluation_node: Rc<MemberSymbol>,
+        is_ungrupped: bool,
+    ) -> Rc<Self> {
         Rc::new(Self {
             member_type,
             evaluation_node,
+            is_ungrupped,
         })
     }
 
@@ -171,4 +212,8 @@ impl MultiStageMember {
     pub fn full_name(&self) -> String {
         self.evaluation_node.full_name()
     }
+
+    pub fn is_ungrupped(&self) -> bool {
+        self.is_ungrupped
+    }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs
index 06fee5c058ecb..b717371719ce0 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs
@@ -6,13 +6,10 @@ use crate::plan::{
     Cte, Expr, From, JoinBuilder, JoinCondition, MemberExpression, OrderBy, QualifiedColumnName,
     QueryPlan, Schema, SelectBuilder, TimeSeries,
 };
-use crate::planner::planners::{
-    FullKeyAggregateQueryPlanner, MultipliedMeasuresQueryPlanner, OrderPlanner, SimpleQueryPlanner,
-};
+use crate::planner::planners::{multi_stage::RollingWindowType, OrderPlanner, QueryPlanner};
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
 use crate::planner::sql_evaluator::ReferencesBuilder;
-use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::QueryProperties;
 use crate::planner::{BaseDimension, BaseMeasure, BaseMember, BaseMemberHelper, BaseTimeDimension};
 use cubenativeutils::CubeError;
@@ -105,16 +102,31 @@ impl MultiStageMemberQueryPlanner {
         let rolling_base_cte_schema = cte_schemas.get(input).unwrap().clone();
         let time_dimension_alias =
             rolling_base_cte_schema.resolve_member_alias(&rolling_window_desc.time_dimension);
-        let on = JoinCondition::new_rolling_join(
-            root_alias.clone(),
-            rolling_window_desc.trailing.clone(),
-            rolling_window_desc.leading.clone(),
-            rolling_window_desc.offset.clone(),
-            Expr::Reference(QualifiedColumnName::new(
-                Some(alias.clone()),
-                time_dimension_alias,
-            )),
-        );
+        let on = match &rolling_window_desc.rolling_window {
+            RollingWindowType::Regular(regular_rolling_window) => {
+                JoinCondition::new_regular_rolling_join(
+                    root_alias.clone(),
+                    regular_rolling_window.trailing.clone(),
+                    regular_rolling_window.leading.clone(),
+                    regular_rolling_window.offset.clone(),
+                    Expr::Reference(QualifiedColumnName::new(
+                        Some(alias.clone()),
+                        time_dimension_alias,
+                    )),
+                )
+            }
+            RollingWindowType::ToDate(to_date_rolling_window) => {
+                JoinCondition::new_to_date_rolling_join(
+                    root_alias.clone(),
+                    to_date_rolling_window.granularity.clone(),
+                    Expr::Reference(QualifiedColumnName::new(
+                        Some(alias.clone()),
+                        time_dimension_alias,
+                    )),
+                    self.query_tools.clone(),
+                )
+            }
+        };
         join_builder.left_join_table_reference(
             input.clone(),
             rolling_base_cte_schema.clone(),
@@ -124,14 +136,22 @@ impl MultiStageMemberQueryPlanner {
 
         let from = From::new_from_join(join_builder.build());
 
-        let group_by = dimensions
-            .iter()
-            .map(|dim| Expr::Member(MemberExpression::new(dim.clone())))
-            .collect_vec();
+        let group_by = if self.description.member().is_ungrupped() {
+            vec![]
+        } else {
+            dimensions
+                .iter()
+                .map(|dim| Expr::Member(MemberExpression::new(dim.clone())))
+                .collect_vec()
+        };
 
         let mut context_factory = SqlNodesFactory::new();
         context_factory.set_rolling_window(true);
 
+        if self.description.member().is_ungrupped() {
+            context_factory.set_ungrouped(true);
+        }
+
         let references_builder = ReferencesBuilder::new(from.clone());
         let mut render_references = HashMap::new();
         let mut select_builder = SelectBuilder::new(from.clone());
@@ -186,7 +206,7 @@ impl MultiStageMemberQueryPlanner {
             format!("{}_join", self.description.alias()),
         );
 
-        let group_by = if multi_stage_member.is_ungrupped() {
+        let group_by = if self.description.member().is_ungrupped() {
             vec![]
         } else {
             dimensions
@@ -195,7 +215,7 @@ impl MultiStageMemberQueryPlanner {
                 .collect_vec()
         };
 
-        let order_by = if multi_stage_member.is_ungrupped() {
+        let order_by = if self.description.member().is_ungrupped() {
             vec![]
         } else {
             self.query_order()?
@@ -243,6 +263,9 @@ impl MultiStageMemberQueryPlanner {
         select_builder.set_group_by(group_by);
         select_builder.set_order_by(order_by);
         context_factory.set_render_references(render_references);
+        if self.description.member().is_ungrupped() {
+            context_factory.set_ungrouped(true);
+        }
         let select = select_builder.build(context_factory);
 
         Ok(Rc::new(Cte::new_from_select(
@@ -356,43 +379,27 @@ impl MultiStageMemberQueryPlanner {
             None,
             None,
             true,
-            false,
+            self.description.member().is_ungrupped(),
         )?;
 
         let mut node_factory = SqlNodesFactory::new();
         node_factory.set_time_shifts(self.description.state().time_shifts().clone());
 
-        /* if cte_query_properties
+        if cte_query_properties
             .full_key_aggregate_measures()?
             .has_multi_stage_measures()
         {
             return Err(CubeError::internal(format!(
                 "Leaf multi stage query cannot contain multi stage member"
             )));
-        } */
+        }
 
-        let cte_select = if cte_query_properties.is_simple_query()? {
-            let planner = SimpleQueryPlanner::new(
-                self.query_tools.clone(),
-                cte_query_properties.clone(),
-                node_factory.clone(),
-            );
-            planner.plan()?
-        } else {
-            let multiplied_measures_query_planner = MultipliedMeasuresQueryPlanner::try_new(
-                self.query_tools.clone(),
-                cte_query_properties.clone(),
-                node_factory.clone(),
-            )?;
-            let full_key_aggregate_planner = FullKeyAggregateQueryPlanner::new(
-                cte_query_properties.clone(),
-                node_factory.clone(),
-                PlanSqlTemplates::new(self.query_tools.templates_render()),
-            );
-            let subqueries = multiplied_measures_query_planner.plan_queries()?;
-            let result = full_key_aggregate_planner.plan(subqueries, vec![])?;
-            result
-        };
+        let query_planner = QueryPlanner::new_with_context_factory(
+            cte_query_properties.clone(),
+            self.query_tools.clone(),
+            node_factory,
+        );
+        let cte_select = query_planner.plan()?;
         let result = Cte::new_from_select(cte_select, self.description.alias().clone());
         Ok(Rc::new(result))
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage_query_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage_query_planner.rs
index 1a2f2955d71b8..6404ca37b469d 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage_query_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage_query_planner.rs
@@ -106,7 +106,7 @@ impl MultiStageQueryPlanner {
     fn create_multi_stage_inode_member(
         &self,
         base_member: Rc<MemberSymbol>,
-    ) -> Result<MultiStageInodeMember, CubeError> {
+    ) -> Result<(MultiStageInodeMember, bool), CubeError> {
         let inode = if let Some(measure) =
             BaseMeasure::try_new(base_member.clone(), self.query_tools.clone())?
         {
@@ -129,24 +129,28 @@ impl MultiStageQueryPlanner {
             };
             let is_ungrupped = match &member_type {
                 MultiStageInodeMemberType::Rank | MultiStageInodeMemberType::Calculate => true,
-                _ => false,
+                _ => self.query_properties.ungrouped(),
             };
-            MultiStageInodeMember::new(
-                member_type,
-                measure.reduce_by().clone().unwrap_or_default(),
-                measure.add_group_by().clone().unwrap_or_default(),
-                measure.group_by().clone(),
-                time_shifts,
+            (
+                MultiStageInodeMember::new(
+                    member_type,
+                    measure.reduce_by().clone().unwrap_or_default(),
+                    measure.add_group_by().clone().unwrap_or_default(),
+                    measure.group_by().clone(),
+                    time_shifts,
+                ),
                 is_ungrupped,
             )
         } else {
-            MultiStageInodeMember::new(
-                MultiStageInodeMemberType::Calculate,
-                vec![],
-                vec![],
-                None,
-                vec![],
-                false,
+            (
+                MultiStageInodeMember::new(
+                    MultiStageInodeMemberType::Calculate,
+                    vec![],
+                    vec![],
+                    None,
+                    vec![],
+                ),
+                self.query_properties.ungrouped(),
             )
         };
         Ok(inode)
@@ -168,6 +172,7 @@ impl MultiStageQueryPlanner {
                             time_dimension.clone(),
                         )),
                         time_dimension.member_evaluator(),
+                        true,
                     ),
                     state.clone(),
                     vec![],
@@ -190,6 +195,7 @@ impl MultiStageQueryPlanner {
             MultiStageMember::new(
                 MultiStageMemberType::Leaf(MultiStageLeafMemberType::Measure),
                 member,
+                self.query_properties.ungrouped(),
             ),
             state,
             vec![],
@@ -199,6 +205,28 @@ impl MultiStageQueryPlanner {
         Ok(description)
     }
 
+    fn get_to_date_rolling_granularity(
+        &self,
+        rolling_window: &RollingWindow,
+    ) -> Result<Option<String>, CubeError> {
+        let is_to_date = rolling_window
+            .rolling_type
+            .as_ref()
+            .map_or(false, |tp| tp == "to_date");
+
+        if is_to_date {
+            if let Some(granularity) = &rolling_window.granularity {
+                Ok(Some(granularity.clone()))
+            } else {
+                Err(CubeError::user(format!(
+                    "Granularity required for to_date rolling window"
+                )))
+            }
+        } else {
+            Ok(None)
+        }
+    }
+
     fn make_rolling_base_state(
         &self,
         time_dimension: Rc<BaseTimeDimension>,
@@ -220,11 +248,15 @@ impl MultiStageQueryPlanner {
 
         new_state.change_time_dimension_granularity(&time_dimension_name, result_granularity);
 
-        new_state.expand_date_range_filter(
-            &time_dimension_name,
-            rolling_window.trailing.clone(),
-            rolling_window.leading.clone(),
-        );
+        if let Some(granularity) = self.get_to_date_rolling_granularity(rolling_window)? {
+            new_state.replace_to_date_date_range_filter(&time_dimension_name, &granularity);
+        } else {
+            new_state.replace_regular_date_range_filter(
+                &time_dimension_name,
+                rolling_window.trailing.clone(),
+                rolling_window.leading.clone(),
+            );
+        }
 
         Ok(Rc::new(new_state))
     }
@@ -244,6 +276,8 @@ impl MultiStageQueryPlanner {
                         trailing: Some("unbounded".to_string()),
                         leading: None,
                         offset: None,
+                        rolling_type: None,
+                        granularity: None,
                     }
                 };
                 let time_dimensions = self.query_properties.time_dimensions();
@@ -276,11 +310,17 @@ impl MultiStageQueryPlanner {
 
                 let alias = format!("cte_{}", descriptions.len());
 
-                let rolling_window_descr = RollingWindowDescription {
-                    time_dimension: time_dimension.clone(),
-                    trailing: rolling_window.trailing.clone(),
-                    leading: rolling_window.leading.clone(),
-                    offset: rolling_window.offset.clone().unwrap_or("end".to_string()),
+                let rolling_window_descr = if let Some(granularity) =
+                    self.get_to_date_rolling_granularity(&rolling_window)?
+                {
+                    RollingWindowDescription::new_to_date(time_dimension, granularity)
+                } else {
+                    RollingWindowDescription::new_regular(
+                        time_dimension,
+                        rolling_window.trailing.clone(),
+                        rolling_window.leading.clone(),
+                        rolling_window.offset.clone().unwrap_or("end".to_string()),
+                    )
                 };
 
                 let inode_member = MultiStageInodeMember::new(
@@ -289,11 +329,14 @@ impl MultiStageQueryPlanner {
                     vec![],
                     None,
                     vec![],
-                    false,
                 );
 
                 let description = MultiStageQueryDescription::new(
-                    MultiStageMember::new(MultiStageMemberType::Inode(inode_member), member),
+                    MultiStageMember::new(
+                        MultiStageMemberType::Inode(inode_member),
+                        member,
+                        self.query_properties.ungrouped(),
+                    ),
                     state.clone(),
                     input,
                     alias.clone(),
@@ -342,13 +385,15 @@ impl MultiStageQueryPlanner {
                 MultiStageMember::new(
                     MultiStageMemberType::Leaf(MultiStageLeafMemberType::Measure),
                     member.clone(),
+                    self.query_properties.ungrouped(),
                 ),
                 state.clone(),
                 vec![],
                 alias.clone(),
             )
         } else {
-            let multi_stage_member = self.create_multi_stage_inode_member(member.clone())?;
+            let (multi_stage_member, is_ungrupped) =
+                self.create_multi_stage_inode_member(member.clone())?;
 
             let dimensions_to_add = multi_stage_member
                 .add_group_by()
@@ -386,7 +431,11 @@ impl MultiStageQueryPlanner {
 
             let alias = format!("cte_{}", descriptions.len());
             MultiStageQueryDescription::new(
-                MultiStageMember::new(MultiStageMemberType::Inode(multi_stage_member), member),
+                MultiStageMember::new(
+                    MultiStageMemberType::Inode(multi_stage_member),
+                    member,
+                    is_ungrupped,
+                ),
                 state.clone(),
                 input,
                 alias.clone(),
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
index 65ad3d132466e..cce7bfa7c2aa1 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multiplied_measures_query_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multiplied_measures_query_planner.rs
@@ -361,8 +361,25 @@ impl MultipliedMeasuresQueryPlanner {
             .query_properties
             .dimensions_for_select_append(dimensions);
 
-        let subquery_dimensions =
-            collect_sub_query_dimensions_from_members(&dimensions, self.query_tools.clone())?;
+        let mut symbols_for_subquery_dimensions =
+            BaseMemberHelper::extract_symbols_from_members(&dimensions);
+        for item in self.query_properties.dimensions_filters() {
+            item.find_all_member_evaluators(&mut symbols_for_subquery_dimensions);
+        }
+
+        for item in self.query_properties.measures_filters() {
+            item.find_all_member_evaluators(&mut symbols_for_subquery_dimensions);
+        }
+
+        let symbols_for_subquery_dimensions = symbols_for_subquery_dimensions
+            .into_iter()
+            .unique_by(|m| m.full_name())
+            .collect_vec();
+
+        let subquery_dimensions = collect_sub_query_dimensions_from_symbols(
+            &symbols_for_subquery_dimensions,
+            self.query_tools.clone(),
+        )?;
 
         let dimension_subquery_planner = DimensionSubqueryPlanner::try_new(
             &subquery_dimensions,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/query_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/query_planner.rs
index 954a599181e2c..5780daf4e73bc 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/query_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/query_planner.rs
@@ -13,6 +13,7 @@ use std::rc::Rc;
 pub struct QueryPlanner {
     query_tools: Rc<QueryTools>,
     request: Rc<QueryProperties>,
+    context_factory: Option<SqlNodesFactory>,
 }
 
 impl QueryPlanner {
@@ -20,19 +21,33 @@ impl QueryPlanner {
         Self {
             request,
             query_tools,
+            context_factory: None,
         }
     }
 
-    pub fn build_sql(&self) -> Result<Rc<Select>, CubeError> {
+    pub fn new_with_context_factory(
+        request: Rc<QueryProperties>,
+        query_tools: Rc<QueryTools>,
+        context_factory: SqlNodesFactory,
+    ) -> Self {
+        Self {
+            request,
+            query_tools,
+            context_factory: Some(context_factory),
+        }
+    }
+
+    pub fn plan(&self) -> Result<Rc<Select>, CubeError> {
         let templates = PlanSqlTemplates::new(self.query_tools.templates_render());
-        self.build_sql_and_params_impl(templates)
+        self.build_sql_impl(templates)
     }
 
-    fn build_sql_and_params_impl(
-        &self,
-        templates: PlanSqlTemplates,
-    ) -> Result<Rc<Select>, CubeError> {
-        let mut nodes_factory = SqlNodesFactory::new();
+    fn build_sql_impl(&self, templates: PlanSqlTemplates) -> Result<Rc<Select>, CubeError> {
+        let mut nodes_factory = if let Some(context_factory) = &self.context_factory {
+            context_factory.clone()
+        } else {
+            SqlNodesFactory::new()
+        };
 
         if self.request.ungrouped() {
             nodes_factory.set_ungrouped(true)
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
index d6b07304ae690..02bcc14e09579 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
@@ -461,11 +461,9 @@ impl QueryProperties {
         }
     }
     pub fn all_member_symbols(&self, exclude_time_dimensions: bool) -> Vec<Rc<MemberSymbol>> {
-        let mut members = self
-            .all_members(exclude_time_dimensions)
-            .into_iter()
-            .map(|m| m.member_evaluator())
-            .collect_vec();
+        let mut members = BaseMemberHelper::extract_symbols_from_members(
+            &self.all_members(exclude_time_dimensions),
+        );
         for filter_item in self.dimensions_filters.iter() {
             filter_item.find_all_member_evaluators(&mut members);
         }

From fc7644a780b5488a543120b05395119f92fe182c Mon Sep 17 00:00:00 2001
From: Alexandr Romanenko <alex.romanenko@cube.dev>
Date: Wed, 22 Jan 2025 13:39:39 +0100
Subject: [PATCH 07/16] 11 tests left

---
 .../src/wrappers/serializer/serializer.rs     |   6 +-
 "rust/cubesqlplanner/\\"                      |  85 +++++++++++++
 .../src/cube_bridge/base_query_options.rs     |  13 +-
 .../src/cube_bridge/join_definition.rs        |   6 +-
 .../src/cube_bridge/join_graph.rs             |   6 +-
 .../src/cube_bridge/join_hints.rs             |   7 +
 .../src/cube_bridge/join_item.rs              |  40 ------
 .../src/cube_bridge/measure_definition.rs     |  14 +-
 .../src/cube_bridge/measure_filter.rs         |  40 ------
 .../src/cube_bridge/member_expression.rs      |  24 ++++
 .../src/cube_bridge/member_order_by.rs        |  40 ------
 .../cubesqlplanner/src/cube_bridge/mod.rs     |   3 +
 .../src/cube_bridge/options_member.rs         |  25 ++++
 .../src/planner/base_dimension.rs             |  55 ++++++--
 .../src/planner/base_measure.rs               |  26 ++--
 .../cubesqlplanner/src/planner/base_member.rs |   8 +-
 .../src/planner/base_time_dimension.rs        |   4 +
 .../planners/dimension_subquery_planner.rs    |   3 +-
 .../src/planner/planners/join_planner.rs      |   7 +-
 .../src/planner/query_properties.rs           |  36 +++++-
 .../cubesqlplanner/src/planner/query_tools.rs |  18 +--
 .../collectors/cube_names_collector.rs        |  42 +++---
 .../collectors/has_cumulative_members.rs      |   1 +
 .../collectors/has_multi_stage_members.rs     |   1 +
 .../collectors/join_hints_collector.rs        |  65 ++++++----
 .../collectors/member_childs_collector.rs     |   1 +
 .../multiplied_measures_collector.rs          |   2 +
 .../collectors/sub_query_dimensions.rs        |   3 +-
 .../src/planner/sql_evaluator/compiler.rs     |   3 +-
 .../src/planner/sql_evaluator/mod.rs          |   4 +-
 .../src/planner/sql_evaluator/sql_call.rs     |  41 ++++++
 .../sql_evaluator/sql_nodes/evaluate_sql.rs   |   2 +-
 .../sql_evaluator/symbols/cube_symbol.rs      |  71 ++++++-----
 .../sql_evaluator/symbols/dimension_symbol.rs |  20 +++
 .../sql_evaluator/symbols/measure_symbol.rs   |  26 +++-
 .../symbols/member_expression_symbol.rs       |  71 +++++++++++
 .../sql_evaluator/symbols/member_symbol.rs    |  27 ++--
 .../src/planner/sql_evaluator/symbols/mod.rs  |   2 +
 .../symbols/time_dimension_symbol.rs          |   4 +-
 .../src/planner/sql_evaluator/visitor.rs      |  16 ++-
 rust/cubesqlplanner/nativebridge/src/lib.rs   | 120 +++++++++++-------
 41 files changed, 666 insertions(+), 322 deletions(-)
 create mode 100644 "rust/cubesqlplanner/\\"
 create mode 100644 rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_hints.rs
 create mode 100644 rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_expression.rs
 create mode 100644 rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/options_member.rs
 create mode 100644 rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_expression_symbol.rs

diff --git a/rust/cubenativeutils/src/wrappers/serializer/serializer.rs b/rust/cubenativeutils/src/wrappers/serializer/serializer.rs
index 21463875cddd2..abbb81b4d86d9 100644
--- a/rust/cubenativeutils/src/wrappers/serializer/serializer.rs
+++ b/rust/cubenativeutils/src/wrappers/serializer/serializer.rs
@@ -185,14 +185,12 @@ impl<IT: InnerTypes> ser::Serializer for NativeSerdeSerializer<IT> {
         _name: &'static str,
         _variant_index: u32,
         _variant: &'static str,
-        _value: &T,
+        value: &T,
     ) -> Result<Self::Ok, Self::Error>
     where
         T: ?Sized + Serialize,
     {
-        Err(NativeObjSerializerError::Message(
-            "serialize_newtype_variant is not implemented".to_string(),
-        ))
+        NativeSerdeSerializer::serialize(value, self.context.clone())
     }
 
     fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
diff --git "a/rust/cubesqlplanner/\\" "b/rust/cubesqlplanner/\\"
new file mode 100644
index 0000000000000..f3a8f6ae1f3be
--- /dev/null
+++ "b/rust/cubesqlplanner/\\"
@@ -0,0 +1,85 @@
+use crate::cube_bridge::join_hints::JoinHintItem;
+use crate::planner::sql_evaluator::{MemberSymbol, TraversalVisitor};
+use crate::planner::BaseMeasure;
+use cubenativeutils::CubeError;
+use std::rc::Rc;
+
+pub struct JoinHintsCollector {
+    hints: Vec<JoinHintItem>,
+}
+
+impl JoinHintsCollector {
+    pub fn new() -> Self {
+        Self { hints: Vec::new() }
+    }
+
+    pub fn extract_result(self) -> Vec<JoinHintItem> {
+        self.hints
+    }
+}
+
+impl TraversalVisitor for JoinHintsCollector {
+    type State = ();
+    fn on_node_traverse(
+        &mut self,
+        node: &Rc<MemberSymbol>,
+        path: &Vec<String>,
+        _: &Self::State,
+    ) -> Result<Option<Self::State>, CubeError> {
+        match node.as_ref() {
+            MemberSymbol::Dimension(e) => {
+                if e.owned_by_cube() {
+                    if !path.is_empty() {
+                        if path.len() == 1 {
+                            self.hints.push(JoinHintItem::Single(path[0].clone()))
+                        } else {
+                            self.hints.push(JoinHintItem::Vector(path.clone()))
+                        }
+                    }
+                }
+                if e.is_sub_query() {
+                    return Ok(None);
+                }
+            }
+            MemberSymbol::TimeDimension(e) => return self.on_node_traverse(e.base_symbol(), path, &()),
+            MemberSymbol::Measure(e) => {
+                if e.owned_by_cube() {
+                    self.hints.push(JoinHintItem::Single(e.cube_name().clone()));
+                }
+                for name in e.get_dependent_cubes().into_iter() {
+                    self.hints.push(JoinHintItem::Single(name));
+                }
+            }
+            MemberSymbol::CubeName(e) => {
+                self.hints.push(JoinHintItem::Single(e.cube_name().clone()));
+            }
+            MemberSymbol::CubeTable(e) => {
+                self.hints.push(JoinHintItem::Single(e.cube_name().clone()));
+            }
+            MemberSymbol::SqlCall(s) => {
+                for name in s.get_dependent_cubes().into_iter() {
+                    self.hints.push(JoinHintItem::Single(name));
+                }
+            }
+        };
+        Ok(Some(()))
+    }
+}
+
+pub fn collect_join_hints(node: &Rc<MemberSymbol>) -> Result<Vec<JoinHintItem>, CubeError> {
+    let mut visitor = JoinHintsCollector::new();
+    visitor.apply(node, &())?;
+    let res = visitor.extract_result();
+    Ok(res)
+}
+
+pub fn collect_join_hints_for_measures(
+    measures: &Vec<Rc<BaseMeasure>>,
+) -> Result<Vec<JoinHintItem>, CubeError> {
+    let mut visitor = JoinHintsCollector::new();
+    for meas in measures.iter() {
+        visitor.apply(&meas.member_evaluator(), &())?;
+    }
+    let res = visitor.extract_result();
+    Ok(res)
+}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_query_options.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_query_options.rs
index 2e0571cfa0fb5..e5d75e4fab299 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_query_options.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_query_options.rs
@@ -1,11 +1,11 @@
 use super::join_graph::{JoinGraph, NativeJoinGraph};
+use super::options_member::OptionsMember;
 use crate::cube_bridge::base_tools::{BaseTools, NativeBaseTools};
 use crate::cube_bridge::evaluator::{CubeEvaluator, NativeCubeEvaluator};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
-use cubenativeutils::wrappers::NativeContextHolder;
-use cubenativeutils::wrappers::NativeObjectHandle;
+use cubenativeutils::wrappers::{NativeArray, NativeContextHolder, NativeObjectHandle};
 use cubenativeutils::CubeError;
 use serde::{Deserialize, Serialize};
 use std::any::Any;
@@ -50,7 +50,6 @@ impl FilterItem {
 #[derive(Serialize, Deserialize, Debug)]
 pub struct BaseQueryOptionsStatic {
     pub measures: Option<Vec<String>>,
-    pub dimensions: Option<Vec<String>>,
     #[serde(rename = "timeDimensions")]
     pub time_dimensions: Option<Vec<TimeDimension>>,
     pub timezone: Option<String>,
@@ -66,9 +65,13 @@ pub struct BaseQueryOptionsStatic {
 #[nativebridge::native_bridge(BaseQueryOptionsStatic)]
 pub trait BaseQueryOptions {
     #[field]
-    fn measures(&self) -> Result<Option<Vec<String>>, CubeError>;
+    #[optional]
+    #[vec]
+    fn measures(&self) -> Result<Option<Vec<OptionsMember>>, CubeError>;
     #[field]
-    fn dimensions(&self) -> Result<Option<Vec<String>>, CubeError>;
+    #[optional]
+    #[vec]
+    fn dimensions(&self) -> Result<Option<Vec<OptionsMember>>, CubeError>;
     #[field]
     fn cube_evaluator(&self) -> Result<Rc<dyn CubeEvaluator>, CubeError>;
     #[field]
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_definition.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_definition.rs
index c224661d2a67b..020b3dd6b8d3c 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_definition.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_definition.rs
@@ -1,7 +1,8 @@
-use super::join_item::{JoinItemsVec, NativeJoinItemsVec};
+use super::join_item::{JoinItem, NativeJoinItem};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
+use cubenativeutils::wrappers::NativeArray;
 use cubenativeutils::wrappers::NativeContextHolder;
 use cubenativeutils::wrappers::NativeObjectHandle;
 use cubenativeutils::CubeError;
@@ -20,5 +21,6 @@ pub struct JoinDefinitionStatic {
 #[nativebridge::native_bridge(JoinDefinitionStatic)]
 pub trait JoinDefinition {
     #[field]
-    fn joins(&self) -> Result<Rc<dyn JoinItemsVec>, CubeError>;
+    #[vec]
+    fn joins(&self) -> Result<Vec<Rc<dyn JoinItem>>, CubeError>;
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_graph.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_graph.rs
index bb8f1c1227e57..32b776061054d 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_graph.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_graph.rs
@@ -1,4 +1,5 @@
 use super::join_definition::{JoinDefinition, NativeJoinDefinition};
+use super::join_hints::JoinHintItem;
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
@@ -10,5 +11,8 @@ use std::rc::Rc;
 
 #[nativebridge::native_bridge]
 pub trait JoinGraph {
-    fn build_join(&self, cubes_to_join: Vec<String>) -> Result<Rc<dyn JoinDefinition>, CubeError>;
+    fn build_join(
+        &self,
+        cubes_to_join: Vec<JoinHintItem>,
+    ) -> Result<Rc<dyn JoinDefinition>, CubeError>;
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_hints.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_hints.rs
new file mode 100644
index 0000000000000..a3ef5d4044dfc
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_hints.rs
@@ -0,0 +1,7 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Clone, Eq, PartialEq, Hash, Serialize, Deserialize)]
+pub enum JoinHintItem {
+    Single(String),
+    Vector(Vec<String>),
+}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_item.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_item.rs
index f3130d0ec7f6f..c712cd3c0697c 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_item.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/join_item.rs
@@ -1,5 +1,4 @@
 use super::join_item_definition::{JoinItemDefinition, NativeJoinItemDefinition};
-use cubenativeutils::wrappers::object::NativeArray;
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
@@ -8,7 +7,6 @@ use cubenativeutils::wrappers::NativeObjectHandle;
 use cubenativeutils::CubeError;
 use serde::{Deserialize, Serialize};
 use std::any::Any;
-use std::marker::PhantomData;
 use std::rc::Rc;
 
 #[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq, Hash)]
@@ -26,41 +24,3 @@ pub trait JoinItem {
     #[field]
     fn join(&self) -> Result<Rc<dyn JoinItemDefinition>, CubeError>;
 }
-
-pub trait JoinItemsVec {
-    fn items(&self) -> &Vec<Rc<dyn JoinItem>>;
-}
-
-pub struct NativeJoinItemsVec<IT: InnerTypes> {
-    items: Vec<Rc<dyn JoinItem>>,
-    phantom: PhantomData<IT>,
-}
-
-impl<IT: InnerTypes> NativeJoinItemsVec<IT> {
-    pub fn try_new(native_items: NativeObjectHandle<IT>) -> Result<Self, CubeError> {
-        let items = native_items
-            .into_array()?
-            .to_vec()?
-            .into_iter()
-            .map(|v| -> Result<Rc<dyn JoinItem>, CubeError> {
-                Ok(Rc::new(NativeJoinItem::from_native(v)?))
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-        Ok(Self {
-            items,
-            phantom: PhantomData::default(),
-        })
-    }
-}
-
-impl<IT: InnerTypes> JoinItemsVec for NativeJoinItemsVec<IT> {
-    fn items(&self) -> &Vec<Rc<dyn JoinItem>> {
-        &self.items
-    }
-}
-
-impl<IT: InnerTypes> NativeDeserialize<IT> for NativeJoinItemsVec<IT> {
-    fn from_native(v: NativeObjectHandle<IT>) -> Result<Self, CubeError> {
-        Self::try_new(v)
-    }
-}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs
index e147ec65bea03..54329c773894e 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs
@@ -1,10 +1,11 @@
 use super::cube_definition::{CubeDefinition, NativeCubeDefinition};
-use super::measure_filter::{MeasureFiltersVec, NativeMeasureFiltersVec};
-use super::member_order_by::{MemberOrderByVec, NativeMemberOrderByVec};
+use super::measure_filter::{MeasureFilter, NativeMeasureFilter};
+use super::member_order_by::{MemberOrderBy, NativeMemberOrderBy};
 use super::member_sql::{MemberSql, NativeMemberSql};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
+use cubenativeutils::wrappers::NativeArray;
 use cubenativeutils::wrappers::NativeContextHolder;
 use cubenativeutils::wrappers::NativeObjectHandle;
 use cubenativeutils::CubeError;
@@ -61,13 +62,16 @@ pub trait MeasureDefinition {
 
     #[optional]
     #[field]
-    fn filters(&self) -> Result<Option<Rc<dyn MeasureFiltersVec>>, CubeError>;
+    #[vec]
+    fn filters(&self) -> Result<Option<Vec<Rc<dyn MeasureFilter>>>, CubeError>;
 
     #[optional]
     #[field]
-    fn drill_filters(&self) -> Result<Option<Rc<dyn MeasureFiltersVec>>, CubeError>;
+    #[vec]
+    fn drill_filters(&self) -> Result<Option<Vec<Rc<dyn MeasureFilter>>>, CubeError>;
 
     #[optional]
     #[field]
-    fn order_by(&self) -> Result<Option<Rc<dyn MemberOrderByVec>>, CubeError>;
+    #[vec]
+    fn order_by(&self) -> Result<Option<Vec<Rc<dyn MemberOrderBy>>>, CubeError>;
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_filter.rs
index d251630f9683b..500774e50b76f 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_filter.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_filter.rs
@@ -1,5 +1,4 @@
 use super::member_sql::{MemberSql, NativeMemberSql};
-use cubenativeutils::wrappers::object::NativeArray;
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
@@ -7,7 +6,6 @@ use cubenativeutils::wrappers::NativeContextHolder;
 use cubenativeutils::wrappers::NativeObjectHandle;
 use cubenativeutils::CubeError;
 use std::any::Any;
-use std::marker::PhantomData;
 use std::rc::Rc;
 
 #[nativebridge::native_bridge]
@@ -15,41 +13,3 @@ pub trait MeasureFilter {
     #[field]
     fn sql(&self) -> Result<Rc<dyn MemberSql>, CubeError>;
 }
-
-pub trait MeasureFiltersVec {
-    fn items(&self) -> &Vec<Rc<dyn MeasureFilter>>;
-}
-
-pub struct NativeMeasureFiltersVec<IT: InnerTypes> {
-    items: Vec<Rc<dyn MeasureFilter>>,
-    phantom: PhantomData<IT>,
-}
-
-impl<IT: InnerTypes> NativeMeasureFiltersVec<IT> {
-    pub fn try_new(native_items: NativeObjectHandle<IT>) -> Result<Self, CubeError> {
-        let items = native_items
-            .into_array()?
-            .to_vec()?
-            .into_iter()
-            .map(|v| -> Result<Rc<dyn MeasureFilter>, CubeError> {
-                Ok(Rc::new(NativeMeasureFilter::from_native(v)?))
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-        Ok(Self {
-            items,
-            phantom: PhantomData::default(),
-        })
-    }
-}
-
-impl<IT: InnerTypes> MeasureFiltersVec for NativeMeasureFiltersVec<IT> {
-    fn items(&self) -> &Vec<Rc<dyn MeasureFilter>> {
-        &self.items
-    }
-}
-
-impl<IT: InnerTypes> NativeDeserialize<IT> for NativeMeasureFiltersVec<IT> {
-    fn from_native(v: NativeObjectHandle<IT>) -> Result<Self, CubeError> {
-        Self::try_new(v)
-    }
-}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_expression.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_expression.rs
new file mode 100644
index 0000000000000..45d2a26ddeb90
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_expression.rs
@@ -0,0 +1,24 @@
+use super::member_sql::{MemberSql, NativeMemberSql};
+use cubenativeutils::wrappers::serializer::{
+    NativeDeserialize, NativeDeserializer, NativeSerialize,
+};
+use cubenativeutils::wrappers::{NativeContextHolder, NativeObjectHandle};
+use cubenativeutils::CubeError;
+use serde::{Deserialize, Serialize};
+use std::any::Any;
+use std::rc::Rc;
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+pub struct MemberExpressionDefinitionStatic {
+    #[serde(rename = "expressionName")]
+    pub expression_name: Option<String>,
+    #[serde(rename = "cubeName")]
+    pub cube_name: Option<String>,
+    pub definition: Option<String>,
+}
+
+#[nativebridge::native_bridge(MemberExpressionDefinitionStatic)]
+pub trait MemberExpressionDefinition {
+    #[field]
+    fn expression(&self) -> Result<Rc<dyn MemberSql>, CubeError>;
+}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_order_by.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_order_by.rs
index b5ddddbc84171..0f56aeafc41f7 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_order_by.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_order_by.rs
@@ -1,5 +1,4 @@
 use super::member_sql::{MemberSql, NativeMemberSql};
-use cubenativeutils::wrappers::object::NativeArray;
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
@@ -7,7 +6,6 @@ use cubenativeutils::wrappers::NativeContextHolder;
 use cubenativeutils::wrappers::NativeObjectHandle;
 use cubenativeutils::CubeError;
 use std::any::Any;
-use std::marker::PhantomData;
 use std::rc::Rc;
 
 #[nativebridge::native_bridge]
@@ -17,41 +15,3 @@ pub trait MemberOrderBy {
     #[field]
     fn dir(&self) -> Result<String, CubeError>;
 }
-
-pub trait MemberOrderByVec {
-    fn items(&self) -> &Vec<Rc<dyn MemberOrderBy>>;
-}
-
-pub struct NativeMemberOrderByVec<IT: InnerTypes> {
-    items: Vec<Rc<dyn MemberOrderBy>>,
-    phantom: PhantomData<IT>,
-}
-
-impl<IT: InnerTypes> NativeMemberOrderByVec<IT> {
-    pub fn try_new(native_items: NativeObjectHandle<IT>) -> Result<Self, CubeError> {
-        let items = native_items
-            .into_array()?
-            .to_vec()?
-            .into_iter()
-            .map(|v| -> Result<Rc<dyn MemberOrderBy>, CubeError> {
-                Ok(Rc::new(NativeMemberOrderBy::from_native(v)?))
-            })
-            .collect::<Result<Vec<_>, _>>()?;
-        Ok(Self {
-            items,
-            phantom: PhantomData::default(),
-        })
-    }
-}
-
-impl<IT: InnerTypes> MemberOrderByVec for NativeMemberOrderByVec<IT> {
-    fn items(&self) -> &Vec<Rc<dyn MemberOrderBy>> {
-        &self.items
-    }
-}
-
-impl<IT: InnerTypes> NativeDeserialize<IT> for NativeMemberOrderByVec<IT> {
-    fn from_native(v: NativeObjectHandle<IT>) -> Result<Self, CubeError> {
-        Self::try_new(v)
-    }
-}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs
index 762e6f8a0553d..46c0f15fe11c8 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs
@@ -8,12 +8,15 @@ pub mod filter_params;
 pub mod geo_item;
 pub mod join_definition;
 pub mod join_graph;
+pub mod join_hints;
 pub mod join_item;
 pub mod join_item_definition;
 pub mod measure_definition;
 pub mod measure_filter;
 pub mod member_definition;
+pub mod member_expression;
 pub mod member_order_by;
 pub mod member_sql;
+pub mod options_member;
 pub mod security_context;
 pub mod sql_templates_render;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/options_member.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/options_member.rs
new file mode 100644
index 0000000000000..11918839cd21c
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/options_member.rs
@@ -0,0 +1,25 @@
+use super::member_expression::{MemberExpressionDefinition, NativeMemberExpressionDefinition};
+use cubenativeutils::wrappers::inner_types::InnerTypes;
+use cubenativeutils::wrappers::serializer::NativeDeserialize;
+use cubenativeutils::wrappers::NativeObjectHandle;
+use cubenativeutils::CubeError;
+use std::rc::Rc;
+
+pub enum OptionsMember {
+    MemberName(String),
+    MemberExpression(Rc<dyn MemberExpressionDefinition>),
+}
+
+impl<IT: InnerTypes> NativeDeserialize<IT> for OptionsMember {
+    fn from_native(native_object: NativeObjectHandle<IT>) -> Result<Self, CubeError> {
+        match String::from_native(native_object.clone()) {
+            Ok(name) => Ok(Self::MemberName(name)),
+            Err(_) => match NativeMemberExpressionDefinition::from_native(native_object) {
+                Ok(expr) => Ok(Self::MemberExpression(Rc::new(expr))),
+                Err(_) => Err(CubeError::user(format!(
+                    "Member name or member expression map expected"
+                ))),
+            },
+        }
+    }
+}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs
index 1f95df17bfcac..87bb6740aa00d 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs
@@ -1,5 +1,5 @@
 use super::query_tools::QueryTools;
-use super::sql_evaluator::{MemberSymbol, SqlCall};
+use super::sql_evaluator::{MemberExpressionSymbol, MemberSymbol, SqlCall};
 use super::{evaluate_with_context, BaseMember, BaseMemberHelper, VisitorContext};
 use crate::cube_bridge::dimension_definition::DimensionDefinition;
 use crate::planner::sql_templates::PlanSqlTemplates;
@@ -10,7 +10,9 @@ pub struct BaseDimension {
     dimension: String,
     query_tools: Rc<QueryTools>,
     member_evaluator: Rc<MemberSymbol>,
-    definition: Rc<dyn DimensionDefinition>,
+    definition: Option<Rc<dyn DimensionDefinition>>,
+    #[allow(dead_code)]
+    member_expression_definition: Option<String>,
     cube_name: String,
     name: String,
     default_alias: String,
@@ -30,6 +32,10 @@ impl BaseMember for BaseDimension {
         )
     }
 
+    fn full_name(&self) -> String {
+        self.member_evaluator.full_name()
+    }
+
     fn alias_name(&self) -> String {
         self.default_alias.clone()
     }
@@ -70,7 +76,8 @@ impl BaseDimension {
                     member_evaluator: evaluation_node.clone(),
                     cube_name: s.cube_name().clone(),
                     name: s.name().clone(),
-                    definition: s.definition().clone(),
+                    definition: Some(s.definition().clone()),
+                    member_expression_definition: None,
                     default_alias,
                 }))
             }
@@ -92,6 +99,35 @@ impl BaseDimension {
         }
     }
 
+    pub fn try_new_from_expression(
+        expression: Rc<SqlCall>,
+        cube_name: String,
+        name: String,
+        member_expression_definition: Option<String>,
+        query_tools: Rc<QueryTools>,
+    ) -> Result<Rc<Self>, CubeError> {
+        let member_expression_symbol = MemberExpressionSymbol::new(
+            cube_name.clone(),
+            name.clone(),
+            expression,
+            member_expression_definition.clone(),
+        );
+        let full_name = member_expression_symbol.full_name();
+        let member_evaluator = Rc::new(MemberSymbol::MemberExpression(member_expression_symbol));
+        let default_alias = PlanSqlTemplates::alias_name(&name);
+
+        Ok(Rc::new(Self {
+            dimension: full_name,
+            query_tools,
+            member_evaluator,
+            definition: None,
+            cube_name,
+            name,
+            member_expression_definition,
+            default_alias,
+        }))
+    }
+
     pub fn member_evaluator(&self) -> Rc<MemberSymbol> {
         self.member_evaluator.clone()
     }
@@ -119,13 +155,16 @@ impl BaseDimension {
     }
 
     pub fn is_sub_query(&self) -> bool {
-        self.definition.static_data().sub_query.unwrap_or(false)
+        self.definition
+            .as_ref()
+            .map_or(false, |def| def.static_data().sub_query.unwrap_or(false))
     }
 
     pub fn propagate_filters_to_sub_query(&self) -> bool {
-        self.definition
-            .static_data()
-            .propagate_filters_to_sub_query
-            .unwrap_or(false)
+        self.definition.as_ref().map_or(false, |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
index d45c23f97a8b0..05bd9310d765b 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
@@ -1,5 +1,5 @@
 use super::query_tools::QueryTools;
-use super::sql_evaluator::{MemberSymbol, SqlCall};
+use super::sql_evaluator::{MemberExpressionSymbol, MemberSymbol, SqlCall};
 use super::{evaluate_with_context, BaseMember, BaseMemberHelper, VisitorContext};
 use crate::cube_bridge::measure_definition::{
     MeasureDefinition, RollingWindow, TimeShiftReference,
@@ -68,6 +68,8 @@ pub struct BaseMeasure {
     query_tools: Rc<QueryTools>,
     member_evaluator: Rc<MemberSymbol>,
     definition: Option<Rc<dyn MeasureDefinition>>,
+    #[allow(dead_code)]
+    member_expression_definition: Option<String>,
     time_shifts: Vec<MeasureTimeShift>,
     cube_name: String,
     name: String,
@@ -142,6 +144,7 @@ impl BaseMeasure {
                     query_tools: query_tools.clone(),
                     member_evaluator: evaluation_node.clone(),
                     definition: Some(s.definition().clone()),
+                    member_expression_definition: None,
                     cube_name: s.cube_name().clone(),
                     name: s.name().clone(),
                     time_shifts,
@@ -170,22 +173,29 @@ impl BaseMeasure {
         expression: Rc<SqlCall>,
         cube_name: String,
         name: String,
+        member_expression_definition: Option<String>,
         query_tools: Rc<QueryTools>,
-    ) -> Result<Self, CubeError> {
-        let full_name = format!("{}.{}", cube_name, name);
-        let member_evaluator = Rc::new(MemberSymbol::SqlCall(expression));
-        let default_alias =
-            BaseMemberHelper::default_alias(&cube_name, &name, &None, query_tools.clone())?;
-        Ok(Self {
+    ) -> Result<Rc<Self>, CubeError> {
+        let member_expression_symbol = MemberExpressionSymbol::new(
+            cube_name.clone(),
+            name.clone(),
+            expression,
+            member_expression_definition.clone(),
+        );
+        let full_name = member_expression_symbol.full_name();
+        let member_evaluator = Rc::new(MemberSymbol::MemberExpression(member_expression_symbol));
+        let default_alias = PlanSqlTemplates::alias_name(&name);
+        Ok(Rc::new(Self {
             measure: full_name,
             query_tools,
             member_evaluator,
             definition: None,
             cube_name,
             name,
+            member_expression_definition,
             default_alias,
             time_shifts: vec![],
-        })
+        }))
     }
 
     pub fn can_used_as_addictive_in_multplied(&self) -> Result<bool, CubeError> {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
index 47f24a93ba00c..0ae0b8a40f296 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
@@ -14,9 +14,7 @@ pub trait BaseMember {
     ) -> Result<String, CubeError>;
     fn alias_name(&self) -> String;
     fn member_evaluator(&self) -> Rc<MemberSymbol>;
-    fn full_name(&self) -> String {
-        self.member_evaluator().full_name()
-    }
+    fn full_name(&self) -> String;
     fn as_base_member(self: Rc<Self>) -> Rc<dyn BaseMember>;
     fn cube_name(&self) -> &String;
     fn name(&self) -> &String;
@@ -44,7 +42,9 @@ impl BaseMemberHelper {
         members.iter().map(|m| m.alias_name()).collect_vec()
     }
 
-    pub fn extract_symbols_from_members(members: &Vec<Rc<dyn BaseMember>>) -> Vec<Rc<MemberSymbol>> {
+    pub fn extract_symbols_from_members(
+        members: &Vec<Rc<dyn BaseMember>>,
+    ) -> Vec<Rc<MemberSymbol>> {
         members.iter().map(|m| m.member_evaluator()).collect_vec()
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
index ca9d2f5982ae0..61e5e606c7514 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
@@ -38,6 +38,10 @@ impl BaseMember for BaseTimeDimension {
         self.member_evaluator.clone()
     }
 
+    fn full_name(&self) -> String {
+        self.member_evaluator.full_name()
+    }
+
     fn as_base_member(self: Rc<Self>) -> Rc<dyn BaseMember> {
         self.clone()
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs
index 7b08972b1c8c2..110b36ef9b91c 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs
@@ -94,6 +94,7 @@ impl DimensionSubqueryPlanner {
             expression,
             cube_name.clone(),
             dim_name.clone(),
+            None,
             self.query_tools.clone(),
         )?;
 
@@ -112,7 +113,7 @@ impl DimensionSubqueryPlanner {
 
         let sub_query_properties = QueryProperties::try_new_from_precompiled(
             self.query_tools.clone(),
-            vec![Rc::new(measure)], //measures,
+            vec![measure], //measures,
             primary_keys_dimensions.clone(),
             vec![],
             time_dimensions_filters,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs
index 748840c1f3cee..1c1c340ecfc57 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs
@@ -1,5 +1,6 @@
 use super::{CommonUtils, DimensionSubqueryPlanner};
 use crate::cube_bridge::join_definition::JoinDefinition;
+use crate::cube_bridge::join_hints::JoinHintItem;
 use crate::cube_bridge::member_sql::MemberSql;
 use crate::plan::{From, JoinBuilder, JoinCondition};
 use crate::planner::query_tools::QueryTools;
@@ -24,7 +25,7 @@ impl JoinPlanner {
     pub fn make_join_node_with_prefix_and_join_hints(
         &self,
         alias_prefix: &Option<String>, /*TODO dimensions for subqueries*/
-        join_hints: Vec<String>,
+        join_hints: Vec<JoinHintItem>,
         dimension_subquery_planner: &DimensionSubqueryPlanner,
     ) -> Result<Rc<From>, CubeError> {
         let join = self.query_tools.join_graph().build_join(join_hints)?;
@@ -39,7 +40,7 @@ impl JoinPlanner {
     ) -> Result<Rc<From>, CubeError> {
         let root = self.utils.cube_from_path(join.static_data().root.clone())?;
         let joins = join.joins()?;
-        if joins.items().is_empty() && dimension_subquery_planner.is_empty() {
+        if joins.is_empty() && dimension_subquery_planner.is_empty() {
             Ok(From::new_from_cube(root, None))
         } else {
             let mut join_builder = JoinBuilder::new_from_cube(
@@ -47,7 +48,7 @@ impl JoinPlanner {
                 Some(root.default_alias_with_prefix(alias_prefix)),
             );
             dimension_subquery_planner.add_joins_for_cube(&mut join_builder, root.name())?;
-            for join in joins.items().iter() {
+            for join in joins.iter() {
                 let definition = join.join()?;
                 let sql_call = self
                     .compile_join_condition(&join.static_data().original_from, definition.sql()?)?;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
index 02bcc14e09579..cbc821b6f27f6 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
@@ -1,9 +1,11 @@
 use super::filter::compiler::FilterCompiler;
 use super::query_tools::QueryTools;
+
 use super::sql_evaluator::MemberSymbol;
 use super::{BaseDimension, BaseMeasure, BaseMember, BaseMemberHelper, BaseTimeDimension};
 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::planner::sql_evaluator::collectors::{
     collect_multiplied_measures, has_cumulative_members, has_multi_stage_members,
@@ -76,12 +78,38 @@ impl QueryProperties {
         let evaluator_compiler_cell = query_tools.evaluator_compiler().clone();
         let mut evaluator_compiler = evaluator_compiler_cell.borrow_mut();
 
-        let dimensions = if let Some(dimensions) = &options.static_data().dimensions {
+        let dimensions = if let Some(dimensions) = &options.dimensions()? {
             dimensions
                 .iter()
-                .map(|d| {
-                    let evaluator = evaluator_compiler.add_dimension_evaluator(d.clone())?;
-                    BaseDimension::try_new_required(evaluator, query_tools.clone())
+                .map(|d| match d {
+                    OptionsMember::MemberName(member_name) => {
+                        let evaluator =
+                            evaluator_compiler.add_dimension_evaluator(member_name.clone())?;
+                        BaseDimension::try_new_required(evaluator, query_tools.clone())
+                    }
+                    OptionsMember::MemberExpression(member_expression) => {
+                        let cube_name =
+                            if let Some(name) = &member_expression.static_data().cube_name {
+                                name.clone()
+                            } else {
+                                "".to_string()
+                            };
+                        let name =
+                            if let Some(name) = &member_expression.static_data().expression_name {
+                                name.clone()
+                            } else {
+                                "".to_string()
+                            };
+                        let expression_evaluator = evaluator_compiler
+                            .compile_sql_call(&cube_name, member_expression.expression()?)?;
+                        BaseDimension::try_new_from_expression(
+                            expression_evaluator,
+                            cube_name,
+                            name,
+                            member_expression.static_data().definition.clone(),
+                            query_tools.clone(),
+                        )
+                    }
                 })
                 .collect::<Result<Vec<_>, _>>()?
         } else {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_tools.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_tools.rs
index 5a1bfe3e4cd9c..ff82a8221cf4b 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_tools.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_tools.rs
@@ -4,6 +4,7 @@ use crate::cube_bridge::base_tools::BaseTools;
 use crate::cube_bridge::evaluator::CubeEvaluator;
 use crate::cube_bridge::join_definition::JoinDefinition;
 use crate::cube_bridge::join_graph::JoinGraph;
+use crate::cube_bridge::join_hints::JoinHintItem;
 use crate::cube_bridge::join_item::JoinItemStatic;
 use crate::cube_bridge::sql_templates_render::SqlTemplatesRender;
 use crate::plan::FilterItem;
@@ -20,8 +21,8 @@ use std::collections::HashMap;
 use std::rc::Rc;
 
 pub struct QueryToolsCachedData {
-    join_hints: HashMap<String, Rc<Vec<String>>>,
-    join_hints_to_join_key: HashMap<Vec<Rc<Vec<String>>>, Rc<JoinKey>>,
+    join_hints: HashMap<String, Rc<Vec<JoinHintItem>>>,
+    join_hints_to_join_key: HashMap<Vec<Rc<Vec<JoinHintItem>>>, Rc<JoinKey>>,
     join_key_to_join: HashMap<Rc<JoinKey>, Rc<dyn JoinDefinition>>,
 }
 
@@ -43,7 +44,7 @@ impl QueryToolsCachedData {
     pub fn join_hints_for_member(
         &mut self,
         node: &Rc<MemberSymbol>,
-    ) -> Result<Rc<Vec<String>>, CubeError> {
+    ) -> Result<Rc<Vec<JoinHintItem>>, CubeError> {
         let full_name = node.full_name();
         if let Some(val) = self.join_hints.get(&full_name) {
             Ok(val.clone())
@@ -57,7 +58,7 @@ impl QueryToolsCachedData {
     pub fn join_hints_for_base_member_vec<T: BaseMember>(
         &mut self,
         vec: &Vec<Rc<T>>,
-    ) -> Result<Vec<Rc<Vec<String>>>, CubeError> {
+    ) -> Result<Vec<Rc<Vec<JoinHintItem>>>, CubeError> {
         vec.iter()
             .map(|b| self.join_hints_for_member(&b.member_evaluator()))
             .collect::<Result<Vec<_>, _>>()
@@ -66,7 +67,7 @@ impl QueryToolsCachedData {
     pub fn join_hints_for_member_symbol_vec(
         &mut self,
         vec: &Vec<Rc<MemberSymbol>>,
-    ) -> Result<Vec<Rc<Vec<String>>>, CubeError> {
+    ) -> Result<Vec<Rc<Vec<JoinHintItem>>>, CubeError> {
         vec.iter()
             .map(|b| self.join_hints_for_member(b))
             .collect::<Result<Vec<_>, _>>()
@@ -75,7 +76,7 @@ impl QueryToolsCachedData {
     pub fn join_hints_for_filter_item_vec(
         &mut self,
         vec: &Vec<FilterItem>,
-    ) -> Result<Vec<Rc<Vec<String>>>, CubeError> {
+    ) -> Result<Vec<Rc<Vec<JoinHintItem>>>, CubeError> {
         let mut member_symbols = Vec::new();
         for i in vec.iter() {
             i.find_all_member_evaluators(&mut member_symbols);
@@ -88,8 +89,8 @@ impl QueryToolsCachedData {
 
     pub fn join_by_hints(
         &mut self,
-        hints: Vec<Rc<Vec<String>>>,
-        join_fn: impl FnOnce(Vec<String>) -> Result<Rc<dyn JoinDefinition>, CubeError>,
+        hints: Vec<Rc<Vec<JoinHintItem>>>,
+        join_fn: impl FnOnce(Vec<JoinHintItem>) -> Result<Rc<dyn JoinDefinition>, CubeError>,
     ) -> Result<(Rc<JoinKey>, Rc<dyn JoinDefinition>), CubeError> {
         if let Some(key) = self.join_hints_to_join_key.get(&hints) {
             Ok((key.clone(), self.join_key_to_join.get(key).unwrap().clone()))
@@ -104,7 +105,6 @@ impl QueryToolsCachedData {
                 root: join.static_data().root.to_string(),
                 joins: join
                     .joins()?
-                    .items()
                     .iter()
                     .map(|i| i.static_data().clone())
                     .collect(),
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs
index d3db79c353218..9d7f68d7a6a62 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs
@@ -24,40 +24,48 @@ impl TraversalVisitor for CubeNamesCollector {
     fn on_node_traverse(
         &mut self,
         node: &Rc<MemberSymbol>,
+        path: &Vec<String>,
         _: &Self::State,
     ) -> Result<Option<Self::State>, CubeError> {
         match node.as_ref() {
             MemberSymbol::Dimension(e) => {
                 if e.owned_by_cube() {
-                    self.names.insert(e.cube_name().clone());
+                    if !path.is_empty() {
+                        for p in path {
+                            self.names.insert(p.clone());
+                        }
+                    } else {
+                        self.names.insert(e.cube_name().clone());
+                    }
                 }
                 if e.is_sub_query() {
                     return Ok(None);
                 }
-                for name in e.get_dependent_cubes().into_iter() {
-                    self.names.insert(name);
-                }
             }
-            MemberSymbol::TimeDimension(e) => return self.on_node_traverse(e.base_symbol(), &()),
+            MemberSymbol::TimeDimension(e) => {
+                return self.on_node_traverse(e.base_symbol(), path, &())
+            }
             MemberSymbol::Measure(e) => {
                 if e.owned_by_cube() {
-                    self.names.insert(e.cube_name().clone());
-                }
-                for name in e.get_dependent_cubes().into_iter() {
-                    self.names.insert(name);
+                    if !path.is_empty() {
+                        for p in path {
+                            self.names.insert(p.clone());
+                        }
+                    } else {
+                        self.names.insert(e.cube_name().clone());
+                    }
                 }
             }
             MemberSymbol::CubeName(e) => {
-                self.names.insert(e.cube_name().clone());
-            }
-            MemberSymbol::CubeTable(e) => {
-                self.names.insert(e.cube_name().clone());
-            }
-            MemberSymbol::SqlCall(s) => {
-                for name in s.get_dependent_cubes().into_iter() {
-                    self.names.insert(name);
+                if !path.is_empty() {
+                    for p in path {
+                        self.names.insert(p.clone());
+                    }
                 }
+                self.names.insert(e.cube_name().clone());
             }
+            MemberSymbol::CubeTable(_) => {}
+            MemberSymbol::MemberExpression(_) => {}
         };
         Ok(Some(()))
     }
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
index deec7e9cbda2c..c73c578680c46 100644
--- 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
@@ -23,6 +23,7 @@ impl TraversalVisitor for HasCumulativeMembersCollector {
     fn on_node_traverse(
         &mut self,
         node: &Rc<MemberSymbol>,
+        _path: &Vec<String>,
         _: &Self::State,
     ) -> Result<Option<Self::State>, CubeError> {
         match node.as_ref() {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/has_multi_stage_members.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/has_multi_stage_members.rs
index 7190d39c469d7..170651bcaaeed 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/has_multi_stage_members.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/has_multi_stage_members.rs
@@ -25,6 +25,7 @@ impl TraversalVisitor for HasMultiStageMembersCollector {
     fn on_node_traverse(
         &mut self,
         node: &Rc<MemberSymbol>,
+        _path: &Vec<String>,
         _: &Self::State,
     ) -> Result<Option<Self::State>, CubeError> {
         match node.as_ref() {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs
index 45b51d3f43fcb..086b610afd169 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs
@@ -1,10 +1,12 @@
+use crate::cube_bridge::join_hints::JoinHintItem;
 use crate::planner::sql_evaluator::{MemberSymbol, TraversalVisitor};
 use crate::planner::BaseMeasure;
 use cubenativeutils::CubeError;
+use itertools::Itertools;
 use std::rc::Rc;
 
 pub struct JoinHintsCollector {
-    hints: Vec<String>,
+    hints: Vec<JoinHintItem>,
 }
 
 impl JoinHintsCollector {
@@ -12,8 +14,8 @@ impl JoinHintsCollector {
         Self { hints: Vec::new() }
     }
 
-    pub fn extract_result(self) -> Vec<String> {
-        self.hints
+    pub fn extract_result(self) -> Vec<JoinHintItem> {
+        self.hints.into_iter().unique().collect()
     }
 }
 
@@ -22,57 +24,72 @@ impl TraversalVisitor for JoinHintsCollector {
     fn on_node_traverse(
         &mut self,
         node: &Rc<MemberSymbol>,
+        path: &Vec<String>,
         _: &Self::State,
     ) -> Result<Option<Self::State>, CubeError> {
         match node.as_ref() {
             MemberSymbol::Dimension(e) => {
                 if e.owned_by_cube() {
-                    self.hints.push(e.cube_name().clone());
+                    if !path.is_empty() {
+                        if path.len() == 1 {
+                            self.hints.push(JoinHintItem::Single(path[0].clone()))
+                        } else {
+                            self.hints.push(JoinHintItem::Vector(path.clone()))
+                        }
+                    } else {
+                        self.hints.push(JoinHintItem::Single(e.cube_name().clone()));
+                    }
                 }
                 if e.is_sub_query() {
                     return Ok(None);
                 }
-                for name in e.get_dependent_cubes().into_iter() {
-                    self.hints.push(name);
-                }
             }
-            MemberSymbol::TimeDimension(e) => return self.on_node_traverse(e.base_symbol(), &()),
+            MemberSymbol::TimeDimension(e) => {
+                return self.on_node_traverse(e.base_symbol(), path, &())
+            }
             MemberSymbol::Measure(e) => {
                 if e.owned_by_cube() {
-                    self.hints.push(e.cube_name().clone());
-                }
-                for name in e.get_dependent_cubes().into_iter() {
-                    self.hints.push(name);
+                    if !path.is_empty() {
+                        if path.len() == 1 {
+                            self.hints.push(JoinHintItem::Single(path[0].clone()))
+                        } else {
+                            self.hints.push(JoinHintItem::Vector(path.clone()))
+                        }
+                    } else {
+                        self.hints.push(JoinHintItem::Single(e.cube_name().clone()));
+                    }
                 }
             }
             MemberSymbol::CubeName(e) => {
-                self.hints.push(e.cube_name().clone());
-            }
-            MemberSymbol::CubeTable(e) => {
-                self.hints.push(e.cube_name().clone());
-            }
-            MemberSymbol::SqlCall(s) => {
-                for name in s.get_dependent_cubes().into_iter() {
-                    self.hints.push(name);
+                if !path.is_empty() {
+                    let mut path = path.clone();
+                    path.push(e.cube_name().clone());
+                    self.hints.push(JoinHintItem::Vector(path));
+                } else {
+                    self.hints.push(JoinHintItem::Single(e.cube_name().clone()));
                 }
             }
+            MemberSymbol::CubeTable(_) => {}
+            MemberSymbol::MemberExpression(_) => {}
         };
         Ok(Some(()))
     }
 }
 
-pub fn collect_join_hints(node: &Rc<MemberSymbol>) -> Result<Vec<String>, CubeError> {
+pub fn collect_join_hints(node: &Rc<MemberSymbol>) -> Result<Vec<JoinHintItem>, CubeError> {
     let mut visitor = JoinHintsCollector::new();
     visitor.apply(node, &())?;
-    Ok(visitor.extract_result())
+    let res = visitor.extract_result();
+    Ok(res)
 }
 
 pub fn collect_join_hints_for_measures(
     measures: &Vec<Rc<BaseMeasure>>,
-) -> Result<Vec<String>, CubeError> {
+) -> Result<Vec<JoinHintItem>, CubeError> {
     let mut visitor = JoinHintsCollector::new();
     for meas in measures.iter() {
         visitor.apply(&meas.member_evaluator(), &())?;
     }
-    Ok(visitor.extract_result())
+    let res = visitor.extract_result();
+    Ok(res)
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/member_childs_collector.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/member_childs_collector.rs
index 8bb049ee48b6a..43f76b41336dc 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/member_childs_collector.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/member_childs_collector.rs
@@ -32,6 +32,7 @@ impl TraversalVisitor for MemberChildsCollector {
     fn on_node_traverse(
         &mut self,
         node: &Rc<MemberSymbol>,
+        _path: &Vec<String>,
         state: &Self::State,
     ) -> Result<Option<Self::State>, CubeError> {
         if state.is_root {
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
index 62de3b9914d73..b2e294cff518f 100644
--- 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
@@ -37,6 +37,7 @@ impl TraversalVisitor for CompositeMeasuresCollector {
     fn on_node_traverse(
         &mut self,
         node: &Rc<MemberSymbol>,
+        _path: &Vec<String>,
         state: &Self::State,
     ) -> Result<Option<Self::State>, CubeError> {
         let res = match node.as_ref() {
@@ -93,6 +94,7 @@ impl TraversalVisitor for MultipliedMeasuresCollector {
     fn on_node_traverse(
         &mut self,
         node: &Rc<MemberSymbol>,
+        _path: &Vec<String>,
         _: &Self::State,
     ) -> Result<Option<Self::State>, CubeError> {
         let res = match node.as_ref() {
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
index fc2b7589ada04..e5e16d4cd53a7 100644
--- 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
@@ -36,6 +36,7 @@ impl TraversalVisitor for SubQueryDimensionsCollector {
     fn on_node_traverse(
         &mut self,
         node: &Rc<MemberSymbol>,
+        path: &Vec<String>,
         _state: &Self::State,
     ) -> Result<Option<Self::State>, CubeError> {
         match node.as_ref() {
@@ -51,7 +52,7 @@ impl TraversalVisitor for SubQueryDimensionsCollector {
                 }
                 Ok(Some(()))
             }
-            MemberSymbol::TimeDimension(dim) => self.on_node_traverse(dim.base_symbol(), &()),
+            MemberSymbol::TimeDimension(dim) => self.on_node_traverse(dim.base_symbol(), path, &()),
             _ => Ok(Some(())),
         }
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs
index 1b284b5219ca3..fe20a91af738a 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs
@@ -6,6 +6,7 @@ use super::{
     SqlCall, SymbolFactory, TraversalVisitor,
 };
 use crate::cube_bridge::evaluator::CubeEvaluator;
+use crate::cube_bridge::join_hints::JoinHintItem;
 use crate::cube_bridge::member_sql::MemberSql;
 use cubenativeutils::CubeError;
 use std::collections::HashMap;
@@ -80,7 +81,7 @@ impl Compiler {
         }
     }
 
-    pub fn join_hints(&self) -> Result<Vec<String>, CubeError> {
+    pub fn join_hints(&self) -> Result<Vec<JoinHintItem>, CubeError> {
         let mut collector = JoinHintsCollector::new();
         for member in self.members.values() {
             collector.apply(member, &())?;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs
index e5a7e41a7c719..83cdce4b7d78c 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs
@@ -15,7 +15,7 @@ pub use sql_call::SqlCall;
 pub use sql_visitor::SqlEvaluatorVisitor;
 pub use symbols::{
     CubeNameSymbol, CubeNameSymbolFactory, CubeTableSymbol, CubeTableSymbolFactory,
-    DimensionSymbol, DimensionSymbolFactory, MeasureSymbol, MeasureSymbolFactory, MemberSymbol,
-    SymbolFactory, TimeDimensionSymbol,
+    DimensionSymbol, DimensionSymbolFactory, MeasureSymbol, MeasureSymbolFactory,
+    MemberExpressionSymbol, MemberSymbol, SymbolFactory, TimeDimensionSymbol,
 };
 pub use visitor::TraversalVisitor;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs
index 6e56d82f2ba28..100e44e86bd83 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs
@@ -46,6 +46,12 @@ impl SqlCall {
         deps
     }
 
+    pub fn get_dependencies_with_path(&self) -> Vec<(Rc<MemberSymbol>, Vec<String>)> {
+        let mut deps = Vec::new();
+        self.extract_symbol_deps_with_path(&mut deps);
+        deps
+    }
+
     pub fn extract_symbol_deps(&self, result: &mut Vec<Rc<MemberSymbol>>) {
         for dep in self.deps.iter() {
             match dep {
@@ -58,6 +64,18 @@ impl SqlCall {
         }
     }
 
+    pub fn extract_symbol_deps_with_path(&self, result: &mut Vec<(Rc<MemberSymbol>, Vec<String>)>) {
+        for dep in self.deps.iter() {
+            match dep {
+                Dependency::SymbolDependency(dep) => result.push((dep.clone(), vec![])),
+                Dependency::CubeDependency(cube_dep) => {
+                    self.extract_symbol_deps_with_path_from_cube_dep(cube_dep, vec![], result)
+                }
+                Dependency::ContextDependency(_) => {}
+            }
+        }
+    }
+
     pub fn get_dependent_cubes(&self) -> Vec<String> {
         let mut deps = Vec::new();
         self.extract_cube_deps(&mut deps);
@@ -91,6 +109,29 @@ impl SqlCall {
         }
     }
 
+    fn extract_symbol_deps_with_path_from_cube_dep(
+        &self,
+        cube_dep: &CubeDependency,
+        mut path: Vec<String>,
+        result: &mut Vec<(Rc<MemberSymbol>, Vec<String>)>,
+    ) {
+        path.push(cube_dep.cube_symbol.cube_name());
+        if let Some(sql_fn) = &cube_dep.sql_fn {
+            result.push((sql_fn.clone(), path.clone()));
+        }
+        if let Some(to_string_fn) = &cube_dep.to_string_fn {
+            result.push((to_string_fn.clone(), path.clone()));
+        }
+        for (_, v) in cube_dep.properties.iter() {
+            match v {
+                CubeDepProperty::SymbolDependency(dep) => result.push((dep.clone(), path.clone())),
+                CubeDepProperty::CubeDependency(cube_dep) => {
+                    self.extract_symbol_deps_with_path_from_cube_dep(cube_dep, path.clone(), result)
+                }
+            };
+        }
+    }
+
     fn extract_cube_deps_from_cube_dep(&self, cube_dep: &CubeDependency, result: &mut Vec<String>) {
         result.push(cube_dep.cube_symbol.name());
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs
index 246d05698366c..6eeda7310d040 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs
@@ -87,7 +87,7 @@ impl SqlNode for EvaluateSqlNode {
                 templates,
             ),
             MemberSymbol::CubeName(ev) => ev.evaluate_sql(),
-            MemberSymbol::SqlCall(s) => s.eval(
+            MemberSymbol::MemberExpression(e) => e.evaluate_sql(
                 visitor,
                 node_processor.clone(),
                 query_tools.clone(),
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/cube_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/cube_symbol.rs
index 56d55ecd89bc6..bfa3be5cfc2d5 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/cube_symbol.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/cube_symbol.rs
@@ -68,7 +68,7 @@ impl SymbolFactory for CubeNameSymbolFactory {
 
 pub struct CubeTableSymbol {
     cube_name: String,
-    member_sql: Rc<SqlCall>,
+    member_sql: Option<Rc<SqlCall>>,
     #[allow(dead_code)]
     definition: Rc<dyn CubeDefinition>,
     is_table_sql: bool,
@@ -77,7 +77,7 @@ pub struct CubeTableSymbol {
 impl CubeTableSymbol {
     pub fn new(
         cube_name: String,
-        member_sql: Rc<SqlCall>,
+        member_sql: Option<Rc<SqlCall>>,
         definition: Rc<dyn CubeDefinition>,
         is_table_sql: bool,
     ) -> Self {
@@ -96,27 +96,33 @@ impl CubeTableSymbol {
         query_tools: Rc<QueryTools>,
         templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
-        lazy_static! {
-            static ref SIMPLE_ASTERIX_RE: Regex =
-                Regex::new(r#"(?i)^\s*select\s+\*\s+from\s+([a-zA-Z0-9_\-`".*]+)\s*$"#).unwrap();
-        }
-        let sql = self
-            .member_sql
-            .eval(visitor, node_processor, query_tools, templates)?;
-        let res = if self.is_table_sql {
-            sql
-        } else {
-            if let Some(captures) = SIMPLE_ASTERIX_RE.captures(&sql) {
-                if let Some(table) = captures.get(1) {
-                    table.as_str().to_owned()
+        if let Some(member_sql) = &self.member_sql {
+            lazy_static! {
+                static ref SIMPLE_ASTERIX_RE: Regex =
+                    Regex::new(r#"(?i)^\s*select\s+\*\s+from\s+([a-zA-Z0-9_\-`".*]+)\s*$"#)
+                        .unwrap();
+            }
+            let sql = member_sql.eval(visitor, node_processor, query_tools, templates)?;
+            let res = if self.is_table_sql {
+                sql
+            } else {
+                if let Some(captures) = SIMPLE_ASTERIX_RE.captures(&sql) {
+                    if let Some(table) = captures.get(1) {
+                        table.as_str().to_owned()
+                    } else {
+                        format!("({})", sql)
+                    }
                 } else {
                     format!("({})", sql)
                 }
-            } else {
-                format!("({})", sql)
-            }
-        };
-        Ok(res)
+            };
+            Ok(res)
+        } else {
+            Err(CubeError::internal(format!(
+                "Cube {} doesn't have sql evaluator",
+                self.cube_name
+            )))
+        }
     }
     pub fn cube_name(&self) -> &String {
         &self.cube_name
@@ -125,7 +131,7 @@ impl CubeTableSymbol {
 
 pub struct CubeTableSymbolFactory {
     cube_name: String,
-    sql: Rc<dyn MemberSql>,
+    sql: Option<Rc<dyn MemberSql>>,
     definition: Rc<dyn CubeDefinition>,
     is_table_sql: bool,
 }
@@ -139,15 +145,7 @@ impl CubeTableSymbolFactory {
         let table_sql = definition.sql_table()?;
         let is_table_sql = table_sql.is_some();
         let sql = definition.sql()?;
-        let sql = if let Some(sql) = table_sql.or(sql) {
-            sql
-        } else {
-            return Err(CubeError::user(format!(
-                "Cube {} sould have sql or sqlTable field",
-                cube_name
-            )));
-        };
-
+        let sql = table_sql.or(sql);
         Ok(Self {
             cube_name: cube_name.clone(),
             sql,
@@ -167,11 +165,14 @@ impl SymbolFactory for CubeTableSymbolFactory {
     }
 
     fn deps_names(&self) -> Result<Vec<String>, CubeError> {
-        Ok(self.sql.args_names().clone())
+        Ok(self
+            .sql
+            .as_ref()
+            .map_or_else(|| vec![], |sql| sql.args_names().clone()))
     }
 
     fn member_sql(&self) -> Option<Rc<dyn MemberSql>> {
-        Some(self.sql.clone())
+        self.sql.clone()
     }
 
     fn build(self, compiler: &mut Compiler) -> Result<Rc<MemberSymbol>, CubeError> {
@@ -181,7 +182,11 @@ impl SymbolFactory for CubeTableSymbolFactory {
             definition,
             is_table_sql,
         } = self;
-        let sql = compiler.compile_sql_call(&cube_name, sql)?;
+        let sql = if let Some(sql) = sql {
+            Some(compiler.compile_sql_call(&cube_name, sql)?)
+        } else {
+            None
+        };
         Ok(MemberSymbol::new_cube_table(CubeTableSymbol::new(
             cube_name,
             sql,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs
index 93d6c7a9c1ab3..c574afd0e0a58 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/dimension_symbol.rs
@@ -92,6 +92,26 @@ impl DimensionSymbol {
         if let Some(member_sql) = &self.member_sql {
             member_sql.extract_symbol_deps(&mut deps);
         }
+        if let Some(member_sql) = &self.latitude {
+            member_sql.extract_symbol_deps(&mut deps);
+        }
+        if let Some(member_sql) = &self.longitude {
+            member_sql.extract_symbol_deps(&mut deps);
+        }
+        deps
+    }
+
+    pub fn get_dependencies_with_path(&self) -> Vec<(Rc<MemberSymbol>, Vec<String>)> {
+        let mut deps = vec![];
+        if let Some(member_sql) = &self.member_sql {
+            member_sql.extract_symbol_deps_with_path(&mut deps);
+        }
+        if let Some(member_sql) = &self.latitude {
+            member_sql.extract_symbol_deps_with_path(&mut deps);
+        }
+        if let Some(member_sql) = &self.longitude {
+            member_sql.extract_symbol_deps_with_path(&mut deps);
+        }
         deps
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs
index 15971ffebdef1..e827878aee0bb 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs
@@ -131,6 +131,26 @@ impl MeasureSymbol {
         deps
     }
 
+    pub fn get_dependencies_with_path(&self) -> Vec<(Rc<MemberSymbol>, Vec<String>)> {
+        let mut deps = vec![];
+        if let Some(member_sql) = &self.member_sql {
+            member_sql.extract_symbol_deps_with_path(&mut deps);
+        }
+        for pk in self.pk_sqls.iter() {
+            pk.extract_symbol_deps_with_path(&mut deps);
+        }
+        for filter in self.measure_filters.iter() {
+            filter.extract_symbol_deps_with_path(&mut deps);
+        }
+        for filter in self.measure_drill_filters.iter() {
+            filter.extract_symbol_deps_with_path(&mut deps);
+        }
+        for order in self.measure_order_by.iter() {
+            order.sql_call().extract_symbol_deps_with_path(&mut deps);
+        }
+        deps
+    }
+
     pub fn get_dependent_cubes(&self) -> Vec<String> {
         let mut cubes = vec![];
         if let Some(member_sql) = &self.member_sql {
@@ -296,7 +316,7 @@ impl SymbolFactory for MeasureSymbolFactory {
         };
         let mut measure_filters = vec![];
         if let Some(filters) = definition.filters()? {
-            for filter in filters.items().iter() {
+            for filter in filters.iter() {
                 let node = compiler.compile_sql_call(&cube_name, filter.sql()?)?;
                 measure_filters.push(node);
             }
@@ -304,7 +324,7 @@ impl SymbolFactory for MeasureSymbolFactory {
 
         let mut measure_drill_filters = vec![];
         if let Some(filters) = definition.drill_filters()? {
-            for filter in filters.items().iter() {
+            for filter in filters.iter() {
                 let node = compiler.compile_sql_call(&cube_name, filter.sql()?)?;
                 measure_drill_filters.push(node);
             }
@@ -312,7 +332,7 @@ impl SymbolFactory for MeasureSymbolFactory {
 
         let mut measure_order_by = vec![];
         if let Some(group_by) = definition.order_by()? {
-            for item in group_by.items().iter() {
+            for item in group_by.iter() {
                 let node = compiler.compile_sql_call(&cube_name, item.sql()?)?;
                 measure_order_by.push(MeasureOrderBy::new(node, item.dir()?));
             }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_expression_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_expression_symbol.rs
new file mode 100644
index 0000000000000..d72603a5729b7
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_expression_symbol.rs
@@ -0,0 +1,71 @@
+use super::MemberSymbol;
+use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::{sql_nodes::SqlNode, SqlCall, SqlEvaluatorVisitor};
+use crate::planner::sql_templates::PlanSqlTemplates;
+use cubenativeutils::CubeError;
+use std::rc::Rc;
+
+pub struct MemberExpressionSymbol {
+    cube_name: String,
+    name: String,
+    expression: Rc<SqlCall>,
+    #[allow(dead_code)]
+    definition: Option<String>,
+}
+
+impl MemberExpressionSymbol {
+    pub fn new(
+        cube_name: String,
+        name: String,
+        expression: Rc<SqlCall>,
+        definition: Option<String>,
+    ) -> Self {
+        Self {
+            cube_name,
+            name,
+            expression,
+            definition,
+        }
+    }
+
+    pub fn evaluate_sql(
+        &self,
+        visitor: &SqlEvaluatorVisitor,
+        node_processor: Rc<dyn SqlNode>,
+        query_tools: Rc<QueryTools>,
+        templates: &PlanSqlTemplates,
+    ) -> Result<String, CubeError> {
+        let sql = self
+            .expression
+            .eval(visitor, node_processor, query_tools, templates)?;
+        Ok(sql)
+    }
+
+    pub fn expression(&self) -> &Rc<SqlCall> {
+        &self.expression
+    }
+
+    pub fn full_name(&self) -> String {
+        format!("expr:{}.{}", self.cube_name, self.name)
+    }
+
+    pub fn get_dependencies(&self) -> Vec<Rc<MemberSymbol>> {
+        let mut deps = vec![];
+        self.expression.extract_symbol_deps(&mut deps);
+        deps
+    }
+
+    pub fn get_dependencies_with_path(&self) -> Vec<(Rc<MemberSymbol>, Vec<String>)> {
+        let mut deps = vec![];
+        self.expression.extract_symbol_deps_with_path(&mut deps);
+        deps
+    }
+
+    pub fn cube_name(&self) -> &String {
+        &self.cube_name
+    }
+
+    pub fn name(&self) -> &String {
+        &self.name
+    }
+}
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
index b0e2a97a66853..442e52312cb45 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_symbol.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_symbol.rs
@@ -1,6 +1,7 @@
-use crate::planner::sql_evaluator::SqlCall;
-
-use super::{CubeNameSymbol, CubeTableSymbol, DimensionSymbol, MeasureSymbol, TimeDimensionSymbol};
+use super::{
+    CubeNameSymbol, CubeTableSymbol, DimensionSymbol, MeasureSymbol, MemberExpressionSymbol,
+    TimeDimensionSymbol,
+};
 use std::rc::Rc;
 
 pub enum MemberSymbol {
@@ -9,7 +10,7 @@ pub enum MemberSymbol {
     Measure(MeasureSymbol),
     CubeName(CubeNameSymbol),
     CubeTable(CubeTableSymbol),
-    SqlCall(Rc<SqlCall>), //FIXME for expressions only
+    MemberExpression(MemberExpressionSymbol),
 }
 
 impl MemberSymbol {
@@ -36,7 +37,7 @@ impl MemberSymbol {
             Self::Measure(m) => m.full_name(),
             Self::CubeName(c) => c.cube_name().clone(),
             Self::CubeTable(c) => c.cube_name().clone(),
-            Self::SqlCall(_) => format!(""),
+            Self::MemberExpression(e) => e.full_name().clone(),
         }
     }
     pub fn name(&self) -> String {
@@ -46,7 +47,7 @@ impl MemberSymbol {
             Self::Measure(m) => m.name().clone(),
             Self::CubeName(c) => c.cube_name().clone(),
             Self::CubeTable(c) => c.cube_name().clone(),
-            Self::SqlCall(_) => format!(""),
+            Self::MemberExpression(e) => e.name().clone(),
         }
     }
 
@@ -57,7 +58,7 @@ impl MemberSymbol {
             Self::Measure(m) => m.cube_name().clone(),
             Self::CubeName(c) => c.cube_name().clone(),
             Self::CubeTable(c) => c.cube_name().clone(),
-            Self::SqlCall(_) => format!(""),
+            Self::MemberExpression(e) => e.cube_name().clone(),
         }
     }
 
@@ -76,18 +77,18 @@ impl MemberSymbol {
             Self::Measure(m) => m.get_dependencies(),
             Self::CubeName(_) => vec![],
             Self::CubeTable(_) => vec![],
-            Self::SqlCall(s) => s.get_dependencies(),
+            Self::MemberExpression(e) => e.get_dependencies(),
         }
     }
 
-    pub fn get_dependent_cubes(&self) -> Vec<String> {
+    pub fn get_dependencies_with_path(&self) -> Vec<(Rc<MemberSymbol>, Vec<String>)> {
         match self {
-            Self::Dimension(d) => d.get_dependent_cubes(),
-            Self::TimeDimension(d) => d.get_dependent_cubes(),
-            Self::Measure(m) => m.get_dependent_cubes(),
+            Self::Dimension(d) => d.get_dependencies_with_path(),
+            Self::TimeDimension(d) => d.get_dependencies_with_path(),
+            Self::Measure(m) => m.get_dependencies_with_path(),
             Self::CubeName(_) => vec![],
             Self::CubeTable(_) => vec![],
-            Self::SqlCall(s) => s.get_dependent_cubes(),
+            Self::MemberExpression(e) => e.get_dependencies_with_path(),
         }
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/mod.rs
index 39f09d356fdf8..9a47779d4f47c 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/mod.rs
@@ -1,6 +1,7 @@
 mod cube_symbol;
 mod dimension_symbol;
 mod measure_symbol;
+mod member_expression_symbol;
 mod member_symbol;
 mod symbol_factory;
 mod time_dimension_symbol;
@@ -10,6 +11,7 @@ pub use cube_symbol::{
 };
 pub use dimension_symbol::{DimensionSymbol, DimensionSymbolFactory};
 pub use measure_symbol::{MeasureSymbol, MeasureSymbolFactory};
+pub use member_expression_symbol::MemberExpressionSymbol;
 pub use member_symbol::MemberSymbol;
 pub use symbol_factory::SymbolFactory;
 pub use time_dimension_symbol::TimeDimensionSymbol;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs
index 212bffbb95a03..590584e872730 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs
@@ -38,8 +38,8 @@ impl TimeDimensionSymbol {
         self.base_symbol.get_dependencies()
     }
 
-    pub fn get_dependent_cubes(&self) -> Vec<String> {
-        self.base_symbol.get_dependent_cubes()
+    pub fn get_dependencies_with_path(&self) -> Vec<(Rc<MemberSymbol>, Vec<String>)> {
+        self.base_symbol.get_dependencies_with_path()
     }
 
     pub fn cube_name(&self) -> String {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/visitor.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/visitor.rs
index abef52ceeaa02..7f4a43980b636 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/visitor.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/visitor.rs
@@ -7,13 +7,23 @@ pub trait TraversalVisitor {
     fn on_node_traverse(
         &mut self,
         node: &Rc<MemberSymbol>,
+        path: &Vec<String>,
         state: &Self::State,
     ) -> Result<Option<Self::State>, CubeError>;
 
     fn apply(&mut self, node: &Rc<MemberSymbol>, state: &Self::State) -> Result<(), CubeError> {
-        if let Some(state) = self.on_node_traverse(node, state)? {
-            for dep in node.get_dependencies() {
-                self.apply(&dep, &state)?
+        self.apply_with_path(node, &vec![], state)
+    }
+
+    fn apply_with_path(
+        &mut self,
+        node: &Rc<MemberSymbol>,
+        path: &Vec<String>,
+        state: &Self::State,
+    ) -> Result<(), CubeError> {
+        if let Some(state) = self.on_node_traverse(node, path, state)? {
+            for (dep, dep_path) in node.get_dependencies_with_path() {
+                self.apply_with_path(&dep, &dep_path, &state)?
             }
         }
         Ok(())
diff --git a/rust/cubesqlplanner/nativebridge/src/lib.rs b/rust/cubesqlplanner/nativebridge/src/lib.rs
index c889ca2933cd8..fd2dff5ac18d2 100644
--- a/rust/cubesqlplanner/nativebridge/src/lib.rs
+++ b/rust/cubesqlplanner/nativebridge/src/lib.rs
@@ -38,6 +38,7 @@ enum NativeMethodType {
 struct NativeMethodParams {
     pub method_type: NativeMethodType,
     pub is_optional: bool,
+    pub is_vec: bool,
 }
 
 impl Default for NativeMethodParams {
@@ -45,12 +46,14 @@ impl Default for NativeMethodParams {
         Self {
             method_type: NativeMethodType::Call,
             is_optional: false,
+            is_vec: false,
         }
     }
 }
 
 struct NativeOutputParams {
     type_path: Path,
+    original_type: Path,
     dynamic_container_path: Option<Path>,
 }
 
@@ -99,6 +102,7 @@ impl Parse for NativeService {
                                 output_params: Self::get_output_for_deserializer(
                                     &method_item.sig.output,
                                     method_params.is_optional,
+                                    method_params.is_vec,
                                 )
                                 .unwrap(),
                                 method_params,
@@ -159,6 +163,9 @@ impl NativeService {
                     "field" => {
                         method_params.method_type = NativeMethodType::Getter;
                     }
+                    "vec" => {
+                        method_params.is_vec = true;
+                    }
                     _ => {}
                 }
             }
@@ -168,12 +175,15 @@ impl NativeService {
     fn get_output_for_deserializer(
         tp: &ReturnType,
         optional: bool,
+        vec: bool,
     ) -> syn::Result<NativeOutputParams> {
-        let expected_type = if optional {
-            "Result<_>"
-        } else {
-            "Result<Option<_>>"
-        };
+        let mut expected_type = "Result<_>".to_string();
+        if optional {
+            expected_type = expected_type.replace("_", "Option<_>");
+        }
+        if vec {
+            expected_type = expected_type.replace("_", "Vec<_>");
+        }
         let s = match tp {
             ReturnType::Default => Err(syn::Error::new(
                 tp.span(),
@@ -182,7 +192,7 @@ impl NativeService {
             ReturnType::Type(_, tt) => match tt.as_ref() {
                 syn::Type::Path(tp) => {
                     let segs = &tp.path.segments;
-                    Self::get_deserializer_output_for_result(segs, optional)
+                    Self::get_deserializer_output_for_result(segs, optional, vec, &expected_type)
                 }
                 _ => Err(syn::Error::new(
                     tp.span(),
@@ -196,18 +206,22 @@ impl NativeService {
     fn get_deserializer_output_for_result(
         segs: &Punctuated<PathSegment, Colon2>,
         optional: bool,
+        vec: bool,
+        expected_type: &str,
     ) -> syn::Result<NativeOutputParams> {
         let seg = segs.last().ok_or(syn::Error::new(
             segs.span(),
             "Return type should be Result<_>",
         ))?;
         if seg.ident.to_string() == "Result" {
-            let args = &seg.arguments;
+            let mut args = seg.arguments.clone();
             if optional {
-                Self::get_deserializer_output_for_option(args)
-            } else {
-                Self::get_type_for_deserialize_from_result_args(args)
+                args = Self::extract_output_for_nested_type(&args, "Option", expected_type)?;
             }
+            if vec {
+                args = Self::extract_output_for_nested_type(&args, "Vec", expected_type)?;
+            }
+            Self::get_type_for_deserialize_from_result_args(&args, expected_type)
         } else {
             Err(syn::Error::new(
                 seg.span(),
@@ -216,13 +230,18 @@ impl NativeService {
         }
     }
 
-    fn get_deserializer_output_for_option(args: &PathArguments) -> syn::Result<NativeOutputParams> {
+    fn extract_output_for_nested_type(
+        args: &PathArguments,
+        type_to_extract: &str,
+        expected_type: &str,
+    ) -> syn::Result<PathArguments> {
+        let error_message = format!("Return type should be {expected_type}");
         match args {
             syn::PathArguments::AngleBracketed(args) => {
-                let arg = args.args.first().ok_or(syn::Error::new(
-                    args.span(),
-                    "Return type should be Result<Option<_>>",
-                ))?;
+                let arg = args
+                    .args
+                    .first()
+                    .ok_or(syn::Error::new(args.span(), error_message.clone()))?;
                 match arg {
                     syn::GenericArgument::Type(tp) => match tp {
                         Type::Path(tp) => {
@@ -231,55 +250,39 @@ impl NativeService {
                                 tp.span(),
                                 "Return type should be Result<Option<_>>",
                             ))?;
-                            if seg.ident.to_string() == "Option" {
+                            if seg.ident.to_string() == type_to_extract {
                                 let args = &seg.arguments;
-                                Self::get_type_for_deserialize_from_result_args(args)
+                                Ok(args.clone())
                             } else {
-                                Err(syn::Error::new(
-                                    seg.span(),
-                                    "Return type should be Result<Option<_>>",
-                                ))
+                                Err(syn::Error::new(seg.span(), error_message.clone()))
                             }
                         }
-                        _ => Err(syn::Error::new(
-                            arg.span(),
-                            "Return type should be Result<Option<_>>",
-                        )),
+                        _ => Err(syn::Error::new(arg.span(), error_message.clone())),
                     },
-                    _ => Err(syn::Error::new(
-                        arg.span(),
-                        "Return type should be Result<<Option<_>>",
-                    )),
+                    _ => Err(syn::Error::new(arg.span(), error_message.clone())),
                 }
             }
-            _ => Err(syn::Error::new(
-                args.span(),
-                "Return type should be Result<_>",
-            )),
+            _ => Err(syn::Error::new(args.span(), error_message.clone())),
         }
     }
 
     fn get_type_for_deserialize_from_result_args(
         args: &PathArguments,
+        expected_type: &str,
     ) -> syn::Result<NativeOutputParams> {
+        let error_message = format!("Return type should be {expected_type}");
         match args {
             syn::PathArguments::AngleBracketed(args) => {
-                let arg = args.args.first().ok_or(syn::Error::new(
-                    args.span(),
-                    "Return type should be Result<_>",
-                ))?;
+                let arg = args
+                    .args
+                    .first()
+                    .ok_or(syn::Error::new(args.span(), error_message.clone()))?;
                 match arg {
                     syn::GenericArgument::Type(tp) => Self::get_type_from_possible_dyn_type(tp),
-                    _ => Err(syn::Error::new(
-                        arg.span(),
-                        "Return type should be Result<_>",
-                    )),
+                    _ => Err(syn::Error::new(arg.span(), error_message.clone())),
                 }
             }
-            _ => Err(syn::Error::new(
-                args.span(),
-                "Return type should be Result<_>",
-            )),
+            _ => Err(syn::Error::new(args.span(), error_message.clone())),
         }
     }
 
@@ -297,22 +300,26 @@ impl NativeService {
                     || ident.to_string() == "Box"
                 {
                     if let Some(dyn_path) = Self::get_dyn_type_for_deserialize(&seg.arguments) {
+                        let original_type = tp.path.clone();
                         let mut dynamic_container_path = tp.path.clone();
                         let last_seg = dynamic_container_path.segments.last_mut().unwrap();
                         last_seg.arguments = syn::PathArguments::None;
                         Ok(NativeOutputParams {
                             type_path: dyn_path,
+                            original_type,
                             dynamic_container_path: Some(dynamic_container_path),
                         })
                     } else {
                         Ok(NativeOutputParams {
                             type_path: tp.path.clone(),
+                            original_type: tp.path.clone(),
                             dynamic_container_path: None,
                         })
                     }
                 } else {
                     Ok(NativeOutputParams {
                         type_path: tp.path.clone(),
+                        original_type: tp.path.clone(),
                         dynamic_container_path: None,
                     })
                 }
@@ -524,7 +531,7 @@ impl NativeMethod {
             .collect::<Vec<_>>();
         let js_method_name = self.camel_case_name();
 
-        let deseralization = Self::deserialization_impl(&output_params);
+        let deseralization = Self::deserialization_impl(&output_params, method_params.is_vec);
 
         match method_params.method_type {
             NativeMethodType::Call => {
@@ -607,10 +614,15 @@ impl NativeMethod {
         }
     }
 
-    fn deserialization_impl(output_params: &NativeOutputParams) -> proc_macro2::TokenStream {
+    fn deserialization_impl(
+        output_params: &NativeOutputParams,
+        is_vec: bool,
+    ) -> proc_macro2::TokenStream {
         let output_type = &output_params.type_path;
 
-        if let Some(dynamic_container_path) = &output_params.dynamic_container_path {
+        let single_deserialization = if let Some(dynamic_container_path) =
+            &output_params.dynamic_container_path
+        {
             quote! {
                 #dynamic_container_path::new(NativeDeserializer::deserialize::<IT, #output_type<IT>>(res)?)
             }
@@ -618,6 +630,18 @@ impl NativeMethod {
             quote! {
                 NativeDeserializer::deserialize::<IT, #output_type>(res)?
             }
+        };
+
+        if is_vec {
+            let original_type = &output_params.original_type;
+            quote! {
+                res.into_array()?.to_vec()?.into_iter().map(|res| -> Result<#original_type, CubeError> {
+                    let r = #single_deserialization;
+                    Ok(r)
+                }).collect::<Result<Vec<_>, _>>()?
+            }
+        } else {
+            single_deserialization
         }
     }
 

From 5024e1aaf9b8fe4c61fd80f2bf5110c1a05723b1 Mon Sep 17 00:00:00 2001
From: Alexandr Romanenko <alex.romanenko@cube.dev>
Date: Wed, 22 Jan 2025 13:42:08 +0100
Subject: [PATCH 08/16] update

---
 "rust/cubesqlplanner/\\" | 85 ----------------------------------------
 1 file changed, 85 deletions(-)
 delete mode 100644 "rust/cubesqlplanner/\\"

diff --git "a/rust/cubesqlplanner/\\" "b/rust/cubesqlplanner/\\"
deleted file mode 100644
index f3a8f6ae1f3be..0000000000000
--- "a/rust/cubesqlplanner/\\"
+++ /dev/null
@@ -1,85 +0,0 @@
-use crate::cube_bridge::join_hints::JoinHintItem;
-use crate::planner::sql_evaluator::{MemberSymbol, TraversalVisitor};
-use crate::planner::BaseMeasure;
-use cubenativeutils::CubeError;
-use std::rc::Rc;
-
-pub struct JoinHintsCollector {
-    hints: Vec<JoinHintItem>,
-}
-
-impl JoinHintsCollector {
-    pub fn new() -> Self {
-        Self { hints: Vec::new() }
-    }
-
-    pub fn extract_result(self) -> Vec<JoinHintItem> {
-        self.hints
-    }
-}
-
-impl TraversalVisitor for JoinHintsCollector {
-    type State = ();
-    fn on_node_traverse(
-        &mut self,
-        node: &Rc<MemberSymbol>,
-        path: &Vec<String>,
-        _: &Self::State,
-    ) -> Result<Option<Self::State>, CubeError> {
-        match node.as_ref() {
-            MemberSymbol::Dimension(e) => {
-                if e.owned_by_cube() {
-                    if !path.is_empty() {
-                        if path.len() == 1 {
-                            self.hints.push(JoinHintItem::Single(path[0].clone()))
-                        } else {
-                            self.hints.push(JoinHintItem::Vector(path.clone()))
-                        }
-                    }
-                }
-                if e.is_sub_query() {
-                    return Ok(None);
-                }
-            }
-            MemberSymbol::TimeDimension(e) => return self.on_node_traverse(e.base_symbol(), path, &()),
-            MemberSymbol::Measure(e) => {
-                if e.owned_by_cube() {
-                    self.hints.push(JoinHintItem::Single(e.cube_name().clone()));
-                }
-                for name in e.get_dependent_cubes().into_iter() {
-                    self.hints.push(JoinHintItem::Single(name));
-                }
-            }
-            MemberSymbol::CubeName(e) => {
-                self.hints.push(JoinHintItem::Single(e.cube_name().clone()));
-            }
-            MemberSymbol::CubeTable(e) => {
-                self.hints.push(JoinHintItem::Single(e.cube_name().clone()));
-            }
-            MemberSymbol::SqlCall(s) => {
-                for name in s.get_dependent_cubes().into_iter() {
-                    self.hints.push(JoinHintItem::Single(name));
-                }
-            }
-        };
-        Ok(Some(()))
-    }
-}
-
-pub fn collect_join_hints(node: &Rc<MemberSymbol>) -> Result<Vec<JoinHintItem>, CubeError> {
-    let mut visitor = JoinHintsCollector::new();
-    visitor.apply(node, &())?;
-    let res = visitor.extract_result();
-    Ok(res)
-}
-
-pub fn collect_join_hints_for_measures(
-    measures: &Vec<Rc<BaseMeasure>>,
-) -> Result<Vec<JoinHintItem>, CubeError> {
-    let mut visitor = JoinHintsCollector::new();
-    for meas in measures.iter() {
-        visitor.apply(&meas.member_evaluator(), &())?;
-    }
-    let res = visitor.extract_result();
-    Ok(res)
-}

From 8e21e1d31acbdca1c5c4256c2ae62defb22084b9 Mon Sep 17 00:00:00 2001
From: Alexandr Romanenko <alex.romanenko@cube.dev>
Date: Wed, 22 Jan 2025 14:48:12 +0100
Subject: [PATCH 09/16] sql utils

---
 packages/cubejs-schema-compiler/src/adapter/BaseQuery.js | 6 ++++++
 .../cubejs-schema-compiler/src/compiler/CubeSymbols.js   | 6 +++++-
 .../cubesqlplanner/src/cube_bridge/base_tools.rs         | 2 ++
 .../cubesqlplanner/src/cube_bridge/member_sql.rs         | 8 ++++++++
 .../cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs | 1 +
 .../cubesqlplanner/src/cube_bridge/sql_utils.rs          | 9 +++++++++
 .../src/planner/sql_evaluator/dependecy.rs               | 2 ++
 .../cubesqlplanner/src/planner/sql_evaluator/sql_call.rs | 3 +++
 8 files changed, 36 insertions(+), 1 deletion(-)
 create mode 100644 rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/sql_utils.rs

diff --git a/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js b/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
index fac5e4bbc976c..e9c3d72e16e63 100644
--- a/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
+++ b/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
@@ -3805,6 +3805,12 @@ export class BaseQuery {
     return this.contextSymbolsProxy(this.contextSymbols.securityContext);
   }
 
+  sqlUtilsForRust() {
+    return {
+      convertTz: this.convertTz.bind(this)
+    };
+  }
+
   contextSymbolsProxy(symbols) {
     return BaseQuery.contextSymbolsProxyFrom(symbols, this.paramAllocator.allocateParam.bind(this.paramAllocator));
   }
diff --git a/packages/cubejs-schema-compiler/src/compiler/CubeSymbols.js b/packages/cubejs-schema-compiler/src/compiler/CubeSymbols.js
index e8c59a8fb2972..0efdc4dcf45a2 100644
--- a/packages/cubejs-schema-compiler/src/compiler/CubeSymbols.js
+++ b/packages/cubejs-schema-compiler/src/compiler/CubeSymbols.js
@@ -609,7 +609,11 @@ export class CubeSymbols {
     return Object.assign({
       filterParams: this.filtersProxyDep(),
       filterGroup: this.filterGroupFunctionDep(),
-      securityContext: BaseQuery.contextSymbolsProxyFrom({}, (param) => param)
+      securityContext: BaseQuery.contextSymbolsProxyFrom({}, (param) => param),
+      sqlUtils: {
+        convertTz: (f) => f
+
+      },
     });
   }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
index 08accd8e6d776..d313e0608fa0a 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
@@ -3,6 +3,7 @@ use super::filter_params::{FilterParams, NativeFilterParams};
 use super::member_sql::{MemberSql, NativeMemberSql};
 use super::security_context::{NativeSecurityContext, SecurityContext};
 use super::sql_templates_render::{NativeSqlTemplatesRender, SqlTemplatesRender};
+use super::sql_utils::{NativeSqlUtils, SqlUtils};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
@@ -34,6 +35,7 @@ pub trait BaseTools {
         sql: Rc<dyn MemberSql>,
     ) -> Result<Vec<CallDep>, CubeError>;
     fn security_context_for_rust(&self) -> Result<Rc<dyn SecurityContext>, CubeError>;
+    fn sql_utils_for_rust(&self) -> Result<Rc<dyn SqlUtils>, CubeError>;
     fn filters_proxy(&self) -> Result<Rc<dyn FilterParams>, CubeError>;
     fn filter_group_function(&self) -> Result<Rc<dyn FilterGroup>, CubeError>;
     fn timestamp_precision(&self) -> Result<u32, CubeError>;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_sql.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_sql.rs
index 0cb0d8d869f2e..1883d75b53c6f 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_sql.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_sql.rs
@@ -2,6 +2,7 @@ use super::{
     filter_group::{FilterGroup, NativeFilterGroup},
     filter_params::{FilterParams, NativeFilterParams},
     security_context::{NativeSecurityContext, SecurityContext},
+    sql_utils::{NativeSqlUtils, SqlUtils},
 };
 use cubenativeutils::wrappers::inner_types::InnerTypes;
 use cubenativeutils::wrappers::object::{NativeFunction, NativeStruct, NativeType};
@@ -24,6 +25,7 @@ pub struct MemberSqlStruct {
 
 pub enum ContextSymbolArg {
     SecurityContext(Rc<dyn SecurityContext>),
+    SqlUtils(Rc<dyn SqlUtils>),
     FilterParams(Rc<dyn FilterParams>),
     FilterGroup(Rc<dyn FilterGroup>),
 }
@@ -115,6 +117,12 @@ impl<IT: InnerTypes> NativeSerialize<IT> for MemberSqlArg {
                     .downcast::<NativeSecurityContext<IT>>()
                     .unwrap()
                     .to_native(context_holder.clone()),
+                ContextSymbolArg::SqlUtils(context) => context
+                    .clone()
+                    .as_any()
+                    .downcast::<NativeSqlUtils<IT>>()
+                    .unwrap()
+                    .to_native(context_holder.clone()),
                 ContextSymbolArg::FilterParams(params) => params
                     .clone()
                     .as_any()
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs
index 46c0f15fe11c8..6fa12c63c418c 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs
@@ -20,3 +20,4 @@ pub mod member_sql;
 pub mod options_member;
 pub mod security_context;
 pub mod sql_templates_render;
+pub mod sql_utils;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/sql_utils.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/sql_utils.rs
new file mode 100644
index 0000000000000..84d78dd137e34
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/sql_utils.rs
@@ -0,0 +1,9 @@
+use cubenativeutils::wrappers::serializer::{NativeDeserialize, NativeSerialize};
+use cubenativeutils::wrappers::NativeContextHolder;
+use cubenativeutils::wrappers::NativeObjectHandle;
+use cubenativeutils::CubeError;
+use std::any::Any;
+use std::rc::Rc;
+
+#[nativebridge::native_bridge]
+pub trait SqlUtils {}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs
index ee48bb0184b72..b1c69f57230b1 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs
@@ -41,6 +41,7 @@ pub enum ContextSymbolDep {
     SecurityContext,
     FilterParams,
     FilterGroup,
+    SqlUtils,
 }
 
 #[derive(Clone)]
@@ -168,6 +169,7 @@ impl<'a> DependenciesBuilder<'a> {
                 ContextSymbolDep::FilterParams,
             )),
             "FILTER_GROUP" => Some(Dependency::ContextDependency(ContextSymbolDep::FilterGroup)),
+            "SQL_UTILS" => Some(Dependency::ContextDependency(ContextSymbolDep::SqlUtils)),
             _ => None,
         }
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs
index 100e44e86bd83..63a9a906f4805 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs
@@ -223,6 +223,9 @@ impl SqlCall {
             ContextSymbolDep::FilterGroup => MemberSqlArg::ContextSymbol(
                 ContextSymbolArg::FilterGroup(query_tools.base_tools().filter_group_function()?),
             ),
+            ContextSymbolDep::SqlUtils => MemberSqlArg::ContextSymbol(ContextSymbolArg::SqlUtils(
+                query_tools.base_tools().sql_utils_for_rust()?,
+            )),
         };
         Ok(res)
     }

From 68717acafea690a00b916d243c5cc050d9c099ec Mon Sep 17 00:00:00 2001
From: Alexandr Romanenko <alex.romanenko@cube.dev>
Date: Wed, 22 Jan 2025 19:01:19 +0100
Subject: [PATCH 10/16] 8 tests remaining

---
 .../postgres/sql-generation.test.ts           |  7 ++++---
 .../src/cube_bridge/base_tools.rs             |  5 +++++
 .../src/planner/base_measure.rs               |  2 +-
 .../planner/planners/multi_stage/member.rs    |  7 +++++++
 .../multi_stage/member_query_planner.rs       |  3 +++
 .../planners/multi_stage_query_planner.rs     |  5 +++++
 .../sql_evaluator/sql_nodes/factory.rs        | 12 ++++++++++-
 .../sql_evaluator/sql_nodes/final_measure.rs  |  9 +++++++++
 .../sql_evaluator/sql_nodes/rolling_window.rs | 20 +++++++++++--------
 9 files changed, 57 insertions(+), 13 deletions(-)

diff --git a/packages/cubejs-schema-compiler/test/integration/postgres/sql-generation.test.ts b/packages/cubejs-schema-compiler/test/integration/postgres/sql-generation.test.ts
index 03740b7088b68..86184d058e311 100644
--- a/packages/cubejs-schema-compiler/test/integration/postgres/sql-generation.test.ts
+++ b/packages/cubejs-schema-compiler/test/integration/postgres/sql-generation.test.ts
@@ -945,8 +945,6 @@ describe('SQL Generation', () => {
       timezone: 'America/Los_Angeles'
     });
 
-    console.log(query.buildSqlAndParams());
-
     expect(query.buildSqlAndParams()[0]).toMatch(/HLL_COUNT\.MERGE/);
     expect(query.buildSqlAndParams()[0]).toMatch(/HLL_COUNT\.INIT/);
   });
@@ -971,7 +969,7 @@ describe('SQL Generation', () => {
 
     console.log(query.buildSqlAndParams());
 
-    expect(query.buildSqlAndParams()[0]).toMatch(/OFFSET (\d) LIMIT (\d)/);
+    expect(query.buildSqlAndParams()[0]).toMatch(/OFFSET (\d)\s+LIMIT (\d)/);
   });
 
   it('calculated join', async () => {
@@ -2535,6 +2533,9 @@ describe('SQL Generation', () => {
 
       const sqlBuild = query.buildSqlAndParams();
 
+      console.log(sqlBuild[0]);
+      console.log(sqlBuild[1]);
+
       expect(sqlBuild[0].includes('America/Los_Angeles')).toEqual(true);
       expect(sqlBuild[1][0]).toEqual(granularityTest.from);
       expect(sqlBuild[1][1]).toEqual(granularityTest.to);
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
index d313e0608fa0a..0ccc1567be747 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
@@ -47,4 +47,9 @@ pub trait BaseTools {
     ) -> Result<Vec<Vec<String>>, CubeError>;
     fn get_allocated_params(&self) -> Result<Vec<String>, CubeError>;
     fn all_cube_members(&self, path: String) -> Result<Vec<String>, CubeError>;
+    //===== TODO Move to templates
+    fn hll_init(&self, sql: String) -> Result<String, CubeError>;
+    fn hll_merge(&self, sql: String) -> Result<String, CubeError>;
+    fn hll_cardinality_merge(&self, sql: String) -> Result<String, CubeError>;
+    fn count_distinct_approx(&self, sql: String) -> Result<String, CubeError>;
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
index 05bd9310d765b..4a1941e806842 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
@@ -200,7 +200,7 @@ impl BaseMeasure {
 
     pub fn can_used_as_addictive_in_multplied(&self) -> Result<bool, CubeError> {
         let measure_type = self.measure_type();
-        let res = if measure_type == "countDistinct" {
+        let res = if measure_type == "countDistinct" || measure_type == "countDistinctApprox" {
             true
         } else if measure_type == "count" {
             if let Some(definition) = &self.definition {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member.rs
index 1801c2538e3d8..de7b566469b72 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member.rs
@@ -186,6 +186,7 @@ pub struct MultiStageMember {
     member_type: MultiStageMemberType,
     evaluation_node: Rc<MemberSymbol>,
     is_ungrupped: bool,
+    has_aggregates_on_top: bool,
 }
 
 impl MultiStageMember {
@@ -193,11 +194,13 @@ impl MultiStageMember {
         member_type: MultiStageMemberType,
         evaluation_node: Rc<MemberSymbol>,
         is_ungrupped: bool,
+        has_aggregates_on_top: bool,
     ) -> Rc<Self> {
         Rc::new(Self {
             member_type,
             evaluation_node,
             is_ungrupped,
+            has_aggregates_on_top,
         })
     }
 
@@ -216,4 +219,8 @@ impl MultiStageMember {
     pub fn is_ungrupped(&self) -> bool {
         self.is_ungrupped
     }
+
+    pub fn has_aggregates_on_top(&self) -> bool {
+        self.has_aggregates_on_top
+    }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs
index b717371719ce0..c673c91fab748 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member_query_planner.rs
@@ -384,6 +384,9 @@ impl MultiStageMemberQueryPlanner {
 
         let mut node_factory = SqlNodesFactory::new();
         node_factory.set_time_shifts(self.description.state().time_shifts().clone());
+        if self.description.member().has_aggregates_on_top() {
+            node_factory.set_count_approx_as_state(true);
+        }
 
         if cte_query_properties
             .full_key_aggregate_measures()?
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage_query_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage_query_planner.rs
index 6404ca37b469d..0a9218832cc63 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage_query_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage_query_planner.rs
@@ -173,6 +173,7 @@ impl MultiStageQueryPlanner {
                         )),
                         time_dimension.member_evaluator(),
                         true,
+                        false,
                     ),
                     state.clone(),
                     vec![],
@@ -196,6 +197,7 @@ impl MultiStageQueryPlanner {
                 MultiStageMemberType::Leaf(MultiStageLeafMemberType::Measure),
                 member,
                 self.query_properties.ungrouped(),
+                true,
             ),
             state,
             vec![],
@@ -336,6 +338,7 @@ impl MultiStageQueryPlanner {
                         MultiStageMemberType::Inode(inode_member),
                         member,
                         self.query_properties.ungrouped(),
+                        false,
                     ),
                     state.clone(),
                     input,
@@ -386,6 +389,7 @@ impl MultiStageQueryPlanner {
                     MultiStageMemberType::Leaf(MultiStageLeafMemberType::Measure),
                     member.clone(),
                     self.query_properties.ungrouped(),
+                    false,
                 ),
                 state.clone(),
                 vec![],
@@ -435,6 +439,7 @@ impl MultiStageQueryPlanner {
                     MultiStageMemberType::Inode(multi_stage_member),
                     member,
                     is_ungrupped,
+                    false,
                 ),
                 state.clone(),
                 input,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs
index a341aad761d9d..0c3d4b727f7c0 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/factory.rs
@@ -13,6 +13,7 @@ pub struct SqlNodesFactory {
     time_shifts: HashMap<String, String>,
     ungrouped: bool,
     ungrouped_measure: bool,
+    count_approx_as_state: bool,
     render_references: HashMap<String, QualifiedColumnName>,
     rendered_as_multiplied_measures: HashSet<String>,
     ungrouped_measure_references: HashMap<String, QualifiedColumnName>,
@@ -28,6 +29,7 @@ impl SqlNodesFactory {
             time_shifts: HashMap::new(),
             ungrouped: false,
             ungrouped_measure: false,
+            count_approx_as_state: false,
             render_references: HashMap::new(),
             ungrouped_measure_references: HashMap::new(),
             cube_name_references: HashMap::new(),
@@ -78,6 +80,10 @@ impl SqlNodesFactory {
         self.rolling_window = value;
     }
 
+    pub fn set_count_approx_as_state(&mut self, value: bool) {
+        self.count_approx_as_state = value;
+    }
+
     pub fn set_ungrouped_measure_references(
         &mut self,
         value: HashMap<String, QualifiedColumnName>,
@@ -161,7 +167,11 @@ impl SqlNodesFactory {
         } else if self.rolling_window {
             RollingWindowNode::new(input)
         } else {
-            FinalMeasureSqlNode::new(input, self.rendered_as_multiplied_measures.clone())
+            FinalMeasureSqlNode::new(
+                input,
+                self.rendered_as_multiplied_measures.clone(),
+                self.count_approx_as_state,
+            )
         }
     }
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/final_measure.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/final_measure.rs
index 8a39e43ee6872..2f3644afc48b3 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/final_measure.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/final_measure.rs
@@ -12,16 +12,19 @@ use std::rc::Rc;
 pub struct FinalMeasureSqlNode {
     input: Rc<dyn SqlNode>,
     rendered_as_multiplied_measures: HashSet<String>,
+    count_approx_as_state: bool,
 }
 
 impl FinalMeasureSqlNode {
     pub fn new(
         input: Rc<dyn SqlNode>,
         rendered_as_multiplied_measures: HashSet<String>,
+        count_approx_as_state: bool,
     ) -> Rc<Self> {
         Rc::new(Self {
             input,
             rendered_as_multiplied_measures,
+            count_approx_as_state,
         })
     }
 
@@ -60,6 +63,12 @@ impl SqlNode for FinalMeasureSqlNode {
 
                 if ev.is_calculated() {
                     input
+                } else if ev.measure_type() == "countDistinctApprox" {
+                    if self.count_approx_as_state {
+                        query_tools.base_tools().hll_init(input)?
+                    } else {
+                        query_tools.base_tools().count_distinct_approx(input)?
+                    }
                 } else if self.is_count_disttinct(ev) {
                     templates.count_distinct(&input)?
                 } else {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/rolling_window.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/rolling_window.rs
index 288375a67a8a5..18e14c93dcb2c 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/rolling_window.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/rolling_window.rs
@@ -39,16 +39,20 @@ impl SqlNode for RollingWindowNode {
                     templates,
                 )?;
                 if m.is_cumulative() {
-                    let aggregate_function = if m.measure_type() == "sum"
-                        || m.measure_type() == "count"
-                        || m.measure_type() == "runningTotal"
-                    {
-                        "sum"
+                    if m.measure_type() == "countDistinctApprox" {
+                        query_tools.base_tools().hll_cardinality_merge(input)?
                     } else {
-                        m.measure_type()
-                    };
+                        let aggregate_function = if m.measure_type() == "sum"
+                            || m.measure_type() == "count"
+                            || m.measure_type() == "runningTotal"
+                        {
+                            "sum"
+                        } else {
+                            m.measure_type()
+                        };
 
-                    format!("{}({})", aggregate_function, input)
+                        format!("{}({})", aggregate_function, input)
+                    }
                 } else {
                     input
                 }

From 43b242fd7a94fe341f10eae4fbacaf4692615b85 Mon Sep 17 00:00:00 2001
From: Alexandr Romanenko <alex.romanenko@cube.dev>
Date: Wed, 22 Jan 2025 19:50:01 +0100
Subject: [PATCH 11/16] pass errors to js

---
 .../cubejs-backend-native/src/node_export.rs  |  3 +-
 .../src/adapter/BaseQuery.js                  | 12 +++++-
 rust/cubenativeutils/src/lib.rs               |  2 +-
 .../cubesqlplanner/src/planner/base_query.rs  | 40 +++++++++++++++++--
 4 files changed, 51 insertions(+), 6 deletions(-)

diff --git a/packages/cubejs-backend-native/src/node_export.rs b/packages/cubejs-backend-native/src/node_export.rs
index 5d4eb733206c6..4b25a44ef6555 100644
--- a/packages/cubejs-backend-native/src/node_export.rs
+++ b/packages/cubejs-backend-native/src/node_export.rs
@@ -466,6 +466,7 @@ fn build_sql_and_params(cx: FunctionContext) -> JsResult<JsValue> {
     //context should be used only inside function
     let mut cx = extend_function_context_lifetime(cx);
     let options = cx.argument::<JsValue>(0)?;
+    let options_tmp = options.clone();
 
     let neon_context_holder = ContextHolder::new(cx);
 
@@ -483,7 +484,7 @@ fn build_sql_and_params(cx: FunctionContext) -> JsResult<JsValue> {
     let base_query = BaseQuery::try_new(context_holder.clone(), base_query_options).unwrap();
 
     //arg_clrep.into_js(&mut cx)
-    let res = base_query.build_sql_and_params().unwrap();
+    let res = base_query.build_sql_and_params();
 
     let result: NeonObject<'static, FunctionContext<'static>> = res.into_object();
     let result = result.into_object();
diff --git a/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js b/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
index e9c3d72e16e63..f452d904655ed 100644
--- a/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
+++ b/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
@@ -654,7 +654,17 @@ export class BaseQuery {
       ungrouped: this.options.ungrouped
 
     };
-    const res = nativeBuildSqlAndParams(queryParams);
+    const buildResult = nativeBuildSqlAndParams(queryParams);
+
+    if (buildResult.error) {
+      if (buildResult.error.cause && buildResult.error.cause === 'User') {
+        throw new UserError(buildResult.error.message);
+      } else {
+        throw new Error(buildResult.error.message);
+      }
+    }
+
+    const res = buildResult.result;
     // FIXME
     res[1] = [...res[1]];
     return res;
diff --git a/rust/cubenativeutils/src/lib.rs b/rust/cubenativeutils/src/lib.rs
index cc20b75017d02..0e6c3b186707d 100644
--- a/rust/cubenativeutils/src/lib.rs
+++ b/rust/cubenativeutils/src/lib.rs
@@ -1,2 +1,2 @@
 pub mod wrappers;
-pub use cubesql::CubeError;
+pub use cubesql::{CubeError, CubeErrorCauseType};
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
index d9cc10ed41f40..304372f54ffdd 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
@@ -7,8 +7,8 @@ use cubenativeutils::wrappers::inner_types::InnerTypes;
 use cubenativeutils::wrappers::object::NativeArray;
 use cubenativeutils::wrappers::serializer::NativeSerialize;
 use cubenativeutils::wrappers::NativeType;
-use cubenativeutils::wrappers::{NativeContextHolder, NativeObjectHandle};
-use cubenativeutils::CubeError;
+use cubenativeutils::wrappers::{NativeContextHolder, NativeObjectHandle, NativeStruct};
+use cubenativeutils::{CubeError, CubeErrorCauseType};
 use std::rc::Rc;
 
 pub struct BaseQuery<IT: InnerTypes> {
@@ -38,7 +38,41 @@ impl<IT: InnerTypes> BaseQuery<IT> {
         })
     }
 
-    pub fn build_sql_and_params(&self) -> Result<NativeObjectHandle<IT>, CubeError> {
+    pub fn build_sql_and_params(&self) -> NativeObjectHandle<IT> {
+        let build_result = self.build_sql_and_params_impl();
+        let result = self.context.empty_struct();
+        match build_result {
+            Ok(res) => {
+                result.set_field("result", res).unwrap();
+            }
+            Err(e) => {
+                let error_descr = self.context.empty_struct();
+                let error_cause = match &e.cause {
+                    CubeErrorCauseType::User(_) => "User",
+                    CubeErrorCauseType::Internal(_) => "Internal",
+                };
+                error_descr
+                    .set_field(
+                        "message",
+                        e.message.to_native(self.context.clone()).unwrap(),
+                    )
+                    .unwrap();
+                error_descr
+                    .set_field(
+                        "cause",
+                        error_cause.to_native(self.context.clone()).unwrap(),
+                    )
+                    .unwrap();
+                result
+                    .set_field("error", NativeObjectHandle::new(error_descr.into_object()))
+                    .unwrap();
+            }
+        }
+
+        NativeObjectHandle::new(result.into_object())
+    }
+
+    fn build_sql_and_params_impl(&self) -> Result<NativeObjectHandle<IT>, CubeError> {
         let templates = PlanSqlTemplates::new(self.query_tools.templates_render());
         let query_planner = QueryPlanner::new(self.request.clone(), self.query_tools.clone());
         let plan = query_planner.plan()?;

From 4236c480fc54960b5d5ed4c0c1a7ffdcd955e75a Mon Sep 17 00:00:00 2001
From: Alexandr Romanenko <alex.romanenko@cube.dev>
Date: Wed, 22 Jan 2025 20:22:19 +0100
Subject: [PATCH 12/16] 100 tests

---
 .../cubesqlplanner/src/planner/base_member.rs          |  9 +--------
 .../planners/multiplied_measures_query_planner.rs      |  7 +++++--
 .../cubesqlplanner/src/planner/query_tools.rs          | 10 ++++++++++
 3 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
index 0ae0b8a40f296..831e1081812ae 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
@@ -54,14 +54,7 @@ impl BaseMemberHelper {
         member_suffix: &Option<String>,
         query_tools: Rc<QueryTools>,
     ) -> Result<String, CubeError> {
-        let cube_definition = query_tools
-            .cube_evaluator()
-            .cube_from_path(cube_name.clone())?;
-        let cube_alias = if let Some(sql_alias) = &cube_definition.static_data().sql_alias {
-            sql_alias
-        } else {
-            cube_name
-        };
+        let cube_alias = query_tools.alias_for_cube(cube_name)?;
         Ok(PlanSqlTemplates::memeber_alias_name(
             &cube_alias,
             &member_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
index cce7bfa7c2aa1..a4508220dff50 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multiplied_measures_query_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multiplied_measures_query_planner.rs
@@ -136,7 +136,7 @@ impl MultipliedMeasuresQueryPlanner {
 
         let pk_cube = self.common_utils.cube_from_path(key_cube_name.clone())?;
         let pk_cube_alias =
-            pk_cube.default_alias_with_prefix(&Some(format!("{key_cube_name}_key")));
+            pk_cube.default_alias_with_prefix(&Some(format!("{}_key", pk_cube.default_alias())));
         let mut ungrouped_measure_references = HashMap::new();
         if should_build_join_for_measure_select {
             let subquery = self.aggregate_subquery_measure_join(
@@ -388,7 +388,10 @@ impl MultipliedMeasuresQueryPlanner {
         )?;
 
         let source = self.join_planner.make_join_node_impl(
-            &Some(format!("{}_key", key_cube_name)),
+            &Some(format!(
+                "{}_key",
+                self.query_tools.alias_for_cube(key_cube_name)?
+            )),
             key_join,
             &dimension_subquery_planner,
         )?;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_tools.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_tools.rs
index ff82a8221cf4b..e75372e7c4896 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_tools.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_tools.rs
@@ -229,6 +229,16 @@ impl QueryTools {
         }
     }
 
+    pub fn alias_for_cube(&self, cube_name: &String) -> Result<String, CubeError> {
+        let cube_definition = self.cube_evaluator().cube_from_path(cube_name.clone())?;
+        let res = if let Some(sql_alias) = &cube_definition.static_data().sql_alias {
+            sql_alias.clone()
+        } else {
+            cube_name.clone()
+        };
+        Ok(res)
+    }
+
     pub fn escape_column_name(&self, column_name: &str) -> String {
         format!("\"{}\"", column_name)
     }

From 889dc4d0fed0ae9fd57c5f312a487fcef3608827 Mon Sep 17 00:00:00 2001
From: Alexandr Romanenko <alex.romanenko@cube.dev>
Date: Fri, 24 Jan 2025 13:38:56 +0100
Subject: [PATCH 13/16] in work

---
 rust/cubenativeutils/src/wrappers/context.rs  |   3 +-
 .../src/wrappers/neon/context.rs              |   4 -
 .../src/wrappers/neon/object/base_types.rs    |  60 ++++++--
 .../src/wrappers/neon/object/mod.rs           | 130 ++++++++++++------
 .../src/wrappers/neon/object/neon_array.rs    |  49 +++----
 .../src/wrappers/neon/object/neon_function.rs |  19 +--
 .../src/wrappers/neon/object/neon_struct.rs   |  54 +++-----
 rust/cubenativeutils/src/wrappers/object.rs   |   4 +
 .../src/wrappers/object_handle.rs             |   1 -
 9 files changed, 187 insertions(+), 137 deletions(-)

diff --git a/rust/cubenativeutils/src/wrappers/context.rs b/rust/cubenativeutils/src/wrappers/context.rs
index 98bb3ba6f7eb9..cafa9d44f6d57 100644
--- a/rust/cubenativeutils/src/wrappers/context.rs
+++ b/rust/cubenativeutils/src/wrappers/context.rs
@@ -1,4 +1,4 @@
-use super::{inner_types::InnerTypes, object_handle::NativeObjectHandle};
+use super::{inner_types::InnerTypes, object::NativeBox, object_handle::NativeObjectHandle};
 
 pub trait NativeContext<IT: InnerTypes>: Clone {
     fn boolean(&self, v: bool) -> IT::Boolean;
@@ -7,6 +7,7 @@ pub trait NativeContext<IT: InnerTypes>: Clone {
     fn undefined(&self) -> NativeObjectHandle<IT>;
     fn empty_array(&self) -> IT::Array;
     fn empty_struct(&self) -> IT::Struct;
+    //fn boxed<T: 'static>(&self, value: T) -> impl NativeBox<IT, T>;
     fn to_string_fn(&self, result: String) -> IT::Function;
 }
 
diff --git a/rust/cubenativeutils/src/wrappers/neon/context.rs b/rust/cubenativeutils/src/wrappers/neon/context.rs
index 96950e5e3aedb..5a9bff155fba7 100644
--- a/rust/cubenativeutils/src/wrappers/neon/context.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/context.rs
@@ -64,10 +64,6 @@ impl<'cx, C: Context<'cx> + 'cx> ContextHolder<'cx, C> {
         context.with_context(f)
     }
 
-    /* pub fn as_native_context_holder(&self) -> NativeContextHolder {
-        NativeContextHolder::new(Box::new(self.clone()))
-    } */
-
     pub fn weak(&self) -> WeakContextHolder<'cx, C> {
         WeakContextHolder {
             context: Rc::downgrade(&self.context),
diff --git a/rust/cubenativeutils/src/wrappers/neon/object/base_types.rs b/rust/cubenativeutils/src/wrappers/neon/object/base_types.rs
index 26e58fc21f982..3f630cccbf8e8 100644
--- a/rust/cubenativeutils/src/wrappers/neon/object/base_types.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/object/base_types.rs
@@ -1,75 +1,107 @@
-use super::NeonObject;
+use super::{NeonObject, NeonTypeHandle};
 use crate::wrappers::neon::inner_types::NeonInnerTypes;
+use std::marker::PhantomData;
 
-use crate::wrappers::object::{NativeBoolean, NativeNumber, NativeString, NativeType};
+use crate::wrappers::object::{NativeBoolean, NativeBox, NativeNumber, NativeString, NativeType};
 use cubesql::CubeError;
 use neon::prelude::*;
+use std::ops::Deref;
 
 pub struct NeonString<'cx: 'static, C: Context<'cx>> {
-    object: NeonObject<'cx, C>,
+    object: NeonTypeHandle<'cx, C, JsString>,
 }
 
 impl<'cx, C: Context<'cx>> NeonString<'cx, C> {
-    pub fn new(object: NeonObject<'cx, C>) -> Self {
+    pub fn new(object: NeonTypeHandle<'cx, C, JsString>) -> Self {
         Self { object }
     }
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NativeType<NeonInnerTypes<'cx, C>> for NeonString<'cx, C> {
     fn into_object(self) -> NeonObject<'cx, C> {
-        self.object
+        self.object.upcast()
     }
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NativeString<NeonInnerTypes<'cx, C>> for NeonString<'cx, C> {
     fn value(&self) -> Result<String, CubeError> {
         self.object
-            .map_downcast_neon_object::<JsString, _, _>(|cx, object| Ok(object.value(cx)))
+            .map_neon_object::<_, _>(|cx, object| Ok(object.value(cx)))
     }
 }
 
 pub struct NeonNumber<'cx: 'static, C: Context<'cx>> {
-    object: NeonObject<'cx, C>,
+    object: NeonTypeHandle<'cx, C, JsNumber>,
 }
 
 impl<'cx, C: Context<'cx>> NeonNumber<'cx, C> {
-    pub fn new(object: NeonObject<'cx, C>) -> Self {
+    pub fn new(object: NeonTypeHandle<'cx, C, JsNumber>) -> Self {
         Self { object }
     }
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NativeType<NeonInnerTypes<'cx, C>> for NeonNumber<'cx, C> {
     fn into_object(self) -> NeonObject<'cx, C> {
-        self.object
+        self.object.upcast()
     }
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NativeNumber<NeonInnerTypes<'cx, C>> for NeonNumber<'cx, C> {
     fn value(&self) -> Result<f64, CubeError> {
         self.object
-            .map_downcast_neon_object::<JsNumber, _, _>(|cx, object| Ok(object.value(cx)))
+            .map_neon_object::<_, _>(|cx, object| Ok(object.value(cx)))
     }
 }
 
 pub struct NeonBoolean<'cx: 'static, C: Context<'cx>> {
-    object: NeonObject<'cx, C>,
+    object: NeonTypeHandle<'cx, C, JsBoolean>,
 }
 
 impl<'cx, C: Context<'cx>> NeonBoolean<'cx, C> {
-    pub fn new(object: NeonObject<'cx, C>) -> Self {
+    pub fn new(object: NeonTypeHandle<'cx, C, JsBoolean>) -> Self {
         Self { object }
     }
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NativeType<NeonInnerTypes<'cx, C>> for NeonBoolean<'cx, C> {
     fn into_object(self) -> NeonObject<'cx, C> {
-        self.object
+        self.object.upcast()
     }
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NativeBoolean<NeonInnerTypes<'cx, C>> for NeonBoolean<'cx, C> {
     fn value(&self) -> Result<bool, CubeError> {
         self.object
-            .map_downcast_neon_object::<JsBoolean, _, _>(|cx, object| Ok(object.value(cx)))
+            .map_neon_object::<_, _>(|cx, object| Ok(object.value(cx)))
+    }
+}
+
+pub struct NeonBox<'cx: 'static, C: Context<'cx>, T: 'static> {
+    object: NeonTypeHandle<'cx, C, JsBox<T>>,
+    _marker: PhantomData<T>,
+}
+
+impl<'cx: 'static, C: Context<'cx>, T: 'static> NeonBox<'cx, C, T> {
+    pub fn new(object: NeonTypeHandle<'cx, C, JsBox<T>>) -> Self {
+        Self {
+            object,
+            _marker: PhantomData::default(),
+        }
+    }
+}
+
+impl<'cx: 'static, C: Context<'cx> + 'cx, T: 'static> NativeType<NeonInnerTypes<'cx, C>>
+    for NeonBox<'cx, C, T>
+{
+    fn into_object(self) -> NeonObject<'cx, C> {
+        self.object.upcast()
+    }
+}
+
+impl<'cx: 'static, C: Context<'cx> + 'cx, T: 'static> NativeBox<NeonInnerTypes<'cx, C>, T>
+    for NeonBox<'cx, C, T>
+{
+    fn deref_value(&self) -> &T {
+        self.object.get_object_ref().deref()
     }
 }
diff --git a/rust/cubenativeutils/src/wrappers/neon/object/mod.rs b/rust/cubenativeutils/src/wrappers/neon/object/mod.rs
index 40763a228b97d..c08e0109ec871 100644
--- a/rust/cubenativeutils/src/wrappers/neon/object/mod.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/object/mod.rs
@@ -14,34 +14,43 @@ use crate::wrappers::{neon::context::ContextHolder, object::NativeObject};
 use cubesql::CubeError;
 use neon::prelude::*;
 
-pub struct NeonObject<'cx: 'static, C: Context<'cx>> {
+pub struct NeonTypeHandle<'cx, C: Context<'cx>, V: Value + 'cx> {
     context: ContextHolder<'cx, C>,
-    object: Handle<'cx, JsValue>,
+    object: Handle<'cx, V>,
 }
 
-impl<'cx: 'static, C: Context<'cx> + 'cx> NeonObject<'cx, C> {
-    pub fn new(context: ContextHolder<'cx, C>, object: Handle<'cx, JsValue>) -> Self {
+impl<'cx: 'static, C: Context<'cx> + 'cx, V: Value + 'cx> NeonTypeHandle<'cx, C, V> {
+    pub fn new(context: ContextHolder<'cx, C>, object: Handle<'cx, V>) -> Self {
         Self { context, object }
     }
 
-    pub fn get_object(&self) -> Handle<'cx, JsValue> {
+    fn get_context(&self) -> ContextHolder<'cx, C> {
+        self.context.clone()
+    }
+
+    pub fn get_object(&self) -> Handle<'cx, V> {
         self.object.clone()
     }
 
-    pub fn get_object_ref(&self) -> &Handle<'cx, JsValue> {
+    pub fn get_object_ref(&self) -> &Handle<'cx, V> {
         &self.object
     }
 
-    pub fn into_object(self) -> Handle<'cx, JsValue> {
+    pub fn into_object(self) -> Handle<'cx, V> {
         self.object
     }
 
+    pub fn upcast(&self) -> NeonObject<'cx, C> {
+        NeonObject::new(self.context.clone(), self.object.upcast())
+    }
+
     pub fn map_neon_object<T, F>(&self, f: F) -> T
     where
-        F: FnOnce(&mut C, &Handle<'cx, JsValue>) -> T,
+        F: FnOnce(&mut C, &Handle<'cx, V>) -> T,
     {
         self.context.with_context(|cx| f(cx, &self.object))
     }
+
     pub fn map_downcast_neon_object<JT: Value, T, F>(&self, f: F) -> Result<T, CubeError>
     where
         F: FnOnce(&mut C, &Handle<'cx, JT>) -> Result<T, CubeError>,
@@ -60,6 +69,63 @@ impl<'cx: 'static, C: Context<'cx> + 'cx> NeonObject<'cx, C> {
     }
 }
 
+impl<'cx: 'static, C: Context<'cx>, V: Value + 'cx> Clone for NeonTypeHandle<'cx, C, V> {
+    fn clone(&self) -> Self {
+        Self {
+            context: self.context.clone(),
+            object: self.object.clone(),
+        }
+    }
+}
+
+pub struct NeonObject<'cx: 'static, C: Context<'cx>> {
+    context: ContextHolder<'cx, C>,
+    object: Handle<'cx, JsValue>,
+}
+
+impl<'cx: 'static, C: Context<'cx> + 'cx> NeonObject<'cx, C> {
+    pub fn new(context: ContextHolder<'cx, C>, object: Handle<'cx, JsValue>) -> Self {
+        Self { context, object }
+    }
+
+    pub fn get_object(&self) -> Handle<'cx, JsValue> {
+        self.object.clone()
+    }
+
+    pub fn get_object_ref(&self) -> &Handle<'cx, JsValue> {
+        &self.object
+    }
+
+    pub fn into_object(self) -> Handle<'cx, JsValue> {
+        self.object
+    }
+
+    pub fn is_a<U: Value>(&self) -> bool {
+        self.context.with_context(|cx| self.object.is_a::<U, _>(cx))
+    }
+
+    pub fn downcast<U: Value>(&self) -> Result<NeonTypeHandle<'cx, C, U>, CubeError> {
+        let obj = self.context.with_context(|cx| {
+            self.object
+                .downcast::<U, _>(cx)
+                .map_err(|_| CubeError::internal("Downcast error".to_string()))
+        })?;
+        Ok(NeonTypeHandle::new(self.context.clone(), obj))
+    }
+
+    pub fn downcast_with_err_msg<U: Value>(
+        &self,
+        msg: &str,
+    ) -> Result<NeonTypeHandle<'cx, C, U>, CubeError> {
+        let obj = self.context.with_context(|cx| {
+            self.object
+                .downcast::<U, _>(cx)
+                .map_err(|_| CubeError::internal(msg.to_string()))
+        })?;
+        Ok(NeonTypeHandle::new(self.context.clone(), obj))
+    }
+}
+
 impl<'cx: 'static, C: Context<'cx> + 'cx> NativeObject<NeonInnerTypes<'cx, C>>
     for NeonObject<'cx, C>
 {
@@ -68,52 +134,28 @@ impl<'cx: 'static, C: Context<'cx> + 'cx> NativeObject<NeonInnerTypes<'cx, C>>
     }
 
     fn into_struct(self) -> Result<NeonStruct<'cx, C>, CubeError> {
-        if !self.is_a::<JsObject>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsObject"
-            )));
-        }
-        Ok(NeonStruct::new(self))
+        let obj = self.downcast_with_err_msg::<JsObject>("NeonObject is not the JsObject")?;
+        Ok(NeonStruct::new(obj))
     }
     fn into_function(self) -> Result<NeonFunction<'cx, C>, CubeError> {
-        if !self.is_a::<JsFunction>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsFunction"
-            )));
-        }
-        Ok(NeonFunction::new(self))
+        let obj = self.downcast_with_err_msg::<JsFunction>("NeonObject is not the JsArray")?;
+        Ok(NeonFunction::new(obj))
     }
     fn into_array(self) -> Result<NeonArray<'cx, C>, CubeError> {
-        if !self.is_a::<JsArray>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsArray"
-            )));
-        }
-        Ok(NeonArray::new(self))
+        let obj = self.downcast_with_err_msg::<JsArray>("NeonObject is not the JsArray")?;
+        Ok(NeonArray::new(obj))
     }
     fn into_string(self) -> Result<NeonString<'cx, C>, CubeError> {
-        if !self.is_a::<JsString>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsString"
-            )));
-        }
-        Ok(NeonString::new(self))
+        let obj = self.downcast_with_err_msg::<JsString>("NeonObject is not the JsString")?;
+        Ok(NeonString::new(obj))
     }
     fn into_number(self) -> Result<NeonNumber<'cx, C>, CubeError> {
-        if !self.is_a::<JsNumber>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsNumber"
-            )));
-        }
-        Ok(NeonNumber::new(self))
+        let obj = self.downcast_with_err_msg::<JsNumber>("NeonObject is not the JsNumber")?;
+        Ok(NeonNumber::new(obj))
     }
     fn into_boolean(self) -> Result<NeonBoolean<'cx, C>, CubeError> {
-        if !self.is_a::<JsBoolean>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsBoolean"
-            )));
-        }
-        Ok(NeonBoolean::<C>::new(self))
+        let obj = self.downcast_with_err_msg::<JsBoolean>("NeonObject is not the JsBoolean")?;
+        Ok(NeonBoolean::new(obj))
     }
 
     fn is_null(&self) -> bool {
diff --git a/rust/cubenativeutils/src/wrappers/neon/object/neon_array.rs b/rust/cubenativeutils/src/wrappers/neon/object/neon_array.rs
index dc06714227c61..4e6847d54bd09 100644
--- a/rust/cubenativeutils/src/wrappers/neon/object/neon_array.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/object/neon_array.rs
@@ -1,4 +1,4 @@
-use super::NeonObject;
+use super::{NeonObject, NeonTypeHandle};
 use crate::wrappers::{
     neon::inner_types::NeonInnerTypes,
     object::{NativeArray, NativeObject, NativeType},
@@ -9,38 +9,32 @@ use neon::prelude::*;
 
 #[derive(Clone)]
 pub struct NeonArray<'cx: 'static, C: Context<'cx>> {
-    object: NeonObject<'cx, C>,
+    object: NeonTypeHandle<'cx, C, JsArray>,
 }
 
-/* impl<C: Context<'static>> InnerTyped for NeonArray<C> {
-    type Inner = NeonObject<C>;
-} */
-
 impl<'cx, C: Context<'cx> + 'cx> NeonArray<'cx, C> {
-    pub fn new(object: NeonObject<'cx, C>) -> Self {
+    pub fn new(object: NeonTypeHandle<'cx, C, JsArray>) -> Self {
         Self { object }
     }
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NativeType<NeonInnerTypes<'cx, C>> for NeonArray<'cx, C> {
     fn into_object(self) -> NeonObject<'cx, C> {
-        self.object
+        self.object.upcast()
     }
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NativeArray<NeonInnerTypes<'cx, C>> for NeonArray<'cx, C> {
     fn len(&self) -> Result<u32, CubeError> {
         self.object
-            .map_downcast_neon_object::<JsArray, _, _>(|cx, object| Ok(object.len(cx)))
+            .map_neon_object::<_, _>(|cx, object| Ok(object.len(cx)))
     }
     fn to_vec(&self) -> Result<Vec<NativeObjectHandle<NeonInnerTypes<'cx, C>>>, CubeError> {
-        let neon_vec = self
-            .object
-            .map_downcast_neon_object::<JsArray, _, _>(|cx, object| {
-                object
-                    .to_vec(cx)
-                    .map_err(|_| CubeError::internal("Error converting JsArray to Vec".to_string()))
-            })?;
+        let neon_vec = self.object.map_neon_object::<_, _>(|cx, object| {
+            object
+                .to_vec(cx)
+                .map_err(|_| CubeError::internal("Error converting JsArray to Vec".to_string()))
+        })?;
 
         Ok(neon_vec
             .into_iter()
@@ -53,21 +47,18 @@ impl<'cx, C: Context<'cx> + 'cx> NativeArray<NeonInnerTypes<'cx, C>> for NeonArr
         value: NativeObjectHandle<NeonInnerTypes<'cx, C>>,
     ) -> Result<bool, CubeError> {
         let value = value.into_object().into_object();
-        self.object
-            .map_downcast_neon_object::<JsArray, _, _>(|cx, object| {
-                object
-                    .set(cx, index, value)
-                    .map_err(|_| CubeError::internal(format!("Error setting index {}", index)))
-            })
+        self.object.map_neon_object::<_, _>(|cx, object| {
+            object
+                .set(cx, index, value)
+                .map_err(|_| CubeError::internal(format!("Error setting index {}", index)))
+        })
     }
     fn get(&self, index: u32) -> Result<NativeObjectHandle<NeonInnerTypes<'cx, C>>, CubeError> {
-        let r = self
-            .object
-            .map_downcast_neon_object::<JsArray, _, _>(|cx, object| {
-                object
-                    .get(cx, index)
-                    .map_err(|_| CubeError::internal(format!("Error setting index {}", index)))
-            })?;
+        let r = self.object.map_neon_object::<_, _>(|cx, object| {
+            object
+                .get(cx, index)
+                .map_err(|_| CubeError::internal(format!("Error setting index {}", index)))
+        })?;
         Ok(NativeObjectHandle::new(NeonObject::new(
             self.object.get_context(),
             r,
diff --git a/rust/cubenativeutils/src/wrappers/neon/object/neon_function.rs b/rust/cubenativeutils/src/wrappers/neon/object/neon_function.rs
index c8fc68d372d50..6d6a4de881233 100644
--- a/rust/cubenativeutils/src/wrappers/neon/object/neon_function.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/object/neon_function.rs
@@ -1,4 +1,4 @@
-use super::NeonObject;
+use super::{NeonObject, NeonTypeHandle};
 use crate::wrappers::{
     neon::inner_types::NeonInnerTypes,
     object::{NativeFunction, NativeType},
@@ -11,18 +11,18 @@ use regex::Regex;
 
 #[derive(Clone)]
 pub struct NeonFunction<'cx: 'static, C: Context<'cx>> {
-    object: NeonObject<'cx, C>,
+    object: NeonTypeHandle<'cx, C, JsFunction>,
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NeonFunction<'cx, C> {
-    pub fn new(object: NeonObject<'cx, C>) -> Self {
+    pub fn new(object: NeonTypeHandle<'cx, C, JsFunction>) -> Self {
         Self { object }
     }
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NativeType<NeonInnerTypes<'cx, C>> for NeonFunction<'cx, C> {
     fn into_object(self) -> NeonObject<'cx, C> {
-        self.object
+        self.object.upcast()
     }
 }
 
@@ -36,11 +36,9 @@ impl<'cx, C: Context<'cx> + 'cx> NativeFunction<NeonInnerTypes<'cx, C>> for Neon
             .map(|arg| -> Result<_, CubeError> { Ok(arg.into_object().get_object()) })
             .collect::<Result<Vec<_>, _>>()?;
         let neon_reuslt = self.object.map_neon_object(|cx, neon_object| {
-            let this = neon_object
-                .downcast::<JsFunction, _>(cx)
-                .map_err(|_| CubeError::internal(format!("Neon object is not JsFunction")))?;
             let null = cx.null();
-            this.call(cx, null, neon_args)
+            neon_object
+                .call(cx, null, neon_args)
                 .map_err(|_| CubeError::internal(format!("Failed to call function ")))
         })?;
         Ok(NativeObjectHandle::new(NeonObject::new(
@@ -53,10 +51,7 @@ impl<'cx, C: Context<'cx> + 'cx> NativeFunction<NeonInnerTypes<'cx, C>> for Neon
         let result =
             self.object
                 .map_neon_object(|cx, neon_object| -> Result<String, CubeError> {
-                    let this = neon_object.downcast::<JsFunction, _>(cx).map_err(|_| {
-                        CubeError::internal(format!("Neon object is not JsFunction"))
-                    })?;
-                    let res = this
+                    let res = neon_object
                         .to_string(cx)
                         .map_err(|_| {
                             CubeError::internal(format!("Can't convert function to string"))
diff --git a/rust/cubenativeutils/src/wrappers/neon/object/neon_struct.rs b/rust/cubenativeutils/src/wrappers/neon/object/neon_struct.rs
index 693c19aeb1da3..869fc8ba6bf07 100644
--- a/rust/cubenativeutils/src/wrappers/neon/object/neon_struct.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/object/neon_struct.rs
@@ -1,4 +1,4 @@
-use super::NeonObject;
+use super::{NeonObject, NeonTypeHandle};
 use crate::wrappers::{
     neon::inner_types::NeonInnerTypes,
     object::{NativeStruct, NativeType},
@@ -9,18 +9,18 @@ use neon::prelude::*;
 
 #[derive(Clone)]
 pub struct NeonStruct<'cx: 'static, C: Context<'cx>> {
-    object: NeonObject<'cx, C>,
+    object: NeonTypeHandle<'cx, C, JsObject>,
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NeonStruct<'cx, C> {
-    pub fn new(object: NeonObject<'cx, C>) -> Self {
+    pub fn new(object: NeonTypeHandle<'cx, C, JsObject>) -> Self {
         Self { object }
     }
 }
 
 impl<'cx, C: Context<'cx> + 'cx> NativeType<NeonInnerTypes<'cx, C>> for NeonStruct<'cx, C> {
     fn into_object(self) -> NeonObject<'cx, C> {
-        self.object
+        self.object.upcast()
     }
 }
 
@@ -30,10 +30,8 @@ impl<'cx, C: Context<'cx> + 'cx> NativeStruct<NeonInnerTypes<'cx, C>> for NeonSt
         field_name: &str,
     ) -> Result<NativeObjectHandle<NeonInnerTypes<'cx, C>>, CubeError> {
         let neon_result = self.object.map_neon_object(|cx, neon_object| {
-            let this = neon_object
-                .downcast::<JsObject, _>(cx)
-                .map_err(|_| CubeError::internal(format!("Neon object is not JsObject")))?;
-            this.get::<JsValue, _, _>(cx, field_name)
+            neon_object
+                .get::<JsValue, _, _>(cx, field_name)
                 .map_err(|_| CubeError::internal(format!("Field `{}` not found", field_name)))
         })?;
         Ok(NativeObjectHandle::new(NeonObject::new(
@@ -46,10 +44,7 @@ impl<'cx, C: Context<'cx> + 'cx> NativeStruct<NeonInnerTypes<'cx, C>> for NeonSt
         let result = self
             .object
             .map_neon_object(|cx, neon_object| -> Result<bool, CubeError> {
-                let this = neon_object
-                    .downcast::<JsObject, _>(cx)
-                    .map_err(|_| CubeError::internal(format!("Neon object is not JsObject")))?;
-                let res = this
+                let res = neon_object
                     .get_opt::<JsValue, _, _>(cx, field_name)
                     .map_err(|_| {
                         CubeError::internal(format!(
@@ -69,21 +64,17 @@ impl<'cx, C: Context<'cx> + 'cx> NativeStruct<NeonInnerTypes<'cx, C>> for NeonSt
         value: NativeObjectHandle<NeonInnerTypes<'cx, C>>,
     ) -> Result<bool, CubeError> {
         let value = value.into_object().into_object();
-        self.object
-            .map_downcast_neon_object::<JsObject, _, _>(|cx, object| {
-                object
-                    .set(cx, field_name, value)
-                    .map_err(|_| CubeError::internal(format!("Error setting field {}", field_name)))
-            })
+        self.object.map_neon_object::<_, _>(|cx, object| {
+            object
+                .set(cx, field_name, value)
+                .map_err(|_| CubeError::internal(format!("Error setting field {}", field_name)))
+        })
     }
     fn get_own_property_names(
         &self,
     ) -> Result<Vec<NativeObjectHandle<NeonInnerTypes<'cx, C>>>, CubeError> {
         let neon_array = self.object.map_neon_object(|cx, neon_object| {
-            let this = neon_object
-                .downcast::<JsObject, _>(cx)
-                .map_err(|_| CubeError::internal(format!("Neon object is not JsObject")))?;
-            let neon_array = this
+            let neon_array = neon_object
                 .get_own_property_names(cx)
                 .map_err(|_| CubeError::internal(format!("Cannot get own properties not found")))?;
 
@@ -107,18 +98,17 @@ impl<'cx, C: Context<'cx> + 'cx> NativeStruct<NeonInnerTypes<'cx, C>> for NeonSt
             .collect::<Result<Vec<_>, _>>()?;
 
         let neon_reuslt = self.object.map_neon_object(|cx, neon_object| {
-            let this = neon_object
-                .downcast::<JsObject, _>(cx)
-                .map_err(|_| CubeError::internal(format!("Neon object is not JsObject")))?;
-            let neon_method = this
+            let neon_method = neon_object
                 .get::<JsFunction, _, _>(cx, method)
                 .map_err(|_| CubeError::internal(format!("Method `{}` not found", method)))?;
-            neon_method.call(cx, this, neon_args).map_err(|err| {
-                CubeError::internal(format!(
-                    "Failed to call method `{} {} {:?}",
-                    method, err, err
-                ))
-            })
+            neon_method
+                .call(cx, neon_object.clone(), neon_args)
+                .map_err(|err| {
+                    CubeError::internal(format!(
+                        "Failed to call method `{} {} {:?}",
+                        method, err, err
+                    ))
+                })
         })?;
         Ok(NativeObjectHandle::new(NeonObject::new(
             self.object.context.clone(),
diff --git a/rust/cubenativeutils/src/wrappers/object.rs b/rust/cubenativeutils/src/wrappers/object.rs
index bee3275ea3aac..d5f0efd6cec61 100644
--- a/rust/cubenativeutils/src/wrappers/object.rs
+++ b/rust/cubenativeutils/src/wrappers/object.rs
@@ -56,3 +56,7 @@ pub trait NativeNumber<IT: InnerTypes>: NativeType<IT> {
 pub trait NativeBoolean<IT: InnerTypes>: NativeType<IT> {
     fn value(&self) -> Result<bool, CubeError>;
 }
+
+pub trait NativeBox<IT: InnerTypes, T: 'static>: NativeType<IT> {
+    fn deref_value(&self) -> &T;
+}
diff --git a/rust/cubenativeutils/src/wrappers/object_handle.rs b/rust/cubenativeutils/src/wrappers/object_handle.rs
index 501c16e356be8..783c60606c4b6 100644
--- a/rust/cubenativeutils/src/wrappers/object_handle.rs
+++ b/rust/cubenativeutils/src/wrappers/object_handle.rs
@@ -61,7 +61,6 @@ impl<IT: InnerTypes> NativeObjectHandle<IT> {
     pub fn is_undefined(&self) -> bool {
         self.object.is_undefined()
     }
-
     pub fn get_context(&self) -> IT::Context {
         self.object.get_context()
     }

From 307e42bf70d9803299cdbfebb3fdc1610a0640eb Mon Sep 17 00:00:00 2001
From: Alexandr Romanenko <alex.romanenko@cube.dev>
Date: Fri, 24 Jan 2025 18:58:13 +0100
Subject: [PATCH 14/16] make safe context lifetime

---
 .../cubejs-backend-native/src/node_export.rs  |  45 ++---
 rust/cubenativeutils/src/wrappers/context.rs  |  29 +--
 .../src/wrappers/neon/context.rs              | 165 ++++++++----------
 .../src/wrappers/neon/inner_types.rs          |  26 +--
 .../src/wrappers/neon/object/base_types.rs    |  66 ++++---
 .../src/wrappers/neon/object/mod.rs           |  82 +++++----
 .../src/wrappers/neon/object/neon_array.rs    |  28 +--
 .../src/wrappers/neon/object/neon_function.rs |  22 +--
 .../src/wrappers/neon/object/neon_struct.rs   |  60 +++----
 rust/cubenativeutils/src/wrappers/object.rs   |   4 +-
 .../src/wrappers/object_handle.rs             |   4 +-
 .../src/wrappers/serializer/deserializer.rs   |   4 +-
 .../src/wrappers/serializer/error.rs          |   7 +
 .../src/wrappers/serializer/serializer.rs     |  38 ++--
 .../src/cube_bridge/member_sql.rs             |   6 +-
 .../cubesqlplanner/src/planner/base_query.rs  |   6 +-
 16 files changed, 287 insertions(+), 305 deletions(-)

diff --git a/packages/cubejs-backend-native/src/node_export.rs b/packages/cubejs-backend-native/src/node_export.rs
index 4b25a44ef6555..802076279c47d 100644
--- a/packages/cubejs-backend-native/src/node_export.rs
+++ b/packages/cubejs-backend-native/src/node_export.rs
@@ -18,7 +18,7 @@ use crate::stream::OnDrainHandler;
 use crate::tokio_runtime_node;
 use crate::transport::NodeBridgeTransport;
 use crate::utils::batch_to_rows;
-use cubenativeutils::wrappers::neon::context::ContextHolder;
+use cubenativeutils::wrappers::neon::context::neon_run_with_guarded_lifetime;
 use cubenativeutils::wrappers::neon::inner_types::NeonInnerTypes;
 use cubenativeutils::wrappers::neon::object::NeonObject;
 use cubenativeutils::wrappers::object_handle::NativeObjectHandle;
@@ -462,38 +462,29 @@ pub fn setup_logger(mut cx: FunctionContext) -> JsResult<JsUndefined> {
 //============ sql planner ===================
 
 fn build_sql_and_params(cx: FunctionContext) -> JsResult<JsValue> {
-    //IMPORTANT It seems to be safe here, because context lifetime is bound to function, but this
-    //context should be used only inside function
-    let mut cx = extend_function_context_lifetime(cx);
-    let options = cx.argument::<JsValue>(0)?;
-    let options_tmp = options.clone();
-
-    let neon_context_holder = ContextHolder::new(cx);
-
-    let options = NativeObjectHandle::<NeonInnerTypes<'static, FunctionContext<'static>>>::new(
-        NeonObject::new(neon_context_holder.clone(), options),
-    );
-
-    let context_holder =
-        NativeContextHolder::<NeonInnerTypes<'static, FunctionContext<'static>>>::new(
+    neon_run_with_guarded_lifetime(cx, |neon_context_holder| {
+        let options =
+            NativeObjectHandle::<NeonInnerTypes<FunctionContext<'static>>>::new(NeonObject::new(
+                neon_context_holder.clone(),
+                neon_context_holder
+                    .with_context(|cx| cx.argument::<JsValue>(0))
+                    .unwrap()?,
+            ));
+
+        let context_holder = NativeContextHolder::<NeonInnerTypes<FunctionContext<'static>>>::new(
             neon_context_holder,
         );
 
-    let base_query_options = Rc::new(NativeBaseQueryOptions::from_native(options).unwrap());
+        let base_query_options = Rc::new(NativeBaseQueryOptions::from_native(options).unwrap());
 
-    let base_query = BaseQuery::try_new(context_holder.clone(), base_query_options).unwrap();
+        let base_query = BaseQuery::try_new(context_holder.clone(), base_query_options).unwrap();
 
-    //arg_clrep.into_js(&mut cx)
-    let res = base_query.build_sql_and_params();
-
-    let result: NeonObject<'static, FunctionContext<'static>> = res.into_object();
-    let result = result.into_object();
-
-    Ok(result)
-}
+        let res = base_query.build_sql_and_params();
 
-fn extend_function_context_lifetime<'a>(cx: FunctionContext<'a>) -> FunctionContext<'static> {
-    unsafe { std::mem::transmute::<FunctionContext<'a>, FunctionContext<'static>>(cx) }
+        let result: NeonObject<FunctionContext<'static>> = res.into_object();
+        let result = result.into_object();
+        Ok(result)
+    })
 }
 
 fn debug_js_to_clrepr_to_js(mut cx: FunctionContext) -> JsResult<JsValue> {
diff --git a/rust/cubenativeutils/src/wrappers/context.rs b/rust/cubenativeutils/src/wrappers/context.rs
index cafa9d44f6d57..a99532764ec9f 100644
--- a/rust/cubenativeutils/src/wrappers/context.rs
+++ b/rust/cubenativeutils/src/wrappers/context.rs
@@ -1,14 +1,15 @@
 use super::{inner_types::InnerTypes, object::NativeBox, object_handle::NativeObjectHandle};
+use cubesql::CubeError;
 
 pub trait NativeContext<IT: InnerTypes>: Clone {
-    fn boolean(&self, v: bool) -> IT::Boolean;
-    fn string(&self, v: String) -> IT::String;
-    fn number(&self, v: f64) -> IT::Number;
-    fn undefined(&self) -> NativeObjectHandle<IT>;
-    fn empty_array(&self) -> IT::Array;
-    fn empty_struct(&self) -> IT::Struct;
+    fn boolean(&self, v: bool) -> Result<IT::Boolean, CubeError>;
+    fn string(&self, v: String) -> Result<IT::String, CubeError>;
+    fn number(&self, v: f64) -> Result<IT::Number, CubeError>;
+    fn undefined(&self) -> Result<NativeObjectHandle<IT>, CubeError>;
+    fn empty_array(&self) -> Result<IT::Array, CubeError>;
+    fn empty_struct(&self) -> Result<IT::Struct, CubeError>;
     //fn boxed<T: 'static>(&self, value: T) -> impl NativeBox<IT, T>;
-    fn to_string_fn(&self, result: String) -> IT::Function;
+    fn to_string_fn(&self, result: String) -> Result<IT::Function, CubeError>;
 }
 
 #[derive(Clone)]
@@ -23,26 +24,26 @@ impl<IT: InnerTypes> NativeContextHolder<IT> {
     pub fn context(&self) -> &impl NativeContext<IT> {
         &self.context
     }
-    pub fn boolean(&self, v: bool) -> IT::Boolean {
+    pub fn boolean(&self, v: bool) -> Result<IT::Boolean, CubeError> {
         self.context.boolean(v)
     }
-    pub fn string(&self, v: String) -> IT::String {
+    pub fn string(&self, v: String) -> Result<IT::String, CubeError> {
         self.context.string(v)
     }
-    pub fn number(&self, v: f64) -> IT::Number {
+    pub fn number(&self, v: f64) -> Result<IT::Number, CubeError> {
         self.context.number(v)
     }
-    pub fn undefined(&self) -> NativeObjectHandle<IT> {
+    pub fn undefined(&self) -> Result<NativeObjectHandle<IT>, CubeError> {
         self.context.undefined()
     }
-    pub fn empty_array(&self) -> IT::Array {
+    pub fn empty_array(&self) -> Result<IT::Array, CubeError> {
         self.context.empty_array()
     }
-    pub fn empty_struct(&self) -> IT::Struct {
+    pub fn empty_struct(&self) -> Result<IT::Struct, CubeError> {
         self.context.empty_struct()
     }
     #[allow(dead_code)]
-    pub fn to_string_fn(&self, result: String) -> IT::Function {
+    pub fn to_string_fn(&self, result: String) -> Result<IT::Function, CubeError> {
         self.context.to_string_fn(result)
     }
 }
diff --git a/rust/cubenativeutils/src/wrappers/neon/context.rs b/rust/cubenativeutils/src/wrappers/neon/context.rs
index 5a9bff155fba7..52c780494a34c 100644
--- a/rust/cubenativeutils/src/wrappers/neon/context.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/context.rs
@@ -12,21 +12,30 @@ use crate::wrappers::{
 use cubesql::CubeError;
 use neon::prelude::*;
 use std::{
-    cell::{RefCell, RefMut},
-    marker::PhantomData,
+    cell::RefCell,
+    panic::{catch_unwind, resume_unwind, AssertUnwindSafe},
     rc::{Rc, Weak},
 };
-pub struct ContextWrapper<'cx, C: Context<'cx>> {
+
+pub trait NoenContextLifetimeExpand<'cx> {
+    type ExpandedResult: Context<'static>;
+    fn expand_lifetime(self) -> Self::ExpandedResult;
+}
+
+impl<'cx> NoenContextLifetimeExpand<'cx> for FunctionContext<'cx> {
+    type ExpandedResult = FunctionContext<'static>;
+    fn expand_lifetime(self) -> Self::ExpandedResult {
+        unsafe { std::mem::transmute::<FunctionContext<'cx>, FunctionContext<'static>>(self) }
+    }
+}
+
+pub struct ContextWrapper<C: Context<'static>> {
     cx: C,
-    lifetime: PhantomData<&'cx ()>,
 }
 
-impl<'cx, C: Context<'cx>> ContextWrapper<'cx, C> {
+impl<C: Context<'static>> ContextWrapper<C> {
     pub fn new(cx: C) -> Rc<RefCell<Self>> {
-        Rc::new(RefCell::new(Self {
-            cx,
-            lifetime: Default::default(),
-        }))
+        Rc::new(RefCell::new(Self { cx }))
     }
 
     pub fn with_context<T, F>(&mut self, f: F) -> T
@@ -41,125 +50,105 @@ impl<'cx, C: Context<'cx>> ContextWrapper<'cx, C> {
     }
 }
 
-pub struct ContextHolder<'cx, C: Context<'cx>> {
-    context: Rc<RefCell<ContextWrapper<'cx, C>>>,
+pub fn neon_run_with_guarded_lifetime<'cx, C, T, F>(cx: C, func: F) -> T
+where
+    C: Context<'cx> + NoenContextLifetimeExpand<'cx>,
+    F: FnOnce(ContextHolder<C::ExpandedResult>) -> T,
+{
+    let context = ContextWrapper::new(cx.expand_lifetime());
+    let context_holder = ContextHolder::new(Rc::downgrade(&context));
+    let res = catch_unwind(AssertUnwindSafe(|| func(context_holder)));
+    match Rc::try_unwrap(context) {
+        Ok(_) => {}
+        Err(_) => panic!("Guarded context have more then one reference"),
+    };
+
+    match res {
+        Ok(res) => res,
+        Err(e) => resume_unwind(e),
+    }
 }
 
-impl<'cx, C: Context<'cx> + 'cx> ContextHolder<'cx, C> {
-    pub fn new(cx: C) -> Self {
-        Self {
-            context: ContextWrapper::new(cx),
-        }
-    }
+pub struct ContextHolder<C: Context<'static>> {
+    context: Weak<RefCell<ContextWrapper<C>>>,
+}
 
-    pub fn borrow_mut(&self) -> RefMut<ContextWrapper<'cx, C>> {
-        self.context.borrow_mut()
+impl<C: Context<'static>> ContextHolder<C> {
+    fn new(context: Weak<RefCell<ContextWrapper<C>>>) -> Self {
+        Self { context }
     }
 
-    pub fn with_context<T, F>(&self, f: F) -> T
+    pub fn with_context<T, F>(&self, f: F) -> Result<T, CubeError>
     where
         F: FnOnce(&mut C) -> T,
     {
-        let mut context = self.context.borrow_mut();
-        context.with_context(f)
-    }
-
-    pub fn weak(&self) -> WeakContextHolder<'cx, C> {
-        WeakContextHolder {
-            context: Rc::downgrade(&self.context),
+        if let Some(context) = self.context.upgrade() {
+            let mut cx = context.borrow_mut();
+            let res = cx.with_context(f);
+            Ok(res)
+        } else {
+            Err(CubeError::internal(format!(
+                "Call to neon context outside of its lifetime"
+            )))
         }
     }
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NativeContext<NeonInnerTypes<'cx, C>> for ContextHolder<'cx, C> {
-    fn boolean(&self, v: bool) -> NeonBoolean<'cx, C> {
-        let obj = NeonObject::new(self.clone(), self.with_context(|cx| cx.boolean(v).upcast()));
-        obj.into_boolean().unwrap()
+impl<C: Context<'static> + 'static> NativeContext<NeonInnerTypes<C>> for ContextHolder<C> {
+    fn boolean(&self, v: bool) -> Result<NeonBoolean<C>, CubeError> {
+        let obj = NeonObject::new(
+            self.clone(),
+            self.with_context(|cx| cx.boolean(v).upcast())?,
+        );
+        obj.into_boolean()
     }
 
-    fn string(&self, v: String) -> NeonString<'cx, C> {
-        let obj = NeonObject::new(self.clone(), self.with_context(|cx| cx.string(v).upcast()));
-        obj.into_string().unwrap()
+    fn string(&self, v: String) -> Result<NeonString<C>, CubeError> {
+        let obj = NeonObject::new(self.clone(), self.with_context(|cx| cx.string(v).upcast())?);
+        obj.into_string()
     }
 
-    fn number(&self, v: f64) -> NeonNumber<'cx, C> {
-        let obj = NeonObject::new(self.clone(), self.with_context(|cx| cx.number(v).upcast()));
-        obj.into_number().unwrap()
+    fn number(&self, v: f64) -> Result<NeonNumber<C>, CubeError> {
+        let obj = NeonObject::new(self.clone(), self.with_context(|cx| cx.number(v).upcast())?);
+        obj.into_number()
     }
 
-    fn undefined(&self) -> NativeObjectHandle<NeonInnerTypes<'cx, C>> {
-        NativeObjectHandle::new(NeonObject::new(
+    fn undefined(&self) -> Result<NativeObjectHandle<NeonInnerTypes<C>>, CubeError> {
+        Ok(NativeObjectHandle::new(NeonObject::new(
             self.clone(),
-            self.with_context(|cx| cx.undefined().upcast()),
-        ))
+            self.with_context(|cx| cx.undefined().upcast())?,
+        )))
     }
 
-    fn empty_array(&self) -> NeonArray<'cx, C> {
+    fn empty_array(&self) -> Result<NeonArray<C>, CubeError> {
         let obj = NeonObject::new(
             self.clone(),
-            self.with_context(|cx| cx.empty_array().upcast()),
+            self.with_context(|cx| cx.empty_array().upcast())?,
         );
-        obj.into_array().unwrap()
+        obj.into_array()
     }
 
-    fn empty_struct(&self) -> NeonStruct<'cx, C> {
+    fn empty_struct(&self) -> Result<NeonStruct<C>, CubeError> {
         let obj = NeonObject::new(
             self.clone(),
-            self.with_context(|cx| cx.empty_object().upcast()),
+            self.with_context(|cx| cx.empty_object().upcast())?,
         );
-        obj.into_struct().unwrap()
+        obj.into_struct()
     }
-    fn to_string_fn(&self, result: String) -> NeonFunction<'cx, C> {
+    fn to_string_fn(&self, result: String) -> Result<NeonFunction<C>, CubeError> {
         let obj = NeonObject::new(
             self.clone(),
             self.with_context(|cx| {
                 JsFunction::new(cx, move |mut c| Ok(c.string(result.clone())))
                     .unwrap()
                     .upcast()
-            }),
+            })?,
         );
-        obj.into_function().unwrap()
-    }
-}
-
-impl<'cx, C: Context<'cx>> Clone for ContextHolder<'cx, C> {
-    fn clone(&self) -> Self {
-        Self {
-            context: self.context.clone(),
-        }
-    }
-}
-
-pub struct WeakContextHolder<'cx, C: Context<'cx>> {
-    context: Weak<RefCell<ContextWrapper<'cx, C>>>,
-}
-
-impl<'cx, C: Context<'cx>> WeakContextHolder<'cx, C> {
-    pub fn try_upgrade<'a>(&'a self) -> Result<ContextHolder<'a, C>, CubeError>
-    where
-        'a: 'cx,
-    {
-        if let Some(context) = self.context.upgrade() {
-            Ok(ContextHolder { context })
-        } else {
-            Err(CubeError::internal(format!("Neon context is not alive")))
-        }
-    }
-    pub fn with_context<T, F>(&self, f: F) -> Result<T, CubeError>
-    where
-        F: FnOnce(&mut C) -> T,
-    {
-        if let Some(context) = self.context.upgrade() {
-            let mut cx = context.borrow_mut();
-            let res = cx.with_context(f);
-            Ok(res)
-        } else {
-            Err(CubeError::internal(format!("Neon context is not alive")))
-        }
+        obj.into_function()
     }
 }
 
-impl<'cx, C: Context<'cx>> Clone for WeakContextHolder<'cx, C> {
+impl<C: Context<'static>> Clone for ContextHolder<C> {
     fn clone(&self) -> Self {
         Self {
             context: self.context.clone(),
diff --git a/rust/cubenativeutils/src/wrappers/neon/inner_types.rs b/rust/cubenativeutils/src/wrappers/neon/inner_types.rs
index 8bf32d0be843e..5da5dca397de4 100644
--- a/rust/cubenativeutils/src/wrappers/neon/inner_types.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/inner_types.rs
@@ -9,25 +9,25 @@ use crate::wrappers::inner_types::InnerTypes;
 use neon::prelude::*;
 use std::marker::PhantomData;
 
-pub struct NeonInnerTypes<'cx: 'static, C: Context<'cx>> {
-    lifetime: PhantomData<&'cx ContextHolder<'cx, C>>,
+pub struct NeonInnerTypes<C: Context<'static>> {
+    marker: PhantomData<ContextHolder<C>>,
 }
 
-impl<'cx, C: Context<'cx>> Clone for NeonInnerTypes<'cx, C> {
+impl<C: Context<'static>> Clone for NeonInnerTypes<C> {
     fn clone(&self) -> Self {
         Self {
-            lifetime: Default::default(),
+            marker: Default::default(),
         }
     }
 }
 
-impl<'cx: 'static, C: Context<'cx>> InnerTypes for NeonInnerTypes<'cx, C> {
-    type Object = NeonObject<'cx, C>;
-    type Context = ContextHolder<'cx, C>;
-    type Array = NeonArray<'cx, C>;
-    type Struct = NeonStruct<'cx, C>;
-    type String = NeonString<'cx, C>;
-    type Boolean = NeonBoolean<'cx, C>;
-    type Function = NeonFunction<'cx, C>;
-    type Number = NeonNumber<'cx, C>;
+impl<C: Context<'static> + 'static> InnerTypes for NeonInnerTypes<C> {
+    type Object = NeonObject<C>;
+    type Context = ContextHolder<C>;
+    type Array = NeonArray<C>;
+    type Struct = NeonStruct<C>;
+    type String = NeonString<C>;
+    type Boolean = NeonBoolean<C>;
+    type Function = NeonFunction<C>;
+    type Number = NeonNumber<C>;
 }
diff --git a/rust/cubenativeutils/src/wrappers/neon/object/base_types.rs b/rust/cubenativeutils/src/wrappers/neon/object/base_types.rs
index 3f630cccbf8e8..54d1a7de02285 100644
--- a/rust/cubenativeutils/src/wrappers/neon/object/base_types.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/object/base_types.rs
@@ -7,82 +7,82 @@ use cubesql::CubeError;
 use neon::prelude::*;
 use std::ops::Deref;
 
-pub struct NeonString<'cx: 'static, C: Context<'cx>> {
-    object: NeonTypeHandle<'cx, C, JsString>,
+pub struct NeonString<C: Context<'static>> {
+    object: NeonTypeHandle<C, JsString>,
 }
 
-impl<'cx, C: Context<'cx>> NeonString<'cx, C> {
-    pub fn new(object: NeonTypeHandle<'cx, C, JsString>) -> Self {
+impl<C: Context<'static>> NeonString<C> {
+    pub fn new(object: NeonTypeHandle<C, JsString>) -> Self {
         Self { object }
     }
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NativeType<NeonInnerTypes<'cx, C>> for NeonString<'cx, C> {
-    fn into_object(self) -> NeonObject<'cx, C> {
+impl<C: Context<'static> + 'static> NativeType<NeonInnerTypes<C>> for NeonString<C> {
+    fn into_object(self) -> NeonObject<C> {
         self.object.upcast()
     }
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NativeString<NeonInnerTypes<'cx, C>> for NeonString<'cx, C> {
+impl<C: Context<'static> + 'static> NativeString<NeonInnerTypes<C>> for NeonString<C> {
     fn value(&self) -> Result<String, CubeError> {
         self.object
-            .map_neon_object::<_, _>(|cx, object| Ok(object.value(cx)))
+            .map_neon_object::<_, _>(|cx, object| Ok(object.value(cx)))?
     }
 }
 
-pub struct NeonNumber<'cx: 'static, C: Context<'cx>> {
-    object: NeonTypeHandle<'cx, C, JsNumber>,
+pub struct NeonNumber<C: Context<'static>> {
+    object: NeonTypeHandle<C, JsNumber>,
 }
 
-impl<'cx, C: Context<'cx>> NeonNumber<'cx, C> {
-    pub fn new(object: NeonTypeHandle<'cx, C, JsNumber>) -> Self {
+impl<C: Context<'static>> NeonNumber<C> {
+    pub fn new(object: NeonTypeHandle<C, JsNumber>) -> Self {
         Self { object }
     }
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NativeType<NeonInnerTypes<'cx, C>> for NeonNumber<'cx, C> {
-    fn into_object(self) -> NeonObject<'cx, C> {
+impl<C: Context<'static> + 'static> NativeType<NeonInnerTypes<C>> for NeonNumber<C> {
+    fn into_object(self) -> NeonObject<C> {
         self.object.upcast()
     }
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NativeNumber<NeonInnerTypes<'cx, C>> for NeonNumber<'cx, C> {
+impl<C: Context<'static> + 'static> NativeNumber<NeonInnerTypes<C>> for NeonNumber<C> {
     fn value(&self) -> Result<f64, CubeError> {
         self.object
-            .map_neon_object::<_, _>(|cx, object| Ok(object.value(cx)))
+            .map_neon_object::<_, _>(|cx, object| Ok(object.value(cx)))?
     }
 }
 
-pub struct NeonBoolean<'cx: 'static, C: Context<'cx>> {
-    object: NeonTypeHandle<'cx, C, JsBoolean>,
+pub struct NeonBoolean<C: Context<'static>> {
+    object: NeonTypeHandle<C, JsBoolean>,
 }
 
-impl<'cx, C: Context<'cx>> NeonBoolean<'cx, C> {
-    pub fn new(object: NeonTypeHandle<'cx, C, JsBoolean>) -> Self {
+impl<C: Context<'static>> NeonBoolean<C> {
+    pub fn new(object: NeonTypeHandle<C, JsBoolean>) -> Self {
         Self { object }
     }
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NativeType<NeonInnerTypes<'cx, C>> for NeonBoolean<'cx, C> {
-    fn into_object(self) -> NeonObject<'cx, C> {
+impl<C: Context<'static> + 'static> NativeType<NeonInnerTypes<C>> for NeonBoolean<C> {
+    fn into_object(self) -> NeonObject<C> {
         self.object.upcast()
     }
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NativeBoolean<NeonInnerTypes<'cx, C>> for NeonBoolean<'cx, C> {
+impl<C: Context<'static> + 'static> NativeBoolean<NeonInnerTypes<C>> for NeonBoolean<C> {
     fn value(&self) -> Result<bool, CubeError> {
         self.object
-            .map_neon_object::<_, _>(|cx, object| Ok(object.value(cx)))
+            .map_neon_object::<_, _>(|cx, object| Ok(object.value(cx)))?
     }
 }
 
-pub struct NeonBox<'cx: 'static, C: Context<'cx>, T: 'static> {
-    object: NeonTypeHandle<'cx, C, JsBox<T>>,
+pub struct NeonBox<C: Context<'static>, T: 'static> {
+    object: NeonTypeHandle<C, JsBox<T>>,
     _marker: PhantomData<T>,
 }
 
-impl<'cx: 'static, C: Context<'cx>, T: 'static> NeonBox<'cx, C, T> {
-    pub fn new(object: NeonTypeHandle<'cx, C, JsBox<T>>) -> Self {
+impl<C: Context<'static>, T: 'static> NeonBox<C, T> {
+    pub fn new(object: NeonTypeHandle<C, JsBox<T>>) -> Self {
         Self {
             object,
             _marker: PhantomData::default(),
@@ -90,17 +90,13 @@ impl<'cx: 'static, C: Context<'cx>, T: 'static> NeonBox<'cx, C, T> {
     }
 }
 
-impl<'cx: 'static, C: Context<'cx> + 'cx, T: 'static> NativeType<NeonInnerTypes<'cx, C>>
-    for NeonBox<'cx, C, T>
-{
-    fn into_object(self) -> NeonObject<'cx, C> {
+impl<C: Context<'static> + 'static, T: 'static> NativeType<NeonInnerTypes<C>> for NeonBox<C, T> {
+    fn into_object(self) -> NeonObject<C> {
         self.object.upcast()
     }
 }
 
-impl<'cx: 'static, C: Context<'cx> + 'cx, T: 'static> NativeBox<NeonInnerTypes<'cx, C>, T>
-    for NeonBox<'cx, C, T>
-{
+impl<C: Context<'static> + 'static, T: 'static> NativeBox<NeonInnerTypes<C>, T> for NeonBox<C, T> {
     fn deref_value(&self) -> &T {
         self.object.get_object_ref().deref()
     }
diff --git a/rust/cubenativeutils/src/wrappers/neon/object/mod.rs b/rust/cubenativeutils/src/wrappers/neon/object/mod.rs
index c08e0109ec871..54b28d10684b5 100644
--- a/rust/cubenativeutils/src/wrappers/neon/object/mod.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/object/mod.rs
@@ -14,46 +14,46 @@ use crate::wrappers::{neon::context::ContextHolder, object::NativeObject};
 use cubesql::CubeError;
 use neon::prelude::*;
 
-pub struct NeonTypeHandle<'cx, C: Context<'cx>, V: Value + 'cx> {
-    context: ContextHolder<'cx, C>,
-    object: Handle<'cx, V>,
+pub struct NeonTypeHandle<C: Context<'static>, V: Value + 'static> {
+    context: ContextHolder<C>,
+    object: Handle<'static, V>,
 }
 
-impl<'cx: 'static, C: Context<'cx> + 'cx, V: Value + 'cx> NeonTypeHandle<'cx, C, V> {
-    pub fn new(context: ContextHolder<'cx, C>, object: Handle<'cx, V>) -> Self {
+impl<C: Context<'static> + 'static, V: Value + 'static> NeonTypeHandle<C, V> {
+    pub fn new(context: ContextHolder<C>, object: Handle<'static, V>) -> Self {
         Self { context, object }
     }
 
-    fn get_context(&self) -> ContextHolder<'cx, C> {
+    fn get_context(&self) -> ContextHolder<C> {
         self.context.clone()
     }
 
-    pub fn get_object(&self) -> Handle<'cx, V> {
+    pub fn get_object(&self) -> Handle<'static, V> {
         self.object.clone()
     }
 
-    pub fn get_object_ref(&self) -> &Handle<'cx, V> {
+    pub fn get_object_ref(&self) -> &Handle<'static, V> {
         &self.object
     }
 
-    pub fn into_object(self) -> Handle<'cx, V> {
+    pub fn into_object(self) -> Handle<'static, V> {
         self.object
     }
 
-    pub fn upcast(&self) -> NeonObject<'cx, C> {
+    pub fn upcast(&self) -> NeonObject<C> {
         NeonObject::new(self.context.clone(), self.object.upcast())
     }
 
-    pub fn map_neon_object<T, F>(&self, f: F) -> T
+    pub fn map_neon_object<T, F>(&self, f: F) -> Result<T, CubeError>
     where
-        F: FnOnce(&mut C, &Handle<'cx, V>) -> T,
+        F: FnOnce(&mut C, &Handle<'static, V>) -> T,
     {
         self.context.with_context(|cx| f(cx, &self.object))
     }
 
     pub fn map_downcast_neon_object<JT: Value, T, F>(&self, f: F) -> Result<T, CubeError>
     where
-        F: FnOnce(&mut C, &Handle<'cx, JT>) -> Result<T, CubeError>,
+        F: FnOnce(&mut C, &Handle<'static, JT>) -> Result<T, CubeError>,
     {
         self.context.with_context(|cx| {
             let obj = self
@@ -61,15 +61,15 @@ impl<'cx: 'static, C: Context<'cx> + 'cx, V: Value + 'cx> NeonTypeHandle<'cx, C,
                 .downcast::<JT, _>(cx)
                 .map_err(|_| CubeError::internal("Downcast error".to_string()))?;
             f(cx, &obj)
-        })
+        })?
     }
 
-    pub fn is_a<U: Value>(&self) -> bool {
+    pub fn is_a<U: Value>(&self) -> Result<bool, CubeError> {
         self.context.with_context(|cx| self.object.is_a::<U, _>(cx))
     }
 }
 
-impl<'cx: 'static, C: Context<'cx>, V: Value + 'cx> Clone for NeonTypeHandle<'cx, C, V> {
+impl<C: Context<'static>, V: Value + 'static> Clone for NeonTypeHandle<C, V> {
     fn clone(&self) -> Self {
         Self {
             context: self.context.clone(),
@@ -78,96 +78,94 @@ impl<'cx: 'static, C: Context<'cx>, V: Value + 'cx> Clone for NeonTypeHandle<'cx
     }
 }
 
-pub struct NeonObject<'cx: 'static, C: Context<'cx>> {
-    context: ContextHolder<'cx, C>,
-    object: Handle<'cx, JsValue>,
+pub struct NeonObject<C: Context<'static>> {
+    context: ContextHolder<C>,
+    object: Handle<'static, JsValue>,
 }
 
-impl<'cx: 'static, C: Context<'cx> + 'cx> NeonObject<'cx, C> {
-    pub fn new(context: ContextHolder<'cx, C>, object: Handle<'cx, JsValue>) -> Self {
+impl<C: Context<'static> + 'static> NeonObject<C> {
+    pub fn new(context: ContextHolder<C>, object: Handle<'static, JsValue>) -> Self {
         Self { context, object }
     }
 
-    pub fn get_object(&self) -> Handle<'cx, JsValue> {
+    pub fn get_object(&self) -> Handle<'static, JsValue> {
         self.object.clone()
     }
 
-    pub fn get_object_ref(&self) -> &Handle<'cx, JsValue> {
+    pub fn get_object_ref(&self) -> &Handle<'static, JsValue> {
         &self.object
     }
 
-    pub fn into_object(self) -> Handle<'cx, JsValue> {
+    pub fn into_object(self) -> Handle<'static, JsValue> {
         self.object
     }
 
-    pub fn is_a<U: Value>(&self) -> bool {
+    pub fn is_a<U: Value>(&self) -> Result<bool, CubeError> {
         self.context.with_context(|cx| self.object.is_a::<U, _>(cx))
     }
 
-    pub fn downcast<U: Value>(&self) -> Result<NeonTypeHandle<'cx, C, U>, CubeError> {
+    pub fn downcast<U: Value>(&self) -> Result<NeonTypeHandle<C, U>, CubeError> {
         let obj = self.context.with_context(|cx| {
             self.object
                 .downcast::<U, _>(cx)
                 .map_err(|_| CubeError::internal("Downcast error".to_string()))
-        })?;
+        })??;
         Ok(NeonTypeHandle::new(self.context.clone(), obj))
     }
 
     pub fn downcast_with_err_msg<U: Value>(
         &self,
         msg: &str,
-    ) -> Result<NeonTypeHandle<'cx, C, U>, CubeError> {
+    ) -> Result<NeonTypeHandle<C, U>, CubeError> {
         let obj = self.context.with_context(|cx| {
             self.object
                 .downcast::<U, _>(cx)
                 .map_err(|_| CubeError::internal(msg.to_string()))
-        })?;
+        })??;
         Ok(NeonTypeHandle::new(self.context.clone(), obj))
     }
 }
 
-impl<'cx: 'static, C: Context<'cx> + 'cx> NativeObject<NeonInnerTypes<'cx, C>>
-    for NeonObject<'cx, C>
-{
-    fn get_context(&self) -> ContextHolder<'cx, C> {
+impl<C: Context<'static> + 'static> NativeObject<NeonInnerTypes<C>> for NeonObject<C> {
+    fn get_context(&self) -> ContextHolder<C> {
         self.context.clone()
     }
 
-    fn into_struct(self) -> Result<NeonStruct<'cx, C>, CubeError> {
+    fn into_struct(self) -> Result<NeonStruct<C>, CubeError> {
         let obj = self.downcast_with_err_msg::<JsObject>("NeonObject is not the JsObject")?;
         Ok(NeonStruct::new(obj))
     }
-    fn into_function(self) -> Result<NeonFunction<'cx, C>, CubeError> {
+    fn into_function(self) -> Result<NeonFunction<C>, CubeError> {
         let obj = self.downcast_with_err_msg::<JsFunction>("NeonObject is not the JsArray")?;
         Ok(NeonFunction::new(obj))
     }
-    fn into_array(self) -> Result<NeonArray<'cx, C>, CubeError> {
+    fn into_array(self) -> Result<NeonArray<C>, CubeError> {
         let obj = self.downcast_with_err_msg::<JsArray>("NeonObject is not the JsArray")?;
         Ok(NeonArray::new(obj))
     }
-    fn into_string(self) -> Result<NeonString<'cx, C>, CubeError> {
+    fn into_string(self) -> Result<NeonString<C>, CubeError> {
         let obj = self.downcast_with_err_msg::<JsString>("NeonObject is not the JsString")?;
         Ok(NeonString::new(obj))
     }
-    fn into_number(self) -> Result<NeonNumber<'cx, C>, CubeError> {
+    fn into_number(self) -> Result<NeonNumber<C>, CubeError> {
         let obj = self.downcast_with_err_msg::<JsNumber>("NeonObject is not the JsNumber")?;
         Ok(NeonNumber::new(obj))
     }
-    fn into_boolean(self) -> Result<NeonBoolean<'cx, C>, CubeError> {
+    fn into_boolean(self) -> Result<NeonBoolean<C>, CubeError> {
         let obj = self.downcast_with_err_msg::<JsBoolean>("NeonObject is not the JsBoolean")?;
         Ok(NeonBoolean::new(obj))
     }
 
-    fn is_null(&self) -> bool {
+    fn is_null(&self) -> Result<bool, CubeError> {
         self.is_a::<JsNull>()
     }
 
-    fn is_undefined(&self) -> bool {
+    fn is_undefined(&self) -> Result<bool, CubeError> {
         self.is_a::<JsUndefined>()
     }
 }
 
-impl<'cx: 'static, C: Context<'cx>> Clone for NeonObject<'cx, C> {
+impl<C: Context<'static>> Clone for NeonObject<C> {
     fn clone(&self) -> Self {
         Self {
             context: self.context.clone(),
diff --git a/rust/cubenativeutils/src/wrappers/neon/object/neon_array.rs b/rust/cubenativeutils/src/wrappers/neon/object/neon_array.rs
index 4e6847d54bd09..e495ebbc38b19 100644
--- a/rust/cubenativeutils/src/wrappers/neon/object/neon_array.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/object/neon_array.rs
@@ -8,33 +8,33 @@ use cubesql::CubeError;
 use neon::prelude::*;
 
 #[derive(Clone)]
-pub struct NeonArray<'cx: 'static, C: Context<'cx>> {
-    object: NeonTypeHandle<'cx, C, JsArray>,
+pub struct NeonArray<C: Context<'static>> {
+    object: NeonTypeHandle<C, JsArray>,
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NeonArray<'cx, C> {
-    pub fn new(object: NeonTypeHandle<'cx, C, JsArray>) -> Self {
+impl<C: Context<'static> + 'static> NeonArray<C> {
+    pub fn new(object: NeonTypeHandle<C, JsArray>) -> Self {
         Self { object }
     }
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NativeType<NeonInnerTypes<'cx, C>> for NeonArray<'cx, C> {
-    fn into_object(self) -> NeonObject<'cx, C> {
+impl<C: Context<'static> + 'static> NativeType<NeonInnerTypes<C>> for NeonArray<C> {
+    fn into_object(self) -> NeonObject<C> {
         self.object.upcast()
     }
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NativeArray<NeonInnerTypes<'cx, C>> for NeonArray<'cx, C> {
+impl<C: Context<'static> + 'static> NativeArray<NeonInnerTypes<C>> for NeonArray<C> {
     fn len(&self) -> Result<u32, CubeError> {
         self.object
-            .map_neon_object::<_, _>(|cx, object| Ok(object.len(cx)))
+            .map_neon_object::<_, _>(|cx, object| Ok(object.len(cx)))?
     }
-    fn to_vec(&self) -> Result<Vec<NativeObjectHandle<NeonInnerTypes<'cx, C>>>, CubeError> {
+    fn to_vec(&self) -> Result<Vec<NativeObjectHandle<NeonInnerTypes<C>>>, CubeError> {
         let neon_vec = self.object.map_neon_object::<_, _>(|cx, object| {
             object
                 .to_vec(cx)
                 .map_err(|_| CubeError::internal("Error converting JsArray to Vec".to_string()))
-        })?;
+        })??;
 
         Ok(neon_vec
             .into_iter()
@@ -44,21 +44,21 @@ impl<'cx, C: Context<'cx> + 'cx> NativeArray<NeonInnerTypes<'cx, C>> for NeonArr
     fn set(
         &self,
         index: u32,
-        value: NativeObjectHandle<NeonInnerTypes<'cx, C>>,
+        value: NativeObjectHandle<NeonInnerTypes<C>>,
     ) -> Result<bool, CubeError> {
         let value = value.into_object().into_object();
         self.object.map_neon_object::<_, _>(|cx, object| {
             object
                 .set(cx, index, value)
                 .map_err(|_| CubeError::internal(format!("Error setting index {}", index)))
-        })
+        })?
     }
-    fn get(&self, index: u32) -> Result<NativeObjectHandle<NeonInnerTypes<'cx, C>>, CubeError> {
+    fn get(&self, index: u32) -> Result<NativeObjectHandle<NeonInnerTypes<C>>, CubeError> {
         let r = self.object.map_neon_object::<_, _>(|cx, object| {
             object
                 .get(cx, index)
                 .map_err(|_| CubeError::internal(format!("Error setting index {}", index)))
-        })?;
+        })??;
         Ok(NativeObjectHandle::new(NeonObject::new(
             self.object.get_context(),
             r,
diff --git a/rust/cubenativeutils/src/wrappers/neon/object/neon_function.rs b/rust/cubenativeutils/src/wrappers/neon/object/neon_function.rs
index 6d6a4de881233..192db172e1c8a 100644
--- a/rust/cubenativeutils/src/wrappers/neon/object/neon_function.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/object/neon_function.rs
@@ -10,27 +10,27 @@ use neon::prelude::*;
 use regex::Regex;
 
 #[derive(Clone)]
-pub struct NeonFunction<'cx: 'static, C: Context<'cx>> {
-    object: NeonTypeHandle<'cx, C, JsFunction>,
+pub struct NeonFunction<C: Context<'static>> {
+    object: NeonTypeHandle<C, JsFunction>,
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NeonFunction<'cx, C> {
-    pub fn new(object: NeonTypeHandle<'cx, C, JsFunction>) -> Self {
+impl<C: Context<'static> + 'static> NeonFunction<C> {
+    pub fn new(object: NeonTypeHandle<C, JsFunction>) -> Self {
         Self { object }
     }
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NativeType<NeonInnerTypes<'cx, C>> for NeonFunction<'cx, C> {
-    fn into_object(self) -> NeonObject<'cx, C> {
+impl<C: Context<'static> + 'static> NativeType<NeonInnerTypes<C>> for NeonFunction<C> {
+    fn into_object(self) -> NeonObject<C> {
         self.object.upcast()
     }
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NativeFunction<NeonInnerTypes<'cx, C>> for NeonFunction<'cx, C> {
+impl<C: Context<'static> + 'static> NativeFunction<NeonInnerTypes<C>> for NeonFunction<C> {
     fn call(
         &self,
-        args: Vec<NativeObjectHandle<NeonInnerTypes<'cx, C>>>,
-    ) -> Result<NativeObjectHandle<NeonInnerTypes<'cx, C>>, CubeError> {
+        args: Vec<NativeObjectHandle<NeonInnerTypes<C>>>,
+    ) -> Result<NativeObjectHandle<NeonInnerTypes<C>>, CubeError> {
         let neon_args = args
             .into_iter()
             .map(|arg| -> Result<_, CubeError> { Ok(arg.into_object().get_object()) })
@@ -40,7 +40,7 @@ impl<'cx, C: Context<'cx> + 'cx> NativeFunction<NeonInnerTypes<'cx, C>> for Neon
             neon_object
                 .call(cx, null, neon_args)
                 .map_err(|_| CubeError::internal(format!("Failed to call function ")))
-        })?;
+        })??;
         Ok(NativeObjectHandle::new(NeonObject::new(
             self.object.context.clone(),
             neon_reuslt,
@@ -58,7 +58,7 @@ impl<'cx, C: Context<'cx> + 'cx> NativeFunction<NeonInnerTypes<'cx, C>> for Neon
                         })?
                         .value(cx);
                     Ok(res)
-                })?;
+                })??;
         Ok(result)
     }
 
diff --git a/rust/cubenativeutils/src/wrappers/neon/object/neon_struct.rs b/rust/cubenativeutils/src/wrappers/neon/object/neon_struct.rs
index 869fc8ba6bf07..3d41ef9dbe5ff 100644
--- a/rust/cubenativeutils/src/wrappers/neon/object/neon_struct.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/object/neon_struct.rs
@@ -8,32 +8,32 @@ use cubesql::CubeError;
 use neon::prelude::*;
 
 #[derive(Clone)]
-pub struct NeonStruct<'cx: 'static, C: Context<'cx>> {
-    object: NeonTypeHandle<'cx, C, JsObject>,
+pub struct NeonStruct<C: Context<'static>> {
+    object: NeonTypeHandle<C, JsObject>,
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NeonStruct<'cx, C> {
-    pub fn new(object: NeonTypeHandle<'cx, C, JsObject>) -> Self {
+impl<C: Context<'static> + 'static> NeonStruct<C> {
+    pub fn new(object: NeonTypeHandle<C, JsObject>) -> Self {
         Self { object }
     }
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NativeType<NeonInnerTypes<'cx, C>> for NeonStruct<'cx, C> {
-    fn into_object(self) -> NeonObject<'cx, C> {
+impl<C: Context<'static> + 'static> NativeType<NeonInnerTypes<C>> for NeonStruct<C> {
+    fn into_object(self) -> NeonObject<C> {
         self.object.upcast()
     }
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NativeStruct<NeonInnerTypes<'cx, C>> for NeonStruct<'cx, C> {
+impl<C: Context<'static> + 'static> NativeStruct<NeonInnerTypes<C>> for NeonStruct<C> {
     fn get_field(
         &self,
         field_name: &str,
-    ) -> Result<NativeObjectHandle<NeonInnerTypes<'cx, C>>, CubeError> {
+    ) -> Result<NativeObjectHandle<NeonInnerTypes<C>>, CubeError> {
         let neon_result = self.object.map_neon_object(|cx, neon_object| {
             neon_object
                 .get::<JsValue, _, _>(cx, field_name)
                 .map_err(|_| CubeError::internal(format!("Field `{}` not found", field_name)))
-        })?;
+        })??;
         Ok(NativeObjectHandle::new(NeonObject::new(
             self.object.context.clone(),
             neon_result,
@@ -41,38 +41,38 @@ impl<'cx, C: Context<'cx> + 'cx> NativeStruct<NeonInnerTypes<'cx, C>> for NeonSt
     }
 
     fn has_field(&self, field_name: &str) -> Result<bool, CubeError> {
-        let result = self
-            .object
-            .map_neon_object(|cx, neon_object| -> Result<bool, CubeError> {
-                let res = neon_object
-                    .get_opt::<JsValue, _, _>(cx, field_name)
-                    .map_err(|_| {
-                        CubeError::internal(format!(
-                            "Error while getting field `{}` not found",
-                            field_name
-                        ))
-                    })?
-                    .is_some();
-                Ok(res)
-            })?;
+        let result =
+            self.object
+                .map_neon_object(|cx, neon_object| -> Result<bool, CubeError> {
+                    let res = neon_object
+                        .get_opt::<JsValue, _, _>(cx, field_name)
+                        .map_err(|_| {
+                            CubeError::internal(format!(
+                                "Error while getting field `{}` not found",
+                                field_name
+                            ))
+                        })?
+                        .is_some();
+                    Ok(res)
+                })??;
         Ok(result)
     }
 
     fn set_field(
         &self,
         field_name: &str,
-        value: NativeObjectHandle<NeonInnerTypes<'cx, C>>,
+        value: NativeObjectHandle<NeonInnerTypes<C>>,
     ) -> Result<bool, CubeError> {
         let value = value.into_object().into_object();
         self.object.map_neon_object::<_, _>(|cx, object| {
             object
                 .set(cx, field_name, value)
                 .map_err(|_| CubeError::internal(format!("Error setting field {}", field_name)))
-        })
+        })?
     }
     fn get_own_property_names(
         &self,
-    ) -> Result<Vec<NativeObjectHandle<NeonInnerTypes<'cx, C>>>, CubeError> {
+    ) -> Result<Vec<NativeObjectHandle<NeonInnerTypes<C>>>, CubeError> {
         let neon_array = self.object.map_neon_object(|cx, neon_object| {
             let neon_array = neon_object
                 .get_own_property_names(cx)
@@ -81,7 +81,7 @@ impl<'cx, C: Context<'cx> + 'cx> NativeStruct<NeonInnerTypes<'cx, C>> for NeonSt
             neon_array
                 .to_vec(cx)
                 .map_err(|_| CubeError::internal(format!("Failed to convert array")))
-        })?;
+        })??;
         Ok(neon_array
             .into_iter()
             .map(|o| NativeObjectHandle::new(NeonObject::new(self.object.context.clone(), o)))
@@ -90,8 +90,8 @@ impl<'cx, C: Context<'cx> + 'cx> NativeStruct<NeonInnerTypes<'cx, C>> for NeonSt
     fn call_method(
         &self,
         method: &str,
-        args: Vec<NativeObjectHandle<NeonInnerTypes<'cx, C>>>,
-    ) -> Result<NativeObjectHandle<NeonInnerTypes<'cx, C>>, CubeError> {
+        args: Vec<NativeObjectHandle<NeonInnerTypes<C>>>,
+    ) -> Result<NativeObjectHandle<NeonInnerTypes<C>>, CubeError> {
         let neon_args = args
             .into_iter()
             .map(|arg| -> Result<_, CubeError> { Ok(arg.into_object().get_object()) })
@@ -109,7 +109,7 @@ impl<'cx, C: Context<'cx> + 'cx> NativeStruct<NeonInnerTypes<'cx, C>> for NeonSt
                         method, err, err
                     ))
                 })
-        })?;
+        })??;
         Ok(NativeObjectHandle::new(NeonObject::new(
             self.object.context.clone(),
             neon_reuslt,
diff --git a/rust/cubenativeutils/src/wrappers/object.rs b/rust/cubenativeutils/src/wrappers/object.rs
index d5f0efd6cec61..401a0b35c2651 100644
--- a/rust/cubenativeutils/src/wrappers/object.rs
+++ b/rust/cubenativeutils/src/wrappers/object.rs
@@ -10,8 +10,8 @@ pub trait NativeObject<IT: InnerTypes>: Clone {
     fn into_number(self) -> Result<IT::Number, CubeError>;
     fn into_boolean(self) -> Result<IT::Boolean, CubeError>;
     fn into_function(self) -> Result<IT::Function, CubeError>;
-    fn is_null(&self) -> bool;
-    fn is_undefined(&self) -> bool;
+    fn is_null(&self) -> Result<bool, CubeError>;
+    fn is_undefined(&self) -> Result<bool, CubeError>;
 }
 
 pub trait NativeType<IT: InnerTypes> {
diff --git a/rust/cubenativeutils/src/wrappers/object_handle.rs b/rust/cubenativeutils/src/wrappers/object_handle.rs
index 783c60606c4b6..93429cacbc117 100644
--- a/rust/cubenativeutils/src/wrappers/object_handle.rs
+++ b/rust/cubenativeutils/src/wrappers/object_handle.rs
@@ -55,10 +55,10 @@ impl<IT: InnerTypes> NativeObjectHandle<IT> {
     pub fn to_boolean(&self) -> Result<IT::Boolean, CubeError> {
         self.object.clone().into_boolean()
     }
-    pub fn is_null(&self) -> bool {
+    pub fn is_null(&self) -> Result<bool, CubeError> {
         self.object.is_null()
     }
-    pub fn is_undefined(&self) -> bool {
+    pub fn is_undefined(&self) -> Result<bool, CubeError> {
         self.object.is_undefined()
     }
     pub fn get_context(&self) -> IT::Context {
diff --git a/rust/cubenativeutils/src/wrappers/serializer/deserializer.rs b/rust/cubenativeutils/src/wrappers/serializer/deserializer.rs
index 9f3cc78582723..ff85659831fa6 100644
--- a/rust/cubenativeutils/src/wrappers/serializer/deserializer.rs
+++ b/rust/cubenativeutils/src/wrappers/serializer/deserializer.rs
@@ -33,7 +33,7 @@ impl<'de, IT: InnerTypes> Deserializer<'de> for NativeSerdeDeserializer<IT> {
     where
         V: Visitor<'de>,
     {
-        if self.input.is_null() || self.input.is_undefined() {
+        if self.input.is_null()? || self.input.is_undefined()? {
             visitor.visit_unit()
         } else if let Ok(val) = self.input.to_boolean() {
             visitor.visit_bool(val.value().unwrap())
@@ -58,7 +58,7 @@ impl<'de, IT: InnerTypes> Deserializer<'de> for NativeSerdeDeserializer<IT> {
     where
         V: Visitor<'de>,
     {
-        if self.input.is_null() || self.input.is_undefined() {
+        if self.input.is_null()? || self.input.is_undefined()? {
             visitor.visit_none()
         } else {
             visitor.visit_some(self)
diff --git a/rust/cubenativeutils/src/wrappers/serializer/error.rs b/rust/cubenativeutils/src/wrappers/serializer/error.rs
index 50e55c88da9f4..2b27014cf1a4c 100644
--- a/rust/cubenativeutils/src/wrappers/serializer/error.rs
+++ b/rust/cubenativeutils/src/wrappers/serializer/error.rs
@@ -1,3 +1,4 @@
+use cubesql::CubeError;
 use serde::{de, ser};
 use std::{fmt, fmt::Display};
 #[derive(Debug)]
@@ -26,3 +27,9 @@ impl Display for NativeObjSerializerError {
 }
 
 impl std::error::Error for NativeObjSerializerError {}
+
+impl From<CubeError> for NativeObjSerializerError {
+    fn from(value: CubeError) -> Self {
+        Self::Message(value.to_string())
+    }
+}
diff --git a/rust/cubenativeutils/src/wrappers/serializer/serializer.rs b/rust/cubenativeutils/src/wrappers/serializer/serializer.rs
index abbb81b4d86d9..5750bc656a364 100644
--- a/rust/cubenativeutils/src/wrappers/serializer/serializer.rs
+++ b/rust/cubenativeutils/src/wrappers/serializer/serializer.rs
@@ -55,79 +55,79 @@ impl<IT: InnerTypes> ser::Serializer for NativeSerdeSerializer<IT> {
 
     fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
         Ok(NativeObjectHandle::new(
-            self.context.boolean(v).into_object(),
+            self.context.boolean(v)?.into_object(),
         ))
     }
 
     fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
         Ok(NativeObjectHandle::new(
-            self.context.number(v as f64).into_object(),
+            self.context.number(v as f64)?.into_object(),
         ))
     }
 
     fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
         Ok(NativeObjectHandle::new(
-            self.context.number(v as f64).into_object(),
+            self.context.number(v as f64)?.into_object(),
         ))
     }
 
     fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
         Ok(NativeObjectHandle::new(
-            self.context.number(v as f64).into_object(),
+            self.context.number(v as f64)?.into_object(),
         ))
     }
 
     fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
         Ok(NativeObjectHandle::new(
-            self.context.number(v as f64).into_object(),
+            self.context.number(v as f64)?.into_object(),
         ))
     }
 
     fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
         Ok(NativeObjectHandle::new(
-            self.context.number(v as f64).into_object(),
+            self.context.number(v as f64)?.into_object(),
         ))
     }
 
     fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
         Ok(NativeObjectHandle::new(
-            self.context.number(v as f64).into_object(),
+            self.context.number(v as f64)?.into_object(),
         ))
     }
 
     fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
         Ok(NativeObjectHandle::new(
-            self.context.number(v as f64).into_object(),
+            self.context.number(v as f64)?.into_object(),
         ))
     }
 
     fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
         Ok(NativeObjectHandle::new(
-            self.context.number(v as f64).into_object(),
+            self.context.number(v as f64)?.into_object(),
         ))
     }
 
     fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
         Ok(NativeObjectHandle::new(
-            self.context.number(v as f64).into_object(),
+            self.context.number(v as f64)?.into_object(),
         ))
     }
 
     fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
         Ok(NativeObjectHandle::new(
-            self.context.number(v as f64).into_object(),
+            self.context.number(v as f64)?.into_object(),
         ))
     }
 
     fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
         Ok(NativeObjectHandle::new(
-            self.context.string(String::from(v)).into_object(),
+            self.context.string(String::from(v))?.into_object(),
         ))
     }
 
     fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
         Ok(NativeObjectHandle::new(
-            self.context.string(String::from(v)).into_object(),
+            self.context.string(String::from(v))?.into_object(),
         ))
     }
 
@@ -138,7 +138,7 @@ impl<IT: InnerTypes> ser::Serializer for NativeSerdeSerializer<IT> {
     }
 
     fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
-        Ok(self.context.undefined())
+        Ok(self.context.undefined()?)
     }
 
     fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
@@ -149,11 +149,11 @@ impl<IT: InnerTypes> ser::Serializer for NativeSerdeSerializer<IT> {
     }
 
     fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        Ok(self.context.undefined())
+        Ok(self.context.undefined()?)
     }
 
     fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
-        Ok(self.context.undefined())
+        Ok(self.context.undefined()?)
     }
 
     fn serialize_unit_variant(
@@ -194,7 +194,7 @@ impl<IT: InnerTypes> ser::Serializer for NativeSerdeSerializer<IT> {
     }
 
     fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
-        let seq = self.context.empty_array();
+        let seq = self.context.empty_array()?;
 
         Ok(NativeSeqSerializer {
             context: self.context.clone(),
@@ -232,7 +232,7 @@ impl<IT: InnerTypes> ser::Serializer for NativeSerdeSerializer<IT> {
     }
 
     fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
-        let obj = self.context.empty_struct();
+        let obj = self.context.empty_struct()?;
         Ok(NativeMapSerializer {
             context: self.context.clone(),
             obj,
@@ -244,7 +244,7 @@ impl<IT: InnerTypes> ser::Serializer for NativeSerdeSerializer<IT> {
         _name: &'static str,
         _len: usize,
     ) -> Result<Self::SerializeStruct, Self::Error> {
-        let obj = self.context.empty_struct();
+        let obj = self.context.empty_struct()?;
         Ok(NativeMapSerializer {
             context: self.context.clone(),
             obj,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_sql.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_sql.rs
index 1883d75b53c6f..993fd76dc81d3 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_sql.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_sql.rs
@@ -82,20 +82,20 @@ impl<IT: InnerTypes> NativeSerialize<IT> for MemberSqlStruct {
         &self,
         context: NativeContextHolder<IT>,
     ) -> Result<NativeObjectHandle<IT>, CubeError> {
-        let res = context.empty_struct();
+        let res = context.empty_struct()?;
         for (k, v) in self.properties.iter() {
             res.set_field(k, v.to_native(context.clone())?)?;
         }
         if let Some(to_string_fn) = &self.to_string_fn {
             res.set_field(
                 "toString",
-                NativeObjectHandle::new(context.to_string_fn(to_string_fn.clone()).into_object()),
+                NativeObjectHandle::new(context.to_string_fn(to_string_fn.clone())?.into_object()),
             )?;
         }
         if let Some(sql_fn) = &self.sql_fn {
             res.set_field(
                 "sql",
-                NativeObjectHandle::new(context.to_string_fn(sql_fn.clone()).into_object()),
+                NativeObjectHandle::new(context.to_string_fn(sql_fn.clone())?.into_object()),
             )?;
         }
         Ok(NativeObjectHandle::new(res.into_object()))
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
index 304372f54ffdd..21de374816760 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
@@ -40,13 +40,13 @@ impl<IT: InnerTypes> BaseQuery<IT> {
 
     pub fn build_sql_and_params(&self) -> NativeObjectHandle<IT> {
         let build_result = self.build_sql_and_params_impl();
-        let result = self.context.empty_struct();
+        let result = self.context.empty_struct().unwrap();
         match build_result {
             Ok(res) => {
                 result.set_field("result", res).unwrap();
             }
             Err(e) => {
-                let error_descr = self.context.empty_struct();
+                let error_descr = self.context.empty_struct().unwrap();
                 let error_cause = match &e.cause {
                     CubeErrorCauseType::User(_) => "User",
                     CubeErrorCauseType::Internal(_) => "Internal",
@@ -80,7 +80,7 @@ impl<IT: InnerTypes> BaseQuery<IT> {
         let sql = plan.to_sql(&templates)?;
         let (result_sql, params) = self.query_tools.build_sql_and_params(&sql, true)?;
 
-        let res = self.context.empty_array();
+        let res = self.context.empty_array()?;
         res.set(0, result_sql.to_native(self.context.clone())?)?;
         res.set(1, params.to_native(self.context.clone())?)?;
         let result = NativeObjectHandle::new(res.into_object());

From 121aa549b9c7497efe0a783f7222357c14572531 Mon Sep 17 00:00:00 2001
From: Alexandr Romanenko <alex.romanenko@cube.dev>
Date: Fri, 24 Jan 2025 19:12:36 +0100
Subject: [PATCH 15/16] update

---
 .../src/wrappers/neon/context.rs              | 46 +++++++++++++++----
 1 file changed, 36 insertions(+), 10 deletions(-)

diff --git a/rust/cubenativeutils/src/wrappers/neon/context.rs b/rust/cubenativeutils/src/wrappers/neon/context.rs
index 52c780494a34c..03376b3bbe587 100644
--- a/rust/cubenativeutils/src/wrappers/neon/context.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/context.rs
@@ -1,4 +1,3 @@
-//use super::object::NeonObject;
 use super::{
     inner_types::NeonInnerTypes,
     object::{
@@ -7,12 +6,15 @@ use super::{
     },
 };
 use crate::wrappers::{
-    context::NativeContext, object::NativeObject, object_handle::NativeObjectHandle,
+    context::{NativeContext, NativeContextHolder},
+    object::NativeObject,
+    object_handle::NativeObjectHandle,
 };
 use cubesql::CubeError;
 use neon::prelude::*;
 use std::{
-    cell::RefCell,
+    cell::{RefCell, RefMut},
+    marker::PhantomData,
     panic::{catch_unwind, resume_unwind, AssertUnwindSafe},
     rc::{Rc, Weak},
 };
@@ -50,18 +52,42 @@ impl<C: Context<'static>> ContextWrapper<C> {
     }
 }
 
+pub struct NeonContextGuard<'cx, C: Context<'cx> + NoenContextLifetimeExpand<'cx>> {
+    context: Rc<RefCell<ContextWrapper<C::ExpandedResult>>>,
+    lifetime: PhantomData<&'cx ()>,
+}
+
+impl<'cx, C: Context<'cx> + NoenContextLifetimeExpand<'cx> + 'cx> NeonContextGuard<'cx, C> {
+    fn new(cx: C) -> Self {
+        Self {
+            context: ContextWrapper::new(cx.expand_lifetime()),
+            lifetime: PhantomData::default(),
+        }
+    }
+
+    fn context_holder(&self) -> ContextHolder<C::ExpandedResult> {
+        ContextHolder::new(Rc::downgrade(&self.context))
+    }
+
+    fn unwrap(self) {
+        if Rc::strong_count(&self.context) > 0 {
+            match Rc::try_unwrap(self.context) {
+                Ok(_) => {}
+                Err(_) => panic!("Guarded context have more then one reference"),
+            }
+        }
+    }
+}
+
 pub fn neon_run_with_guarded_lifetime<'cx, C, T, F>(cx: C, func: F) -> T
 where
-    C: Context<'cx> + NoenContextLifetimeExpand<'cx>,
+    C: Context<'cx> + NoenContextLifetimeExpand<'cx> + 'cx,
     F: FnOnce(ContextHolder<C::ExpandedResult>) -> T,
 {
-    let context = ContextWrapper::new(cx.expand_lifetime());
-    let context_holder = ContextHolder::new(Rc::downgrade(&context));
+    let guard = NeonContextGuard::new(cx);
+    let context_holder = guard.context_holder();
     let res = catch_unwind(AssertUnwindSafe(|| func(context_holder)));
-    match Rc::try_unwrap(context) {
-        Ok(_) => {}
-        Err(_) => panic!("Guarded context have more then one reference"),
-    };
+    guard.unwrap();
 
     match res {
         Ok(res) => res,

From 58836036094d4a3e480eccea210ac7710f3ad0bb Mon Sep 17 00:00:00 2001
From: Alexandr Romanenko <alex.romanenko@cube.dev>
Date: Wed, 5 Feb 2025 17:36:35 +0100
Subject: [PATCH 16/16] update

---
 rust/cubenativeutils/src/wrappers/context.rs                | 2 +-
 rust/cubenativeutils/src/wrappers/neon/context.rs           | 6 ++----
 rust/cubenativeutils/src/wrappers/neon/object/neon_array.rs | 2 +-
 3 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/rust/cubenativeutils/src/wrappers/context.rs b/rust/cubenativeutils/src/wrappers/context.rs
index a99532764ec9f..9695b30717ec3 100644
--- a/rust/cubenativeutils/src/wrappers/context.rs
+++ b/rust/cubenativeutils/src/wrappers/context.rs
@@ -1,4 +1,4 @@
-use super::{inner_types::InnerTypes, object::NativeBox, object_handle::NativeObjectHandle};
+use super::{inner_types::InnerTypes, object_handle::NativeObjectHandle};
 use cubesql::CubeError;
 
 pub trait NativeContext<IT: InnerTypes>: Clone {
diff --git a/rust/cubenativeutils/src/wrappers/neon/context.rs b/rust/cubenativeutils/src/wrappers/neon/context.rs
index 03376b3bbe587..cc5139110f393 100644
--- a/rust/cubenativeutils/src/wrappers/neon/context.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/context.rs
@@ -6,14 +6,12 @@ use super::{
     },
 };
 use crate::wrappers::{
-    context::{NativeContext, NativeContextHolder},
-    object::NativeObject,
-    object_handle::NativeObjectHandle,
+    context::NativeContext, object::NativeObject, object_handle::NativeObjectHandle,
 };
 use cubesql::CubeError;
 use neon::prelude::*;
 use std::{
-    cell::{RefCell, RefMut},
+    cell::RefCell,
     marker::PhantomData,
     panic::{catch_unwind, resume_unwind, AssertUnwindSafe},
     rc::{Rc, Weak},
diff --git a/rust/cubenativeutils/src/wrappers/neon/object/neon_array.rs b/rust/cubenativeutils/src/wrappers/neon/object/neon_array.rs
index e495ebbc38b19..08dea2a0c1ee0 100644
--- a/rust/cubenativeutils/src/wrappers/neon/object/neon_array.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/object/neon_array.rs
@@ -1,7 +1,7 @@
 use super::{NeonObject, NeonTypeHandle};
 use crate::wrappers::{
     neon::inner_types::NeonInnerTypes,
-    object::{NativeArray, NativeObject, NativeType},
+    object::{NativeArray, NativeType},
     object_handle::NativeObjectHandle,
 };
 use cubesql::CubeError;