case expression

Author: waralexrom

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

@@ -678,10 +678,7 @@ const CaseSchema = Joi.object().keys({
 }).required();
 
 const SwitchCaseSchema = Joi.object().keys({
-  switch: Joi.alternatives([
-    Joi.string(),
-    Joi.func()
-  ]).required(),
+  switch: Joi.func().required(),
   when: Joi.array().items(Joi.object().keys({
     value: Joi.string().required(),
     sql: Joi.func().required()

packages/cubejs-schema-compiler/test/integration/postgres/calc-groups.test.ts

@@ -51,23 +51,23 @@ cubes:
           - EUR
           - GBP
 
-      - name: test
+      - name: strategy
+        type: switch
+        values:
+          - A
+          - B
+
+      - name: currency_full_name
         type: string
         case:
-          switch: "{CUBE}.currency"
+          switch: "{CUBE.currency}"
           when:
             - value: USD
-              sql: "'111'"
+              sql: "'dollars'"
             - value: EUR
-              sql: "'333'"
+              sql: "'euros'"
           else:
-            sql: "'def'"
-
-      - name: strategy
-        type: switch
-        values:
-          - A
-          - B
+            sql: "'unknown'"
 
     measures:
       - name: count
@@ -460,13 +460,14 @@ views:
     ],
     { joinGraph, cubeEvaluator, compiler }));
 
-    it('measure switch', async () => dbRunner.runQueryTest({
-      dimensions: ['orders.currency', 'orders.test'],
+    it('dimension switch expression simple', async () => dbRunner.runQueryTest({
+      dimensions: ['orders.currency', 'orders.currency_full_name'],
       measures: ['orders.revenue'],
       timeDimensions: [
         {
           dimension: 'orders.date',
-          granularity: 'year'
+          granularity: 'year',
+          dateRange: ['2024-01-01', '2026-01-01']
         }
       ],
       timezone: 'UTC',
@@ -477,27 +478,43 @@ views:
       },
       ],
     }, [
-      {
-        orders__date_year: '2022-01-01T00:00:00.000Z',
-        orders__strategy: 'B',
-        orders__revenue: '5',
-      },
-      {
-        orders__date_year: '2023-01-01T00:00:00.000Z',
-        orders__strategy: 'B',
-        orders__revenue: '15',
-      },
-      {
-        orders__date_year: '2024-01-01T00:00:00.000Z',
-        orders__strategy: 'B',
-        orders__revenue: '30',
-      },
-      {
-        orders__date_year: '2025-01-01T00:00:00.000Z',
-        orders__strategy: 'B',
-        orders__revenue: '5',
-      }
-    ],
+        {
+          orders__currency: 'EUR',
+          orders__currency_full_name: 'euros',
+          orders__date_year: '2024-01-01T00:00:00.000Z',
+          orders__revenue: '30'
+        },
+        {
+          orders__currency: 'GBP',
+          orders__currency_full_name: 'unknown',
+          orders__date_year: '2024-01-01T00:00:00.000Z',
+          orders__revenue: '30'
+        },
+        {
+          orders__currency: 'USD',
+          orders__currency_full_name: 'dollars',
+          orders__date_year: '2024-01-01T00:00:00.000Z',
+          orders__revenue: '30'
+        },
+        {
+          orders__currency: 'EUR',
+          orders__currency_full_name: 'euros',
+          orders__date_year: '2025-01-01T00:00:00.000Z',
+          orders__revenue: '5'
+        },
+        {
+          orders__currency: 'GBP',
+          orders__currency_full_name: 'unknown',
+          orders__date_year: '2025-01-01T00:00:00.000Z',
+          orders__revenue: '5'
+        },
+        {
+          orders__currency: 'USD',
+          orders__currency_full_name: 'dollars',
+          orders__date_year: '2025-01-01T00:00:00.000Z',
+          orders__revenue: '5'
+        }
+      ],
     { joinGraph, cubeEvaluator, compiler }));
   } else {
     // This test is working only in tesseract

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/case_else_item.rs

@@ -1,4 +1,4 @@
-use super::case_label::CaseLabel;
+use super::string_or_sql::StringOrSql;
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
@@ -11,5 +11,5 @@ use std::rc::Rc;
 #[nativebridge::native_bridge]
 pub trait CaseElseItem {
     #[nbridge(field)]
-    fn label(&self) -> Result<CaseLabel, CubeError>;
+    fn label(&self) -> Result<StringOrSql, CubeError>;
 }

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/case_item.rs

@@ -1,4 +1,4 @@
-use super::case_label::CaseLabel;
+use super::string_or_sql::StringOrSql;
 use super::member_sql::{MemberSql, NativeMemberSql};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
@@ -14,5 +14,5 @@ pub trait CaseItem {
     #[nbridge(field)]
     fn sql(&self) -> Result<Rc<dyn MemberSql>, CubeError>;
     #[nbridge(field)]
-    fn label(&self) -> Result<CaseLabel, CubeError>;
+    fn label(&self) -> Result<StringOrSql, CubeError>;
 }

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/case_switch_definition.rs

@@ -0,0 +1,24 @@
+use crate::cube_bridge::member_sql::{MemberSql, NativeMemberSql};
+
+use super::case_switch_else_item::{CaseSwitchElseItem, NativeCaseSwitchElseItem};
+use super::case_switch_item::{CaseSwitchItem, NativeCaseSwitchItem};
+use super::string_or_sql::StringOrSql;
+use cubenativeutils::wrappers::serializer::{
+    NativeDeserialize, NativeDeserializer, NativeSerialize,
+};
+use cubenativeutils::wrappers::NativeArray;
+use cubenativeutils::wrappers::NativeContextHolder;
+use cubenativeutils::wrappers::NativeObjectHandle;
+use cubenativeutils::CubeError;
+use std::any::Any;
+use std::rc::Rc;
+
+#[nativebridge::native_bridge]
+pub trait CaseSwitchDefinition {
+    #[nbridge(field)]
+    fn switch(&self) -> Result<Rc<dyn MemberSql>, CubeError>;
+    #[nbridge(field, vec)]
+    fn when(&self) -> Result<Vec<Rc<dyn CaseSwitchItem>>, CubeError>;
+    #[nbridge(field, rename = "else")]
+    fn else_sql(&self) -> Result<Rc<dyn CaseSwitchElseItem>, CubeError>;
+}

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/case_switch_else_item.rs

@@ -1,6 +1,5 @@
 use crate::cube_bridge::member_sql::{MemberSql, NativeMemberSql};
 
-use super::case_label::CaseLabel;
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/case_switch_item.rs

@@ -1,18 +1,21 @@
-use super::case_label::CaseLabel;
 use super::member_sql::{MemberSql, NativeMemberSql};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
 use cubenativeutils::wrappers::NativeContextHolder;
 use cubenativeutils::wrappers::NativeObjectHandle;
 use cubenativeutils::CubeError;
+use serde::{Deserialize, Serialize};
 use std::any::Any;
 use std::rc::Rc;
 
-#[nativebridge::native_bridge]
+#[derive(Serialize, Deserialize, Debug)]
+pub struct CaseSwitchItemStatic {
+    pub value: String,
+}
+
+#[nativebridge::native_bridge(CaseSwitchItemStatic)]
 pub trait CaseSwitchItem {
-    #[nbridge(field)]
-    fn value(&self) -> Result<String, CubeError>;
     #[nbridge(field)]
     fn sql(&self) -> Result<Rc<dyn MemberSql>, CubeError>;
 }

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/case_variant.rs

@@ -0,0 +1,28 @@
+use crate::cube_bridge::case_definition::{CaseDefinition, NativeCaseDefinition};
+use crate::cube_bridge::case_switch_definition::{
+    CaseSwitchDefinition, NativeCaseSwitchDefinition,
+};
+
+use super::struct_with_sql_member::{NativeStructWithSqlMember, StructWithSqlMember};
+use cubenativeutils::wrappers::inner_types::InnerTypes;
+use cubenativeutils::wrappers::serializer::NativeDeserialize;
+use cubenativeutils::wrappers::NativeObjectHandle;
+use cubenativeutils::CubeError;
+use std::rc::Rc;
+
+pub enum CaseVariant {
+    Case(Rc<dyn CaseDefinition>),
+    CaseSwitch(Rc<dyn CaseSwitchDefinition>),
+}
+
+impl<IT: InnerTypes> NativeDeserialize<IT> for CaseVariant {
+    fn from_native(native_object: NativeObjectHandle<IT>) -> Result<Self, CubeError> {
+        match NativeCaseSwitchDefinition::from_native(native_object.clone()) {
+            Ok(case) => Ok(Self::CaseSwitch(Rc::new(case))),
+            Err(_) => match NativeCaseDefinition::from_native(native_object) {
+                Ok(case) => Ok(Self::Case(Rc::new(case))),
+                Err(_) => Err(CubeError::user(format!("Case or Case Switch  expected"))),
+            },
+        }
+    }
+}

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/dimension_definition.rs

@@ -1,4 +1,4 @@
-use super::case_definition::{CaseDefinition, NativeCaseDefinition};
+use super::case_variant::CaseVariant;
 use super::geo_item::{GeoItem, NativeGeoItem};
 use super::member_sql::{MemberSql, NativeMemberSql};
 use crate::cube_bridge::timeshift_definition::{NativeTimeShiftDefinition, TimeShiftDefinition};
@@ -34,7 +34,7 @@ pub trait DimensionDefinition {
     fn sql(&self) -> Result<Option<Rc<dyn MemberSql>>, CubeError>;
 
     #[nbridge(field, optional)]
-    fn case(&self) -> Result<Option<Rc<dyn CaseDefinition>>, CubeError>;
+    fn case(&self) -> Result<Option<CaseVariant>, CubeError>;
 
     #[nbridge(field, optional)]
     fn latitude(&self) -> Result<Option<Rc<dyn GeoItem>>, CubeError>;

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/mod.rs

@@ -3,9 +3,10 @@ pub mod base_tools;
 pub mod case_definition;
 pub mod case_else_item;
 pub mod case_item;
-pub mod case_label;
+pub mod case_switch_definition;
 pub mod case_switch_else_item;
 pub mod case_switch_item;
+pub mod case_variant;
 pub mod cube_definition;
 pub mod dimension_definition;
 pub mod driver_tools;
@@ -31,5 +32,6 @@ pub mod security_context;
 pub mod segment_definition;
 pub mod sql_templates_render;
 pub mod sql_utils;
+pub mod string_or_sql;
 pub mod struct_with_sql_member;
 pub mod timeshift_definition;