diff --git a/packages/cubejs-backend-native/src/node_export.rs b/packages/cubejs-backend-native/src/node_export.rs
index 5d4eb733206c6..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,37 +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 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().unwrap();
-
-    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/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js b/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
index d7863713f6b2a..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;
@@ -3332,6 +3342,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 +3359,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 }}',
@@ -3803,6 +3815,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/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/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/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/cubenativeutils/src/wrappers/context.rs b/rust/cubenativeutils/src/wrappers/context.rs
index 98bb3ba6f7eb9..9695b30717ec3 100644
--- a/rust/cubenativeutils/src/wrappers/context.rs
+++ b/rust/cubenativeutils/src/wrappers/context.rs
@@ -1,13 +1,15 @@
 use super::{inner_types::InnerTypes, 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 to_string_fn(&self, result: String) -> IT::Function;
+    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) -> Result<IT::Function, CubeError>;
 }
 
 #[derive(Clone)]
@@ -22,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 96950e5e3aedb..cc5139110f393 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::{
@@ -12,21 +11,31 @@ use crate::wrappers::{
 use cubesql::CubeError;
 use neon::prelude::*;
 use std::{
-    cell::{RefCell, RefMut},
+    cell::RefCell,
     marker::PhantomData,
+    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,129 +50,129 @@ impl<'cx, C: Context<'cx>> ContextWrapper<'cx, C> {
     }
 }
 
-pub struct ContextHolder<'cx, C: Context<'cx>> {
-    context: Rc<RefCell<ContextWrapper<'cx, C>>>,
+pub struct NeonContextGuard<'cx, C: Context<'cx> + NoenContextLifetimeExpand<'cx>> {
+    context: Rc<RefCell<ContextWrapper<C::ExpandedResult>>>,
+    lifetime: PhantomData<&'cx ()>,
 }
 
-impl<'cx, C: Context<'cx> + 'cx> ContextHolder<'cx, C> {
-    pub fn new(cx: C) -> Self {
+impl<'cx, C: Context<'cx> + NoenContextLifetimeExpand<'cx> + 'cx> NeonContextGuard<'cx, C> {
+    fn new(cx: C) -> Self {
         Self {
-            context: ContextWrapper::new(cx),
+            context: ContextWrapper::new(cx.expand_lifetime()),
+            lifetime: PhantomData::default(),
         }
     }
 
-    pub fn borrow_mut(&self) -> RefMut<ContextWrapper<'cx, C>> {
-        self.context.borrow_mut()
+    fn context_holder(&self) -> ContextHolder<C::ExpandedResult> {
+        ContextHolder::new(Rc::downgrade(&self.context))
     }
 
-    pub fn with_context<T, F>(&self, f: F) -> T
-    where
-        F: FnOnce(&mut C) -> T,
-    {
-        let mut context = self.context.borrow_mut();
-        context.with_context(f)
+    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> + 'cx,
+    F: FnOnce(ContextHolder<C::ExpandedResult>) -> T,
+{
+    let guard = NeonContextGuard::new(cx);
+    let context_holder = guard.context_holder();
+    let res = catch_unwind(AssertUnwindSafe(|| func(context_holder)));
+    guard.unwrap();
+
+    match res {
+        Ok(res) => res,
+        Err(e) => resume_unwind(e),
     }
+}
+
+pub struct ContextHolder<C: Context<'static>> {
+    context: Weak<RefCell<ContextWrapper<C>>>,
+}
 
-    /* pub fn as_native_context_holder(&self) -> NativeContextHolder {
-        NativeContextHolder::new(Box::new(self.clone()))
-    } */
+impl<C: Context<'static>> ContextHolder<C> {
+    fn new(context: Weak<RefCell<ContextWrapper<C>>>) -> Self {
+        Self { context }
+    }
 
-    pub fn weak(&self) -> WeakContextHolder<'cx, C> {
-        WeakContextHolder {
-            context: Rc::downgrade(&self.context),
+    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!(
+                "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 26e58fc21f982..54d1a7de02285 100644
--- a/rust/cubenativeutils/src/wrappers/neon/object/base_types.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/object/base_types.rs
@@ -1,75 +1,103 @@
-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>,
+pub struct NeonString<C: Context<'static>> {
+    object: NeonTypeHandle<C, JsString>,
 }
 
-impl<'cx, C: Context<'cx>> NeonString<'cx, C> {
-    pub fn new(object: NeonObject<'cx, C>) -> 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> {
-        self.object
+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_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>,
+pub struct NeonNumber<C: Context<'static>> {
+    object: NeonTypeHandle<C, JsNumber>,
 }
 
-impl<'cx, C: Context<'cx>> NeonNumber<'cx, C> {
-    pub fn new(object: NeonObject<'cx, C>) -> 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> {
-        self.object
+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_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>,
+pub struct NeonBoolean<C: Context<'static>> {
+    object: NeonTypeHandle<C, JsBoolean>,
 }
 
-impl<'cx, C: Context<'cx>> NeonBoolean<'cx, C> {
-    pub fn new(object: NeonObject<'cx, C>) -> 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> {
-        self.object
+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_downcast_neon_object::<JsBoolean, _, _>(|cx, object| Ok(object.value(cx)))
+            .map_neon_object::<_, _>(|cx, object| Ok(object.value(cx)))?
+    }
+}
+
+pub struct NeonBox<C: Context<'static>, T: 'static> {
+    object: NeonTypeHandle<C, JsBox<T>>,
+    _marker: PhantomData<T>,
+}
+
+impl<C: Context<'static>, T: 'static> NeonBox<C, T> {
+    pub fn new(object: NeonTypeHandle<C, JsBox<T>>) -> Self {
+        Self {
+            object,
+            _marker: PhantomData::default(),
+        }
+    }
+}
+
+impl<C: Context<'static> + 'static, T: 'static> NativeType<NeonInnerTypes<C>> for NeonBox<C, T> {
+    fn into_object(self) -> NeonObject<C> {
+        self.object.upcast()
+    }
+}
+
+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 40763a228b97d..54b28d10684b5 100644
--- a/rust/cubenativeutils/src/wrappers/neon/object/mod.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/object/mod.rs
@@ -14,37 +14,46 @@ use crate::wrappers::{neon::context::ContextHolder, object::NativeObject};
 use cubesql::CubeError;
 use neon::prelude::*;
 
-pub struct NeonObject<'cx: 'static, C: Context<'cx>> {
-    context: ContextHolder<'cx, C>,
-    object: Handle<'cx, JsValue>,
+pub struct NeonTypeHandle<C: Context<'static>, V: Value + 'static> {
+    context: ContextHolder<C>,
+    object: Handle<'static, V>,
 }
 
-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, V: Value + 'static> NeonTypeHandle<C, V> {
+    pub fn new(context: ContextHolder<C>, object: Handle<'static, V>) -> Self {
         Self { context, object }
     }
 
-    pub fn get_object(&self) -> Handle<'cx, JsValue> {
+    fn get_context(&self) -> ContextHolder<C> {
+        self.context.clone()
+    }
+
+    pub fn get_object(&self) -> Handle<'static, V> {
         self.object.clone()
     }
 
-    pub fn get_object_ref(&self) -> &Handle<'cx, JsValue> {
+    pub fn get_object_ref(&self) -> &Handle<'static, V> {
         &self.object
     }
 
