From f8af8f695582033a273892318db0c53b5990fb7a Mon Sep 17 00:00:00 2001 From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com> Date: Tue, 19 May 2026 15:39:26 +0000 Subject: [PATCH 1/7] docs: add rollup join recipe for FX rates with mixed refresh cadences --- docs-mintlify/docs.json | 3 +- .../pre-aggregations/fx-rates-rollup-join.mdx | 338 ++++++++++++++++++ 2 files changed, 340 insertions(+), 1 deletion(-) create mode 100644 docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx diff --git a/docs-mintlify/docs.json b/docs-mintlify/docs.json index ce4e970f9f1b1..b7e39fee0b328 100644 --- a/docs-mintlify/docs.json +++ b/docs-mintlify/docs.json @@ -636,7 +636,8 @@ "recipes/pre-aggregations/disabling-pre-aggregations", "recipes/pre-aggregations/using-originalsql-and-rollups-effectively", "recipes/pre-aggregations/refreshing-select-partitions", - "recipes/pre-aggregations/joining-multiple-data-sources" + "recipes/pre-aggregations/joining-multiple-data-sources", + "recipes/pre-aggregations/fx-rates-rollup-join" ] }, { diff --git a/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx b/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx new file mode 100644 index 0000000000000..67f1fbfb6706d --- /dev/null +++ b/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx @@ -0,0 +1,338 @@ +--- +title: Joining slow-changing facts with frequently-updated FX rates +description: Use a rollup join to combine a heavy, slowly-refreshed sales pre-aggregation with a lightweight, frequently-refreshed FX rates pre-aggregation so currency-converted metrics stay fresh without rebuilding the full fact table. +--- + +## Use case + +Let's imagine we report sales in multiple currencies and want to display them +converted to USD. The sales fact table is large and expensive to aggregate, so +we'd like to refresh it on a slow cadence (for example, hourly). However, the +foreign exchange (FX) rates we use for conversion change frequently and need +to be refreshed every few minutes to stay accurate. + +Combining both into a single [rollup](/reference/data-modeling/pre-aggregations#rollup) +forces the entire pre-aggregation to refresh whenever FX rates change, which is +wasteful. In the recipe below, we'll learn how to use a +[rollup join](/reference/data-modeling/pre-aggregations#rollup_join) to keep +each pre-aggregation on its own refresh schedule while still serving the +combined, currency-converted query from pre-aggregations. + +## Data modeling + +We have two cubes: `orders`, which stores per-order amounts in the original +transaction currency, and `fx_rates`, which stores the latest exchange rate +from each currency to USD. + +First, define a `rollup` pre-aggregation on `orders` that aggregates the +amount by `currency` and day. This is the heavy pre-aggregation, so we set a +slow `refresh_key` — for example, every hour: + + + +```yaml title="YAML" +cubes: + - name: orders + + sql_table: public.orders + + joins: + - name: fx_rates + sql: "{CUBE}.currency = {fx_rates.currency}" + relationship: many_to_one + + dimensions: + - name: id + sql: id + type: number + primary_key: true + + - name: currency + sql: currency + type: string + + - name: created_at + sql: created_at + type: time + + measures: + - name: amount + sql: amount + type: sum + + pre_aggregations: + - name: orders_rollup + type: rollup + measures: + - amount + dimensions: + - currency + time_dimension: created_at + granularity: day + refresh_key: + every: 1 hour + indexes: + - name: currency_index + columns: + - currency +``` + +```javascript title="JavaScript" +cube(`orders`, { + sql_table: `public.orders`, + + joins: { + fx_rates: { + sql: `${CUBE}.currency = ${fx_rates.currency}`, + relationship: `many_to_one` + } + }, + + dimensions: { + id: { + sql: `id`, + type: `number`, + primary_key: true + }, + + currency: { + sql: `currency`, + type: `string` + }, + + created_at: { + sql: `created_at`, + type: `time` + } + }, + + measures: { + amount: { + sql: `amount`, + type: `sum` + } + }, + + pre_aggregations: { + orders_rollup: { + type: `rollup`, + measures: [amount], + dimensions: [currency], + time_dimension: created_at, + granularity: `day`, + refresh_key: { + every: `1 hour` + }, + indexes: { + currency_index: { + columns: [currency] + } + } + } + } +}) +``` + + + +Next, define a `rollup` pre-aggregation on `fx_rates`. This pre-aggregation is +small (one row per currency) and cheap to rebuild, so we set a fast +`refresh_key` — for example, every minute: + + + +```yaml title="YAML" +cubes: + - name: fx_rates + + sql_table: public.fx_rates + + dimensions: + - name: currency + sql: currency + type: string + primary_key: true + + - name: rate_to_usd + sql: rate_to_usd + type: number + + pre_aggregations: + - name: fx_rates_rollup + type: rollup + dimensions: + - currency + - rate_to_usd + refresh_key: + every: 1 minute + indexes: + - name: currency_index + columns: + - currency +``` + +```javascript title="JavaScript" +cube(`fx_rates`, { + sql_table: `public.fx_rates`, + + dimensions: { + currency: { + sql: `currency`, + type: `string`, + primary_key: true + }, + + rate_to_usd: { + sql: `rate_to_usd`, + type: `number` + } + }, + + pre_aggregations: { + fx_rates_rollup: { + type: `rollup`, + dimensions: [currency, rate_to_usd], + refresh_key: { + every: `1 minute` + }, + indexes: { + currency_index: { + columns: [currency] + } + } + } + } +}) +``` + + + + + Both pre-aggregations must include an index on the join key (`currency` in + this example) for the `rollup_join` to match. The `fx_rates_rollup` also + needs `rate_to_usd` as a dimension so it's available downstream. + + +Finally, define a `rollup_join` pre-aggregation on `orders` that references +both rollups. This is an ephemeral pre-aggregation — it doesn't materialize +its own data, so it doesn't need a `refresh_key`. Cube serves queries from it +by joining the two underlying rollups on the fly: + + + +```yaml title="YAML" +cubes: + - name: orders + # ... + + pre_aggregations: + # ... + + - name: orders_with_fx_rollup + type: rollup_join + measures: + - amount + dimensions: + - currency + - fx_rates.rate_to_usd + time_dimension: created_at + granularity: day + rollups: + - fx_rates.fx_rates_rollup + - orders_rollup +``` + +```javascript title="JavaScript" +cube(`orders`, { + // ... + + pre_aggregations: { + // ... + + orders_with_fx_rollup: { + type: `rollup_join`, + measures: [amount], + dimensions: [currency, fx_rates.rate_to_usd], + time_dimension: created_at, + granularity: `day`, + rollups: [fx_rates.fx_rates_rollup, orders_rollup] + } + } +}) +``` + + + +To expose the USD-converted amount, add a derived measure on `orders` that +multiplies the order amount by the FX rate from the joined cube: + + + +```yaml title="YAML" +cubes: + - name: orders + # ... + + measures: + # ... + + - name: amount_usd + sql: "{CUBE.amount} * {fx_rates.rate_to_usd}" + type: number +``` + +```javascript title="JavaScript" +cube(`orders`, { + // ... + + measures: { + // ... + + amount_usd: { + sql: `${CUBE.amount} * ${fx_rates.rate_to_usd}`, + type: `number` + } + } +}) +``` + + + +## Query + +Let's query daily sales in USD by currency: + +```json +{ + "measures": ["orders.amount_usd"], + "dimensions": ["orders.currency"], + "timeDimensions": [ + { + "dimension": "orders.created_at", + "granularity": "day" + } + ] +} +``` + +## Result + +Cube serves the query from `orders_with_fx_rollup`, joining the cached +`orders_rollup` (refreshed hourly) with the cached `fx_rates_rollup` +(refreshed every minute). The heavy aggregation never rebuilds when FX rates +change, but the converted totals always reflect the latest rates. + +```javascript +[ + { + "orders.created_at.day": "2026-05-19T00:00:00.000", + "orders.currency": "EUR", + "orders.amount_usd": "12450.32" + }, + { + "orders.created_at.day": "2026-05-19T00:00:00.000", + "orders.currency": "GBP", + "orders.amount_usd": "8930.17" + } +] +``` From c22ae5afa7da34101865d40c12bab9e4218b70a9 Mon Sep 17 00:00:00 2001 From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com> Date: Tue, 19 May 2026 16:12:48 +0000 Subject: [PATCH 2/7] docs: default refresh_key cadence to 1 hour in FX rates recipe --- .../pre-aggregations/fx-rates-rollup-join.mdx | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx b/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx index 67f1fbfb6706d..6a17e50a44f89 100644 --- a/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx +++ b/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx @@ -9,7 +9,7 @@ Let's imagine we report sales in multiple currencies and want to display them converted to USD. The sales fact table is large and expensive to aggregate, so we'd like to refresh it on a slow cadence (for example, hourly). However, the foreign exchange (FX) rates we use for conversion change frequently and need -to be refreshed every few minutes to stay accurate. +to be refreshed more often than the heavy fact aggregation. Combining both into a single [rollup](/reference/data-modeling/pre-aggregations#rollup) forces the entire pre-aggregation to refresh whenever FX rates change, which is @@ -136,8 +136,8 @@ cube(`orders`, { Next, define a `rollup` pre-aggregation on `fx_rates`. This pre-aggregation is -small (one row per currency) and cheap to rebuild, so we set a fast -`refresh_key` — for example, every minute: +small (one row per currency) and cheap to rebuild, so we keep the same +hourly `refresh_key` as the orders rollup: @@ -164,7 +164,7 @@ cubes: - currency - rate_to_usd refresh_key: - every: 1 minute + every: 1 hour indexes: - name: currency_index columns: @@ -193,7 +193,7 @@ cube(`fx_rates`, { type: `rollup`, dimensions: [currency, rate_to_usd], refresh_key: { - every: `1 minute` + every: `1 hour` }, indexes: { currency_index: { @@ -319,7 +319,7 @@ Let's query daily sales in USD by currency: Cube serves the query from `orders_with_fx_rollup`, joining the cached `orders_rollup` (refreshed hourly) with the cached `fx_rates_rollup` -(refreshed every minute). The heavy aggregation never rebuilds when FX rates +(also refreshed hourly). The heavy aggregation never rebuilds when FX rates change, but the converted totals always reflect the latest rates. ```javascript From 0beb51ba8b3ba89dbec7d445613b399a4ce51011 Mon Sep 17 00:00:00 2001 From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com> Date: Tue, 19 May 2026 16:15:42 +0000 Subject: [PATCH 3/7] docs: add sample base table data and switch refresh cadence to 1 day --- .../pre-aggregations/fx-rates-rollup-join.mdx | 36 ++++++++++++++----- 1 file changed, 27 insertions(+), 9 deletions(-) diff --git a/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx b/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx index 6a17e50a44f89..ce023fb85b08b 100644 --- a/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx +++ b/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx @@ -7,7 +7,7 @@ description: Use a rollup join to combine a heavy, slowly-refreshed sales pre-ag Let's imagine we report sales in multiple currencies and want to display them converted to USD. The sales fact table is large and expensive to aggregate, so -we'd like to refresh it on a slow cadence (for example, hourly). However, the +we'd like to refresh it on a slow cadence (for example, daily). However, the foreign exchange (FX) rates we use for conversion change frequently and need to be refreshed more often than the heavy fact aggregation. @@ -24,9 +24,27 @@ We have two cubes: `orders`, which stores per-order amounts in the original transaction currency, and `fx_rates`, which stores the latest exchange rate from each currency to USD. +The `orders` table looks like this: + +| id | currency | amount | created_at | +|----|----------|---------|---------------------| +| 1 | EUR | 120.00 | 2026-05-18 09:14:22 | +| 2 | GBP | 75.50 | 2026-05-18 11:02:47 | +| 3 | EUR | 245.10 | 2026-05-19 08:31:05 | +| 4 | USD | 310.00 | 2026-05-19 10:18:33 | +| 5 | GBP | 89.99 | 2026-05-19 12:44:51 | + +The `fx_rates` table looks like this: + +| currency | rate_to_usd | +|----------|-------------| +| EUR | 1.085 | +| GBP | 1.262 | +| USD | 1.000 | + First, define a `rollup` pre-aggregation on `orders` that aggregates the amount by `currency` and day. This is the heavy pre-aggregation, so we set a -slow `refresh_key` — for example, every hour: +slow `refresh_key` — for example, every day: @@ -70,7 +88,7 @@ cubes: time_dimension: created_at granularity: day refresh_key: - every: 1 hour + every: 1 day indexes: - name: currency_index columns: @@ -121,7 +139,7 @@ cube(`orders`, { time_dimension: created_at, granularity: `day`, refresh_key: { - every: `1 hour` + every: `1 day` }, indexes: { currency_index: { @@ -137,7 +155,7 @@ cube(`orders`, { Next, define a `rollup` pre-aggregation on `fx_rates`. This pre-aggregation is small (one row per currency) and cheap to rebuild, so we keep the same -hourly `refresh_key` as the orders rollup: +daily `refresh_key` as the orders rollup: @@ -164,7 +182,7 @@ cubes: - currency - rate_to_usd refresh_key: - every: 1 hour + every: 1 day indexes: - name: currency_index columns: @@ -193,7 +211,7 @@ cube(`fx_rates`, { type: `rollup`, dimensions: [currency, rate_to_usd], refresh_key: { - every: `1 hour` + every: `1 day` }, indexes: { currency_index: { @@ -318,8 +336,8 @@ Let's query daily sales in USD by currency: ## Result Cube serves the query from `orders_with_fx_rollup`, joining the cached -`orders_rollup` (refreshed hourly) with the cached `fx_rates_rollup` -(also refreshed hourly). The heavy aggregation never rebuilds when FX rates +`orders_rollup` (refreshed daily) with the cached `fx_rates_rollup` +(also refreshed daily). The heavy aggregation never rebuilds when FX rates change, but the converted totals always reflect the latest rates. ```javascript From eb0607c0e8f3f21afc6ff1fd998f539a0ae1cfe2 Mon Sep 17 00:00:00 2001 From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com> Date: Tue, 19 May 2026 16:48:04 +0000 Subject: [PATCH 4/7] docs: refresh FX rates rollup hourly to match recipe narrative --- .../recipes/pre-aggregations/fx-rates-rollup-join.mdx | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx b/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx index ce023fb85b08b..6afa04125e68c 100644 --- a/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx +++ b/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx @@ -154,8 +154,8 @@ cube(`orders`, { Next, define a `rollup` pre-aggregation on `fx_rates`. This pre-aggregation is -small (one row per currency) and cheap to rebuild, so we keep the same -daily `refresh_key` as the orders rollup: +small (one row per currency) and cheap to rebuild, so we give it a much +faster `refresh_key` than the orders rollup — for example, every hour: @@ -182,7 +182,7 @@ cubes: - currency - rate_to_usd refresh_key: - every: 1 day + every: 1 hour indexes: - name: currency_index columns: @@ -211,7 +211,7 @@ cube(`fx_rates`, { type: `rollup`, dimensions: [currency, rate_to_usd], refresh_key: { - every: `1 day` + every: `1 hour` }, indexes: { currency_index: { @@ -337,7 +337,7 @@ Let's query daily sales in USD by currency: Cube serves the query from `orders_with_fx_rollup`, joining the cached `orders_rollup` (refreshed daily) with the cached `fx_rates_rollup` -(also refreshed daily). The heavy aggregation never rebuilds when FX rates +(refreshed hourly). The heavy aggregation never rebuilds when FX rates change, but the converted totals always reflect the latest rates. ```javascript From cb9bd60568e1d27a123a18476b579be940286970 Mon Sep 17 00:00:00 2001 From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com> Date: Tue, 19 May 2026 18:34:22 +0000 Subject: [PATCH 5/7] docs: add FX rates rollup join card to recipes home --- docs-mintlify/recipes/index.mdx | 3 +++ 1 file changed, 3 insertions(+) diff --git a/docs-mintlify/recipes/index.mdx b/docs-mintlify/recipes/index.mdx index 4b9406ea8797b..7a418918aabe1 100644 --- a/docs-mintlify/recipes/index.mdx +++ b/docs-mintlify/recipes/index.mdx @@ -108,6 +108,9 @@ pre-aggregations, configuration, APIs, and AI. Join data from different warehouses with cross-database rollup joins. + + Combine a slow-changing fact rollup with a frequently-refreshed FX rates rollup for fresh currency-converted metrics. + ## Configuration From 9938598031f1b1814f22b1d708ae3c13e1c3aed9 Mon Sep 17 00:00:00 2001 From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com> Date: Tue, 19 May 2026 18:38:36 +0000 Subject: [PATCH 6/7] docs: generalize rollup join recipe to mixed refresh cadences pattern --- docs-mintlify/docs.json | 2 +- docs-mintlify/recipes/index.mdx | 4 +- ...=> mixed-refresh-cadences-rollup-join.mdx} | 46 ++++++++++++++----- 3 files changed, 38 insertions(+), 14 deletions(-) rename docs-mintlify/recipes/pre-aggregations/{fx-rates-rollup-join.mdx => mixed-refresh-cadences-rollup-join.mdx} (77%) diff --git a/docs-mintlify/docs.json b/docs-mintlify/docs.json index b7e39fee0b328..b9aab32aa5cb7 100644 --- a/docs-mintlify/docs.json +++ b/docs-mintlify/docs.json @@ -637,7 +637,7 @@ "recipes/pre-aggregations/using-originalsql-and-rollups-effectively", "recipes/pre-aggregations/refreshing-select-partitions", "recipes/pre-aggregations/joining-multiple-data-sources", - "recipes/pre-aggregations/fx-rates-rollup-join" + "recipes/pre-aggregations/mixed-refresh-cadences-rollup-join" ] }, { diff --git a/docs-mintlify/recipes/index.mdx b/docs-mintlify/recipes/index.mdx index 7a418918aabe1..ac6e5eddd03e9 100644 --- a/docs-mintlify/recipes/index.mdx +++ b/docs-mintlify/recipes/index.mdx @@ -108,8 +108,8 @@ pre-aggregations, configuration, APIs, and AI. Join data from different warehouses with cross-database rollup joins. - - Combine a slow-changing fact rollup with a frequently-refreshed FX rates rollup for fresh currency-converted metrics. + + Combine a slow-changing fact rollup with a frequently-refreshed lookup rollup using a rollup join. diff --git a/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx b/docs-mintlify/recipes/pre-aggregations/mixed-refresh-cadences-rollup-join.mdx similarity index 77% rename from docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx rename to docs-mintlify/recipes/pre-aggregations/mixed-refresh-cadences-rollup-join.mdx index 6afa04125e68c..7568878fc0113 100644 --- a/docs-mintlify/recipes/pre-aggregations/fx-rates-rollup-join.mdx +++ b/docs-mintlify/recipes/pre-aggregations/mixed-refresh-cadences-rollup-join.mdx @@ -1,22 +1,46 @@ --- -title: Joining slow-changing facts with frequently-updated FX rates -description: Use a rollup join to combine a heavy, slowly-refreshed sales pre-aggregation with a lightweight, frequently-refreshed FX rates pre-aggregation so currency-converted metrics stay fresh without rebuilding the full fact table. +title: Joining pre-aggregations with different refresh cadences +description: Use a rollup join to combine a heavy, slowly-refreshed fact pre-aggregation with a lightweight, frequently-refreshed lookup pre-aggregation so derived metrics stay fresh without rebuilding the full fact table. --- ## Use case -Let's imagine we report sales in multiple currencies and want to display them -converted to USD. The sales fact table is large and expensive to aggregate, so -we'd like to refresh it on a slow cadence (for example, daily). However, the -foreign exchange (FX) rates we use for conversion change frequently and need -to be refreshed more often than the heavy fact aggregation. +A common modeling problem is computing a metric that depends on two inputs +which change at very different rates: -Combining both into a single [rollup](/reference/data-modeling/pre-aggregations#rollup) -forces the entire pre-aggregation to refresh whenever FX rates change, which is -wasteful. In the recipe below, we'll learn how to use a +- A **large fact table** that is expensive to aggregate and only needs to be + refreshed on a slow cadence (for example, daily or hourly). +- A **small lookup table** whose values are applied to each fact row and that + needs to be refreshed much more frequently than the fact aggregation. + +Some examples of this pattern: + +- Converting an amount column to a target currency using the latest foreign + exchange (FX) rates — either a single-currency column multiplied by a rate, + or an `amount` and `currency` column resolved with a `CASE` statement. +- Re-pricing inventory or order lines with a frequently-updated price list. +- Applying a frequently-tuned scoring weight, tax rate, or commission rate to + historical events. + +Combining both inputs into a single [rollup](/reference/data-modeling/pre-aggregations#rollup) +forces the entire pre-aggregation to refresh whenever the lookup values +change, which is wasteful. In the recipe below, we'll learn how to use a [rollup join](/reference/data-modeling/pre-aggregations#rollup_join) to keep each pre-aggregation on its own refresh schedule while still serving the -combined, currency-converted query from pre-aggregations. +combined, derived query from pre-aggregations. + +We'll walk through the FX conversion variant as a concrete example, but the +same pattern applies to any of the use cases above. + + + `rollup_join` has several constraints documented on the + [pre-aggregations reference page](/reference/data-modeling/pre-aggregations#rollup_join). + In particular: it is currently in Preview, it is designed for joining data + across data sources, it can only join two rollups, neither rollup can have + more than one partition (so at least one side must be under ~1M rows), and + it is ephemeral — set freshness controls on the referenced rollups rather + than on the `rollup_join` itself. + ## Data modeling From c776b1097678baf12be2dc9a96c7b1a6baa22f17 Mon Sep 17 00:00:00 2001 From: "mintlify[bot]" <109931778+mintlify[bot]@users.noreply.github.com> Date: Fri, 22 May 2026 18:08:41 +0000 Subject: [PATCH 7/7] docs: update rollup_join warnings with Cube Store partition limits --- .../mixed-refresh-cadences-rollup-join.mdx | 15 +++++++++++---- .../reference/data-modeling/pre-aggregations.mdx | 16 +++++++++++----- 2 files changed, 22 insertions(+), 9 deletions(-) diff --git a/docs-mintlify/recipes/pre-aggregations/mixed-refresh-cadences-rollup-join.mdx b/docs-mintlify/recipes/pre-aggregations/mixed-refresh-cadences-rollup-join.mdx index 7568878fc0113..be59c9cb0b208 100644 --- a/docs-mintlify/recipes/pre-aggregations/mixed-refresh-cadences-rollup-join.mdx +++ b/docs-mintlify/recipes/pre-aggregations/mixed-refresh-cadences-rollup-join.mdx @@ -36,10 +36,17 @@ same pattern applies to any of the use cases above. `rollup_join` has several constraints documented on the [pre-aggregations reference page](/reference/data-modeling/pre-aggregations#rollup_join). In particular: it is currently in Preview, it is designed for joining data - across data sources, it can only join two rollups, neither rollup can have - more than one partition (so at least one side must be under ~1M rows), and - it is ephemeral — set freshness controls on the referenced rollups rather - than on the `rollup_join` itself. + across data sources, it can only join two rollups, and it is ephemeral — + set freshness controls on the referenced rollups rather than on the + `rollup_join` itself. + + The rollup on the right side of the join is also bounded by the number of + physical Cube Store partitions it can have, which depends on your Cube + Store compute tier. Note that these are Cube Store physical partitions — + not Cube logical partitions — and each one is roughly 50 MB in size and + contains up to ~1M rows. The exact per-tier limits are still being + finalized, but expect on the order of 5, 10, and 20 physical partitions + for S, M, and L tiers respectively. ## Data modeling diff --git a/docs-mintlify/reference/data-modeling/pre-aggregations.mdx b/docs-mintlify/reference/data-modeling/pre-aggregations.mdx index 46e983ee14ee1..eb87efd60b62a 100644 --- a/docs-mintlify/reference/data-modeling/pre-aggregations.mdx +++ b/docs-mintlify/reference/data-modeling/pre-aggregations.mdx @@ -219,11 +219,17 @@ version. Rollup join is designed to join data across different data sources. -To join data within the same data source you can list members from different cubes within a regular rollup. -Rollup join can be used only to join two tables, and one can't contain more than -one partition so that the join can operate correctly. It means that at least one -table should be less than 1M of rows. There's work in progress to remove those -limitations. +To join data within the same data source you can list members from different +cubes within a regular rollup. Rollup join can be used only to join two +rollups. + +The rollup on the right side of the join is bounded by the number of physical +Cube Store partitions it can have, which depends on your Cube Store compute +tier. Note that these are Cube Store physical partitions — not Cube logical +partitions — and each one is roughly 50 MB in size and contains up to ~1M +rows. The exact per-tier limits are still being finalized, but expect on the +order of 5, 10, and 20 physical partitions for S, M, and L tiers +respectively.