fix(sqlplanner): Sql planner make some tests working

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

@@ -605,7 +605,38 @@
     }
   }
 
+  buildSqlAndParamsTest(exportAnnotatedSql) {
+    if (!this.options.preAggregationQuery && !this.options.disableExternalPreAggregations && this.externalQueryClass) {
+      if (this.externalPreAggregationQuery()) { // TODO performance
+        return this.externalQuery().buildSqlAndParams(exportAnnotatedSql);
+      }
+    }
+    const js_res = this.compilers.compiler.withQuery(
+      this,
+      () => this.cacheValue(
+        ['buildSqlAndParams', exportAnnotatedSql],
+        () => this.paramAllocator.buildSqlAndParams(
+          this.buildParamAnnotatedSql(),
+          exportAnnotatedSql,
+          this.shouldReuseParams
+        ),
+        { cache: this.queryCache }
+      )
+    );
+    console.log('js result: ', js_res[0]);
+    const rust = this.buildSqlAndParamsRust(exportAnnotatedSql);
+    console.log('rust result: ', rust[0]);
+    return js_res;
+  }
+
   buildSqlAndParamsRust(exportAnnotatedSql) {
+
+
+    const order = this.options.order && R.pipe(
+      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,
@@ -614,12 +645,13 @@
       joinRoot: this.join.root,
       joinGraph: this.joinGraph,
       cubeEvaluator: this.cubeEvaluator,
-      order: this.options.order,
+      order: order,
       filters: this.options.filters,
       limit: this.options.limit ? this.options.limit.toString() : null,
       rowLimit: this.options.rowLimit ? this.options.rowLimit.toString() : null,
       offset: this.options.offset ? this.options.offset.toString() : null,
       baseTools: this,
+      ungrouped: this.options.ungrouped
 
     };
     const res = nativeBuildSqlAndParams(queryParams);
@@ -628,6 +660,10 @@
     return res;
   }
 
+  getAllocatedParams() {
+    return this.paramAllocator.getParams()
+  }
+
   // FIXME helper for native generator, maybe should be moved entire to rust
   generateTimeSeries(granularity, dateRange) {
     return timeSeriesBase(granularity, dateRange);
@@ -806,6 +842,7 @@
     } = this.fullKeyQueryAggregateMeasures();
 
     if (!multipliedMeasures.length && !cumulativeMeasures.length && !multiStageMembers.length) {
+    console.log("!!!!! LLLOOOO!!!!");
       return this.simpleQuery();
     }
 
@@ -1019,6 +1056,8 @@
     const allMemberChildren = this.collectAllMemberChildren(context);
     const memberToIsMultiStage = this.collectAllMultiStageMembers(allMemberChildren);
 
