fix: Exclude out-of-range rollupLambda partitions

packages/cubejs-query-orchestrator/src/orchestrator/PreAggregationPartitionRangeLoader.ts

@@ -274,7 +274,11 @@ export class PreAggregationPartitionRangeLoader {
         }
         const rollupLambdaResults = this.preAggregationsTablesToTempTables.filter(tempTableResult => tempTableResult[1].rollupLambdaId === this.preAggregation.rollupLambdaId);
         const filteredResults = loadResults.filter(
-          r => (this.preAggregation.lastRollupLambda || reformatInIsoLocal(r.buildRangeEnd) === reformatInIsoLocal(r.partitionRange[1])) &&
+          r => (!this.preAggregation.matchedTimeDimensionDateRange || !!PreAggregationPartitionRangeLoader.intersectDateRanges(
+            r.partitionRange,
+            this.preAggregation.matchedTimeDimensionDateRange
+          )) &&
+            (this.preAggregation.lastRollupLambda || reformatInIsoLocal(r.buildRangeEnd) === reformatInIsoLocal(r.partitionRange[1])) &&
             rollupLambdaResults.every(result => !result[1].buildRangeEnd || reformatInIsoLocal(result[1].buildRangeEnd) < reformatInIsoLocal(r.partitionRange[0]))
         );
         if (filteredResults.length === 0) {

packages/cubejs-query-orchestrator/test/unit/PreAggregations.test.ts

@@ -93,14 +93,18 @@ const mockPreAggregation = (overrides: Record<string, any> = {}) => ({
   ...overrides,
 });
 
-const createLoader = (overrides: Record<string, any> = {}, options: Record<string, any> = {}) => {
+const createLoader = (
+  overrides: Record<string, any> = {},
+  options: Record<string, any> = {},
+  preAggregationsTablesToTempTables: any[] = [],
+) => {
   const loader = new PreAggregationPartitionRangeLoader(
     {} as any, // driverFactory
     {} as any, // logger
     { options: {} } as any, // queryCache
     {} as any, // preAggregations
     mockPreAggregation(overrides) as any,
-    [], // preAggregationsTablesToTempTables
+    preAggregationsTablesToTempTables,
     {} as any, // loadCache
     options as any,
   );
@@ -581,6 +585,103 @@ describe('PreAggregations', () => {
     });
   });
 
+  describe('rollupLambda partition filtering', () => {
+    let loadPreAggregationMock: jest.SpyInstance;
+
+    beforeEach(() => {
+      loadPreAggregationMock = jest.spyOn(PreAggregationLoader.prototype, 'loadPreAggregation').mockResolvedValue({
+        targetTableName: 'hot_partition',
+        refreshKeyValues: [],
+        lastUpdatedAt: 1,
+        buildRangeEnd: '2024-02-01T23:59:59.999',
+      });
+    });
+
+    afterEach(() => {
+      loadPreAggregationMock.mockRestore();
+    });
+
+    test('should return an empty result for an out-of-range last rollupLambda partition', async () => {
+      const loader = createLoader({
+        rollupLambdaId: 'orders.lambda',
+        lastRollupLambda: true,
+        matchedTimeDimensionDateRange: ['2024-01-01T00:00:00.000', '2024-01-31T23:59:59.999'],
+      });
+      jest.spyOn(loader as any, 'partitionRanges').mockResolvedValue({
+        buildRange: ['2024-02-01T00:00:00.000', '2024-02-01T23:59:59.999'],
+        partitionRanges: [['2024-02-01T00:00:00.000', '2024-02-01T23:59:59.999']],
+      });
+
+      const result = await loader.loadPreAggregations();
+
+      expect(result.targetTableName).toBe('(SELECT * FROM hot_partition WHERE 1 = 0)');
+      expect(result.buildRangeEnd).toBeFalsy();
+    });
+
+    test('should retain a last rollupLambda partition that overlaps the requested range', async () => {
+      const loader = createLoader(
+        {
+          rollupLambdaId: 'orders.lambda',
+          lastRollupLambda: true,
+          matchedTimeDimensionDateRange: ['2024-01-30T12:00:00.000', '2024-01-31T23:59:59.999'],
+        },
+        {},
+        [[
+          'batch_rollup',
+          {
+            targetTableName: 'batch_partition',
+            refreshKeyValues: [],
+            lastUpdatedAt: 1,
+            buildRangeEnd: '2024-01-30T23:59:59.999',
+            rollupLambdaId: 'orders.lambda',
+          },
+        ]],
+      );
+      jest.spyOn(loader as any, 'partitionRanges').mockResolvedValue({
+        buildRange: ['2024-01-31T00:00:00.000', '2024-02-01T23:59:59.999'],
+        partitionRanges: [['2024-01-31T00:00:00.000', '2024-02-01T23:59:59.999']],
+      });
+
+      const result = await loader.loadPreAggregations();
+
+      expect(result.targetTableName).toBe('hot_partition');
+      expect(result.buildRangeEnd).toBe('2024-02-01T23:59:59.999');
+    });
+
+    test('should retain existing rollupLambda filtering without a matched range', async () => {
+      const loader = createLoader({
+        rollupLambdaId: 'orders.lambda',
+        lastRollupLambda: true,
+      });
+      jest.spyOn(loader as any, 'partitionRanges').mockResolvedValue({
+        buildRange: ['2024-02-01T00:00:00.000', '2024-02-01T23:59:59.999'],
+        partitionRanges: [['2024-02-01T00:00:00.000', '2024-02-01T23:59:59.999']],
+      });
+
+      const result = await loader.loadPreAggregations();
+
+      expect(result.targetTableName).toBe('hot_partition');
+      expect(result.buildRangeEnd).toBe('2024-02-01T23:59:59.999');
+    });
+
+    test('should retain a rollupLambda partition that touches the requested range boundary', async () => {
+      const loader = createLoader({
+        rollupLambdaId: 'orders.lambda',
+        lastRollupLambda: true,
+        matchedTimeDimensionDateRange: ['2024-01-31T00:00:00.000', '2024-02-01T00:00:00.000'],
+      });
+      jest.spyOn(loader as any, 'partitionRanges').mockResolvedValue({
+        buildRange: ['2024-02-01T00:00:00.000', '2024-02-01T23:59:59.999'],
+        partitionRanges: [['2024-02-01T00:00:00.000', '2024-02-01T23:59:59.999']],
+      });
+
+      const result = await loader.loadPreAggregations();
+
+      expect(result.targetTableName).toBe('hot_partition');
+      expect(result.buildRangeEnd).toBe('2024-02-01T23:59:59.999');
+    });
+  });
+
   describe('partitionTableName', () => {
     test('should generate correct table names for different granularities', () => {
       const testDateRange: [string, string] = ['2024-01-05T12:34:56.789', '2024-01-05T23:59:59.999'];