feat: Rewrite joins from SQL as query-level join hints (cube-js#9561)

This allows to keep join structure in some cases. Consider query like this:
```
SELECT cube2.dim, cube3.dim
FROM cube1
JOIN cube2 ON cube1.__cubeJoinField = cube2.__cubeJoinField
JOIN cube3 ON cube1.__cubeJoinField = cube3.__cubeJoinField
GROUP BY 1, 2
```
It references members only from `cube2` and `cube3`, but join structure actually has `cube1` as root, and it is completely missing from query.

Now every join will generate separate join hint during rewrite, and then they will get to JS side as a query-level join hints.


Supporting changes:
* Remove unused MergedMembersReplacer

* Remove unused rewrite for CrossJoin on empty CubeScan
CubeScan with empty members just should not manifest during rewrites: either it's `AllMembers`, or specific members, but never empty

* Simplify CrossJoin to CubeScan rewrite

* Drop ordering from CubeScan during CrossJoin rewrite
CROSS JOIN does not guarantee same ordering as inputs

* Rewrite join on `__cubeJoinField` directly to CubeScan, without intermediate CrossJoin

Author: mcheshkov

packages/cubejs-api-gateway/openspec.yml

@@ -369,6 +369,10 @@ components:
         - "on"
         - joinType
         - alias
+    V1LoadRequestJoinHint:
+      type: "array"
+      items:
+        type: "string"
     V1LoadRequestQuery:
       type: "object"
       properties:
@@ -412,6 +416,10 @@ components:
           type: "array"
           items:
             $ref: "#/components/schemas/V1LoadRequestQueryJoinSubquery"
+        joinHints:
+          type: "array"
+          items:
+            $ref: "#/components/schemas/V1LoadRequestJoinHint"
     V1LoadRequest:
       type: "object"
       properties:

packages/cubejs-api-gateway/src/query.js

@@ -162,6 +162,8 @@ const subqueryJoin = Joi.object().keys({
   alias: Joi.string(),
 });
 
+const joinHint = Joi.array().items(Joi.string());
+
 const querySchema = Joi.object().keys({
   // TODO add member expression alternatives only for SQL API queries?
   measures: Joi.array().items(Joi.alternatives(id, memberExpression, parsedMemberExpression)),
@@ -189,6 +191,7 @@ const querySchema = Joi.object().keys({
   ungrouped: Joi.boolean(),
   responseFormat: Joi.valid('default', 'compact'),
   subqueryJoins: Joi.array().items(subqueryJoin),
+  joinHints: Joi.array().items(joinHint),
 });
 
 const normalizeQueryOrder = order => {

packages/cubejs-api-gateway/src/types/query.ts

@@ -122,6 +122,8 @@ type SubqueryJoins = {
   alias: string,
 };
 
+type JoinHint = Array<string>;
+
 /**
  * Incoming network query data type.
  */
@@ -143,6 +145,8 @@ interface Query {
 
   // TODO incoming query, query with parsed exprs and query with evaluated exprs are all different types
   subqueryJoins?: Array<SubqueryJoins>,
+
+  joinHints?: Array<JoinHint>
 }
 
 /**

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

@@ -279,6 +279,7 @@ export class BaseQuery {
       multiStageDimensions: this.options.multiStageDimensions,
       multiStageTimeDimensions: this.options.multiStageTimeDimensions,
       subqueryJoins: this.options.subqueryJoins,
+      joinHints: this.options.joinHints,
     });
     this.from = this.options.from;
     this.multiStageQuery = this.options.multiStageQuery;
@@ -329,6 +330,7 @@ export class BaseQuery {
       const hasMultiStageMeasures = this.fullKeyQueryAggregateMeasures({ hasMultipliedForPreAggregation: true }).multiStageMembers.length > 0;
       this.canUseNativeSqlPlannerPreAggregation = hasMultiStageMeasures;
     }
+    this.queryLevelJoinHints = this.options.joinHints ?? [];
     this.prebuildJoin();
 
     this.cubeAliasPrefix = this.options.cubeAliasPrefix;
@@ -410,7 +412,10 @@ export class BaseQuery {
    */
   get allJoinHints() {
     if (!this.collectedJoinHints) {
-      this.collectedJoinHints = this.collectJoinHints();
+      this.collectedJoinHints = [
+        ...this.queryLevelJoinHints,
+        ...this.collectJoinHints(),
+      ];
     }
     return this.collectedJoinHints;
   }

packages/cubejs-schema-compiler/test/integration/postgres/multiple-join-paths.test.ts

@@ -641,4 +641,32 @@ describe('Multiple join paths', () => {
       });
     }
   });
+
+  describe('Query level join hints', () => {
+    it('should respect query level join hints', async () => {
+      const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
+        measures: [],
+        dimensions: [
+          'A.a_id',
+          'X.x_name_ref',
+        ],
+        joinHints: [
+          ['A', 'D'],
+          ['D', 'E'],
+          ['E', 'X'],
+        ],
+      });
+
+      const [sql, _params] = query.buildSqlAndParams();
+
+      expect(sql).toMatch(/ON 'A' = 'D'/);
+      expect(sql).toMatch(/ON 'D' = 'E'/);
+      expect(sql).toMatch(/ON 'E' = 'X'/);
+      expect(sql).not.toMatch(/ON 'A' = 'B'/);
+      expect(sql).not.toMatch(/ON 'B' = 'C'/);
+      expect(sql).not.toMatch(/ON 'C' = 'X'/);
+      expect(sql).not.toMatch(/ON 'A' = 'F'/);
+      expect(sql).not.toMatch(/ON 'F' = 'X'/);
+    });
+  });
 });

