feat(tesseract): Segments and MemberExpressions segments support (#9336)

* fix(tesseract): Fix error on memeber expressions working on views

* feat(tesseract): Segments and MemberExpressions segments support

Author: waralexrom

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

@@ -683,6 +683,7 @@ export class BaseQuery {
     const queryParams = {
       measures: this.options.measures,
       dimensions: this.options.dimensions,
+      segments: this.options.segments,
       timeDimensions: this.options.timeDimensions,
       timezone: this.options.timezone,
       joinGraph: this.joinGraph,

packages/cubejs-schema-compiler/test/integration/postgres/member-expression.test.ts

@@ -0,0 +1,127 @@
+import {
+  getEnv,
+} from '@cubejs-backend/shared';
+import { PostgresQuery } from '../../../src/adapter/PostgresQuery';
+import { prepareYamlCompiler } from '../../unit/PrepareCompiler';
+import { dbRunner } from './PostgresDBRunner';
+
+describe('Member Expression', () => {
+  jest.setTimeout(200000);
+
+  const { compiler, joinGraph, cubeEvaluator } = prepareYamlCompiler(`
+cubes:
+  - name: customers
+    sql: >
+      SELECT 9 as ID, 'state1' as STATE, 'New York' as CITY
+      UNION ALL
+      SELECT 10 as ID, 'state2' as STATE, 'New York' as CITY
+      UNION ALL
+      SELECT 11 as ID, 'state3' as STATE, 'LA' as CITY
+
+    dimensions:
+      - name: id
+        sql: ID
+        type: number
+        primary_key: true
+
+      - name: state
+        sql: STATE
+        type: string
+
+      - name: city
+        sql: CITY
+        type: string
+
+
+    measures:
+      - name: count
+        type: count
+
+views:
+  - name: customers_view
+
+    cubes:
+      - join_path: customers
+        includes:
+          - count
+
+          - city
+
+    `);
+
+  async function runQueryTest(q, expectedResult) {
+    /* if (!getEnv('nativeSqlPlanner')) {
+      return;
+    } */
+    await compiler.compile();
+    const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, q);
+
+    console.log(query.buildSqlAndParams());
+
+    const res = await dbRunner.testQuery(query.buildSqlAndParams());
+    console.log(JSON.stringify(res));
+
+    expect(res).toEqual(
+      expectedResult
+    );
+  }
+
+  it('member expression over views', async () => runQueryTest({
+    measures: [
+      {
+        // eslint-disable-next-line no-new-func
+        expression: new Function(
+          'customers_view',
+          // eslint-disable-next-line no-template-curly-in-string
+          'return `${customers_view.count}`'
+        ),
+        // eslint-disable-next-line no-template-curly-in-string
+        definition: '${customers_view.count}',
+        expressionName: 'count',
+        cubeName: 'customers_view',
+      },
+      {
+        // eslint-disable-next-line no-new-func
+        expression: new Function(
+          'customers_view',
+          // eslint-disable-next-line no-template-curly-in-string
+          'return `${customers_view.city}`'
+        ),
+        // eslint-disable-next-line no-template-curly-in-string
+        definition: '${customers_view.city}',
+        expressionName: 'city',
+        cubeName: 'customers_view',
+      },
+      {
+        // eslint-disable-next-line no-new-func
+        expression: new Function(
+          // eslint-disable-next-line no-template-curly-in-string
+          'return `\'NULL\'`'
+        ),
+        // eslint-disable-next-line no-template-curly-in-string
+        definition: 'CAST(NULL AS STRING)',
+        expressionName: 'cubejoinfield',
+        cubeName: 'customers_view',
+      },
+    ],
+    segments: [
+      {
+        // eslint-disable-next-line no-new-func
+        expression: new Function(
+          'customers_view',
+          // eslint-disable-next-line no-template-curly-in-string
+          'return `(${customers_view.city} = \'New York\')`'
+        ),
+        // eslint-disable-next-line no-template-curly-in-string
+        definition: '(${customers_view.city} = \'New York\')',
+        expressionName: 'castomers_view_c',
+        cubeName: 'customers_view',
+      },
+
+    ],
+    allowUngroupedWithoutPrimaryKey: true,
+    ungrouped: true,
+  },
+
+  [{ count: 1, city: 'New York', cubejoinfield: 'NULL' }, { count: 1, city: 'New York', cubejoinfield: 'NULL' }]));
+});

packages/cubejs-schema-compiler/test/integration/postgres/sql-generation.test.ts

@@ -35,6 +35,12 @@ describe('SQL Generation', () => {
         }
       },
 
+      segments: {
+        some_source: {
+          sql: \`\${CUBE}.source = 'some'\`
+        }
+      },
+
       measures: {
         visitor_count: {
           type: 'number',
@@ -3276,6 +3282,43 @@ SELECT 1 AS revenue,  cast('2024-01-01' AS timestamp) as time UNION ALL
     }]
   ));
 
+  it('simple join with segment', async () => runQueryTest(
+    {
+      measures: [
+        'visitors.visitor_revenue',
+        'visitors.visitor_count',
+        'visitor_checkins.visitor_checkins_count',
+        'visitors.per_visitor_revenue'
+      ],
+      timeDimensions: [{
+        dimension: 'visitors.created_at',
+        granularity: 'day',
+        dateRange: ['2017-01-01', '2017-01-30']
+      }],
+      segments: ['visitors.some_source'],
+      timezone: 'America/Los_Angeles',
+      order: [{
+        id: 'visitors.created_at'
+      }]
+    },
+    [
+      {
+        visitors__created_at_day: '2017-01-02T00:00:00.000Z',
+        visitors__visitor_revenue: '100',
+        visitors__visitor_count: '1',
+        vc__visitor_checkins_count: '3',
+        visitors__per_visitor_revenue: '100'
+      },
+      {
+        visitors__created_at_day: '2017-01-04T00:00:00.000Z',
+        visitors__visitor_revenue: '200',
+        visitors__visitor_count: '1',
+        vc__visitor_checkins_count: '2',
+        visitors__per_visitor_revenue: '200'
+      },
+    ]
+  ));
+
   // Subquery aggregation for multiplied measure (and any `keysSelect` for that matter)
   // should pick up all dimensions, even through member expressions
   it('multiplied sum with dimension member expressions', async () => runQueryTest(

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_query_options.rs

@@ -67,6 +67,8 @@ pub trait BaseQueryOptions {
     fn measures(&self) -> Result<Option<Vec<OptionsMember>>, CubeError>;
     #[nbridge(field, optional, vec)]
     fn dimensions(&self) -> Result<Option<Vec<OptionsMember>>, CubeError>;
+    #[nbridge(field, optional, vec)]
+    fn segments(&self) -> Result<Option<Vec<OptionsMember>>, CubeError>;
     #[nbridge(field)]
     fn cube_evaluator(&self) -> Result<Rc<dyn CubeEvaluator>, CubeError>;
     #[nbridge(field)]

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/evaluator.rs

@@ -2,6 +2,7 @@ use super::cube_definition::{CubeDefinition, NativeCubeDefinition};
 use super::dimension_definition::{DimensionDefinition, NativeDimensionDefinition};
 use super::measure_definition::{MeasureDefinition, NativeMeasureDefinition};
 use super::member_sql::{MemberSql, NativeMemberSql};
+use super::segment_definition::{NativeSegmentDefinition, SegmentDefinition};
 use cubenativeutils::wrappers::serializer::{
     NativeDeserialize, NativeDeserializer, NativeSerialize,
 };
@@ -34,8 +35,10 @@ pub trait CubeEvaluator {
         -> Result<Rc<dyn MeasureDefinition>, CubeError>;
     fn dimension_by_path(
         &self,
-        measure_path: String,
+        dimension_path: String,
     ) -> Result<Rc<dyn DimensionDefinition>, CubeError>;
+    fn segment_by_path(&self, segment_path: String)
+        -> Result<Rc<dyn SegmentDefinition>, CubeError>;
     fn cube_from_path(&self, cube_path: String) -> Result<Rc<dyn CubeDefinition>, CubeError>;
     fn is_measure(&self, path: Vec<String>) -> Result<bool, CubeError>;
     fn is_dimension(&self, path: Vec<String>) -> Result<bool, CubeError>;

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

@@ -22,6 +22,7 @@ pub mod member_order_by;
 pub mod member_sql;
 pub mod options_member;
 pub mod security_context;
+pub mod segment_definition;
 pub mod sql_templates_render;
 pub mod sql_utils;
 pub mod struct_with_sql_member;

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/options_member.rs

@@ -3,6 +3,7 @@ use cubenativeutils::wrappers::inner_types::InnerTypes;
 use cubenativeutils::wrappers::serializer::NativeDeserialize;
 use cubenativeutils::wrappers::NativeObjectHandle;
 use cubenativeutils::CubeError;
+use std::fmt::Debug;
 use std::rc::Rc;
 
 pub enum OptionsMember {
@@ -23,3 +24,15 @@ impl<IT: InnerTypes> NativeDeserialize<IT> for OptionsMember {
         }
     }
 }
+
+impl Debug for OptionsMember {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::MemberName(name) => f.debug_tuple("MemberName").field(name).finish(),
+            Self::MemberExpression(member_expression) => f
+                .debug_tuple("MemberExpression")
+                .field(member_expression.static_data())
+                .finish(),
+        }
+    }
+}

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/segment_definition.rs

@@ -0,0 +1,24 @@
+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;
+
+#[derive(Serialize, Deserialize, Debug)]
+pub struct SegmentDefinitionStatic {
+    #[serde(rename = "type")]
+    pub segment_type: Option<String>,
+    #[serde(rename = "ownedByCube")]
+    pub owned_by_cube: Option<bool>,
+}
+
+#[nativebridge::native_bridge(SegmentDefinitionStatic)]
+pub trait SegmentDefinition {
+    #[nbridge(field)]
+    fn sql(&self) -> Result<Rc<dyn MemberSql>, CubeError>;
+}

rust/cubesqlplanner/cubesqlplanner/src/plan/filter.rs

@@ -1,4 +1,4 @@
-use crate::planner::filter::BaseFilter;
+use crate::planner::filter::{BaseFilter, BaseSegment};
 use crate::planner::sql_evaluator::MemberSymbol;
 use crate::planner::sql_templates::PlanSqlTemplates;
 use crate::planner::VisitorContext;
@@ -34,6 +34,7 @@ impl FilterGroup {
 pub enum FilterItem {
     Group(Rc<FilterGroup>),
     Item(Rc<BaseFilter>),
+    Segment(Rc<BaseSegment>),
 }
 
 #[derive(Clone)]
@@ -78,6 +79,10 @@ impl FilterItem {
                 let sql = item.to_sql(context.clone(), templates)?;
                 format!("({})", sql)
             }
+            FilterItem::Segment(item) => {
+                let sql = item.to_sql(context.clone(), templates)?;
+                format!("({})", sql)
+            }
         };
         Ok(res)
     }
@@ -96,6 +101,7 @@ impl FilterItem {
                 }
             }
             FilterItem::Item(item) => result.push(item.member_evaluator().clone()),
+            FilterItem::Segment(item) => result.push(item.member_evaluator().clone()),
         }
     }
 }

rust/cubesqlplanner/cubesqlplanner/src/planner/filter/base_segment.rs

@@ -0,0 +1,72 @@
+use crate::cube_bridge::dimension_definition::DimensionDefinition;
+use crate::planner::query_tools::QueryTools;
+use crate::planner::sql_evaluator::{MemberExpressionSymbol, MemberSymbol, SqlCall};
+use crate::planner::sql_templates::PlanSqlTemplates;
+use crate::planner::{evaluate_with_context, BaseMember, BaseMemberHelper, VisitorContext};
+use cubenativeutils::CubeError;
+use std::rc::Rc;
+
+pub struct BaseSegment {
+    full_name: String,
+    query_tools: Rc<QueryTools>,
+    member_evaluator: Rc<MemberSymbol>,
+    cube_name: String,
+    name: String,
+}
+
+impl PartialEq for BaseSegment {
+    fn eq(&self, other: &Self) -> bool {
+        self.full_name == other.full_name
+    }
+}
+
+impl BaseSegment {
+    pub fn try_new(
+        expression: Rc<SqlCall>,
+        cube_name: String,
+        name: String,
+        full_name: Option<String>,
+        query_tools: Rc<QueryTools>,
+    ) -> Result<Rc<Self>, CubeError> {
+        let member_expression_symbol =
+            MemberExpressionSymbol::new(cube_name.clone(), name.clone(), expression, None);
+        let full_name = full_name.unwrap_or(member_expression_symbol.full_name());
+        let member_evaluator = Rc::new(MemberSymbol::MemberExpression(member_expression_symbol));
+
+        Ok(Rc::new(Self {
+            full_name,
+            query_tools,
+            member_evaluator,
+            cube_name,
+            name,
+        }))
+    }
+    pub fn to_sql(
+        &self,
+        context: Rc<VisitorContext>,
+        templates: &PlanSqlTemplates,
+    ) -> Result<String, CubeError> {
+        evaluate_with_context(
+            &self.member_evaluator,
+            self.query_tools.clone(),
+            context,
+            templates,
+        )
+    }
+
+    pub fn full_name(&self) -> String {
+        self.full_name.clone()
+    }
+
+    pub fn member_evaluator(&self) -> Rc<MemberSymbol> {
+        self.member_evaluator.clone()
+    }
+
+    pub fn cube_name(&self) -> &String {
+        &self.cube_name
+    }
+
+    pub fn name(&self) -> &String {
+        &self.name
+    }
+}