feat(tesseract): Switch dimensions and case measures

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

@@ -3232,6 +3232,9 @@ export class BaseQuery {
         }
         if (symbol.case) {
           return this.renderDimensionCase(symbol, cubeName);
+        } else if (symbol.type === 'switch') {
+          // Dimension of type switch is not supported in BaseQuery, return an empty string to make dependency resolution work.
+          return '';
         } else if (symbol.type === 'geo') {
           return this.concatStringsSql([
             this.autoPrefixAndEvaluateSql(cubeName, symbol.latitude.sql, isMemberExpr),
@@ -4210,7 +4213,17 @@ export class BaseQuery {
         time_series_get_range: 'SELECT {{ max_expr }} as {{ quoted_max_name }},\n' +
           '{{ min_expr }} as {{ quoted_min_name }}\n' +
           'FROM {{ from_prepared }}\n' +
-          '{% if filter %}WHERE {{ filter }}{% endif %}'
+          '{% if filter %}WHERE {{ filter }}{% endif %}',
+        calc_groups_join: '{% if original_sql %}{{ original_sql }}\n{% endif %}' +
+        '{% for group in groups  %}' +
+        '{% if original_sql or not loop.first %}CROSS JOIN\n{% endif %}' +
+        '(\n' +
+        '{% for value in group.values  %}' +
+        'SELECT {{ value }} as {{ group.name }}' +
+        '{% if not loop.last %} UNION ALL\n{% endif %}' +
+        '{% endfor %}' +
+        ') AS {{ group.alias }}\n' +
+        '{% endfor %}'
       },
       expressions: {
         column_reference: '{% if table_name %}{{ table_name }}.{% endif %}{{ name }}',

packages/cubejs-schema-compiler/src/compiler/CubeEvaluator.ts

@@ -547,6 +547,9 @@ export class CubeEvaluator extends CubeSymbols {
       let aliasMember;
 
       const member = members[memberName];
+      if (member.type === 'switch' || member.multiStage) {
+        ownedByCube = false;
+      }
       if (member.sql && !member.subQuery) {
         const funcArgs = this.funcArguments(member.sql);
         const { cubeReferencesUsed, evaluatedSql, pathReferencesUsed } = this.collectUsedCubeReferences(cube.name, member.sql);

packages/cubejs-schema-compiler/src/compiler/CubeValidator.ts

@@ -132,6 +132,11 @@ const BaseDimensionWithoutSubQuery = {
   enableSuggestions: Joi.boolean().strict(),
   format: formatSchema,
   meta: Joi.any(),
+  values: Joi.when('type', {
+    is: 'switch',
+    then: Joi.array().items(Joi.string()),
+    otherwise: Joi.forbidden()
+  }),
   granularities: Joi.when('type', {
     is: 'time',
     then: Joi.object().pattern(identifierRegex,
@@ -583,13 +588,50 @@ const timeShiftItemOptional = Joi.object({
   .xor('name', 'interval')
   .and('interval', 'type');
 
+const CaseSchema = Joi.object().keys({
+  when: Joi.array().items(Joi.object().keys({
+    sql: Joi.func().required(),
+    label: Joi.alternatives([
+      Joi.string(),
+      Joi.object().keys({
+        sql: Joi.func().required()
+      })
+    ])
+  })),
+  else: Joi.object().keys({
+    label: Joi.alternatives([
+      Joi.string(),
+      Joi.object().keys({
+        sql: Joi.func().required()
+      })
+    ])
+  })
+}).required();
+
+const SwitchCaseSchema = Joi.object().keys({
+  switch: Joi.func().required(),
+  when: Joi.array().items(Joi.object().keys({
+    value: Joi.string().required(),
+    sql: Joi.func().required()
+  })),
+  else: Joi.object().keys({
+    sql: Joi.func().required()
+  })
+}).required();
+
+const CaseVariants = Joi.alternatives().try(
+  CaseSchema,
+  SwitchCaseSchema
+);
+
 const MeasuresSchema = Joi.object().pattern(identifierRegex, Joi.alternatives().conditional(Joi.ref('.multiStage'), [
   {
     is: true,
     then: inherit(BaseMeasure, {
       multiStage: Joi.boolean().strict(),
       type: multiStageMeasureType.required(),
       sql: Joi.func(), // TODO .required(),
+      case: CaseVariants,
       groupBy: Joi.func(),
       reduceBy: Joi.func(),
       addGroupBy: Joi.func(),
@@ -647,53 +689,45 @@ const CalendarTimeShiftItem = Joi.alternatives().try(
   })
 );
 
-const DimensionsSchema = Joi.object().pattern(identifierRegex, Joi.alternatives().try(
-  inherit(BaseDimensionWithoutSubQuery, {
-    case: Joi.object().keys({
-      when: Joi.array().items(Joi.object().keys({
-        sql: Joi.func().required(),
-        label: Joi.alternatives([
-          Joi.string(),
-          Joi.object().keys({
-            sql: Joi.func().required()
-          })
-        ])
-      })),
-      else: Joi.object().keys({
-        label: Joi.alternatives([
-          Joi.string(),
-          Joi.object().keys({
-            sql: Joi.func().required()
-          })
-        ])
-      })
-    }).required()
-  }),
-  inherit(BaseDimensionWithoutSubQuery, {
-    latitude: Joi.object().keys({
-      sql: Joi.func().required()
-    }).required(),
-    longitude: Joi.object().keys({
-      sql: Joi.func().required()
-    }).required()
-  }),
-  inherit(BaseDimension, {
-    sql: Joi.func().required(),
-  }),
-  inherit(BaseDimension, {
-    multiStage: Joi.boolean().valid(true),
-    type: Joi.any().valid('number').required(),
-    sql: Joi.func().required(),
-    addGroupBy: Joi.func(),
-  }),
-  // TODO should be valid only for calendar cubes, but this requires significant refactoring
-  // of all schemas. Left for the future when we'll switch to zod.
-  inherit(BaseDimensionWithoutSubQuery, {
-    type: Joi.any().valid('time').required(),
-    sql: Joi.func().required(),
-    timeShift: Joi.array().items(CalendarTimeShiftItem),
-  })
-));
+const SwitchDimension = Joi.object({
+  type: Joi.string().valid('switch').required(),
+  values: Joi.array().items(Joi.string()).min(1).required()
+});
+
+const DimensionsSchema = Joi.object().pattern(identifierRegex, Joi.alternatives().conditional(Joi.ref('.type'), {
+  is: 'switch',
+  then: SwitchDimension,
+  otherwise: Joi.alternatives().try(
+    inherit(BaseDimensionWithoutSubQuery, {
+      case: CaseVariants.required(),
+      multiStage: Joi.boolean().strict(),
+    }),
+    inherit(BaseDimensionWithoutSubQuery, {
+      latitude: Joi.object().keys({
+        sql: Joi.func().required()
+      }).required(),
+      longitude: Joi.object().keys({
+        sql: Joi.func().required()
+      }).required()
+    }),
+    inherit(BaseDimension, {
+      sql: Joi.func().required(),
+    }),
+    inherit(BaseDimension, {
+      multiStage: Joi.boolean().valid(true),
+      type: Joi.any().valid('number').required(),
+      sql: Joi.func().required(),
+      addGroupBy: Joi.func(),
+    }),
+    // TODO should be valid only for calendar cubes, but this requires significant refactoring
+    // of all schemas. Left for the future when we'll switch to zod.
+    inherit(BaseDimensionWithoutSubQuery, {
+      type: Joi.any().valid('time').required(),
+      sql: Joi.func().required(),
+      timeShift: Joi.array().items(CalendarTimeShiftItem),
+    })
+  )
+}));
 
 const SegmentsSchema = Joi.object().pattern(identifierRegex, Joi.object().keys({
   aliases: Joi.array().items(Joi.string()),

packages/cubejs-schema-compiler/src/compiler/transpilers/CubePropContextTranspiler.ts

@@ -19,6 +19,7 @@ export const transpiledFieldsPatterns: Array<RegExp> = [
   /^measures\.[_a-zA-Z][_a-zA-Z0-9]*\.(orderBy|order_by)\.[0-9]+\.sql$/,
   /^measures\.[_a-zA-Z][_a-zA-Z0-9]*\.(timeShift|time_shift)\.[0-9]+\.(timeDimension|time_dimension)$/,
   /^measures\.[_a-zA-Z][_a-zA-Z0-9]*\.(reduceBy|reduce_by|groupBy|group_by|addGroupBy|add_group_by)$/,
+  /^(measures|dimensions)\.[_a-zA-Z][_a-zA-Z0-9]*\.case\.switch$/,
   /^dimensions\.[_a-zA-Z][_a-zA-Z0-9]*\.(reduceBy|reduce_by|groupBy|group_by|addGroupBy|add_group_by)$/,
   /^(preAggregations|pre_aggregations)\.[_a-zA-Z][_a-zA-Z0-9]*\.indexes\.[_a-zA-Z][_a-zA-Z0-9]*\.columns$/,
   /^(preAggregations|pre_aggregations)\.[_a-zA-Z][_a-zA-Z0-9]*\.(timeDimensionReference|timeDimension|time_dimension|segments|dimensions|measures|rollups|segmentReferences|dimensionReferences|measureReferences|rollupReferences)$/,