-    pub fn into_object(self) -> Handle<'cx, JsValue> {
+    pub fn into_object(self) -> Handle<'static, V> {
         self.object
     }
 
-    pub fn map_neon_object<T, F>(&self, f: F) -> T
+    pub fn upcast(&self) -> NeonObject<C> {
+        NeonObject::new(self.context.clone(), self.object.upcast())
+    }
+
+    pub fn map_neon_object<T, F>(&self, f: F) -> Result<T, CubeError>
     where
-        F: FnOnce(&mut C, &Handle<'cx, JsValue>) -> 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
@@ -52,80 +61,111 @@ impl<'cx: 'static, C: Context<'cx> + 'cx> NeonObject<'cx, C> {
                 .downcast::<JT, _>(cx)
                 .map_err(|_| CubeError::internal("Downcast error".to_string()))?;
             f(cx, &obj)
-        })
+        })?
+    }
+
+    pub fn is_a<U: Value>(&self) -> Result<bool, CubeError> {
+        self.context.with_context(|cx| self.object.is_a::<U, _>(cx))
+    }
+}
+
+impl<C: Context<'static>, V: Value + 'static> Clone for NeonTypeHandle<C, V> {
+    fn clone(&self) -> Self {
+        Self {
+            context: self.context.clone(),
+            object: self.object.clone(),
+        }
+    }
+}
+
+pub struct NeonObject<C: Context<'static>> {
+    context: ContextHolder<C>,
+    object: Handle<'static, JsValue>,
+}
+
+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<'static, JsValue> {
+        self.object.clone()
+    }
+
+    pub fn get_object_ref(&self) -> &Handle<'static, JsValue> {
+        &self.object
+    }
+
+    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<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<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> {
-        if !self.is_a::<JsObject>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsObject"
-            )));
-        }
-        Ok(NeonStruct::new(self))
+    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> {
-        if !self.is_a::<JsFunction>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsFunction"
-            )));
-        }
-        Ok(NeonFunction::new(self))
+    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> {
-        if !self.is_a::<JsArray>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsArray"
-            )));
-        }
-        Ok(NeonArray::new(self))
+    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> {
-        if !self.is_a::<JsString>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsString"
-            )));
-        }
-        Ok(NeonString::new(self))
+    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> {
-        if !self.is_a::<JsNumber>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsNumber"
-            )));
-        }
-        Ok(NeonNumber::new(self))
+    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> {
-        if !self.is_a::<JsBoolean>() {
-            return Err(CubeError::internal(format!(
-                "NeonObject is not the JsBoolean"
-            )));
-        }
-        Ok(NeonBoolean::<C>::new(self))
+    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 dc06714227c61..08dea2a0c1ee0 100644
--- a/rust/cubenativeutils/src/wrappers/neon/object/neon_array.rs
+++ b/rust/cubenativeutils/src/wrappers/neon/object/neon_array.rs
@@ -1,46 +1,40 @@
-use super::NeonObject;
+use super::{NeonObject, NeonTypeHandle};
 use crate::wrappers::{
     neon::inner_types::NeonInnerTypes,
-    object::{NativeArray, NativeObject, NativeType},
+    object::{NativeArray, NativeType},
     object_handle::NativeObjectHandle,
 };
 use cubesql::CubeError;
 use neon::prelude::*;
 
 #[derive(Clone)]
-pub struct NeonArray<'cx: 'static, C: Context<'cx>> {
-    object: NeonObject<'cx, C>,
+pub struct NeonArray<C: Context<'static>> {
+    object: NeonTypeHandle<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 {
+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> {
-        self.object
+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_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()))
-            })?;
+    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()
@@ -50,24 +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_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)))
-            })?;
+    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 c8fc68d372d50..192db172e1c8a 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},
@@ -10,39 +10,37 @@ use neon::prelude::*;
 use regex::Regex;
 
 #[derive(Clone)]
