fix(schema-compiler): Handle measures with dimension-only member expressions in fullKeyQueryAggregateMeasures

`fullKeyQueryAggregate` is using measure.cube() a lot, like for grouping measures to key cube
This can be wrong for measure targeting view: we want to attach measure to subquery
for its definition cube, and there should be no subquery for view itself
It's expected that `fullKeyQueryAggregateMeasures` would resolve and prepare all measures from its original form in query to actual leaf measures in cubes, then build subqueries with those, and then `joinFullKeyQueryAggregate` would use `renderedReference` to point to these leaf measures

Hard case is a measure that:
* targeting view
* is a member expression
* references only dimensions from that view
Measure like that are "leaf" - there's nowhere to push it, member expression has to be directly in leaf subquery
If measure references dimension from a single cube it can be multiplied (think `SUM(${view.deep_dimension})`)
So, three points:
* it must be accounted for in `multipliedMeasures`
* it must be attached to a proper cube subquery
* it must use renderedReference correctly

`collectRootMeasureToHieararchy` will not drop such measure completely. Now it will check is there's 0 measures collected, try to collect all referenced members to gather used cubes and detect multiplication, and add new measure in hierarchy.

Because new returned measure is patched, it will be attached to correct cube subquery in `fullKeyQueryAggregate`

Then `outerMeasuresJoinFullKeyQueryAggregate` needs to generate proper alias for it, so outer unpatched measure would pick up alias from inner patched one

Author: mcheshkov

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

@@ -1058,7 +1058,7 @@ export class BaseQuery {
           const member = m.measure ? m.measure : m.dimension;
           const memberPath = typeof member === 'string'
             ? member
-            : this.cubeEvaluator.pathFromArray([m.expressionCubeName, m.expressionName]);
+            : this.cubeEvaluator.pathFromArray([m.measure?.originalCubeName ?? m.expressionCubeName, m.expressionName]);
           return [memberPath, m.aliasName()];
         }),
         R.fromPairs,
@@ -1701,6 +1701,8 @@ export class BaseQuery {
       .filter(f => R.none(m => m.measure === f.measure, this.measures));
 
     return R.fromPairs(this.measures.concat(notAddedMeasureFilters).map(m => {
+      const measureName = typeof m.measure === 'string' ? m.measure : `${m.measure.cubeName}.${m.measure.name}`;
+
       const collectedMeasures = this.collectFrom(
         [m],
         this.collectMultipliedMeasures(context),
@@ -1714,7 +1716,57 @@ export class BaseQuery {
         const cubeName = m.expressionCubeName ? `\`${m.expressionCubeName}\` ` : '';
         throw new UserError(`The query contains \`COUNT(*)\` expression but cube/view ${cubeName}is missing \`count\` measure`);
       }
-      return [typeof m.measure === 'string' ? m.measure : `${m.measure.cubeName}.${m.measure.name}`, collectedMeasures];
+      if (collectedMeasures.length === 0 && m.isMemberExpression) {
+        // `m` is member expression measure, but does not reference any other measure
+        // Consider this dimensions-only measure. This can happen at least in 2 cases:
+        // 1. Ad-hoc aggregation over dimension: SELECT MAX(dim) FROM cube
+        // 2. Ungrouped query with SQL pushdown will render every column as measure: SELECT dim1 FROM cube WHERE LOWER(dim2) = 'foo';
+        // Measures like this needs a special treatment to attach them to cube and decide if they are multiplied or not
+        // This would return measure object in `measure`, not path
+        // TODO return measure object for every measure
+
+        const memberNamesForMeasure = this.collectFrom(
+          [m],
+          this.collectMemberNamesFor.bind(this),
+          context ? ['collectMemberNamesFor', JSON.stringify(context)] : 'collectMemberNamesFor',
+          this.queryCache
+        );
+        const cubeNamesForMeasure = R.pipe(
+          R.map(mem => this.cubeEvaluator.parsePathAnyType(mem)[0]),
+          // Filtering views, because collectMemberNamesFor can return both view.dim and cube.dim
+          R.filter(cubeName => {
+            const cubeDef = this.cubeEvaluator.getCubeDefinition(cubeName);
+            return !cubeDef.isView;
+          }),
+          // Single member expression can reference multiple dimensions from same cube
+          R.uniq,
+        )(
+          memberNamesForMeasure
+        );
+
+        let cubeNameToAttach;
+        switch (cubeNamesForMeasure.length) {
+          case 1:
+            cubeNameToAttach = cubeNamesForMeasure[0];
+            break;
+          default:
+            throw new Error(`Expected single cube for dimension-only measure ${mName}, got ${cubeNamesForMeasure}`);
+        }
+
+        const multiplied = this.multipliedJoinRowResult(cubeNameToAttach) || false;
+
+        const attachedMeasure = {
+          ...m.measure,
+          originalCubeName: m.measure.cubeName,
+          cubeName: cubeNameToAttach
+        };
+
+        return [measureName, [{
+          multiplied,
+          measure: attachedMeasure,
+        }]];
+      }
+      return [measureName, collectedMeasures];
     }));
   }