fix

Author: waralexrom

packages/cubejs-schema-compiler/src/adapter/BaseQuery.js

@@ -4214,23 +4214,23 @@ export class BaseQuery {
           '{{ min_expr }} as {{ quoted_min_name }}\n' +
           'FROM {{ from_prepared }}\n' +
           '{% if filter %}WHERE {{ filter }}{% endif %}',
-        calc_groups_join: 'SELECT "{{ original_cube }}".*, ' +
+        calc_groups_join: 'SELECT {{ original_cube }}.*, ' +
         '{%for single_value in single_values %}' +
-        '\'{{ single_value.value }}\' as "{{ single_value.name }}"{% if not loop.last %}, {% endif %}' +
+        '{{ single_value.value }} as {{ single_value.name }}{% if not loop.last %}, {% endif %}' +
         '{% endfor %}' +
         '{% if single_values and groups %}, {% endif %}' +
         '{%for group in groups %}' +
-        '"{{ group.name }}"{% if not loop.last %}, {% endif %}' +
+        '{{ group.name }}{% if not loop.last %}, {% endif %}' +
         '{% endfor %}' +
         'FROM {{ original_cube_sql }} {{ original_cube }}\n' +
         '{% for group in groups  %}' +
         'CROSS JOIN\n' +
         '(\n' +
         '{% for value in group.values  %}' +
-        'SELECT \'{{ value }}\' as "{{ group.name }}"' +
+        'SELECT {{ value }} as {{ group.name }}' +
         '{% if not loop.last %} UNION ALL\n{% endif %}' +
         '{% endfor %}' +
-        ') "{{ group.name }}_values"\n' +
+        ') {{ group.alias }}\n' +
         '{% endfor %}'
       },
       expressions: {

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_evaluator/sql_nodes/cube_calc_groups.rs

@@ -72,27 +72,21 @@ impl SqlNode for CubeCalcGroupsSqlNode {
             MemberSymbol::CubeTable(ev) => {
                 let res = if let Some(calc_groups) = self.items.get(ev.cube_name()) {
                     let mut single_values = vec![];
-                    let mut groups = vec![];
+                    let mut template_groups = vec![];
                     for calc_group in calc_groups {
                         if calc_group.values.len() == 1 {
                             single_values.push(TemplateCalcSingleValue {
                                 name: calc_group.name.clone(),
                                 value: calc_group.values[0].clone(),
                             })
                         } else {
-                            groups.push(TemplateCalcGroup {
+                            template_groups.push(TemplateCalcGroup {
                                 name: calc_group.name.clone(),
+                                alias: format!("{}_values", calc_group.name),
                                 values: calc_group.values.clone(),
                             })
                         }
                     }
-                    let template_groups = groups
-                        .iter()
-                        .map(|group| TemplateCalcGroup {
-                            name: group.name.clone(),
-                            values: group.values.clone(),
-                        })
-                        .collect_vec();
                     let res = templates.calc_groups_join(
                         &ev.cube_name(),
                         &input,

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/plan.rs

@@ -355,6 +355,38 @@ impl PlanSqlTemplates {
         single_values: Vec<TemplateCalcSingleValue>,
         groups: Vec<TemplateCalcGroup>,
     ) -> Result<String, CubeError> {
+        let original_cube = self.quote_identifier(original_cube)?;
+        let single_values = single_values
+            .into_iter()
+            .map(|v| -> Result<_, CubeError> {
+                Ok(TemplateCalcSingleValue {
+                    value: self.quote_string(&v.value)?,
+                    name: self.quote_identifier(&v.name)?,
+                })
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        let groups = groups
+            .into_iter()
+            .map(|g| -> Result<_, CubeError> {
+                let TemplateCalcGroup {
+                    name,
+                    alias,
+                    values,
+                } = g;
+                let name = self.quote_identifier(&name)?;
+                let alias = self.quote_identifier(&alias)?;
+                let values = values
+                    .into_iter()
+                    .map(|v| self.quote_string(&v))
+                    .collect::<Result<Vec<_>, _>>()?;
+
+                Ok(TemplateCalcGroup {
+                    name,
+                    alias,
+                    values,
+                })
+            })
+            .collect::<Result<Vec<_>, _>>()?;
         self.render.render_template(
             "statements/calc_groups_join",
             context! {

rust/cubesqlplanner/cubesqlplanner/src/planner/sql_templates/structs.rs

@@ -21,6 +21,7 @@ pub struct TemplateOrderByColumn {
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct TemplateCalcGroup {
     pub name: String,
+    pub alias: String,
     pub values: Vec<String>,
 }