diff --git a/.github/workflows/drivers-tests.yml b/.github/workflows/drivers-tests.yml
index a06b5ca230b9c..fe4e057077ef7 100644
--- a/.github/workflows/drivers-tests.yml
+++ b/.github/workflows/drivers-tests.yml
@@ -57,9 +57,19 @@ on:
       # To test SQL API Push down
       - 'packages/cubejs-backend-native/**'
       - 'rust/cubesql/**'
+  workflow_dispatch:
+    inputs:
+      use_tesseract_sql_planner:
+        description: 'Enable TESSERACT_SQL_PLANNER?'
+        required: true
+        default: 'false'
+        type: choice
+        options:
+          - 'true'
+          - 'false'
 
 env:
-  CUBEJS_TESSERACT_ORCHESTRATOR: true
+  USE_TESSERACT_SQL_PLANNER: false
 
 jobs:
   latest-tag-sha:
@@ -316,6 +326,8 @@ jobs:
           (contains(env.CLOUD_DATABASES, matrix.database) && env.DRIVERS_TESTS_ATHENA_CUBEJS_AWS_KEY != '') ||
           (!contains(env.CLOUD_DATABASES, matrix.database))
         env:
+          DRIVERS_TESTS_CUBEJS_TESSERACT_SQL_PLANNER: ${{ github.event_name == 'workflow_dispatch' && github.event.inputs.use_tesseract_sql_planner || env.USE_TESSERACT_SQL_PLANNER }}
+
           # Athena
           DRIVERS_TESTS_ATHENA_CUBEJS_AWS_KEY: ${{ secrets.DRIVERS_TESTS_ATHENA_CUBEJS_AWS_KEY }}
           DRIVERS_TESTS_ATHENA_CUBEJS_AWS_SECRET: ${{ secrets.DRIVERS_TESTS_ATHENA_CUBEJS_AWS_SECRET }}
