feat(cubesql): SQL push down support for synthetic fields (#7418)

Author: paveltiunov

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

@@ -18869,6 +18869,44 @@ ORDER BY \"COUNT(count)\" DESC"
         );
     }
 
+    #[tokio::test]
+    async fn test_case_wrapper_with_system_fields() {
+        if !Rewriter::sql_push_down_enabled() {
+            return;
+        }
+        init_logger();
+
+        let query_plan = convert_select_to_query_plan(
+            "SELECT CASE WHEN customer_gender = 'female' THEN 'f' ELSE 'm' END, __user, __cubeJoinField, AVG(avgPrice) mp FROM KibanaSampleDataEcommerce a GROUP BY 1, 2, 3 LIMIT 1123"
+                .to_string(),
+            DatabaseProtocol::PostgreSQL,
+        )
+            .await;
+
+        let logical_plan = query_plan.as_logical_plan();
+
+        assert!(
+            logical_plan
+                .find_cube_scan_wrapper()
+                .wrapped_sql
+                .unwrap()
+                .sql
+                .contains("__user:(KibanaSampleDataEcommerce):$"),
+            "SQL contains __user:(KibanaSampleDataEcommerce):$: {}",
+            logical_plan
+                .find_cube_scan_wrapper()
+                .wrapped_sql
+                .unwrap()
+                .sql
+        );
+
+        let physical_plan = query_plan.as_physical_plan().await.unwrap();
+        println!(
+            "Physical plan: {}",
+            displayable(physical_plan.as_ref()).indent()
+        );
+    }
+
     #[tokio::test]
     async fn test_case_wrapper_with_limit() {
         if !Rewriter::sql_push_down_enabled() {

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

@@ -1343,18 +1343,33 @@ impl LanguageToLogicalPlanConverter {
                                                     ))
                                                 })?;
                                             for column in cube.get_columns() {
-                                                // TODO literal members and cube members
-                                                fields.push((
-                                                    DFField::new(
-                                                        Some(&alias),
-                                                        column.get_name(),
-                                                        column.get_column_type().to_arrow(),
-                                                        true,
-                                                    ),
-                                                    MemberField::Member(
-                                                        column.member_name().to_string(),
-                                                    ),
-                                                ));
+                                                if self.cube_context.meta.is_synthetic_field(
+                                                    column.member_name().to_string(),
+                                                ) {
+                                                    fields.push((
+                                                        DFField::new(
+                                                            Some(&alias),
+                                                            column.get_name(),
+                                                            column.get_column_type().to_arrow(),
+                                                            true,
+                                                        ),
+                                                        MemberField::Literal(ScalarValue::Utf8(
+                                                            None,
+                                                        )),
+                                                    ));
+                                                } else {
+                                                    fields.push((
+                                                        DFField::new(
+                                                            Some(&alias),
+                                                            column.get_name(),
+                                                            column.get_column_type().to_arrow(),
+                                                            true,
+                                                        ),
+                                                        MemberField::Member(
+                                                            column.member_name().to_string(),
+                                                        ),
+                                                    ));
+                                                }
                                             }
                                         }
                                     }

rust/cubesql/cubesql/src/compile/rewrite/rules/wrapper/column.rs

@@ -66,9 +66,11 @@ impl WrapperRules {
                         .iter()
                         .find(|(cn, _)| cn == &column.name)
                     {
-                        if let Some(_) = cube_context
+                        if cube_context
                             .meta
                             .find_dimension_with_name(member.to_string())
+                            .is_some()
+                            || cube_context.meta.is_synthetic_field(member.to_string())
                         {
                             let column_expr_column =
                                 egraph.add(LogicalPlanLanguage::ColumnExprColumn(

rust/cubesql/cubesql/src/transport/ctx.rs

@@ -169,6 +169,24 @@ impl MetaContext {
         }
     }
 
+    pub fn is_synthetic_field(&self, name: String) -> bool {
+        let cube_and_member_name = name.split(".").collect::<Vec<_>>();
+        if cube_and_member_name.len() == 1
+            && MetaContext::is_synthetic_field_name(cube_and_member_name[0])
+        {
+            return true;
+        }
+        if let Some(_) = self.find_cube_with_name(cube_and_member_name[0]) {
+            MetaContext::is_synthetic_field_name(cube_and_member_name[1])
+        } else {
+            false
+        }
+    }
+
+    pub fn is_synthetic_field_name(field_name: &str) -> bool {
+        field_name == "__user" || field_name == "__cubeJoinField"
+    }
+
     pub fn find_df_data_type(&self, member_name: String) -> Option<DataType> {
         self.find_cube_with_name(member_name.split(".").next()?)?
             .df_data_type(member_name.as_str())