rust/cubesql/cubeclient/src/models/v1_load_request_query.rs

@@ -30,6 +30,8 @@ pub struct V1LoadRequestQuery {
     pub ungrouped: Option<bool>,
     #[serde(rename = "subqueryJoins", skip_serializing_if = "Option::is_none")]
     pub subquery_joins: Option<Vec<crate::models::V1LoadRequestQueryJoinSubquery>>,
+    #[serde(rename = "joinHints", skip_serializing_if = "Option::is_none")]
+    pub join_hints: Option<Vec<Vec<String>>>,
 }
 
 impl V1LoadRequestQuery {
@@ -45,6 +47,7 @@ impl V1LoadRequestQuery {
             filters: None,
             ungrouped: None,
             subquery_joins: None,
+            join_hints: None,
         }
     }
 }

rust/cubesql/cubesql/src/compile/builder.rs

@@ -152,6 +152,7 @@ impl QueryBuilder {
                 },
                 ungrouped: None,
                 subquery_joins: None,
+                join_hints: None,
             },
             meta: self.meta,
         }

rust/cubesql/cubesql/src/compile/engine/df/wrapper.rs

@@ -3368,6 +3368,8 @@ impl WrappedSelectNode {
             time_dimensions: load_request.time_dimensions.clone(),
             subquery_joins: (!prepared_join_subqueries.is_empty())
                 .then_some(prepared_join_subqueries),
+
+            join_hints: load_request.join_hints.clone(),
         };
 
         // TODO time dimensions, filters, segments

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

@@ -4665,6 +4665,13 @@ ORDER BY "ca_4" ASC
                 segments: Some(vec![]),
                 dimensions: Some(vec!["Logs.read".to_string()]),
                 order: Some(vec![]),
+                join_hints: Some(vec![
+                    vec!["KibanaSampleDataEcommerce".to_string(), "Logs".to_string(),],
+                    vec![
+                        "KibanaSampleDataEcommerce".to_string(),
+                        "NumberCube".to_string(),
+                    ],
+                ]),
                 ..Default::default()
             }
         );
@@ -4726,6 +4733,10 @@ ORDER BY
                     date_range: None,
                 }]),
                 order: Some(vec![]),
