diff --git a/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js b/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
index c852b18298e44..1701ad115f3af 100644
--- a/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
+++ b/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
@@ -605,34 +605,9 @@ export class BaseQuery {
     }
   }
 
-  buildSqlAndParamsTest(exportAnnotatedSql) {
-    if (!this.options.preAggregationQuery && !this.options.disableExternalPreAggregations && this.externalQueryClass) {
-      if (this.externalPreAggregationQuery()) { // TODO performance
-        return this.externalQuery().buildSqlAndParams(exportAnnotatedSql);
-      }
-    }
-    const js_res = this.compilers.compiler.withQuery(
-      this,
-      () => this.cacheValue(
-        ['buildSqlAndParams', exportAnnotatedSql],
-        () => this.paramAllocator.buildSqlAndParams(
-          this.buildParamAnnotatedSql(),
-          exportAnnotatedSql,
-          this.shouldReuseParams
-        ),
-        { cache: this.queryCache }
-      )
-    );
-    console.log('js result: ', js_res[0]);
-    const rust = this.buildSqlAndParamsRust(exportAnnotatedSql);
-    console.log('rust result: ', rust[0]);
-    return js_res;
-  }
-
   buildSqlAndParamsRust(exportAnnotatedSql) {
-
     const order = this.options.order && R.pipe(
-      R.map((hash) => (!hash || !hash.id) ? null : hash),
+      R.map((hash) => ((!hash || !hash.id) ? null : hash)),
       R.reject(R.isNil),
     )(this.options.order);
 
@@ -644,7 +619,7 @@ export class BaseQuery {
       joinRoot: this.join.root,
       joinGraph: this.joinGraph,
       cubeEvaluator: this.cubeEvaluator,
-      order: order,
+      order,
       filters: this.options.filters,
       limit: this.options.limit ? this.options.limit.toString() : null,
       rowLimit: this.options.rowLimit ? this.options.rowLimit.toString() : null,
@@ -847,7 +822,6 @@ export class BaseQuery {
     } = this.fullKeyQueryAggregateMeasures();
 
     if (!multipliedMeasures.length && !cumulativeMeasures.length && !multiStageMembers.length) {
-    console.log("!!!!! LLLOOOO!!!!");
       return this.simpleQuery();
     }
 
@@ -1061,8 +1035,6 @@ export class BaseQuery {
     const allMemberChildren = this.collectAllMemberChildren(context);
     const memberToIsMultiStage = this.collectAllMultiStageMembers(allMemberChildren);
 
-    console.log("!!! measure to her ", measureToHierarchy);
-
     const hasMultiStageMembers = (m) => {
       if (memberToIsMultiStage[m]) {
         return true;
diff --git a/packages/cubejs-schema-compiler/test/integration/clickhouse/ClickHouseDbRunner.ts b/packages/cubejs-schema-compiler/test/integration/clickhouse/ClickHouseDbRunner.ts
index f399bcfa72a7b..296a224446a57 100644
--- a/packages/cubejs-schema-compiler/test/integration/clickhouse/ClickHouseDbRunner.ts
+++ b/packages/cubejs-schema-compiler/test/integration/clickhouse/ClickHouseDbRunner.ts
@@ -5,7 +5,7 @@ import type { StartedTestContainer } from 'testcontainers';
 import { format as formatSql } from 'sqlstring';
 import { v4 as uuidv4 } from 'uuid';
 import { ClickHouseQuery } from '../../../src/adapter/ClickHouseQuery';
-import { BaseDbRunner } from "../utils/BaseDbRunner";
+import { BaseDbRunner } from '../utils/BaseDbRunner';
 
 process.env.TZ = 'GMT';
 
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 d6420fb5c0d40..f5491f153af06 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
@@ -2348,7 +2348,7 @@ describe('SQL Generation', () => {
     ]
   ));
 
-  it('rank measure', async () => runQueryTest(
+  it('rank measure 1', async () => runQueryTest(
     {
       measures: ['visitors.revenue_rank'],
     },
diff --git a/packages/cubejs-schema-compiler/test/unit/base-query.test.ts b/packages/cubejs-schema-compiler/test/unit/base-query.test.ts
index 3159fab098c41..1b1f28b9d1817 100644
--- a/packages/cubejs-schema-compiler/test/unit/base-query.test.ts
+++ b/packages/cubejs-schema-compiler/test/unit/base-query.test.ts
@@ -1596,7 +1596,7 @@ describe('SQL Generation', () => {
               sql: 'product_id',
               type: 'avg',
               filters: [
-                { sql: `{FILTER_PARAMS.Order.category.filter('category')}` }
+                { sql: '{FILTER_PARAMS.Order.category.filter(\'category\')}' }
               ]
             }
           ],
@@ -1613,7 +1613,7 @@ describe('SQL Generation', () => {
             },
             {
               name: 'proxied',
-              sql: `{FILTER_PARAMS.Order.type.filter("x => type = 'online'")}`,
+              sql: '{FILTER_PARAMS.Order.type.filter("x => type = \'online\'")}',
               type: 'boolean',
             }
           ]
diff --git a/packages/cubejs-schema-compiler/test/unit/pre-aggregations.test.ts b/packages/cubejs-schema-compiler/test/unit/pre-aggregations.test.ts
index cb6d653b4b23c..641f2aea699d5 100644
--- a/packages/cubejs-schema-compiler/test/unit/pre-aggregations.test.ts
+++ b/packages/cubejs-schema-compiler/test/unit/pre-aggregations.test.ts
@@ -217,8 +217,8 @@ describe('pre-aggregations', () => {
     console.log(JSON.stringify(preAggregationsDescription, null, 2));
 
     expect(preAggregationsDescription.length).toEqual(2);
-    expect(preAggregationsDescription[0].preAggregationId).toEqual("Orders.simple1");
-    expect(preAggregationsDescription[1].preAggregationId).toEqual("Orders.simple2");
+    expect(preAggregationsDescription[0].preAggregationId).toEqual('Orders.simple1');
+    expect(preAggregationsDescription[1].preAggregationId).toEqual('Orders.simple2');
   });
 
   // @link https://github.com/cube-js/cube/issues/6623
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/cube_definition.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/cube_definition.rs
index e7d0cbab55ffa..ead66c3433594 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/cube_definition.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/cube_definition.rs
@@ -1,5 +1,3 @@
-use super::dimension_definition::DimenstionDefinitionStatic;
-use super::measure_definition::MeasureDefinitionStatic;
 use super::memeber_sql::{MemberSql, NativeMemberSql};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
@@ -9,7 +7,6 @@ use cubenativeutils::wrappers::NativeObjectHandle;
 use cubenativeutils::CubeError;
 use serde::{Deserialize, Serialize};
 use std::any::Any;
-use std::collections::HashMap;
 use std::rc::Rc;
 
 #[derive(Serialize, Deserialize, Debug)]
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs
index 4704c44b02e32..4e143cb86f703 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs
@@ -1,33 +1,29 @@
 use crate::plan::{
-    AliasedExpr, Cte, Expr, Filter, From, MemberExpression, OrderBy, Schema, Select,
+    AliasedExpr, Cte, Expr, Filter, From, MemberExpression, OrderBy, Schema, SchemaColumn, Select,
     SingleAliasedSource, SingleSource,
 };
 
 use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
-use crate::planner::sql_evaluator::symbols::MemberSymbol;
 use crate::planner::{BaseMember, VisitorContext};
 use std::collections::HashMap;
 use std::rc::Rc;
 
 pub struct SelectBuilder {
     projection_columns: Vec<AliasedExpr>,
-    from: From,
+    from: Rc<From>,
     filter: Option<Filter>,
     group_by: Vec<Expr>,
     having: Option<Filter>,
     order_by: Vec<OrderBy>,
-    nodes_factory: SqlNodesFactory,
     ctes: Vec<Rc<Cte>>,
     is_distinct: bool,
     limit: Option<usize>,
     offset: Option<usize>,
-    input_schema: Rc<Schema>,
     result_schema: Schema,
 }
 
 impl SelectBuilder {
-    pub fn new(from: From, nodes_factory: SqlNodesFactory) -> Self {
-        let input_schema = from.schema.clone();
+    pub fn new(from: Rc<From>) -> Self {
         Self {
             projection_columns: vec![],
             from,
@@ -35,34 +31,30 @@ impl SelectBuilder {
             group_by: vec![],
             having: None,
             order_by: vec![],
-            nodes_factory,
             ctes: vec![],
             is_distinct: false,
             limit: None,
             offset: None,
-            input_schema,
             result_schema: Schema::empty(),
         }
     }
 
-    pub fn add_projection_member(
-        &mut self,
-        member: &Rc<dyn BaseMember>,
-        source: Option<String>,
-        alias: Option<String>,
-    ) {
+    pub fn add_projection_member(&mut self, member: &Rc<dyn BaseMember>, alias: Option<String>) {
         let alias = if let Some(alias) = alias {
             alias
         } else {
-            self.input_schema.resolve_member_alias(&member, &source)
+            member.alias_name()
         };
-        let expr = Expr::Member(MemberExpression::new(member.clone(), source));
+
+        let expr = Expr::Member(MemberExpression::new(member.clone()));
         let aliased_expr = AliasedExpr {
             expr,
             alias: alias.clone(),
         };
 
         self.projection_columns.push(aliased_expr);
+        self.result_schema
+            .add_column(SchemaColumn::new(alias.clone(), Some(member.full_name())));
     }
 
     pub fn set_filter(&mut self, filter: Option<Filter>) {
@@ -127,9 +119,30 @@ impl SelectBuilder {
         }
     }
 
-    pub fn build(mut self) -> Select {
+    fn make_asteriks_schema(&self) -> Rc<Schema> {
+        let schema = match &self.from.source {
+            crate::plan::FromSource::Empty => Rc::new(Schema::empty()),
+            crate::plan::FromSource::Single(source) => source.source.schema(),
+            crate::plan::FromSource::Join(join) => {
+                let mut schema = Schema::empty();
+                schema.merge(join.root.source.schema().as_ref());
+                for itm in join.joins.iter() {
+                    schema.merge(itm.from.source.schema().as_ref())
+                }
+                Rc::new(schema)
+            }
+        };
+        schema
+    }
+
+    pub fn build(self, mut nodes_factory: SqlNodesFactory) -> Select {
         let cube_references = self.make_cube_references();
-        self.nodes_factory.set_cube_name_references(cube_references);
+        nodes_factory.set_cube_name_references(cube_references);
+        let schema = if self.projection_columns.is_empty() {
+            self.make_asteriks_schema()
+        } else {
+            Rc::new(self.result_schema)
+        };
         Select {
             projection_columns: self.projection_columns,
             from: self.from,
@@ -137,11 +150,12 @@ impl SelectBuilder {
             group_by: self.group_by,
             having: self.having,
             order_by: self.order_by,
-            context: Rc::new(VisitorContext::new(&self.nodes_factory)),
+            context: Rc::new(VisitorContext::new(&nodes_factory)),
             ctes: self.ctes,
             is_distinct: self.is_distinct,
             limit: self.limit,
             offset: self.offset,
+            schema,
         }
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/cte.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/cte.rs
index dba7dd3a9c7a3..4d3ee55a6fceb 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/cte.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/cte.rs
@@ -1,4 +1,4 @@
-use super::{QueryPlan, Schema, Select};
+use super::{QueryPlan, Select};
 use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 
@@ -22,10 +22,6 @@ impl Cte {
         }
     }
 
-    pub fn make_schema(&self) -> Schema {
-        self.query.make_schema(Some(self.name().clone()))
-    }
-
     pub fn query(&self) -> &Rc<QueryPlan> {
         &self.query
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/expression.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/expression.rs
index f9189a04fc85f..be13ad59816e7 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/expression.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/expression.rs
@@ -1,4 +1,4 @@
-use super::Schema;
+use super::QualifiedColumnName;
 use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::{BaseMember, VisitorContext};
 use cubenativeutils::CubeError;
@@ -7,68 +7,45 @@ use std::rc::Rc;
 #[derive(Clone)]
 pub struct MemberExpression {
     pub member: Rc<dyn BaseMember>,
-    pub source: Option<String>,
 }
 
 impl MemberExpression {
-    pub fn new(member: Rc<dyn BaseMember>, source: Option<String>) -> Self {
-        Self { member, source }
+    pub fn new(member: Rc<dyn BaseMember>) -> Self {
+        Self { member }
     }
 
     pub fn to_sql(
         &self,
-        templates: &PlanSqlTemplates,
+        _templates: &PlanSqlTemplates,
         context: Rc<VisitorContext>,
-        schema: Rc<Schema>,
     ) -> Result<String, CubeError> {
-        if let Some(reference_column) =
-            schema.find_column_for_member(&self.member.full_name(), &self.source)
-        {
-            templates.column_reference(&reference_column.table_name, &reference_column.alias)
-        } else {
-            self.member.to_sql(context, schema)
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct ReferenceExpression {
-    pub reference: String,
-    pub source: Option<String>,
-}
-
-impl ReferenceExpression {
-    pub fn new(reference: String, source: Option<String>) -> Self {
-        Self { reference, source }
-    }
-
-    pub fn to_sql(&self, templates: &PlanSqlTemplates) -> Result<String, CubeError> {
-        templates.column_reference(&self.source, &self.reference)
+        self.member.to_sql(context)
     }
 }
 
 #[derive(Clone)]
 pub enum Expr {
     Member(MemberExpression),
-    Reference(ReferenceExpression),
+    Reference(QualifiedColumnName),
 }
 
 impl Expr {
-    pub fn new_member(member: Rc<dyn BaseMember>, source: Option<String>) -> Self {
-        Self::Member(MemberExpression::new(member, source))
+    pub fn new_member(member: Rc<dyn BaseMember>) -> Self {
+        Self::Member(MemberExpression::new(member))
     }
-    pub fn new_reference(reference: String, source: Option<String>) -> Self {
-        Self::Reference(ReferenceExpression::new(reference, source))
+    pub fn new_reference(source: Option<String>, reference: String) -> Self {
+        Self::Reference(QualifiedColumnName::new(source, reference))
     }
     pub fn to_sql(
         &self,
         templates: &PlanSqlTemplates,
         context: Rc<VisitorContext>,
-        schema: Rc<Schema>,
     ) -> Result<String, CubeError> {
         match self {
-            Self::Member(member) => member.to_sql(templates, context, schema),
-            Self::Reference(reference) => reference.to_sql(templates),
+            Self::Member(member) => member.to_sql(templates, context),
+            Self::Reference(reference) => {
+                templates.column_reference(reference.source(), &reference.name())
+            }
         }
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs
index 25f2c7c229191..b7e59049cb373 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs
@@ -1,4 +1,3 @@
-use super::Schema;
 use crate::planner::filter::BaseFilter;
 use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::VisitorContext;
@@ -54,7 +53,6 @@ impl FilterItem {
         &self,
         templates: &PlanSqlTemplates,
         context: Rc<VisitorContext>,
-        schema: Rc<Schema>,
     ) -> Result<String, CubeError> {
         let res = match self {
             FilterItem::Group(group) => {
@@ -62,7 +60,7 @@ impl FilterItem {
                 let items_sql = group
                     .items
                     .iter()
-                    .map(|itm| itm.to_sql(templates, context.clone(), schema.clone()))
+                    .map(|itm| itm.to_sql(templates, context.clone()))
                     .collect::<Result<Vec<_>, _>>()?
                     .into_iter()
                     .filter(|itm| !itm.is_empty())
@@ -75,7 +73,7 @@ impl FilterItem {
                 }
             }
             FilterItem::Item(item) => {
-                let sql = item.to_sql(context.clone(), schema)?;
+                let sql = item.to_sql(context.clone())?;
                 format!("({})", sql)
             }
         };
@@ -88,12 +86,11 @@ impl Filter {
         &self,
         templates: &PlanSqlTemplates,
         context: Rc<VisitorContext>,
-        schema: Rc<Schema>,
     ) -> Result<String, CubeError> {
         let res = self
             .items
             .iter()
-            .map(|itm| itm.to_sql(templates, context.clone(), schema.clone()))
+            .map(|itm| itm.to_sql(templates, context.clone()))
             .collect::<Result<Vec<_>, _>>()?
             .join(" AND ");
         Ok(res)
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/from.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/from.rs
index a1667e89d7a4c..175fb662ca89b 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/from.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/from.rs
@@ -1,4 +1,4 @@
-use super::{Join, QueryPlan, Schema, SchemaCube, Select};
+use super::{Join, QueryPlan, Schema, Select};
 use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::{BaseCube, VisitorContext};
 use cubenativeutils::CubeError;
@@ -27,6 +27,14 @@ impl SingleSource {
         };
         Ok(sql)
     }
+
+    pub fn schema(&self) -> Rc<Schema> {
+        match self {
+            SingleSource::Subquery(subquery) => subquery.schema(),
+            SingleSource::Cube(_) => Rc::new(Schema::empty()),
+            SingleSource::TableReference(_, schema) => schema.clone(),
+        }
+    }
 }
 
 #[derive(Clone)]
@@ -72,14 +80,6 @@ impl SingleAliasedSource {
 
         templates.query_aliased(&sql, &self.alias)
     }
-
-    pub fn make_schema(&self) -> Schema {
-        match &self.source {
-            SingleSource::Subquery(query) => query.make_schema(Some(self.alias.clone())),
-            SingleSource::Cube(cube) => Schema::empty(), //cube.schema().move_to_source(&self.alias),
-            SingleSource::TableReference(_, schema) => schema.move_to_source(&self.alias),
-        }
-    }
 }
 
 #[derive(Clone)]
@@ -89,30 +89,17 @@ pub enum FromSource {
     Join(Rc<Join>),
 }
 
-impl FromSource {
-    pub fn get_schema(&self) -> Rc<Schema> {
-        let schema = match self {
-            FromSource::Empty => Schema::empty(),
-            FromSource::Single(source) => source.make_schema(),
-            FromSource::Join(join) => join.make_schema(),
-        };
-        Rc::new(schema)
-    }
-}
-
 #[derive(Clone)]
 pub struct From {
     pub source: FromSource,
-    pub schema: Rc<Schema>,
 }
 
 impl From {
-    pub fn new(source: FromSource) -> Self {
-        let schema = source.get_schema();
-        Self { source, schema }
+    pub fn new(source: FromSource) -> Rc<Self> {
+        Rc::new(Self { source })
     }
 
-    pub fn new_from_cube(cube: Rc<BaseCube>, alias: Option<String>) -> Self {
+    pub fn new_from_cube(cube: Rc<BaseCube>, alias: Option<String>) -> Rc<Self> {
         Self::new(FromSource::Single(SingleAliasedSource::new_from_cube(
             cube, alias,
         )))
@@ -122,23 +109,23 @@ impl From {
         reference: String,
         schema: Rc<Schema>,
         alias: Option<String>,
-    ) -> Self {
+    ) -> Rc<Self> {
         Self::new(FromSource::Single(
             SingleAliasedSource::new_from_table_reference(reference, schema, alias),
         ))
     }
 
-    pub fn new_from_join(join: Rc<Join>) -> Self {
+    pub fn new_from_join(join: Rc<Join>) -> Rc<Self> {
         Self::new(FromSource::Join(join))
     }
 
-    pub fn new_from_subquery(plan: Rc<QueryPlan>, alias: String) -> Self {
+    pub fn new_from_subquery(plan: Rc<QueryPlan>, alias: String) -> Rc<Self> {
         Self::new(FromSource::Single(SingleAliasedSource::new_from_subquery(
             plan, alias,
         )))
     }
 
-    pub fn new_from_subselect(plan: Rc<Select>, alias: String) -> Self {
+    pub fn new_from_subselect(plan: Rc<Select>, alias: String) -> Rc<Self> {
         Self::new(FromSource::Single(SingleAliasedSource::new_from_subquery(
             Rc::new(QueryPlan::Select(plan)),
             alias,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs
index eb3a7347bd103..3a19170443d80 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs
@@ -1,31 +1,28 @@
-use super::{Schema, SingleAliasedSource};
+use super::{Expr, SingleAliasedSource};
 use crate::planner::sql_templates::PlanSqlTemplates;
-use crate::planner::{BaseJoinCondition, BaseMember, VisitorContext};
+use crate::planner::{BaseJoinCondition, VisitorContext};
 use cubenativeutils::CubeError;
 use lazy_static::lazy_static;
 
 use std::rc::Rc;
 
 pub struct RollingWindowJoinCondition {
-    data_source: String,
     time_series_source: String,
     trailing_interval: Option<String>,
     leading_interval: Option<String>,
     offset: String,
-    time_dimension: Rc<dyn BaseMember>,
+    time_dimension: Expr,
 }
 
 impl RollingWindowJoinCondition {
     pub fn new(
-        data_source: String,
         time_series_source: String,
         trailing_interval: Option<String>,
         leading_interval: Option<String>,
         offset: String,
-        time_dimension: Rc<dyn BaseMember>,
+        time_dimension: Expr,
     ) -> Self {
         Self {
-            data_source,
             time_series_source,
             trailing_interval,
             leading_interval,
@@ -38,11 +35,9 @@ impl RollingWindowJoinCondition {
         &self,
         templates: &PlanSqlTemplates,
         context: Rc<VisitorContext>,
-        schema: Rc<Schema>,
     ) -> Result<String, CubeError> {
         let mut conditions = vec![];
-        let date_column_alias =
-            self.resolve_time_column_alias(templates, context.clone(), schema.clone())?;
+        let date_column = self.time_dimension.to_sql(templates, context)?;
 
         lazy_static! {
             static ref UNBOUNDED: Option<String> = Some("unbounded".to_string());
@@ -63,7 +58,7 @@ impl RollingWindowJoinCondition {
 
             let sign = if self.offset == "start" { ">=" } else { ">" };
 
-            conditions.push(format!("{date_column_alias} {sign} {trailing_start}"));
+            conditions.push(format!("{date_column} {sign} {trailing_start}"));
         }
 
         if self.leading_interval != *UNBOUNDED {
@@ -81,7 +76,7 @@ impl RollingWindowJoinCondition {
 
             let sign = if self.offset == "end" { "<=" } else { "<" };
 
-            conditions.push(format!("{date_column_alias} {sign} {leading_end}"));
+            conditions.push(format!("{date_column} {sign} {leading_end}"));
         }
         let result = if conditions.is_empty() {
             templates.always_true()?
@@ -90,43 +85,17 @@ impl RollingWindowJoinCondition {
         };
         Ok(result)
     }
-
-    fn resolve_time_column_alias(
-        &self,
-        templates: &PlanSqlTemplates,
-        context: Rc<VisitorContext>,
-        schema: Rc<Schema>,
-    ) -> Result<String, CubeError> {
-        let schema = schema.extract_source_schema(&self.data_source);
-        let source = Some(self.data_source.clone());
-        if let Some(column) =
-            schema.find_column_for_member(&self.time_dimension.full_name(), &source)
-        {
-            templates.column_reference(&source, &column.alias.clone())
-        } else {
-            self.time_dimension.to_sql(context.clone(), schema.clone())
-        }
-    }
 }
 
 pub struct DimensionJoinCondition {
-    left_source: String,
-    right_source: String,
-    dimensions: Vec<Rc<dyn BaseMember>>,
+    conditions: Vec<(Expr, Expr)>,
     null_check: bool,
 }
 
 impl DimensionJoinCondition {
-    pub fn new(
-        left_source: String,
-        right_source: String,
-        dimensions: Vec<Rc<dyn BaseMember>>,
-        null_check: bool,
-    ) -> Self {
+    pub fn new(conditions: Vec<(Expr, Expr)>, null_check: bool) -> Self {
         Self {
-            left_source,
-            right_source,
-            dimensions,
+            conditions,
             null_check,
         }
     }
@@ -135,15 +104,14 @@ impl DimensionJoinCondition {
         &self,
         templates: &PlanSqlTemplates,
         context: Rc<VisitorContext>,
-        schema: Rc<Schema>,
     ) -> Result<String, CubeError> {
-        let result = if self.dimensions.is_empty() {
+        let result = if self.conditions.is_empty() {
             format!("1 = 1")
         } else {
-            self.dimensions
+            self.conditions
                 .iter()
-                .map(|dim| -> Result<String, CubeError> {
-                    self.dimension_condition(templates, context.clone(), dim, schema.clone())
+                .map(|(left, right)| -> Result<String, CubeError> {
+                    self.dimension_condition(templates, context.clone(), left, right)
                 })
                 .collect::<Result<Vec<_>, _>>()?
                 .join(" AND ")
@@ -155,41 +123,12 @@ impl DimensionJoinCondition {
         &self,
         templates: &PlanSqlTemplates,
         context: Rc<VisitorContext>,
-        dimension: &Rc<dyn BaseMember>,
-        schema: Rc<Schema>,
-    ) -> Result<String, CubeError> {
-        let left_column = self.resolve_member_alias(
-            templates,
-            context.clone(),
-            &self.left_source,
-            dimension,
-            schema.clone(),
-        )?;
-        let right_column = self.resolve_member_alias(
-            templates,
-            context.clone(),
-            &self.right_source,
-            dimension,
-            schema.clone(),
-        )?;
-        templates.join_by_dimension_conditions(&left_column, &right_column, self.null_check)
-    }
-
-    fn resolve_member_alias(
-        &self,
-        templates: &PlanSqlTemplates,
-        context: Rc<VisitorContext>,
-        source: &String,
-        dimension: &Rc<dyn BaseMember>,
-        schema: Rc<Schema>,
+        left_expr: &Expr,
+        right_expr: &Expr,
     ) -> Result<String, CubeError> {
-        let schema = schema.extract_source_schema(source);
-        let source = Some(source.clone());
-        if let Some(column) = schema.find_column_for_member(&dimension.full_name(), &source) {
-            templates.column_reference(&source, &column.alias.clone())
-        } else {
-            dimension.to_sql(context.clone(), schema.clone())
-        }
+        let left_sql = left_expr.to_sql(templates, context.clone())?;
+        let right_sql = right_expr.to_sql(templates, context.clone())?;
+        templates.join_by_dimension_conditions(&left_sql, &right_sql, self.null_check)
     }
 }
 
@@ -200,30 +139,18 @@ pub enum JoinCondition {
 }
 
 impl JoinCondition {
-    pub fn new_dimension_join(
-        left_source: String,
-        right_source: String,
-        dimensions: Vec<Rc<dyn BaseMember>>,
-        null_check: bool,
-    ) -> Self {
-        Self::DimensionJoinCondition(DimensionJoinCondition::new(
-            left_source,
-            right_source,
-            dimensions,
-            null_check,
-        ))
+    pub fn new_dimension_join(conditions: Vec<(Expr, Expr)>, null_check: bool) -> Self {
+        Self::DimensionJoinCondition(DimensionJoinCondition::new(conditions, null_check))
     }
 
     pub fn new_rolling_join(
-        data_source: String,
         time_series_source: String,
         trailing_interval: Option<String>,
         leading_interval: Option<String>,
         offset: String,
-        time_dimension: Rc<dyn BaseMember>,
+        time_dimension: Expr,
     ) -> Self {
         Self::RollingWindowJoinCondition(RollingWindowJoinCondition::new(
-            data_source,
             time_series_source,
             trailing_interval,
             leading_interval,
@@ -240,14 +167,11 @@ impl JoinCondition {
         &self,
         templates: &PlanSqlTemplates,
         context: Rc<VisitorContext>,
-        schema: Rc<Schema>,
     ) -> Result<String, CubeError> {
         match &self {
-            JoinCondition::DimensionJoinCondition(cond) => cond.to_sql(templates, context, schema),
-            JoinCondition::BaseJoinCondition(cond) => cond.to_sql(context, schema),
-            JoinCondition::RollingWindowJoinCondition(cond) => {
-                cond.to_sql(templates, context, schema)
-            }
+            JoinCondition::DimensionJoinCondition(cond) => cond.to_sql(templates, context),
+            JoinCondition::BaseJoinCondition(cond) => cond.to_sql(context),
+            JoinCondition::RollingWindowJoinCondition(cond) => cond.to_sql(templates, context),
         }
     }
 }
@@ -268,9 +192,8 @@ impl JoinItem {
         &self,
         templates: &PlanSqlTemplates,
         context: Rc<VisitorContext>,
-        schema: Rc<Schema>,
     ) -> Result<String, CubeError> {
-        let on_sql = self.on.to_sql(templates, context.clone(), schema)?;
+        let on_sql = self.on.to_sql(templates, context.clone())?;
         let result = templates.join(
             &self.from.to_sql(templates, context)?,
             &on_sql,
@@ -281,24 +204,15 @@ impl JoinItem {
 }
 
 impl Join {
-    pub fn make_schema(&self) -> Schema {
-        let mut schema = self.root.make_schema();
-        for itm in self.joins.iter() {
-            schema.merge(itm.from.make_schema());
-        }
-        schema
-    }
-
     pub fn to_sql(
         &self,
         templates: &PlanSqlTemplates,
         context: Rc<VisitorContext>,
     ) -> Result<String, CubeError> {
-        let schema = Rc::new(self.make_schema());
         let joins_sql = self
             .joins
             .iter()
-            .map(|j| j.to_sql(templates, context.clone(), schema.clone()))
+            .map(|j| j.to_sql(templates, context.clone()))
             .collect::<Result<Vec<_>, _>>()?;
         let res = format!(
             "{}\n{}",
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/mod.rs
index 7dc4a188a3fbf..3799935638bd2 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/mod.rs
@@ -19,7 +19,7 @@ pub use from::{From, FromSource, SingleAliasedSource, SingleSource};
 pub use join::{Join, JoinCondition, JoinItem, RollingWindowJoinCondition};
 pub use order::OrderBy;
 pub use query_plan::QueryPlan;
-pub use schema::{Schema, SchemaColumn, SchemaCube};
+pub use schema::{QualifiedColumnName, Schema, SchemaColumn};
 pub use select::{AliasedExpr, Select};
 pub use time_series::TimeSeries;
 pub use union::Union;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/query_plan.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/query_plan.rs
index 8fd8b9144f214..8957321274111 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/query_plan.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/query_plan.rs
@@ -10,11 +10,11 @@ pub enum QueryPlan {
 }
 
 impl QueryPlan {
-    pub fn make_schema(&self, self_alias: Option<String>) -> Schema {
+    pub fn schema(&self) -> Rc<Schema> {
         match self {
-            QueryPlan::Select(select) => select.make_schema(self_alias),
-            QueryPlan::Union(union) => union.make_schema(self_alias),
-            QueryPlan::TimeSeries(series) => series.make_schema(self_alias),
+            QueryPlan::Select(select) => select.schema(),
+            QueryPlan::Union(union) => union.schema(),
+            QueryPlan::TimeSeries(series) => series.schema(),
         }
     }
     pub fn to_sql(&self, templates: &PlanSqlTemplates) -> Result<String, CubeError> {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/schema.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/schema.rs
deleted file mode 100644
index ecda0d157938d..0000000000000
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/schema.rs
+++ /dev/null
@@ -1,150 +0,0 @@
-use crate::planner::sql_templates::PlanSqlTemplates;
-use crate::planner::BaseMember;
-use itertools::Itertools;
-use std::rc::Rc;
-
-#[derive(Debug, Clone)]
-pub struct SchemaColumn {
-    pub table_name: Option<String>,
-    pub alias: String,
-    pub origin_member: Option<String>,
-}
-
-impl SchemaColumn {
-    pub fn new(table_name: Option<String>, alias: String, origin_member: Option<String>) -> Self {
-        Self {
-            table_name,
-            alias,
-            origin_member,
-        }
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct SchemaCube {
-    pub name: String,
-    pub alias: String,
-}
-
-impl SchemaCube {
-    pub fn new(name: String, alias: String) -> Self {
-        Self { name, alias }
-    }
-}
-
-#[derive(Debug)]
-pub struct Schema {
-    columns: Vec<SchemaColumn>,
-    cubes: Vec<SchemaCube>,
-}
-
-impl Schema {
-    pub fn empty() -> Self {
-        Self::new(vec![], vec![])
-    }
-    pub fn new(columns: Vec<SchemaColumn>, cubes: Vec<SchemaCube>) -> Self {
-        Self { columns, cubes }
-    }
-
-    pub fn add_column(&mut self, column: SchemaColumn) {
-        self.columns.push(column)
-    }
-
-    pub fn add_cube(&mut self, cube: SchemaCube) {
-        self.cubes.push(cube)
-    }
-    pub fn merge(&mut self, other: Self) {
-        let Schema {
-            mut columns,
-            mut cubes,
-        } = other;
-        self.columns.append(&mut columns);
-        self.cubes.append(&mut cubes);
-    }
-
-    pub fn resolve_member_alias(
-        &self,
-        member: &Rc<dyn BaseMember>,
-        source: &Option<String>,
-    ) -> String {
-        if let Some(column) = self.find_column_for_member(&member.full_name(), source) {
-            column.alias.clone()
-        } else {
-            PlanSqlTemplates::memeber_alias_name(
-                member.cube_name(),
-                member.name(),
-                member.alias_suffix(),
-            )
-        }
-    }
-
-    pub fn resolve_member_reference(
-        &self,
-        member_name: &String,
-        source: &Option<String>,
-    ) -> Option<String> {
-        if let Some(column) = self.find_column_for_member(&member_name, source) {
-            Some(column.alias.clone())
-        } else {
-            None
-        }
-    }
-
-    pub fn resolve_cube_alias(&self, cube_name: &String) -> String {
-        if let Some(cube) = self.find_cube_by_origin_cube_name(cube_name) {
-            cube.alias.clone()
-        } else {
-            cube_name.clone()
-        }
-    }
-
-    pub fn find_column_for_member(
-        &self,
-        member_name: &String,
-        source: &Option<String>,
-    ) -> Option<&SchemaColumn> {
-        self.columns.iter().find(|col| {
-            if source.is_some() && source != &col.table_name {
-                return false;
-            }
-            if let Some(origin_member) = &col.origin_member {
-                origin_member == member_name
-            } else {
-                false
-            }
-        })
-    }
-
-    pub fn find_cube_by_origin_cube_name(&self, member_cube_name: &String) -> Option<&SchemaCube> {
-        self.cubes
-            .iter()
-            .find(|cube| &cube.name == member_cube_name)
-    }
-
-    pub fn extract_source_schema(&self, source: &String) -> Rc<Self> {
-        let columns = self
-            .columns
-            .iter()
-            .filter(|col| col.table_name.is_some() && col.table_name.as_ref().unwrap() == source)
-            .cloned()
-            .collect_vec();
-        let cubes = self
-            .cubes
-            .iter()
-            .filter(|cb| &cb.alias == source)
-            .cloned()
-            .collect_vec();
-        Rc::new(Self { columns, cubes })
-    }
-
-    pub fn move_to_source(&self, source: &String) -> Self {
-        let mut columns = self.columns.clone();
-        for col in columns.iter_mut() {
-            col.table_name = Some(source.clone())
-        }
-        Self {
-            columns,
-            cubes: vec![], //we not fill cubes here
-        }
-    }
-}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/schema/column.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/schema/column.rs
new file mode 100644
index 0000000000000..8d39385af42af
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/schema/column.rs
@@ -0,0 +1,57 @@
+use std::fmt::Display;
+
+#[derive(Debug, Clone)]
+pub struct QualifiedColumnName {
+    source: Option<String>,
+    name: String,
+}
+
+impl QualifiedColumnName {
+    pub fn new(source: Option<String>, name: String) -> Self {
+        Self { source, name }
+    }
+
+    pub fn source(&self) -> &Option<String> {
+        &self.source
+    }
+
+    pub fn name(&self) -> &String {
+        &self.name
+    }
+
+    pub fn set_source(&mut self, source: Option<String>) {
+        self.source = source;
+    }
+}
+
+impl Display for QualifiedColumnName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(source) = &self.source {
+            write!(f, "{}.", source)?
+        }
+        write!(f, "{}", self.name)
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct SchemaColumn {
+    name: String,
+    origin_member: Option<String>,
+}
+
+impl SchemaColumn {
+    pub fn new(name: String, origin_member: Option<String>) -> Self {
+        Self {
+            name,
+            origin_member,
+        }
+    }
+
+    pub fn name(&self) -> &String {
+        &self.name
+    }
+
+    pub fn origin_member(&self) -> &Option<String> {
+        &self.origin_member
+    }
+}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/schema/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/schema/mod.rs
new file mode 100644
index 0000000000000..18ffca6a0bee9
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/schema/mod.rs
@@ -0,0 +1,5 @@
+mod column;
+mod schema;
+
+pub use column::{QualifiedColumnName, SchemaColumn};
+pub use schema::Schema;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/schema/schema.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/schema/schema.rs
new file mode 100644
index 0000000000000..29c519dba835f
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/schema/schema.rs
@@ -0,0 +1,67 @@
+use super::SchemaColumn;
+use crate::planner::sql_templates::PlanSqlTemplates;
+use crate::planner::BaseMember;
+use itertools::Itertools;
+use std::rc::Rc;
+
+#[derive(Debug)]
+pub struct Schema {
+    columns: Vec<SchemaColumn>,
+}
+
+impl Schema {
+    pub fn empty() -> Self {
+        Self::new(vec![])
+    }
+    pub fn new(columns: Vec<SchemaColumn>) -> Self {
+        Self { columns }
+    }
+
+    pub fn add_column(&mut self, column: SchemaColumn) {
+        self.columns.push(column)
+    }
+
+    pub fn has_column(&self, column_name: &String) -> bool {
+        self.columns.iter().any(|col| col.name() == column_name)
+    }
+
+    pub fn merge(&mut self, other: &Self) {
+        let res = self
+            .columns
+            .iter()
+            .chain(other.columns.iter())
+            .unique_by(|col| col.name())
+            .collect_vec();
+        self.columns = res.into_iter().cloned().collect_vec();
+    }
+
+    pub fn resolve_member_alias(&self, member: &Rc<dyn BaseMember>) -> String {
+        if let Some(column) = self.find_column_for_member(&member.full_name()) {
+            column.name().clone()
+        } else {
+            PlanSqlTemplates::memeber_alias_name(
+                member.cube_name(),
+                member.name(),
+                member.alias_suffix(),
+            )
+        }
+    }
+
+    pub fn resolve_member_reference(&self, member_name: &String) -> Option<String> {
+        if let Some(column) = self.find_column_for_member(&member_name) {
+            Some(column.name().clone())
+        } else {
+            None
+        }
+    }
+
+    pub fn find_column_for_member(&self, member_name: &String) -> Option<&SchemaColumn> {
+        self.columns.iter().find(|col| {
+            if let Some(origin_member) = &col.origin_member() {
+                origin_member == member_name
+            } else {
+                false
+            }
+        })
+    }
+}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/select.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/select.rs
index a9b49ccf1d09a..2c37717014cf9 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/select.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/select.rs
@@ -1,4 +1,4 @@
-use super::{Cte, Expr, Filter, From, OrderBy, Schema, SchemaColumn};
+use super::{Cte, Expr, Filter, From, OrderBy, Schema};
 use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::sql_templates::{
     TemplateGroupByColumn, TemplateOrderByColumn, TemplateProjectionColumn,
@@ -21,9 +21,8 @@ impl AliasedExpr {
         &self,
         templates: &PlanSqlTemplates,
         context: Rc<VisitorContext>,
-        schema: Rc<Schema>,
     ) -> Result<TemplateProjectionColumn, CubeError> {
-        let expr = self.expr.to_sql(templates, context, schema)?;
+        let expr = self.expr.to_sql(templates, context)?;
         let aliased = templates.column_aliased(&expr, &self.alias)?;
         Ok(TemplateProjectionColumn {
             expr,
@@ -35,7 +34,7 @@ impl AliasedExpr {
 
 pub struct Select {
     pub(super) projection_columns: Vec<AliasedExpr>,
-    pub(super) from: From,
+    pub(super) from: Rc<From>,
     pub(super) filter: Option<Filter>,
     pub(super) group_by: Vec<Expr>,
     pub(super) having: Option<Filter>,
@@ -45,47 +44,19 @@ pub struct Select {
     pub(super) is_distinct: bool,
     pub(super) limit: Option<usize>,
     pub(super) offset: Option<usize>,
+    pub(super) schema: Rc<Schema>,
 }
 
 impl Select {
-    pub fn make_schema(&self, self_alias: Option<String>) -> Schema {
-        if self.projection_columns.is_empty() {
-            if let Some(self_alias) = self_alias {
-                self.from.schema.move_to_source(&self_alias)
-            } else {
-                Schema::empty() //FIXME
-            }
-        } else {
-            let mut schema = Schema::empty();
-            for col in self.projection_columns.iter() {
-                match &col.expr {
-                    Expr::Member(member) => {
-                        let schema_col = SchemaColumn::new(
-                            self_alias.clone(),
-                            col.alias.clone(),
-                            Some(member.member.full_name()),
-                        );
-                        schema.add_column(schema_col);
-                    }
-                    Expr::Reference(reference) => {
-                        let schema_col = SchemaColumn::new(
-                            self_alias.clone(),
-                            col.alias.clone(),
-                            None, //"".to_string(), //member.member.full_name(),
-                        );
-                        schema.add_column(schema_col);
-                    }
-                }
-            }
-            schema
-        }
+    pub fn schema(&self) -> Rc<Schema> {
+        self.schema.clone()
     }
+
     pub fn to_sql(&self, templates: &PlanSqlTemplates) -> Result<String, CubeError> {
-        let schema = self.from.schema.clone();
         let projection = if !self.projection_columns.is_empty() {
             self.projection_columns
                 .iter()
-                .map(|p| p.to_sql(templates, self.context.clone(), schema.clone()))
+                .map(|p| p.to_sql(templates, self.context.clone()))
                 .collect::<Result<Vec<_>, _>>()?
         } else {
             vec![TemplateProjectionColumn {
@@ -96,7 +67,7 @@ impl Select {
         };
 
         let where_condition = if let Some(filter) = &self.filter {
-            Some(filter.to_sql(templates, self.context.clone(), schema.clone())?)
+            Some(filter.to_sql(templates, self.context.clone())?)
         } else {
             None
         };
@@ -106,13 +77,13 @@ impl Select {
             .iter()
             .enumerate()
             .map(|(i, expr)| -> Result<_, CubeError> {
-                let expr = expr.to_sql(templates, self.context.clone(), schema.clone())?;
+                let expr = expr.to_sql(templates, self.context.clone())?;
                 Ok(TemplateGroupByColumn { expr, index: i + 1 })
             })
             .collect::<Result<Vec<_>, _>>()?;
 
         let having = if let Some(having) = &self.having {
-            Some(having.to_sql(templates, self.context.clone(), schema.clone())?)
+            Some(having.to_sql(templates, self.context.clone())?)
         } else {
             None
         };
@@ -130,8 +101,7 @@ impl Select {
             .iter()
             .map(|itm| -> Result<_, CubeError> {
                 let expr = templates.order_by(
-                    &itm.expr
-                        .to_sql(templates, self.context.clone(), schema.clone())?,
+                    &itm.expr.to_sql(templates, self.context.clone())?,
                     Some(itm.pos),
                     !itm.desc,
                 )?;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/time_series.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/time_series.rs
index b6c2fab40dc19..43de9351a5405 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/time_series.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/time_series.rs
@@ -1,22 +1,36 @@
 use super::{Schema, SchemaColumn};
 use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
+use std::rc::Rc;
 
 pub struct TimeSeries {
     pub time_dimension_name: String,
     pub from_date: Option<String>,
     pub to_date: Option<String>,
     pub seria: Vec<Vec<String>>,
+    pub schema: Rc<Schema>,
 }
 
 impl TimeSeries {
-    pub fn make_schema(&self, self_alias: Option<String>) -> Schema {
-        let column = SchemaColumn::new(
-            self_alias,
-            format!("date_from"),
-            Some(self.time_dimension_name.clone()),
-        );
-        Schema::new(vec![column], vec![])
+    pub fn new(
+        time_dimension_name: String,
+        from_date: Option<String>,
+        to_date: Option<String>,
+        seria: Vec<Vec<String>>,
+    ) -> Self {
+        let column = SchemaColumn::new(format!("date_from"), Some(time_dimension_name.clone()));
+        let schema = Rc::new(Schema::new(vec![column]));
+        Self {
+            time_dimension_name,
+            from_date,
+            to_date,
+            seria,
+            schema,
+        }
+    }
+
+    pub fn schema(&self) -> Rc<Schema> {
+        self.schema.clone()
     }
 
     pub fn to_sql(&self, templates: &PlanSqlTemplates) -> Result<String, CubeError> {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/union.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/union.rs
index 2fb5f5615ecaf..ce367857b201e 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/union.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/union.rs
@@ -1,21 +1,25 @@
 use super::{QueryPlan, Schema};
 use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
+use std::rc::Rc;
 
 pub struct Union {
     pub union: Vec<QueryPlan>,
+    pub schema: Rc<Schema>,
 }
 
 impl Union {
     pub fn new(union: Vec<QueryPlan>) -> Self {
-        Self { union }
-    }
-    pub fn make_schema(&self, self_alias: Option<String>) -> Schema {
-        if self.union.is_empty() {
-            Schema::empty()
+        let schema = if union.is_empty() {
+            Rc::new(Schema::empty())
         } else {
-            self.union[0].make_schema(self_alias)
-        }
+            union[0].schema()
+        };
+        Self { union, schema }
+    }
+
+    pub fn schema(&self) -> Rc<Schema> {
+        self.schema.clone()
     }
 
     pub fn to_sql(&self, templates: &PlanSqlTemplates) -> Result<String, CubeError> {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_cube.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_cube.rs
index 6fb78a91c6711..ee9e8116f8506 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_cube.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_cube.rs
@@ -1,14 +1,13 @@
 use super::query_tools::QueryTools;
 use super::sql_evaluator::MemberSymbol;
 use super::{evaluate_with_context, VisitorContext};
-use crate::plan::{Schema, SchemaColumn};
 use cubenativeutils::CubeError;
+use std::collections::HashSet;
 use std::rc::Rc;
 
 pub struct BaseCube {
     cube_name: String,
-    members: Vec<String>,
-    schema: Schema,
+    members: HashSet<String>,
     member_evaluator: Rc<MemberSymbol>,
     query_tools: Rc<QueryTools>,
 }
@@ -20,32 +19,21 @@ impl BaseCube {
     ) -> Result<Rc<Self>, CubeError> {
         let members = query_tools
             .base_tools()
-            .all_cube_members(cube_name.clone())?;
-        let mut schema = Schema::empty();
-        for member in members.iter() {
-            schema.add_column(SchemaColumn::new(
-                Some(cube_name.clone()),
-                member.clone(),
-                Some(format!("{}.{}", cube_name, member)),
-            ));
-        }
+            .all_cube_members(cube_name.clone())?
+            .into_iter()
+            .collect::<HashSet<_>>();
 
         Ok(Rc::new(Self {
             cube_name,
             members,
-            schema,
             member_evaluator,
             query_tools,
         }))
     }
 
     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,
-            Rc::new(Schema::empty()),
-        )?;
+        let cube_sql =
+            evaluate_with_context(&self.member_evaluator, self.query_tools.clone(), context)?;
         Ok(cube_sql)
     }
 
@@ -53,12 +41,12 @@ impl BaseCube {
         &self.cube_name
     }
 
-    pub fn members(&self) -> &Vec<String> {
+    pub fn members(&self) -> &HashSet<String> {
         &self.members
     }
 
-    pub fn schema(&self) -> &Schema {
-        &self.schema
+    pub fn has_member(&self, name: &str) -> bool {
+        self.members.contains(name)
     }
 
     pub fn default_alias(&self) -> String {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs
index d753add3b0634..6a1bca2d280de 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_dimension.rs
@@ -1,7 +1,6 @@
 use super::query_tools::QueryTools;
 use super::sql_evaluator::MemberSymbol;
 use super::{evaluate_with_context, BaseMember, VisitorContext};
-use crate::plan::Schema;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
@@ -14,18 +13,12 @@ pub struct BaseDimension {
 }
 
 impl BaseMember for BaseDimension {
-    fn to_sql(&self, context: Rc<VisitorContext>, schema: Rc<Schema>) -> Result<String, CubeError> {
-        evaluate_with_context(
-            &self.member_evaluator,
-            self.query_tools.clone(),
-            context,
-            schema,
-        )
+    fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
+        evaluate_with_context(&self.member_evaluator, self.query_tools.clone(), context)
     }
 
     fn alias_name(&self) -> String {
-        self.query_tools
-            .escape_column_name(&self.unescaped_alias_name())
+        self.unescaped_alias_name()
     }
 
     fn member_evaluator(&self) -> Rc<MemberSymbol> {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_join_condition.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_join_condition.rs
index e4e3bc3b9415f..c90c901fbca68 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_join_condition.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_join_condition.rs
@@ -1,11 +1,10 @@
 use super::query_tools::QueryTools;
 use super::sql_evaluator::SqlCall;
-use super::{evaluate_sql_call_with_context, evaluate_with_context, VisitorContext};
-use crate::plan::Schema;
+use super::{evaluate_sql_call_with_context, VisitorContext};
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 pub trait BaseJoinCondition {
-    fn to_sql(&self, context: Rc<VisitorContext>, schema: Rc<Schema>) -> Result<String, CubeError>;
+    fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError>;
 }
 pub struct SqlJoinCondition {
     sql_call: Rc<SqlCall>,
@@ -24,7 +23,7 @@ impl SqlJoinCondition {
 }
 
 impl BaseJoinCondition for SqlJoinCondition {
-    fn to_sql(&self, context: Rc<VisitorContext>, schema: Rc<Schema>) -> Result<String, CubeError> {
-        evaluate_sql_call_with_context(&self.sql_call, self.query_tools.clone(), context, schema)
+    fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
+        evaluate_sql_call_with_context(&self.sql_call, self.query_tools.clone(), context)
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
index 81a27aa4557f5..89e832620af1d 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
@@ -4,7 +4,6 @@ use super::{evaluate_with_context, BaseMember, VisitorContext};
 use crate::cube_bridge::measure_definition::{
     MeasureDefinition, RollingWindow, TimeShiftReference,
 };
-use crate::plan::Schema;
 use cubenativeutils::CubeError;
 use lazy_static::lazy_static;
 use regex::Regex;
@@ -73,18 +72,12 @@ pub struct BaseMeasure {
 }
 
 impl BaseMember for BaseMeasure {
-    fn to_sql(&self, context: Rc<VisitorContext>, schema: Rc<Schema>) -> Result<String, CubeError> {
-        evaluate_with_context(
-            &self.member_evaluator,
-            self.query_tools.clone(),
-            context,
-            schema,
-        )
+    fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
+        evaluate_with_context(&self.member_evaluator, self.query_tools.clone(), context)
     }
 
     fn alias_name(&self) -> String {
-        self.query_tools
-            .escape_column_name(&self.unescaped_alias_name())
+        self.unescaped_alias_name()
     }
 
     fn member_evaluator(&self) -> Rc<MemberSymbol> {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
index f0d0f9e715b42..7b60dedbbb728 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_member.rs
@@ -1,13 +1,11 @@
 use super::sql_evaluator::MemberSymbol;
 use super::VisitorContext;
-use crate::plan::Schema;
 use cubenativeutils::CubeError;
 use itertools::Itertools;
-use std::collections::HashMap;
 use std::rc::Rc;
 
 pub trait BaseMember {
-    fn to_sql(&self, context: Rc<VisitorContext>, schema: Rc<Schema>) -> Result<String, CubeError>;
+    fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError>;
     fn alias_name(&self) -> String;
     fn member_evaluator(&self) -> Rc<MemberSymbol>;
     fn full_name(&self) -> String {
@@ -39,11 +37,4 @@ impl BaseMemberHelper {
     pub fn to_alias_vec(members: &Vec<Rc<dyn BaseMember>>) -> Vec<String> {
         members.iter().map(|m| m.alias_name()).collect_vec()
     }
-
-    pub fn to_reference_map(members: &Vec<Rc<dyn BaseMember>>) -> HashMap<String, String> {
-        members
-            .iter()
-            .map(|m| (m.full_name(), m.alias_name()))
-            .collect::<HashMap<String, String>>()
-    }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
index 50a803ab0b472..296ba7c9161c7 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
@@ -2,7 +2,6 @@ use super::query_tools::QueryTools;
 use super::sql_evaluator::MemberSymbol;
 use super::BaseDimension;
 use super::{BaseMember, VisitorContext};
-use crate::plan::Schema;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
@@ -15,28 +14,12 @@ pub struct BaseTimeDimension {
 }
 
 impl BaseMember for BaseTimeDimension {
-    fn to_sql(
-        &self,
-        context: Rc<VisitorContext>,
-        source_schema: Rc<Schema>,
-    ) -> Result<String, CubeError> {
-        let field_sql = if let Some(granularity) = &self.granularity {
-            let converted_tz = self
-                .query_tools
-                .base_tools()
-                .convert_tz(self.dimension.to_sql(context, source_schema)?)?;
-            self.query_tools
-                .base_tools()
-                .time_grouped_column(granularity.clone(), converted_tz)?
-        } else {
-            unimplemented!("Time dimensions without granularity not supported yet")
-        };
-        Ok(field_sql)
+    fn to_sql(&self, context: Rc<VisitorContext>) -> Result<String, CubeError> {
+        self.dimension.to_sql(context)
     }
 
     fn alias_name(&self) -> String {
-        self.query_tools
-            .escape_column_name(&self.unescaped_alias_name())
+        self.unescaped_alias_name()
     }
 
     fn member_evaluator(&self) -> Rc<MemberSymbol> {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
index 0abe6b8fb2be6..b9e5a8829735d 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
@@ -1,5 +1,4 @@
 use super::filter_operator::FilterOperator;
-use crate::plan::Schema;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_templates::filter::FilterTemplates;
@@ -80,6 +79,10 @@ impl BaseFilter {
         })
     }
 
+    pub fn member_evaluator(&self) -> &Rc<MemberSymbol> {
+        &self.member_evaluator
+    }
+
     pub fn values(&self) -> &Vec<Option<String>> {
         &self.values
     }
@@ -92,17 +95,9 @@ impl BaseFilter {
         self.member_evaluator.full_name()
     }
 
-    pub fn to_sql(
-        &self,
-        context: Rc<VisitorContext>,
-        schema: Rc<Schema>,
-    ) -> Result<String, CubeError> {
-        let member_sql = evaluate_with_context(
-            &self.member_evaluator,
-            self.query_tools.clone(),
-            context,
-            schema,
-        )?;
+    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)?,
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 295201d44a518..99ea934db4da5 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
@@ -1,11 +1,15 @@
 use super::OrderPlanner;
-use crate::plan::{Cte, Filter, From, JoinBuilder, JoinCondition, Select, SelectBuilder};
+use crate::plan::{
+    Cte, Expr, Filter, From, JoinBuilder, JoinCondition, QualifiedColumnName, Select, SelectBuilder,
+};
 use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
+use crate::planner::sql_evaluator::ReferencesBuilder;
+use crate::planner::BaseMeasure;
 use crate::planner::BaseMemberHelper;
 use crate::planner::QueryProperties;
-use crate::planner::{BaseMeasure, VisitorContext};
 use cubenativeutils::CubeError;
 use itertools::Itertools;
+use std::collections::HashMap;
 use std::rc::Rc;
 
 pub struct FullKeyAggregateQueryPlanner {
@@ -30,61 +34,97 @@ impl FullKeyAggregateQueryPlanner {
             )));
         }
 
-        let mut aggregate =
-            self.outer_measures_join_full_key_aggregate(&self.query_properties.measures(), joins)?;
-        if !ctes.is_empty() {
-            aggregate.set_ctes(ctes.clone());
-        }
+        let aggregate = self.outer_measures_join_full_key_aggregate(
+            &self.query_properties.measures(),
+            joins,
+            ctes,
+        )?;
 
-        Ok(aggregate.build())
+        Ok(aggregate)
     }
 
     fn outer_measures_join_full_key_aggregate(
         &self,
         outer_measures: &Vec<Rc<BaseMeasure>>,
         joins: Vec<Rc<Select>>,
-    ) -> Result<SelectBuilder, CubeError> {
+        ctes: Vec<Rc<Cte>>,
+    ) -> Result<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().skip(1).enumerate() {
-            let left_alias = format!("q_{}", i);
-            let right_alias = format!("q_{}", i + 1);
-            let on = JoinCondition::new_dimension_join(
-                left_alias,
-                right_alias,
-                dimensions_to_select.clone(),
-                true,
-            );
-            join_builder.inner_join_subselect(join.clone(), format!("q_{}", i + 1), on);
+        for (i, join) in joins.iter().enumerate().skip(1) {
+            let left_alias = format!("q_{}", i - 1);
+            let right_alias = format!("q_{}", i);
+            let left_schema = joins[i - 1].schema();
+            let right_schema = joins[i].schema();
+            let conditions = dimensions_to_select
+                .iter()
+                .map(|dim| {
+                    let alias_in_left_query = left_schema.resolve_member_alias(dim);
+                    let left_ref = Expr::Reference(QualifiedColumnName::new(
+                        Some(left_alias.clone()),
+                        alias_in_left_query,
+                    ));
+                    let alias_in_right_query = right_schema.resolve_member_alias(dim);
+                    let right_ref = Expr::Reference(QualifiedColumnName::new(
+                        Some(right_alias.clone()),
+                        alias_in_right_query,
+                    ));
+                    (left_ref, right_ref)
+                })
+                .collect_vec();
+            let on = JoinCondition::new_dimension_join(conditions, true);
+            join_builder.inner_join_subselect(join.clone(), format!("q_{}", i), on);
         }
 
-        let having = if self.query_properties.measures_filters().is_empty() {
-            None
-        } else {
-            Some(Filter {
-                items: self.query_properties.measures_filters().clone(),
-            })
-        };
-
         let from = From::new_from_join(join_builder.build());
-        let mut select_builder = SelectBuilder::new(from, self.context_factory.clone());
+        let references_builder = ReferencesBuilder::new(from.clone());
+        let mut render_references = HashMap::new();
 
-        for member in self
-            .query_properties
-            .all_dimensions_and_measures(&vec![])?
-            .iter()
-        {
-            select_builder.add_projection_member(member, Some(format!("q_0")), None);
+        let mut select_builder = SelectBuilder::new(from.clone());
+
+        let dimensions_source = Some(format!("q_0"));
+        for member in dimensions_to_select.iter() {
+            references_builder.resolve_references_for_member(
+                member.member_evaluator(),
+                &dimensions_source,
+                &mut render_references,
+            )?;
+            let alias = references_builder
+                .resolve_alias_for_member(&member.full_name(), &dimensions_source);
+            select_builder.add_projection_member(member, alias);
         }
 
         for member in BaseMemberHelper::iter_as_base_member(&outer_measures) {
-            select_builder.add_projection_member(&member, None, None);
+            references_builder.resolve_references_for_member(
+                member.member_evaluator(),
+                &None,
+                &mut render_references,
+            )?;
+            let alias = references_builder.resolve_alias_for_member(&member.full_name(), &None);
+            select_builder.add_projection_member(&member, alias);
         }
 
+        let having = if self.query_properties.measures_filters().is_empty() {
+            None
+        } else {
+            let filter = Filter {
+                items: self.query_properties.measures_filters().clone(),
+            };
+            references_builder.resolve_references_for_filter(&filter, &mut render_references)?;
+            Some(filter)
+        };
+
         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());
-        Ok(select_builder)
+        if !ctes.is_empty() {
+            select_builder.set_ctes(ctes.clone());
+        }
+
+        let mut context_factory = self.context_factory.clone();
+        context_factory.set_render_references(render_references);
+
+        Ok(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 cdb0bc1bd447a..d087448a73743 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/join_planner.rs
@@ -24,7 +24,7 @@ impl JoinPlanner {
     pub fn make_join_node_with_prefix(
         &self,
         alias_prefix: &Option<String>, /*TODO dimensions for subqueries*/
-    ) -> Result<From, CubeError> {
+    ) -> Result<Rc<From>, CubeError> {
         let join = self.query_tools.cached_data().join()?.clone();
         self.make_join_node_impl(alias_prefix, join)
     }
@@ -33,12 +33,12 @@ impl JoinPlanner {
         &self,
         alias_prefix: &Option<String>, /*TODO dimensions for subqueries*/
         join_hints: Vec<String>,
-    ) -> Result<From, CubeError> {
+    ) -> Result<Rc<From>, CubeError> {
         let join = self.query_tools.join_graph().build_join(join_hints)?;
         self.make_join_node_impl(alias_prefix, join)
     }
 
-    pub fn make_join_node(&self) -> Result<From, CubeError> {
+    pub fn make_join_node(&self) -> Result<Rc<From>, CubeError> {
         self.make_join_node_with_prefix(&None)
     }
 
@@ -46,7 +46,7 @@ impl JoinPlanner {
         &self,
         alias_prefix: &Option<String>,
         join: Rc<dyn JoinDefinition>,
-    ) -> Result<From, CubeError> {
+    ) -> 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() {
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 a75be62232d80..461fbcc50bbae 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
@@ -3,21 +3,20 @@ use super::{
     MultiStageQueryDescription, RollingWindowDescription,
 };
 use crate::plan::{
-    Cte, Expr, FilterGroup, FilterItem, From, JoinBuilder, JoinCondition, MemberExpression,
-    OrderBy, QueryPlan, Schema, SelectBuilder, TimeSeries,
+    Cte, Expr, From, JoinBuilder, JoinCondition, MemberExpression, OrderBy, QualifiedColumnName,
+    QueryPlan, Schema, SelectBuilder, TimeSeries,
 };
 use crate::planner::planners::{
     FullKeyAggregateQueryPlanner, MultipliedMeasuresQueryPlanner, OrderPlanner, SimpleQueryPlanner,
 };
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
+use crate::planner::sql_evaluator::ReferencesBuilder;
 use crate::planner::QueryProperties;
-use crate::planner::{
-    BaseDimension, BaseMeasure, BaseMember, BaseMemberHelper, BaseTimeDimension, VisitorContext,
-};
+use crate::planner::{BaseDimension, BaseMeasure, BaseMember, BaseMemberHelper, BaseTimeDimension};
 use cubenativeutils::CubeError;
 use itertools::Itertools;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::rc::Rc;
 pub struct MultiStageMemberQueryPlanner {
     query_tools: Rc<QueryTools>,
@@ -70,12 +69,12 @@ impl MultiStageMemberQueryPlanner {
             .query_tools
             .base_tools()
             .generate_time_series(granularity, date_range.clone())?;
-        let time_seira = TimeSeries {
-            time_dimension_name: time_dimension.full_name(),
-            from_date: Some(from_date),
-            to_date: Some(to_date),
+        let time_seira = TimeSeries::new(
+            time_dimension.full_name(),
+            Some(from_date),
+            Some(to_date),
             seria,
-        };
+        );
         let query_plan = Rc::new(QueryPlan::TimeSeries(Rc::new(time_seira)));
         Ok(Rc::new(Cte::new(query_plan, format!("time_series"))))
     }
@@ -87,6 +86,7 @@ impl MultiStageMemberQueryPlanner {
         cte_schemas: &HashMap<String, Rc<Schema>>,
     ) -> Result<Rc<Cte>, CubeError> {
         let inputs = self.input_cte_aliases();
+        assert!(inputs.len() == 2);
         let dimensions = self.all_dimensions();
 
         let root_alias = format!("time_series");
@@ -98,60 +98,72 @@ impl MultiStageMemberQueryPlanner {
             Some(root_alias.clone()),
         );
 
-        for (i, input) in inputs.iter().skip(1).enumerate() {
-            let alias = format!("rolling_{}", i + 1);
-            let on = JoinCondition::new_rolling_join(
-                alias.clone(),
-                root_alias.clone(),
-                rolling_window_desc.trailing.clone(),
-                rolling_window_desc.leading.clone(),
-                rolling_window_desc.offset.clone(),
-                rolling_window_desc.time_dimension.clone(),
-            );
-            let cte_schema = cte_schemas.get(input).unwrap().clone();
-            join_builder.left_join_table_reference(
-                input.clone(),
-                cte_schema,
-                Some(format!("rolling_{}", i + 1)),
-                on,
-            );
-        }
+        let input = &inputs[1];
+        let alias = format!("rolling_source");
+        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,
+            )),
+        );
+        join_builder.left_join_table_reference(
+            input.clone(),
+            rolling_base_cte_schema.clone(),
+            Some(alias.clone()),
+            on,
+        );
 
         let from = From::new_from_join(join_builder.build());
 
         let group_by = dimensions
             .iter()
-            .map(|dim| Expr::Member(MemberExpression::new(dim.clone(), None)))
+            .map(|dim| Expr::Member(MemberExpression::new(dim.clone())))
             .collect_vec();
 
         let mut context_factory = SqlNodesFactory::new();
         context_factory.set_rolling_window(true);
 
-        //let node_context = context_factory.rolling_window_node_processor();
-
-        let mut select_builder = SelectBuilder::new(from, context_factory);
+        let references_builder = ReferencesBuilder::new(from.clone());
+        let mut render_references = HashMap::new();
+        let mut select_builder = SelectBuilder::new(from.clone());
         for dim in dimensions.iter() {
             if dim.full_name() == rolling_window_desc.time_dimension.full_name() {
-                select_builder.add_projection_member(
-                    &dim,
-                    Some(root_alias.clone()),
-                    Some(
-                        cte_schemas
-                            .get(&inputs[1])
-                            .unwrap()
-                            .resolve_member_alias(&dim, &Some(inputs[1].clone())),
-                    ),
+                render_references.insert(
+                    dim.full_name(),
+                    QualifiedColumnName::new(Some(root_alias.clone()), format!("date_from")),
                 );
             } else {
-                select_builder.add_projection_member(&dim, None, None);
+                references_builder.resolve_references_for_member(
+                    dim.member_evaluator(),
+                    &Some(alias.clone()),
+                    &mut render_references,
+                )?;
             }
+            let alias =
+                references_builder.resolve_alias_for_member(&dim.full_name(), &Some(alias.clone()));
+            select_builder.add_projection_member(&dim, alias);
         }
 
         let query_member = self.query_member_as_base_member()?;
-        select_builder.add_projection_member(&query_member, None, None);
+        let query_member_base_name = rolling_base_cte_schema.resolve_member_alias(&query_member);
+
+        context_factory.add_ungrouped_measure_reference(
+            query_member.full_name(),
+            QualifiedColumnName::new(Some(alias), query_member_base_name),
+        );
+        context_factory.set_render_references(render_references);
+
+        select_builder.add_projection_member(&query_member, None);
         select_builder.set_group_by(group_by);
         select_builder.set_order_by(self.query_order()?);
-        let select = select_builder.build();
+        let select = select_builder.build(context_factory);
 
         Ok(Rc::new(Cte::new_from_select(
             Rc::new(select),
@@ -177,7 +189,7 @@ impl MultiStageMemberQueryPlanner {
         } else {
             dimensions
                 .iter()
-                .map(|dim| Expr::Member(MemberExpression::new(dim.clone(), None)))
+                .map(|dim| Expr::Member(MemberExpression::new(dim.clone())))
                 .collect_vec()
         };
 
@@ -205,16 +217,31 @@ impl MultiStageMemberQueryPlanner {
             _ => {}
         };
 
-        let mut select_builder = SelectBuilder::new(from, context_factory);
+        let references_builder = ReferencesBuilder::new(from.clone());
+        let mut render_references = HashMap::new();
+        let mut select_builder = SelectBuilder::new(from.clone());
         for dim in dimensions.iter() {
-            select_builder.add_projection_member(&dim, None, None);
+            references_builder.resolve_references_for_member(
+                dim.member_evaluator(),
+                &None,
+                &mut render_references,
+            )?;
+            let alias = references_builder.resolve_alias_for_member(&dim.full_name(), &None);
+            select_builder.add_projection_member(&dim, alias);
         }
 
         let query_member = self.query_member_as_base_member()?;
-        select_builder.add_projection_member(&query_member, None, None);
+        references_builder.resolve_references_for_member(
+            query_member.member_evaluator(),
+            &None,
+            &mut render_references,
+        )?;
+        let alias = references_builder.resolve_alias_for_member(&query_member.full_name(), &None);
+        select_builder.add_projection_member(&query_member, alias);
         select_builder.set_group_by(group_by);
         select_builder.set_order_by(order_by);
-        let select = select_builder.build();
+        context_factory.set_render_references(render_references);
+        let select = select_builder.build(context_factory);
 
         Ok(Rc::new(Cte::new_from_select(
             Rc::new(select),
@@ -237,36 +264,67 @@ impl MultiStageMemberQueryPlanner {
             cte_schema,
             Some(root_alias.clone()),
         );
-        for (i, input) in inputs.iter().skip(1).enumerate() {
-            let left_alias = format!("q_{}", i);
-            let right_alias = format!("q_{}", i + 1);
-            let on = JoinCondition::new_dimension_join(
-                left_alias,
-                right_alias,
-                dimensions.clone(),
-                true,
-            );
+        for (i, input) in inputs.iter().enumerate().skip(1) {
+            let left_alias = format!("q_{}", i - 1);
+            let right_alias = format!("q_{}", i);
+            let left_schema = cte_schemas.get(&inputs[i - 1]).unwrap().clone();
             let cte_schema = cte_schemas.get(input).unwrap().clone();
+            let conditions = dimensions
+                .iter()
+                .map(|dim| {
+                    let alias_in_left_query = left_schema.resolve_member_alias(dim);
+                    let left_ref = Expr::Reference(QualifiedColumnName::new(
+                        Some(left_alias.clone()),
+                        alias_in_left_query,
+                    ));
+                    let alias_in_right_query = cte_schema.resolve_member_alias(dim);
+                    let right_ref = Expr::Reference(QualifiedColumnName::new(
+                        Some(right_alias.clone()),
+                        alias_in_right_query,
+                    ));
+                    (left_ref, right_ref)
+                })
+                .collect_vec();
+            let on = JoinCondition::new_dimension_join(conditions, true);
             join_builder.inner_join_table_reference(
                 input.clone(),
                 cte_schema,
-                Some(format!("q_{}", i + 1)),
+                Some(format!("q_{}", i)),
                 on,
             );
         }
 
         let from = From::new_from_join(join_builder.build());
-        let mut select_builder = SelectBuilder::new(from, SqlNodesFactory::new());
+        let references_builder = ReferencesBuilder::new(from.clone());
+        let mut render_references = HashMap::new();
+        let mut select_builder = SelectBuilder::new(from.clone());
 
+        let root_source = Some(root_alias);
         for dim in dimensions.iter() {
-            select_builder.add_projection_member(dim, None, None)
+            references_builder.resolve_references_for_member(
+                dim.member_evaluator(),
+                &root_source,
+                &mut render_references,
+            )?;
+            let alias = references_builder.resolve_alias_for_member(&dim.full_name(), &root_source);
+            select_builder.add_projection_member(dim, alias)
         }
         for meas in self.input_measures()?.iter() {
-            select_builder.add_projection_member(meas, None, None)
+            references_builder.resolve_references_for_member(
+                meas.member_evaluator(),
+                &None,
+                &mut render_references,
+            )?;
+            let alias = references_builder.resolve_alias_for_member(&meas.full_name(), &None);
+            select_builder.add_projection_member(meas, alias)
         }
         select_builder.set_order_by(self.subquery_order()?);
 
-        Ok(QueryPlan::Select(Rc::new(select_builder.build())))
+        let mut node_factory = SqlNodesFactory::new();
+        node_factory.set_render_references(render_references);
+        Ok(QueryPlan::Select(Rc::new(
+            select_builder.build(node_factory),
+        )))
     }
 
     fn plan_for_leaf_cte_query(&self) -> Result<Rc<Cte>, CubeError> {
@@ -295,11 +353,8 @@ impl MultiStageMemberQueryPlanner {
             false,
         )?;
 
-        let node_factory = if self.description.state().time_shifts().is_empty() {
-            SqlNodesFactory::new()
-        } else {
-            SqlNodesFactory::new_with_time_shifts(self.description.state().time_shifts().clone())
-        };
+        let mut node_factory = SqlNodesFactory::new();
+        node_factory.set_time_shifts(self.description.state().time_shifts().clone());
 
         /* if cte_query_properties
             .full_key_aggregate_measures()?
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage_query_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage_query_planner.rs
index c7c5f8ecc251d..1a2f2955d71b8 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
@@ -10,7 +10,7 @@ use crate::planner::sql_evaluator::collectors::has_multi_stage_members;
 use crate::planner::sql_evaluator::collectors::member_childs;
 use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
 use crate::planner::sql_evaluator::MemberSymbol;
-use crate::planner::{BaseDimension, BaseMeasure, VisitorContext};
+use crate::planner::{BaseDimension, BaseMeasure};
 use crate::planner::{BaseTimeDimension, GranularityHelper, QueryProperties};
 use cubenativeutils::CubeError;
 use itertools::Itertools;
@@ -78,7 +78,7 @@ impl MultiStageQueryPlanner {
                     descr.clone(),
                 )
                 .plan_query(&cte_schemas)?;
-                cte_schemas.insert(descr.alias().clone(), Rc::new(res.make_schema()));
+                cte_schemas.insert(descr.alias().clone(), res.query().schema());
                 Ok(res)
             })
             .collect::<Result<Vec<_>, _>>()?;
@@ -97,12 +97,10 @@ impl MultiStageQueryPlanner {
         cte_schemas: &HashMap<String, Rc<Schema>>,
     ) -> Rc<Select> {
         let schema = cte_schemas.get(alias).unwrap().clone();
-        let select_builder = SelectBuilder::new(
-            From::new_from_table_reference(alias.clone(), schema, None),
-            SqlNodesFactory::new(),
-        );
+        let select_builder =
+            SelectBuilder::new(From::new_from_table_reference(alias.clone(), schema, None));
 
-        Rc::new(select_builder.build())
+        Rc::new(select_builder.build(SqlNodesFactory::new()))
     }
 
     fn create_multi_stage_inode_member(
@@ -260,21 +258,18 @@ impl MultiStageQueryPlanner {
                     ));
                 }
                 let time_dimension = time_dimensions[0].clone();
-                let source_name = format!("_{}_base", member.name());
-                //let (member, source) = member.try_split_measure(source_name).unwrap(); //FIXME
-                //unwrap!!!
 
                 let input = vec![
                     self.add_time_series(time_dimension.clone(), state.clone(), descriptions)?,
-                    /* self.add_rolling_window_base(
-                        source.clone(),
+                    self.add_rolling_window_base(
+                        member.clone(),
                         self.make_rolling_base_state(
                             time_dimension.clone(),
                             &rolling_window,
                             state.clone(),
                         )?,
                         descriptions,
-                    )?, */
+                    )?,
                 ];
 
                 let time_dimension = time_dimensions[0].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 0cc22f60e769d..1d1152d276e91 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,15 +1,18 @@
 use super::{CommonUtils, JoinPlanner};
-use crate::plan::{From, JoinBuilder, JoinCondition, Select, SelectBuilder};
+use crate::plan::{
+    Expr, From, JoinBuilder, JoinCondition, MemberExpression, QualifiedColumnName, Select,
+    SelectBuilder,
+};
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::collectors::{
     collect_cube_names, collect_join_hints, collect_join_hints_for_measures,
 };
-use crate::planner::sql_evaluator::sql_nodes::{ungroupped_measure, SqlNodesFactory};
-use crate::planner::BaseMember;
-use crate::planner::QueryProperties;
-use crate::planner::{BaseMeasure, VisitorContext};
+use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
+use crate::planner::sql_evaluator::ReferencesBuilder;
+use crate::planner::{BaseMeasure, BaseMember, BaseMemberHelper, QueryProperties};
 use cubenativeutils::CubeError;
 use itertools::Itertools;
+use std::collections::HashMap;
 use std::rc::Rc;
 
 pub struct MultipliedMeasuresQueryPlanner {
@@ -75,67 +78,108 @@ impl MultipliedMeasuresQueryPlanner {
             self.check_should_build_join_for_measure_select(measures, key_cube_name)?;
 
         let mut join_builder =
-            JoinBuilder::new_from_subselect(keys_query, keys_query_alias.clone());
+            JoinBuilder::new_from_subselect(keys_query.clone(), keys_query_alias.clone());
 
         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")));
-        let measures = if should_build_join_for_measure_select {
-            let mut top_measures = vec![];
-            let mut ungroupped_measures = vec![];
-            /* for meas in measures.iter() {
-                let ungropped_name = format!("{}_ungrouped", meas.name());
-                let (top, ungrouped) = meas
-                    .member_evaluator()
-                    .clone()
-                    .try_split_measure(ungropped_name)
-                    .unwrap();
-                top_measures.push(BaseMeasure::try_new(top, self.query_tools.clone())?.unwrap());
-                ungroupped_measures
-                    .push(BaseMeasure::try_new(ungrouped, self.query_tools.clone())?.unwrap());
-            } */
+        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,
+            )?;
+
+            let conditions = primary_keys_dimensions
+                .iter()
+                .map(|dim| {
+                    let alias_in_keys_query = keys_query.schema().resolve_member_alias(dim);
+                    let keys_query_ref = Expr::Reference(QualifiedColumnName::new(
+                        Some(keys_query_alias.clone()),
+                        alias_in_keys_query,
+                    ));
+                    let alias_in_subquery = subquery.schema().resolve_member_alias(dim);
+                    let subquery_ref = Expr::Reference(QualifiedColumnName::new(
+                        Some(pk_cube_alias.clone()),
+                        alias_in_subquery,
+                    ));
+                    (keys_query_ref, subquery_ref)
+                })
+                .collect_vec();
+
+            for meas in measures.iter() {
+                ungrouped_measure_references.insert(
+                    meas.full_name(),
+                    QualifiedColumnName::new(
+                        Some(pk_cube_alias.clone()),
+                        subquery
+                            .schema()
+                            .resolve_member_alias(&meas.clone().as_base_member()),
+                    ),
+                );
+            }
+
             join_builder.left_join_subselect(
-                self.aggregate_subquery_measure_join(
-                    key_cube_name,
-                    &ungroupped_measures,
-                    &primary_keys_dimensions,
-                )?,
+                subquery,
                 pk_cube_alias.clone(),
-                JoinCondition::new_dimension_join(
-                    keys_query_alias,
-                    pk_cube_alias,
-                    primary_keys_dimensions,
-                    false,
-                ),
+                JoinCondition::new_dimension_join(conditions, false),
             );
-            top_measures
         } else {
+            let conditions = primary_keys_dimensions
+                .iter()
+                .map(|dim| {
+                    let alias_in_keys_query = keys_query.schema().resolve_member_alias(dim);
+                    let keys_query_ref = Expr::Reference(QualifiedColumnName::new(
+                        Some(keys_query_alias.clone()),
+                        alias_in_keys_query,
+                    ));
+                    let pk_cube_expr = Expr::Member(MemberExpression::new(dim.clone()));
+                    (keys_query_ref, pk_cube_expr)
+                })
+                .collect_vec();
             join_builder.left_join_cube(
                 pk_cube.clone(),
                 Some(pk_cube_alias.clone()),
-                JoinCondition::new_dimension_join(
-                    keys_query_alias,
-                    pk_cube_alias,
-                    primary_keys_dimensions,
-                    false,
-                ),
+                JoinCondition::new_dimension_join(conditions, false),
             );
-            measures.clone()
         };
 
-        let mut select_builder = SelectBuilder::new(
-            From::new_from_join(join_builder.build()),
-            self.context_factory.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();
         for member in self
             .query_properties
-            .all_dimensions_and_measures(&measures)?
+            .all_dimensions_and_measures(&vec![])?
             .iter()
         {
-            select_builder.add_projection_member(member, None, None);
+            references_builder.resolve_references_for_member(
+                member.member_evaluator(),
+                &None,
+                &mut render_references,
+            )?;
+            let alias = references_builder.resolve_alias_for_member(&member.full_name(), &None);
+            select_builder.add_projection_member(member, alias);
+        }
+        for member in BaseMemberHelper::iter_as_base_member(&measures) {
+            let alias = if !should_build_join_for_measure_select {
+                references_builder.resolve_references_for_member(
+                    member.member_evaluator(),
+                    &None,
+                    &mut render_references,
+                )?;
+                references_builder.resolve_alias_for_member(&member.full_name(), &None)
+            } else {
+                None
+            };
+            select_builder.add_projection_member(&member, alias);
         }
         select_builder.set_group_by(self.query_properties.group_by());
-        Ok(Rc::new(select_builder.build()))
+        let mut context_factory = self.context_factory.clone();
+        context_factory.set_render_references(render_references);
+        context_factory.set_ungrouped_measure_references(ungrouped_measure_references);
+        Ok(Rc::new(select_builder.build(context_factory)))
     }
 
     fn check_should_build_join_for_measure_select(
@@ -163,7 +207,7 @@ impl MultipliedMeasuresQueryPlanner {
     }
     fn aggregate_subquery_measure_join(
         &self,
-        key_cube_name: &String,
+        _key_cube_name: &String,
         measures: &Vec<Rc<BaseMeasure>>,
         primary_keys_dimensions: &Vec<Rc<dyn BaseMember>>,
     ) -> Result<Rc<Select>, CubeError> {
@@ -173,14 +217,14 @@ impl MultipliedMeasuresQueryPlanner {
             .make_join_node_with_prefix_and_join_hints(&None, join_hints)?;
         let mut context_factory = self.context_factory.clone();
         context_factory.set_ungrouped_measure(true);
-        let mut select_builder = SelectBuilder::new(from, context_factory);
+        let mut select_builder = SelectBuilder::new(from);
         for dim in primary_keys_dimensions.iter() {
-            select_builder.add_projection_member(dim, None, None);
+            select_builder.add_projection_member(dim, None);
         }
         for meas in measures.iter() {
-            select_builder.add_projection_member(&meas.clone().as_base_member(), None, None);
+            select_builder.add_projection_member(&meas.clone().as_base_member(), None);
         }
-        Ok(Rc::new(select_builder.build()))
+        Ok(Rc::new(select_builder.build(context_factory)))
     }
 
     fn regular_measures_subquery(
@@ -190,17 +234,26 @@ impl MultipliedMeasuresQueryPlanner {
         let source = self
             .join_planner
             .make_join_node_with_prefix(&Some(format!("main")))?;
-        let mut select_builder = SelectBuilder::new(source, self.context_factory.clone());
+
+        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
             .all_dimensions_and_measures(&measures)?
             .iter()
         {
-            select_builder.add_projection_member(member, None, None);
+            select_builder.add_projection_member(member, None);
         }
-        select_builder.set_filter(self.query_properties.all_filters());
+        let filter = self.query_properties.all_filters();
+        select_builder.set_filter(filter);
         select_builder.set_group_by(self.query_properties.group_by());
-        Ok(Rc::new(select_builder.build()))
+        Ok(Rc::new(select_builder.build(context_factory)))
     }
 
     fn key_query(
@@ -215,13 +268,19 @@ impl MultipliedMeasuresQueryPlanner {
             .query_properties
             .dimensions_for_select_append(dimensions);
 
-        let mut select_builder = SelectBuilder::new(source, self.context_factory.clone());
+        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);
+            }
+        }
         for member in dimensions.iter() {
-            select_builder.add_projection_member(&member, None, None);
+            select_builder.add_projection_member(&member, None);
         }
         select_builder.set_distinct();
         select_builder.set_filter(self.query_properties.all_filters());
 
-        Ok(Rc::new(select_builder.build()))
+        Ok(Rc::new(select_builder.build(context_factory)))
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/order_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/order_planner.rs
index ada3ec3df38f9..b5e9d6e2aa856 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/order_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/order_planner.rs
@@ -30,7 +30,7 @@ impl OrderPlanner {
                 .find(|(_, m)| m.full_name().to_lowercase() == itm.name().to_lowercase())
             {
                 result.push(OrderBy::new(
-                    Expr::Member(MemberExpression::new(member.clone(), None)),
+                    Expr::Member(MemberExpression::new(member.clone())),
                     pos + 1,
                     itm.desc(),
                 ));
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 21803cda8b9a5..9229314a0cc51 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/simple_query_planer.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/simple_query_planer.rs
@@ -2,8 +2,7 @@ use super::{JoinPlanner, OrderPlanner};
 use crate::plan::{Filter, Select, SelectBuilder};
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
-use crate::planner::QueryProperties;
-use crate::planner::VisitorContext;
+use crate::planner::{BaseMember, QueryProperties};
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
@@ -36,16 +35,20 @@ impl SimpleQueryPlanner {
                 items: self.query_properties.measures_filters().clone(),
             })
         };
-        let mut select_builder = SelectBuilder::new(
-            self.join_planner.make_join_node()?,
-            self.context_factory.clone(),
-        );
+        let mut context_factory = self.context_factory.clone();
+        let from = self.join_planner.make_join_node()?;
+        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())?
             .iter()
         {
-            select_builder.add_projection_member(member, None, None);
+            select_builder.add_projection_member(member, None);
         }
         select_builder.set_filter(filter);
         select_builder.set_group_by(self.query_properties.group_by());
@@ -53,7 +56,7 @@ impl SimpleQueryPlanner {
         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();
+        let res = 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 cbad5f4f406f8..54b31fa40ed20 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
@@ -31,12 +31,6 @@ impl OrderByItem {
     }
 }
 
-enum SymbolAggregateType {
-    Regular,
-    Multiplied,
-    MultiStage,
-}
-
 #[derive(Default, Clone)]
 pub struct FullKeyAggregateMeasures {
     pub multiplied_measures: Vec<Rc<BaseMeasure>>,
@@ -339,11 +333,11 @@ impl QueryProperties {
         } else {
             self.dimensions
                 .iter()
-                .map(|f| Expr::Member(MemberExpression::new(f.clone(), None)))
+                .map(|f| Expr::Member(MemberExpression::new(f.clone())))
                 .chain(
                     self.time_dimensions
                         .iter()
-                        .map(|f| Expr::Member(MemberExpression::new(f.clone(), None))),
+                        .map(|f| Expr::Member(MemberExpression::new(f.clone()))),
                 )
                 .collect()
         }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs
index 005f6e5384eea..73f875a07adc1 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/cube_names_collector.rs
@@ -31,11 +31,17 @@ impl TraversalVisitor for CubeNamesCollector {
                 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);
+                }
             }
             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);
+                }
             }
             MemberSymbol::CubeName(e) => {
                 self.names.insert(e.cube_name().clone());
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/join_hints_collector.rs
index d5e128c796176..b33ea186c6083 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,7 +1,6 @@
 use crate::planner::sql_evaluator::{MemberSymbol, TraversalVisitor};
 use crate::planner::BaseMeasure;
 use cubenativeutils::CubeError;
-use std::collections::HashSet;
 use std::rc::Rc;
 
 pub struct JoinHintsCollector {
@@ -30,11 +29,17 @@ impl TraversalVisitor for JoinHintsCollector {
                 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);
+                }
             }
             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);
+                }
             }
             MemberSymbol::CubeName(e) => {
                 self.hints.push(e.cube_name().clone());
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 1aab6e120978e..8bb049ee48b6a 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
@@ -37,7 +37,7 @@ impl TraversalVisitor for MemberChildsCollector {
         if state.is_root {
             let new_state = MemberChildsCollectorState::new(false);
             match node.as_ref() {
-                MemberSymbol::Measure(s) => Ok(Some(new_state)),
+                MemberSymbol::Measure(_) => Ok(Some(new_state)),
                 MemberSymbol::Dimension(_) => Ok(Some(new_state)),
                 _ => Ok(None),
             }
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 e0345e96658e6..c285bff19379f 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
@@ -39,7 +39,7 @@ impl TraversalVisitor for CompositeMeasuresCollector {
         state: &Self::State,
     ) -> Result<Option<Self::State>, CubeError> {
         let res = match node.as_ref() {
-            MemberSymbol::Measure(e) => {
+            MemberSymbol::Measure(_) => {
                 if let Some(parent) = &state.parent_measure {
                     if parent.cube_name() != node.cube_name() {
                         self.composite_measures.insert(parent.full_name());
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs
index 74322f40efc3e..c23f085fbee99 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/compiler.rs
@@ -112,8 +112,6 @@ impl Compiler {
         full_name: &String,
         factory: T,
     ) -> Result<Rc<MemberSymbol>, CubeError> {
-        let cube_name = factory.cube_name();
-
         let node = factory.build(self)?;
         let key = (T::symbol_name().to_string(), full_name.clone());
         if T::is_cachable() {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs
index 1b146b5ba53c3..ce284b26387b3 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs
@@ -1,7 +1,5 @@
-use super::symbols::CubeTableSymbol;
 use super::symbols::MemberSymbol;
 use super::Compiler;
-use super::SqlCall;
 use crate::cube_bridge::evaluator::{CallDep, CubeEvaluator};
 use crate::cube_bridge::memeber_sql::MemberSql;
 use cubenativeutils::CubeError;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs
index ee9940aa6e673..7612612d20969 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/mod.rs
@@ -1,6 +1,7 @@
 pub mod collectors;
 pub mod compiler;
 mod dependecy;
+pub mod references_builder;
 pub mod sql_call;
 pub mod sql_node_transformers;
 pub mod sql_nodes;
@@ -10,6 +11,7 @@ pub mod visitor;
 
 pub use compiler::Compiler;
 pub use dependecy::{CubeDepProperty, Dependency};
+pub use references_builder::ReferencesBuilder;
 pub use sql_call::SqlCall;
 pub use sql_visitor::SqlEvaluatorVisitor;
 pub use symbols::{
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/references_builder.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/references_builder.rs
new file mode 100644
index 0000000000000..f14f6f15e500d
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/references_builder.rs
@@ -0,0 +1,310 @@
+use crate::plan::{
+    Filter, FilterItem, From, Join, QualifiedColumnName, SingleAliasedSource, SingleSource,
+};
+use cubenativeutils::CubeError;
+use std::collections::HashMap;
+use std::rc::Rc;
+
+use super::MemberSymbol;
+
+pub struct ReferencesBuilder {
+    source: Rc<From>,
+}
+
+impl ReferencesBuilder {
+    pub fn new(source: Rc<From>) -> Self {
+        Self { source }
+    }
+
+    pub fn validate_member(
+        &self,
+        member: Rc<MemberSymbol>,
+        strict_source: &Option<String>,
+    ) -> Result<(), CubeError> {
+        let member_name = member.full_name();
+        if self
+            .find_reference_for_member(&member_name, strict_source)
+            .is_some()
+        {
+            return Ok(());
+        }
+
+        let dependencies = member.get_dependencies();
+        if !dependencies.is_empty() {
+            for dep in dependencies.iter() {
+                self.validate_member(dep.clone(), strict_source)?;
+            }
+        } else {
+            if !self.has_source_for_leaf_memeber(&member, strict_source) {
+                return Err(CubeError::internal(format!(
+                    "Planning error: member {} has no source",
+                    member_name
+                )));
+            }
+        }
+        Ok(())
+    }
+
+    pub fn resolve_references_for_member(
+        &self,
+        member: Rc<MemberSymbol>,
+        strict_source: &Option<String>,
+        references: &mut HashMap<String, QualifiedColumnName>,
+    ) -> Result<(), CubeError> {
+        let member_name = member.full_name();
+        if let Some(reference) = self.find_reference_for_member(&member_name, strict_source) {
+            references.insert(member_name.clone(), reference);
+            return Ok(());
+        }
+
+        let dependencies = member.get_dependencies();
+        if !dependencies.is_empty() {
+            for dep in dependencies.iter() {
+                self.resolve_references_for_member(dep.clone(), strict_source, references)?
+            }
+        } else {
+            if !self.has_source_for_leaf_memeber(&member, strict_source) {
+                return Err(CubeError::internal(format!(
+                    "Planning error: member {} has no source",
+                    member_name
+                )));
+            }
+        }
+
+        Ok(())
+    }
+
+    pub fn validete_member_for_leaf_query(
+        &self,
+        member: Rc<MemberSymbol>,
+        strict_source: &Option<String>,
+    ) -> Result<(), CubeError> {
+        let dependencies = member.get_dependencies();
+        if !dependencies.is_empty() {
+            for dep in dependencies.iter() {
+                self.validete_member_for_leaf_query(dep.clone(), strict_source)?
+            }
+        } else {
+            if !self.has_source_for_leaf_memeber(&member, strict_source) {
+                return Err(CubeError::internal(format!(
+                    "Planning error: member {} has no source",
+                    member.full_name()
+                )));
+            }
+        }
+        Ok(())
+    }
+
+    pub fn validate_filter(&self, filter: &Filter) -> Result<(), CubeError> {
+        for itm in filter.items.iter() {
+            self.validate_filter_item(itm)?;
+        }
+        Ok(())
+    }
+
+    pub fn resolve_references_for_filter(
+        &self,
+        filter: &Filter,
+        references: &mut HashMap<String, QualifiedColumnName>,
+    ) -> Result<(), CubeError> {
+        for itm in filter.items.iter() {
+            self.resolve_references_for_filter_item(itm, references)?;
+        }
+        Ok(())
+    }
+
+    fn validate_filter_item(&self, item: &FilterItem) -> Result<(), CubeError> {
+        match item {
+            FilterItem::Item(item) => {
+                self.validate_member(item.member_evaluator().clone(), &None)?
+            }
+            FilterItem::Group(group) => {
+                for itm in group.items.iter() {
+                    self.validate_filter_item(itm)?
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn resolve_references_for_filter_item(
+        &self,
+        item: &FilterItem,
+        references: &mut HashMap<String, QualifiedColumnName>,
+    ) -> Result<(), CubeError> {
+        match item {
+            FilterItem::Item(item) => self.resolve_references_for_member(
+                item.member_evaluator().clone(),
+                &None,
+                references,
+            )?,
+            FilterItem::Group(group) => {
+                for itm in group.items.iter() {
+                    self.resolve_references_for_filter_item(itm, references)?
+                }
+            }
+        }
+        Ok(())
+    }
+
+    fn has_source_for_leaf_memeber(
+        &self,
+        member: &Rc<MemberSymbol>,
+        strict_source: &Option<String>,
+    ) -> bool {
+        match &self.source.source {
+            crate::plan::FromSource::Empty => false,
+            crate::plan::FromSource::Single(source) => {
+                self.is_single_source_has_leaf_member(&source, member, strict_source)
+            }
+            crate::plan::FromSource::Join(join) => {
+                self.is_single_source_has_leaf_member(&join.root, member, strict_source)
+                    || join.joins.iter().any(|itm| {
+                        self.is_single_source_has_leaf_member(&itm.from, member, strict_source)
+                    })
+            }
+        }
+    }
+
+    fn is_single_source_has_leaf_member(
+        &self,
+        source: &SingleAliasedSource,
+        member: &Rc<MemberSymbol>,
+        strict_source: &Option<String>,
+    ) -> bool {
+        if let Some(strict_source) = strict_source {
+            if strict_source != &source.alias {
+                return false;
+            }
+        }
+
+        match &source.source {
+            SingleSource::Cube(cube) => {
+                cube.name() == &member.cube_name() && cube.has_member(&member.name())
+            }
+            _ => false,
+        }
+    }
+
+    pub fn resolve_alias_for_member(
+        &self,
+        member_name: &String,
+        strict_source: &Option<String>,
+    ) -> Option<String> {
+        if let Some(reference) = self.find_reference_for_member(member_name, strict_source) {
+            Some(reference.name().clone())
+        } else {
+            None
+        }
+    }
+
+    pub fn find_reference_for_member(
+        &self,
+        member_name: &String,
+        strict_source: &Option<String>,
+    ) -> Option<QualifiedColumnName> {
+        match &self.source.source {
+            crate::plan::FromSource::Empty => None,
+            crate::plan::FromSource::Single(source) => self
+                .find_reference_column_for_member_in_single_source(
+                    &source,
+                    member_name,
+                    strict_source,
+                ),
+            crate::plan::FromSource::Join(join) => {
+                self.find_reference_column_for_member_in_join(&join, member_name, strict_source)
+            }
+        }
+    }
+
+    fn find_reference_column_for_member_in_single_source(
+        &self,
+        source: &SingleAliasedSource,
+        member_name: &String,
+        strict_source: &Option<String>,
+    ) -> Option<QualifiedColumnName> {
+        if let Some(strict_source) = strict_source {
+            if strict_source != &source.alias {
+                return None;
+            }
+        }
+        let column_name = match &source.source {
+            SingleSource::Subquery(query_plan) => {
+                query_plan.schema().resolve_member_reference(member_name)
+            }
+            SingleSource::Cube(_) => None,
+            SingleSource::TableReference(_, schema) => schema.resolve_member_reference(member_name),
+        };
+        column_name.map(|col| QualifiedColumnName::new(Some(source.alias.clone()), col))
+    }
+
+    fn find_reference_column_for_member_in_join(
+        &self,
+        join: &Rc<Join>,
+        member_name: &String,
+        strict_source: &Option<String>,
+    ) -> Option<QualifiedColumnName> {
+        if let Some(root_ref) = self.find_reference_column_for_member_in_single_source(
+            &join.root,
+            member_name,
+            strict_source,
+        ) {
+            return Some(root_ref);
+        }
+        join.joins.iter().find_map(|item| {
+            self.find_reference_column_for_member_in_single_source(
+                &item.from,
+                member_name,
+                strict_source,
+            )
+        })
+    }
+
+    /* fn validate_reference(&self, reference: &QualifiedColumnName) -> Result<(), CubeError> {
+        if self.is_source_has_reference(reference) {
+            Ok(())
+        } else {
+            Err(CubeError::internal(format!(
+                "Error while planning: schema does not have reference {}",
+                reference
+            )))
+        }
+    }
+
+    fn is_source_has_reference(&self, reference: &QualifiedColumnName) -> bool {
+        match &self.source.source {
+            crate::plan::FromSource::Empty => false,
+            crate::plan::FromSource::Single(source) => {
+                self.is_single_source_has_reference(&source, reference)
+            }
+            crate::plan::FromSource::Join(join) => self.is_join_has_reference(&join, reference),
+        }
+    }
+
+    fn is_join_has_reference(&self, join: &Rc<Join>, reference: &QualifiedColumnName) -> bool {
+        if self.is_single_source_has_reference(&join.root, reference) {
+            return true;
+        }
+        join.joins
+            .iter()
+            .any(|item| self.is_single_source_has_reference(&item.from, reference))
+    }
+
+    fn is_single_source_has_reference(
+        &self,
+        source: &SingleAliasedSource,
+        reference: &QualifiedColumnName,
+    ) -> bool {
+        if let Some(reference_source) = &reference.source() {
+            if reference_source != &source.alias {
+                return false;
+            }
+        }
+
+        match &source.source {
+            SingleSource::Subquery(query_plan) => query_plan.schema().has_column(reference.name()),
+            SingleSource::Cube(_) => false,
+            SingleSource::TableReference(_, schema) => schema.has_column(reference.name()),
+        }
+    } */
+}
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 9de412fcdc56e..35fed31484c9a 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_call.rs
@@ -1,9 +1,6 @@
 use super::dependecy::{ContextSymbolDep, CubeDepProperty, CubeDependency, Dependency};
 use super::sql_nodes::SqlNode;
-use super::{
-    symbols::MemberSymbol, CubeNameSymbol, CubeTableSymbol, DimensionSymbol, MeasureSymbol,
-    SqlEvaluatorVisitor,
-};
+use super::{symbols::MemberSymbol, SqlEvaluatorVisitor};
 use crate::cube_bridge::memeber_sql::{ContextSymbolArg, MemberSql, MemberSqlArg, MemberSqlStruct};
 use crate::planner::query_tools::QueryTools;
 use cubenativeutils::CubeError;
@@ -47,6 +44,18 @@ impl SqlCall {
         }
     }
 
+    pub fn extract_cube_deps(&self, result: &mut Vec<String>) {
+        for dep in self.deps.iter() {
+            match dep {
+                Dependency::SymbolDependency(_) => {}
+                Dependency::CubeDependency(cube_dep) => {
+                    self.extract_cube_deps_from_cube_dep(cube_dep, result)
+                }
+                Dependency::ContextDependency(_) => {}
+            }
+        }
+    }
+
     fn extract_symbol_deps_from_cube_dep(
         &self,
         cube_dep: &CubeDependency,
@@ -62,6 +71,19 @@ impl SqlCall {
         }
     }
 
+    fn extract_cube_deps_from_cube_dep(&self, cube_dep: &CubeDependency, result: &mut Vec<String>) {
+        result.push(cube_dep.cube_symbol.name());
+
+        for (_, v) in cube_dep.properties.iter() {
+            match v {
+                CubeDepProperty::CubeDependency(cube_dep) => {
+                    self.extract_cube_deps_from_cube_dep(cube_dep, result)
+                }
+                _ => {}
+            };
+        }
+    }
+
     fn evaluate_single_dep(
         &self,
         dep: &Dependency,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_node_transformers/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_node_transformers/mod.rs
index 1c0aeef099360..e69de29bb2d1d 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_node_transformers/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_node_transformers/mod.rs
@@ -1,3 +0,0 @@
-pub mod set_schema;
-
-pub use set_schema::set_schema;
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 be8446eabe168..63587cb9289ed 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
@@ -1,5 +1,4 @@
 use super::SqlNode;
-use crate::cube_bridge::memeber_sql::MemberSqlArg;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
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 fb86c9f7dba69..a288558b292e8 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,24 +1,22 @@
+use super::leaf_time_dimension::LeafTimeDimensionNode;
 use super::{
     AutoPrefixSqlNode, EvaluateSqlNode, FinalMeasureSqlNode, MeasureFilterSqlNode,
     MultiStageRankNode, MultiStageWindowNode, RenderReferencesSqlNode, RollingWindowNode,
     RootSqlNode, SqlNode, TimeShiftSqlNode, UngroupedMeasureSqlNode,
     UngroupedQueryFinalMeasureSqlNode,
 };
+use crate::plan::schema::QualifiedColumnName;
 use std::collections::HashMap;
 use std::rc::Rc;
-#[derive(Clone)]
-pub struct Reference {
-    pub reference: String,
-    pub source: Option<String>,
-}
 
 #[derive(Clone)]
 pub struct SqlNodesFactory {
     time_shifts: HashMap<String, String>,
     ungrouped: bool,
     ungrouped_measure: bool,
-    render_references: HashMap<String, Reference>,
-    ungrouped_measure_references: HashMap<String, Reference>,
+    render_references: HashMap<String, QualifiedColumnName>,
+    ungrouped_measure_references: HashMap<String, QualifiedColumnName>,
+    leaf_time_dimensions: HashMap<String, String>,
     cube_name_references: HashMap<String, String>,
     multi_stage_rank: Option<Vec<String>>,   //partition_by
     multi_stage_window: Option<Vec<String>>, //partition_by
@@ -34,32 +32,7 @@ impl SqlNodesFactory {
             render_references: HashMap::new(),
             ungrouped_measure_references: HashMap::new(),
             cube_name_references: HashMap::new(),
-            multi_stage_rank: None,
-            multi_stage_window: None,
-            rolling_window: false,
-        }
-    }
-    pub fn new_ungroupped() -> Self {
-        Self {
-            time_shifts: HashMap::new(),
-            ungrouped: true,
-            ungrouped_measure: false,
-            render_references: HashMap::new(),
-            ungrouped_measure_references: HashMap::new(),
-            cube_name_references: HashMap::new(),
-            multi_stage_rank: None,
-            multi_stage_window: None,
-            rolling_window: false,
-        }
-    }
-    pub fn new_with_time_shifts(time_shifts: HashMap<String, String>) -> Self {
-        Self {
-            time_shifts,
-            ungrouped: false,
-            ungrouped_measure: false,
-            render_references: HashMap::new(),
-            ungrouped_measure_references: HashMap::new(),
-            cube_name_references: HashMap::new(),
+            leaf_time_dimensions: HashMap::new(),
             multi_stage_rank: None,
             multi_stage_window: None,
             rolling_window: false,
@@ -78,15 +51,15 @@ impl SqlNodesFactory {
         self.ungrouped_measure = value;
     }
 
-    pub fn set_render_references(&mut self, value: HashMap<String, Reference>) {
+    pub fn set_render_references(&mut self, value: HashMap<String, QualifiedColumnName>) {
         self.render_references = value;
     }
 
-    pub fn render_references(&self) -> &HashMap<String, Reference> {
+    pub fn render_references(&self) -> &HashMap<String, QualifiedColumnName> {
         &self.render_references
     }
 
-    pub fn add_render_reference(&mut self, key: String, value: Reference) {
+    pub fn add_render_reference(&mut self, key: String, value: QualifiedColumnName) {
         self.render_references.insert(key, value);
     }
 
@@ -94,6 +67,11 @@ 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);
     }
@@ -102,11 +80,14 @@ impl SqlNodesFactory {
         self.rolling_window = value;
     }
 
-    pub fn set_ungrouped_measure_references(&mut self, value: HashMap<String, Reference>) {
+    pub fn set_ungrouped_measure_references(
+        &mut self,
+        value: HashMap<String, QualifiedColumnName>,
+    ) {
         self.ungrouped_measure_references = value;
     }
 
-    pub fn add_ungrouped_measure_reference(&mut self, key: String, value: Reference) {
+    pub fn add_ungrouped_measure_reference(&mut self, key: String, value: QualifiedColumnName) {
         self.ungrouped_measure_references.insert(key, value);
     }
 
@@ -127,8 +108,9 @@ impl SqlNodesFactory {
 
         let measure_filter_processor = MeasureFilterSqlNode::new(auto_prefix_processor.clone());
 
-        let measure_processor = self.final_measure_node_processor(measure_filter_processor.clone());
-        let measure_processor = self.add_rolling_window_if_needed(measure_processor);
+        let measure_processor =
+            self.add_ungrouped_measure_reference_if_needed(measure_filter_processor.clone());
+        let measure_processor = self.final_measure_node_processor(measure_processor);
         let measure_processor = self
             .add_multi_stage_window_if_needed(measure_processor, measure_filter_processor.clone());
         let measure_processor = self.add_multi_stage_rank_if_needed(measure_processor);
@@ -139,7 +121,18 @@ impl SqlNodesFactory {
             auto_prefix_processor.clone(),
             evaluate_sql_processor.clone(),
         );
-        RenderReferencesSqlNode::new(root_node)
+        RenderReferencesSqlNode::new(root_node, self.render_references.clone())
+    }
+
+    fn add_ungrouped_measure_reference_if_needed(
+        &self,
+        default: Rc<dyn SqlNode>,
+    ) -> Rc<dyn SqlNode> {
+        if !self.ungrouped_measure_references.is_empty() {
+            RenderReferencesSqlNode::new(default, self.ungrouped_measure_references.clone())
+        } else {
+            default
+        }
     }
 
     fn add_multi_stage_rank_if_needed(&self, default: Rc<dyn SqlNode>) -> Rc<dyn SqlNode> {
@@ -162,29 +155,30 @@ impl SqlNodesFactory {
         }
     }
 
-    fn add_rolling_window_if_needed(&self, default: Rc<dyn SqlNode>) -> Rc<dyn SqlNode> {
-        if self.rolling_window {
-            RollingWindowNode::new(default)
-        } else {
-            default
-        }
-    }
-
     fn final_measure_node_processor(&self, input: Rc<dyn SqlNode>) -> Rc<dyn SqlNode> {
         if self.ungrouped_measure {
             UngroupedMeasureSqlNode::new(input)
         } else if self.ungrouped {
             UngroupedQueryFinalMeasureSqlNode::new(input)
+        } else if self.rolling_window {
+            RollingWindowNode::new(input)
         } else {
             FinalMeasureSqlNode::new(input)
         }
     }
 
     fn dimension_processor(&self, input: Rc<dyn SqlNode>) -> Rc<dyn SqlNode> {
-        if !&self.time_shifts.is_empty() {
+        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 285f8258c9e79..c844c2a786de4 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,5 +1,4 @@
 use super::SqlNode;
-use crate::cube_bridge::memeber_sql::MemberSqlArg;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
@@ -31,19 +30,6 @@ impl SqlNode for FinalMeasureSqlNode {
     ) -> Result<String, CubeError> {
         let res = match node.as_ref() {
             MemberSymbol::Measure(ev) => {
-                /* let input = if ev.is_splitted_source() {
-                    let args = visitor.evaluate_deps(node, node_processor.clone())?;
-                    //FIXME hack for working with
-                    //measures like rolling window
-                    if !args.is_empty() {
-                        match &args[0] {
-                            MemberSqlArg::String(s) => s.clone(),
-                            _ => "".to_string(),
-                        }
-                    } else {
-                        "".to_string()
-                    }
-                } else { */
                 let input = self.input.to_sql(
                     visitor,
                     node,
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
new file mode 100644
index 0000000000000..92c06ec1e6ea1
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/leaf_time_dimension.rs
@@ -0,0 +1,55 @@
+use super::SqlNode;
+use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::MemberSymbol;
+use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
+use cubenativeutils::CubeError;
+use std::any::Any;
+use std::collections::HashMap;
+use std::rc::Rc;
+
+pub struct LeafTimeDimensionNode {
+    input: Rc<dyn SqlNode>,
+    leaf_time_dimensions: HashMap<String, String>,
+}
+
+impl LeafTimeDimensionNode {
+    pub fn new(input: Rc<dyn SqlNode>, leaf_time_dimensions: HashMap<String, String>) -> Rc<Self> {
+        Rc::new(Self {
+            input,
+            leaf_time_dimensions,
+        })
+    }
+}
+
+impl SqlNode for LeafTimeDimensionNode {
+    fn to_sql(
+        &self,
+        visitor: &SqlEvaluatorVisitor,
+        node: &Rc<MemberSymbol>,
+        query_tools: Rc<QueryTools>,
+        node_processor: Rc<dyn SqlNode>,
+    ) -> Result<String, CubeError> {
+        let full_name = node.full_name();
+        let input_sql = self
+            .input
+            .to_sql(visitor, node, query_tools.clone(), node_processor)?;
+
+        let res = if let Some(granularity) = self.leaf_time_dimensions.get(&full_name) {
+            let converted_tz = query_tools.base_tools().convert_tz(input_sql)?;
+            query_tools
+                .base_tools()
+                .time_grouped_column(granularity.clone(), converted_tz)?
+        } else {
+            input_sql
+        };
+        Ok(res)
+    }
+
+    fn as_any(self: Rc<Self>) -> Rc<dyn Any> {
+        self.clone()
+    }
+
+    fn childs(&self) -> Vec<Rc<dyn SqlNode>> {
+        vec![self.input.clone()]
+    }
+}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/mod.rs
index 60a1c025855c5..346fb326cc689 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/mod.rs
@@ -2,6 +2,7 @@ pub mod auto_prefix;
 pub mod evaluate_sql;
 pub mod factory;
 pub mod final_measure;
+pub mod leaf_time_dimension;
 pub mod measure_filter;
 pub mod multi_stage_rank;
 pub mod multi_stage_window;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/render_references.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/render_references.rs
index a8948c39f487e..9d4e17a8687ce 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
@@ -1,27 +1,24 @@
 use super::SqlNode;
-use crate::plan::Schema;
+use crate::plan::QualifiedColumnName;
 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 RenderReferencesSqlNode {
     input: Rc<dyn SqlNode>,
-    schema: Rc<Schema>,
+    references: HashMap<String, QualifiedColumnName>,
 }
 
 impl RenderReferencesSqlNode {
-    pub fn new(input: Rc<dyn SqlNode>) -> Rc<Self> {
-        Rc::new(Self {
-            input,
-            schema: Rc::new(Schema::empty()),
-        })
-    }
-
-    pub fn new_with_schema(input: Rc<dyn SqlNode>, schema: Rc<Schema>) -> Rc<Self> {
-        Rc::new(Self { input, schema })
+    pub fn new(
+        input: Rc<dyn SqlNode>,
+        references: HashMap<String, QualifiedColumnName>,
+    ) -> Rc<Self> {
+        Rc::new(Self { input, references })
     }
 
     pub fn input(&self) -> &Rc<dyn SqlNode> {
@@ -37,23 +34,16 @@ impl SqlNode for RenderReferencesSqlNode {
         query_tools: Rc<QueryTools>,
         node_processor: Rc<dyn SqlNode>,
     ) -> Result<String, CubeError> {
-        let reference_column = match node.as_ref() {
-            MemberSymbol::Dimension(ev) => {
-                self.schema.find_column_for_member(&ev.full_name(), &None)
-            }
-            MemberSymbol::Measure(ev) => self.schema.find_column_for_member(&ev.full_name(), &None),
-            _ => None,
-        };
-
-        if let Some(reference_column) = reference_column {
-            let table_ref = reference_column.table_name.as_ref().map_or_else(
+        let full_name = node.full_name();
+        if let Some(reference) = self.references.get(&full_name) {
+            let table_ref = reference.source().as_ref().map_or_else(
                 || format!(""),
                 |table_name| format!("{}.", query_tools.escape_column_name(table_name)),
             );
             Ok(format!(
                 "{}{}",
                 table_ref,
-                query_tools.escape_column_name(&reference_column.alias)
+                query_tools.escape_column_name(&reference.name())
             ))
         } else {
             self.input
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 c9a8a92875b9a..b6bcc87431855 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,5 +1,4 @@
 use super::SqlNode;
-use crate::cube_bridge::memeber_sql::MemberSqlArg;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::{MemberSymbol, SqlEvaluatorVisitor};
 use cubenativeutils::CubeError;
@@ -30,19 +29,10 @@ impl SqlNode for RollingWindowNode {
     ) -> Result<String, CubeError> {
         let res = match node.as_ref() {
             MemberSymbol::Measure(m) => {
-                if m.is_cumulative() && m.is_splitted_source() {
-                    //let args = visitor.evaluate_deps(node, node_processor.clone())?;
-                    //FIXME hack for working with
-                    //measures like rolling window
-                    let input = "111".to_string();
-                    /* if !args.is_empty() {
-                        match &args[0] {
-                            MemberSqlArg::String(s) => s.clone(),
-                            _ => "".to_string(),
-                        }
-                    } else {
-                        "".to_string()
-                    }; */
+                let input =
+                    self.input
+                        .to_sql(visitor, node, query_tools.clone(), node_processor)?;
+                if m.is_cumulative() {
                     let aggregate_function = if m.measure_type() == "sum"
                         || m.measure_type() == "count"
                         || m.measure_type() == "runningTotal"
@@ -54,8 +44,7 @@ impl SqlNode for RollingWindowNode {
 
                     format!("{}({})", aggregate_function, input)
                 } else {
-                    self.input
-                        .to_sql(visitor, node, query_tools.clone(), node_processor.clone())?
+                    input
                 }
             }
             _ => {
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 e0cdff9155242..1b2f9675a7492 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
@@ -29,7 +29,7 @@ impl SqlNode for UngroupedMeasureSqlNode {
         node_processor: Rc<dyn SqlNode>,
     ) -> Result<String, CubeError> {
         let res = match node.as_ref() {
-            MemberSymbol::Measure(ev) => {
+            MemberSymbol::Measure(_) => {
                 let input = self.input.to_sql(
                     visitor,
                     node,
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 13d779fa6ca86..6a583bd86a135 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_visitor.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_visitor.rs
@@ -1,7 +1,5 @@
-use super::dependecy::{ContextSymbolDep, CubeDepProperty, CubeDependency, Dependency};
 use super::sql_nodes::SqlNode;
 use super::MemberSymbol;
-use crate::cube_bridge::memeber_sql::{ContextSymbolArg, MemberSqlArg, MemberSqlStruct};
 use crate::planner::query_tools::QueryTools;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
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 09fde605ff843..263d28e88c7b6 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,11 +1,9 @@
 use super::{MemberSymbol, SymbolFactory};
 use crate::cube_bridge::cube_definition::CubeDefinition;
 use crate::cube_bridge::evaluator::CubeEvaluator;
-use crate::cube_bridge::memeber_sql::{MemberSql, MemberSqlArg};
+use crate::cube_bridge::memeber_sql::MemberSql;
 use crate::planner::query_tools::QueryTools;
-use crate::planner::sql_evaluator::{
-    dependecy::Dependency, sql_nodes::SqlNode, Compiler, SqlCall, SqlEvaluatorVisitor,
-};
+use crate::planner::sql_evaluator::{sql_nodes::SqlNode, Compiler, SqlCall, SqlEvaluatorVisitor};
 use cubenativeutils::CubeError;
 use lazy_static::lazy_static;
 use regex::Regex;
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 25560d985bd3c..40ec863b6e8ff 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,11 +1,9 @@
 use super::{MemberSymbol, SymbolFactory};
 use crate::cube_bridge::dimension_definition::DimensionDefinition;
 use crate::cube_bridge::evaluator::CubeEvaluator;
-use crate::cube_bridge::memeber_sql::{MemberSql, MemberSqlArg};
+use crate::cube_bridge::memeber_sql::MemberSql;
 use crate::planner::query_tools::QueryTools;
-use crate::planner::sql_evaluator::{
-    sql_nodes::SqlNode, Compiler, Dependency, SqlCall, SqlEvaluatorVisitor,
-};
+use crate::planner::sql_evaluator::{sql_nodes::SqlNode, Compiler, SqlCall, SqlEvaluatorVisitor};
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
@@ -59,6 +57,12 @@ impl DimensionSymbol {
         deps
     }
 
+    pub fn get_dependent_cubes(&self) -> Vec<String> {
+        let mut cubes = vec![];
+        self.member_sql.extract_cube_deps(&mut cubes);
+        cubes
+    }
+
     pub fn cube_name(&self) -> &String {
         &self.cube_name
     }
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 279c4410ac5cd..7ef7024e700c6 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,11 +3,9 @@ use crate::cube_bridge::evaluator::CubeEvaluator;
 use crate::cube_bridge::measure_definition::{
     MeasureDefinition, RollingWindow, TimeShiftReference,
 };
-use crate::cube_bridge::memeber_sql::{MemberSql, MemberSqlArg};
+use crate::cube_bridge::memeber_sql::MemberSql;
 use crate::planner::query_tools::QueryTools;
-use crate::planner::sql_evaluator::{
-    sql_nodes::SqlNode, Compiler, Dependency, SqlCall, SqlEvaluatorVisitor,
-};
+use crate::planner::sql_evaluator::{sql_nodes::SqlNode, Compiler, SqlCall, SqlEvaluatorVisitor};
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
@@ -116,6 +114,18 @@ impl MeasureSymbol {
         deps
     }
 
+    pub fn get_dependent_cubes(&self) -> Vec<String> {
+        let mut cubes = vec![];
+        self.member_sql.extract_cube_deps(&mut cubes);
+        for filter in self.measure_filters.iter() {
+            filter.extract_cube_deps(&mut cubes);
+        }
+        for order in self.measure_order_by.iter() {
+            order.sql_call().extract_cube_deps(&mut cubes);
+        }
+        cubes
+    }
+
     pub fn owned_by_cube(&self) -> bool {
         self.definition()
             .static_data()
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 dc9893355b0a0..ac62b640e580e 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
@@ -64,4 +64,17 @@ impl MemberSymbol {
             Self::CubeTable(_) => vec![],
         }
     }
+
+    pub fn get_dependent_cubes(&self) -> Vec<String> {
+        match self {
+            Self::Dimension(d) => d.get_dependent_cubes(),
+            Self::Measure(m) => m.get_dependent_cubes(),
+            Self::CubeName(_) => vec![],
+            Self::CubeTable(_) => vec![],
+        }
+    }
+
+    pub fn is_leaf(&self) -> bool {
+        self.get_dependencies().is_empty()
+    }
 }
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 f1789c9f48efd..c0e681412ccfb 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,6 +1,5 @@
 use super::MemberSymbol;
 use crate::cube_bridge::memeber_sql::MemberSql;
-use crate::planner::sql_evaluator::dependecy::Dependency;
 use crate::planner::sql_evaluator::Compiler;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/visitor.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/visitor.rs
index c305e8e898b35..abef52ceeaa02 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/visitor.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/visitor.rs
@@ -1,7 +1,4 @@
-use super::{
-    dependecy::{CubeDepProperty, CubeDependency, Dependency},
-    MemberSymbol,
-};
+use super::MemberSymbol;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/filter.rs
index 05f9a85af6680..6ee5d9a3f66d6 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/filter.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/filter.rs
@@ -1,7 +1,7 @@
 use crate::cube_bridge::sql_templates_render::SqlTemplatesRender;
 use cubenativeutils::CubeError;
 use minijinja::context;
-use std::{ptr::null, rc::Rc};
+use std::rc::Rc;
 
 #[derive(Clone)]
 pub struct FilterTemplates {
@@ -209,7 +209,7 @@ impl FilterTemplates {
         self.render.render_template(
             &"expressions/ilike",
             context! {
-                expr => column.clone(),
+                expr => column,
                 negated => not,
                 pattern => pattern
             },
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/visitor_context.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/visitor_context.rs
index 23d4e6f20a962..7e4cf9137d9f8 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/visitor_context.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/visitor_context.rs
@@ -1,8 +1,6 @@
 use super::query_tools::QueryTools;
 use super::sql_evaluator::sql_nodes::{SqlNode, SqlNodesFactory};
 use super::sql_evaluator::{MemberSymbol, SqlCall};
-use crate::plan::Schema;
-use crate::planner::sql_evaluator::sql_node_transformers::set_schema;
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
@@ -31,10 +29,9 @@ pub fn evaluate_with_context(
     node: &Rc<MemberSymbol>,
     query_tools: Rc<QueryTools>,
     context: Rc<VisitorContext>,
-    source_schema: Rc<Schema>,
 ) -> Result<String, CubeError> {
     let visitor = context.make_visitor(query_tools);
-    let node_processor = set_schema(context.node_processor(), source_schema);
+    let node_processor = context.node_processor();
 
     visitor.apply(node, node_processor)
 }
@@ -43,9 +40,8 @@ pub fn evaluate_sql_call_with_context(
     sql_call: &Rc<SqlCall>,
     query_tools: Rc<QueryTools>,
     context: Rc<VisitorContext>,
-    source_schema: Rc<Schema>,
 ) -> Result<String, CubeError> {
     let visitor = context.make_visitor(query_tools.clone());
-    let node_processor = set_schema(context.node_processor(), source_schema);
+    let node_processor = context.node_processor();
     sql_call.eval(&visitor, node_processor, query_tools)
 }