diff --git a/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js b/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
index 3ac1a2de9e600..5d6e3fa86cee5 100644
--- a/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
+++ b/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
@@ -11,7 +11,7 @@ import cronParser from 'cron-parser';
 
 import moment from 'moment-timezone';
 import inflection from 'inflection';
-import { FROM_PARTITION_RANGE, inDbTimeZone, MAX_SOURCE_ROW_LIMIT, QueryAlias, getEnv } from '@cubejs-backend/shared';
+import { FROM_PARTITION_RANGE, inDbTimeZone, MAX_SOURCE_ROW_LIMIT, QueryAlias, getEnv, timeSeries as timeSeriesBase } from '@cubejs-backend/shared';
 
 import {
   buildSqlAndParams as nativeBuildSqlAndParams,
@@ -628,6 +628,11 @@ export class BaseQuery {
     return res;
   }
 
+  // FIXME helper for native generator, maybe should be moved entire to rust
+  generateTimeSeries(granularity, dateRange) {
+    return timeSeriesBase(granularity, dateRange);
+  }
+
   get shouldReuseParams() {
     return false;
   }
@@ -3232,7 +3237,16 @@ export class BaseQuery {
           '{% if offset is not none %}\nOFFSET {{ offset }}{% endif %}',
         group_by_exprs: '{{ group_by | map(attribute=\'index\') | join(\', \') }}',
         join: '{{ join_type }} JOIN {{ source }} ON {{ condition }}',
-        cte: '{{ alias }} AS ({{ query | indent(2, true) }})'
+        cte: '{{ alias }} AS ({{ query | indent(2, true) }})',
+        time_series_select: 'SELECT date_from::timestamp AS "date_from",\n' +
+        'date_to::timestamp AS "date_to" \n' +
+        'FROM(\n' +
+        '    VALUES ' +
+        '{% for time_item in seria  %}' +
+        '(\'{{ time_item | join(\'\\\', \\\'\') }}\')' +
+        '{% if not loop.last %}, {% endif %}' +
+        '{% endfor %}' +
+        ') AS dates (date_from, date_to)'
       },
       expressions: {
         column_reference: '{% if table_name %}{{ table_name }}.{% endif %}{{ name }}',
@@ -3253,6 +3267,8 @@ export class BaseQuery {
         cube: 'CUBE({{ exprs_concat }})',
         negative: '-({{ expr }})',
         not: 'NOT ({{ expr }})',
+        add_interval: '{{ date }} + interval \'{{ interval }}\'',
+        sub_interval: '{{ date }} - interval \'{{ interval }}\'',
         true: 'TRUE',
         false: 'FALSE',
         like: '{{ expr }} {% if negated %}NOT {% endif %}LIKE {{ pattern }}',
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 f9493faba34a0..a595e0523dc17 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
@@ -64,7 +64,7 @@ describe('SQL Generation', () => {
             offset: 'start'
           }
         },
-        revenueRolling3day: {
+        revenueRollingThreeDay: {
           type: 'sum',
           sql: 'amount',
           rollingWindow: {
@@ -769,7 +769,7 @@ describe('SQL Generation', () => {
 
   it('rolling month', async () => runQueryTest({
     measures: [
-      'visitors.revenueRolling3day'
+      'visitors.revenueRollingThreeDay'
     ],
     timeDimensions: [{
       dimension: 'visitors.created_at',
@@ -781,7 +781,7 @@ describe('SQL Generation', () => {
     }],
     timezone: 'America/Los_Angeles'
   }, [
-    { visitors__created_at_week: '2017-01-09T00:00:00.000Z', visitors__revenue_rolling3day: '900' }
+    { visitors__created_at_week: '2017-01-09T00:00:00.000Z', visitors__revenue_rolling_three_day: '900' }
   ]));
 
   it('rolling count', async () => runQueryTest({
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
index d5aef3c6d812d..5ade3438edc5c 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
@@ -38,4 +38,9 @@ pub trait BaseTools {
     fn filter_group_function(&self) -> Result<Rc<dyn FilterGroup>, CubeError>;
     fn timestamp_precision(&self) -> Result<u32, CubeError>;
     fn in_db_time_zone(&self, date: String) -> Result<String, CubeError>;
+    fn generate_time_series(
+        &self,
+        granularity: String,
+        date_range: Vec<String>,
+    ) -> Result<Vec<Vec<String>>, CubeError>;
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs
index 5b23f4e971e4e..4c1cdb21f2596 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/measure_definition.rs
@@ -21,6 +21,13 @@ pub struct TimeShiftReference {
     pub time_dimension: String,
 }
 
+#[derive(Serialize, Deserialize, Debug, PartialEq, Eq, Clone)]
+pub struct RollingWindow {
+    pub trailing: Option<String>,
+    pub leading: Option<String>,
+    pub offset: Option<String>,
+}
+
 #[derive(Serialize, Deserialize, Debug)]
 pub struct MeasureDefinitionStatic {
     #[serde(rename = "type")]
@@ -37,6 +44,8 @@ pub struct MeasureDefinitionStatic {
     pub group_by_references: Option<Vec<String>>,
     #[serde(rename = "timeShiftReferences")]
     pub time_shift_references: Option<Vec<TimeShiftReference>>,
+    #[serde(rename = "rollingWindow")]
+    pub rolling_window: Option<RollingWindow>,
 }
 
 #[nativebridge::native_bridge(MeasureDefinitionStatic)]
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs
index f118aefe5d8e5..9776ad592a37a 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs
@@ -6,7 +6,7 @@ use cubenativeutils::CubeError;
 use std::fmt;
 use std::rc::Rc;
 
-#[derive(Clone)]
+#[derive(Clone, PartialEq)]
 pub enum FilterGroupOperator {
     Or,
     And,
@@ -18,13 +18,19 @@ pub struct FilterGroup {
     pub items: Vec<FilterItem>,
 }
 
+impl PartialEq for FilterGroup {
+    fn eq(&self, other: &Self) -> bool {
+        self.operator == other.operator && self.items == other.items
+    }
+}
+
 impl FilterGroup {
     pub fn new(operator: FilterGroupOperator, items: Vec<FilterItem>) -> Self {
         Self { operator, items }
     }
 }
 
-#[derive(Clone)]
+#[derive(Clone, PartialEq)]
 pub enum FilterItem {
     Group(Rc<FilterGroup>),
     Item(Rc<BaseFilter>),
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs
index 19e8283bc5e68..eb3a7347bd103 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs
@@ -2,9 +2,113 @@ use super::{Schema, SingleAliasedSource};
 use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::{BaseJoinCondition, BaseMember, 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>,
+}
+
+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>,
+    ) -> Self {
+        Self {
+            data_source,
+            time_series_source,
+            trailing_interval,
+            leading_interval,
+            offset,
+            time_dimension,
+        }
+    }
+
+    pub fn to_sql(
+        &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())?;
+
+        lazy_static! {
+            static ref UNBOUNDED: Option<String> = Some("unbounded".to_string());
+        }
+
+        if self.trailing_interval != *UNBOUNDED {
+            let start_date = if self.offset == "start" {
+                templates.column_reference(&Some(self.time_series_source.clone()), "date_from")?
+            } else {
+                templates.column_reference(&Some(self.time_series_source.clone()), "date_to")?
+            };
+
+            let trailing_start = if let Some(trailing_interval) = &self.trailing_interval {
+                format!("{start_date} - interval '{trailing_interval}'")
+            } else {
+                start_date
+            };
+
+            let sign = if self.offset == "start" { ">=" } else { ">" };
+
+            conditions.push(format!("{date_column_alias} {sign} {trailing_start}"));
+        }
+
+        if self.leading_interval != *UNBOUNDED {
+            let end_date = if self.offset == "end" {
+                templates.column_reference(&Some(self.time_series_source.clone()), "date_to")?
+            } else {
+                templates.column_reference(&Some(self.time_series_source.clone()), "date_from")?
+            };
+
+            let leading_end = if let Some(leading_interval) = &self.leading_interval {
+                format!("{end_date} + interval '{leading_interval}'")
+            } else {
+                end_date
+            };
+
+            let sign = if self.offset == "end" { "<=" } else { "<" };
+
+            conditions.push(format!("{date_column_alias} {sign} {leading_end}"));
+        }
+        let result = if conditions.is_empty() {
+            templates.always_true()?
+        } else {
+            conditions.join(" AND ")
+        };
+        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,
@@ -92,6 +196,7 @@ impl DimensionJoinCondition {
 pub enum JoinCondition {
     DimensionJoinCondition(DimensionJoinCondition),
     BaseJoinCondition(Rc<dyn BaseJoinCondition>),
+    RollingWindowJoinCondition(RollingWindowJoinCondition),
 }
 
 impl JoinCondition {
@@ -109,6 +214,24 @@ impl JoinCondition {
         ))
     }
 
+    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>,
+    ) -> Self {
+        Self::RollingWindowJoinCondition(RollingWindowJoinCondition::new(
+            data_source,
+            time_series_source,
+            trailing_interval,
+            leading_interval,
+            offset,
+            time_dimension,
+        ))
+    }
+
     pub fn new_base_join(base: Rc<dyn BaseJoinCondition>) -> Self {
         Self::BaseJoinCondition(base)
     }
@@ -122,6 +245,9 @@ impl JoinCondition {
         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)
+            }
         }
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/mod.rs
index 5d98909183278..7dc4a188a3fbf 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/mod.rs
@@ -8,6 +8,7 @@ pub mod order;
 pub mod query_plan;
 pub mod schema;
 pub mod select;
+pub mod time_series;
 pub mod union;
 
 pub use builder::{JoinBuilder, SelectBuilder};
@@ -15,9 +16,10 @@ pub use cte::Cte;
 pub use expression::{Expr, MemberExpression};
 pub use filter::{Filter, FilterGroup, FilterItem};
 pub use from::{From, FromSource, SingleAliasedSource, SingleSource};
-pub use join::{Join, JoinCondition, JoinItem};
+pub use join::{Join, JoinCondition, JoinItem, RollingWindowJoinCondition};
 pub use order::OrderBy;
 pub use query_plan::QueryPlan;
 pub use schema::{Schema, SchemaColumn, SchemaCube};
 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 e8224fb74aebf..8fd8b9144f214 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/query_plan.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/query_plan.rs
@@ -1,4 +1,4 @@
-use super::{Schema, Select, Union};
+use super::{Schema, Select, TimeSeries, Union};
 use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
@@ -6,6 +6,7 @@ use std::rc::Rc;
 pub enum QueryPlan {
     Select(Rc<Select>),
     Union(Rc<Union>),
+    TimeSeries(Rc<TimeSeries>),
 }
 
 impl QueryPlan {
@@ -13,12 +14,14 @@ impl QueryPlan {
         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),
         }
     }
     pub fn to_sql(&self, templates: &PlanSqlTemplates) -> Result<String, CubeError> {
         match self {
             QueryPlan::Select(s) => s.to_sql(templates),
             QueryPlan::Union(u) => u.to_sql(templates),
+            QueryPlan::TimeSeries(series) => series.to_sql(templates),
         }
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/time_series.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/time_series.rs
new file mode 100644
index 0000000000000..f9e0ce8f777d5
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/time_series.rs
@@ -0,0 +1,29 @@
+use super::{Schema, SchemaColumn};
+use crate::planner::sql_templates::PlanSqlTemplates;
+use cubenativeutils::CubeError;
+
+pub struct TimeSeries {
+    pub time_dimension_name: String,
+    pub from_date: Option<String>,
+    pub to_date: Option<String>,
+    pub seria: Vec<Vec<String>>,
+}
+
+impl TimeSeries {
+    pub fn make_schema(&self, self_alias: Option<String>) -> Schema {
+        let column = SchemaColumn::new(
+            self_alias,
+            format!("date_from"),
+            self.time_dimension_name.clone(),
+        );
+        Schema::new(vec![column], vec![])
+    }
+
+    pub fn to_sql(&self, templates: &PlanSqlTemplates) -> Result<String, CubeError> {
+        templates.time_series_select(
+            self.from_date.clone(),
+            self.to_date.clone(),
+            self.seria.clone(),
+        )
+    }
+}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
index 936f107a1ab1f..5fa5ce929c703 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_measure.rs
@@ -1,7 +1,9 @@
 use super::query_tools::QueryTools;
 use super::sql_evaluator::{EvaluationNode, MemberSymbol, MemberSymbolType};
 use super::{evaluate_with_context, BaseMember, VisitorContext};
-use crate::cube_bridge::measure_definition::{MeasureDefinition, TimeShiftReference};
+use crate::cube_bridge::measure_definition::{
+    MeasureDefinition, RollingWindow, TimeShiftReference,
+};
 use crate::plan::Schema;
 use cubenativeutils::CubeError;
 use lazy_static::lazy_static;
@@ -195,6 +197,22 @@ impl BaseMeasure {
         self.definition.static_data().multi_stage.unwrap_or(false)
     }
 
+    pub fn rolling_window(&self) -> &Option<RollingWindow> {
+        &self.definition.static_data().rolling_window
+    }
+
+    pub fn is_rolling_window(&self) -> bool {
+        self.rolling_window().is_some()
+    }
+
+    pub fn is_running_total(&self) -> bool {
+        self.measure_type() == "runningTotal"
+    }
+
+    pub fn is_cumulative(&self) -> bool {
+        self.is_rolling_window() || self.is_running_total()
+    }
+
     //FIXME dublicate with symbol
     pub fn measure_type(&self) -> &String {
         &self.definition.static_data().measure_type
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
index 38fa14ff5f7e7..f6e297971e249 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_time_dimension.rs
@@ -11,6 +11,7 @@ pub struct BaseTimeDimension {
     query_tools: Rc<QueryTools>,
     granularity: Option<String>,
     date_range: Option<Vec<String>>,
+    alias_suffix: String,
 }
 
 impl BaseMember for BaseTimeDimension {
@@ -55,12 +56,7 @@ impl BaseMember for BaseTimeDimension {
     }
 
     fn alias_suffix(&self) -> Option<String> {
-        let granularity = if let Some(granularity) = &self.granularity {
-            granularity
-        } else {
-            "day"
-        };
-        Some(granularity.to_string())
+        Some(self.alias_suffix.clone())
     }
 }
 
@@ -71,14 +67,30 @@ impl BaseTimeDimension {
         granularity: Option<String>,
         date_range: Option<Vec<String>>,
     ) -> Result<Rc<Self>, CubeError> {
+        let alias_suffix = if let Some(granularity) = &granularity {
+            granularity.clone()
+        } else {
+            "day".to_string()
+        };
         Ok(Rc::new(Self {
             dimension: BaseDimension::try_new_required(member_evaluator, query_tools.clone())?,
             query_tools,
             granularity,
             date_range,
+            alias_suffix,
         }))
     }
 
+    pub fn change_granularity(&self, new_granularity: Option<String>) -> Rc<Self> {
+        Rc::new(Self {
+            dimension: self.dimension.clone(),
+            query_tools: self.query_tools.clone(),
+            granularity: new_granularity,
+            date_range: self.date_range.clone(),
+            alias_suffix: self.alias_suffix.clone(),
+        })
+    }
+
     pub fn get_granularity(&self) -> Option<String> {
         self.granularity.clone()
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
index 02247f982135e..249092a5774f2 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
@@ -8,7 +8,6 @@ use cubenativeutils::CubeError;
 use lazy_static::lazy_static;
 use regex::Regex;
 use std::rc::Rc;
-use std::str::FromStr;
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum FilterType {
@@ -26,6 +25,14 @@ pub struct BaseFilter {
     templates: FilterTemplates,
 }
 
+impl PartialEq for BaseFilter {
+    fn eq(&self, other: &Self) -> bool {
+        self.filter_type == other.filter_type
+            && self.filter_operator == other.filter_operator
+            && self.values == other.values
+    }
+}
+
 lazy_static! {
     static ref DATE_TIME_LOCAL_MS_RE: Regex =
         Regex::new(r"^\d\d\d\d-\d\d-\d\dT\d\d:\d\d:\d\d\.\d\d\d$").unwrap();
@@ -39,7 +46,7 @@ impl BaseFilter {
         query_tools: Rc<QueryTools>,
         member_evaluator: Rc<EvaluationNode>,
         filter_type: FilterType,
-        filter_operator: String,
+        filter_operator: FilterOperator,
         values: Option<Vec<Option<String>>>,
     ) -> Result<Rc<Self>, CubeError> {
         let templates = FilterTemplates::new(query_tools.templates_render());
@@ -52,12 +59,35 @@ impl BaseFilter {
             query_tools,
             member_evaluator,
             filter_type,
-            filter_operator: FilterOperator::from_str(&filter_operator)?,
+            filter_operator,
             values,
             templates,
         }))
     }
 
+    pub fn change_operator(
+        &self,
+        filter_operator: FilterOperator,
+        values: Vec<Option<String>>,
+    ) -> Rc<Self> {
+        Rc::new(Self {
+            query_tools: self.query_tools.clone(),
+            member_evaluator: self.member_evaluator.clone(),
+            filter_type: self.filter_type.clone(),
+            filter_operator,
+            values,
+            templates: self.templates.clone(),
+        })
+    }
+
+    pub fn values(&self) -> &Vec<Option<String>> {
+        &self.values
+    }
+
+    pub fn filter_operator(&self) -> &FilterOperator {
+        &self.filter_operator
+    }
+
     pub fn member_name(&self) -> String {
         self.member_evaluator.full_name()
     }
@@ -77,6 +107,7 @@ impl BaseFilter {
             FilterOperator::Equal => self.equals_where(&member_sql)?,
             FilterOperator::NotEqual => self.not_equals_where(&member_sql)?,
             FilterOperator::InDateRange => self.in_date_range(&member_sql)?,
+            FilterOperator::InDateRangeExtended => self.in_date_range_extended(&member_sql)?,
             FilterOperator::In => self.in_where(&member_sql)?,
             FilterOperator::NotIn => self.not_in_where(&member_sql)?,
             FilterOperator::Set => self.set_where(&member_sql)?,
@@ -127,6 +158,45 @@ impl BaseFilter {
             .time_range_filter(member_sql.to_string(), from, to)
     }
 
+    fn extend_date_range_bound(
+        &self,
+        date: String,
+        interval: &Option<String>,
+        is_sub: bool,
+    ) -> Result<String, CubeError> {
+        if let Some(interval) = interval {
+            if interval != "unbounded" {
+                if is_sub {
+                    self.templates.sub_interval(date, interval.clone())
+                } else {
+                    self.templates.add_interval(date, interval.clone())
+                }
+            } else {
+                Ok(date.to_string())
+            }
+        } else {
+            Ok(date.to_string())
+        }
+    }
+    fn in_date_range_extended(&self, member_sql: &str) -> Result<String, CubeError> {
+        let (from, to) = self.allocate_date_params()?;
+
+        let from = if self.values.len() >= 3 {
+            self.extend_date_range_bound(from, &self.values[2], true)?
+        } else {
+            from
+        };
+
+        let to = if self.values.len() >= 4 {
+            self.extend_date_range_bound(to, &self.values[3], false)?
+        } else {
+            to
+        };
+
+        self.templates
+            .time_range_filter(member_sql.to_string(), from, to)
+    }
+
     fn in_where(&self, member_sql: &str) -> Result<String, CubeError> {
         let need_null_check = self.is_need_null_chek(false);
         self.templates.in_where(
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/compiler.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/compiler.rs
index d103229021eeb..17e8a64a6be20 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/compiler.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/compiler.rs
@@ -1,4 +1,5 @@
 use super::base_filter::{BaseFilter, FilterType};
+use super::FilterOperator;
 use crate::cube_bridge::base_query_options::FilterItem as NativeFilterItem;
 use crate::plan::filter::{FilterGroup, FilterGroupOperator, FilterItem};
 use crate::planner::query_tools::QueryTools;
@@ -6,6 +7,7 @@ use crate::planner::sql_evaluator::Compiler;
 use crate::planner::BaseTimeDimension;
 use cubenativeutils::CubeError;
 use std::rc::Rc;
+use std::str::FromStr;
 
 pub struct FilterCompiler<'a> {
     evaluator_compiler: &'a mut Compiler,
@@ -43,7 +45,7 @@ impl<'a> FilterCompiler<'a> {
                 self.query_tools.clone(),
                 item.member_evaluator(),
                 FilterType::Dimension,
-                "InDateRange".to_string(),
+                FilterOperator::InDateRange,
                 Some(date_range.into_iter().map(|v| Some(v)).collect()),
             )?;
             self.time_dimension_filters.push(FilterItem::Item(filter));
@@ -92,7 +94,7 @@ impl<'a> FilterCompiler<'a> {
                     self.query_tools.clone(),
                     evaluator,
                     item_type.clone(),
-                    operator.clone(),
+                    FilterOperator::from_str(&operator)?,
                     item.values.clone(),
                 )?))
             } else {
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/filter_operator.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/filter_operator.rs
index 5b3eeae125f06..d66caf4368928 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/filter_operator.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/filter_operator.rs
@@ -1,9 +1,12 @@
 use cubenativeutils::CubeError;
 use std::str::FromStr;
+
+#[derive(Clone, PartialEq, Debug)]
 pub enum FilterOperator {
     Equal,
     NotEqual,
     InDateRange,
+    InDateRangeExtended,
     In,
     NotIn,
     Set,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/mod.rs
index 02277136c6979..01f95fd0d8ba6 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/mod.rs
@@ -3,3 +3,4 @@ pub mod compiler;
 pub mod filter_operator;
 
 pub use base_filter::BaseFilter;
+pub use filter_operator::FilterOperator;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/granularity_helper.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/granularity_helper.rs
new file mode 100644
index 0000000000000..b1e4bf1863b80
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/granularity_helper.rs
@@ -0,0 +1,149 @@
+use cubenativeutils::CubeError;
+use itertools::Itertools;
+use lazy_static::lazy_static;
+use std::collections::HashMap;
+
+pub struct GranularityHelper {}
+
+impl GranularityHelper {
+    pub fn min_granularity(
+        granularity_a: &Option<String>,
+        granularity_b: &Option<String>,
+    ) -> Result<Option<String>, CubeError> {
+        if let Some((granularity_a, granularity_b)) =
+            granularity_a.as_ref().zip(granularity_b.as_ref())
+        {
+            let a_parents = Self::granularity_parents(granularity_a)?;
+            let b_parents = Self::granularity_parents(granularity_b)?;
+            let diff_position = a_parents
+                .iter()
+                .zip(b_parents.iter())
+                .find_position(|(a, b)| a != b);
+            if let Some((diff_position, _)) = diff_position {
+                if diff_position == 0 {
+                    Err(CubeError::user(format!(
+                        "Can't find common parent for '{granularity_a}' and '{granularity_b}'"
+                    )))
+                } else {
+                    Ok(Some(a_parents[diff_position - 1].clone()))
+                }
+            } else {
+                if a_parents.len() >= b_parents.len() {
+                    Ok(Some(b_parents.last().unwrap().clone()))
+                } else {
+                    Ok(Some(a_parents.last().unwrap().clone()))
+                }
+            }
+        } else if granularity_a.is_some() {
+            Ok(granularity_a.clone())
+        } else {
+            Ok(granularity_b.clone())
+        }
+    }
+
+    pub fn granularity_from_interval(interval: &Option<String>) -> Option<String> {
+        if let Some(interval) = interval {
+            if interval.find("day").is_some() {
+                Some("day".to_string())
+            } else if interval.find("month").is_some() {
+                Some("month".to_string())
+            } else if interval.find("year").is_some() {
+                Some("year".to_string())
+            } else if interval.find("week").is_some() {
+                Some("week".to_string())
+            } else if interval.find("hour").is_some() {
+                Some("hour".to_string())
+            } else {
+                None
+            }
+        } else {
+            None
+        }
+    }
+
+    pub fn granularity_parents(granularity: &str) -> Result<&Vec<String>, CubeError> {
+        if let Some(parents) = Self::standard_granularity_parents().get(granularity) {
+            Ok(parents)
+        } else {
+            Err(CubeError::user(format!(
+                "Granularity {} not found",
+                granularity
+            )))
+        }
+    }
+
+    pub fn standard_granularity_parents() -> &'static HashMap<String, Vec<String>> {
+        lazy_static! {
+            static ref STANDARD_GRANULARITIES_PARENTS: HashMap<String, Vec<String>> = {
+                let mut map = HashMap::new();
+                map.insert(
+                    "year".to_string(),
+                    vec![
+                        "second".to_string(),
+                        "minute".to_string(),
+                        "hour".to_string(),
+                        "day".to_string(),
+                        "month".to_string(),
+                        "quarter".to_string(),
+                        "year".to_string(),
+                    ],
+                );
+                map.insert(
+                    "quarter".to_string(),
+                    vec![
+                        "second".to_string(),
+                        "minute".to_string(),
+                        "hour".to_string(),
+                        "day".to_string(),
+                        "month".to_string(),
+                        "quarter".to_string(),
+                    ],
+                );
+                map.insert(
+                    "month".to_string(),
+                    vec![
+                        "second".to_string(),
+                        "minute".to_string(),
+                        "hour".to_string(),
+                        "day".to_string(),
+                        "month".to_string(),
+                    ],
+                );
+                map.insert(
+                    "week".to_string(),
+                    vec![
+                        "second".to_string(),
+                        "minute".to_string(),
+                        "hour".to_string(),
+                        "day".to_string(),
+                        "week".to_string(),
+                    ],
+                );
+                map.insert(
+                    "day".to_string(),
+                    vec![
+                        "second".to_string(),
+                        "minute".to_string(),
+                        "hour".to_string(),
+                        "day".to_string(),
+                    ],
+                );
+                map.insert(
+                    "hour".to_string(),
+                    vec![
+                        "second".to_string(),
+                        "minute".to_string(),
+                        "hour".to_string(),
+                    ],
+                );
+                map.insert(
+                    "minute".to_string(),
+                    vec!["second".to_string(), "minute".to_string()],
+                );
+                map.insert("second".to_string(), vec!["second".to_string()]);
+                map
+            };
+        }
+        &STANDARD_GRANULARITIES_PARENTS
+    }
+}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/mod.rs
index a6def37da64c1..cc457b6318ecc 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/mod.rs
@@ -6,6 +6,7 @@ pub mod base_member;
 pub mod base_query;
 pub mod base_time_dimension;
 pub mod filter;
+pub mod granularity_helper;
 pub mod params_allocator;
 pub mod planners;
 pub mod query_properties;
@@ -22,6 +23,7 @@ pub use base_measure::BaseMeasure;
 pub use base_member::{BaseMember, BaseMemberHelper};
 pub use base_query::BaseQuery;
 pub use base_time_dimension::BaseTimeDimension;
+pub use granularity_helper::GranularityHelper;
 pub use params_allocator::ParamsAllocator;
 pub use query_properties::{FullKeyAggregateMeasures, OrderByItem, QueryProperties};
 pub use visitor_context::{evaluate_with_context, VisitorContext};
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/applied_state.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/applied_state.rs
index 40d03969a2d04..7a4061c43f64d 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/applied_state.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/applied_state.rs
@@ -1,34 +1,48 @@
-use crate::planner::base_measure::MeasureTimeShift;
-use crate::planner::BaseDimension;
+use crate::plan::{FilterGroup, FilterItem};
+use crate::planner::filter::FilterOperator;
+use crate::planner::planners::multi_stage::MultiStageTimeShift;
+use crate::planner::{BaseDimension, BaseTimeDimension};
 use itertools::Itertools;
 use std::cmp::PartialEq;
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::fmt::Debug;
 use std::rc::Rc;
 
 #[derive(Clone)]
 pub struct MultiStageAppliedState {
+    time_dimensions: Vec<Rc<BaseTimeDimension>>,
     dimensions: Vec<Rc<BaseDimension>>,
-    allowed_filter_members: HashSet<String>,
+    time_dimensions_filters: Vec<FilterItem>,
+    dimensions_filters: Vec<FilterItem>,
+    measures_filters: Vec<FilterItem>,
     time_shifts: HashMap<String, String>,
 }
 
 impl MultiStageAppliedState {
     pub fn new(
+        time_dimensions: Vec<Rc<BaseTimeDimension>>,
         dimensions: Vec<Rc<BaseDimension>>,
-        allowed_filter_members: HashSet<String>,
+        time_dimensions_filters: Vec<FilterItem>,
+        dimensions_filters: Vec<FilterItem>,
+        measures_filters: Vec<FilterItem>,
     ) -> Rc<Self> {
         Rc::new(Self {
+            time_dimensions,
             dimensions,
-            allowed_filter_members,
+            time_dimensions_filters,
+            dimensions_filters,
+            measures_filters,
             time_shifts: HashMap::new(),
         })
     }
 
     pub fn clone_state(&self) -> Self {
         Self {
+            time_dimensions: self.time_dimensions.clone(),
             dimensions: self.dimensions.clone(),
-            allowed_filter_members: self.allowed_filter_members.clone(),
+            time_dimensions_filters: self.time_dimensions_filters.clone(),
+            dimensions_filters: self.dimensions_filters.clone(),
+            measures_filters: self.measures_filters.clone(),
             time_shifts: self.time_shifts.clone(),
         }
     }
@@ -43,7 +57,7 @@ impl MultiStageAppliedState {
             .collect_vec();
     }
 
-    pub fn add_time_shifts(&mut self, time_shifts: Vec<MeasureTimeShift>) {
+    pub fn add_time_shifts(&mut self, time_shifts: Vec<MultiStageTimeShift>) {
         for ts in time_shifts.into_iter() {
             self.time_shifts
                 .insert(ts.time_dimension.clone(), ts.interval.clone());
@@ -54,35 +68,165 @@ impl MultiStageAppliedState {
         &self.time_shifts
     }
 
-    pub fn is_filter_allowed(&self, name: &str) -> bool {
-        self.allowed_filter_members.contains(name)
+    pub fn time_dimensions_filters(&self) -> &Vec<FilterItem> {
+        &self.time_dimensions_filters
     }
 
-    pub fn allowed_filter_members(&self) -> &HashSet<String> {
-        &self.allowed_filter_members
+    pub fn dimensions_filters(&self) -> &Vec<FilterItem> {
+        &self.dimensions_filters
     }
 
-    pub fn disallow_filter(&mut self, name: &str) {
-        self.allowed_filter_members.take(name);
+    pub fn measures_filters(&self) -> &Vec<FilterItem> {
+        &self.measures_filters
     }
 
     pub fn dimensions(&self) -> &Vec<Rc<BaseDimension>> {
         &self.dimensions
     }
+
+    pub fn time_dimensions(&self) -> &Vec<Rc<BaseTimeDimension>> {
+        &self.time_dimensions
+    }
+
+    pub fn change_time_dimension_granularity(
+        &mut self,
+        dimension_name: &str,
+        new_granularity: Option<String>,
+    ) {
+        if let Some(time_dimension) = self
+            .time_dimensions
+            .iter_mut()
+            .find(|dim| dim.member_evaluator().full_name() == dimension_name)
+        {
+            *time_dimension = time_dimension.change_granularity(new_granularity);
+        }
+    }
+
+    pub fn remove_filter_for_member(&mut self, member_name: &String) {
+        self.time_dimensions_filters =
+            self.extract_filters_exclude_member(member_name, &self.time_dimensions_filters);
+        self.dimensions_filters =
+            self.extract_filters_exclude_member(member_name, &self.dimensions_filters);
+        self.measures_filters =
+            self.extract_filters_exclude_member(member_name, &self.measures_filters);
+    }
+
+    fn extract_filters_exclude_member(
+        &self,
+        member_name: &String,
+        filters: &Vec<FilterItem>,
+    ) -> Vec<FilterItem> {
+        let mut result = Vec::new();
+        for item in filters.iter() {
+            match item {
+                FilterItem::Group(group) => {
+                    let new_group = FilterItem::Group(Rc::new(FilterGroup::new(
+                        group.operator.clone(),
+                        self.extract_filters_exclude_member(member_name, &group.items),
+                    )));
+                    result.push(new_group);
+                }
+                FilterItem::Item(itm) => {
+                    if &itm.member_name() != member_name {
+                        result.push(FilterItem::Item(itm.clone()));
+                    }
+                }
+            }
+        }
+        result
+    }
+
+    pub fn has_filters_for_member(&self, member_name: &String) -> bool {
+        self.has_filters_for_member_impl(member_name, &self.time_dimensions_filters)
+            || self.has_filters_for_member_impl(member_name, &self.dimensions_filters)
+            || self.has_filters_for_member_impl(member_name, &self.measures_filters)
+    }
+
+    fn has_filters_for_member_impl(&self, member_name: &String, filters: &Vec<FilterItem>) -> bool {
+        for item in filters.iter() {
+            match item {
+                FilterItem::Group(group) => {
+                    if self.has_filters_for_member_impl(member_name, &group.items) {
+                        return true;
+                    }
+                }
+                FilterItem::Item(itm) => {
+                    if &itm.member_name() == member_name {
+                        return true;
+                    }
+                }
+            }
+        }
+        false
+    }
+
+    pub fn expand_date_range_filter(
+        &mut self,
+        member_name: &String,
+        left_interval: Option<String>,
+        right_interval: Option<String>,
+    ) {
+        self.time_dimensions_filters = self.expand_date_range_filter_impl(
+            member_name,
+            &self.time_dimensions_filters,
+            &left_interval,
+            &right_interval,
+        );
+    }
+
+    fn expand_date_range_filter_impl(
+        &self,
+        member_name: &String,
+        filters: &Vec<FilterItem>,
+        left_interval: &Option<String>,
+        right_interval: &Option<String>,
+    ) -> Vec<FilterItem> {
+        let mut result = Vec::new();
+        for item in filters.iter() {
+            match item {
+                FilterItem::Group(group) => {
+                    let new_group = FilterItem::Group(Rc::new(FilterGroup::new(
+                        group.operator.clone(),
+                        self.expand_date_range_filter_impl(
+                            member_name,
+                            filters,
+                            left_interval,
+                            right_interval,
+                        ),
+                    )));
+                    result.push(new_group);
+                }
+                FilterItem::Item(itm) => {
+                    let itm = if &itm.member_name() == member_name
+                        && matches!(itm.filter_operator(), FilterOperator::InDateRange)
+                    {
+                        let mut values = itm.values().clone();
+                        values.push(left_interval.clone());
+                        values.push(right_interval.clone());
+                        itm.change_operator(FilterOperator::InDateRangeExtended, values)
+                    } else {
+                        itm.clone()
+                    };
+                    result.push(FilterItem::Item(itm));
+                }
+            }
+        }
+        result
+    }
 }
 
 impl PartialEq for MultiStageAppliedState {
     fn eq(&self, other: &Self) -> bool {
-        let dims_eq = if !self.dimensions.len() == other.dimensions.len() {
-            false
-        } else {
-            self.dimensions
+        let dims_eq = self.dimensions.len() == other.dimensions.len()
+            && self
+                .dimensions
                 .iter()
                 .zip(other.dimensions.iter())
-                .all(|(a, b)| a.member_evaluator().full_name() == b.member_evaluator().full_name())
-        };
+                .all(|(a, b)| a.member_evaluator().full_name() == b.member_evaluator().full_name());
         dims_eq
-            && self.allowed_filter_members == other.allowed_filter_members
+            && self.time_dimensions_filters == other.time_dimensions_filters
+            && self.dimensions_filters == other.dimensions_filters
+            && self.measures_filters == other.measures_filters
             && self.time_shifts == other.time_shifts
     }
 }
@@ -98,7 +242,6 @@ impl Debug for MultiStageAppliedState {
                     .map(|d| d.member_evaluator().full_name())
                     .join(", "),
             )
-            .field("allowed_filter_members", &self.allowed_filter_members)
             .field("time_shifts", &self.time_shifts)
             .finish()
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member.rs
new file mode 100644
index 0000000000000..dbfa67cc2f7ba
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/member.rs
@@ -0,0 +1,174 @@
+use crate::cube_bridge::measure_definition::TimeShiftReference;
+use crate::planner::sql_evaluator::EvaluationNode;
+use crate::planner::BaseMember;
+use crate::planner::BaseTimeDimension;
+use cubenativeutils::CubeError;
+use lazy_static::lazy_static;
+use regex::Regex;
+use std::rc::Rc;
+
+#[derive(Clone, Debug)]
+pub struct MultiStageTimeShift {
+    pub interval: String,
+    pub time_dimension: String,
+}
+
+lazy_static! {
+    static ref INTERVAL_MATCH_RE: Regex =
+        Regex::new(r"^(-?\d+) (second|minute|hour|day|week|month|quarter|year)s?$").unwrap();
+}
+impl MultiStageTimeShift {
+    pub fn try_from_reference(reference: &TimeShiftReference) -> Result<Self, CubeError> {
+        let parsed_interval =
+            if let Some(captures) = INTERVAL_MATCH_RE.captures(&reference.interval) {
+                let duration = if let Some(duration) = captures.get(1) {
+                    duration.as_str().parse::<i64>().ok()
+                } else {
+                    None
+                };
+                let granularity = if let Some(granularity) = captures.get(2) {
+                    Some(granularity.as_str().to_owned())
+                } else {
+                    None
+                };
+                if let Some((duration, granularity)) = duration.zip(granularity) {
+                    Some((duration, granularity))
+                } else {
+                    None
+                }
+            } else {
+                None
+            };
+        if let Some((duration, granularity)) = parsed_interval {
+            let duration = if reference.shift_type.as_ref().unwrap_or(&format!("prior")) == "next" {
+                duration * (-1)
+            } else {
+                duration
+            };
+
+            Ok(Self {
+                interval: format!("{duration} {granularity}"),
+                time_dimension: reference.time_dimension.clone(),
+            })
+        } else {
+            Err(CubeError::user(format!(
+                "Invalid interval: {}",
+                reference.interval
+            )))
+        }
+    }
+}
+
+#[derive(Clone)]
+pub enum MultiStageLeafMemberType {
+    Measure,
+    TimeSeries(Rc<BaseTimeDimension>),
+}
+
+#[derive(Clone)]
+pub struct RollingWindowDescription {
+    pub time_dimension: Rc<dyn BaseMember>,
+    pub trailing: Option<String>,
+    pub leading: Option<String>,
+    pub offset: String,
+}
+
+#[derive(Clone)]
+pub struct RunningTotalDescription {
+    pub time_dimension: Rc<dyn BaseMember>,
+}
+
+#[derive(Clone)]
+pub enum MultiStageInodeMemberType {
+    Rank,
+    Aggregate,
+    Calculate,
+    RollingWindow(RollingWindowDescription),
+    RunningTotal(RunningTotalDescription),
+}
+
+#[derive(Clone)]
+pub struct MultiStageInodeMember {
+    inode_type: MultiStageInodeMemberType,
+    reduce_by: Vec<String>,
+    add_group_by: Vec<String>,
+    group_by: Option<Vec<String>>,
+    time_shifts: Vec<MultiStageTimeShift>,
+    is_ungrupped: bool,
+}
+
+impl MultiStageInodeMember {
+    pub fn new(
+        inode_type: MultiStageInodeMemberType,
+        reduce_by: Vec<String>,
+        add_group_by: Vec<String>,
+        group_by: Option<Vec<String>>,
+        time_shifts: Vec<MultiStageTimeShift>,
+        is_ungrupped: bool,
+    ) -> Self {
+        Self {
+            inode_type,
+            reduce_by,
+            add_group_by,
+            group_by,
+            time_shifts,
+            is_ungrupped,
+        }
+    }
+
+    pub fn inode_type(&self) -> &MultiStageInodeMemberType {
+        &self.inode_type
+    }
+
+    pub fn reduce_by(&self) -> &Vec<String> {
+        &self.reduce_by
+    }
+
+    pub fn add_group_by(&self) -> &Vec<String> {
+        &self.add_group_by
+    }
+
+    pub fn group_by(&self) -> &Option<Vec<String>> {
+        &self.group_by
+    }
+
+    pub fn time_shifts(&self) -> &Vec<MultiStageTimeShift> {
+        &self.time_shifts
+    }
+
+    pub fn is_ungrupped(&self) -> bool {
+        self.is_ungrupped
+    }
+}
+
+#[derive(Clone)]
+pub enum MultiStageMemberType {
+    Inode(MultiStageInodeMember),
+    Leaf(MultiStageLeafMemberType),
+}
+
+pub struct MultiStageMember {
+    member_type: MultiStageMemberType,
+    evaluation_node: Rc<EvaluationNode>,
+}
+
+impl MultiStageMember {
+    pub fn new(member_type: MultiStageMemberType, evaluation_node: Rc<EvaluationNode>) -> Rc<Self> {
+        Rc::new(Self {
+            member_type,
+            evaluation_node,
+        })
+    }
+
+    pub fn member_type(&self) -> &MultiStageMemberType {
+        &self.member_type
+    }
+
+    pub fn evaluation_node(&self) -> &Rc<EvaluationNode> {
+        &self.evaluation_node
+    }
+
+    pub fn full_name(&self) -> String {
+        self.evaluation_node.full_name()
+    }
+}
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 1ba7e8943dd89..06533fcbed1f2 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
@@ -1,7 +1,10 @@
-use super::MultiStageQueryDescription;
+use super::{
+    MultiStageInodeMember, MultiStageInodeMemberType, MultiStageMemberType,
+    MultiStageQueryDescription, RollingWindowDescription,
+};
 use crate::plan::{
     Cte, Expr, FilterGroup, FilterItem, From, JoinBuilder, JoinCondition, MemberExpression,
-    OrderBy, QueryPlan, Schema, SelectBuilder,
+    OrderBy, QueryPlan, Schema, SelectBuilder, TimeSeries,
 };
 use crate::planner::planners::{
     FullKeyAggregateQueryPlanner, MultipliedMeasuresQueryPlanner, OrderPlanner, SimpleQueryPlanner,
@@ -9,14 +12,16 @@ use crate::planner::planners::{
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::sql_nodes::SqlNodesFactory;
 use crate::planner::QueryProperties;
-use crate::planner::{BaseDimension, BaseMeasure, BaseMember, BaseMemberHelper, VisitorContext};
+use crate::planner::{
+    BaseDimension, BaseMeasure, BaseMember, BaseMemberHelper, BaseTimeDimension, VisitorContext,
+};
 use cubenativeutils::CubeError;
 use itertools::Itertools;
 use std::collections::{HashMap, HashSet};
 use std::rc::Rc;
 pub struct MultiStageMemberQueryPlanner {
     query_tools: Rc<QueryTools>,
-    query_properties: Rc<QueryProperties>,
+    _query_properties: Rc<QueryProperties>,
     description: Rc<MultiStageQueryDescription>,
 }
 
@@ -28,7 +33,7 @@ impl MultiStageMemberQueryPlanner {
     ) -> Self {
         Self {
             query_tools,
-            query_properties,
+            _query_properties: query_properties,
             description,
         }
     }
@@ -37,28 +42,135 @@ impl MultiStageMemberQueryPlanner {
         &self,
         cte_schemas: &HashMap<String, Rc<Schema>>,
     ) -> Result<Rc<Cte>, CubeError> {
-        if self.description.is_leaf() {
-            self.plan_for_leaf_cte_query()
-        } else {
-            self.plan_for_cte_query(cte_schemas)
+        match self.description.member().member_type() {
+            MultiStageMemberType::Inode(member) => match member.inode_type() {
+                MultiStageInodeMemberType::RollingWindow(rolling_window_desc) => {
+                    self.plan_rolling_window_query(rolling_window_desc, member, cte_schemas)
+                }
+                _ => self.plan_for_cte_query(member, cte_schemas),
+            },
+            MultiStageMemberType::Leaf(node) => match node {
+                super::MultiStageLeafMemberType::Measure => self.plan_for_leaf_cte_query(),
+                super::MultiStageLeafMemberType::TimeSeries(time_dimension) => {
+                    self.plan_time_series_query(time_dimension.clone())
+                }
+            },
         }
     }
 
-    fn plan_for_cte_query(
+    fn plan_time_series_query(
+        &self,
+        time_dimension: Rc<BaseTimeDimension>,
+    ) -> Result<Rc<Cte>, CubeError> {
+        let granularity = time_dimension.get_granularity().unwrap(); //FIXME remove this unwrap
+        let date_range = time_dimension.get_date_range().unwrap(); //FIXME remove this unwrap
+        let from_date = date_range[0].clone();
+        let to_date = date_range[1].clone();
+        let seria = self
+            .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),
+            seria,
+        };
+        let query_plan = Rc::new(QueryPlan::TimeSeries(Rc::new(time_seira)));
+        Ok(Rc::new(Cte::new(query_plan, format!("time_series"))))
+    }
+
+    fn plan_rolling_window_query(
         &self,
+        rolling_window_desc: &RollingWindowDescription,
+        _multi_stage_member: &MultiStageInodeMember,
         cte_schemas: &HashMap<String, Rc<Schema>>,
     ) -> Result<Rc<Cte>, CubeError> {
-        let query_member = self.query_member_as_measure()?.unwrap();
+        let inputs = self.input_cte_aliases();
+        let dimensions = self.all_dimensions();
+
+        let root_alias = format!("time_series");
+        let cte_schema = cte_schemas.get(&inputs[0]).unwrap().clone();
+
+        let mut join_builder = JoinBuilder::new_from_table_reference(
+            inputs[0].clone(),
+            cte_schema,
+            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 from = From::new_from_join(join_builder.build());
+
+        let group_by = dimensions
+            .iter()
+            .map(|dim| Expr::Member(MemberExpression::new(dim.clone(), None)))
+            .collect_vec();
+
+        let context_factory = SqlNodesFactory::new();
+        let node_context = context_factory.rolling_window_node_processor();
+
+        let mut select_builder = SelectBuilder::new(from, VisitorContext::new(None, node_context));
+        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())),
+                    ),
+                );
+            } else {
+                select_builder.add_projection_member(&dim, None, None);
+            }
+        }
+
+        let query_member = self.query_member_as_base_member()?;
+        select_builder.add_projection_member(&query_member, None, None);
+        select_builder.set_group_by(group_by);
+        select_builder.set_order_by(self.query_order()?);
+        let select = select_builder.build();
+
+        Ok(Rc::new(Cte::new_from_select(
+            Rc::new(select),
+            self.description.alias().clone(),
+        )))
+    }
 
+    fn plan_for_cte_query(
+        &self,
+        multi_stage_member: &MultiStageInodeMember,
+        cte_schemas: &HashMap<String, Rc<Schema>>,
+    ) -> Result<Rc<Cte>, CubeError> {
         let dimensions = self.all_dimensions();
         let dimensions_aliases = BaseMemberHelper::to_alias_vec(&dimensions);
 
         let from = From::new_from_subquery(
-            Rc::new(self.make_input_join(cte_schemas)?),
+            Rc::new(self.make_input_join(multi_stage_member, cte_schemas)?),
             format!("{}_join", self.description.alias()),
         );
 
-        let group_by = if query_member.is_multi_stage_ungroupped() {
+        let group_by = if multi_stage_member.is_ungrupped() {
             vec![]
         } else {
             dimensions
@@ -67,30 +179,41 @@ impl MultiStageMemberQueryPlanner {
                 .collect_vec()
         };
 
-        let order_by = if query_member.is_multi_stage_ungroupped() {
+        let order_by = if multi_stage_member.is_ungrupped() {
             vec![]
         } else {
             self.query_order()?
         };
 
-        let partition_by =
-            self.member_partition_by(query_member.reduce_by(), query_member.group_by());
+        //FIXME here is direct use of alias, should be replaced with schema use
+        let partition_by = self.member_partition_by(
+            multi_stage_member.reduce_by(),
+            multi_stage_member.group_by(),
+        );
 
         let context_factory = SqlNodesFactory::new();
 
-        let node_context = if query_member.measure_type() == "rank" {
-            context_factory.multi_stage_rank_node_processor(partition_by)
-        } else if !query_member.is_calculated() && partition_by != dimensions_aliases {
-            context_factory.multi_stage_window_node_processor(partition_by)
-        } else {
-            context_factory.default_node_processor()
+        let node_context = match multi_stage_member.inode_type() {
+            MultiStageInodeMemberType::Rank => {
+                context_factory.multi_stage_rank_node_processor(partition_by)
+            }
+            MultiStageInodeMemberType::Aggregate => {
+                if partition_by != dimensions_aliases {
+                    context_factory.multi_stage_window_node_processor(partition_by)
+                } else {
+                    context_factory.default_node_processor()
+                }
+            }
+            _ => context_factory.default_node_processor(),
         };
 
         let mut select_builder = SelectBuilder::new(from, VisitorContext::new(None, node_context));
         for dim in dimensions.iter() {
             select_builder.add_projection_member(&dim, None, None);
         }
-        select_builder.add_projection_member(&query_member.as_base_member(), None, None);
+
+        let query_member = self.query_member_as_base_member()?;
+        select_builder.add_projection_member(&query_member, None, None);
         select_builder.set_group_by(group_by);
         select_builder.set_order_by(order_by);
         let select = select_builder.build();
@@ -103,6 +226,7 @@ impl MultiStageMemberQueryPlanner {
 
     fn make_input_join(
         &self,
+        _multi_stage_member: &MultiStageInodeMember,
         cte_schemas: &HashMap<String, Rc<Schema>>,
     ) -> Result<QueryPlan, CubeError> {
         let inputs = self.input_cte_aliases();
@@ -159,28 +283,18 @@ impl MultiStageMemberQueryPlanner {
             vec![]
         };
 
-        let allowed_filter_members = self.description.state().allowed_filter_members().clone();
-
         let cte_query_properties = QueryProperties::try_new_from_precompiled(
             self.query_tools.clone(),
             measures,
             self.description.state().dimensions().clone(),
-            self.query_properties.time_dimensions().clone(),
-            self.extract_filters(
-                &allowed_filter_members,
-                self.query_properties.time_dimensions_filters(),
-            ),
-            self.extract_filters(
-                &allowed_filter_members,
-                self.query_properties.dimensions_filters(),
-            ),
-            self.extract_filters(
-                &allowed_filter_members,
-                self.query_properties.measures_filters(),
-            ),
+            self.description.state().time_dimensions().clone(),
+            self.description.state().time_dimensions_filters().clone(),
+            self.description.state().dimensions_filters().clone(),
+            self.description.state().measures_filters().clone(),
             vec![],
             None,
             None,
+            true,
         )?;
 
         let node_factory = if self.description.state().time_shifts().is_empty() {
@@ -189,14 +303,14 @@ impl MultiStageMemberQueryPlanner {
             SqlNodesFactory::new_with_time_shifts(self.description.state().time_shifts().clone())
         };
 
-        if cte_query_properties
+        /* if cte_query_properties
             .full_key_aggregate_measures()?
             .has_multi_stage_measures()
         {
             return Err(CubeError::internal(format!(
                 "Leaf multi stage query cannot contain multi stage member"
             )));
-        }
+        } */
 
         let cte_select = if cte_query_properties.is_simple_query()? {
             let planner = SimpleQueryPlanner::new(
@@ -223,35 +337,10 @@ impl MultiStageMemberQueryPlanner {
         Ok(Rc::new(result))
     }
 
-    fn extract_filters(
-        &self,
-        allowed_filter_members: &HashSet<String>,
-        filters: &Vec<FilterItem>,
-    ) -> Vec<FilterItem> {
-        let mut result = Vec::new();
-        for item in filters.iter() {
-            match item {
-                FilterItem::Group(group) => {
-                    let new_group = FilterItem::Group(Rc::new(FilterGroup::new(
-                        group.operator.clone(),
-                        self.extract_filters(allowed_filter_members, &group.items),
-                    )));
-                    result.push(new_group);
-                }
-                FilterItem::Item(itm) => {
-                    if allowed_filter_members.contains(&itm.member_name()) {
-                        result.push(FilterItem::Item(itm.clone()));
-                    }
-                }
-            }
-        }
-        result
-    }
-
     fn all_dimensions(&self) -> Vec<Rc<dyn BaseMember>> {
         BaseMemberHelper::iter_as_base_member(self.description.state().dimensions())
             .chain(BaseMemberHelper::iter_as_base_member(
-                self.query_properties.time_dimensions(),
+                self.description.state().time_dimensions(),
             ))
             .collect_vec()
     }
@@ -268,7 +357,7 @@ impl MultiStageMemberQueryPlanner {
     fn all_input_dimensions(&self) -> Vec<Rc<dyn BaseMember>> {
         BaseMemberHelper::iter_as_base_member(&self.input_dimensions())
             .chain(BaseMemberHelper::iter_as_base_member(
-                self.query_properties.time_dimensions(),
+                self.description.state().time_dimensions(),
             ))
             .collect_vec()
     }
@@ -316,13 +405,31 @@ impl MultiStageMemberQueryPlanner {
         )
     }
 
+    fn query_member_as_base_member(&self) -> Result<Rc<dyn BaseMember>, CubeError> {
+        if let Some(measure) = BaseMeasure::try_new(
+            self.description.member_node().clone(),
+            self.query_tools.clone(),
+        )? {
+            Ok(measure)
+        } else if let Some(dimension) = BaseDimension::try_new(
+            self.description.member_node().clone(),
+            self.query_tools.clone(),
+        )? {
+            Ok(dimension)
+        } else {
+            Err(CubeError::internal(
+                "Expected measure or dimension as multi stage member".to_string(),
+            ))
+        }
+    }
+
     fn member_partition_by(
         &self,
-        reduce_by: &Option<Vec<String>>,
+        reduce_by: &Vec<String>,
         group_by: &Option<Vec<String>>,
     ) -> Vec<String> {
         let dimensions = self.all_dimensions();
-        let dimensions = if let Some(reduce_by) = reduce_by {
+        let dimensions = if !reduce_by.is_empty() {
             dimensions
                 .into_iter()
                 .filter(|d| {
@@ -357,7 +464,7 @@ impl MultiStageMemberQueryPlanner {
     fn subquery_order(&self) -> Result<Vec<OrderBy>, CubeError> {
         let order_items = QueryProperties::default_order(
             &self.input_dimensions(),
-            &self.query_properties.time_dimensions(),
+            &self.description.state().time_dimensions(),
             &self.raw_input_measures()?,
         );
         Ok(OrderPlanner::custom_order(
@@ -375,7 +482,7 @@ impl MultiStageMemberQueryPlanner {
 
         let order_items = QueryProperties::default_order(
             &self.description.state().dimensions(),
-            &self.query_properties.time_dimensions(),
+            &self.description.state().time_dimensions(),
             &measures,
         );
         let mut all_members = self.all_dimensions().clone();
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/mod.rs
index f09180ad85da5..4a70b00f7c009 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/mod.rs
@@ -1,7 +1,9 @@
 mod applied_state;
+mod member;
 mod member_query_planner;
 mod query_description;
 
 pub use applied_state::MultiStageAppliedState;
+pub use member::*;
 pub use member_query_planner::MultiStageMemberQueryPlanner;
 pub use query_description::MultiStageQueryDescription;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/query_description.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/query_description.rs
index fb3a46e9ea7e0..a25d148c28396 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/query_description.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/query_description.rs
@@ -1,10 +1,10 @@
-use super::MultiStageAppliedState;
+use super::{MultiStageAppliedState, MultiStageMember};
 use crate::planner::sql_evaluator::EvaluationNode;
 use std::fmt::Debug;
 use std::rc::Rc;
 
 pub struct MultiStageQueryDescription {
-    member_node: Rc<EvaluationNode>,
+    member: Rc<MultiStageMember>,
     state: Rc<MultiStageAppliedState>,
     input: Vec<Rc<MultiStageQueryDescription>>,
     alias: String,
@@ -15,7 +15,7 @@ impl Debug for MultiStageQueryDescription {
         f.debug_struct("MultiStageQueryDescription")
             .field(
                 "member_node",
-                &format!("node with path {}", self.member_node.full_name()),
+                &format!("node with path {}", self.member_node().full_name()),
             )
             .field("state", &self.state)
             .field("input", &self.input)
@@ -26,13 +26,13 @@ impl Debug for MultiStageQueryDescription {
 
 impl MultiStageQueryDescription {
     pub fn new(
-        member_node: Rc<EvaluationNode>,
+        member: Rc<MultiStageMember>,
         state: Rc<MultiStageAppliedState>,
         input: Vec<Rc<MultiStageQueryDescription>>,
         alias: String,
     ) -> Rc<Self> {
         Rc::new(Self {
-            member_node,
+            member,
             state,
             input,
             alias,
@@ -40,7 +40,11 @@ impl MultiStageQueryDescription {
     }
 
     pub fn member_node(&self) -> &Rc<EvaluationNode> {
-        &self.member_node
+        &self.member.evaluation_node()
+    }
+
+    pub fn member(&self) -> &Rc<MultiStageMember> {
+        &self.member
     }
 
     pub fn state(&self) -> Rc<MultiStageAppliedState> {
@@ -48,7 +52,7 @@ impl MultiStageQueryDescription {
     }
 
     pub fn member_name(&self) -> String {
-        self.member_node.full_name()
+        self.member_node().full_name()
     }
 
     pub fn alias(&self) -> &String {
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 fb7e4b6d00a6f..1237a0ece2c75 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
@@ -1,13 +1,17 @@
-use super::multi_stage::MultiStageMemberQueryPlanner;
-use super::multi_stage::{MultiStageAppliedState, MultiStageQueryDescription};
+use super::multi_stage::{
+    MultiStageAppliedState, MultiStageInodeMember, MultiStageInodeMemberType,
+    MultiStageLeafMemberType, MultiStageMember, MultiStageMemberQueryPlanner, MultiStageMemberType,
+    MultiStageQueryDescription, MultiStageTimeShift, RollingWindowDescription,
+};
+use crate::cube_bridge::measure_definition::RollingWindow;
 use crate::plan::{Cte, From, Schema, Select, SelectBuilder};
 use crate::planner::query_tools::QueryTools;
 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::EvaluationNode;
-use crate::planner::QueryProperties;
 use crate::planner::{BaseDimension, BaseMeasure, VisitorContext};
+use crate::planner::{BaseTimeDimension, GranularityHelper, QueryProperties};
 use cubenativeutils::CubeError;
 use itertools::Itertools;
 use std::collections::HashMap;
@@ -31,7 +35,7 @@ impl MultiStageQueryPlanner {
             .all_members(false)
             .into_iter()
             .filter_map(|memb| -> Option<Result<_, CubeError>> {
-                match has_multi_stage_members(&memb.member_evaluator()) {
+                match has_multi_stage_members(&memb.member_evaluator(), false) {
                     Ok(true) => Some(Ok(memb)),
                     Ok(false) => None,
                     Err(e) => Some(Err(e)),
@@ -42,10 +46,12 @@ impl MultiStageQueryPlanner {
             return Ok((vec![], vec![]));
         }
         let mut descriptions = Vec::new();
-        let all_filter_members = self.query_properties.all_filtered_members();
         let state = MultiStageAppliedState::new(
+            self.query_properties.time_dimensions().clone(),
             self.query_properties.dimensions().clone(),
-            all_filter_members,
+            self.query_properties.time_dimensions_filters().clone(),
+            self.query_properties.dimensions_filters().clone(),
+            self.query_properties.measures_filters().clone(),
         );
 
         let top_level_ctes = multi_stage_members
@@ -99,6 +105,214 @@ impl MultiStageQueryPlanner {
         Rc::new(select_builder.build())
     }
 
+    fn create_multi_stage_inode_member(
+        &self,
+        base_member: Rc<EvaluationNode>,
+    ) -> Result<MultiStageInodeMember, CubeError> {
+        let inode = if let Some(measure) =
+            BaseMeasure::try_new(base_member.clone(), self.query_tools.clone())?
+        {
+            let member_type = if measure.measure_type() == "rank" {
+                MultiStageInodeMemberType::Rank
+            } else if !measure.is_calculated() {
+                MultiStageInodeMemberType::Aggregate
+            } else {
+                MultiStageInodeMemberType::Calculate
+            };
+
+            let time_shifts = if let Some(refs) = measure.time_shift_references() {
+                let time_shifts = refs
+                    .iter()
+                    .map(|r| MultiStageTimeShift::try_from_reference(r))
+                    .collect::<Result<Vec<_>, _>>()?;
+                time_shifts
+            } else {
+                vec![]
+            };
+            let is_ungrupped = match &member_type {
+                MultiStageInodeMemberType::Rank | MultiStageInodeMemberType::Calculate => true,
+                _ => false,
+            };
+            MultiStageInodeMember::new(
+                member_type,
+                measure.reduce_by().clone().unwrap_or_default(),
+                measure.add_group_by().clone().unwrap_or_default(),
+                measure.group_by().clone(),
+                time_shifts,
+                is_ungrupped,
+            )
+        } else {
+            MultiStageInodeMember::new(
+                MultiStageInodeMemberType::Calculate,
+                vec![],
+                vec![],
+                None,
+                vec![],
+                false,
+            )
+        };
+        Ok(inode)
+    }
+
+    fn add_time_series(
+        &self,
+        time_dimension: Rc<BaseTimeDimension>,
+        state: Rc<MultiStageAppliedState>,
+        descriptions: &mut Vec<Rc<MultiStageQueryDescription>>,
+    ) -> Result<Rc<MultiStageQueryDescription>, CubeError> {
+        let description =
+            if let Some(description) = descriptions.iter().find(|d| d.alias() == "time_series") {
+                description.clone()
+            } else {
+                let time_series_node = MultiStageQueryDescription::new(
+                    MultiStageMember::new(
+                        MultiStageMemberType::Leaf(MultiStageLeafMemberType::TimeSeries(
+                            time_dimension.clone(),
+                        )),
+                        time_dimension.member_evaluator(),
+                    ),
+                    state.clone(),
+                    vec![],
+                    "time_series".to_string(),
+                );
+                descriptions.push(time_series_node.clone());
+                time_series_node
+            };
+        Ok(description)
+    }
+
+    fn add_rolling_window_base(
+        &self,
+        member: Rc<EvaluationNode>,
+        state: Rc<MultiStageAppliedState>,
+        descriptions: &mut Vec<Rc<MultiStageQueryDescription>>,
+    ) -> Result<Rc<MultiStageQueryDescription>, CubeError> {
+        let alias = format!("cte_{}", descriptions.len());
+        let description = MultiStageQueryDescription::new(
+            MultiStageMember::new(
+                MultiStageMemberType::Leaf(MultiStageLeafMemberType::Measure),
+                member,
+            ),
+            state,
+            vec![],
+            alias.clone(),
+        );
+        descriptions.push(description.clone());
+        Ok(description)
+    }
+
+    fn make_rolling_base_state(
+        &self,
+        time_dimension: Rc<BaseTimeDimension>,
+        rolling_window: &RollingWindow,
+        state: Rc<MultiStageAppliedState>,
+    ) -> Result<Rc<MultiStageAppliedState>, CubeError> {
+        let time_dimension_name = time_dimension.member_evaluator().full_name();
+        let mut new_state = state.clone_state();
+        let trailing_granularity =
+            GranularityHelper::granularity_from_interval(&rolling_window.trailing);
+        let leading_granularity =
+            GranularityHelper::granularity_from_interval(&rolling_window.leading);
+        let window_granularity =
+            GranularityHelper::min_granularity(&trailing_granularity, &leading_granularity)?;
+        let result_granularity = GranularityHelper::min_granularity(
+            &window_granularity,
+            &time_dimension.get_granularity(),
+        )?;
+
+        new_state.change_time_dimension_granularity(&time_dimension_name, result_granularity);
+
+        new_state.expand_date_range_filter(
+            &time_dimension_name,
+            rolling_window.trailing.clone(),
+            rolling_window.leading.clone(),
+        );
+
+        Ok(Rc::new(new_state))
+    }
+
+    fn try_make_rolling_window(
+        &self,
+        member: Rc<EvaluationNode>,
+        state: Rc<MultiStageAppliedState>,
+        descriptions: &mut Vec<Rc<MultiStageQueryDescription>>,
+    ) -> Result<Option<Rc<MultiStageQueryDescription>>, CubeError> {
+        if let Some(measure) = BaseMeasure::try_new(member.clone(), self.query_tools.clone())? {
+            if measure.is_cumulative() {
+                let rolling_window = if let Some(rolling_window) = measure.rolling_window() {
+                    rolling_window.clone()
+                } else {
+                    RollingWindow {
+                        trailing: Some("unbounded".to_string()),
+                        leading: None,
+                        offset: None,
+                    }
+                };
+                let time_dimensions = self.query_properties.time_dimensions();
+                if time_dimensions.len() == 0 {
+                    let rolling_base =
+                        self.add_rolling_window_base(member.clone(), state.clone(), descriptions)?;
+                    return Ok(Some(rolling_base));
+                }
+                if time_dimensions.len() != 1 {
+                    return Err(CubeError::internal(
+                        "Rolling window requires one time dimension".to_string(),
+                    ));
+                }
+                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.make_rolling_base_state(
+                            time_dimension.clone(),
+                            &rolling_window,
+                            state.clone(),
+                        )?,
+                        descriptions,
+                    )?,
+                ];
+
+                let time_dimension = time_dimensions[0].clone();
+
+                let alias = format!("cte_{}", descriptions.len());
+
+                let rolling_window_descr = RollingWindowDescription {
+                    time_dimension: time_dimension.clone(),
+                    trailing: rolling_window.trailing.clone(),
+                    leading: rolling_window.leading.clone(),
+                    offset: rolling_window.offset.clone().unwrap_or("end".to_string()),
+                };
+
+                let inode_member = MultiStageInodeMember::new(
+                    MultiStageInodeMemberType::RollingWindow(rolling_window_descr),
+                    vec![],
+                    vec![],
+                    None,
+                    vec![],
+                    false,
+                );
+
+                let description = MultiStageQueryDescription::new(
+                    MultiStageMember::new(MultiStageMemberType::Inode(inode_member), member),
+                    state.clone(),
+                    input,
+                    alias.clone(),
+                );
+                descriptions.push(description.clone());
+                Ok(Some(description))
+            } else {
+                Ok(None)
+            }
+        } else {
+            Ok(None)
+        }
+    }
+
     fn make_queries_descriptions(
         &self,
         member: Rc<EvaluationNode>,
@@ -113,54 +327,77 @@ impl MultiStageQueryPlanner {
             return Ok(exists.clone());
         };
 
-        let (dimensions_to_add, time_shifts) = if let Some(measure) =
-            BaseMeasure::try_new(member.clone(), self.query_tools.clone())?
+        if let Some(rolling_window_query) =
+            self.try_make_rolling_window(member.clone(), state.clone(), descriptions)?
         {
-            let dimensions_to_add = if let Some(add_group_by) = measure.add_group_by() {
-                add_group_by
-                    .iter()
-                    .map(|name| self.compile_dimension(name))
-                    .collect::<Result<Vec<_>, _>>()?
-            } else {
-                vec![]
-            };
+            return Ok(rolling_window_query);
+        }
 
-            (dimensions_to_add, measure.time_shifts().clone())
-        } else {
-            (vec![], vec![])
-        };
+        let childs = member_childs(&member)?;
 
-        let new_state = if !dimensions_to_add.is_empty()
-            || !time_shifts.is_empty()
-            || state.is_filter_allowed(&member_name)
-        {
-            let mut new_state = state.clone_state();
-            if !dimensions_to_add.is_empty() {
-                new_state.add_dimensions(dimensions_to_add);
-            }
-            if !time_shifts.is_empty() {
-                new_state.add_time_shifts(time_shifts);
+        let description = if childs.is_empty() {
+            if has_multi_stage_members(&member, false)? {
+                return Err(CubeError::internal(format!(
+                    "Leaf multi stage query cannot contain multi stage member"
+                )));
             }
-            if state.is_filter_allowed(&member_name) {
-                new_state.disallow_filter(&member_name);
-            }
-            Rc::new(new_state)
+
+            let alias = format!("cte_{}", descriptions.len());
+            MultiStageQueryDescription::new(
+                MultiStageMember::new(
+                    MultiStageMemberType::Leaf(MultiStageLeafMemberType::Measure),
+                    member.clone(),
+                ),
+                state.clone(),
+                vec![],
+                alias.clone(),
+            )
         } else {
-            state.clone()
-        };
+            let multi_stage_member = self.create_multi_stage_inode_member(member.clone())?;
 
-        let childs = member_childs(&member)?;
-        let input = childs
-            .into_iter()
-            .map(
-                |child| -> Result<Rc<MultiStageQueryDescription>, CubeError> {
-                    self.make_queries_descriptions(child, new_state.clone(), descriptions)
-                },
+            let dimensions_to_add = multi_stage_member
+                .add_group_by()
+                .iter()
+                .map(|name| self.compile_dimension(name))
+                .collect::<Result<Vec<_>, _>>()?;
+
+            let new_state = if !dimensions_to_add.is_empty()
+                || !multi_stage_member.time_shifts().is_empty()
+                || state.has_filters_for_member(&member_name)
+            {
+                let mut new_state = state.clone_state();
+                if !dimensions_to_add.is_empty() {
+                    new_state.add_dimensions(dimensions_to_add);
+                }
+                if !multi_stage_member.time_shifts().is_empty() {
+                    new_state.add_time_shifts(multi_stage_member.time_shifts().clone());
+                }
+                if state.has_filters_for_member(&member_name) {
+                    new_state.remove_filter_for_member(&member_name);
+                }
+                Rc::new(new_state)
+            } else {
+                state.clone()
+            };
+
+            let input = childs
+                .into_iter()
+                .map(
+                    |child| -> Result<Rc<MultiStageQueryDescription>, CubeError> {
+                        self.make_queries_descriptions(child, new_state.clone(), descriptions)
+                    },
+                )
+                .collect::<Result<Vec<_>, _>>()?;
+
+            let alias = format!("cte_{}", descriptions.len());
+            MultiStageQueryDescription::new(
+                MultiStageMember::new(MultiStageMemberType::Inode(multi_stage_member), member),
+                state.clone(),
+                input,
+                alias.clone(),
             )
-            .collect::<Result<Vec<_>, _>>()?;
-        let alias = format!("cte_{}", descriptions.len());
-        let description =
-            MultiStageQueryDescription::new(member, state.clone(), input, alias.clone());
+        };
+
         descriptions.push(description.clone());
         Ok(description)
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
index 384ff238c12f2..63465f24c8ef7 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
@@ -4,7 +4,7 @@ use super::{BaseDimension, BaseMeasure, BaseMember, BaseMemberHelper, BaseTimeDi
 use crate::cube_bridge::base_query_options::BaseQueryOptions;
 use crate::plan::{Expr, Filter, FilterItem, MemberExpression};
 use crate::planner::sql_evaluator::collectors::{
-    collect_multiplied_measures, has_multi_stage_members,
+    collect_multiplied_measures, has_cumulative_members, has_multi_stage_members,
 };
 use crate::planner::sql_evaluator::EvaluationNode;
 use cubenativeutils::CubeError;
@@ -67,6 +67,7 @@ pub struct QueryProperties {
     row_limit: Option<usize>,
     offset: Option<usize>,
     query_tools: Rc<QueryTools>,
+    ignore_cumulative: bool,
 }
 
 impl QueryProperties {
@@ -172,6 +173,7 @@ impl QueryProperties {
             row_limit,
             offset,
             query_tools,
+            ignore_cumulative: false,
         }))
     }
 
@@ -186,6 +188,7 @@ impl QueryProperties {
         order_by: Vec<OrderByItem>,
         row_limit: Option<usize>,
         offset: Option<usize>,
+        ignore_cumulative: bool,
     ) -> Result<Rc<Self>, CubeError> {
         let order_by = if order_by.is_empty() {
             Self::default_order(&dimensions, &time_dimensions, &measures)
@@ -204,6 +207,7 @@ impl QueryProperties {
             row_limit,
             offset,
             query_tools,
+            ignore_cumulative,
         }))
     }
 
@@ -386,6 +390,15 @@ impl QueryProperties {
         Ok(true)
     }
 
+    pub fn should_use_time_series(&self) -> Result<bool, CubeError> {
+        for member in self.all_members(false) {
+            if has_cumulative_members(&member.member_evaluator())? {
+                return Ok(true);
+            }
+        }
+        Ok(false)
+    }
+
     pub fn full_key_aggregate_measures(&self) -> Result<FullKeyAggregateMeasures, CubeError> {
         let mut result = FullKeyAggregateMeasures::default();
         let measures = self.measures();
@@ -404,7 +417,7 @@ impl QueryProperties {
         &self,
         symbol: &Rc<EvaluationNode>,
     ) -> Result<SymbolAggregateType, CubeError> {
-        let symbol_type = if has_multi_stage_members(symbol)? {
+        let symbol_type = if has_multi_stage_members(symbol, self.ignore_cumulative)? {
             SymbolAggregateType::MultiStage
         } else if let Some(multiple) =
             collect_multiplied_measures(self.query_tools.clone(), symbol)?
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/has_cumulative_members.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/has_cumulative_members.rs
new file mode 100644
index 0000000000000..98ee71eacb947
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/has_cumulative_members.rs
@@ -0,0 +1,39 @@
+use crate::planner::sql_evaluator::{EvaluationNode, MemberSymbolType, TraversalVisitor};
+use cubenativeutils::CubeError;
+use std::rc::Rc;
+
+pub struct HasCumulativeMembersCollector {
+    pub has_cumulative_members: bool,
+}
+
+impl HasCumulativeMembersCollector {
+    pub fn new() -> Self {
+        Self {
+            has_cumulative_members: false,
+        }
+    }
+
+    pub fn extract_result(self) -> bool {
+        self.has_cumulative_members
+    }
+}
+
+impl TraversalVisitor for HasCumulativeMembersCollector {
+    fn on_node_traverse(&mut self, node: &Rc<EvaluationNode>) -> Result<bool, CubeError> {
+        match node.symbol() {
+            MemberSymbolType::Measure(s) => {
+                if s.is_rolling_window() {
+                    self.has_cumulative_members = true;
+                }
+            }
+            _ => {}
+        };
+        Ok(!self.has_cumulative_members)
+    }
+}
+
+pub fn has_cumulative_members(node: &Rc<EvaluationNode>) -> Result<bool, CubeError> {
+    let mut visitor = HasCumulativeMembersCollector::new();
+    visitor.apply(node)?;
+    Ok(visitor.extract_result())
+}
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/has_multi_stage_members.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/has_multi_stage_members.rs
index aedeaf794b7a3..f7b8b6234be21 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/has_multi_stage_members.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/has_multi_stage_members.rs
@@ -3,12 +3,14 @@ use cubenativeutils::CubeError;
 use std::rc::Rc;
 
 pub struct HasMultiStageMembersCollector {
+    pub ignore_cumulative: bool,
     pub has_multi_stage: bool,
 }
 
 impl HasMultiStageMembersCollector {
-    pub fn new() -> Self {
+    pub fn new(ignore_cumulative: bool) -> Self {
         Self {
+            ignore_cumulative,
             has_multi_stage: false,
         }
     }
@@ -24,6 +26,10 @@ impl TraversalVisitor for HasMultiStageMembersCollector {
             MemberSymbolType::Measure(s) => {
                 if s.is_multi_stage() {
                     self.has_multi_stage = true;
+                } else if !self.ignore_cumulative
+                    && (s.is_rolling_window() || s.measure_type() == "runningTotal")
+                {
+                    self.has_multi_stage = true;
                 } else {
                     for filter_node in s.measure_filters() {
                         self.apply(filter_node)?
@@ -44,8 +50,11 @@ impl TraversalVisitor for HasMultiStageMembersCollector {
     }
 }
 
-pub fn has_multi_stage_members(node: &Rc<EvaluationNode>) -> Result<bool, CubeError> {
-    let mut visitor = HasMultiStageMembersCollector::new();
+pub fn has_multi_stage_members(
+    node: &Rc<EvaluationNode>,
+    ignore_cumulative: bool,
+) -> Result<bool, CubeError> {
+    let mut visitor = HasMultiStageMembersCollector::new(ignore_cumulative);
     visitor.apply(node)?;
     Ok(visitor.extract_result())
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/mod.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/mod.rs
index d276385a25241..b291633ab01d5 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/mod.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/collectors/mod.rs
@@ -1,8 +1,10 @@
+mod has_cumulative_members;
 mod has_multi_stage_members;
 mod join_hints_collector;
 mod member_childs_collector;
 mod multiplied_measures_collector;
 
+pub use has_cumulative_members::{has_cumulative_members, HasCumulativeMembersCollector};
 pub use has_multi_stage_members::{has_multi_stage_members, HasMultiStageMembersCollector};
 pub use join_hints_collector::JoinHintsCollector;
 pub use member_childs_collector::{member_childs, MemberChildsCollector};
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs
index a9ac62c42aba6..635c7e944c076 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/dependecy.rs
@@ -5,6 +5,7 @@ use cubenativeutils::CubeError;
 use std::collections::HashMap;
 use std::rc::Rc;
 
+#[derive(Clone)]
 pub struct StructDependency {
     pub sql_fn: Option<Rc<EvaluationNode>>,
     pub to_string_fn: Option<Rc<EvaluationNode>>,
@@ -25,12 +26,14 @@ impl StructDependency {
     }
 }
 
+#[derive(Clone)]
 pub enum ContextSymbolDep {
     SecurityContext,
     FilterParams,
     FilterGroup,
 }
 
+#[derive(Clone)]
 pub enum Dependency {
     SingleDependency(Rc<EvaluationNode>),
     StructDependency(StructDependency),
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/evaluation_node.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/evaluation_node.rs
index 02355626a2c28..5c53c7833ca61 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/evaluation_node.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/evaluation_node.rs
@@ -62,10 +62,33 @@ impl EvaluationNode {
         self.symbol.full_name()
     }
 
+    pub fn name(&self) -> String {
+        self.symbol.name()
+    }
+
     pub fn is_measure(&self) -> bool {
         self.symbol.is_measure()
     }
     pub fn is_dimension(&self) -> bool {
         self.symbol.is_dimension()
     }
+
+    pub fn try_split_measure(self: Rc<Self>, source_name: String) -> Option<(Rc<Self>, Rc<Self>)> {
+        match &self.symbol {
+            MemberSymbolType::Measure(measure_symbol) => {
+                let (measure, source) = measure_symbol.split_with_source(source_name);
+                let source = Self {
+                    symbol: MemberSymbolType::Measure(source),
+                    deps: self.deps.clone(),
+                };
+                let source = Rc::new(source);
+                let measure = Self {
+                    symbol: MemberSymbolType::Measure(measure),
+                    deps: vec![Dependency::SingleDependency(source.clone())],
+                };
+                Some((Rc::new(measure), source))
+            }
+            _ => None,
+        }
+    }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_node_transformers/set_schema.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_node_transformers/set_schema.rs
index d7e580edcac19..a8a63d4f21b55 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_node_transformers/set_schema.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_node_transformers/set_schema.rs
@@ -2,7 +2,8 @@ use crate::plan::schema::Schema;
 use crate::planner::sql_evaluator::sql_nodes::final_measure::FinalMeasureSqlNode;
 use crate::planner::sql_evaluator::sql_nodes::{
     AutoPrefixSqlNode, EvaluateSqlNode, MeasureFilterSqlNode, MultiStageRankNode,
-    MultiStageWindowNode, RenderReferencesSqlNode, RootSqlNode, SqlNode, TimeShiftSqlNode,
+    MultiStageWindowNode, RenderReferencesSqlNode, RollingWindowNode, RootSqlNode, SqlNode,
+    TimeShiftSqlNode,
 };
 use std::rc::Rc;
 
@@ -55,6 +56,13 @@ pub fn set_schema_impl(sql_node: Rc<dyn SqlNode>, schema: Rc<Schema>) -> Rc<dyn
             else_processor,
             multi_stage_window.partition().clone(),
         )
+    } else if let Some(rolling_window) = sql_node
+        .clone()
+        .as_any()
+        .downcast_ref::<RollingWindowNode>()
+    {
+        let input = set_schema_impl(rolling_window.input().clone(), schema.clone());
+        RollingWindowNode::new(input)
     } else if let Some(render_references) = sql_node
         .clone()
         .as_any()
@@ -81,6 +89,6 @@ pub fn set_schema_impl(sql_node: Rc<dyn SqlNode>, schema: Rc<Schema>) -> Rc<dyn
         let input = set_schema_impl(time_shift.input().clone(), schema.clone());
         TimeShiftSqlNode::new(time_shift.shifts().clone(), input)
     } else {
-        unreachable!("Not all nodes are implemented");
+        unreachable!("Not all nodes are implemented in set_schema function");
     }
 }
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 9d8729896e84d..3368a23781deb 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,7 +1,7 @@
 use super::{
     AutoPrefixSqlNode, EvaluateSqlNode, FinalMeasureSqlNode, MeasureFilterSqlNode,
-    MultiStageRankNode, MultiStageWindowNode, RenderReferencesSqlNode, RootSqlNode, SqlNode,
-    TimeShiftSqlNode,
+    MultiStageRankNode, MultiStageWindowNode, RenderReferencesSqlNode, RollingWindowNode,
+    RootSqlNode, SqlNode, TimeShiftSqlNode,
 };
 use std::collections::HashMap;
 use std::rc::Rc;
@@ -73,6 +73,24 @@ impl SqlNodesFactory {
         references_processor
     }
 
+    pub fn rolling_window_node_processor(&self) -> Rc<dyn SqlNode> {
+        let evaluate_sql_processor = EvaluateSqlNode::new();
+        let auto_prefix_processor = AutoPrefixSqlNode::new(evaluate_sql_processor.clone());
+        let measure_filter_processor = MeasureFilterSqlNode::new(auto_prefix_processor.clone());
+        let final_measure_processor = FinalMeasureSqlNode::new(measure_filter_processor.clone());
+
+        let rolling_window_processor = RollingWindowNode::new(final_measure_processor.clone());
+
+        let root_processor = RootSqlNode::new(
+            self.dimension_processor(auto_prefix_processor.clone()),
+            rolling_window_processor.clone(),
+            auto_prefix_processor.clone(),
+            evaluate_sql_processor.clone(),
+        );
+        let references_processor = RenderReferencesSqlNode::new(root_processor);
+        references_processor
+    }
+
     fn dimension_processor(&self, input: Rc<dyn SqlNode>) -> Rc<dyn SqlNode> {
         if let Some(time_shifts) = &self.time_shifts {
             TimeShiftSqlNode::new(time_shifts.clone(), 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 2fd786a986f9e..c5469d5206242 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
@@ -40,7 +40,11 @@ impl SqlNode for FinalMeasureSqlNode {
                 if ev.is_calculated() {
                     input
                 } else {
-                    let measure_type = ev.measure_type();
+                    let measure_type = if ev.measure_type() == "runningTotal" {
+                        "sum"
+                    } else {
+                        &ev.measure_type()
+                    };
                     format!("{}({})", measure_type, input)
                 }
             }
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 9cb6190581a9d..f316c5d8facb3 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
@@ -6,6 +6,7 @@ pub mod measure_filter;
 pub mod multi_stage_rank;
 pub mod multi_stage_window;
 pub mod render_references;
+pub mod rolling_window;
 pub mod root_processor;
 pub mod sql_node;
 pub mod time_shift;
@@ -18,6 +19,7 @@ pub use measure_filter::MeasureFilterSqlNode;
 pub use multi_stage_rank::MultiStageRankNode;
 pub use multi_stage_window::MultiStageWindowNode;
 pub use render_references::RenderReferencesSqlNode;
+pub use rolling_window::RollingWindowNode;
 pub use root_processor::RootSqlNode;
 pub use sql_node::SqlNode;
 pub use time_shift::TimeShiftSqlNode;
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
new file mode 100644
index 0000000000000..f97ac113e2fc4
--- /dev/null
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/rolling_window.rs
@@ -0,0 +1,76 @@
+use super::SqlNode;
+use crate::cube_bridge::memeber_sql::MemberSqlArg;
+use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::{EvaluationNode, MemberSymbolType, SqlEvaluatorVisitor};
+use cubenativeutils::CubeError;
+use std::any::Any;
+use std::rc::Rc;
+
+pub struct RollingWindowNode {
+    input: Rc<dyn SqlNode>,
+}
+
+impl RollingWindowNode {
+    pub fn new(input: Rc<dyn SqlNode>) -> Rc<Self> {
+        Rc::new(Self { input })
+    }
+
+    pub fn input(&self) -> &Rc<dyn SqlNode> {
+        &self.input
+    }
+}
+
+impl SqlNode for RollingWindowNode {
+    fn to_sql(
+        &self,
+        visitor: &mut SqlEvaluatorVisitor,
+        node: &Rc<EvaluationNode>,
+        query_tools: Rc<QueryTools>,
+        node_processor: Rc<dyn SqlNode>,
+    ) -> Result<String, CubeError> {
+        let res = match node.symbol() {
+            MemberSymbolType::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 = if !args.is_empty() {
+                        match &args[0] {
+                            MemberSqlArg::String(s) => s.clone(),
+                            _ => "".to_string(),
+                        }
+                    } else {
+                        "".to_string()
+                    };
+                    let aggregate_function = if m.measure_type() == "sum"
+                        || m.measure_type() == "count"
+                        || m.measure_type() == "runningTotal"
+                    {
+                        "sum"
+                    } else {
+                        m.measure_type()
+                    };
+
+                    format!("{}({})", aggregate_function, input)
+                } else {
+                    self.input
+                        .to_sql(visitor, node, query_tools.clone(), node_processor.clone())?
+                }
+            }
+            _ => {
+                return Err(CubeError::internal(format!(
+                    "Unexpected evaluation node type for RollingWindowNode"
+                )));
+            }
+        };
+        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/symbols/measure_symbol.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/measure_symbol.rs
index e6ecf3db0e0c5..261ec2c5f7e8b 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
@@ -1,11 +1,14 @@
 use super::{MemberSymbol, SymbolFactory};
 use crate::cube_bridge::evaluator::CubeEvaluator;
-use crate::cube_bridge::measure_definition::{MeasureDefinition, TimeShiftReference};
+use crate::cube_bridge::measure_definition::{
+    MeasureDefinition, RollingWindow, TimeShiftReference,
+};
 use crate::cube_bridge::memeber_sql::{MemberSql, MemberSqlArg};
 use crate::planner::sql_evaluator::{Compiler, Dependency, EvaluationNode};
 use cubenativeutils::CubeError;
 use std::rc::Rc;
 
+#[derive(Clone)]
 pub struct MeasureOrderBy {
     evaluation_node: Rc<EvaluationNode>,
     direction: String,
@@ -28,6 +31,7 @@ impl MeasureOrderBy {
     }
 }
 
+#[derive(Clone)]
 pub struct MeasureSymbol {
     cube_name: String,
     name: String,
@@ -35,6 +39,7 @@ pub struct MeasureSymbol {
     measure_filters: Vec<Rc<EvaluationNode>>,
     measure_order_by: Vec<MeasureOrderBy>,
     member_sql: Rc<dyn MemberSql>,
+    is_splitted_source: bool,
 }
 
 impl MeasureSymbol {
@@ -53,6 +58,7 @@ impl MeasureSymbol {
             definition,
             measure_filters,
             measure_order_by,
+            is_splitted_source: false,
         }
     }
 
@@ -60,6 +66,24 @@ impl MeasureSymbol {
         format!("{}.{}", self.cube_name, self.name)
     }
 
+    pub fn is_splitted_source(&self) -> bool {
+        self.is_splitted_source
+    }
+
+    pub fn split_with_source(&self, source_name: String) -> (Self, Self) {
+        let mut measure_with_source = self.clone();
+        measure_with_source.is_splitted_source = true;
+        let source = Self::new(
+            self.cube_name.clone(),
+            source_name.clone(),
+            self.member_sql.clone(),
+            self.definition().clone(),
+            self.measure_filters.clone(),
+            self.measure_order_by.clone(),
+        );
+        (measure_with_source, source)
+    }
+
     pub fn is_calculated(&self) -> bool {
         match self.definition.static_data().measure_type.as_str() {
             "number" | "string" | "time" | "boolean" => true,
@@ -83,6 +107,22 @@ impl MeasureSymbol {
         &self.definition.static_data().measure_type
     }
 
+    pub fn rolling_window(&self) -> &Option<RollingWindow> {
+        &self.definition.static_data().rolling_window
+    }
+
+    pub fn is_rolling_window(&self) -> bool {
+        self.rolling_window().is_some()
+    }
+
+    pub fn is_running_total(&self) -> bool {
+        self.measure_type() == "runningTotal"
+    }
+
+    pub fn is_cumulative(&self) -> bool {
+        self.is_rolling_window() || self.is_running_total()
+    }
+
     pub fn measure_filters(&self) -> &Vec<Rc<EvaluationNode>> {
         &self.measure_filters
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_symbol_type.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_symbol_type.rs
index 830c8e7f4e367..d719fb93492c2 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_symbol_type.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/symbols/member_symbol_type.rs
@@ -1,4 +1,6 @@
-use super::{CubeNameSymbol, CubeTableSymbol, DimensionSymbol, MeasureSymbol, SimpleSqlSymbol};
+use super::{
+    CubeNameSymbol, CubeTableSymbol, DimensionSymbol, MeasureSymbol, MemberSymbol, SimpleSqlSymbol,
+};
 pub enum MemberSymbolType {
     Dimension(DimensionSymbol),
     Measure(MeasureSymbol),
@@ -17,6 +19,15 @@ impl MemberSymbolType {
             MemberSymbolType::SimpleSql(_) => "".to_string(),
         }
     }
+    pub fn name(&self) -> String {
+        match self {
+            MemberSymbolType::Dimension(d) => d.name().clone(),
+            MemberSymbolType::Measure(m) => m.name().clone(),
+            MemberSymbolType::CubeName(c) => c.cube_name().clone(),
+            MemberSymbolType::CubeTable(c) => c.cube_name().clone(),
+            MemberSymbolType::SimpleSql(_) => "".to_string(),
+        }
+    }
     pub fn is_measure(&self) -> bool {
         matches!(self, Self::Measure(_))
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/filter.rs
index f0d23de97e232..c7eaaf9a8ed11 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/filter.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/filter.rs
@@ -3,6 +3,7 @@ use cubenativeutils::CubeError;
 use minijinja::context;
 use std::rc::Rc;
 
+#[derive(Clone)]
 pub struct FilterTemplates {
     render: Rc<dyn SqlTemplatesRender>,
 }
@@ -103,6 +104,26 @@ impl FilterTemplates {
         )
     }
 
+    pub fn add_interval(&self, date: String, interval: String) -> Result<String, CubeError> {
+        self.render.render_template(
+            &"expressions/add_interval",
+            context! {
+                date => date,
+                interval => interval
+            },
+        )
+    }
+
+    pub fn sub_interval(&self, date: String, interval: String) -> Result<String, CubeError> {
+        self.render.render_template(
+            &"expressions/sub_interval",
+            context! {
+                date => date,
+                interval => interval
+            },
+        )
+    }
+
     pub fn set_where(&self, column: String) -> Result<String, CubeError> {
         self.render.render_template(
             &"filters/set_where",
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/plan.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/plan.rs
index aca5695ef8544..26b12acacd25a 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/plan.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/plan.rs
@@ -121,6 +121,22 @@ impl PlanSqlTemplates {
         )
     }
 
+    pub fn time_series_select(
+        &self,
+        from_date: Option<String>,
+        to_date: Option<String>,
+        seria: Vec<Vec<String>>,
+    ) -> Result<String, CubeError> {
+        self.render.render_template(
+            "statements/time_series_select",
+            context! {
+                from_date => from_date,
+                to_date => to_date,
+                seria => seria
+            },
+        )
+    }
+
     pub fn select(
         &self,
         ctes: Vec<String>,
@@ -152,59 +168,6 @@ impl PlanSqlTemplates {
         )
     }
 
-    /* pub fn select(
-        &self,
-        from: String,
-        projection: Vec<AliasedColumn>,
-        group_by: Vec<AliasedColumn>,
-        group_descs: Vec<Option<GroupingSetDesc>>,
-        aggregate: Vec<AliasedColumn>,
-        alias: String,
-        filter: Option<String>,
-        _having: Option<String>,
-        order_by: Vec<AliasedColumn>,
-        limit: Option<usize>,
-        offset: Option<usize>,
-        distinct: bool,
-    ) -> Result<String, CubeError> {
-        let group_by = self.to_template_columns(group_by)?;
-        let aggregate = self.to_template_columns(aggregate)?;
-        let projection = self.to_template_columns(projection)?;
-        let order_by = self.to_template_columns(order_by)?;
-        let select_concat = group_by
-            .iter()
-            .chain(aggregate.iter())
-            .chain(projection.iter())
-            .map(|c| c.clone())
-            .collect::<Vec<_>>();
-        let quoted_from_alias = self.quote_identifier(&alias)?;
-        let has_grouping_sets = group_descs.iter().any(|d| d.is_some());
-        let group_by_expr = if has_grouping_sets {
-            self.group_by_with_grouping_sets(&group_by, &group_descs)?
-        } else {
-            self.render_template(
-                "statements/group_by_exprs",
-                context! { group_by => group_by },
-            )?
-        };
-        self.render.render_template(
-            "statements/select",
-            context! {
-                from => from,
-                select_concat => select_concat,
-                group_by => group_by_expr,
-                aggregate => aggregate,
-                projection => projection,
-                order_by => order_by,
-                filter => filter,
-                from_alias => quoted_from_alias,
-                limit => limit,
-                offset => offset,
-                distinct => distinct,
-            },
-        )
-    } */
-
     pub fn join(&self, source: &str, condition: &str, is_inner: bool) -> Result<String, CubeError> {
         let join_type = if is_inner {
             self.render.get_template("join_types/inner")?