+                join_hints: Some(vec![vec![
+                    "KibanaSampleDataEcommerce".to_string(),
+                    "Logs".to_string(),
+                ],]),
                 ..Default::default()
             }
         );
@@ -8218,6 +8229,10 @@ ORDER BY "source"."str0" ASC
                 segments: Some(vec![]),
                 order: Some(vec![]),
                 ungrouped: Some(true),
+                join_hints: Some(vec![vec![
+                    "KibanaSampleDataEcommerce".to_string(),
+                    "Logs".to_string(),
+                ],]),
                 ..Default::default()
             }
         )
@@ -9794,6 +9809,10 @@ ORDER BY "source"."str0" ASC
                 segments: Some(vec![]),
                 order: Some(vec![]),
                 ungrouped: Some(true),
+                join_hints: Some(vec![vec![
+                    "Logs".to_string(),
+                    "KibanaSampleDataEcommerce".to_string(),
+                ],]),
                 ..Default::default()
             },
         );
@@ -11845,6 +11864,12 @@ ORDER BY "source"."str0" ASC
                     }).to_string(),
                 ]),
                 order: Some(vec![]),
+                join_hints: Some(vec![
+                    vec![
+                        "KibanaSampleDataEcommerce".to_string(),
+                        "Logs".to_string(),
+                    ],
+                ]),
                 ..Default::default()
             }
         );
@@ -12271,6 +12296,10 @@ ORDER BY "source"."str0" ASC
                 ]),
                 segments: Some(vec![]),
                 order: Some(vec![]),
+                join_hints: Some(vec![vec![
+                    "KibanaSampleDataEcommerce".to_string(),
+                    "Logs".to_string(),
+                ],]),
                 ..Default::default()
             }
         )

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

@@ -12,11 +12,11 @@ use crate::{
             AggregateFunctionExprDistinct, AggregateFunctionExprFun, AggregateSplit,
             AggregateUDFExprFun, AliasExprAlias, AnyExprAll, AnyExprOp, BetweenExprNegated,
             BinaryExprOp, CastExprDataType, ChangeUserMemberValue, ColumnExprColumn,
-            CubeScanAliasToCube, CubeScanLimit, CubeScanOffset, CubeScanUngrouped, CubeScanWrapped,
-            DimensionName, EmptyRelationDerivedSourceTableName, EmptyRelationIsWrappable,
-            EmptyRelationProduceOneRow, FilterMemberMember, FilterMemberOp, FilterMemberValues,
-            FilterOpOp, GroupingSetExprType, GroupingSetType, InListExprNegated,
-            InSubqueryExprNegated, JoinJoinConstraint, JoinJoinType, JoinLeftOn,
+            CubeScanAliasToCube, CubeScanJoinHints, CubeScanLimit, CubeScanOffset,
+            CubeScanUngrouped, CubeScanWrapped, DimensionName, EmptyRelationDerivedSourceTableName,
+            EmptyRelationIsWrappable, EmptyRelationProduceOneRow, FilterMemberMember,
+            FilterMemberOp, FilterMemberValues, FilterOpOp, GroupingSetExprType, GroupingSetType,
+            InListExprNegated, InSubqueryExprNegated, JoinJoinConstraint, JoinJoinType, JoinLeftOn,
             JoinNullEqualsNull, JoinRightOn, LikeExprEscapeChar, LikeExprLikeType, LikeExprNegated,
             LikeType, LimitFetch, LimitSkip, LiteralExprValue, LiteralMemberRelation,
             LiteralMemberValue, LogicalPlanLanguage, MeasureName, MemberErrorError, OrderAsc,
@@ -2002,6 +2002,12 @@ impl LanguageToLogicalPlanConverter {
                     query.ungrouped = Some(true);
                 }
 
+                let join_hints =
+                    match_data_node!(node_by_id, cube_scan_params[10], CubeScanJoinHints);
+                if join_hints.len() > 0 {
+                    query.join_hints = Some(join_hints);
+                }
+
                 query.order = if !query_order.is_empty() {
                     Some(query_order)
                 } else {