-pub struct NeonFunction<'cx: 'static, C: Context<'cx>> {
-    object: NeonObject<'cx, C>,
+pub struct NeonFunction<C: Context<'static>> {
+    object: NeonTypeHandle<C, JsFunction>,
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NeonFunction<'cx, C> {
-    pub fn new(object: NeonObject<'cx, C>) -> 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> {
-        self.object
+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()) })
             .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(
             self.object.context.clone(),
             neon_reuslt,
@@ -53,17 +51,14 @@ 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"))
                         })?
                         .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 693c19aeb1da3..3d41ef9dbe5ff 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},
@@ -8,34 +8,32 @@ use cubesql::CubeError;
 use neon::prelude::*;
 
 #[derive(Clone)]
-pub struct NeonStruct<'cx: 'static, C: Context<'cx>> {
-    object: NeonObject<'cx, C>,
+pub struct NeonStruct<C: Context<'static>> {
+    object: NeonTypeHandle<C, JsObject>,
 }
 
-impl<'cx, C: Context<'cx> + 'cx> NeonStruct<'cx, C> {
-    pub fn new(object: NeonObject<'cx, C>) -> 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> {
-        self.object
+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| {
-            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(
             self.object.context.clone(),
             neon_result,
@@ -43,54 +41,47 @@ 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 this = neon_object
-                    .downcast::<JsObject, _>(cx)
-                    .map_err(|_| CubeError::internal(format!("Neon object is not JsObject")))?;
-                let res = this
-                    .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_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> {
+    ) -> Result<Vec<NativeObjectHandle<NeonInnerTypes<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")))?;
 
             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)))
@@ -99,27 +90,26 @@ 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()) })
             .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(),
             neon_reuslt,
