fix(schema-compiler): Allow no-cache queries to use pre-aggregations (cube-js#10440)

no-cache mode now only skips the result cache (via forceNoCache in
QueryCache) but still routes queries through pre-aggregation tables
when available, avoiding expensive source database queries.

We initially discussed this exact behavior, but we skipped it. Skipping pre-aggregations doesn't make sense, since the cache parameter controls the in-memory cache.

Author: ovr

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

@@ -771,7 +771,7 @@ export class BaseQuery {
     }
     const hasMemberExpressions = this.allMembersConcat(false).some(m => m.isMemberExpression);
 
-    if (this.options.cacheMode !== 'no-cache' && !this.options.preAggregationQuery && !this.customSubQueryJoins.length && !hasMemberExpressions) {
+    if (!this.options.preAggregationQuery && !this.customSubQueryJoins.length && !hasMemberExpressions) {
       preAggForQuery =
         this.preAggregations.findPreAggregationForQuery();
       if (this.options.disableExternalPreAggregations && preAggForQuery?.preAggregation.external) {
@@ -844,10 +844,6 @@ export class BaseQuery {
   }
 
   externalPreAggregationQuery() {
-    if (this.options.cacheMode === 'no-cache') {
-      return false;
-    }
-
     if (!this.options.preAggregationQuery && !this.options.disableExternalPreAggregations && this.externalQueryClass) {
       const preAggregationForQuery = this.preAggregations.findPreAggregationForQuery();
       if (preAggregationForQuery?.preAggregation.external) {

packages/cubejs-schema-compiler/test/unit/pre-aggregations.test.ts

@@ -506,6 +506,90 @@ describe('pre-aggregations', () => {
     expect(preAggregationsDescription[0].preAggregationId).toEqual('orders.simple');
   });
 
+  it('no-cache should still match pre-aggregations', async () => {
+    const { compiler, cubeEvaluator, joinGraph } = prepareYamlCompiler(
+      createSchemaYaml(createECommerceSchema())
+    );
+
+    await compiler.compile();
+
+    const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
+      measures: [
+        'orders_view.count'
+      ],
+      timeDimensions: [{
+        dimension: 'orders_view.created_at',
+        granularity: 'day',
+        dateRange: ['2023-01-01', '2023-01-10']
+      }],
+      timezone: 'America/Los_Angeles',
+      cacheMode: 'no-cache',
+    });
+
+    const queryPreAggs: any = query.preAggregations?.preAggregationsDescription();
+    expect(queryPreAggs.length).toBeGreaterThan(0);
+    expect(queryPreAggs[0].preAggregationId).toEqual('orders.orders_by_day_with_day');
+  });
+
+  it('no-cache should still use external pre-aggregations', async () => {
+    const { compiler, cubeEvaluator, joinGraph } = prepareYamlCompiler(
+      createSchemaYaml({
+        cubes: [
+          {
+            name: 'orders',
+            sql_table: 'orders',
+            measures: [{
+              name: 'count',
+              type: 'count',
+            }],
+            dimensions: [
+              {
+                name: 'created_at',
+                sql: 'created_at',
+                type: 'time',
+              },
+              {
+                name: 'status',
+                sql: 'status',
+                type: 'string',
+              }
+            ],
+            preAggregations: [
+              {
+                name: 'orders_external',
+                measures: ['count'],
+                dimensions: ['status'],
+                timeDimension: 'CUBE.created_at',
+                granularity: 'day',
+                external: true,
+              },
+            ]
+          }
+        ]
+      })
+    );
+
+    await compiler.compile();
+
+    const query = new PostgresQuery({ joinGraph, cubeEvaluator, compiler }, {
+      measures: ['orders.count'],
+      dimensions: ['orders.status'],
+      timeDimensions: [{
+        dimension: 'orders.created_at',
+        granularity: 'day',
+        dateRange: ['2023-01-01', '2023-01-10']
+      }],
+      cacheMode: 'no-cache',
+      externalQueryClass: PostgresQuery,
+    });
+
+    expect(query.externalPreAggregationQuery()).toBe(true);
+
+    const preAggregationsDescription: any = query.preAggregations?.preAggregationsDescription();
+    expect(preAggregationsDescription.length).toBeGreaterThan(0);
+    expect(preAggregationsDescription[0].preAggregationId).toEqual('orders.orders_external');
+  });
+
   describe('rollup with multiplied measure', () => {
     let compiler;
     let cubeEvaluator;