chore(cubesql): dataRange filter isn't being push down to time dimension in case of other filters are used

Generalized case support

Fixes #6312

Author: paveltiunov

packages/cubejs-backend-native/Cargo.lock

@@ -3165,6 +3165,83 @@ ORDER BY \"COUNT(count)\" DESC"
         );
     }
 
+    #[tokio::test]
+    async fn superset_pg_time_filter_with_generalized_filters() {
+        init_logger();
+
+        let query_plan = convert_select_to_query_plan(
+            "SELECT DATE_TRUNC('week', \"order_date\") AS __timestamp,
+               count(count) AS \"COUNT(count)\"
+FROM public.\"KibanaSampleDataEcommerce\"
+WHERE \"customer_gender\" = 'female'\
+ AND \"order_date\" >= TO_TIMESTAMP('2021-05-15 00:00:00.000000', 'YYYY-MM-DD HH24:MI:SS.US')
+ AND \"customer_gender\" LIKE '%fem%'
+ AND \"customer_gender\" LIKE '%fe%'
+ AND \"order_date\" < TO_TIMESTAMP('2022-05-15 00:00:00.000000', 'YYYY-MM-DD HH24:MI:SS.US')
+ AND \"customer_gender\" LIKE '%f%'
+GROUP BY DATE_TRUNC('week', \"order_date\")
+ORDER BY \"COUNT(count)\" DESC"
+                .to_string(),
+            DatabaseProtocol::PostgreSQL,
+        )
+        .await;
+
+        let logical_plan = query_plan.as_logical_plan();
+        assert_eq!(
+            logical_plan.find_cube_scan().request,
+            V1LoadRequestQuery {
+                measures: Some(vec!["KibanaSampleDataEcommerce.count".to_string()]),
+                segments: Some(vec![]),
+                dimensions: Some(vec![]),
+                time_dimensions: Some(vec![V1LoadRequestQueryTimeDimension {
+                    dimension: "KibanaSampleDataEcommerce.order_date".to_string(),
+                    granularity: Some("week".to_string()),
+                    date_range: Some(json!(vec![
+                        "2021-05-15T00:00:00.000Z".to_string(),
+                        "2022-05-14T23:59:59.999Z".to_string()
+                    ]))
+                }]),
+                order: Some(vec![vec![
+                    "KibanaSampleDataEcommerce.count".to_string(),
+                    "desc".to_string()
+                ]]),
+                limit: None,
+                offset: None,
+                filters: Some(vec![
+                    V1LoadRequestQueryFilterItem {
+                        member: Some("KibanaSampleDataEcommerce.customer_gender".to_string()),
+                        operator: Some("equals".to_string()),
+                        values: Some(vec!["female".to_string()]),
+                        or: None,
+                        and: None
+                    },
+                    V1LoadRequestQueryFilterItem {
+                        member: Some("KibanaSampleDataEcommerce.customer_gender".to_string()),
+                        operator: Some("contains".to_string()),
+                        values: Some(vec!["fem".to_string()]),
+                        or: None,
+                        and: None
+                    },
+                    V1LoadRequestQueryFilterItem {
+                        member: Some("KibanaSampleDataEcommerce.customer_gender".to_string()),
+                        operator: Some("contains".to_string()),
+                        values: Some(vec!["fe".to_string()]),
+                        or: None,
+                        and: None
+                    },
+                    V1LoadRequestQueryFilterItem {
+                        member: Some("KibanaSampleDataEcommerce.customer_gender".to_string()),
+                        operator: Some("contains".to_string()),
+                        values: Some(vec!["f".to_string()]),
+                        or: None,
+                        and: None
+                    }
+                ]),
+                ungrouped: None,
+            }
+        );
+    }
+
     #[tokio::test]
     async fn power_bi_dimension_only() {
         init_logger();

rust/cubesql/cubesql/src/compile/mod.rs

@@ -258,7 +258,8 @@ impl LogicalPlanAnalysis {
     ) -> Option<Vec<(String, String)>> {
         let filter_operators = |id| egraph.index(id).data.filter_operators.clone();
         match enode {
-            LogicalPlanLanguage::FilterOp(params) => {
+            LogicalPlanLanguage::FilterOp(params) => filter_operators(params[0]),
+            LogicalPlanLanguage::FilterOpFilters(params) => {
                 let mut map = Vec::new();
                 for id in params.iter() {
                     map.extend(filter_operators(*id)?.into_iter());

rust/cubesql/cubesql/src/compile/rewrite/analysis.rs

@@ -352,7 +352,7 @@ impl Rewriter {
                         .iter()
                         .enumerate()
                         .map(|(i, n)| format!("{}: {:?}", i, n))
-                        .join(",")
+                        .join(", ")
                 );
                 let converter =
                     LanguageToLogicalPlanConverter::new(best, cube_context.clone(), auth_context);