diff --git a/rust/cubenativeutils/src/wrappers/object.rs b/rust/cubenativeutils/src/wrappers/object.rs
index bee3275ea3aac..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> {
@@ -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..93429cacbc117 100644
--- a/rust/cubenativeutils/src/wrappers/object_handle.rs
+++ b/rust/cubenativeutils/src/wrappers/object_handle.rs
@@ -55,13 +55,12 @@ 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 {
         self.object.get_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 21463875cddd2..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(
@@ -185,18 +185,16 @@ 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> {
-        let seq = self.context.empty_array();
+        let seq = self.context.empty_array()?;
 
         Ok(NativeSeqSerializer {
             context: self.context.clone(),
@@ -234,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,
@@ -246,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/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/base_tools.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
index ded10dda2e5d4..0ccc1567be747 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
@@ -1,8 +1,9 @@
 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 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>;
@@ -45,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/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 c4936c31259ac..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,
 };
@@ -17,10 +18,23 @@ 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)]
 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_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/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..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::memeber_sql::{MemberSql, NativeMemberSql};
+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;
@@ -26,6 +27,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)]
@@ -58,9 +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]
+    #[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 a7973e0c6047d..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::memeber_sql::{MemberSql, NativeMemberSql};
-use cubenativeutils::wrappers::object::NativeArray;
+use super::member_sql::{MemberSql, NativeMemberSql};
 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_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_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 56905aa825306..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::memeber_sql::{MemberSql, NativeMemberSql};
-use cubenativeutils::wrappers::object::NativeArray;
+use super::member_sql::{MemberSql, NativeMemberSql};
 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/memeber_sql.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_sql.rs
similarity index 78%
rename from rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/memeber_sql.rs
rename to rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/member_sql.rs
index 3dbf3a967f713..993fd76dc81d3 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/memeber_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>),
 }
@@ -37,9 +39,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>,
@@ -50,14 +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()),
             )?;
         }
         Ok(NativeObjectHandle::new(res.into_object()))
@@ -79,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()
@@ -131,6 +175,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..6fa12c63c418c 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs
@@ -5,14 +5,19 @@ 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_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 memeber_sql;
+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/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/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/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/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 123463e24075f..df354bacebcb7 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>,
 }
@@ -74,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..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)
     }
@@ -180,8 +240,13 @@ impl JoinCondition {
     ) -> Result<String, CubeError> {
         match &self {
             JoinCondition::DimensionJoinCondition(cond) => cond.to_sql(templates, context),
-            JoinCondition::BaseJoinCondition(cond) => cond.to_sql(context),
-            JoinCondition::RollingWindowJoinCondition(cond) => cond.to_sql(templates, context),
+            JoinCondition::BaseJoinCondition(cond) => cond.to_sql(context, templates),
+            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/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_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 bca6d99ca2a34..87bb6740aa00d 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs
@@ -1,6 +1,8 @@
 use super::query_tools::QueryTools;
-use super::sql_evaluator::MemberSymbol;
+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;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
@@ -8,14 +10,30 @@ pub struct BaseDimension {
     dimension: String,
     query_tools: Rc<QueryTools>,
     member_evaluator: Rc<MemberSymbol>,
+    definition: Option<Rc<dyn DimensionDefinition>>,
+    #[allow(dead_code)]
+    member_expression_definition: Option<String>,
     cube_name: String,
     name: String,
     default_alias: String,
 }
 
 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 full_name(&self) -> String {
+        self.member_evaluator.full_name()
     }
 
     fn alias_name(&self) -> String {
@@ -58,6 +76,8 @@ impl BaseDimension {
                     member_evaluator: evaluation_node.clone(),
                     cube_name: s.cube_name().clone(),
                     name: s.name().clone(),
+                    definition: Some(s.definition().clone()),
+                    member_expression_definition: None,
                     default_alias,
                 }))
             }
@@ -79,11 +99,72 @@ 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()
     }
 
+    pub fn sql_call(&self) -> Result<Rc<SqlCall>, CubeError> {
+        match self.member_evaluator.as_ref() {
+            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"
+            ))),
+        }
+    }
+
     pub fn dimension(&self) -> &String {
         &self.dimension
     }