diff --git a/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js b/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
index c7617ddf8e9b2..5ffba2f3e18a8 100644
--- a/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
+++ b/packages/cubejs-schema-compiler/src/adapter/BaseQuery.js
@@ -326,7 +326,7 @@ export class BaseQuery {
     this.allFilters = this.timeDimensions.concat(this.segments).concat(this.filters);
     this.useNativeSqlPlanner = this.options.useNativeSqlPlanner ?? getEnv('nativeSqlPlanner');
     this.canUseNativeSqlPlannerPreAggregation = false;
-    if (this.useNativeSqlPlanner) {
+    if (this.useNativeSqlPlanner && !this.neverUseSqlPlannerPreaggregation()) {
       const hasMultiStageMeasures = this.fullKeyQueryAggregateMeasures({ hasMultipliedForPreAggregation: true }).multiStageMembers.length > 0;
       this.canUseNativeSqlPlannerPreAggregation = hasMultiStageMeasures;
     }
@@ -349,6 +349,11 @@ export class BaseQuery {
     this.initUngrouped();
   }
 
+  // Temporary workaround to avoid checking for multistage in CubeStoreQuery, since that could lead to errors when HLL functions are present in the query.
+  neverUseSqlPlannerPreaggregation() {
+    return false;
+  }
+
   prebuildJoin() {
     try {
       // TODO allJoinHints should contain join hints form pre-agg
@@ -775,7 +780,6 @@ export class BaseQuery {
       R.map((hash) => ((!hash || !hash.id) ? null : hash)),
       R.reject(R.isNil),
     )(this.options.order);
-
     const queryParams = {
       measures: this.options.measures,
       dimensions: this.options.dimensions,
@@ -792,7 +796,8 @@ export class BaseQuery {
       baseTools: this,
       ungrouped: this.options.ungrouped,
       exportAnnotatedSql: exportAnnotatedSql === true,
-      preAggregationQuery: this.options.preAggregationQuery
+      preAggregationQuery: this.options.preAggregationQuery,
+      totalQuery: this.options.totalQuery,
     };
 
     const buildResult = nativeBuildSqlAndParams(queryParams);
@@ -871,12 +876,12 @@ export class BaseQuery {
 
   // FIXME helper for native generator, maybe should be moved entirely to rust
   generateTimeSeries(granularity, dateRange) {
-    return timeSeriesBase(granularity, dateRange);
+    return timeSeriesBase(granularity, dateRange, { timestampPrecision: this.timestampPrecision() });
   }
 
   // FIXME helper for native generator, maybe should be moved entirely to rust
   generateCustomTimeSeries(granularityInterval, dateRange, origin) {
-    return timeSeriesFromCustomInterval(granularityInterval, dateRange, moment(origin), { timestampPrecision: 3 });
+    return timeSeriesFromCustomInterval(granularityInterval, dateRange, moment(origin), { timestampPrecision: this.timestampPrecision() });
   }
 
   getPreAggregationByName(cube, preAggregationName) {
@@ -3827,6 +3832,9 @@ export class BaseQuery {
         like_escape: '{{ like_expr }} ESCAPE {{ escape_char }}',
         concat_strings: '{{ strings | join(\' || \' ) }}',
       },
+      tesseract: {
+        ilike: '{{ expr }} {% if negated %}NOT {% endif %}ILIKE {{ pattern }}', // May require different overloads in Tesseract than the ilike from expressions used in SQLAPI.
+      },
       filters: {
         equals: '{{ column }} = {{ value }}{{ is_null_check }}',
         not_equals: '{{ column }} <> {{ value }}{{ is_null_check }}',
diff --git a/packages/cubejs-schema-compiler/src/adapter/BigqueryQuery.ts b/packages/cubejs-schema-compiler/src/adapter/BigqueryQuery.ts
index db7e0e4056f2c..27d6816263e2c 100644
--- a/packages/cubejs-schema-compiler/src/adapter/BigqueryQuery.ts
+++ b/packages/cubejs-schema-compiler/src/adapter/BigqueryQuery.ts
@@ -261,13 +261,24 @@ export class BigqueryQuery extends BaseQuery {
     templates.expressions.timestamp_literal = 'TIMESTAMP(\'{{ value }}\')';
     delete templates.expressions.ilike;
     delete templates.expressions.like_escape;
+    templates.filters.like_pattern = 'CONCAT({% if start_wild %}\'%\'{% else %}\'\'{% endif %}, LOWER({{ value }}), {% if end_wild %}\'%\'{% else %}\'\'{% endif %})';
+    templates.tesseract.ilike = 'LOWER({{ expr }}) {% if negated %}NOT {% endif %} LIKE {{ pattern }}';
     templates.types.boolean = 'BOOL';
     templates.types.float = 'FLOAT64';
     templates.types.double = 'FLOAT64';
     templates.types.decimal = 'BIGDECIMAL({{ precision }},{{ scale }})';
     templates.types.binary = 'BYTES';
+    templates.expressions.cast_to_string = 'CAST({{ expr }} AS STRING)';
     templates.operators.is_not_distinct_from = 'IS NOT DISTINCT FROM';
     templates.join_types.full = 'FULL';
+    templates.statements.time_series_select = 'SELECT DATETIME(TIMESTAMP(f)) date_from, DATETIME(TIMESTAMP(t)) date_to \n' +
+    'FROM (\n' +
+    '{% for time_item in seria  %}' +
+    '    select \'{{ time_item[0] }}\' f, \'{{ time_item[1] }}\' t \n' +
+    '{% if not loop.last %} UNION ALL\n{% endif %}' +
+    '{% endfor %}' +
+    ') AS dates';
+      
     return templates;
   }
 }
diff --git a/packages/cubejs-schema-compiler/src/adapter/CubeStoreQuery.ts b/packages/cubejs-schema-compiler/src/adapter/CubeStoreQuery.ts
index c64ef3fd0984c..5717969612fd7 100644
--- a/packages/cubejs-schema-compiler/src/adapter/CubeStoreQuery.ts
+++ b/packages/cubejs-schema-compiler/src/adapter/CubeStoreQuery.ts
@@ -68,6 +68,11 @@ export class CubeStoreQuery extends BaseQuery {
     return `date_trunc('${GRANULARITY_TO_INTERVAL[granularity]}', ${dimension})`;
   }
 
+  // Temporary workaround to avoid checking for multistage in CubeStoreQuery, since that could lead to errors when HLL functions are present in the query.
+  public neverUseSqlPlannerPreaggregation() {
+    return true;
+  }
+
   /**
    * Returns sql for source expression floored to timestamps aligned with
    * intervals relative to origin timestamp point.
diff --git a/packages/cubejs-testing-drivers/fixtures/athena.json b/packages/cubejs-testing-drivers/fixtures/athena.json
index 2041681230409..ba5f8b2b5074c 100644
--- a/packages/cubejs-testing-drivers/fixtures/athena.json
+++ b/packages/cubejs-testing-drivers/fixtures/athena.json
@@ -15,7 +15,8 @@
       "CUBEJS_PG_SQL_PORT": "5656",
       "CUBEJS_SQL_USER": "admin",
       "CUBEJS_SQL_PASSWORD": "admin_password",
-      "CUBESQL_SQL_PUSH_DOWN": "true"
+      "CUBESQL_SQL_PUSH_DOWN": "true",
+      "CUBEJS_TESSERACT_SQL_PLANNER": "${DRIVERS_TESTS_CUBEJS_TESSERACT_SQL_PLANNER}"
     },
     "ports" : ["4000", "5656"]
   },
diff --git a/packages/cubejs-testing-drivers/fixtures/bigquery.json b/packages/cubejs-testing-drivers/fixtures/bigquery.json
index 9af4155bb8da8..bd8c634a20252 100644
--- a/packages/cubejs-testing-drivers/fixtures/bigquery.json
+++ b/packages/cubejs-testing-drivers/fixtures/bigquery.json
@@ -17,7 +17,8 @@
       "CUBESQL_SQL_PUSH_DOWN": "true",
 
       "CUBEJS_DB_EXPORT_BUCKET": "cube-open-source-export-bucket",
-      "CUBEJS_DB_EXPORT_BUCKET_TYPE": "gcp"
+      "CUBEJS_DB_EXPORT_BUCKET_TYPE": "gcp",
+      "CUBEJS_TESSERACT_SQL_PLANNER": "${DRIVERS_TESTS_CUBEJS_TESSERACT_SQL_PLANNER}"
     },
     "ports" : ["4000", "5656"]
   },
diff --git a/packages/cubejs-testing-drivers/fixtures/clickhouse.json b/packages/cubejs-testing-drivers/fixtures/clickhouse.json
index 01b0df848281b..44cb88cbb3703 100644
--- a/packages/cubejs-testing-drivers/fixtures/clickhouse.json
+++ b/packages/cubejs-testing-drivers/fixtures/clickhouse.json
@@ -25,7 +25,8 @@
       "CUBEJS_PG_SQL_PORT": "5656",
       "CUBEJS_SQL_USER": "admin",
       "CUBEJS_SQL_PASSWORD": "admin_password",
-      "CUBESQL_SQL_PUSH_DOWN": "true"
+      "CUBESQL_SQL_PUSH_DOWN": "true",
+      "CUBEJS_TESSERACT_SQL_PLANNER": "${DRIVERS_TESTS_CUBEJS_TESSERACT_SQL_PLANNER}"
     },
     "depends_on": ["data"],
     "links": ["data"],
diff --git a/packages/cubejs-testing-drivers/fixtures/databricks-jdbc.json b/packages/cubejs-testing-drivers/fixtures/databricks-jdbc.json
index 6c902ef2564e3..4d80e74c0b50f 100644
--- a/packages/cubejs-testing-drivers/fixtures/databricks-jdbc.json
+++ b/packages/cubejs-testing-drivers/fixtures/databricks-jdbc.json
@@ -73,7 +73,8 @@
       "CUBEJS_PG_SQL_PORT": "5656",
       "CUBEJS_SQL_USER": "admin",
       "CUBEJS_SQL_PASSWORD": "admin_password",
-      "CUBESQL_SQL_PUSH_DOWN": "true"
+      "CUBESQL_SQL_PUSH_DOWN": "true",
+      "CUBEJS_TESSERACT_SQL_PLANNER": "${DRIVERS_TESTS_CUBEJS_TESSERACT_SQL_PLANNER}"
     },
     "ports" : ["4000", "5656"]
   },
diff --git a/packages/cubejs-testing-drivers/fixtures/mssql.json b/packages/cubejs-testing-drivers/fixtures/mssql.json
index 767e07a0e3aa8..1a18eb928441f 100644
--- a/packages/cubejs-testing-drivers/fixtures/mssql.json
+++ b/packages/cubejs-testing-drivers/fixtures/mssql.json
@@ -11,7 +11,8 @@
       "CUBEJS_PG_SQL_PORT": "5656",
       "CUBEJS_SQL_USER": "admin",
       "CUBEJS_SQL_PASSWORD": "admin_password",
-      "CUBESQL_SQL_PUSH_DOWN": "true"
+      "CUBESQL_SQL_PUSH_DOWN": "true",
+      "CUBEJS_TESSERACT_SQL_PLANNER": "${DRIVERS_TESTS_CUBEJS_TESSERACT_SQL_PLANNER}"
     },
     "depends_on": ["data"],
     "links": ["data"],
diff --git a/packages/cubejs-testing-drivers/fixtures/mysql.json b/packages/cubejs-testing-drivers/fixtures/mysql.json
index 0e1f61a9edad5..3f378eb971eaa 100644
--- a/packages/cubejs-testing-drivers/fixtures/mysql.json
+++ b/packages/cubejs-testing-drivers/fixtures/mysql.json
@@ -12,7 +12,8 @@
       "CUBEJS_PG_SQL_PORT": "5656",
       "CUBEJS_SQL_USER": "admin",
       "CUBEJS_SQL_PASSWORD": "admin_password",
-      "CUBESQL_SQL_PUSH_DOWN": "true"
+      "CUBESQL_SQL_PUSH_DOWN": "true",
+      "CUBEJS_TESSERACT_SQL_PLANNER": "${DRIVERS_TESTS_CUBEJS_TESSERACT_SQL_PLANNER}"
     },
     "depends_on": ["data"],
     "links": ["data"],
diff --git a/packages/cubejs-testing-drivers/fixtures/postgres.json b/packages/cubejs-testing-drivers/fixtures/postgres.json
index df16d61ecc11f..0b6d6fa0a6606 100644
--- a/packages/cubejs-testing-drivers/fixtures/postgres.json
+++ b/packages/cubejs-testing-drivers/fixtures/postgres.json
@@ -12,7 +12,8 @@
       "CUBEJS_PG_SQL_PORT": "5656",
       "CUBEJS_SQL_USER": "admin",
       "CUBEJS_SQL_PASSWORD": "admin_password",
-      "CUBESQL_SQL_PUSH_DOWN": "true"
+      "CUBESQL_SQL_PUSH_DOWN": "true",
+      "CUBEJS_TESSERACT_SQL_PLANNER": "${DRIVERS_TESTS_CUBEJS_TESSERACT_SQL_PLANNER}"
     },
     "depends_on": ["data"],
     "links": ["data"],
diff --git a/packages/cubejs-testing-drivers/fixtures/redshift.json b/packages/cubejs-testing-drivers/fixtures/redshift.json
index 2351eee2cec17..82b6df3330c83 100644
--- a/packages/cubejs-testing-drivers/fixtures/redshift.json
+++ b/packages/cubejs-testing-drivers/fixtures/redshift.json
@@ -28,7 +28,8 @@
       "CUBEJS_PG_SQL_PORT": "5656",
       "CUBEJS_SQL_USER": "admin",
       "CUBEJS_SQL_PASSWORD": "admin_password",
-      "CUBESQL_SQL_PUSH_DOWN": "true"
+      "CUBESQL_SQL_PUSH_DOWN": "true",
+      "CUBEJS_TESSERACT_SQL_PLANNER": "${DRIVERS_TESTS_CUBEJS_TESSERACT_SQL_PLANNER}"
     },
     "ports" : ["4000", "5656"]
   },
diff --git a/packages/cubejs-testing-drivers/fixtures/snowflake.json b/packages/cubejs-testing-drivers/fixtures/snowflake.json
index 9a9c721abb6a0..cbed7a3cf985f 100644
--- a/packages/cubejs-testing-drivers/fixtures/snowflake.json
+++ b/packages/cubejs-testing-drivers/fixtures/snowflake.json
@@ -70,7 +70,8 @@
       "CUBEJS_PG_SQL_PORT": "5656",
       "CUBEJS_SQL_USER": "admin",
       "CUBEJS_SQL_PASSWORD": "admin_password",
-      "CUBESQL_SQL_PUSH_DOWN": "true"
+      "CUBESQL_SQL_PUSH_DOWN": "true",
+      "CUBEJS_TESSERACT_SQL_PLANNER": "${DRIVERS_TESTS_CUBEJS_TESSERACT_SQL_PLANNER}"
     },
     "ports" : ["4000", "5656"]
   },
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_query_options.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_query_options.rs
index da4ebe8da8c6b..94687ba9d1971 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_query_options.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_query_options.rs
@@ -63,6 +63,8 @@ pub struct BaseQueryOptionsStatic {
     pub export_annotated_sql: bool,
     #[serde(rename = "preAggregationQuery")]
     pub pre_aggregation_query: Option<bool>,
+    #[serde(rename = "totalQuery")]
+    pub total_query: Option<bool>,
 }
 
 #[nativebridge::native_bridge(BaseQueryOptionsStatic)]
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
index 3bfdb34a29907..99a5463bca518 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs
@@ -34,6 +34,8 @@ pub trait BaseTools {
         used_filters: Option<Vec<FilterItem>>,
     ) -> Result<Rc<dyn FilterGroup>, CubeError>;
     fn timestamp_precision(&self) -> Result<u32, CubeError>;
+    fn time_stamp_cast(&self, field: String) -> Result<String, CubeError>; //TODO move to templates
+    fn date_time_cast(&self, field: String) -> Result<String, CubeError>; //TODO move to templates
     fn in_db_time_zone(&self, date: String) -> Result<String, CubeError>;
     fn generate_time_series(
         &self,
@@ -47,6 +49,8 @@ pub trait BaseTools {
         origin: String,
     ) -> Result<Vec<Vec<String>>, CubeError>;
     fn get_allocated_params(&self) -> Result<Vec<String>, CubeError>;
+    fn subtract_interval(&self, date: String, interval: String) -> Result<String, CubeError>;
+    fn add_interval(&self, date: String, interval: String) -> Result<String, CubeError>;
     fn all_cube_members(&self, path: String) -> Result<Vec<String>, CubeError>;
     //===== TODO Move to templates
     fn hll_init(&self, sql: String) -> Result<String, CubeError>;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/builder.rs b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/builder.rs
index 695f1f1773131..ecb7539fcc9e6 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/builder.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/physical_plan_builder/builder.rs
@@ -16,6 +16,8 @@ use itertools::Itertools;
 use std::collections::HashMap;
 use std::collections::HashSet;
 use std::rc::Rc;
+const TOTAL_COUNT: &'static str = "total_count";
+const ORIGINAL_QUERY: &'static str = "original_query";
 
 #[derive(Clone, Debug)]
 struct PhysicalPlanBuilderContext {
@@ -56,7 +58,7 @@ pub struct PhysicalPlanBuilder {
 
 impl PhysicalPlanBuilder {
     pub fn new(query_tools: Rc<QueryTools>) -> Self {
-        let plan_sql_templates = PlanSqlTemplates::new(query_tools.templates_render());
+        let plan_sql_templates = query_tools.plan_sql_templates();
         Self {
             query_tools,
             plan_sql_templates,
@@ -67,10 +69,29 @@ impl PhysicalPlanBuilder {
         &self,
         logical_plan: Rc<Query>,
         original_sql_pre_aggregations: HashMap<String, String>,
+        total_query: bool,
     ) -> Result<Rc<Select>, CubeError> {
         let mut context = PhysicalPlanBuilderContext::default();
         context.original_sql_pre_aggregations = original_sql_pre_aggregations;
-        self.build_impl(logical_plan, &context)
+        let query = self.build_impl(logical_plan, &context)?;
+        let query = if total_query {
+            self.build_total_count(query, &context)?
+        } else {
+            query
+        };
+        Ok(query)
+    }
+
+    fn build_total_count(
+        &self,
+        source: Rc<Select>,
+        context: &PhysicalPlanBuilderContext,
+    ) -> Result<Rc<Select>, CubeError> {
+        let from = From::new_from_subselect(source.clone(), ORIGINAL_QUERY.to_string());
+        let mut select_builder = SelectBuilder::new(from);
+        select_builder.add_count_all(TOTAL_COUNT.to_string());
+        let context_factory = context.make_sql_nodes_factory();
+        Ok(Rc::new(select_builder.build(context_factory)))
     }
 
     fn build_impl(
@@ -957,7 +978,7 @@ impl PhysicalPlanBuilder {
             ));
         };
 
-        let templates = PlanSqlTemplates::new(self.query_tools.templates_render());
+        let templates = self.query_tools.plan_sql_templates();
 
         let ts_date_range = if templates.supports_generated_time_series() {
             if let Some(date_range) = time_dimension_symbol
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs
index ce1518295d22b..9e8bee36d67c5 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/builder/select.rs
@@ -75,6 +75,19 @@ impl SelectBuilder {
             .add_column(SchemaColumn::new(alias.clone(), Some(member.full_name())));
     }
 
+    pub fn add_count_all(&mut self, alias: String) {
+        let func = Expr::Function(FunctionExpression {
+            function: "COUNT".to_string(),
+            arguments: vec![Expr::Asterisk],
+        });
+        let aliased_expr = AliasedExpr {
+            expr: func,
+            alias: alias.clone(),
+        };
+        self.projection_columns.push(aliased_expr);
+        self.result_schema
+            .add_column(SchemaColumn::new(alias.clone(), None));
+    }
     pub fn add_projection_function_expression(
         &mut self,
         function: &str,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/expression.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/expression.rs
index 57fb6fae5d686..6dc16b08a1d00 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/expression.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/expression.rs
@@ -34,6 +34,7 @@ pub enum Expr {
     Member(MemberExpression),
     Reference(QualifiedColumnName),
     Function(FunctionExpression),
+    Asterisk,
 }
 
 impl Expr {
@@ -65,6 +66,7 @@ impl Expr {
                 None,
                 None,
             ),
+            Self::Asterisk => Ok("*".to_string()),
         }
     }
 }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs
index 5ce70d718f376..5998be84e3917 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/join.rs
@@ -52,7 +52,9 @@ impl RegularRollingWindowJoinCondition {
             };
 
             let trailing_start = if let Some(trailing_interval) = &self.trailing_interval {
-                format!("{start_date} - interval '{trailing_interval}'")
+                templates
+                    .base_tools()
+                    .subtract_interval(start_date, trailing_interval.clone())?
             } else {
                 start_date
             };
@@ -70,7 +72,9 @@ impl RegularRollingWindowJoinCondition {
             };
 
             let leading_end = if let Some(leading_interval) = &self.leading_interval {
-                format!("{end_date} + interval '{leading_interval}'")
+                templates
+                    .base_tools()
+                    .add_interval(end_date, leading_interval.clone())?
             } else {
                 end_date
             };
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/plan/time_series.rs b/rust/cubesqlplanner/cubesqlplanner/src/plan/time_series.rs
index 3b98f2d4f495d..f48dbfff2300b 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/plan/time_series.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/plan/time_series.rs
@@ -95,10 +95,13 @@ impl TimeSeries {
                 &self.granularity.granularity_interval(),
             )
         } else {
-            let (from_date, to_date) = match &self.date_range {
-                TimeSeriesDateRange::Filter(from_date, to_date) => {
-                    (format!("'{}'", from_date), format!("'{}'", to_date))
-                }
+            let (from_date, to_date, raw_from_date, raw_to_date) = match &self.date_range {
+                TimeSeriesDateRange::Filter(from_date, to_date) => (
+                    format!("'{}'", from_date),
+                    format!("'{}'", to_date),
+                    from_date.clone(),
+                    to_date.clone(),
+                ),
                 TimeSeriesDateRange::Generated(_) => {
                     return Err(CubeError::user(
                         "Date range is required for time series in drivers where generated time series is not supported".to_string(),
@@ -108,12 +111,12 @@ impl TimeSeries {
             let series = if self.granularity.is_predefined_granularity() {
                 self.query_tools.base_tools().generate_time_series(
                     self.granularity.granularity().clone(),
-                    vec![from_date.clone(), to_date.clone()],
+                    vec![raw_from_date.clone(), raw_to_date.clone()],
                 )?
             } else {
                 self.query_tools.base_tools().generate_custom_time_series(
                     self.granularity.granularity_interval().clone(),
-                    vec![from_date.clone(), to_date.clone()],
+                    vec![raw_from_date.clone(), raw_to_date.clone()],
                     self.granularity.origin_local_formatted(),
                 )?
             };
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
index 7a97412fcc31f..14651d0a4febf 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs
@@ -6,7 +6,6 @@ use crate::cube_bridge::pre_aggregation_obj::{NativePreAggregationObj, PreAggreg
 use crate::logical_plan::optimizers::*;
 use crate::logical_plan::Query;
 use crate::physical_plan_builder::PhysicalPlanBuilder;
-use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::wrappers::inner_types::InnerTypes;
 use cubenativeutils::wrappers::object::NativeArray;
 use cubenativeutils::wrappers::serializer::NativeSerialize;
@@ -79,7 +78,7 @@ impl<IT: InnerTypes> BaseQuery<IT> {
     }
 
     fn build_sql_and_params_impl(&self) -> Result<NativeObjectHandle<IT>, CubeError> {
-        let templates = PlanSqlTemplates::new(self.query_tools.templates_render());
+        let templates = self.query_tools.plan_sql_templates();
         let query_planner = QueryPlanner::new(self.request.clone(), self.query_tools.clone());
         let logical_plan = query_planner.plan()?;
 
@@ -92,8 +91,11 @@ impl<IT: InnerTypes> BaseQuery<IT> {
         } else {
             HashMap::new()
         };
-        let physical_plan =
-            physical_plan_builder.build(optimized_plan, original_sql_pre_aggregations)?;
+        let physical_plan = physical_plan_builder.build(
+            optimized_plan,
+            original_sql_pre_aggregations,
+            self.request.is_total_query(),
+        )?;
 
         let sql = physical_plan.to_sql(&templates)?;
         let (result_sql, params) = self.query_tools.build_sql_and_params(&sql, true)?;
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
index 60bbaffd262f1..aad4c13b1db62 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_filter.rs
@@ -271,7 +271,7 @@ impl BaseFilter {
         filters_context: &FiltersContext,
     ) -> Result<String, CubeError> {
         let use_db_time_zone = !filters_context.use_local_tz;
-        let (from, to) = self.allocate_date_params(use_db_time_zone)?;
+        let (from, to) = self.allocate_date_params(use_db_time_zone, false)?;
         self.templates
             .time_range_filter(member_sql.to_string(), from, to)
     }
@@ -282,7 +282,7 @@ impl BaseFilter {
         filters_context: &FiltersContext,
     ) -> Result<String, CubeError> {
         let use_db_time_zone = !filters_context.use_local_tz;
-        let (from, to) = self.allocate_date_params(use_db_time_zone)?;
+        let (from, to) = self.allocate_date_params(use_db_time_zone, false)?;
         self.templates
             .time_not_in_range_filter(member_sql.to_string(), from, to)
     }
@@ -293,7 +293,7 @@ impl BaseFilter {
         filters_context: &FiltersContext,
     ) -> Result<String, CubeError> {
         let use_db_time_zone = !filters_context.use_local_tz;
-        let value = self.first_timestamp_param(use_db_time_zone)?;
+        let value = self.first_timestamp_param(use_db_time_zone, false)?;
 
         self.templates.lt(member_sql.to_string(), value)
     }
@@ -304,7 +304,7 @@ impl BaseFilter {
         filters_context: &FiltersContext,
     ) -> Result<String, CubeError> {
         let use_db_time_zone = !filters_context.use_local_tz;
-        let value = self.first_timestamp_param(use_db_time_zone)?;
+        let value = self.first_timestamp_param(use_db_time_zone, false)?;
 
         self.templates.lte(member_sql.to_string(), value)
     }
@@ -315,7 +315,7 @@ impl BaseFilter {
         filters_context: &FiltersContext,
     ) -> Result<String, CubeError> {
         let use_db_time_zone = !filters_context.use_local_tz;
-        let value = self.first_timestamp_param(use_db_time_zone)?;
+        let value = self.first_timestamp_param(use_db_time_zone, false)?;
 
         self.templates.gt(member_sql.to_string(), value)
     }
@@ -326,7 +326,7 @@ impl BaseFilter {
         filters_context: &FiltersContext,
     ) -> Result<String, CubeError> {
         let use_db_time_zone = !filters_context.use_local_tz;
-        let value = self.first_timestamp_param(use_db_time_zone)?;
+        let value = self.first_timestamp_param(use_db_time_zone, false)?;
 
         self.templates.gte(member_sql.to_string(), value)
     }
@@ -340,9 +340,17 @@ impl BaseFilter {
         if let Some(interval) = interval {
             if interval != "unbounded" {
                 if is_sub {
-                    Ok(Some(self.templates.sub_interval(date, interval.clone())?))
+                    Ok(Some(
+                        self.query_tools
+                            .base_tools()
+                            .subtract_interval(date, interval.clone())?,
+                    ))
                 } else {
-                    Ok(Some(self.templates.add_interval(date, interval.clone())?))
+                    Ok(Some(
+                        self.query_tools
+                            .base_tools()
+                            .add_interval(date, interval.clone())?,
+                    ))
                 }
             } else {
                 Ok(None)
@@ -357,7 +365,7 @@ impl BaseFilter {
         member_sql: &str,
         _filters_context: &FiltersContext,
     ) -> Result<String, CubeError> {
-        let (from, to) = self.allocate_date_params(false)?;
+        let (from, to) = self.allocate_date_params(false, true)?;
 
         let from = if self.values.len() >= 3 {
             self.extend_date_range_bound(from, &self.values[2], true)?
@@ -392,7 +400,7 @@ impl BaseFilter {
         member_sql: &str,
         _filters_context: &FiltersContext,
     ) -> Result<String, CubeError> {
-        let (from, to) = self.allocate_date_params(false)?;
+        let (from, to) = self.allocate_date_params(false, true)?;
 
         let from = if self.values.len() >= 3 {
             if let Some(granularity) = &self.values[2] {
@@ -607,7 +615,11 @@ impl BaseFilter {
         Ok(res)
     }
 
-    fn allocate_date_params(&self, use_db_time_zone: bool) -> Result<(String, String), CubeError> {
+    fn allocate_date_params(
+        &self,
+        use_db_time_zone: bool,
+        as_date_time: bool,
+    ) -> Result<(String, String), CubeError> {
         if self.values.len() >= 2 {
             let from = if let Some(from_str) = &self.values[0] {
                 self.from_date_in_db_time_zone(from_str, use_db_time_zone)?
@@ -624,8 +636,8 @@ impl BaseFilter {
                     "Arguments for date range is not valid"
                 )));
             };
-            let from = self.allocate_timestamp_param(&from);
-            let to = self.allocate_timestamp_param(&to);
+            let from = self.allocate_timestamp_param(&from, as_date_time)?;
+            let to = self.allocate_timestamp_param(&to, as_date_time)?;
             Ok((from, to))
         } else {
             Err(CubeError::user(format!(
@@ -647,12 +659,20 @@ impl BaseFilter {
         self.query_tools.allocate_param(param)
     }
 
-    fn allocate_timestamp_param(&self, param: &str) -> String {
+    fn allocate_timestamp_param(
+        &self,
+        param: &str,
+        as_date_time: bool,
+    ) -> Result<String, CubeError> {
         if self.use_raw_values {
-            return param.to_string();
+            return Ok(param.to_string());
         }
         let placeholder = self.query_tools.allocate_param(param);
-        format!("{}::timestamptz", placeholder)
+        if as_date_time {
+            self.query_tools.base_tools().date_time_cast(placeholder)
+        } else {
+            self.query_tools.base_tools().time_stamp_cast(placeholder)
+        }
     }
 
     fn first_param(&self) -> Result<String, CubeError> {
@@ -669,16 +689,21 @@ impl BaseFilter {
         }
     }
 
-    fn first_timestamp_param(&self, use_db_time_zone: bool) -> Result<String, CubeError> {
+    fn first_timestamp_param(
+        &self,
+        use_db_time_zone: bool,
+        as_date_time: bool,
+    ) -> Result<String, CubeError> {
         if self.values.is_empty() {
             Err(CubeError::user(format!(
                 "Expected at least one parameter but nothing found"
             )))
         } else {
             if let Some(value) = &self.values[0] {
-                Ok(self.allocate_timestamp_param(
+                self.allocate_timestamp_param(
                     &self.from_date_in_db_time_zone(value, use_db_time_zone)?,
-                ))
+                    as_date_time,
+                )
             } else {
                 return Err(CubeError::user(format!(
                     "Arguments for timestamp parameter for operator {} is not valid",
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs
index 9874e0af99a75..b7b860c262d82 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/dimension_subquery_planner.rs
@@ -106,6 +106,7 @@ impl DimensionSubqueryPlanner {
             true,
             false,
             false,
+            false,
         )?;
         let query_planner = QueryPlanner::new(sub_query_properties, self.query_tools.clone());
         let sub_query = query_planner.plan()?;
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 c9801a96967d7..b1a8a25f1a42c 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
@@ -72,6 +72,7 @@ impl MultiStageMemberQueryPlanner {
             true,
             true,
             false,
+            false,
         )?;
 
         let simple_query_planer =
@@ -264,6 +265,7 @@ impl MultiStageMemberQueryPlanner {
             true,
             self.description.member().is_ungrupped(),
             false,
+            false,
         )?;
 
         let query_planner =
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/rolling_window_planner.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/rolling_window_planner.rs
index 07657cd9e92a2..094f5a64cf6dc 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/rolling_window_planner.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/planners/multi_stage/rolling_window_planner.rs
@@ -6,7 +6,7 @@ use super::{
 use crate::cube_bridge::measure_definition::RollingWindow;
 use crate::planner::query_tools::QueryTools;
 use crate::planner::sql_evaluator::MemberSymbol;
-use crate::planner::sql_templates::{PlanSqlTemplates, TemplateProjectionColumn};
+use crate::planner::sql_templates::TemplateProjectionColumn;
 use crate::planner::BaseMeasure;
 use crate::planner::{BaseMember, BaseTimeDimension, GranularityHelper, QueryProperties};
 use cubenativeutils::CubeError;
@@ -262,7 +262,7 @@ impl RollingWindowPlanner {
         &self,
         time_series_cte_name: &str,
     ) -> Result<(String, String), CubeError> {
-        let templates = PlanSqlTemplates::new(self.query_tools.templates_render());
+        let templates = self.query_tools.plan_sql_templates();
         let from_expr = format!("min(date_from)");
         let to_expr = format!("max(date_to)");
         let alias = format!("value");
@@ -324,7 +324,7 @@ impl RollingWindowPlanner {
             &time_dimension.resolve_granularity()?,
         )?;
 
-        let templates = PlanSqlTemplates::new(self.query_tools.templates_render());
+        let templates = self.query_tools.plan_sql_templates();
 
         if templates.supports_generated_time_series() {
             let (from, to) =
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
index bf57932c16237..15e8ab826b39b 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_properties.rs
@@ -78,6 +78,7 @@ pub struct QueryProperties {
     ungrouped: bool,
     multi_fact_join_groups: Vec<(Rc<dyn JoinDefinition>, Vec<Rc<BaseMeasure>>)>,
     pre_aggregation_query: bool,
+    total_query: bool,
 }
 
 impl QueryProperties {
@@ -269,9 +270,18 @@ impl QueryProperties {
             order
                 .iter()
                 .map(|o| -> Result<_, CubeError> {
-                    let member_evaluator =
-                        evaluator_compiler.add_auto_resolved_member_evaluator(o.id.clone())?;
-                    Ok(OrderByItem::new(member_evaluator, o.is_desc()))
+                    let evaluator = if let Some(found) =
+                        dimensions.iter().find(|d| d.name() == &o.id)
+                    {
+                        found.member_evaluator().clone()
+                    } else if let Some(found) = time_dimensions.iter().find(|d| d.name() == &o.id) {
+                        found.member_evaluator().clone()
+                    } else if let Some(found) = measures.iter().find(|d| d.name() == &o.id) {
+                        found.member_evaluator().clone()
+                    } else {
+                        evaluator_compiler.add_auto_resolved_member_evaluator(o.id.clone())?
+                    };
+                    Ok(OrderByItem::new(evaluator, o.is_desc()))
                 })
                 .collect::<Result<Vec<_>, _>>()?
         } else {
@@ -302,6 +312,7 @@ impl QueryProperties {
         )?;
 
         let pre_aggregation_query = options.static_data().pre_aggregation_query.unwrap_or(false);
+        let total_query = options.static_data().total_query.unwrap_or(false);
 
         Ok(Rc::new(Self {
             measures,
@@ -319,6 +330,7 @@ impl QueryProperties {
             ungrouped,
             multi_fact_join_groups,
             pre_aggregation_query,
+            total_query,
         }))
     }
 
@@ -337,6 +349,7 @@ impl QueryProperties {
         ignore_cumulative: bool,
         ungrouped: bool,
         pre_aggregation_query: bool,
+        total_query: bool,
     ) -> Result<Rc<Self>, CubeError> {
         let order_by = if order_by.is_empty() {
             Self::default_order(&dimensions, &time_dimensions, &measures)
@@ -371,6 +384,7 @@ impl QueryProperties {
             ungrouped,
             multi_fact_join_groups,
             pre_aggregation_query,
+            total_query,
         }))
     }
 
@@ -390,6 +404,10 @@ impl QueryProperties {
         )
     }
 
+    pub fn is_total_query(&self) -> bool {
+        self.total_query
+    }
+
     pub fn compute_join_multi_fact_groups(
         query_tools: Rc<QueryTools>,
         measures: &Vec<Rc<BaseMeasure>>,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_tools.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_tools.rs
index 93916af991a2b..2ab26de23d7d5 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/query_tools.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/query_tools.rs
@@ -13,8 +13,6 @@ use crate::planner::sql_templates::PlanSqlTemplates;
 use chrono_tz::Tz;
 use cubenativeutils::CubeError;
 use itertools::Itertools;
-use lazy_static::lazy_static;
-use regex::Regex;
 use std::cell::{Ref, RefCell, RefMut};
 use std::collections::HashMap;
 use std::rc::Rc;
@@ -146,7 +144,7 @@ impl QueryTools {
             cube_evaluator.clone(),
             timezone.clone(),
         )));
-        let sql_templates = PlanSqlTemplates::new(templates_render.clone());
+        let sql_templates = PlanSqlTemplates::new(templates_render.clone(), base_tools.clone());
         Ok(Rc::new(Self {
             cube_evaluator,
             base_tools,
@@ -166,6 +164,10 @@ impl QueryTools {
         &self.cube_evaluator
     }
 
+    pub fn plan_sql_templates(&self) -> PlanSqlTemplates {
+        PlanSqlTemplates::new(self.templates_render.clone(), self.base_tools.clone())
+    }
+
     pub fn base_tools(&self) -> &Rc<dyn BaseTools> {
         &self.base_tools
     }
@@ -194,10 +196,6 @@ impl QueryTools {
         PlanSqlTemplates::alias_name(name)
     }
 
-    pub fn escaped_alias_name(&self, name: &str) -> String {
-        self.escape_column_name(&self.alias_name(name))
-    }
-
     pub fn cube_alias_name(&self, name: &str, prefix: &Option<String>) -> String {
         if let Some(prefix) = prefix {
             self.alias_name(&format!("{}__{}", prefix, self.alias_name(name)))
@@ -218,21 +216,6 @@ impl QueryTools {
         }
     }
 
-    pub fn auto_prefix_with_cube_name(&self, cube_name: &str, sql: &str) -> String {
-        lazy_static! {
-            static ref SINGLE_MEMBER_RE: Regex = Regex::new(r"^[_a-zA-Z][_a-zA-Z0-9]*$").unwrap();
-        }
-        if SINGLE_MEMBER_RE.is_match(sql) {
-            format!(
-                "{}.{}",
-                self.escape_column_name(&self.cube_alias_name(&cube_name, &None)),
-                sql
-            )
-        } else {
-            sql.to_string()
-        }
-    }
-
     pub fn alias_for_cube(&self, cube_name: &String) -> Result<String, CubeError> {
         let cube_definition = self.cube_evaluator().cube_from_path(cube_name.clone())?;
         let res = if let Some(sql_alias) = &cube_definition.static_data().sql_alias {
@@ -243,10 +226,6 @@ impl QueryTools {
         Ok(res)
     }
 
-    pub fn escape_column_name(&self, column_name: &str) -> String {
-        format!("\"{}\"", column_name)
-    }
-
     pub fn templates_render(&self) -> Rc<dyn SqlTemplatesRender> {
         self.templates_render.clone()
     }
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/auto_prefix.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/auto_prefix.rs
index 20d0aab127f12..aa2ff4657e3fa 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/auto_prefix.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/auto_prefix.rs
@@ -5,6 +5,8 @@ use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_evaluator::SqlEvaluatorVisitor;
 use crate::planner::sql_templates::PlanSqlTemplates;
 use cubenativeutils::CubeError;
+use lazy_static::lazy_static;
+use regex::Regex;
 use std::any::Any;
 use std::collections::HashMap;
 use std::rc::Rc;
@@ -55,6 +57,27 @@ impl AutoPrefixSqlNode {
             name.clone()
         }
     }
+
+    pub fn auto_prefix_with_cube_name(
+        &self,
+        cube_name: &str,
+        sql: &str,
+        templates: &PlanSqlTemplates,
+    ) -> Result<String, CubeError> {
+        lazy_static! {
+            static ref SINGLE_MEMBER_RE: Regex = Regex::new(r"^[_a-zA-Z][_a-zA-Z0-9]*$").unwrap();
+        }
+        let res = if SINGLE_MEMBER_RE.is_match(sql) {
+            format!(
+                "{}.{}",
+                templates.quote_identifier(&PlanSqlTemplates::alias_name(&cube_name))?,
+                sql
+            )
+        } else {
+            sql.to_string()
+        };
+        Ok(res)
+    }
 }
 
 impl SqlNode for AutoPrefixSqlNode {
@@ -76,15 +99,15 @@ impl SqlNode for AutoPrefixSqlNode {
         let res = match node.as_ref() {
             MemberSymbol::Dimension(ev) => {
                 let cube_alias = self.resolve_cube_alias(&ev.cube_name());
-                query_tools.auto_prefix_with_cube_name(&cube_alias, &input)
+                self.auto_prefix_with_cube_name(&cube_alias, &input, templates)?
             }
             MemberSymbol::Measure(ev) => {
                 let cube_alias = self.resolve_cube_alias(&ev.cube_name());
-                query_tools.auto_prefix_with_cube_name(&cube_alias, &input)
+                self.auto_prefix_with_cube_name(&cube_alias, &input, templates)?
             }
             MemberSymbol::CubeName(_) => {
                 let cube_alias = self.resolve_cube_alias(&input);
-                query_tools.escape_column_name(&cube_alias)
+                templates.quote_identifier(&cube_alias)?
             }
             _ => input,
         };
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs
index 9e14eddda76ea..ff3b92f56615c 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/evaluate_sql.rs
@@ -25,12 +25,15 @@ impl SqlNode for EvaluateSqlNode {
         templates: &PlanSqlTemplates,
     ) -> Result<String, CubeError> {
         match node.as_ref() {
-            MemberSymbol::Dimension(ev) => ev.evaluate_sql(
-                visitor,
-                node_processor.clone(),
-                query_tools.clone(),
-                templates,
-            ),
+            MemberSymbol::Dimension(ev) => {
+                let res = ev.evaluate_sql(
+                    visitor,
+                    node_processor.clone(),
+                    query_tools.clone(),
+                    templates,
+                )?;
+                Ok(res)
+            }
             MemberSymbol::TimeDimension(ev) => {
                 let res = visitor.apply(&ev.base_symbol(), node_processor.clone(), templates)?;
                 Ok(res)
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/final_pre_aggregation_measure.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/final_pre_aggregation_measure.rs
index e15adf8e57c4f..f1bf73c76115b 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/final_pre_aggregation_measure.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/final_pre_aggregation_measure.rs
@@ -39,14 +39,15 @@ impl SqlNode for FinalPreAggregationMeasureSqlNode {
         let res = match node.as_ref() {
             MemberSymbol::Measure(ev) => {
                 if let Some(reference) = self.references.get(&node.full_name()) {
-                    let table_ref = reference.source().as_ref().map_or_else(
-                        || format!(""),
-                        |table_name| format!("{}.", query_tools.escape_column_name(table_name)),
-                    );
+                    let table_ref = if let Some(table_name) = reference.source() {
+                        format!("{}.", templates.quote_identifier(table_name)?)
+                    } else {
+                        format!("")
+                    };
                     let pre_aggregation_measure = format!(
                         "{}{}",
                         table_ref,
-                        query_tools.escape_column_name(&reference.name())
+                        templates.quote_identifier(&reference.name())?
                     );
                     if ev.measure_type() == "count" || ev.measure_type() == "sum" {
                         format!("sum({})", pre_aggregation_measure)
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/render_references.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/render_references.rs
index 0b3b6934533cd..d9ef51d302af8 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/render_references.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/render_references.rs
@@ -38,14 +38,15 @@ impl SqlNode for RenderReferencesSqlNode {
     ) -> Result<String, CubeError> {
         let full_name = node.full_name();
         if let Some(reference) = self.references.get(&full_name) {
-            let table_ref = reference.source().as_ref().map_or_else(
-                || format!(""),
-                |table_name| format!("{}.", query_tools.escape_column_name(table_name)),
-            );
+            let table_ref = if let Some(table_name) = reference.source() {
+                format!("{}.", templates.quote_identifier(table_name)?)
+            } else {
+                format!("")
+            };
             Ok(format!(
                 "{}{}",
                 table_ref,
-                query_tools.escape_column_name(&reference.name())
+                templates.quote_identifier(&reference.name())?
             ))
         } else {
             self.input.to_sql(
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/time_dimension.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/time_dimension.rs
index 284127a82c353..56413bd0f4a99 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/time_dimension.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/time_dimension.rs
@@ -55,13 +55,16 @@ impl SqlNode for TimeDimensionNode {
 
                     let res = if granularity_obj.is_natural_aligned() {
                         if let Some(granularity_offset) = granularity_obj.granularity_offset() {
-                            let dt =
-                                templates.sub_interval(converted_tz, granularity_offset.clone())?;
+                            let dt = query_tools
+                                .base_tools()
+                                .subtract_interval(converted_tz, granularity_offset.clone())?;
                             let dt = query_tools.base_tools().time_grouped_column(
                                 granularity_obj.granularity_from_interval()?,
                                 dt,
                             )?;
-                            templates.add_interval(dt, granularity_offset.clone())?
+                            query_tools
+                                .base_tools()
+                                .add_interval(dt, granularity_offset.clone())?
                         } else {
                             query_tools.base_tools().time_grouped_column(
                                 granularity_obj.granularity().clone(),
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/filter.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/filter.rs
index 3ab58c46e2815..4381851f60a7b 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/filter.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/filter.rs
@@ -120,26 +120,6 @@ 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",
@@ -227,7 +207,7 @@ impl FilterTemplates {
             },
         )?;
         self.render.render_template(
-            &"expressions/ilike",
+            &"tesseract/ilike",
             context! {
                 expr => column,
                 negated => not,
diff --git a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/plan.rs b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/plan.rs
index df0c6cdf2cb9d..daeeb6192dfef 100644
--- a/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/plan.rs
+++ b/rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/plan.rs
@@ -1,4 +1,5 @@
 use super::{TemplateGroupByColumn, TemplateOrderByColumn, TemplateProjectionColumn};
+use crate::cube_bridge::base_tools::BaseTools;
 use crate::cube_bridge::sql_templates_render::SqlTemplatesRender;
 use crate::plan::join::JoinType;
 use convert_case::{Boundary, Case, Casing};
@@ -9,6 +10,7 @@ use std::rc::Rc;
 #[derive(Clone)]
 pub struct PlanSqlTemplates {
     render: Rc<dyn SqlTemplatesRender>,
+    base_tools: Rc<dyn BaseTools>,
 }
 pub const UNDERSCORE_UPPER_BOUND: Boundary = Boundary {
     name: "LowerUpper",
@@ -24,8 +26,8 @@ pub const UNDERSCORE_UPPER_BOUND: Boundary = Boundary {
 };
 
 impl PlanSqlTemplates {
-    pub fn new(render: Rc<dyn SqlTemplatesRender>) -> Self {
-        Self { render }
+    pub fn new(render: Rc<dyn SqlTemplatesRender>, base_tools: Rc<dyn BaseTools>) -> Self {
+        Self { render, base_tools }
     }
 
     pub fn alias_name(name: &str) -> String {
@@ -41,6 +43,10 @@ impl PlanSqlTemplates {
         res
     }
 
+    pub fn base_tools(&self) -> &Rc<dyn BaseTools> {
+        &self.base_tools
+    }
+
     pub fn memeber_alias_name(cube_name: &str, name: &str, suffix: &Option<String>) -> String {
         let suffix = if let Some(suffix) = suffix {
             format!("_{}", suffix)
@@ -55,27 +61,6 @@ impl PlanSqlTemplates {
         )
     }
 
-    //FIXME duplicated with filter templates
-    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 quote_string(&self, string: &str) -> Result<String, CubeError> {
         Ok(format!("'{}'", string))
     }