+    console.log("!!! measure to her ", measureToHierarchy);
+
     const hasMultiStageMembers = (m) => {
       if (memberToIsMultiStage[m]) {
         return true;
@@ -3288,7 +3327,8 @@
         gte: '{{ column }} >= {{ param }}',
         lt: '{{ column }} < {{ param }}',
         lte: '{{ column }} <= {{ param }}',
-        always_true: '1 == 1'
+        like_pattern: '{% if start_wild %}\'%\' || {% endif %}{{ value }}{% if end_wild %}|| \'%\'{% endif %}',
+        always_true: '1 = 1'
 
       },
       quotes: {

packages/cubejs-schema-compiler/src/adapter/ParamAllocator.ts

@@ -51,6 +51,10 @@ export class ParamAllocator {
     return `$${paramIndex}$`;
   }
 
+  public getParams() {
+    return this.params;
+  }
+
   // eslint-disable-next-line no-unused-vars
   protected paramPlaceHolder(paramIndex) {
     return '?';

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

@@ -453,7 +453,7 @@ describe('SQL Generation', () => {
     }
   });
 
-  it('having filter with operator OR', async () => {
+  it('having filter with operator OR 1', async () => {
     await compiler.compile();
 
     const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
@@ -486,7 +486,7 @@ describe('SQL Generation', () => {
       }]
     });
 
-    console.log(query.buildSqlAndParams());
+    console.log(query.buildSqlAndParamsTest());
 
     return dbRunner.testQuery(query.buildSqlAndParams()).then(res => {
       console.log(JSON.stringify(res));
@@ -648,7 +648,7 @@ describe('SQL Generation', () => {
     });
   });
 
-  it('where filter with operators OR & AND', async () => {
+  it('where filter with operators OR & AND 1', async () => {
     await compiler.compile();
 
     const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {

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

@@ -976,7 +976,7 @@ describe('SQL Generation', () => {
 
     console.log(query.buildSqlAndParams());
 
-    return dbRunner.testQuery(query.buildSqlAndParams()).then(res => {
+    return dbRunner.testQuery(query.buildSqlAndParamsTest()).then(res => {
       console.log(JSON.stringify(res));
       expect(res).toEqual(
         [{ visitor_checkins__revenue_per_checkin: '50' }]
@@ -1721,7 +1721,7 @@ describe('SQL Generation', () => {
   ]));
 
   it(
-    'contains filter',
+    'contains filter 1',
     () => runQueryTest({
       measures: [],
       dimensions: [

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

@@ -60,6 +60,7 @@ pub struct BaseQueryOptionsStatic {
     #[serde(rename = "rowLimit")]
     pub row_limit: Option<String>,
     pub offset: Option<String>,
+    pub ungrouped: Option<bool>,
 }
 
 #[nativebridge::native_bridge(BaseQueryOptionsStatic)]

rust/cubesqlplanner/cubesqlplanner/src/cube_bridge/base_tools.rs

@@ -43,4 +43,5 @@ pub trait BaseTools {
         granularity: String,
         date_range: Vec<String>,
     ) -> Result<Vec<Vec<String>>, CubeError>;
+    fn get_allocated_params(&self) -> Result<Vec<String>, CubeError>;
 }

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

@@ -63,13 +63,16 @@ impl FilterItem {
                     .items
                     .iter()
                     .map(|itm| itm.to_sql(templates, context.clone(), schema.clone()))
-                    .collect::<Result<Vec<_>, _>>()?;
-                let result = if items_sql.is_empty() {
-                    templates.always_true()?
+                    .collect::<Result<Vec<_>, _>>()?
+                    .into_iter()
+                    .filter(|itm| !itm.is_empty())
+                    .collect::<Vec<_>>();
+                if items_sql.is_empty() {
+                    "".to_string()
                 } else {
-                    items_sql.join(&operator)
-                };
-                format!("({})", result)
+                    let result = items_sql.join(&operator);
+                    format!("({})", result)
+                }
             }
             FilterItem::Item(item) => {
                 let sql = item.to_sql(context.clone(), schema)?;

rust/cubesqlplanner/cubesqlplanner/src/planner/base_query.rs

@@ -59,23 +59,29 @@ impl<IT: InnerTypes> BaseQuery<IT> {
     }
 
     fn build_sql_and_params_impl(&self) -> Result<Select, CubeError> {
+        let nodes_factory = if self.request.ungrouped() {
+            SqlNodesFactory::new_ungroupped()
+        } else {
+            SqlNodesFactory::new()
+        };
+
         if self.request.is_simple_query()? {
             let planner = SimpleQueryPlanner::new(
                 self.query_tools.clone(),
                 self.request.clone(),
-                SqlNodesFactory::new(),
+                nodes_factory.clone(),
             );
             planner.plan()
         } else {
             let multiplied_measures_query_planner = MultipliedMeasuresQueryPlanner::new(
                 self.query_tools.clone(),
                 self.request.clone(),
-                SqlNodesFactory::new(),
+                nodes_factory.clone(),
             );
             let multi_stage_query_planner =
                 MultiStageQueryPlanner::new(self.query_tools.clone(), self.request.clone());
             let full_key_aggregate_planner =
-                FullKeyAggregateQueryPlanner::new(self.request.clone(), SqlNodesFactory::new());
+                FullKeyAggregateQueryPlanner::new(self.request.clone(), nodes_factory.clone());
             let mut subqueries = multiplied_measures_query_planner.plan_queries()?;
             let (multi_stage_ctes, multi_stage_subqueries) =
                 multi_stage_query_planner.plan_queries()?;

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

@@ -116,6 +116,12 @@ impl BaseFilter {
             FilterOperator::Gte => self.gte_where(&member_sql)?,
             FilterOperator::Lt => self.lt_where(&member_sql)?,
             FilterOperator::Lte => self.lte_where(&member_sql)?,
+            FilterOperator::Contains => self.contains_where(&member_sql)?,
+            FilterOperator::NotContains => self.not_contains_where(&member_sql)?,
+            FilterOperator::StartsWith => self.starts_with_where(&member_sql)?,
+            FilterOperator::NotStartsWith => self.not_starts_with_where(&member_sql)?,
+            FilterOperator::EndsWith => self.ends_with_where(&member_sql)?,
+            FilterOperator::NotEndsWith => self.not_ends_with_where(&member_sql)?,
         };
         Ok(res)
     }
@@ -243,6 +249,58 @@ impl BaseFilter {
             .lte(member_sql.to_string(), self.first_param()?)
     }
 
+    fn contains_where(&self, member_sql: &str) -> Result<String, CubeError> {
+        self.like_or_where(member_sql, false, true, true)
+    }
+
+    fn not_contains_where(&self, member_sql: &str) -> Result<String, CubeError> {
+        self.like_or_where(member_sql, true, true, true)
+    }
+
+    fn starts_with_where(&self, member_sql: &str) -> Result<String, CubeError> {
+        self.like_or_where(member_sql, false, false, true)
+    }
+
+    fn not_starts_with_where(&self, member_sql: &str) -> Result<String, CubeError> {
+        self.like_or_where(member_sql, true, false, true)
+    }
+
+    fn ends_with_where(&self, member_sql: &str) -> Result<String, CubeError> {
+        self.like_or_where(member_sql, false, true, false)
+    }
+
+    fn not_ends_with_where(&self, member_sql: &str) -> Result<String, CubeError> {
+        self.like_or_where(member_sql, true, true, false)
+    }
+
+    fn like_or_where(
+        &self,
+        member_sql: &str,
+        not: bool,
+        start_wild: bool,
+        end_wild: bool,
+    ) -> Result<String, CubeError> {
+        let values = self.filter_and_allocate_values();
+        let like_parts = values
+            .into_iter()
+            .map(|v| {
+                self.templates
+                    .ilike(member_sql, &v, start_wild, end_wild, not)
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        let logical_symbol = if not { " AND " } else { " OR " };
+        let null_check = if self.is_need_null_chek(not) {
+            self.templates.or_is_null_check(member_sql.to_string())?
+        } else {
+            "".to_string()
+        };
+        Ok(format!(
+            "({}){}",
+            like_parts.join(logical_symbol),
+            null_check
+        ))
+    }
+
     fn allocate_date_params(&self) -> Result<(String, String), CubeError> {
         if self.values.len() >= 2 {
             let from = if let Some(from_str) = &self.values[0] {
@@ -345,13 +403,12 @@ impl BaseFilter {
     }
 
     fn allocate_param(&self, param: &str) -> String {
-        let index = self.query_tools.allocaate_param(param);
-        format!("${}$", index)
+        self.query_tools.allocate_param(param)
     }
 
     fn allocate_timestamp_param(&self, param: &str) -> String {
-        let index = self.query_tools.allocaate_param(param);
-        format!("${}$::timestamptz", index)
+        let placeholder = self.query_tools.allocate_param(param);
+        format!("{}::timestamptz", placeholder)
     }
 
     fn first_param(&self) -> Result<String, CubeError> {

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

@@ -15,6 +15,12 @@ pub enum FilterOperator {
     Gte,
     Lt,
     Lte,
+    Contains,
+    NotContains,
+    StartsWith,
+    NotStartsWith,
+    NotEndsWith,
+    EndsWith,
 }
 
 impl FromStr for FilterOperator {
@@ -32,6 +38,12 @@ impl FromStr for FilterOperator {
             "gte" => Ok(Self::Gte),
             "lt" => Ok(Self::Lt),
             "lte" => Ok(Self::Lte),
+            "contains" => Ok(Self::Contains),
+            "notcontains" => Ok(Self::NotContains),
+            "startswith" => Ok(Self::StartsWith),
+            "notstartswith" => Ok(Self::NotStartsWith),
+            "endswith" => Ok(Self::EndsWith),
+            "notendswith" => Ok(Self::NotEndsWith),
 
             _ => Err(CubeError::user(format!("Unknown filter operator {}", s))),
         }