+
+    pub fn is_sub_query(&self) -> bool {
+        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.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_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 e61724563d367..4a1941e806842 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
@@ -1,9 +1,10 @@
 use super::query_tools::QueryTools;
-use super::sql_evaluator::MemberSymbol;
+use super::sql_evaluator::{MemberExpressionSymbol, MemberSymbol, SqlCall};
 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;
@@ -66,7 +67,9 @@ pub struct BaseMeasure {
     measure: String,
     query_tools: Rc<QueryTools>,
     member_evaluator: Rc<MemberSymbol>,
-    definition: Rc<dyn MeasureDefinition>,
+    definition: Option<Rc<dyn MeasureDefinition>>,
+    #[allow(dead_code)]
+    member_expression_definition: Option<String>,
     time_shifts: Vec<MeasureTimeShift>,
     cube_name: String,
     name: String,
@@ -84,8 +87,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 {
@@ -100,6 +112,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 +143,8 @@ 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()),
+                    member_expression_definition: None,
                     cube_name: s.cube_name().clone(),
                     name: s.name().clone(),
                     time_shifts,
@@ -152,6 +169,51 @@ impl BaseMeasure {
         }
     }
 
+    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 {
+            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> {
+        let measure_type = self.measure_type();
+        let res = if measure_type == "countDistinct" || measure_type == "countDistinctApprox" {
+            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> {
@@ -177,28 +239,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 +276,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 +300,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_member.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
index 0618a9101b1f2..831e1081812ae 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
@@ -7,12 +7,14 @@ 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 {
-        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;
@@ -40,20 +42,19 @@ 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,
         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/base_query.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
index 6e59585e4fbbf..21de374816760 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
@@ -1,19 +1,14 @@
-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;
 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> {
@@ -43,55 +38,53 @@ 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().unwrap();
+        match build_result {
+            Ok(res) => {
+                result.set_field("result", res).unwrap();
+            }
+            Err(e) => {
+                let error_descr = self.context.empty_struct().unwrap();
+                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 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.plan()?;
 
         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());
 
         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..61e5e606c7514 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
@@ -1,12 +1,14 @@
 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 crate::planner::sql_templates::PlanSqlTemplates;
 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>>,
@@ -15,8 +17,17 @@ pub struct BaseTimeDimension {
 }
 
 impl BaseMember for BaseTimeDimension {
-    fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
-        self.dimension.to_sql(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 {
@@ -24,7 +35,11 @@ impl BaseMember for BaseTimeDimension {
     }
 
     fn member_evaluator(&self) -> Rc<MemberSymbol> {
-        self.dimension.member_evaluator()
+        self.member_evaluator.clone()
+    }
+
+    fn full_name(&self) -> String {
+        self.member_evaluator.full_name()
     }
 
     fn as_base_member(self: Rc<Self>) -> Rc<dyn BaseMember> {
@@ -56,13 +71,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 +90,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 +106,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/filter/base_filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
index b9e5a8829735d..4b77c9eef4e96 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,89 @@ 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::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)?,
+                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)
     }
@@ -154,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)
     }
@@ -179,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)?
@@ -194,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> {
@@ -296,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"
@@ -309,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"
@@ -354,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> {
@@ -390,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/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..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,
@@ -21,19 +22,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 +47,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 442700dca052d..ea9ba1d53d24d 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
@@ -32,7 +32,8 @@ impl CommonUtils {
             .static_data()
             .primary_keys
             .get(cube_name)
-            .unwrap();
+            .cloned()
+            .unwrap_or_else(|| vec![]);
 
         let dims = primary_keys
             .iter()
@@ -40,7 +41,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..110b36ef9b91c
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs
@@ -0,0 +1,204 @@
+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(),
+            None,
+            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![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.plan()?;
+        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..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
@@ -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) {
@@ -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() {
@@ -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..1c1c340ecfc57 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs
@@ -1,6 +1,7 @@
-use super::CommonUtils;
+use super::{CommonUtils, DimensionSubqueryPlanner};
 use crate::cube_bridge::join_definition::JoinDefinition;
-use crate::cube_bridge::memeber_sql::MemberSql;
+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;
 use crate::planner::sql_evaluator::SqlCall;
@@ -24,27 +25,30 @@ 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)?;
-        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.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)),
             );
-            for join in joins.items().iter() {
+            dimension_subquery_planner.add_joins_for_cube(&mut join_builder, root.name())?;
+            for join in joins.iter() {
                 let definition = join.join()?;
                 let sql_call = self
                     .compile_join_condition(&join.static_data().original_from, definition.sql()?)?;
@@ -60,6 +64,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/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..de7b566469b72 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,22 @@ pub enum MultiStageMemberType {
 pub struct MultiStageMember {
     member_type: MultiStageMemberType,
     evaluation_node: Rc<MemberSymbol>,
+    is_ungrupped: bool,
+    has_aggregates_on_top: 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,
+        has_aggregates_on_top: bool,
+    ) -> Rc<Self> {
         Rc::new(Self {
             member_type,
             evaluation_node,
+            is_ungrupped,
+            has_aggregates_on_top,
         })
     }
 
@@ -171,4 +215,12 @@ impl MultiStageMember {
     pub fn full_name(&self) -> String {
         self.evaluation_node.full_name()
     }
+
+    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 fd0c237164271..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
@@ -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,44 +379,31 @@ 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 self.description.member().has_aggregates_on_top() {
+            node_factory.set_count_approx_as_state(true);
+        }
 
-        /* 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::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 result = Cte::new_from_select(Rc::new(cte_select), self.description.alias().clone());
+        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..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
@@ -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,8 @@ impl MultiStageQueryPlanner {
                             time_dimension.clone(),
                         )),
                         time_dimension.member_evaluator(),
+                        true,
+                        false,
                     ),
                     state.clone(),
                     vec![],
@@ -190,6 +196,8 @@ impl MultiStageQueryPlanner {
             MultiStageMember::new(
                 MultiStageMemberType::Leaf(MultiStageLeafMemberType::Measure),
                 member,
+                self.query_properties.ungrouped(),
+                true,
             ),
             state,
             vec![],
@@ -199,6 +207,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 +250,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 +278,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 +312,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 +331,15 @@ 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(),
+                        false,
+                    ),
                     state.clone(),
                     input,
                     alias.clone(),
@@ -342,13 +388,16 @@ impl MultiStageQueryPlanner {
                 MultiStageMember::new(
                     MultiStageMemberType::Leaf(MultiStageLeafMemberType::Measure),
                     member.clone(),
+                    self.query_properties.ungrouped(),
+                    false,
                 ),
                 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 +435,12 @@ 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,
+                    false,
+                ),
                 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 14ecfd86aa0e5..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
@@ -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,10 +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_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;
@@ -22,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> {
@@ -46,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,
@@ -68,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()
@@ -101,7 +109,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 =
@@ -112,13 +136,14 @@ 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(
                 key_cube_name,
                 &measures,
                 &primary_keys_dimensions,
+                &dimension_subquery_planner,
             )?;
 
             let conditions = primary_keys_dimensions
@@ -173,12 +198,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![])?
@@ -209,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)))
     }
 
@@ -241,13 +274,26 @@ 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());
+
+        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);
@@ -264,17 +310,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_symbols(
+            &self.query_properties.all_member_symbols(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 +339,15 @@ 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);
+        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)))
     }
 
@@ -295,20 +357,50 @@ 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 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,
+            self.query_tools.clone(),
+            self.query_properties.clone(),
+        )?;
+
+        let source = self.join_planner.make_join_node_impl(
+            &Some(format!(
+                "{}_key",
+                self.query_tools.alias_for_cube(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..5780daf4e73bc
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/query_planner.rs
@@ -0,0 +1,85 @@
+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>,
+    context_factory: Option<SqlNodesFactory>,
+}
+
+impl QueryPlanner {
+    pub fn new(request: Rc<QueryProperties>, query_tools: Rc<QueryTools>) -> Self {
+        Self {
+            request,
+            query_tools,
+            context_factory: None,
+        }
+    }
+
+    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_impl(templates)
+    }
+
+    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)
+        }
+
+        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::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(
+                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..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,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_symbols;
 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_symbols(
+            &self.query_properties.all_member_symbols(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/query_properties.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
index 2b7c2d2f06d15..cbc821b6f27f6 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
@@ -1,8 +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,
@@ -37,6 +40,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 {
@@ -74,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 {
@@ -451,13 +481,28 @@ 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)
                 .collect_vec()
         }
     }
+    pub fn all_member_symbols(&self, exclude_time_dimensions: bool) -> Vec<Rc<MemberSymbol>> {
+        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);
+        }
+        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 +586,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 +604,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 +619,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/query_tools.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_tools.rs
index 5a1bfe3e4cd9c..e75372e7c4896 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(),
@@ -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)
     }
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..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,31 +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());
+                    }
                 }
-                for name in e.get_dependent_cubes().into_iter() {
-                    self.names.insert(name);
+                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.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) => {
+                if !path.is_empty() {
+                    for p in path {
+                        self.names.insert(p.clone());
+                    }
+                }
                 self.names.insert(e.cube_name().clone());
             }
-            MemberSymbol::CubeTable(e) => {
-                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 b33ea186c6083..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,48 +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()));
+                    }
                 }
-                for name in e.get_dependent_cubes().into_iter() {
-                    self.hints.push(name);
+                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(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());
+                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/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/mod.rs
index 1a3241bf740c4..3315b5dfa2b79 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,7 @@ 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,
+    collect_sub_query_dimensions_from_symbols,
+};
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
new file mode 100644
index 0000000000000..e5e16d4cd53a7
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/sub_query_dimensions.rs
@@ -0,0 +1,90 @@
+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 {
+    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>,
+        path: &Vec<String>,
+        _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(()))
+            }
+            MemberSymbol::TimeDimension(dim) => self.on_node_traverse(dim.base_symbol(), path, &()),
+            _ => 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 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, &())?;
+    }
+    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/compiler.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs
index 9e87582b8c7d1..fe20a91af738a 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs
@@ -6,7 +6,8 @@ use super::{
     SqlCall, SymbolFactory, TraversalVisitor,
 };
 use crate::cube_bridge::evaluator::CubeEvaluator;
-use crate::cube_bridge::memeber_sql::MemberSql;
+use crate::cube_bridge::join_hints::JoinHintItem;
+use crate::cube_bridge::member_sql::MemberSql;
 use cubenativeutils::CubeError;
 use std::collections::HashMap;
 use std::rc::Rc;
@@ -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/dependecy.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs
index ce284b26387b3..b1c69f57230b1 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;
@@ -41,6 +41,7 @@ pub enum ContextSymbolDep {
     SecurityContext,
     FilterParams,
     FilterGroup,
+    SqlUtils,
 }
 
 #[derive(Clone)]
@@ -68,9 +69,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() {
@@ -165,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/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs
index df22f8bc00b64..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,
+    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 35fed31484c9a..63a9a906f4805 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,17 +22,36 @@ 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)
     }
 
+    pub fn get_dependencies(&self) -> Vec<Rc<MemberSymbol>> {
+        let mut deps = Vec::new();
+        self.extract_symbol_deps(&mut deps);
+        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 {
@@ -44,6 +64,24 @@ 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);
+        deps
+    }
+
     pub fn extract_cube_deps(&self, result: &mut Vec<String>) {
         for dep in self.deps.iter() {
             match dep {
@@ -71,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());
 
@@ -90,14 +151,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())
             }
@@ -110,24 +178,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);
@@ -152,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)
     }
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 63587cb9289ed..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
@@ -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,18 +22,77 @@ 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(), templates)?;
+                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())
-            }
-            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::MemberExpression(e) => e.evaluate_sql(
+                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 a288558b292e8..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
@@ -1,12 +1,11 @@
-use super::leaf_time_dimension::LeafTimeDimensionNode;
 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,9 +13,10 @@ 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>,
-    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
@@ -29,10 +29,11 @@ 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(),
-            leaf_time_dimensions: HashMap::new(),
+            rendered_as_multiplied_measures: HashSet::new(),
             multi_stage_rank: None,
             multi_stage_window: None,
             rolling_window: false,
@@ -59,6 +60,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);
     }
@@ -67,11 +72,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);
     }
@@ -80,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>,
@@ -116,7 +120,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(),
@@ -163,22 +167,26 @@ impl SqlNodesFactory {
         } else if self.rolling_window {
             RollingWindowNode::new(input)
         } else {
-            FinalMeasureSqlNode::new(input)
+            FinalMeasureSqlNode::new(
+                input,
+                self.rendered_as_multiplied_measures.clone(),
+                self.count_approx_as_state,
+            )
         }
     }
 
     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 {
             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/final_measure.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/final_measure.rs
index c844c2a786de4..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
@@ -1,23 +1,44 @@
 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>,
+    count_approx_as_state: bool,
 }
 
 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>,
+        count_approx_as_state: bool,
+    ) -> Rc<Self> {
+        Rc::new(Self {
+            input,
+            rendered_as_multiplied_measures,
+            count_approx_as_state,
+        })
     }
 
     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 +48,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 +57,20 @@ impl SqlNode for FinalMeasureSqlNode {
                     node,
                     query_tools.clone(),
                     node_processor.clone(),
+                    templates,
                 )?;
                 //};
 
                 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 {
                     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..d6691f59d3942
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/geo_dimension.rs
@@ -0,0 +1,86 @@
+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;
+
+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/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/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 346fb326cc689..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,7 +2,7 @@ pub mod auto_prefix;
 pub mod evaluate_sql;
 pub mod factory;
 pub mod final_measure;
-pub mod leaf_time_dimension;
+pub mod geo_dimension;
 pub mod measure_filter;
 pub mod multi_stage_rank;
 pub mod multi_stage_window;
@@ -18,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..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
@@ -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,23 +27,32 @@ 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"
-                        || 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
                 }
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..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
@@ -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;
@@ -67,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,
@@ -76,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 {
@@ -93,26 +94,35 @@ 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 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
@@ -121,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,
 }
@@ -135,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,
@@ -163,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> {
@@ -177,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 40ec863b6e8ff..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
@@ -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,9 +42,29 @@ 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) -> &Option<Rc<SqlCall>> {
+        &self.member_sql
     }
 
     pub fn full_name(&self) -> String {
@@ -51,15 +78,48 @@ 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 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);
+        }
+        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
     }
 
     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
     }
 
@@ -67,6 +127,10 @@ impl DimensionSymbol {
         &self.cube_name
     }
 
+    pub fn definition(&self) -> &Rc<dyn DimensionDefinition> {
+        &self.definition
+    }
+
     pub fn name(&self) -> &String {
         &self.name
     }
@@ -75,7 +139,7 @@ impl DimensionSymbol {
 pub struct DimensionSymbolFactory {
     cube_name: String,
     name: String,
-    sql: Rc<dyn MemberSql>,
+    sql: Option<Rc<dyn MemberSql>>,
     definition: Rc<dyn DimensionDefinition>,
 }
 
@@ -109,11 +173,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> {
@@ -123,9 +191,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..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
@@ -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::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,29 +94,77 @@ 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);
         }
         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![];
-        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 +202,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 +233,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 +249,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 +269,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,30 +286,71 @@ 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() {
+            for filter in filters.iter() {
                 let node = compiler.compile_sql_call(&cube_name, filter.sql()?)?;
                 measure_filters.push(node);
             }
         }
 
+        let mut measure_drill_filters = vec![];
+        if let Some(filters) = definition.drill_filters()? {
+            for filter in filters.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() {
+            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()?));
             }
         }
-        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/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 ac62b640e580e..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,11 +1,16 @@
-use super::{CubeNameSymbol, CubeTableSymbol, DimensionSymbol, MeasureSymbol};
+use super::{
+    CubeNameSymbol, CubeTableSymbol, DimensionSymbol, MeasureSymbol, MemberExpressionSymbol,
+    TimeDimensionSymbol,
+};
 use std::rc::Rc;
 
 pub enum MemberSymbol {
     Dimension(DimensionSymbol),
+    TimeDimension(TimeDimensionSymbol),
     Measure(MeasureSymbol),
     CubeName(CubeNameSymbol),
     CubeTable(CubeTableSymbol),
+    MemberExpression(MemberExpressionSymbol),
 }
 
 impl MemberSymbol {
@@ -28,49 +33,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::MemberExpression(e) => e.full_name().clone(),
         }
     }
     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::MemberExpression(e) => e.name().clone(),
         }
     }
 
     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::MemberExpression(e) => e.cube_name().clone(),
         }
     }
+
     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::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::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::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 ddb631648d6f1..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,13 +1,17 @@
 mod cube_symbol;
 mod dimension_symbol;
 mod measure_symbol;
+mod member_expression_symbol;
 mod member_symbol;
 mod symbol_factory;
+mod time_dimension_symbol;
 
 pub use cube_symbol::{
     CubeNameSymbol, CubeNameSymbolFactory, CubeTableSymbol, CubeTableSymbolFactory,
 };
 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/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_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..590584e872730
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/time_dimension_symbol.rs
@@ -0,0 +1,52 @@
+use super::MemberSymbol;
+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,
+        }
+    }
+
+    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.full_name.clone()
+    }
+
+    pub fn get_dependencies(&self) -> Vec<Rc<MemberSymbol>> {
+        self.base_symbol.get_dependencies()
+    }
+
+    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 {
+        self.base_symbol.cube_name()
+    }
+
+    pub fn name(&self) -> String {
+        self.base_symbol.name()
+    }
+}
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/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)
 }
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
         }
     }