get rid of references.fullName* in favor of fullpath-members

Author: KSDaemon

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

@@ -653,9 +653,9 @@ export class PreAggregations {
         ? transformedQuery.timeDimensions
         : transformedQuery.sortedTimeDimensions;
 
-      const refTimeDimensions = backAlias(sortTimeDimensions(references.fullNameTimeDimensions));
-      const backAliasMeasures = backAlias(references.fullNameMeasures);
-      const backAliasDimensions = backAlias(references.fullNameDimensions);
+      const refTimeDimensions = backAlias(sortTimeDimensions(references.timeDimensions));
+      const backAliasMeasures = backAlias(references.measures);
+      const backAliasDimensions = backAlias(references.dimensions);
       return ((
         transformedQuery.hasNoTimeDimensionsWithoutGranularity
       ) && (
@@ -746,11 +746,8 @@ export class PreAggregations {
         }
       }
 
-      const dimsToMatch = references.fullNameDimensions;
-      const timeDimsToMatch = references.fullNameTimeDimensions;
-
       const dimensionsMatch = (dimensions, doBackAlias) => {
-        const target = doBackAlias ? backAlias(dimsToMatch) : dimsToMatch;
+        const target = doBackAlias ? backAlias(references.dimensions) : references.dimensions;
         return dimensions.every(d => target.includes(d));
       };
 
@@ -766,8 +763,8 @@ export class PreAggregations {
         )
       )(
         doBackAlias ?
-          backAlias(sortTimeDimensions(timeDimsToMatch)) :
-          (sortTimeDimensions(timeDimsToMatch))
+          backAlias(sortTimeDimensions(references.timeDimensions)) :
+          (sortTimeDimensions(references.timeDimensions))
       );
 
       if (transformedQuery.ungrouped) {
@@ -1065,8 +1062,8 @@ export class PreAggregations {
 
   private cubesFromPreAggregation(preAggObj: PreAggregationForQuery): string[] {
     return R.uniq(
-      preAggObj.references.measures.map(m => this.query.cubeEvaluator.parsePath('measures', m)).concat(
-        preAggObj.references.dimensions.map(m => this.query.cubeEvaluator.parsePathAnyType(m))
+      preAggObj.references.measures.map(m => this.query.cubeEvaluator.parsePath('measures', this.query.cubeEvaluator.memberShortNameFromPath(m))).concat(
+        preAggObj.references.dimensions.map(m => this.query.cubeEvaluator.parsePathAnyType(this.query.cubeEvaluator.memberShortNameFromPath(m)))
       ).map(p => p[0])
     );
   }
@@ -1125,19 +1122,19 @@ export class PreAggregations {
         return path.reverse();
       };
 
-      references.fullNameDimensions = references.dimensions.map(d => {
+      references.dimensions = references.dimensions.map(d => {
         const [cubeName, ...restPath] = d.split('.');
         const path = buildPath(cubeName);
 
         return `${path.join('.')}.${restPath.join('.')}`;
       });
-      references.fullNameMeasures = references.measures.map(m => {
+      references.measures = references.measures.map(m => {
         const [cubeName, ...restPath] = m.split('.');
         const path = buildPath(cubeName);
 
         return `${path.join('.')}.${restPath.join('.')}`;
       });
-      references.fullNameTimeDimensions = references.timeDimensions.map(td => {
+      references.timeDimensions = references.timeDimensions.map(td => {
         const [cubeName, ...restPath] = td.dimension.split('.');
         const path = buildPath(cubeName);
 
@@ -1198,9 +1195,6 @@ export class PreAggregations {
       });
       referencedPreAggregations.forEach(preAgg => {
         references.rollupsReferences.push(preAgg.references);
-        references.fullNameDimensions.push(...preAgg.references.fullNameDimensions);
-        references.fullNameMeasures.push(...preAgg.references.fullNameMeasures);
-        references.fullNameTimeDimensions.push(...preAgg.references.fullNameTimeDimensions);
       });
       return {
         ...preAggObj,
@@ -1235,7 +1229,7 @@ export class PreAggregations {
       if (typeof member !== 'string') {
         return `${member.dimension.split('.')[1]}.${member.granularity}`;
       } else {
-        return member.split('.')[1];
+        return member.split('.').at(-1)!;
       }
     });
   }
@@ -1386,9 +1380,9 @@ export class PreAggregations {
           // So we store full named members separately and use them in canUsePreAggregation functions.
           references.joinTree = preAggQuery.join;
           const root = references.joinTree?.root || '';
-          references.fullNameMeasures = references.measures.map(m => (m.startsWith(root) ? m : `${root}.${m}`));
-          references.fullNameDimensions = references.dimensions.map(d => (d.startsWith(root) ? d : `${root}.${d}`));
-          references.fullNameTimeDimensions = references.timeDimensions.map(d => ({
+          references.measures = references.measures.map(m => (m.startsWith(root) ? m : `${root}.${m}`));
+          references.dimensions = references.dimensions.map(d => (d.startsWith(root) ? d : `${root}.${d}`));
+          references.timeDimensions = references.timeDimensions.map(d => ({
             dimension: (d.dimension.startsWith(root) ? d.dimension : `${root}.${d.dimension}`),
             granularity: d.granularity,
           }));

packages/cubejs-schema-compiler/src/compiler/CubeEvaluator.ts

@@ -89,11 +89,8 @@ export type PreAggregationTimeDimensionReference = {
 export type PreAggregationReferences = {
   allowNonStrictDateRangeMatch?: boolean,
   dimensions: Array<string>,
-  fullNameDimensions: Array<string>,
   measures: Array<string>,
-  fullNameMeasures: Array<string>,
   timeDimensions: Array<PreAggregationTimeDimensionReference>,
-  fullNameTimeDimensions: Array<PreAggregationTimeDimensionReference>,
   rollups: Array<string>,
   rollupsReferences: Array<PreAggregationReferences>,
   multipliedMeasures?: Array<string>,
@@ -901,9 +898,6 @@ export class CubeEvaluator extends CubeSymbols {
       timeDimensions,
       rollups:
         aggregation.rollupReferences && this.evaluateReferences(cube, aggregation.rollupReferences, { originalSorting: true }) || [],
-      fullNameDimensions: [], // May be filled in PreAggregations.evaluateAllReferences()
-      fullNameMeasures: [], // May be filled in PreAggregations.evaluateAllReferences()
-      fullNameTimeDimensions: [], // May be filled in PreAggregations.evaluateAllReferences()
       rollupsReferences: [], // May be filled in PreAggregations.evaluateAllReferences()
     };
   }

packages/cubejs-schema-compiler/test/unit/pre-agg-by-filter-match.test.ts

@@ -59,12 +59,6 @@ describe('Pre Aggregation by filter match tests', () => {
         granularity: testPreAgg.granularity,
       }],
       rollups: [],
-      fullNameDimensions: testPreAgg.segments ? testPreAgg.dimensions.concat(testPreAgg.segments) : testPreAgg.dimensions,
-      fullNameMeasures: testPreAgg.measures,
-      fullNameTimeDimensions: [{
-        dimension: testPreAgg.timeDimension,
-        granularity: testPreAgg.granularity,
-      }],
       rollupsReferences: [],
     };
 

packages/cubejs-schema-compiler/test/unit/pre-agg-time-dim-match.test.ts

@@ -69,12 +69,6 @@ describe('Pre Aggregation by filter match tests', () => {
         granularity: testPreAgg.granularity,
       }],
       rollups: [],
-      fullNameDimensions: testPreAgg.dimensions,
-      fullNameMeasures: testPreAgg.measures,
-      fullNameTimeDimensions: [{
-        dimension: testPreAgg.timeDimension,
-        granularity: testPreAgg.granularity,
-      }],
       rollupsReferences: [],
     };
 

packages/cubejs-server-core/test/unit/RefreshScheduler.test.ts

@@ -666,9 +666,6 @@ describe('Refresh Scheduler', () => {
                 timeDimensions: [{ dimension: 'Foo.time', granularity: 'hour' }],
                 rollups: [],
                 rollupsReferences: [],
-                fullNameDimensions: [],
-                fullNameMeasures: [],
-                fullNameTimeDimensions: [],
               },
               refreshKey: { every: '1 hour', updateWindow: '1 day', incremental: true },
             },