diff --git a/.basedpyright/baseline.json b/.basedpyright/baseline.json index 2559ade4..fc937f4b 100644 --- a/.basedpyright/baseline.json +++ b/.basedpyright/baseline.json @@ -28470,344 +28470,6 @@ } } ], - "./tests/test_recommend_root_model_surfaces.py": [ - { - "code": "reportIndexIssue", - "range": { - "startColumn": 15, - "endColumn": 21, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 15, - "endColumn": 21, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 15, - "endColumn": 21, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 15, - "endColumn": 21, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 15, - "endColumn": 21, - "lineCount": 1 - } - }, - { - "code": "reportAttributeAccessIssue", - "range": { - "startColumn": 25, - "endColumn": 29, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportAttributeAccessIssue", - "range": { - "startColumn": 39, - "endColumn": 43, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportAttributeAccessIssue", - "range": { - "startColumn": 39, - "endColumn": 43, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 27, - "endColumn": 33, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 27, - "endColumn": 33, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 27, - "endColumn": 33, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 27, - "endColumn": 33, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 27, - "endColumn": 33, - "lineCount": 1 - } - }, - { - "code": "reportAttributeAccessIssue", - "range": { - "startColumn": 37, - "endColumn": 41, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 19, - "endColumn": 25, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 19, - "endColumn": 25, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 19, - "endColumn": 25, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 19, - "endColumn": 25, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 19, - "endColumn": 25, - "lineCount": 1 - } - }, - { - "code": "reportAttributeAccessIssue", - "range": { - "startColumn": 29, - "endColumn": 33, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 29, - "endColumn": 35, - "lineCount": 1 - } - }, - { - "code": "reportAttributeAccessIssue", - "range": { - "startColumn": 39, - "endColumn": 43, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 27, - "endColumn": 33, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 27, - "endColumn": 33, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 27, - "endColumn": 33, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 27, - "endColumn": 33, - "lineCount": 1 - } - }, - { - "code": "reportIndexIssue", - "range": { - "startColumn": 27, - "endColumn": 33, - "lineCount": 1 - } - }, - { - "code": "reportAttributeAccessIssue", - "range": { - "startColumn": 37, - "endColumn": 41, - "lineCount": 1 - } - } - ], "./tests/test_reference_semantics.py": [ { "code": "reportArgumentType", diff --git a/architecture/semantics.arc42.md b/architecture/semantics.arc42.md index 032e86af..7aa2ecad 100644 --- a/architecture/semantics.arc42.md +++ b/architecture/semantics.arc42.md @@ -102,6 +102,12 @@ is the coercion from coarser to finer. together; everything that crosses a non-determining path is defined in terms of it. [review] Association is derivable from forward join declarations alone (bidirectional traversal). + - **3.1 Unrelated datasets.** A dataset no join path reaches from a query's + population meets it as the product `P × D`, every row with every row, + reached only by naming `D` as a query path's first hop, never by route + search. Only aggregates and filters (Axiom 14) read across `×`; any other + row-level read is a type error, so `×` never multiplies the population. + [enforced: test:tests/test_unrelated_datasets.py] [enforced: test:tests/test_dev1853_mirror_parity.py] [enforced: test:tests/test_dev1935_boolean_lowering.py] 4. **The home-dataset axiom**: an aggregation runs over the rows of its home diff --git a/docs/concepts/formulas.md b/docs/concepts/formulas.md index 7e941131..d3419e16 100644 --- a/docs/concepts/formulas.md +++ b/docs/concepts/formulas.md @@ -264,10 +264,10 @@ When a measure is renamed via `name`, query filters and ORDER BY entries in the | `+` | `"sum(revenue) + sum(bonus)"` | `SUM(revenue) + SUM(bonus)` | | `-` | `"sum(revenue) - sum(cost)"` | `SUM(revenue) - SUM(cost)` | | `*` | `"avg(price) * sum(quantity)"` | `AVG(price) * SUM(quantity)` | -| `/` | `"sum(revenue) / count(*)"` | `SUM(revenue) / COUNT(*)` | +| `/` | `"sum(revenue) / count(*)"` | `SUM(revenue) / NULLIF(COUNT(*), 0)` | | `**` | `"sum(value) ** 2"` | `SUM(value) ** 2` | -Parentheses work as expected: `"(sum(revenue) - sum(cost)) / count(*)"`. +Parentheses work as expected: `"(sum(revenue) - sum(cost)) / count(*)"`. Division by zero is NULL on every backend. All measure names referenced in the formula must exist in the model (except `*` which is always available). For measures from joined models, use a dotted path inside the aggregation: `"avg(customers.score)"` or multi-hop: `"sum(customers.regions.population)"`. Joins are auto-resolved by walking the join graph. See [Cross-Model Measures](queries.md#cross-model-measures). diff --git a/docs/concepts/queries.md b/docs/concepts/queries.md index 1372dba0..05fb1d9c 100644 --- a/docs/concepts/queries.md +++ b/docs/concepts/queries.md @@ -263,7 +263,7 @@ Query results are returned as a `SlayerResponse`: | `row_count` | int | Number of rows | | `sql` | string | The generated SQL (useful for debugging) | | `attributes` | ResponseAttributes | Field metadata split by type: `attributes.dimensions` and `attributes.measures`, each a dict of column alias → FieldMetadata (label, format) | -| `warnings` | list[SlayerWarning] | Advisories, discriminated by `kind`: input normalizations (`"normalization"`), a [cross-model measure broadcast](#cross-model-measures) (`"broadcast"` — `measure`, `location`, and per-dimension `dimensions[].reason`), a distinct-entity attribution over an unattributable dimension (`"associated"` — `measure`, `location`, `dimensions`; cells overlap and are not additive), a semi-join-pushed filter (`"semi_join_pushed"` — `measure` (`null` for a population-level push), `location`, `filter_text`), a query run without its statement timeout (`"statement_timeout_skipped"` — `datasource`, `timeout_seconds`, `reason`: `readonly_user` or `timeout_rejected`), and [`whole_periods_only`](time.md#whole_periods_only) over non-nesting granularities (`"whole_periods_non_nesting"` — `column`, `granularities`, `location`) | +| `warnings` | list[SlayerWarning] | Advisories, discriminated by `kind`: input normalizations (`"normalization"`), a [cross-model measure broadcast](#cross-model-measures) (`"broadcast"` — `measure`, `location`, and per-dimension `dimensions[].reason`), a distinct-entity attribution over an unattributable dimension (`"associated"` — `measure`, `location`, `dimensions`; cells overlap and are not additive), an aggregate over a model no join path reaches (`"unrelated_dataset"` — `dataset`, `population`, `measures`, `location`), a semi-join-pushed filter (`"semi_join_pushed"` — `measure` (`null` for a population-level push), `location`, `filter_text`), a query run without its statement timeout (`"statement_timeout_skipped"` — `datasource`, `timeout_seconds`, `reason`: `readonly_user` or `timeout_rejected`), and [`whole_periods_only`](time.md#whole_periods_only) over non-nesting granularities (`"whole_periods_non_nesting"` — `column`, `granularities`, `location`) | `columns` — and the key order of each row in `data` — follows the order you declared fields in the query: dimensions, then time dimensions, then measures, @@ -581,7 +581,7 @@ rec.root_model # "orders" (the only model that determines both to-one) # {"customers.name": "customers.name", "products.category": "products.category"} ``` -A root is valid when it **determines** every requested column along provably to-one join paths; saved measures and aggregation-suffixed items are attachments that only need to be reachable and never steer the choice (each `ItemPath` flags `attachment`). Among valid roots, the one with the fewest total join hops wins — the same rule as population inference, so the two surfaces cannot disagree. Root-owned items come back as a bare leaf (`status`); joined items as a dotted path (`customers.regions.name`), each hop spelled by its edge name when it has one (`customers.hr.name` for an edge named `hr`); aggregation suffixes are preserved (`sum(revenue)`). +A root is valid when it **determines** every requested column along provably to-one join paths; saved measures and aggregation-suffixed items are attachments that only need to be reachable and never steer the choice (each `ItemPath` flags `attachment`). Among valid roots, the one with the fewest total join hops wins — the same rule as population inference, so the two surfaces cannot disagree. Root-owned items come back as a bare leaf (`status`); joined items as a dotted path (`customers.regions.name`), each hop spelled by its edge name when it has one (`customers.hr.name` for an edge named `hr`); aggregation suffixes are preserved (`sum(revenue)`). With at least one column item, an attachment on a model no join path reaches never blocks a root: it comes back spelled from the root (`count(events.id)`) and flagged `unrelated`. When no single model reaches everything, `root_model` is `None`, `reachable` is `False`, and `coverage` lists the best partial roots (each with its reachable / unreachable items) so you can split the request into a multi-stage [`source_queries`](models.md#query-backed-models) query. @@ -779,6 +779,8 @@ Example: `{"source_model": "orders", "dimensions": ["status"], "measures": [{"fo Every input of an aggregate — its source, arguments (`weight=`), definition defaults, and its column-level `filter=` — is traced recursively through derived-column definitions, and an input whose expansion crosses a fanning (not provably to-one) hop fails closed with a typed error instead of silently multiplying rows. +A model (or query stage) that no join path reaches is read only through aggregates: rooted at `customers`, `{"formula": "count(events.id) / count(*)"}` computes `count(events.id)` over every event, repeats it on every row (per bucket of a `time_spine` time dimension) with a `kind: "unrelated_dataset"` warning, and a filter on it restricts its rows, while grouping, ordering or filtering by its columns alongside other models' is a typed error. + A filter **on** the cross-model value itself (`"avg(customers.score) > 4"`) restricts the result rows, uniformly with local aggregate filters — groups that fail the predicate are dropped, not returned with `NULL`. diff --git a/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/.openspec.yaml b/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/.openspec.yaml new file mode 100644 index 00000000..a216797d --- /dev/null +++ b/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/.openspec.yaml @@ -0,0 +1,2 @@ +schema: spec-driven +created: 2026-10-15 diff --git a/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/design.md b/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/design.md new file mode 100644 index 00000000..1bc0dce4 --- /dev/null +++ b/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/design.md @@ -0,0 +1,51 @@ +## Context + +See proposal.md (Why). The walker (`slayer/core/join_walker.py`) already models a keyless meeting: a dataset with no to-one chain to an axis meets the time spine through a product edge (`_detached_edge`, `join_pairs: []`, many-to-many), and its aggregates attach at the empty grain by `CROSS JOIN` with a `broadcast` warning. Outside spine queries, a first hop with no edge and no route fails in binding (`slayer/engine/dimension_routing.py`). The binding bundle (`slayer/engine/bundle_builder.py`) holds only the root's connected component plus explicit join targets, and binding never reads storage afterwards (engine P3). + +Governing principles: semantics Axioms 1, 2.2/2.8, 3 and the approved 3.1, 4, 7, 8, 10, 12, 14, 15; engine P3, P5, P9, P10, P11; sql P7, P12; core P5; system P13, P15. + +## Goals / Non-Goals + +**Goals:** +- Reduce unrelated datasets to the one existing product concept; every downstream behaviour comes from existing machinery or from one central product rule. +- Make "no row explosion" and "no quadratic evaluation" structural: guaranteed by what the checker admits, not by runtime guards. + +**Non-Goals:** +- Row-level cross joins, including reading a one-row stage's field without aggregating it. +- The unit population for measures-only queries (DEV-2095) and the zero-match filter corner case (DEV-2094). +- Unrelated references inside stored definitions. + +## Decisions + +### D1. One product hop, discriminated +A product hop is an oriented hop with a typed discriminator (not inferred from empty `join_pairs` or from the spine target). The spine's product and detached edges and the new unrelated hop share it. Generic consumers fail closed on it: join rendering, rerooting, association-kernel building, row scopes, and semi-join correlation. Only the checker-admitted paths (D3) consume it. *Alternative:* an ordinary `OrientedJoin` with empty pairs (rejected; Codex finding 3). `is_product_edge` today keys on the spine target, so any generic path it doesn't cover would render a cartesian join. + +### D2. Resolution only in strict first-hop binding +The unrelated hop is minted only when strict resolution of a query frame's first token finds no edge and no route, and the token names a dataset in the bundle's unrelated set. `neighbors`, `edges_between` and every `join_search` function never yield it. So route counting, short-form routing, population inference, `blocking_pairs` and the determination probe are unchanged by construction. + +### D3. One central product rule on dependency closures +"Crosses a product hop" is a property of a reference's dependency closure (engine P10). The checker admits a product-crossing closure in exactly two places: +- beneath an aggregation whose whole input closure (source, column-valued parameters, definition defaults, column filters) lies on the unrelated dataset's side; +- in a field-filter conjunct whose closure lies wholly on one side. + +Everything else raises the new `QueryTypeError` subclass, or the existing input-safety error for mixed aggregation inputs. This one rule covers dimensions, time dimensions, computed-dimension operands, order keys, raw rows, hidden filter and order slots, and derived or saved definitions reached through the hop. + +### D4. Bundle collection before binding +A pre-binding syntax pass collects, per query frame, the first-hop tokens of every reference (measures, dimensions, filters, order, `partition_by`, computed dimensions) that the connected bundle cannot resolve. It resolves them once against the caller's access-scoped storage for the population's datasource, plus the query-local stage names, and records the found datasets as the bundle's unrelated set, each with its connected component. It never loads the whole datasource, and it records nothing for a hidden, unknown or other-datasource name, so those keep their existing errors (system P15). + +### D5. Emission: one producer per dataset and grain, attached cardinality-neutrally +An aggregate homed across the hop compiles as the existing producer, rooted at the unrelated dataset over its own rows, at its attributable grain: empty, or the spine bucket through its own axis. It attaches by `CROSS JOIN` at the empty grain (sql P7) or on the bucket. Associate mode uses a dedicated product disposition that emits the identical producer and differs only in the warning, never the association kernel (Codex finding 4). A one-sided `D` filter conjunct becomes a predicate inside `D`'s producers plus an uncorrelated `EXISTS` on the population. A one-sided population conjunct becomes an uncorrelated `EXISTS` inside each unrelated producer. Mixed conjuncts are refused (D3), so no emitted subquery correlates across the hop. + +### D6. Warning payload +`UnrelatedDatasetWarningPayload(kind="unrelated_dataset", dataset, population, measures, location)` in `slayer/core/warnings.py`. It is emitted once per unrelated dataset per stage and surfaced twice (core P5). The existing broadcast and associated payloads are untouched and fire independently. + +### D7. Root recommendation +Determination probing is unchanged. With at least one determination item, an attachment whose dataset has no join path to a candidate is excluded from that candidate's reachability test. After selection, it gets the product-hop path from the chosen root and `ItemPath.unrelated = True`. `ItemPath` gains `unrelated: bool = False`, serialised on every surface. + +## Risks / Trade-offs + +- [A wrong-model reference now returns values instead of failing] → the always-on `unrelated_dataset` warning names the dataset, and an unknown name still errors. +- [A generic code path consumes a product hop and emits a cartesian join] → the D1 discriminator fails closed in every generic consumer, and an SQL-shape test asserts each unrelated table appears only in its own producers and uncorrelated `EXISTS`. +- [The pre-binding collection misses a reference position] → spec scenario "References in every position are found" covers filters, order and `partition_by`; a missed position fails with today's error, never silently. +- [The zero-match filter empties the population] → pinned by a spec scenario as today's association semantics; DEV-2094 may revisit. +- [Merge conflicts with the in-flight MCP surface change (DEV-2083) on the `measures` description] → resolve at merge; the description budget test guards the result. diff --git a/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/proposal.md b/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/proposal.md new file mode 100644 index 00000000..9e63fb6a --- /dev/null +++ b/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/proposal.md @@ -0,0 +1,30 @@ +## Why + +One query cannot combine two models or stages that no join path connects: rooted at `customers`, `count(events.id)` fails with "no route to target", so "events per customer" needs two queries and a division done by the agent. SLayer already defines how unrelated datasets meet — a detached dataset meets the time spine as a product — so the algebra can admit the general case without new semantics, provided the product never multiplies result rows. + +## What Changes + +- A query-frame reference whose first hop names a dataset no join path reaches from the population (a model or query-local stage in the same datasource) resolves through a product hop `P × D` instead of failing; route search never takes it. +- Aggregates across `×` are homed on `D` and resolve per `to_many_handling` like any unattributable aggregate (broadcast by default; spine dimensions attribute through `D`'s own axis); they are computed over `D`'s own rows and attached cardinality-neutrally. +- Every other row-level read across `×` (dimension, time dimension, row-level computed-dimension operand or order key, raw rows) fails with a new typed checker error naming the remedy — so the result's rows are always the population's. +- Filters reading `D` keep the existing association semantics (Axiom 14). +- New warning kind `unrelated_dataset`, emitted whenever an aggregate crosses `×`. +- `recommend_root_model` resolves an attachment item on an unrelated dataset through the product hop and flags it `unrelated: true` (new `ItemPath` field). +- The `ValidationError` for a stage join with empty `join_pairs` names the aggregate remedy. +- Semantics Axiom 3 gains sub-clause 3.1 (Unrelated datasets). + +## Capabilities + +### New Capabilities +- `queries/unrelated-datasets`: resolution, aggregation, row-level refusal, filters, warnings, and the no-row-explosion guarantees for datasets with no join path from the population. + +### Modified Capabilities +- `queries/population`: root recommendation resolves attachments on unrelated datasets through the product hop and reports them as such. +- `mcp/tool-surface`: the `measures` guidance names the unrelated-dataset behaviour, and the documented idioms gain the unrelated ratio. + +## Impact + +- Code: `slayer/core/join_walker.py` (product hop resolution), binding / population / join-safety in `slayer/engine/`, the checker (new typed error), `slayer/core/warnings.py`, `slayer/core/models.py` (join_pairs message), root recommendation, MCP `measures` description. +- APIs: new warning kind on every surface; new `ItemPath.unrelated` field on Python / REST / CLI / MCP `recommend_root_model`; queries that failed with "no route to target" now return values with warnings. +- Docs: `docs/concepts/queries.md`, `recommend_root_model` reference docs; `architecture/semantics.arc42.md` Axiom 3.1. +- Downstream: slayer-evals' events-per-customer guard task becomes answerable in one query. diff --git a/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/specs/mcp/tool-surface/spec.md b/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/specs/mcp/tool-surface/spec.md new file mode 100644 index 00000000..73b8d739 --- /dev/null +++ b/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/specs/mcp/tool-surface/spec.md @@ -0,0 +1,119 @@ +## MODIFIED Requirements + +### Requirement: Query-language guidance lives on the owning schema field, once +Each piece of query-language guidance SHALL appear in exactly one place across the `query` tool description and every description in its input schema (field- and definition-level), namely the field where an agent writes that value: +- `measures`: aggregation call form; arithmetic combining aggregates over different models, with a cross-model ratio example rooted at customers; `partition_by=` with keys spelled like the query's dimensions (dotted paths), a share-of-group example and `partition_by=[]` for the grand total; `window=` with compact durations (`'90d'`, `'3m'`); nested aggregation; one line per transform (`cumsum`, `change` / `change_pct`, `time_shift`, `lag` / `lead`, `rank` / `dense_rank` with required direction, `ntile`, `consecutive_periods`); a joined model's aggregate is computed over that model's own rows, broadcast across dimensions it cannot be attributed to unless `to_many_handling` is `associate`; aggregates over several child models in one query (orders and returns from customers) are each computed over their own rows; a child row without a parent counts in the NULL row of a parent dimension when that row exists and in an ungrouped total, and is never added again; an aggregate over a model no join path reaches from the population is computed over that model's own rows and repeated on every row, with an `unrelated_dataset` warning. +- `dimensions`: group by naturally readable labels: a name, never an id alone unless ids are asked for, and the id and the name when a name may repeat. +- `filters`: routing to row / aggregate / post-aggregation filtering; transforms in filters (top N per group via a rank); the anti-join (a joined model's key `is null`); the time-point forms. +- `order`: sorting by any aggregate or transform, displayed or not, with `limit` for top N; returning only the columns the question asks for, never adding the sort value to the measures. +- `time_dimensions`: buckets without rows are absent; a time dimension on `time_spine.timestamp` with a lower `date_range` bound returns every bucket, empty ones included, and lines several models up on one time axis. +- a time dimension's `date_range`: its forms; that `change`, `change_pct`, `time_shift` and `window=` read rows before the range (a forward `time_shift`, after it) so the range is not widened; that `cumsum` starts at the range start. +- `source_model`: rooting at the model whose every row must appear when the question asks for every such row, with a named conditional aggregate; otherwise rooting where the facts are, so rows without facts drop out, or omitting it to infer the smallest model determining every dimension and row-level condition column. +- `name` (stages): what needs no stage (top N per group, averaging or bucketing per-entity totals, shares and totals); that a filter on a transform's value applies after it, which is computed over every row the other filters keep; that a stage is needed only to drop rows by a dimension or time condition that a cross-row value must still see, or to join or reuse a whole result, because a row filter or `date_range` applies before a running total, `lag` / `lead`, rank, `ntile`, `consecutive_periods` or `partition_by` total while `change`, `change_pct`, `time_shift` and `window=` read past `date_range` or a filter on their own time dimension only; and that an outer stage references inner dotted columns by their flattened `__` names. + +The one-query rule SHALL appear only in the server `instructions` and the `query` tool description. The gap-filling, several-child-models, parentless-child-row, cross-model-ratio, unrelated-model, projection, conditional-rooting and stage guidance SHALL also appear in no help topic and not in the server `instructions`; the instructions' fan-out reason SHALL appear only in the instructions. No description, the instructions or a help topic SHALL tell agents to use a stage to filter after a rank or window, to re-query a whole result, or to answer with one query only "whenever" it can. + +Fields that reuse another field's syntax (a refinement's clauses, a measure's `formula`) SHALL point to the owning field instead of repeating its guidance. Guidance too long for its field SHALL be cited by the exact `inspect` call of the help topic that holds it. + +#### Scenario: Each guidance marker has one owner +- **WHEN** the `query` tool description and every description in its input schema are collected +- **THEN** each guidance marker (for example the grand-total `partition_by=[]` example, the "rows before the range" rule, the flattened `__` stage-column rule, the stage rule, the readable-label rule) occurs in its owning field's description and nowhere else + +#### Scenario: Moved guidance has no second copy +- **WHEN** the `query` tool description, every description in its input schema, the server instructions and every help topic body are collected +- **THEN** each of the gap-filling (`time_spine.timestamp`), several-child-models, parentless-child-row, cross-model-ratio, unrelated-model, projection, conditional-rooting and stage-rule markers occurs only in its owning field's description, the fan-out-reason marker only in the instructions, and the one-query marker only in the instructions and the `query` description + +#### Scenario: No retired stage or one-query wording remains +- **WHEN** the same texts are collected +- **THEN** none tells agents to use stages to filter after a window or rank or to re-query a whole result, none says to answer with one query "whenever" it can, and no help topic keeps a "One query first" section or a "Typical uses" list of stages + +#### Scenario: Examples group by readable columns +- **WHEN** the same texts are collected +- **THEN** no example groups, partitions or flattens by a column whose name ends in `_id` + +#### Scenario: A refinement clause points to the query field +- **WHEN** a client reads the `refine` argument's `measures` description +- **THEN** it refers to the query object's `measures` instead of repeating its guidance + +#### Scenario: date_range is described +- **WHEN** a client reads a time dimension's `date_range` description +- **THEN** it states the accepted forms, that `change` / `change_pct` / `time_shift` / `window=` read rows before the range (a forward `time_shift`, after it), and that `cumsum` starts at the range start + +### Requirement: Documented query idioms behave as documented +Every query idiom given as an example in the tool or schema descriptions SHALL execute and return the documented result: +- `change`, `change_pct` and `time_shift(…, -1)` with a `date_range` compare the first in-range bucket against the bucket before the range, and `time_shift(…, 1)` compares the last in-range bucket against the bucket after it; +- an aggregation with `window=` includes rows before the range in the first in-range buckets; +- `cumsum` with a `date_range` accumulates from the range start only; +- a filter `. is null` keeps exactly the rows with no joined row; +- a query rooted at a model keeps every row of that model, counting 0 where no joined rows exist; +- ordering by an undisplayed aggregate with a `limit` returns the top rows by that aggregate without projecting it; +- a filter on `rank(..., partition_by=customers.regions.name, direction='desc') <= N` keeps the top N per region; +- `x / x(partition_by=customers.regions.name)` and `x / x(partition_by=[])` give the share of region and of grand total; +- a joined model's aggregate sliced by a non-attributable dimension broadcasts its total by default and splits per group under `associate`; +- a nested aggregation averages the inner per-group values within the outer group; +- an outer stage reads an inner dotted dimension by its flattened `__` name (`customers.regions.name` as `customers__regions__name`); +- a monthly time dimension on `time_spine.timestamp` with a `date_range` returns every month of the range, months without rows included (count 0, other aggregates NULL); +- rooted at customers, `sum(orders.amount)` and `sum(returns.amount)` in one query each equal the sum over that child model's own rows; +- rooted at customers and grouped by a parent dimension, a child row without a parent counts in that dimension's NULL row when the population has one and in no row otherwise, and an ungrouped aggregate includes it; +- rooted at customers, `sum(orders.amount) / count(*)` divides the orders' total by the number of customers; +- rooted at customers, `count(events.id) / count(*)` with `events` joined to nothing divides the events' total by the number of customers and warns `unrelated_dataset`; +- a filter on a transform's value (`rank(...) <= N`, `cumsum(...) > X`) applies after the transform, which is computed over every row the other filters keep; +- a time filter on the bucketed time column restricts `cumsum`, `lag`, `lead`, `consecutive_periods`, `rank` / `ntile` over buckets and `partition_by` totals to the kept buckets, while `change`, `change_pct`, `time_shift` and `window=` read past it; +- a filter on a dimension restricts `rank`, `dense_rank`, `ntile`, `partition_by` shares and totals and nested aggregates to the kept peers; a filter on a non-time column restricts the rows `window=` reads, before the range as well; +- an inner stage computing a rank over all rows and an outer stage filtering one row returns that row's rank among all rows. + +#### Scenario: Lookback before date_range +- **WHEN** a monthly query with `date_range` `"2025"` measures `change(sum(amount))` +- **THEN** January 2025's change is computed against December 2024 + +#### Scenario: Running total starts at the range +- **WHEN** a monthly query with `date_range` `"2025"` measures `cumsum(sum(amount))` +- **THEN** January 2025's value excludes 2024 amounts + +#### Scenario: Anti-join +- **WHEN** a query rooted at customers filters `orders.id is null` +- **THEN** exactly the customers with no orders are returned + +#### Scenario: Cross-model aggregate broadcast vs associate +- **WHEN** a query rooted at orders, grouped by order status, measures `sum(customers.credit)` +- **THEN** by default each row carries the total credit of all customers with a broadcast warning, and with `to_many_handling` `associate` each row carries the credit of the distinct customers with orders in that status + +#### Scenario: Time spine returns empty buckets +- **WHEN** a query buckets `time_spine.timestamp` by month with `date_range` `"2025"` and measures `sum(orders.amount)` and `count(orders.id)`, and one month of 2025 has no orders +- **THEN** twelve rows are returned, the month without orders carrying count 0 and sum NULL + +#### Scenario: Several child models in one query +- **WHEN** a query rooted at customers, grouped by customer name, measures `sum(orders.amount)` and `sum(returns.amount)` +- **THEN** each customer's values equal the sums over that customer's own orders and own returns, unmultiplied by the other child model's rows + +#### Scenario: Parentless child rows land in the parent dimension's NULL row +- **WHEN** a query rooted at customers, grouped by `regions.name`, measures `sum(orders.amount)`, one customer has no region and some orders have no (or a non-existent) customer +- **THEN** the NULL-region row holds the region-less customer's orders plus the parentless orders, and the same aggregate without dimensions includes the parentless orders + +#### Scenario: Parentless child rows without a NULL population row +- **WHEN** the same query runs on data where every customer has a region +- **THEN** no NULL-region row is returned and the parentless orders count in no row + +#### Scenario: Cross-model ratio +- **WHEN** a query rooted at customers measures `sum(orders.amount) / count(*)` +- **THEN** the value equals the orders' total divided by the number of customers + +#### Scenario: A filter on a transform's value applies after it +- **WHEN** a monthly query over all months measures `cumsum(sum(amount))` and filters on that running total exceeding a threshold +- **THEN** the kept months carry the running total accumulated over every month, not only the kept ones + +#### Scenario: A time filter restricts cross-row values except calendar look-backs +- **WHEN** a monthly query filters the bucketed time column to two months and measures one cross-row value +- **THEN** `cumsum`, `lag`, `lead`, `consecutive_periods`, `rank` / `ntile` over months and `sum(amount, partition_by=[])` are computed over the two kept months only, while `change`, `change_pct`, `time_shift` and `window=` equal their values in the unfiltered query + +#### Scenario: A dimension filter restricts peer values +- **WHEN** a query grouped by region name and customer name filters one customer and measures a rank, dense rank, ntile, share of region, grand total or nested average +- **THEN** the value is computed over the kept customer only + +#### Scenario: Rank among all rows needs a stage +- **WHEN** an inner stage ranks every customer by total amount and an outer stage keeps one customer +- **THEN** that customer carries its rank among all customers + +#### Scenario: Unrelated-model ratio +- **WHEN** a query rooted at customers measures `count(events.id) / count(*)` and no join path connects `events` to `customers` +- **THEN** the value equals the number of events divided by the number of customers, and the response carries an `unrelated_dataset` warning diff --git a/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/specs/queries/population/spec.md b/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/specs/queries/population/spec.md new file mode 100644 index 00000000..0fb961af --- /dev/null +++ b/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/specs/queries/population/spec.md @@ -0,0 +1,82 @@ +## MODIFIED Requirements + +### Requirement: Root recommendation follows the population rule + +`recommend_root_model` SHALL classify each resolved item by entity type: columns +are determination items (determined, counting routed hops); saved measures and +aggregation-suffixed items are attachments requiring reachability only and reported +as such. Selection SHALL use the same rule as population inference so the two +surfaces cannot disagree whenever inference succeeds: a column item is determined +from a candidate exactly when the inference probe finds it viable from that +candidate. Only when no candidate is viable and an item's probe failed solely because +a hop or its short-form route is ambiguous — never fanning or unreachable — SHALL +recommendation resolve that item along its tie-break-best fan-out-free route and emit +that full canonical path, so the recommended root executes once named as +`source_model`. When the items include at least one determination item, an attachment +on a dataset that no join path connects to a candidate SHALL NOT count against that +candidate; once a root is chosen, each such attachment SHALL be reported with the +path a query rooted there spells it by (its product hop, `queries/unrelated-datasets`) +and flagged `unrelated`, and SHALL never steer the choice. Without determination items, +attachments steer selection by join-path reachability alone. Every other item +SHALL carry `unrelated` false. A feasible `root_hint` (determines all determination +items under either rule, reaches all attachments, by a join path or as unrelated +datasets when determination items exist) SHALL override selection; an infeasible one +falls back with a warning; a malformed one raises. The no-common-root coverage output +SHALL be retained with the per-item criterion updated to match. A pair whose +unaddressable edges keep an item from being reached SHALL be named in the response +warnings with the remedy to name its edges. + +#### Scenario: Saved measure does not steer the recommendation + +- **WHEN** items mix columns with a suffix-less saved measure +- **THEN** the saved measure is reported as an attachment and does not change the + recommended root + +#### Scenario: Recommendation matches inference + +- **WHEN** the same dimension items are given to `recommend_root_model` and queried + without `source_model` +- **THEN** the recommended root equals the inferred population + +#### Scenario: Ambiguity is resolved by an explicit path + +- **WHEN** `orders` reaches `regions` by two fan-out-free routes (via `customers` and + via `warehouses`) and `recommend_root_model` is given `orders.status` and + `regions.population` +- **THEN** the root is `orders` and the path for `regions.population` is + `customers.regions.population`, while + `{"dimensions": ["orders.status", "regions.population"]}` without `source_model` + fails with the ambiguous-path error + +#### Scenario: Recommendation and inference agree on a directed cycle + +- **WHEN** `recommend_root_model` is given `x.v`, `y.v` and `z.v` on the directed + cycle `x → y → z → x` +- **THEN** no root is recommended, matching inference's failure, and the coverage + output reports which items each candidate determines + +#### Scenario: An unaddressable pair is named in the warnings + +- **WHEN** `orders` declares two unnamed joins to `addresses` and + `recommend_root_model` is given `orders.id` and `addresses.city` +- **THEN** the response warnings name `orders`↔`addresses` and the remedy to name + the edges + +#### Scenario: An unrelated attachment is reported through the product hop + +- **WHEN** `customers` and `events` share no join path and `recommend_root_model` is + given `customers.city` and `count(events.id)` +- **THEN** the root is `customers`, `count(events.id)` is reported as an attachment + flagged `unrelated` with the path `count(events.id)`, `customers.city` is flagged + `unrelated` false, and querying that path rooted at `customers` succeeds + +#### Scenario: An unrelated column stays unreachable + +- **WHEN** `recommend_root_model` is given `customers.city` and `events.kind` +- **THEN** no root is recommended, exactly as before this change + +#### Scenario: Attachments alone keep join-path selection + +- **WHEN** `recommend_root_model` is given only `count(customers.id)` and + `count(events.id)` +- **THEN** no root is recommended, exactly as before this change diff --git a/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/specs/queries/semantics/spec.md b/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/specs/queries/semantics/spec.md new file mode 100644 index 00000000..b61745f4 --- /dev/null +++ b/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/specs/queries/semantics/spec.md @@ -0,0 +1,10 @@ +## ADDED Requirements + +### Requirement: Division by zero is NULL + +A division whose divisor evaluates to 0 SHALL be NULL on every backend and in every position (measure, filter, order key, computed dimension) — never an error, an infinity or NaN. + +#### Scenario: A ratio over an empty population + +- **WHEN** a query measures `sum(amount) / count(*)` and its filters keep no population row +- **THEN** one row is returned whose ratio is NULL on SQLite and DuckDB, and the SQL emitted for every dialect guards the divisor with `NULLIF(…, 0)` diff --git a/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/specs/queries/unrelated-datasets/spec.md b/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/specs/queries/unrelated-datasets/spec.md new file mode 100644 index 00000000..9d7a6a2a --- /dev/null +++ b/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/specs/queries/unrelated-datasets/spec.md @@ -0,0 +1,181 @@ +## Purpose + +How one query combines datasets that no join path connects: an unrelated dataset meets the population as the product `P × D`, read only through aggregates and one-sided filters, so result rows are always the population's and no evaluation is quadratic. + +Scenario seed data, unless a scenario says otherwise: `customers` (id 1–3, city A, A, B; no time column) and `events` (id 1–5, amount 10, 20, 30, 40, 50, created_at 2024-01-01, 2024-01-02, 2024-02-01, 2024-02-02, 2024-03-01, kind x, y, x, x, y) in one datasource, with no join between them. + +## ADDED Requirements + +### Requirement: An unrelated dataset is reached by naming it + +In a query frame — the main query and every stage of a query list, including the stored stages of a query-backed model — a reference path whose first hop resolves to no edge and no route from the population SHALL resolve through a product hop to the dataset its token names, when that token names a model visible to the caller or a query-local stage (the stage spelling taking precedence) in the population's datasource. The product hop SHALL pair every population row with every row of that dataset (`P × D`) and determine nothing across it. Every existing edge and route resolution SHALL take precedence, and no route search — short-form routing, route counting, population inference, root recommendation's determination probe — SHALL take a product hop. A path SHALL continue past the product hop over ordinary edges. A token naming no visible dataset of the population's datasource, the time spine, or the population itself SHALL keep its existing error. Stored definitions (`Column.sql`, model filters, saved measures, joins) SHALL refuse a reference with no join path: a saved measure fails when used with the existing no-route error, and a `Column.sql` or model filter is rejected at save time with a typed error naming the definition and the unreachable model, and fails closed with that error at query time when stored without validation. + +#### Scenario: A grand-total ratio across unrelated models + +- **WHEN** a query with `source_model: customers` measures `{"formula": "count(events.id) / count(*)", "name": "events_per_customer"}` +- **THEN** one row is returned with `events_per_customer` = 5 / 3, equal to dividing the two separate single-model answers + +#### Scenario: A path continues past the product hop + +- **WHEN** `events` joins `users` many-to-one and a query rooted at `customers` measures `count(events.users.id)` +- **THEN** the value equals that of an `events`-rooted query measuring `count(users.id)` + +#### Scenario: A query-local stage is an unrelated dataset + +- **WHEN** a query list has stages `c` (`source_model: customers`, measure `count(*)` named `nc`) and `e` (`source_model: events`, measure `count(*)` named `ne`) and a final stage `{"source_model": "c", "dimensions": ["nc"], "measures": [{"formula": "max(e.ne)", "name": "ne"}]}` +- **THEN** exactly one row (nc 3, ne 5) is returned + +#### Scenario: References in every position are found + +- **WHEN** the only reference to `events` in a `customers`-rooted query sits in a filter, an order entry, or an aggregation's `partition_by=[]` measure +- **THEN** it resolves through the product hop exactly as it would in a measure + +#### Scenario: Existing paths and routing are unchanged + +- **WHEN** a query references a model that a join path or a unique short-form route reaches +- **THEN** it resolves exactly as before this change, and no product hop is taken + +#### Scenario: Names that are not reachable datasets keep their errors + +- **WHEN** a `customers`-rooted query references `evnts.id` (no such model), a model of another datasource, a model hidden from the caller by its access context, or `customers.id` spelled through the population's own name +- **THEN** each fails or resolves exactly as before this change; a hidden model is reported as unknown + +#### Scenario: Row-level security scopes the unrelated dataset + +- **WHEN** an engine-level tenant policy restricts both models to one tenant, owning customers 1–2 and events 1–3, and the grand-total ratio query runs +- **THEN** the ratio is 3 / 2 + +#### Scenario: Stored definitions keep refusing + +- **WHEN** a saved measure on `customers` reads `count(events.id)`, a `customers` column's `sql` reads `events.amount`, or a `customers` model filter reads `events.amount > 1` +- **THEN** using the saved measure fails with the existing no-route error; saving the column or the filter fails with the typed error, and using either one stored without validation fails with the same error + +### Requirement: Aggregates across a product hop resolve like unattributable aggregates + +An aggregation homed on an unrelated dataset `D` SHALL be counted over `D`'s own rows (restricted by the query's one-sided `D` filters) and SHALL be attributable to no population dimension except a time-spine dimension, which it SHALL attribute through `D`'s own axis. The remaining dimensions SHALL resolve per `to_many_handling`: under `broadcast` the value at the attributable grain repeats across them with the existing `broadcast` warning; under `associate` every cell associates all of `D`'s rows, so it carries the same value with the existing `associated` warning; under `error` the query fails with the existing unattributable-dimension error. An explicit `partition_by` naming a population dimension SHALL follow the existing rule for a dimension unattributable from the aggregate's home. Transforms, nested aggregation, measure-typed filters, order entries and explicitly grained computed dimensions over such aggregates SHALL behave as over any aggregate. + +#### Scenario: Grouped query broadcasts the unrelated total + +- **WHEN** a `customers`-rooted query groups by `city` and measures `count(*)` and `count(events.id)` +- **THEN** the rows are A (2, 5) and B (1, 5), with a `broadcast` warning naming `count(events.id)` and `city` + +#### Scenario: Associate mode gives the same total + +- **WHEN** the grouped query sets `to_many_handling: associate` +- **THEN** the rows are A (2, 5) and B (1, 5), with an `associated` warning and no `broadcast` warning + +#### Scenario: Error mode refuses a population dimension + +- **WHEN** the grouped query sets `to_many_handling: error` +- **THEN** it fails with the existing unattributable-dimension error naming `count(events.id)` and `city` + +#### Scenario: Error mode accepts a dimensionless query + +- **WHEN** the grand-total ratio query sets `to_many_handling: error` +- **THEN** it returns 5 / 3 + +#### Scenario: A spine query attributes through the unrelated dataset's own axis + +- **WHEN** a query with `source_model: customers` groups by `city` and by `time_spine.timestamp` at month with `date_range: ["2024-01-01", "2024-03-31"]` and measures `count(events.id)` +- **THEN** the rows are A and B for each of January–March, each January row reading 2, each February row 2 and each March row 1 + +#### Scenario: Partitioning by a population dimension + +- **WHEN** the grouped query measures `count(events.id, partition_by=[city])` +- **THEN** it fails with the existing error for a `partition_by` key unattributable from the aggregate's home, outside `associate` mode + +#### Scenario: Composed aggregates + +- **WHEN** the grouped query measures `count(events.id) * 2` and `count(*) / count(events.id)`, filters `count(events.id) > 4`, and orders by `count(events.id)` +- **THEN** both rows survive the measure filter, reading A (10, 0.4) and B (10, 0.2) + +### Requirement: Other row-level reads across a product hop fail closed + +A row-level read of an unrelated dataset that is neither beneath an aggregation whose input lies wholly on that dataset's side nor a one-sided field filter SHALL fail with a typed query type error naming the dataset, the reference, the population, and the remedy of aggregating it (for a one-row stage, `max(.)`). This SHALL cover dimensions, time dimensions, row-level operands of computed dimensions, row-level order keys, and raw-row (`distinct_dimension_values: false`) queries, and SHALL be judged on dependency closures, so a derived column or saved definition reached through the product hop is classified by everything its definition reads. A row-level combination of population and unrelated columns inside one aggregation SHALL fail with the existing input-safety error. A join declared with empty `join_pairs` SHALL remain invalid, with a message naming the same aggregate remedy. + +#### Scenario: Unrelated dimension + +- **WHEN** a `customers`-rooted query groups by `city` and `events.kind` +- **THEN** it fails with the typed error naming `events`, `events.kind`, `customers` and the aggregate remedy + +#### Scenario: Other row-level positions + +- **WHEN** a `customers`-rooted query has the time dimension `events.created_at` at month, the computed dimension `{"expression": "events.amount * 2", "name": "a2"}`, the order key `events.amount`, or `distinct_dimension_values: false` with dimension `events.kind` +- **THEN** each fails with the same typed error + +#### Scenario: Mixed operands inside one aggregation + +- **WHEN** a `customers`-rooted query measures `sum(events.amount * customers.id)` +- **THEN** it fails with the existing input-safety error + +#### Scenario: Unrelated derived column in an aggregation + +- **WHEN** `events` declares `amount_x2` with `sql: amount * 2` and a `customers`-rooted query measures `sum(events.amount_x2)` +- **THEN** the value is 300 + +#### Scenario: Empty join pairs + +- **WHEN** a stage's `source_model` extension declares a join with `join_pairs: []` +- **THEN** validation fails with a message naming the aggregate remedy + +### Requirement: Filters across a product hop are one-sided associations + +A field-typed filter conjunct whose dependency closure reads only an unrelated dataset `D` SHALL restrict `D`'s rows for every aggregation homed on `D` and SHALL restrict the population by association, so the population keeps every row when at least one row of `D` passes and keeps none otherwise. A conjunct reading only the population side SHALL restrict each unrelated aggregation's rows by association, which keeps all of `D`'s rows when at least one population row passes and none otherwise. A conjunct whose dependency closure reads both an unrelated dataset and anything outside it SHALL fail with a typed error naming the conjunct and the remedy of splitting it into one-sided conjuncts. An unrelated dataset with no rows and no filter on it SHALL leave the population unchanged, its aggregates taking their empty value. + +#### Scenario: A filter on the unrelated dataset + +- **WHEN** the grouped query adds the filter `events.amount > 25` +- **THEN** the rows are A (2, 3) and B (1, 3) + +#### Scenario: A filter on the population + +- **WHEN** the grouped query adds the filter `city = 'A'` +- **THEN** the only row is A (2, 5) + +#### Scenario: Mixed conjuncts are refused + +- **WHEN** a `customers`-rooted query measuring `count(events.id)` filters `events.amount > customers.id`, or `city = 'A' or events.amount > 100` +- **THEN** it fails with the typed error naming the conjunct and the split remedy + +#### Scenario: A filter no unrelated row passes + +- **WHEN** the grouped query filters `events.amount > 1000`, and separately the grand-total ratio query does +- **THEN** the grouped query returns no rows, and the grand-total query returns one row with `count(*)` 0, `count(events.id)` 0 and the ratio NULL + +#### Scenario: An empty unrelated dataset + +- **WHEN** `events` has no rows and the grouped query has no filter +- **THEN** the rows are A (2, 0) and B (1, 0) + +### Requirement: Reading an unrelated dataset is announced + +Every query stage in which an aggregation crosses a product hop SHALL carry one warning of kind `unrelated_dataset` per unrelated dataset, naming the dataset, the population, the measures homed on it and the stage location, surfaced both as a Python warning and on the response's warnings, whether or not the stage has dimensions. The `broadcast` and `associated` warnings SHALL fire independently of it, exactly as for any unattributable aggregate. + +#### Scenario: Dimensionless query + +- **WHEN** the grand-total ratio query runs +- **THEN** its warnings hold exactly one `unrelated_dataset` entry, naming `events`, `customers` and the measure `events_per_customer`, and no `broadcast` entry + +#### Scenario: Grouped query + +- **WHEN** the grouped query runs +- **THEN** its warnings hold one `unrelated_dataset` entry and one `broadcast` entry + +#### Scenario: One entry per dataset and stage + +- **WHEN** a stage measures `count(events.id)` and `sum(events.amount)`, and a second stage of the same list measures `count(events.id)` +- **THEN** each stage carries exactly one `unrelated_dataset` entry for `events`, listing its own measures + +### Requirement: Product hops never multiply rows or work + +A query reading unrelated datasets SHALL return exactly the rows its population defines, and each of its values SHALL equal the value of the same measure computed alone, regardless of how many unrelated datasets or aggregations it reads and in every `to_many_handling` mode. No emitted relation SHALL join an unrelated dataset's rows with the population's rows or with another unrelated dataset's rows; an unrelated dataset SHALL appear only in its own aggregate producers and in uncorrelated existence tests, and no reference to it SHALL be correlated with a column outside it. + +#### Scenario: Three unrelated datasets + +- **WHEN** in a separate datasource `customers` has 200 rows over 7 cities, three unrelated models hold 1,000, 3 and 0 rows, and a `customers`-rooted query grouped by `city` measures two aggregates over each of them plus `count(*)`, under `broadcast` and under `associate` +- **THEN** each returns exactly 7 rows, and every value equals the same measure queried alone + +#### Scenario: Emitted SQL never pairs unrelated rows + +- **WHEN** the three-dataset query, an associate-mode query, a spine query, and a query with one-sided filters on both sides are compiled +- **THEN** each unrelated table occurs only inside its own producers and uncorrelated `EXISTS` subqueries, never in the population's relation, another dataset's producer, or a correlated subquery diff --git a/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/tasks.md b/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/tasks.md new file mode 100644 index 00000000..a2f320ff --- /dev/null +++ b/openspec/changes/archive/2026-10-15-dev-2082-combine-models-and-stages-that-have-no-join-path-cross-join/tasks.md @@ -0,0 +1,49 @@ +## 1. Tests first (pr-tests) + +- [x] 1.1 Write `tests/test_unrelated_datasets.py` covering every scenario of `specs/queries/unrelated-datasets/spec.md` on in-process SQLite (unit tests, not `integration`), and verify each fails on the current code for the right reason +- [x] 1.2 Strengthen the no-explosion scenarios per design D1/D5: sentinel sums with non-trivial row counts, each value checked against the same measure queried alone, two aggregates from one dataset, several datasets in one expression, empty dataset, all three modes; SQL-shape assertions parse the emitted SQL with sqlglot and check each unrelated table occurs only in its own producers and uncorrelated `EXISTS`; verify they fail today +- [x] 1.3 Add the root-recommendation scenarios of `specs/queries/population/spec.md` (unrelated attachment, unrelated column, attachments alone) next to the existing recommendation tests, plus the `unrelated` field on the REST / CLI / MCP / client outputs; verify they fail today +- [x] 1.4 Add the MCP scenarios of `specs/mcp/tool-surface/spec.md`: the unrelated-model marker owned only by `measures` (drift-guard table), the unrelated-model ratio idiom, budgets intact; verify they fail today +- [x] 1.5 Add the RLS scenario (a tenant policy scopes the unrelated dataset's producer) and the access-context scenario (a hidden model is reported as unknown); verify they fail today + +## 2. Product hop and resolution + +- [x] 2.1 Add the typed product-hop discriminator (design D1), move the spine product and detached edges onto it, and make join rendering, rerooting, association building, row scopes and semi-join correlation fail closed on an unrelated product hop; verify the full existing suite stays green +- [x] 2.2 Add the pre-binding collection of unresolved first-hop dataset names into the binding bundle (design D4); verify the "references in every position" and "names that are not reachable datasets" scenarios +- [x] 2.3 Mint the unrelated product hop in strict first-hop resolution only (design D2); verify the resolution scenarios and that route-search / inference / routing suites are unchanged + +## 3. Checker and emission + +- [x] 3.1 Implement the central product rule on dependency closures and the new typed row-level error (design D3); verify the row-level and mixed-conjunct scenarios +- [x] 3.2 Compile aggregates across the hop as producers over the unrelated dataset at their attributable grain (empty or spine bucket), attached by `CROSS JOIN` / bucket join, with the dedicated associate disposition (design D5); verify the aggregation scenarios and the SQL-shape tests +- [x] 3.3 Lower one-sided filters across the hop to producer predicates and uncorrelated `EXISTS` (design D5); verify the filter scenarios, including zero-match and empty dataset +- [x] 3.4 Add `UnrelatedDatasetWarningPayload` and emit it once per dataset per stage (design D6); verify the warning scenarios +- [x] 3.5 Change the empty-`join_pairs` validation message to name the aggregate remedy; verify the empty-join-pairs scenario +- [x] 3.6 Reject a `Column.sql` or model filter whose qualifier names a dataset no join path reaches, at save time and (stored unvalidated) at query time; verify the stored-definitions scenario +- [x] 3.7 Render every division as `x / NULLIF(y, 0)` in the one arithmetic composer (`slayer/sql/render/row_expr.py`) and regenerate the golden SQL; verify the division-by-zero scenario and the zero-match filter scenarios on DuckDB + +## 4. Root recommendation + +- [x] 4.1 Add `ItemPath.unrelated` and the attachment rule of design D7 across the Python / REST / CLI / MCP surfaces; verify the recommendation tests + +## 5. Docs, agent surface, architecture + +- [x] 5.1 Add one sentence to `docs/concepts/queries.md` › Cross-model measures and one to › Choosing a root model (the `unrelated` flag); verify every touched page stays in the `zensical.toml` nav +- [x] 5.2 Add the unrelated-model clause to the MCP `measures` field description within the 2048-character budget; verify the tool-surface tests +- [x] 5.3 Land the approved Axiom 3.1 in `architecture/semantics.arc42.md` exactly as approved (below), with its `[enforced: test:tests/test_unrelated_datasets.py]` tag; verify `poetry run la-arch-check` is green + + Approved wording, inserted between the existing Axiom 3 text and its two `[enforced: …]` tags: + + ``` + - **3.1 Unrelated datasets.** A dataset no join path reaches from a query's + population meets it as the product `P × D`, every row with every row, + reached only by naming `D` as a query path's first hop, never by route + search. Only aggregates and filters (Axiom 14) read across `×`; any other + row-level read is a type error, so `×` never multiplies the population. + [enforced: test:tests/test_unrelated_datasets.py] + ``` + +## 6. Gates + +- [x] 6.1 Run `poetry run pytest -m "not integration"`, `poetry run ruff check slayer/ tests/`, `poetry run basedpyright` (no new errors vs the baseline) and `poetry run la-arch-check`; all green +- [x] 6.2 Run the integration suite with the CI invocation from `.github/workflows/ci.yml`; green diff --git a/openspec/specs/mcp/tool-surface/spec.md b/openspec/specs/mcp/tool-surface/spec.md index c079b4ba..14206788 100644 --- a/openspec/specs/mcp/tool-surface/spec.md +++ b/openspec/specs/mcp/tool-surface/spec.md @@ -55,7 +55,7 @@ The `query` tool description SHALL open with `ONE QUESTION = ONE QUERY. Build th ### Requirement: Query-language guidance lives on the owning schema field, once Each piece of query-language guidance SHALL appear in exactly one place across the `query` tool description and every description in its input schema (field- and definition-level), namely the field where an agent writes that value: -- `measures`: aggregation call form; arithmetic combining aggregates over different models, with a cross-model ratio example rooted at customers; `partition_by=` with keys spelled like the query's dimensions (dotted paths), a share-of-group example and `partition_by=[]` for the grand total; `window=` with compact durations (`'90d'`, `'3m'`); nested aggregation; one line per transform (`cumsum`, `change` / `change_pct`, `time_shift`, `lag` / `lead`, `rank` / `dense_rank` with required direction, `ntile`, `consecutive_periods`); a joined model's aggregate is computed over that model's own rows, broadcast across dimensions it cannot be attributed to unless `to_many_handling` is `associate`; aggregates over several child models in one query (orders and returns from customers) are each computed over their own rows; a child row without a parent counts in the NULL row of a parent dimension when that row exists and in an ungrouped total, and is never added again. +- `measures`: aggregation call form; arithmetic combining aggregates over different models, with a cross-model ratio example rooted at customers; `partition_by=` with keys spelled like the query's dimensions (dotted paths), a share-of-group example and `partition_by=[]` for the grand total; `window=` with compact durations (`'90d'`, `'3m'`); nested aggregation; one line per transform (`cumsum`, `change` / `change_pct`, `time_shift`, `lag` / `lead`, `rank` / `dense_rank` with required direction, `ntile`, `consecutive_periods`); a joined model's aggregate is computed over that model's own rows, broadcast across dimensions it cannot be attributed to unless `to_many_handling` is `associate`; aggregates over several child models in one query (orders and returns from customers) are each computed over their own rows; a child row without a parent counts in the NULL row of a parent dimension when that row exists and in an ungrouped total, and is never added again; an aggregate over a model no join path reaches from the population is computed over that model's own rows and repeated on every row, per bucket when a `time_spine` time dimension attributes it through that model's own axis, with an `unrelated_dataset` warning. - `dimensions`: group by naturally readable labels: a name, never an id alone unless ids are asked for, and the id and the name when a name may repeat. - `filters`: routing to row / aggregate / post-aggregation filtering; transforms in filters (top N per group via a rank); the anti-join (a joined model's key `is null`); the time-point forms. - `order`: sorting by any aggregate or transform, displayed or not, with `limit` for top N; returning only the columns the question asks for, never adding the sort value to the measures. @@ -64,7 +64,7 @@ Each piece of query-language guidance SHALL appear in exactly one place across t - `source_model`: rooting at the model whose every row must appear when the question asks for every such row, with a named conditional aggregate; otherwise rooting where the facts are, so rows without facts drop out, or omitting it to infer the smallest model determining every dimension and row-level condition column. - `name` (stages): what needs no stage (top N per group, averaging or bucketing per-entity totals, shares and totals); that a filter on a transform's value applies after it, which is computed over every row the other filters keep; that a stage is needed only to drop rows by a dimension or time condition that a cross-row value must still see, or to join or reuse a whole result, because a row filter or `date_range` applies before a running total, `lag` / `lead`, rank, `ntile`, `consecutive_periods` or `partition_by` total while `change`, `change_pct`, `time_shift` and `window=` read past `date_range` or a filter on their own time dimension only; and that an outer stage references inner dotted columns by their flattened `__` names. -The one-query rule SHALL appear only in the server `instructions` and the `query` tool description. The gap-filling, several-child-models, parentless-child-row, cross-model-ratio, projection, conditional-rooting and stage guidance SHALL also appear in no help topic and not in the server `instructions`; the instructions' fan-out reason SHALL appear only in the instructions. No description, the instructions or a help topic SHALL tell agents to use a stage to filter after a rank or window, to re-query a whole result, or to answer with one query only "whenever" it can. +The one-query rule SHALL appear only in the server `instructions` and the `query` tool description. The gap-filling, several-child-models, parentless-child-row, cross-model-ratio, unrelated-model, projection, conditional-rooting and stage guidance SHALL also appear in no help topic and not in the server `instructions`; the instructions' fan-out reason SHALL appear only in the instructions. No description, the instructions or a help topic SHALL tell agents to use a stage to filter after a rank or window, to re-query a whole result, or to answer with one query only "whenever" it can. Fields that reuse another field's syntax (a refinement's clauses, a measure's `formula`) SHALL point to the owning field instead of repeating its guidance. Guidance too long for its field SHALL be cited by the exact `inspect` call of the help topic that holds it. @@ -74,7 +74,7 @@ Fields that reuse another field's syntax (a refinement's clauses, a measure's `f #### Scenario: Moved guidance has no second copy - **WHEN** the `query` tool description, every description in its input schema, the server instructions and every help topic body are collected -- **THEN** each of the gap-filling (`time_spine.timestamp`), several-child-models, parentless-child-row, cross-model-ratio, projection, conditional-rooting and stage-rule markers occurs only in its owning field's description, the fan-out-reason marker only in the instructions, and the one-query marker only in the instructions and the `query` description +- **THEN** each of the gap-filling (`time_spine.timestamp`), several-child-models, parentless-child-row, cross-model-ratio, unrelated-model, projection, conditional-rooting and stage-rule markers occurs only in its owning field's description, the fan-out-reason marker only in the instructions, and the one-query marker only in the instructions and the `query` description #### Scenario: No retired stage or one-query wording remains - **WHEN** the same texts are collected @@ -109,6 +109,7 @@ Every query idiom given as an example in the tool or schema descriptions SHALL e - rooted at customers, `sum(orders.amount)` and `sum(returns.amount)` in one query each equal the sum over that child model's own rows; - rooted at customers and grouped by a parent dimension, a child row without a parent counts in that dimension's NULL row when the population has one and in no row otherwise, and an ungrouped aggregate includes it; - rooted at customers, `sum(orders.amount) / count(*)` divides the orders' total by the number of customers; +- rooted at customers, `count(events.id) / count(*)` with `events` joined to nothing divides the events' total by the number of customers and warns `unrelated_dataset`; - a filter on a transform's value (`rank(...) <= N`, `cumsum(...) > X`) applies after the transform, which is computed over every row the other filters keep; - a time filter on the bucketed time column restricts `cumsum`, `lag`, `lead`, `consecutive_periods`, `rank` / `ntile` over buckets and `partition_by` totals to the kept buckets, while `change`, `change_pct`, `time_shift` and `window=` read past it; - a filter on a dimension restricts `rank`, `dense_rank`, `ntile`, `partition_by` shares and totals and nested aggregates to the kept peers; a filter on a non-time column restricts the rows `window=` reads, before the range as well; @@ -166,6 +167,10 @@ Every query idiom given as an example in the tool or schema descriptions SHALL e - **WHEN** an inner stage ranks every customer by total amount and an outer stage keeps one customer - **THEN** that customer carries its rank among all customers +#### Scenario: Unrelated-model ratio +- **WHEN** a query rooted at customers measures `count(events.id) / count(*)` and no join path connects `events` to `customers` +- **THEN** the value equals the number of events divided by the number of customers, and the response carries an `unrelated_dataset` warning + ### Requirement: Help topics hold the long-form reference and are reachable The server SHALL seed the help topics `help.intro`, `help.models`, `help.workflow`, `help.aggregations`, `help.transforms`, `help.time`, `help.joins` and `help.queries`. Each topic SHALL be self-contained and carry a one-line description stating when to read it. Every `memory:help.` reference in the tool descriptions, input schemas or instructions SHALL name a seeded topic. Seeding a store that holds earlier bodies under these ids SHALL replace them with the current bodies, and re-seeding SHALL keep them. diff --git a/openspec/specs/queries/population/spec.md b/openspec/specs/queries/population/spec.md index e3e9eaf5..591cc9e5 100644 --- a/openspec/specs/queries/population/spec.md +++ b/openspec/specs/queries/population/spec.md @@ -260,11 +260,19 @@ candidate. Only when no candidate is viable and an item's probe failed solely be a hop or its short-form route is ambiguous — never fanning or unreachable — SHALL recommendation resolve that item along its tie-break-best fan-out-free route and emit that full canonical path, so the recommended root executes once named as -`source_model`. A feasible `root_hint` (determines all determination items under -either rule, reaches all attachments) SHALL override selection; an infeasible one falls back with a warning; a malformed one raises. The -no-common-root coverage output SHALL be retained with the per-item criterion updated -to match. A pair whose unaddressable edges keep an item from being reached SHALL be -named in the response warnings with the remedy to name its edges. +`source_model`. When the items include at least one determination item, an attachment +on a dataset that no join path connects to a candidate SHALL NOT count against that +candidate; once a root is chosen, each such attachment SHALL be reported with the +path a query rooted there spells it by (its product hop, `queries/unrelated-datasets`) +and flagged `unrelated`, and SHALL never steer the choice. Without determination items, +attachments steer selection by join-path reachability alone. Every other item +SHALL carry `unrelated` false. A feasible `root_hint` (determines all determination +items under either rule, reaches all attachments, by a join path or as unrelated +datasets when determination items exist) SHALL override selection; an infeasible one +falls back with a warning; a malformed one raises. The no-common-root coverage output +SHALL be retained with the per-item criterion updated to match. A pair whose +unaddressable edges keep an item from being reached SHALL be named in the response +warnings with the remedy to name its edges. #### Scenario: Saved measure does not steer the recommendation @@ -302,6 +310,25 @@ named in the response warnings with the remedy to name its edges. - **THEN** the response warnings name `orders`↔`addresses` and the remedy to name the edges +#### Scenario: An unrelated attachment is reported through the product hop + +- **WHEN** `customers` and `events` share no join path and `recommend_root_model` is + given `customers.city` and `count(events.id)` +- **THEN** the root is `customers`, `count(events.id)` is reported as an attachment + flagged `unrelated` with the path `count(events.id)`, `customers.city` is flagged + `unrelated` false, and querying that path rooted at `customers` succeeds + +#### Scenario: An unrelated column stays unreachable + +- **WHEN** `recommend_root_model` is given `customers.city` and `events.kind` +- **THEN** no root is recommended, exactly as before this change + +#### Scenario: Attachments alone keep join-path selection + +- **WHEN** `recommend_root_model` is given only `count(customers.id)` and + `count(events.id)` +- **THEN** no root is recommended, exactly as before this change + ### Requirement: Population specs are typed at construction A query's `source_model` SHALL accept exactly three forms — a saved model name (a string), diff --git a/openspec/specs/queries/semantics/spec.md b/openspec/specs/queries/semantics/spec.md index f94335b6..006228dc 100644 --- a/openspec/specs/queries/semantics/spec.md +++ b/openspec/specs/queries/semantics/spec.md @@ -1085,3 +1085,12 @@ never depends on which dataset roots the query. - **THEN** the orderless customer fails the filter on its null-extended row and counts in no cell, and every cell equals the hand-computed aggregate over the customers associated with app orders, by executed values + +### Requirement: Division by zero is NULL + +A division whose divisor evaluates to 0 SHALL be NULL on every backend and in every position (measure, filter, order key, computed dimension) — never an error, an infinity or NaN. + +#### Scenario: A ratio over an empty population + +- **WHEN** a query measures `sum(amount) / count(*)` and its filters keep no population row +- **THEN** one row is returned whose ratio is NULL on SQLite and DuckDB, and the SQL emitted for every dialect guards the divisor with `NULLIF(…, 0)` diff --git a/openspec/specs/queries/unrelated-datasets/spec.md b/openspec/specs/queries/unrelated-datasets/spec.md new file mode 100644 index 00000000..90bf1210 --- /dev/null +++ b/openspec/specs/queries/unrelated-datasets/spec.md @@ -0,0 +1,182 @@ +# queries/unrelated-datasets Specification + +## Purpose +How one query combines datasets that no join path connects: an unrelated dataset meets the population as the product `P × D`, read only through aggregates and one-sided filters, so result rows are always the population's and no evaluation is quadratic. + +Scenario seed data, unless a scenario says otherwise: `customers` (id 1–3, city A, A, B; no time column) and `events` (id 1–5, amount 10, 20, 30, 40, 50, created_at 2024-01-01, 2024-01-02, 2024-02-01, 2024-02-02, 2024-03-01, kind x, y, x, x, y) in one datasource, with no join between them. + +## Requirements + +### Requirement: An unrelated dataset is reached by naming it + +In a query frame — the main query and every stage of a query list, including the stored stages of a query-backed model — a reference path whose first hop resolves to no edge and no route from the population SHALL resolve through a product hop to the dataset its token names, when that token names a model visible to the caller or a query-local stage (the stage spelling taking precedence) in the population's datasource. The product hop SHALL pair every population row with every row of that dataset (`P × D`) and determine nothing across it. Every existing edge and route resolution SHALL take precedence, and no route search — short-form routing, route counting, population inference, root recommendation's determination probe — SHALL take a product hop. A path SHALL continue past the product hop over ordinary edges. A token naming no visible dataset of the population's datasource, the time spine, or the population itself SHALL keep its existing error. Stored definitions (`Column.sql`, model filters, saved measures, joins) SHALL refuse a reference with no join path: a saved measure fails when used with the existing no-route error, and a `Column.sql` or model filter is rejected at save time with a typed error naming the definition and the unreachable model, and fails closed with that error at query time when stored without validation. + +#### Scenario: A grand-total ratio across unrelated models + +- **WHEN** a query with `source_model: customers` measures `{"formula": "count(events.id) / count(*)", "name": "events_per_customer"}` +- **THEN** one row is returned with `events_per_customer` = 5 / 3, equal to dividing the two separate single-model answers + +#### Scenario: A path continues past the product hop + +- **WHEN** `events` joins `users` many-to-one and a query rooted at `customers` measures `count(events.users.id)` +- **THEN** the value equals that of an `events`-rooted query measuring `count(users.id)` + +#### Scenario: A query-local stage is an unrelated dataset + +- **WHEN** a query list has stages `c` (`source_model: customers`, measure `count(*)` named `nc`) and `e` (`source_model: events`, measure `count(*)` named `ne`) and a final stage `{"source_model": "c", "dimensions": ["nc"], "measures": [{"formula": "max(e.ne)", "name": "ne"}]}` +- **THEN** exactly one row (nc 3, ne 5) is returned + +#### Scenario: References in every position are found + +- **WHEN** the only reference to `events` in a `customers`-rooted query sits in a filter, an order entry, or an aggregation's `partition_by=[]` measure +- **THEN** it resolves through the product hop exactly as it would in a measure + +#### Scenario: Existing paths and routing are unchanged + +- **WHEN** a query references a model that a join path or a unique short-form route reaches +- **THEN** it resolves exactly as before this change, and no product hop is taken + +#### Scenario: Names that are not reachable datasets keep their errors + +- **WHEN** a `customers`-rooted query references `evnts.id` (no such model), a model of another datasource, a model hidden from the caller by its access context, or `customers.id` spelled through the population's own name +- **THEN** each fails or resolves exactly as before this change; a hidden model is reported as unknown + +#### Scenario: Row-level security scopes the unrelated dataset + +- **WHEN** an engine-level tenant policy restricts both models to one tenant, owning customers 1–2 and events 1–3, and the grand-total ratio query runs +- **THEN** the ratio is 3 / 2 + +#### Scenario: Stored definitions keep refusing + +- **WHEN** a saved measure on `customers` reads `count(events.id)`, a `customers` column's `sql` reads `events.amount`, or a `customers` model filter reads `events.amount > 1` +- **THEN** using the saved measure fails with the existing no-route error; saving the column or the filter fails with the typed error, and using either one stored without validation fails with the same error + +### Requirement: Aggregates across a product hop resolve like unattributable aggregates + +An aggregation homed on an unrelated dataset `D` SHALL be counted over `D`'s own rows (restricted by the query's one-sided `D` filters) and SHALL be attributable to no population dimension except a time-spine dimension, which it SHALL attribute through `D`'s own axis. The remaining dimensions SHALL resolve per `to_many_handling`: under `broadcast` the value at the attributable grain repeats across them with the existing `broadcast` warning; under `associate` every cell associates all of `D`'s rows, so it carries the same value with the existing `associated` warning; under `error` the query fails with the existing unattributable-dimension error. An explicit `partition_by` naming a population dimension SHALL follow the existing rule for a dimension unattributable from the aggregate's home. Transforms, nested aggregation, measure-typed filters, order entries and explicitly grained computed dimensions over such aggregates SHALL behave as over any aggregate. + +#### Scenario: Grouped query broadcasts the unrelated total + +- **WHEN** a `customers`-rooted query groups by `city` and measures `count(*)` and `count(events.id)` +- **THEN** the rows are A (2, 5) and B (1, 5), with a `broadcast` warning naming `count(events.id)` and `city` + +#### Scenario: Associate mode gives the same total + +- **WHEN** the grouped query sets `to_many_handling: associate` +- **THEN** the rows are A (2, 5) and B (1, 5), with an `associated` warning and no `broadcast` warning + +#### Scenario: Error mode refuses a population dimension + +- **WHEN** the grouped query sets `to_many_handling: error` +- **THEN** it fails with the existing unattributable-dimension error naming `count(events.id)` and `city` + +#### Scenario: Error mode accepts a dimensionless query + +- **WHEN** the grand-total ratio query sets `to_many_handling: error` +- **THEN** it returns 5 / 3 + +#### Scenario: A spine query attributes through the unrelated dataset's own axis + +- **WHEN** a query with `source_model: customers` groups by `city` and by `time_spine.timestamp` at month with `date_range: ["2024-01-01", "2024-03-31"]` and measures `count(events.id)` +- **THEN** the rows are A and B for each of January–March, each January row reading 2, each February row 2 and each March row 1 + +#### Scenario: Partitioning by a population dimension + +- **WHEN** the grouped query measures `count(events.id, partition_by=[city])` +- **THEN** it fails with the existing error for a `partition_by` key unattributable from the aggregate's home, outside `associate` mode + +#### Scenario: Composed aggregates + +- **WHEN** the grouped query measures `count(events.id) * 2` and `count(*) / count(events.id)`, filters `count(events.id) > 4`, and orders by `count(events.id)` +- **THEN** both rows survive the measure filter, reading A (10, 0.4) and B (10, 0.2) + +### Requirement: Other row-level reads across a product hop fail closed + +A row-level read of an unrelated dataset that is neither beneath an aggregation whose input lies wholly on that dataset's side nor a one-sided field filter SHALL fail with a typed query type error naming the dataset, the reference, the population, and the remedy of aggregating it (for a one-row stage, `max(.)`). This SHALL cover dimensions, time dimensions, row-level operands of computed dimensions, row-level order keys, and raw-row (`distinct_dimension_values: false`) queries, and SHALL be judged on dependency closures, so a derived column or saved definition reached through the product hop is classified by everything its definition reads. A row-level combination of population and unrelated columns inside one aggregation SHALL fail with the existing input-safety error. A join declared with empty `join_pairs` SHALL remain invalid, with a message naming the same aggregate remedy. + +#### Scenario: Unrelated dimension + +- **WHEN** a `customers`-rooted query groups by `city` and `events.kind` +- **THEN** it fails with the typed error naming `events`, `events.kind`, `customers` and the aggregate remedy + +#### Scenario: Other row-level positions + +- **WHEN** a `customers`-rooted query has the time dimension `events.created_at` at month, the computed dimension `{"expression": "events.amount * 2", "name": "a2"}`, the order key `events.amount`, or `distinct_dimension_values: false` with dimension `events.kind` +- **THEN** each fails with the same typed error + +#### Scenario: Mixed operands inside one aggregation + +- **WHEN** a `customers`-rooted query measures `sum(events.amount * customers.id)` +- **THEN** it fails with the existing input-safety error + +#### Scenario: Unrelated derived column in an aggregation + +- **WHEN** `events` declares `amount_x2` with `sql: amount * 2` and a `customers`-rooted query measures `sum(events.amount_x2)` +- **THEN** the value is 300 + +#### Scenario: Empty join pairs + +- **WHEN** a stage's `source_model` extension declares a join with `join_pairs: []` +- **THEN** validation fails with a message naming the aggregate remedy + +### Requirement: Filters across a product hop are one-sided associations + +A field-typed filter conjunct whose dependency closure reads only an unrelated dataset `D` SHALL restrict `D`'s rows for every aggregation homed on `D` and SHALL restrict the population by association, so the population keeps every row when at least one row of `D` passes and keeps none otherwise. A conjunct reading only the population side SHALL restrict each unrelated aggregation's rows by association, which keeps all of `D`'s rows when at least one population row passes and none otherwise. A conjunct whose dependency closure reads both an unrelated dataset and anything outside it SHALL fail with a typed error naming the conjunct and the remedy of splitting it into one-sided conjuncts. An unrelated dataset with no rows and no filter on it SHALL leave the population unchanged, its aggregates taking their empty value. + +#### Scenario: A filter on the unrelated dataset + +- **WHEN** the grouped query adds the filter `events.amount > 25` +- **THEN** the rows are A (2, 3) and B (1, 3) + +#### Scenario: A filter on the population + +- **WHEN** the grouped query adds the filter `city = 'A'` +- **THEN** the only row is A (2, 5) + +#### Scenario: Mixed conjuncts are refused + +- **WHEN** a `customers`-rooted query measuring `count(events.id)` filters `events.amount > customers.id`, or `city = 'A' or events.amount > 100` +- **THEN** it fails with the typed error naming the conjunct and the split remedy + +#### Scenario: A filter no unrelated row passes + +- **WHEN** the grouped query filters `events.amount > 1000`, and separately the grand-total ratio query does +- **THEN** the grouped query returns no rows, and the grand-total query returns one row with `count(*)` 0, `count(events.id)` 0 and the ratio NULL + +#### Scenario: An empty unrelated dataset + +- **WHEN** `events` has no rows and the grouped query has no filter +- **THEN** the rows are A (2, 0) and B (1, 0) + +### Requirement: Reading an unrelated dataset is announced + +Every query stage in which an aggregation crosses a product hop SHALL carry one warning of kind `unrelated_dataset` per unrelated dataset, naming the dataset, the population, the measures homed on it and the stage location, surfaced both as a Python warning and on the response's warnings, whether or not the stage has dimensions. The `broadcast` and `associated` warnings SHALL fire independently of it, exactly as for any unattributable aggregate. + +#### Scenario: Dimensionless query + +- **WHEN** the grand-total ratio query runs +- **THEN** its warnings hold exactly one `unrelated_dataset` entry, naming `events`, `customers` and the measure `events_per_customer`, and no `broadcast` entry + +#### Scenario: Grouped query + +- **WHEN** the grouped query runs +- **THEN** its warnings hold one `unrelated_dataset` entry and one `broadcast` entry + +#### Scenario: One entry per dataset and stage + +- **WHEN** a stage measures `count(events.id)` and `sum(events.amount)`, and a second stage of the same list measures `count(events.id)` +- **THEN** each stage carries exactly one `unrelated_dataset` entry for `events`, listing its own measures + +### Requirement: Product hops never multiply rows or work + +A query reading unrelated datasets SHALL return exactly the rows its population defines, and each of its values SHALL equal the value of the same measure computed alone, regardless of how many unrelated datasets or aggregations it reads and in every `to_many_handling` mode. No emitted relation SHALL join an unrelated dataset's rows with the population's rows or with another unrelated dataset's rows; an unrelated dataset SHALL appear only in its own aggregate producers and in uncorrelated existence tests, and no reference to it SHALL be correlated with a column outside it. + +#### Scenario: Three unrelated datasets + +- **WHEN** in a separate datasource `customers` has 200 rows over 7 cities, three unrelated models hold 1,000, 3 and 0 rows, and a `customers`-rooted query grouped by `city` measures two aggregates over each of them plus `count(*)`, under `broadcast` and under `associate` +- **THEN** each returns exactly 7 rows, and every value equals the same measure queried alone + +#### Scenario: Emitted SQL never pairs unrelated rows + +- **WHEN** the three-dataset query, an associate-mode query, a spine query, and a query with one-sided filters on both sides are compiled +- **THEN** each unrelated table occurs only inside its own producers and uncorrelated `EXISTS` subqueries, never in the population's relation, another dataset's producer, or a correlated subquery diff --git a/slayer/core/errors.py b/slayer/core/errors.py index 295f3077..9b44c61e 100644 --- a/slayer/core/errors.py +++ b/slayer/core/errors.py @@ -403,6 +403,37 @@ class TimeSpineError(QueryTypeError): outside a bucketed time dimension or a bound, or a stored model shadowing ``time_spine``.""" +class UnrelatedDatasetError(QueryTypeError): + """A row-level read of a dataset no join path reaches, outside an aggregation or a one-sided filter.""" + + +class UnreachableDefinitionError(SlayerError, ValueError): + """A stored ``Column.sql`` / ``Column.filter`` / model filter naming a dataset no join path reaches from its model.""" + + def __init__(self, *, model: str, reference: str, dataset: str, definition: str | None = None) -> None: + self.model = model + self.reference = reference + self.dataset = dataset + self.definition = definition + super().__init__(_format_error_message( + cls_name=type(self).__name__, + summary=f"{definition or 'A definition'} on model {model!r} reads {reference!r}, but no join path " + f"reaches {dataset!r} from {model!r}.", + suggestion=f"Declare a join between them, or read {dataset!r} in a query through aggregates.", + )) + + def labelled(self, definition: str) -> "UnreachableDefinitionError": + """This error naming ``definition``, unless it already names one.""" + if self.definition is not None: + return self + return UnreachableDefinitionError( + model=self.model, reference=self.reference, dataset=self.dataset, definition=definition, + ) + + def __reduce__(self): + return _rebuild_query_type_error, (type(self), self.args, self.__dict__) + + class GranularityDefinitionError(SlayerError): """A datasource custom-granularity definition breaking a save-time rule.""" diff --git a/slayer/core/join_search.py b/slayer/core/join_search.py index 8132f41b..307693ea 100644 --- a/slayer/core/join_search.py +++ b/slayer/core/join_search.py @@ -34,6 +34,7 @@ "shortest_route", "shortest_routes", "unaddressable_pairs", + "unreachable_target", ] @@ -316,3 +317,14 @@ def dfs(node: str, route: Route, visited: set[str]) -> None: dfs(root.name, Route(), {root.name}) return out + + +def unreachable_target(*, root: SlayerModel, token: str, models_by_name: dict[str, SlayerModel]) -> str | None: + """The model ``token`` names when neither an incident edge nor a route reaches it from ``root``.""" + target = models_by_name.get(token) + if target is None or token == root.name or is_spine(target): + return None + universe = {**models_by_name, root.name: root.with_unrelated(frozenset())} + if any(e.name == token or e.target_model == token for e in neighbors(model=root, models_by_name=universe)): + return None + return token if count_routes(root=root, target=token, models_by_name=universe) == 0 else None diff --git a/slayer/core/join_walker.py b/slayer/core/join_walker.py index 5d4c414a..c486acc0 100644 --- a/slayer/core/join_walker.py +++ b/slayer/core/join_walker.py @@ -45,6 +45,7 @@ "follow", "incident_model_names", "is_product_edge", + "is_unrelated_edge", "matching_edges", "neighbors", "observe_traversals", @@ -64,6 +65,11 @@ ] +#: A product hop's kind: the population to its spine, the spine to a dataset with no axis route, +#: or the population to a dataset no join path reaches (minted only by strict resolution). +ProductKind = Literal["spine", "detached", "unrelated"] + + class OrientedJoin(BaseModel): """A declared join viewed from a chosen traversal source. @@ -85,6 +91,8 @@ class OrientedJoin(BaseModel): # A query stage's user spelling of an endpoint (``None`` for an ordinary model). source_spelling: str | None = None target_spelling: str | None = None + # A keyless hop pairing every source row with every target row; ``None`` for a declared join. + product: ProductKind | None = None _traversals: ContextVar[Optional[Dict[str, bool]]] = ContextVar( @@ -174,7 +182,7 @@ def _product_edge(model: SlayerModel) -> OrientedJoin: source_model=model.name, target_model=TIME_SPINE_MODEL, join_pairs=[], join_type=PRODUCT_JOIN_TYPE, cardinality=JoinCardinality.ONE_TO_MANY, name=TIME_SPINE_MODEL, declaring_model=model.name, - source_spelling=model.explicit_spelling, + source_spelling=model.explicit_spelling, product="spine", ) @@ -232,12 +240,28 @@ def _detached_edge(*, source: SlayerModel, target: SlayerModel) -> OrientedJoin: join_type=PRODUCT_JOIN_TYPE, cardinality=JoinCardinality.MANY_TO_MANY, name=None, declaring_model=TIME_SPINE_MODEL, source_spelling=source.explicit_spelling, target_spelling=target.explicit_spelling, + product="detached", + ) + + +def _unrelated_edge(*, source: SlayerModel, target: SlayerModel) -> OrientedJoin: + """The population and a dataset no join path reaches, meeting only as a product.""" + return OrientedJoin( + source_model=source.name, target_model=target.name, join_pairs=[], + join_type=PRODUCT_JOIN_TYPE, cardinality=JoinCardinality.MANY_TO_MANY, + name=None, declaring_model=source.name, + source_spelling=source.explicit_spelling, target_spelling=target.explicit_spelling, + product="unrelated", ) def is_product_edge(edge: OrientedJoin) -> bool: - """The population's hop to the spine (never an axis edge).""" - return edge.target_model == TIME_SPINE_MODEL and not edge.join_pairs + """A keyless product hop (never a declared or axis edge).""" + return edge.product is not None + + +def is_unrelated_edge(edge: OrientedJoin) -> bool: + return edge.product == "unrelated" def _declared_toward(model: SlayerModel, target: str, *, spine: bool) -> list[ModelJoin]: @@ -344,6 +368,8 @@ def resolve_hop( edges qualify. """ candidates = matching_edges(neighbors(model=current, models_by_name=models_by_name), token) + if not candidates: + candidates = _unrelated_hops(current=current, token=token, models_by_name=models_by_name) if not candidates: return None if len(candidates) > 1: @@ -357,6 +383,14 @@ def resolve_hop( return candidates[0] +def _unrelated_hops( + *, current: SlayerModel, token: str, models_by_name: dict[str, SlayerModel], +) -> list[OrientedJoin]: + """The product hop from a query frame's population to the unrelated dataset ``token`` names.""" + targets = [models_by_name[n] for n in sorted(current.unrelated_datasets) if n in models_by_name] + return matching_edges([_unrelated_edge(source=current, target=t) for t in targets], token) + + def addresses_alone(*, edge: OrientedJoin, incident: list[OrientedJoin]) -> bool: """Whether ``edge``'s canonical token names it alone among ``incident`` (its source's edges).""" return matching_edges(incident, canonical_token(edge)) == [edge] diff --git a/slayer/core/models.py b/slayer/core/models.py index 90f695a4..8ea58352 100644 --- a/slayer/core/models.py +++ b/slayer/core/models.py @@ -570,7 +570,10 @@ def _validate_name(cls, v: str | None) -> str | None: @classmethod def _validate_join_pairs(cls, v: list[list[str]]) -> list[list[str]]: if not v: - raise ValueError("join_pairs must be non-empty") + raise ValueError( + "join_pairs must be non-empty; to combine a model no join path reaches, drop the join and " + "aggregate its columns in the query (e.g. count(events.id) / count(*))" + ) for i, pair in enumerate(v): if len(pair) != 2 or not all(isinstance(s, str) and s for s in pair): raise ValueError( @@ -723,6 +726,8 @@ def _require_data_source_unless_query_backed(self) -> "SlayerModel": _spelling: str | None = PrivateAttr(default=None) # NOSONAR(S5890) — pydantic PrivateAttr descriptor; the attribute holds str | None # Runtime-only: this model is the P factor of a ``time_spine × P`` population. _population_spine: bool = PrivateAttr(default=False) + # Runtime-only: datasets no join path reaches that this query frame's population names. + _unrelated: frozenset[str] = PrivateAttr(default=frozenset()) @field_validator("filters") @classmethod @@ -881,6 +886,16 @@ def as_population_factor(self, factor: bool = True) -> "SlayerModel": out._population_spine = factor return out + @property + def unrelated_datasets(self) -> frozenset[str]: + """Names of the datasets this query frame's population meets only as a product.""" + return self._unrelated + + def with_unrelated(self, names: frozenset[str]) -> "SlayerModel": + out = self.model_copy() + out._unrelated = names + return out + @property def awaits_columns(self) -> bool: """Query-backed with its output columns not yet populated.""" diff --git a/slayer/core/query.py b/slayer/core/query.py index 248be5b4..d94dd4d9 100644 --- a/slayer/core/query.py +++ b/slayer/core/query.py @@ -1164,7 +1164,10 @@ class SlayerQuery(BaseModel): "own rows: several child models never fan out or double count. A child row without a " "parent (an order with no customer) has NULL parent columns: it counts in the NULL " "row of a parent dimension when that row exists, and in an ungrouped total; never add " - "it again.\n" + "it again. An aggregate over a model no join path reaches from the root is computed " + "over that model's own rows and repeated on every row (per bucket of a time_spine " + "time dimension), with an unrelated_dataset warning: rooted at customers, " + "count(events.id) / count(*).\n" "More (every aggregation, empty-input values, nesting and transform rules): " 'inspect(reference=["memory:help.aggregations", "memory:help.transforms"], ' 'entity_type="memory").' diff --git a/slayer/core/recommend.py b/slayer/core/recommend.py index 6a829692..6b62ab32 100644 --- a/slayer/core/recommend.py +++ b/slayer/core/recommend.py @@ -1,4 +1,4 @@ -"""Result models + rendering for ``recommend_root_model`` (DEV-1626). +"""Result models + rendering for ``recommend_root_model``. Given a set of ``model.column`` / ``model.metric`` items an agent wants in one query, the engine recommends a root model (query ``source_model``) and @@ -20,9 +20,11 @@ class ItemPath(BaseModel): input_item: str path: str - # DEV-1866: True for a saved measure / aggregation-suffixed item — reachable + # True for a saved measure / aggregation-suffixed item — reachable # from the root but not a determination item that steers the recommendation. attachment: bool = False + # An attachment on a dataset no join path reaches: its path is the root's product hop. + unrelated: bool = False class CandidateCoverage(BaseModel): @@ -54,33 +56,45 @@ class RootModelRecommendation(BaseModel): warnings: list[str] = [] +def _render_item_paths(rec: RootModelRecommendation) -> list[str]: + lines = [ + f"Recommended root model: `{rec.root_model}`", + "", + "| Input item | Path from root |", + "|------------|----------------|", + ] + for ip in rec.item_paths: + note = " (unrelated: no join path, aggregated over its own rows)" if ip.unrelated else "" + lines.append(f"| `{ip.input_item}` | `{ip.path}`{note} |") + return lines + + +def _render_coverage(rec: RootModelRecommendation) -> list[str]: + lines = ["Recommended root model: _none_ — no single model reaches every item."] + if rec.message: + lines.extend(["", rec.message]) + if rec.coverage: + lines.extend([ + "", + "Best partial roots (Pareto frontier):", + "", + "| Candidate root | Reaches | Cannot reach |", + "|----------------|---------|--------------|", + ]) + for c in rec.coverage: + reaches = ", ".join(f"`{i}`" for i in c.reachable_items) or "_(none)_" + misses = ", ".join(f"`{i}`" for i in c.unreachable_items) or "_(none)_" + lines.append(f"| `{c.model_name}` | {reaches} | {misses} |") + return lines + + def render_recommendation_markdown(rec: RootModelRecommendation) -> str: """Render a recommendation as human-readable markdown (MCP / CLI).""" - lines: list[str] = [] - lines.append(f"Datasource: `{rec.data_source}`") + lines = [f"Datasource: `{rec.data_source}`"] if rec.reachable and rec.root_model is not None: - lines.append(f"Recommended root model: `{rec.root_model}`") - lines.append("") - lines.append("| Input item | Path from root |") - lines.append("|------------|----------------|") - for ip in rec.item_paths: - lines.append(f"| `{ip.input_item}` | `{ip.path}` |") + lines.extend(_render_item_paths(rec)) else: - lines.append("Recommended root model: _none_ — no single model " - "reaches every item.") - if rec.message: - lines.append("") - lines.append(rec.message) - if rec.coverage: - lines.append("") - lines.append("Best partial roots (Pareto frontier):") - lines.append("") - lines.append("| Candidate root | Reaches | Cannot reach |") - lines.append("|----------------|---------|--------------|") - for c in rec.coverage: - reaches = ", ".join(f"`{i}`" for i in c.reachable_items) or "_(none)_" - misses = ", ".join(f"`{i}`" for i in c.unreachable_items) or "_(none)_" - lines.append(f"| `{c.model_name}` | {reaches} | {misses} |") + lines.extend(_render_coverage(rec)) if rec.warnings: lines.append("") lines.append("Warnings:") diff --git a/slayer/core/warnings.py b/slayer/core/warnings.py index 83ea03b1..1eb032e4 100644 --- a/slayer/core/warnings.py +++ b/slayer/core/warnings.py @@ -92,6 +92,23 @@ def human_message(self) -> str: ) +class UnrelatedDatasetWarningPayload(SlayerWarning): + """Aggregates over ``dataset``, which no join path reaches from ``population``: each is computed over the dataset's own rows and repeated on every row.""" + + kind: Literal["unrelated_dataset"] = "unrelated_dataset" + dataset: str + population: str + measures: list[str] + location: str + + def human_message(self) -> str: + return ( + f"{', '.join(repr(m) for m in self.measures)} (at {self.location}) read {self.dataset!r}, which no " + f"join path reaches from {self.population!r}: unrelated dataset, aggregated over its own rows and " + f"repeated on every row" + ) + + class DegenerateReaggregationWarningPayload(SlayerWarning): """A second-order aggregation whose operand grain equals the outer grain, so it is the identity; ``operand_grain`` / ``outer_grain`` name the equal grains and ``hint`` the partition_by remedy.""" @@ -224,6 +241,7 @@ def human_message(self) -> str: NormalizationWarning, BroadcastGrainWarningPayload, AssociatedWarningPayload, + UnrelatedDatasetWarningPayload, DegenerateReaggregationWarningPayload, SemiJoinPushedWarningPayload, ResponseTruncationWarning, @@ -247,6 +265,17 @@ def __str__(self) -> str: return self.payload.human_message() +class SlayerUnrelatedDatasetWarning(UserWarning): + """Carrier ``UserWarning`` for an ``UnrelatedDatasetWarningPayload`` — one wording on both channels.""" + + def __init__(self, payload: UnrelatedDatasetWarningPayload) -> None: + super().__init__(payload) + self.payload = payload + + def __str__(self) -> str: + return self.payload.human_message() + + class SlayerWholePeriodsWarning(UserWarning): """Carrier ``UserWarning`` for a ``WholePeriodsNonNestingWarningPayload`` — one wording on both channels.""" diff --git a/slayer/engine/bundle_builder.py b/slayer/engine/bundle_builder.py index bebc2a07..c4442f6f 100644 --- a/slayer/engine/bundle_builder.py +++ b/slayer/engine/bundle_builder.py @@ -12,6 +12,8 @@ from slayer.core.query import ModelExtension, SlayerQuery, SourceSpec from slayer.core.scope import StageDisplay from slayer.core.time_spine import TIME_SPINE_MODEL, is_spine, query_host, spine_model +from slayer.engine.column_dependency import definition_heads +from slayer.engine.unrelated import first_hop_names from slayer.ir.source_bundle import ( ResolvedSourceBundle, apply_extension_overlay, @@ -38,8 +40,9 @@ async def _referenced_models( source_model=source_model, named_queries=named_queries, storage=storage, data_source=data_source, failures=failures, ) + known = {m.name for m in component} component.extend(await _query_written_targets( - queries=[*named_queries.values(), query], known={m.name for m in component}, + queries=[*named_queries.values(), query], known=known, sibling_names=set(named_queries), storage=storage, data_source=data_source, failures=failures, )) referenced, query_backed = await _split_query_backed( @@ -182,10 +185,11 @@ async def _stage_source_models( return out -def _written_join_targets(spec: SourceSpec | None) -> List[str]: - if spec is None or isinstance(spec, str): - return [] - return [j.target_model for j in spec.joins or []] +def _written_targets(query: SlayerQuery) -> List[str]: + """The models ``query`` names: its source's join targets, then its references' first hops.""" + spec = query.source_model + joins = [] if spec is None or isinstance(spec, str) else [j.target_model for j in spec.joins or []] + return list(dict.fromkeys([*joins, *sorted(first_hop_names(query))])) async def _query_written_targets( @@ -197,25 +201,39 @@ async def _query_written_targets( data_source: Optional[str], failures: DocumentLoadFailures, ) -> List[SlayerModel]: - """The components of models the queries name as join targets but the join-graph - walk did not reach (an extension over a sibling carries its own joins).""" + """The components of models the queries name — as join targets or first hops — but the + join-graph walk did not reach (an extension over a sibling carries its own joins).""" + names = [n for q in queries for n in _written_targets(q) if n not in sibling_names] + return await _named_components( + names=names, known=known, storage=storage, data_source=data_source, failures=failures, + ) + + +async def _named_components( + *, + names: List[str], + known: "set[str]", + storage: "StorageBackend", + data_source: Optional[str], + failures: DocumentLoadFailures, +) -> List[SlayerModel]: + """The components of the ``names`` models not yet ``known`` (absent names skipped).""" out: List[SlayerModel] = [] - for q in queries: - for name in _written_join_targets(q.source_model): - if name in known or name in sibling_names: - continue - model = await _frontier_model(name=name, all_models={}, storage=storage, ds=data_source) - if model is None: - continue - fresh = [ - m for m in await _collect_referenced_models( - source_model=model, named_queries={}, storage=storage, data_source=data_source, - failures=failures, - ) - if m.name not in known - ] - known.update(m.name for m in fresh) - out.extend(fresh) + for name in names: + if name in known: + continue + model = await _frontier_model(name=name, all_models={}, storage=storage, ds=data_source) + if model is None: + continue + fresh = [ + m for m in await _collect_referenced_models( + source_model=model, named_queries={}, storage=storage, data_source=data_source, + failures=failures, + ) + if m.name not in known + ] + known.update(m.name for m in fresh) + out.extend(fresh) return out @@ -243,8 +261,9 @@ async def _split_query_backed( failures: DocumentLoadFailures, ) -> "Tuple[List[SlayerModel], Dict[str, SlayerModel]]": """Split ``models`` into referenced models and query-backed placeholders, closing - over each placeholder's stage bases (and their components). Placeholders keep - their stored form with joins dropped; on-chain names are never loaded.""" + over each placeholder's stage bases and each model's definition-named models (and + their components). Placeholders keep their stored form with joins dropped; on-chain + names are never loaded.""" referenced: Dict[str, SlayerModel] = {} query_backed: Dict[str, SlayerModel] = {} pending = list(models) @@ -254,6 +273,11 @@ async def _split_query_backed( continue if not model.source_queries: referenced[model.name] = model + pending.extend(m for m in await _named_components( + names=definition_heads([model]), + known={*chain, *referenced, *query_backed, *(p.name for p in pending)}, + storage=storage, data_source=data_source, failures=failures, + ) if not is_spine(m)) continue query_backed[model.name] = model.model_copy(update={"joins": []}) pending.extend(await _stage_base_components( @@ -290,6 +314,10 @@ async def _stage_base_components( source_model=base, named_queries={}, storage=storage, data_source=data_source, failures=failures, )) + out.extend(await _query_written_targets( + queries=list(model.source_queries or []), known={*known, *skip, *(m.name for m in out)}, + sibling_names=set(private), storage=storage, data_source=data_source, failures=failures, + )) return out diff --git a/slayer/engine/column_dependency.py b/slayer/engine/column_dependency.py index 8ab5aeb3..d274a3d0 100644 --- a/slayer/engine/column_dependency.py +++ b/slayer/engine/column_dependency.py @@ -26,7 +26,9 @@ DerivedColumnAmbiguousError, DerivedColumnCircularError, DerivedColumnFanningError, + UnreachableDefinitionError, ) +from slayer.core.join_search import unreachable_target from slayer.core.join_walker import provably_to_one, walk, walk_miss, walk_terminal from slayer.core.models import Column, SlayerModel from slayer.engine.join_safety import provably_fans @@ -347,6 +349,32 @@ def _definition_label(*, column: Column | None, fragment: str) -> str: return f"column {column.name!r}" if column is not None else f"model filter {fragment!r}" +def definition_heads(models: list[SlayerModel]) -> list[str]: + """The first join hops ``models``' Mode-A definitions spell, deduplicated in order.""" + heads = ( + path[0] + for model in models + for _column, fragment in _definitions(model) + for quals, _leaf in _fragment_refs(fragment) or [] + if (path := _hop_path(quals=quals, host=model)) + ) + return list(dict.fromkeys(heads)) + + +def check_definition_reach(*, model: SlayerModel, reachable: dict[str, SlayerModel]) -> None: + """Reject a Mode-A definition on ``model`` naming a model no join path reaches from it.""" + models = {**reachable, model.name: model} + for column, fragment in _definitions(model): + for quals, leaf in _fragment_refs(fragment) or []: + path = _hop_path(quals=quals, host=model) + dataset = unreachable_target(root=model, token=path[0], models_by_name=models) if path else None + if dataset is not None: + raise UnreachableDefinitionError( + model=model.name, reference=".".join((*quals, leaf)), dataset=dataset, + definition=_definition_label(column=column, fragment=fragment), + ) + + def check_definition_ambiguity(*, model: SlayerModel, reachable: dict[str, SlayerModel]) -> None: """Reject a Mode-A definition on ``model`` whose path crosses an ambiguous hop: a column's as :class:`DerivedColumnAmbiguousError`, a model filter's as the base error naming it. A @@ -439,6 +467,7 @@ def validate_derived_columns( failed to load, whose reverse joins can't be proved absent. Best-effort; the compile-time / query-time guards remain authoritative.""" reachable = {**peers, model.name: model} + check_definition_reach(model=model, reachable=reachable) check_definition_ambiguity(model=model, reachable=reachable) _check_reference_arity(model=model, reachable=reachable) # Iterate roots in a deterministic order so the reported cycle is diff --git a/slayer/engine/compile/stages.py b/slayer/engine/compile/stages.py index 51c3d5c5..e0a41e8d 100644 --- a/slayer/engine/compile/stages.py +++ b/slayer/engine/compile/stages.py @@ -147,6 +147,7 @@ spine_column, ) from slayer.engine.compile.shift import carried_placeholders +from slayer.engine.unrelated import crosses_product_hop from slayer.engine.compile.staging import stage_slots from slayer.engine.key_metadata import ( dimension_key_metadata, @@ -2134,8 +2135,11 @@ def _synthesize_cross_model_producer( # NOSONAR(S3776) — one cohesive target- key=agg, target_path=target_path, root_model=root_model, models_by_name=models_by_name, host_name=host_model.name, ) + product = crosses_product_hop(host=host_model, path=target_path, models_by_name=models_by_name) + # Across a product hop every cell associates all home rows: the broadcast producer, warned as associated. + product_associate = mode == "associate" and product # Association only when a DIMENSION is unattributable; attached inputs never need it. - associate = mode == "associate" and bool(unattributable) + associate = mode == "associate" and bool(unattributable) and not product_associate window_td_key: Optional[TimeTruncKey] = None semi_joins: List[SemiJoinFilter] = [] broadcast: List[Tuple[str, str]] = [] @@ -2172,11 +2176,15 @@ def _synthesize_cross_model_producer( # NOSONAR(S3776) — one cohesive target- ) else: # BROADCAST / ERROR ARM: an unattributable explicit key is a hard error. - check_cross_model_partition_keys_attributable( - alias=alias, root_name=root_name, explicit=explicit, - unattributable=[(u.name, u.reason) for u in unattributable], - ) - broadcast = [(u.name, u.reason) for u in unattributable] + if product_associate: + associated_measure = None if explicit or not unattributable else alias + associated_dimensions = [] if explicit else [u.name for u in unattributable] + else: + check_cross_model_partition_keys_attributable( + alias=alias, root_name=root_name, explicit=explicit, + unattributable=[(u.name, u.reason) for u in unattributable], + ) + broadcast = [(u.name, u.reason) for u in unattributable] if target_path != source_anchor_path(agg.source): # The source sits beyond the home: render inline as a host-locus # aggregate joining the to-one path from the home, never a @@ -2338,10 +2346,27 @@ def _synthesize_cross_model_producer( # NOSONAR(S3776) — one cohesive target- associated_measure=associated_measure, associated_dimensions=associated_dimensions, association_restricted_filter_texts=restricted_texts, + **(_unrelated_attach_fields(agg=agg, alias=alias, dataset=target_path[0], context=context) + if product else {}), **cm_attach_kwargs, ) +def _unrelated_attach_fields( + *, agg: AggregateKey, alias: str, dataset: str, context: _ProducerSynthesisContext, +) -> Dict[str, Any]: + """The ``unrelated_dataset`` warning's fields: the public measures reading ``agg``, else its alias.""" + measures = [ + dm.public_name for dm in context.prebound.declared_measures + if dm.public_name and agg in walk_value_keys(dm.bound.value_key) + ] + return { + "unrelated_dataset": dataset, + "unrelated_population": context.host_model.spelling, + "unrelated_measures": measures or [alias], + } + + def _window_endpoints( *, host_keys: List[ValueKey], context: _ProducerSynthesisContext, producer_registry: Optional[Dict[Hashable, PlannedQuery]], @@ -3407,8 +3432,8 @@ def _synthesize_local_regroup( substitutions=substitutions, partition_display=[_regroup_grain_name(pk) for pk in ordered_pks], # A population semi-join inherited into this producer reports each of - # the producer's own public measures, not its stage alias. DEV-1944: - # an aggregate selected under two names warns only the first. + # the producer's own public measures, not its stage alias; an aggregate + # selected under two names warns only the first. population_semi_join_measures=( [alias_map[a] for a in aggs if isinstance(a, AggregateKey) and a in alias_map] @@ -4184,6 +4209,10 @@ def _emit_planned(routed: _Routed) -> PlannedQuery: # NOSONAR(S3776) — projec sid = projection.registry.find_by_key(sub.placeholder) if sid is not None: regroup_combined_slot_ids.add(sid) + regroup_combined_slot_ids |= _isolated_composites( + slots=[*agg_slots, *combined_slots], isolated={*windowed_slot_ids, *regroup_combined_slot_ids}, + registry=projection.registry, + ) empty_base_plan = _plan_empty_base_grain( projection=projection.public_projection, agg_slots=agg_slots, @@ -4265,6 +4294,16 @@ def _assert_no_inline_kernel_aggregates( ) +def _isolated_composites(*, slots: list, isolated: AbstractSet[SlotId], registry) -> set[SlotId]: + """Composites built only from isolated aggregates and literals: they too leave ``_base`` empty.""" + def composed(key: ValueKey) -> bool: + if isinstance(key, LiteralKey) or registry.find_by_key(key) in isolated: + return True + return isinstance(key, SLOT_COMPOSITE_KINDS) and all(composed(c) for c in key.children()) + + return {s.id for s in slots if isinstance(s.key, SLOT_COMPOSITE_KINDS) and composed(s.key)} + + def _plan_empty_base_grain( *, projection: List[SlotId], diff --git a/slayer/engine/elaborate.py b/slayer/engine/elaborate.py index 2e01b3c6..f98c4246 100644 --- a/slayer/engine/elaborate.py +++ b/slayer/engine/elaborate.py @@ -8,21 +8,26 @@ from __future__ import annotations -from typing import Any, Dict, Optional, Union +from typing import Any, Dict, List, Optional, Sequence, Tuple, Union +from slayer.core.keys import ValueKey, split_top_level_and from slayer.core.query import SlayerQuery from slayer.core.scope import ModelScope, StageSchema from slayer.engine.bind_inputs import bind_query_inputs from slayer.engine.elaborate_env import ( build_environment, check_combined_partition_keys, + check_unrelated_filter_sides, + check_unrelated_row_read, home_dataset, position_typing_context, type_and_split_filters, ) from slayer.engine.home import resolve_aggregate_homes from slayer.engine.join_safety import crossing_local_root_predicate -from slayer.ir.elaborated import ElaboratedProducer, ElaboratedQuery, ElaboratedStage +from slayer.engine.unrelated import ProductSides +from slayer.ir.elaborated import ConjunctTyping, ElaboratedProducer, ElaboratedQuery, ElaboratedStage +from slayer.ir.planned import MaskTyping from slayer.ir.prebound import ( PreboundQuery, StrictQueryCarrier, @@ -51,9 +56,17 @@ def elaborate_query( query=query, bundle=bundle, scope=scope, stage_schemas=stage_schemas, ) + sides = ProductSides(host=scope.source_model, bundle=bundle) if isinstance(scope, ModelScope) and ( + scope.source_model is not None) else None + crossing = crossing_local_root_predicate(scope=scope, bundle=bundle) prebound, filter_typings = type_and_split_filters( - prebound, crossing_root=crossing_local_root_predicate(scope=scope, bundle=bundle), + prebound, + crossing_root=crossing if sides is None or not sides.tokens else ( + lambda k: crossing(k) or bool(sides.crossed(k)) + ), ) + if sides is not None: + _check_product_hops(prebound, filter_typings=filter_typings, sides=sides) check_combined_partition_keys( prebound, filter_typings=filter_typings, order_texts=[o.raw_formula or o.column.full_name for o in query.order or []], @@ -64,6 +77,29 @@ def elaborate_query( )) +def _check_product_hops( + prebound: PreboundQuery, *, filter_typings: Sequence[ConjunctTyping], sides: ProductSides, +) -> None: + """Only aggregates and one-sided field filters read across a product hop (semantics Axiom 3.1).""" + if not sides.tokens: + return + population = sides.host.spelling + roots: List[Tuple[ValueKey, str]] = [ + (dm.bound.value_key, f"{'dimension' if dm.is_dimension else 'measure'} {dm.public_name!r}") + for dm in prebound.declared_measures + ] + roots += [(sp.bound.value_key, "order") for sp in prebound.order_specs] + for bf, typing in zip(prebound.bound_filters, filter_typings, strict=True): + if typing.typing == MaskTyping.FIELD: + for cj in split_top_level_and(bf.value_key): + check_unrelated_filter_sides(conjunct=cj, datasets=sides.mixed_sides(cj), population=population) + else: + roots.append((bf.value_key, "filter")) + for root, location in roots: + reference, dataset = next(sides.row_level_reads(root), (None, "")) + check_unrelated_row_read(reference=reference, dataset=dataset, population=population, location=location) + + def elaborate_synthesized( prebound: PreboundQuery, *, diff --git a/slayer/engine/elaborate_env.py b/slayer/engine/elaborate_env.py index c4547775..3f63a6f5 100644 --- a/slayer/engine/elaborate_env.py +++ b/slayer/engine/elaborate_env.py @@ -39,6 +39,7 @@ TransformInputError, UnanalyzableDependencyError, UnknownGranularityError, + UnrelatedDatasetError, UnsafeJoinInputError, ) from slayer.core.formula import TIME_TRANSFORMS @@ -861,6 +862,35 @@ def check_windowed_time_dimension(*, resolved: bool) -> None: ) +def check_unrelated_row_read( + *, reference: Optional[ValueKey], dataset: str, population: str, location: str, +) -> None: + """A row-level read of a dataset no join path reaches, outside an aggregation's inputs, raises.""" + if reference is None: + return + ref = key_display(reference.column if isinstance(reference, TimeTruncKey) else reference) + raise UnrelatedDatasetError( + summary=f"{ref} reads {dataset}, which no join path reaches from the population " + f"{population}: it meets {population} as a product, so it is read only through aggregates.", + location=location, + suggestion=f"Aggregate it, e.g. max({ref}).", + ) + + +def check_unrelated_filter_sides( + *, conjunct: ValueKey, datasets: Optional[frozenset], population: str, +) -> None: + """A filter condition reading an unrelated dataset together with anything else raises.""" + if not datasets: + return + raise UnrelatedDatasetError( + summary=f"The filter condition {key_display(conjunct)} reads {', '.join(sorted(datasets))} " + f"together with another dataset, but no join path reaches {', '.join(sorted(datasets))} " + f"from the population {population}: each condition must read one side alone.", + suggestion="Split it into AND-ed conditions that each read one dataset.", + ) + + def check_spine_clash(*, clash: bool) -> None: """A stored model named ``time_spine`` shadows the built-in spine.""" if clash: diff --git a/slayer/engine/join_safety.py b/slayer/engine/join_safety.py index 1e54e4cf..d3c84aaa 100644 --- a/slayer/engine/join_safety.py +++ b/slayer/engine/join_safety.py @@ -53,6 +53,7 @@ key_closure, ) from slayer.engine.elaborate_env import check_partition_key_attributable +from slayer.engine.unrelated import crosses_product_hop from slayer.ir.prebound import walk_key_path from slayer.ir.source_bundle import ResolvedSourceBundle from slayer.engine.cardinality import ( @@ -567,6 +568,8 @@ def assert_partition_key_attributable( return models_by_name = bundle.models_by_name hp = key_host_path(pk) + if crosses_product_hop(host=host_m, path=hp, models_by_name=models_by_name): + return # a row-level read across a product hop: the checker refuses it (Axiom 3.1) if not hp: # Path-less derived key: a fan from its own host is a mode-invariant safety # error; a host-safe key's cross-model-root concern stays the planner's. diff --git a/slayer/engine/plan.py b/slayer/engine/plan.py index e08f17bf..16dbc7f0 100644 --- a/slayer/engine/plan.py +++ b/slayer/engine/plan.py @@ -27,6 +27,7 @@ from slayer.engine.compile import compile_query from slayer.engine.elaborate import elaborate_query from slayer.engine.normalization import normalize_query +from slayer.engine.unrelated import stamp_unrelated from slayer.engine.stage_ordering import ( localize_stages, stage_sibling_reads, @@ -87,8 +88,41 @@ def _stage_scope_and_bundle( stage_schemas: Dict[str, StageSchema], data_source: str, stage_model: Optional[SlayerModel], + placeholders: List[SlayerModel], ) -> "Tuple[ModelScope | StageSchema, ResolvedSourceBundle]": """Resolve one DAG stage's ``(scope, per-stage bundle)``; each stage binds against its OWN source, with sibling synthetic models threaded in.""" + scope, sb = _stage_scope_and_bundle_unframed( + query=query, bundle=bundle, stage_schemas=stage_schemas, data_source=data_source, + stage_model=stage_model, + ) + framed_scope, framed = _framed(query=query, scope=scope, bundle=sb, placeholders=placeholders) + assert framed_scope is not None + return framed_scope, framed + + +def _framed( + *, query: SlayerQuery, scope: "ModelScope | StageSchema | None", bundle: ResolvedSourceBundle, + placeholders: List[SlayerModel], +) -> "Tuple[ModelScope | StageSchema | None, ResolvedSourceBundle]": + """The frame's population stamped with the unrelated datasets ``query`` names (unspliced + placeholders included, so a product hop to one is walked); dots need a model scope.""" + host = bundle.source_model + if host is None: + return scope, bundle + stamped = stamp_unrelated(query=query, bundle=bundle, host=host, extra=placeholders) + if stamped is host: + return scope, bundle + return ModelScope(source_model=stamped), bundle.model_copy(update={"source_model": stamped}) + + +def _stage_scope_and_bundle_unframed( + *, + query: SlayerQuery, + bundle: ResolvedSourceBundle, + stage_schemas: Dict[str, StageSchema], + data_source: str, + stage_model: Optional[SlayerModel], +) -> "Tuple[ModelScope | StageSchema, ResolvedSourceBundle]": src = query.source_model sibling_names = set(stage_schemas) sib = source_name_if_sibling(spec=src, sibling_names=sibling_names) @@ -264,11 +298,12 @@ def _universe( ) -> "Tuple[ModelScope | StageSchema | None, ResolvedSourceBundle]": base = self.bundle.model_copy(update={"stage_displays": dict(self.state.displays)}) if single: - return None, base + return _framed(query=query, scope=None, bundle=base, placeholders=self._placeholders()) return _stage_scope_and_bundle( query=query, bundle=base, stage_schemas=self.state.schemas, data_source=self.data_source, stage_model=stage_model or self.bundle.source_model, + placeholders=self._placeholders(), ) def _placeholders(self) -> List[SlayerModel]: diff --git a/slayer/engine/query_engine.py b/slayer/engine/query_engine.py index 3681b6cb..4ad8f984 100644 --- a/slayer/engine/query_engine.py +++ b/slayer/engine/query_engine.py @@ -64,8 +64,8 @@ refine_query, render_probe_text, ) -from slayer.core.join_search import blocking_pairs, shortest_routes -from slayer.engine.column_dependency import check_definition_ambiguity +from slayer.core.join_search import blocking_pairs, shortest_routes, unreachable_target +from slayer.engine.column_dependency import check_definition_ambiguity, check_definition_reach from slayer.engine.population import ( ambiguity_resolved_path, determined_path, @@ -87,7 +87,9 @@ NormalizationWarning, SemiJoinPushedWarningPayload, SlayerNarrowedAccessWarning, + SlayerUnrelatedDatasetWarning, SlayerWholePeriodsWarning, + UnrelatedDatasetWarningPayload, WholePeriodsNonNestingWarningPayload, ) from slayer.core.refs import functional_agg_text @@ -417,6 +419,23 @@ def _collect_associated_warnings( ] +def _collect_unrelated_warnings(*, planned_list, labels) -> List[UnrelatedDatasetWarningPayload]: + """One unrelated-dataset payload per ``(stage location, dataset)``; measures unioned.""" + found: "dict[tuple[str, str], tuple[str, list[str]]]" = {} + for planned, location in zip(planned_list, labels): + for attach in _walk_regroup_attaches(planned): + if attach.unrelated_dataset is None: + continue + _population, measures = found.setdefault( + (location, attach.unrelated_dataset), (attach.unrelated_population or "", []), + ) + measures.extend(m for m in attach.unrelated_measures if m not in measures) + return [ + UnrelatedDatasetWarningPayload(dataset=dataset, population=population, measures=measures, location=location) + for (location, dataset), (population, measures) in found.items() + ] + + def _collect_degenerate_warnings( *, planned_list, stages=None, displays=None, labels=None, ) -> List[DegenerateReaggregationWarningPayload]: @@ -537,6 +556,8 @@ def _emit_python_warnings(response) -> None: ) elif isinstance(w, WholePeriodsNonNestingWarningPayload): _warnings_module.warn(SlayerWholePeriodsWarning(w), stacklevel=3) + elif isinstance(w, UnrelatedDatasetWarningPayload): + _warnings_module.warn(SlayerUnrelatedDatasetWarning(w), stacklevel=3) class SlayerResponse(BaseModel): @@ -1184,6 +1205,7 @@ async def _plan_and_render( # NOSONAR S3776 — linear pipeline (localize→inf _raise_on_error_events(broadcasts=broadcast_warnings) warnings.extend(broadcast_warnings) warnings.extend(_collect_associated_warnings(planned_list=plans, labels=labels)) + warnings.extend(_collect_unrelated_warnings(planned_list=plans, labels=labels)) warnings.extend(_collect_semi_join_pushed_warnings(planned_list=plans, labels=labels)) warnings.extend(_collect_degenerate_warnings(planned_list=plans, labels=labels)) warnings.extend(_granularity_conflict_warnings(planned_list=plans, labels=labels)) @@ -2084,9 +2106,19 @@ async def recommend_root_model( # NOSONAR(S3776) — cohesive: small named reac # fan-out-free path of an item blocked only by ambiguity (used when nothing is viable, or by a hint). strict: dict[str, dict[str, tuple[str, ...]]] = {} lenient: dict[str, dict[str, tuple[str, ...]]] = {} + # With determination items, an attachment no join path reaches meets the root as a product. + unrelated: dict[str, set[str]] = {} for name in all_names: routed = shortest_routes(root=models_by_name[name], models_by_name=models_by_name) paths = {r.input_item: routed[r.model].tokens for r in attach if r.model in routed} + unrelated[name] = { + r.input_item for r in attach + if det and r.model not in routed and unreachable_target( + root=models_by_name[name], token=r.model, models_by_name=models_by_name, + ) is not None + } + paths.update({item: (models_by_name[r.model].spelling,) for r in attach + if (item := r.input_item) in unrelated[name]}) fallback: dict[str, tuple[str, ...]] = {} for r in det: item = f"{r.model}.{r.leaf}" @@ -2142,6 +2174,7 @@ def unmet(root: str) -> list[str]: input_item=r.input_item, path=_emit_recommend_path(list(reach[root][r.input_item]), r), attachment=r.attachment, + unrelated=r.input_item in unrelated[root], ) for r in resolved ] @@ -2875,6 +2908,7 @@ async def _validate_mode_a_join_paths( datasource = await self.storage.get_datasource(model.data_source) dialect = self._dialect_for_type(datasource.type if datasource else None) models_by_name = {k: v for k, v in loaded.items() if v is not None} + check_definition_reach(model=model, reachable=models_by_name) check_definition_ambiguity(model=model, reachable=models_by_name) def _expand(sql: str) -> None: diff --git a/slayer/engine/reference_closure.py b/slayer/engine/reference_closure.py index aae5c9fe..f6faf218 100644 --- a/slayer/engine/reference_closure.py +++ b/slayer/engine/reference_closure.py @@ -41,6 +41,7 @@ AmbiguousJoinPathError, CircularJoinPathError, SlayerError, + UnreachableDefinitionError, ) from slayer.core.join_walker import canonical_path, walk from slayer.core.models import Column, SlayerModel @@ -87,7 +88,7 @@ def _expand_derived_refs_any_dialect( sql=sql, model=model, alias_path=alias_path, models_by_name=bundle.models_by_name, dialect=dialect, ) - except (ColumnCycleError, CircularJoinPathError): + except (ColumnCycleError, CircularJoinPathError, UnreachableDefinitionError): raise except Exception: continue @@ -138,7 +139,7 @@ def fragment_closure( owner_path=tuple(owner_path), models_by_name=bundle.models_by_name, dialect=dialect, crossed_paths=sink, ) - except (ColumnCycleError, CircularJoinPathError): + except (ColumnCycleError, CircularJoinPathError, UnreachableDefinitionError): raise except Exception: continue @@ -189,7 +190,7 @@ def fragment_null_propagates( models_by_name=bundle.models_by_name, dialect=dialect, ) nodes = list(sqlglot.parse_one(expanded or "", dialect=dialect).walk()) - except (ColumnCycleError, CircularJoinPathError): + except (ColumnCycleError, CircularJoinPathError, UnreachableDefinitionError): raise except Exception: continue @@ -338,10 +339,13 @@ def _column_key_closure( return out owner_relation = "__".join(path) if path else anchor_relation for sql in _definition_fragments(col): - frag = fragment_closure( - sql=sql, model=terminal, owner_path=path, - anchor_relation=owner_relation, bundle=bundle, cache=cache, - ) + try: + frag = fragment_closure( + sql=sql, model=terminal, owner_path=path, + anchor_relation=owner_relation, bundle=bundle, cache=cache, + ) + except UnreachableDefinitionError as exc: + raise exc.labelled(f"column {col.name!r}") from None if frag is None: return None out.extend(frag) diff --git a/slayer/engine/unrelated.py b/slayer/engine/unrelated.py new file mode 100644 index 00000000..b8360ee2 --- /dev/null +++ b/slayer/engine/unrelated.py @@ -0,0 +1,198 @@ +"""Unrelated datasets: what a query frame names that no join path reaches from its population.""" + +from __future__ import annotations + +from typing import Any, Iterable, Iterator, Optional, Tuple + +from pydantic import BaseModel + +from slayer.core.join_search import count_routes +from slayer.core.join_walker import matching_edges, neighbors +from slayer.core.keys import ( + AggregateKey, + ColumnKey, + ColumnSqlKey, + StarKey, + TimeTruncKey, + TransformKey, + ValueKey, +) +from slayer.core.models import SlayerModel +from slayer.core.query import ComputedDimension, SlayerQuery, render_probe_text +from slayer.core.time_spine import is_spine +from slayer.engine.reference_closure import key_closure +from slayer.engine.syntax import DottedRef, parse_expr, parse_filter_expr +from slayer.ir.source_bundle import ResolvedSourceBundle + +__all__ = ["ProductSides", "first_hop_names", "stamp_unrelated", "unrelated_targets"] + + +def _dotted_heads(node: Any) -> Iterator[str]: + """The first token of every dotted reference anywhere in a parsed tree.""" + if isinstance(node, DottedRef): + if len(node.parts) > 1: + yield node.parts[0] + return + if isinstance(node, BaseModel): + for name in type(node).model_fields: + yield from _dotted_heads(getattr(node, name)) + elif isinstance(node, (tuple, list)): + for item in node: + yield from _dotted_heads(item) + + +def _parsed_heads(text: str, *, as_filter: bool) -> Iterator[str]: + try: + parsed = parse_filter_expr(render_probe_text(text)) if as_filter else parse_expr(text) + except Exception: # noqa: BLE001 — the binder reports a malformed expression + return + yield from _dotted_heads(parsed) + + +def _path_head(full_name: str) -> Iterator[str]: + if "." in full_name: + yield full_name.split(".", 1)[0] + + +def first_hop_names(query: SlayerQuery) -> set[str]: + """The first hop of every dotted reference in ``query``'s own fields.""" + out: set[str] = set() + for m in query.measures or []: + out.update(_parsed_heads(m.formula, as_filter=False)) + for d in query.dimensions or []: + out.update(_parsed_heads(d.expression, as_filter=False) if isinstance(d, ComputedDimension) + else _path_head(d.full_name)) + for td in query.time_dimensions or []: + out.update(_path_head(td.dimension.full_name)) + for f in query.filters or []: + out.update(_parsed_heads(f, as_filter=True)) + for o in query.order or []: + out.update(_parsed_heads(o.raw_formula, as_filter=False) if o.raw_formula else _path_head(o.column.full_name)) + return out + + +def _named(token: str, models: Iterable[SlayerModel]) -> Optional[SlayerModel]: + """The dataset ``token`` names: a query stage's spelling first, then a model name.""" + models = list(models) + return next((m for m in models if m.explicit_spelling == token), None) or next( + (m for m in models if m.explicit_spelling is None and m.name == token), None, + ) + + +def unrelated_targets( + *, host: SlayerModel, names: Iterable[str], models_by_name: dict[str, SlayerModel], +) -> frozenset[str]: + """The datasets ``names`` spell that neither an incident edge nor a route reaches from ``host``.""" + universe = {**models_by_name, host.name: host} + incident = neighbors(model=host, models_by_name=universe) + out: set[str] = set() + for token in names: + if token in (host.name, host.spelling) or matching_edges(incident, token): + continue + target = _named(token, universe.values()) + if target is None or is_spine(target) or target.name == host.name: + continue + if count_routes(root=host, target=target.name, models_by_name=universe) == 0: + out.add(target.name) + return frozenset(out) + + +def stamp_unrelated( + *, query: SlayerQuery, bundle: ResolvedSourceBundle, host: SlayerModel, extra: Iterable[SlayerModel] = (), +) -> SlayerModel: + """``host`` as ``query``'s population, carrying the unrelated datasets the frame names + among the bundle's models plus ``extra`` (unspliced query-backed placeholders).""" + models = {**bundle.models_by_name, **{m.name: m for m in extra}} + found = unrelated_targets(host=host, names=first_hop_names(query), models_by_name=models) + return host.with_unrelated(found) if found != host.unrelated_datasets else host + + +def crosses_product_hop( + *, host: SlayerModel, path: Tuple[str, ...], models_by_name: dict[str, SlayerModel], +) -> bool: + """``path`` from ``host`` starts with a product hop to an unrelated dataset.""" + return bool(path) and any( + models_by_name[n].spelling == path[0] for n in host.unrelated_datasets if n in models_by_name + ) + + +class ProductSides: + """Which side of each product hop a population's references read, by dependency closure (engine P10).""" + + def __init__(self, *, host: SlayerModel, bundle: ResolvedSourceBundle) -> None: + models = bundle.models_by_name + self.host = host + self.bundle = bundle + # A product hop's canonical token is its target's spelling. + self.tokens = {models[n].spelling: n for n in host.unrelated_datasets if n in models} + + def crossed(self, leaf: ValueKey) -> frozenset[str]: + """The spellings of the unrelated datasets ``leaf``'s dependency closure reaches.""" + if not self.tokens: + return frozenset() + closure = key_closure(key=leaf, anchor_model=self.host, anchor_relation=self.host.name, bundle=self.bundle) + paths = closure if closure is not None else (_leaf_path(leaf),) + return frozenset(p[0] for p in paths if p and p[0] in self.tokens) + + def row_level_reads(self, root: ValueKey) -> Iterator[Tuple[ValueKey, str]]: + """``(reference, dataset)`` for every read across a product hop outside an aggregation's inputs.""" + if not self.tokens: + return + yield from self._walk(root, inputs=False) + + def _walk(self, node: ValueKey, *, inputs: bool) -> Iterator[Tuple[ValueKey, str]]: + if isinstance(node, AggregateKey): + yield from self._walk_aggregate(node) + elif isinstance(node, TransformKey): + yield from self._walk_transform(node, inputs=inputs) + elif isinstance(node, TimeTruncKey): + yield from self._walk(node.column, inputs=inputs) + elif isinstance(node, (ColumnKey, ColumnSqlKey, StarKey)): + if not inputs: + yield from ((node, dataset) for dataset in sorted(self.crossed(node))) + else: + for child in node.children(): + yield from self._walk(child, inputs=inputs) + + def _walk_aggregate(self, node: AggregateKey) -> Iterator[Tuple[ValueKey, str]]: + for pk in node.partition_keys or (): + yield from self._walk(pk, inputs=False) + for child in (node.source, *node.args, *(v for _, v in node.kwargs)): + if isinstance(child, ValueKey): + yield from self._walk(child, inputs=True) + + def _walk_transform(self, node: TransformKey, *, inputs: bool) -> Iterator[Tuple[ValueKey, str]]: + yield from self._walk(node.input, inputs=inputs) + for k in (*node.partition_keys, node.time_key): + if k is not None: + yield from self._walk(k, inputs=False) + + def mixed_sides(self, conjunct: ValueKey) -> Optional[frozenset[str]]: + """The unrelated datasets a row-level conjunct reads when it also reads anything else, else ``None``.""" + if not self.tokens: + return None + datasets: set[str] = set() + other = False + for leaf in _row_leaves(conjunct): + crossed = self.crossed(leaf) + datasets |= crossed + other = other or not crossed + return frozenset(datasets) if datasets and (other or len(datasets) > 1) else None + + +def _leaf_path(leaf: ValueKey) -> Tuple[str, ...]: + return tuple(getattr(leaf, "path", ()) or ()) + + +def _row_leaves(node: ValueKey) -> Iterator[ValueKey]: + """Column leaves outside aggregates and transforms (attached values belong to no side).""" + if isinstance(node, (AggregateKey, TransformKey)): + return + if isinstance(node, TimeTruncKey): + yield from _row_leaves(node.column) + return + if isinstance(node, (ColumnKey, ColumnSqlKey, StarKey)): + yield node + return + for child in node.children(): + yield from _row_leaves(child) diff --git a/slayer/ir/planned.py b/slayer/ir/planned.py index e9466ebc..7ec6b587 100644 --- a/slayer/ir/planned.py +++ b/slayer/ir/planned.py @@ -409,6 +409,11 @@ class RegroupAttachPlan(BaseModel): # are not additive across (empty for an explicit ``partition_by=`` grain). associated_measure: Optional[str] = None associated_dimensions: List[str] = Field(default_factory=list) + # A producer over an unrelated dataset (its product-hop spelling), the population it + # meets, and the public measures reading it. + unrelated_dataset: Optional[str] = None + unrelated_population: Optional[str] = None + unrelated_measures: List[str] = Field(default_factory=list) # Reachable-but-unsafe conjuncts inlined on a home-rooted association # producer's joins: carried here since ``semi_join_filters`` is # empty for association producers, so the informational entry a semi-join diff --git a/slayer/ir/source_bundle.py b/slayer/ir/source_bundle.py index 9bc5f0c8..98e8bb17 100644 --- a/slayer/ir/source_bundle.py +++ b/slayer/ir/source_bundle.py @@ -72,7 +72,9 @@ def get_referenced_model(self, name: str) -> Optional[SlayerModel]: return None def factor_free(self, model: SlayerModel) -> SlayerModel: - """``model`` as stored: a spine population's P factor without its product hop.""" + """``model`` as stored: a population without its product hops.""" + if model.unrelated_datasets: + model = model.with_unrelated(frozenset()) return model.as_population_factor(False) if model.population_spine else model def rerooted(self, new_source: SlayerModel) -> "ResolvedSourceBundle": diff --git a/slayer/sql/column_expansion.py b/slayer/sql/column_expansion.py index 30e747b9..67cadca0 100644 --- a/slayer/sql/column_expansion.py +++ b/slayer/sql/column_expansion.py @@ -1,6 +1,6 @@ """Recursive expansion of derived ``Column.sql`` references. -Closes DEV-1333. A ``Column.sql`` may reference any other column on the same +A ``Column.sql`` may reference any other column on the same model or on a joined model — including columns that are themselves derived (have their own ``sql`` expression rather than being a bare base-table column). The query planner had been emitting such references verbatim, which @@ -29,8 +29,10 @@ CircularJoinPathError, ColumnCycleError, LegacyDunderAliasError, + UnreachableDefinitionError, UnresolvableDimensionJoinError, ) +from slayer.core.join_search import unreachable_target from slayer.core.join_walker import ( canonical_path, follow, @@ -79,7 +81,7 @@ def is_trivial_base(*, column: Column) -> bool: def root_scope_column_ids(*, parsed: exp.Expression) -> set[int]: """Return the ``id()`` set of ``exp.Column`` nodes that lexically belong - to the root scope of ``parsed`` (DEV-1410). + to the root scope of ``parsed``. Column.sql is contractually a scalar expression, not a SELECT. To re-use sqlglot's scope analysis we wrap ``parsed`` in a synthetic @@ -142,7 +144,7 @@ def add(self, path: Tuple[str, ...], /) -> None: ... # --------------------------------------------------------------------------- -# DEV-1743 — the shared Mode-A qualifier resolver. +# The shared Mode-A qualifier resolver. # # The dotted-canonical flip makes ``.`` the ONLY chain separator in Mode-A free # SQL. A qualifier is EITHER an exact name (the host, or a directly-joined model @@ -254,7 +256,7 @@ def _resolve_qualifiers( models_by_name: ModelsByName, column: Optional[str] = None, ) -> Optional[Tuple[str, ...]]: - """Classify a Mode-A qualifier chain (DEV-1743). + """Classify a Mode-A qualifier chain. Returns: * ``()`` — the reference is anchored on the host / owner model; @@ -275,6 +277,14 @@ def _resolve_qualifiers( if not quals: return () path = tuple(quals) + # A definition is judged from its model as stored: it never sees a query frame's product hops. + source_model = source_model.with_unrelated(frozenset()) if source_model.unrelated_datasets else source_model + dataset = unreachable_target(root=source_model, token=path[0], models_by_name=models_by_name) + if dataset is not None: + raise UnreachableDefinitionError( + model=source_model.name, reference=".".join((*qualifiers, leaf)), dataset=dataset, + definition=f"column {column!r}" if column else None, + ) # A revisit surfaces either from the direct walk or from the legacy # ``a__b`` split-alias probe; re-raise both with the complete pre-strip # reference and the column being expanded. @@ -660,7 +670,7 @@ def expand_derived_refs_sync( ``bundle.referenced_models``) — hops resolve through the shared bidirectional walker. ``owner_path`` is the ROOT-relative path of ``model`` (empty at the scope root). ``alias_resolver`` - (DEV-1743) threads the WP3 join-alias registry so qualifier strings match + threads the WP3 join-alias registry so qualifier strings match the emitted JOIN aliases; ``None`` falls back to the legacy ``"__".join`` spelling. When ``crossed_paths`` is supplied, every join-path prefix the fragment (recursively) crosses is added to it — the structural alternative @@ -673,7 +683,7 @@ def expand_derived_refs_sync( # Reserved-word qualifiers (``grant.amount``) parse as an unsupported # ``Command`` unless quoted, so the reference would be invisible to the # resolver (no join registered). Prequote first — idempotent, so callers - # that already prequoted (the Mode-A door) are unaffected (DEV-1686). + # that already prequoted (the Mode-A door) are unaffected. sql = prequote_reserved_identifiers(sql, dialect=dialect) parsed = sqlglot.parse_one(sql, dialect=dialect) root_scope_ids = root_scope_column_ids(parsed=parsed) diff --git a/slayer/sql/generator.py b/slayer/sql/generator.py index 59bbb21d..cd994188 100644 --- a/slayer/sql/generator.py +++ b/slayer/sql/generator.py @@ -41,7 +41,14 @@ from slayer.core.granularity import CustomGranularity, Granularity, granularity_parts from slayer.core.time_spine import TIME_SPINE_COLUMN, is_spine from slayer.core.keys import BOOL_CONNECTIVE_OPS, KIND_POLICY, REGROUP_LEAF_PREFIX, SLOT_COMPOSITE_KINDS, TEMPORAL_TYPES, VALUE_KEY_TYPES, AggregateKey, ArithmeticKey, ColumnKey, ColumnSqlKey, ColumnTypeFn, InKey, LiteralKey, Phase, ScalarCallKey, SqlFragmentKey, StarKey, TimePointCmpKey, TimeTruncKey, TransformKey, aggregation_source_type, column_path, date_add_type, is_boolean_shaped, parameter_row_leaves, shift_offset_of, source_anchor_path, substitute_value_keys, temporal_type, walk_value_keys -from slayer.core.join_walker import aggregation_owner, follow, model_column_type, physical_join_pairs, resolved_terminal +from slayer.core.join_walker import ( + aggregation_owner, + follow, + is_unrelated_edge, + model_column_type, + physical_join_pairs, + resolved_terminal, +) from slayer.core.models import VALUE_PLACEHOLDER, aggregation_definition, rendered_formula, reserved_value_param_message from slayer.core.refs import EXPRESSION_SOURCE_KINDS as _EXPRESSION_SOURCE_KINDS from slayer.core.window_duration import WINDOW_UNIT_GRANULARITY @@ -4389,7 +4396,9 @@ def _build_from_and_joins( def _hop_join( self, *, edge, prev_model, next_model, current_alias: str, next_alias: str, ) -> Tuple[Expression, Optional[exp.Condition], str]: - """``(join_expr, on_expr, join_type)`` for one oriented hop.""" + """``(join_expr, on_expr, join_type)`` for one oriented hop; an unrelated product hop fails closed.""" + if is_unrelated_edge(edge): + raise ValueError(f"The product hop {edge.source_model} × {edge.target_model} cannot be joined.") join_on_parts = [ # _to_ident quotes mixed-case keys; table qualifiers are internal aliases. exp.EQ( diff --git a/slayer/sql/render/row_expr.py b/slayer/sql/render/row_expr.py index b94f81ce..f15beaf4 100644 --- a/slayer/sql/render/row_expr.py +++ b/slayer/sql/render/row_expr.py @@ -152,6 +152,13 @@ def _render_unary(*, op: str, operand: Expression) -> Expression: raise NotImplementedError(f"Unsupported unary operator {op!r}.") +def _nonzero_number(node: Expression) -> bool: + try: + return isinstance(node, exp.Literal) and node.is_number and float(node.this) != 0 + except ValueError: + return False + + def _fold_binary( *, node_cls: Any, operands: List[Expression], ) -> Expression: @@ -167,6 +174,8 @@ def _fold_binary( rhs = _paren_if_lower_prec( rhs, parent_prec=parent_prec, is_right=True, ) + if node_cls is exp.Div and not _nonzero_number(rhs): + rhs = exp.Nullif(this=rhs, expression=exp.Literal.number(0)) # division by zero is NULL result = node_cls(this=lhs, expression=rhs) return result diff --git a/slayer/sql/scope.py b/slayer/sql/scope.py index 8700b953..01e1fa5a 100644 --- a/slayer/sql/scope.py +++ b/slayer/sql/scope.py @@ -28,7 +28,7 @@ from sqlglot.errors import ParseError from slayer.core.enums import DataType -from slayer.core.errors import ModeASqlParseError, UnknownReferenceError +from slayer.core.errors import ModeASqlParseError, UnknownReferenceError, UnreachableDefinitionError from slayer.core.join_walker import model_column_type, resolved_terminal from slayer.core.keys import ( REGROUP_LEAF_PREFIX, @@ -256,16 +256,19 @@ def _enter( owner_path=owner_path, ) - expanded = expand_derived_refs_sync( - sql=prequoted, - model=owner_model, - alias_path=alias_path, - models_by_name=self._models_by_name(), - dialect=self.dialect.sqlglot_name, - owner_path=owner_path, - alias_resolver=self._alias_resolver(), - crossed_paths=self.join_paths, - ) + try: + expanded = expand_derived_refs_sync( + sql=prequoted, + model=owner_model, + alias_path=alias_path, + models_by_name=self._models_by_name(), + dialect=self.dialect.sqlglot_name, + owner_path=owner_path, + alias_resolver=self._alias_resolver(), + crossed_paths=self.join_paths, + ) + except UnreachableDefinitionError as exc: + raise exc.labelled(f"definition {sql!r}") from None if expanded is None or expanded == prequoted: final = raw_ast else: diff --git a/tests/_dev1871_raise_ledger.py b/tests/_dev1871_raise_ledger.py index 666d5c5d..827f607b 100644 --- a/tests/_dev1871_raise_ledger.py +++ b/tests/_dev1871_raise_ledger.py @@ -419,6 +419,12 @@ def _row(module, function, exc, message, category, family, user, owner, _row(module=_EE, function='check_spine_raw_rows', exc='TimeSpineError', message='A time_spine query cannot set distinct_dimension_values=false: the spine has no rows.\n suggestion: …', category="checker", family='time-spine', user=True, owner="checker"), + _row(module=_EE, function='check_unrelated_filter_sides', exc='UnrelatedDatasetError', + message='The filter condition … reads … together with another dataset, but no join path reaches … from the population …: each condition must read one side alone.\n suggestion: Split it into AND-ed conditions that each read one dataset.', + category="checker", family='unrelated-datasets', user=True, owner="checker"), + _row(module=_EE, function='check_unrelated_row_read', exc='UnrelatedDatasetError', + message='… reads …, which no join path reaches from the population …: it meets … as a product, so it is read only through aggregates.\n at …\n suggestion: Aggregate it, e.g. max(…).', + category="checker", family='unrelated-datasets', user=True, owner="checker"), _row(module=_PL, function="_iter_slot_deps", exc="TypeError", message="_iter_slot_deps has no case for …: classify the kind explicitly (slot-worthy, inlined composite, or never slottable).", category="internal", family="internal", user=False, owner="compiler"), diff --git a/tests/_mcp_idiom_fixtures.py b/tests/_mcp_idiom_fixtures.py index d8daca09..988b8ecf 100644 --- a/tests/_mcp_idiom_fixtures.py +++ b/tests/_mcp_idiom_fixtures.py @@ -23,6 +23,7 @@ orders (id, customer, amount): 1 Alice 10 | 2 Alice 20 | 3 Bob 35 | 4 Carol 40 | 5 Dan 50 | 6 NULL 6 | 7 #99 (no such customer) 7 returns (id, customer, amount): 1 Alice 1 | 2 Alice 2 | 3 Alice 4 | 4 Carol 8 +events (id, kind), joined to nothing: 1 a | 2 b | 3 a | 4 c | 5 a | 6 b Orders: Alice 30, Bob 35, Carol 40, Dan 50, parentless 13; total 168. Returns: Alice 7, Carol 8; total 15. By region: North 65, South 40, NULL 63 (Dan + parentless). @@ -67,6 +68,9 @@ SPINE_MEASURE = "sum(orders.amount)" SECOND_CHILD = "sum(returns.amount)" CROSS_MODEL_RATIO = "sum(orders.amount) / count(*)" +#: Guidance marker for an aggregate over a model no join path reaches; owned by ``measures``. +UNRELATED_MODEL = "no join path reaches" +UNRELATED_RATIO = "count(events.id) / count(*)" # Guidance markers STAGE_NOT_NEEDED = "A STAGE IS NOT NEEDED" @@ -221,6 +225,13 @@ def child(name: str) -> SlayerModel: Column(name="name", type=DataType.TEXT), ], ), + SlayerModel( + name="events", sql_table="events", data_source=data_source, + columns=[ + Column(name="id", type=DataType.INT, primary_key=True), + Column(name="kind", type=DataType.TEXT), + ], + ), ] @@ -240,6 +251,8 @@ def seed(db_path: str) -> None: "(6, NULL, 6), (7, 99, 7)", "CREATE TABLE returns (id INTEGER PRIMARY KEY, customer_id INTEGER, amount INTEGER)", "INSERT INTO returns VALUES (1, 1, 1), (2, 1, 2), (3, 1, 4), (4, 3, 8)", + "CREATE TABLE events (id INTEGER PRIMARY KEY, kind VARCHAR)", + "INSERT INTO events VALUES (1, 'a'), (2, 'b'), (3, 'a'), (4, 'c'), (5, 'a'), (6, 'b')", ): con.execute(stmt) con.close() diff --git a/tests/_unrelated_datasets_fixtures.py b/tests/_unrelated_datasets_fixtures.py new file mode 100644 index 00000000..27226171 --- /dev/null +++ b/tests/_unrelated_datasets_fixtures.py @@ -0,0 +1,344 @@ +"""Unrelated-dataset seeds, engines, row helpers and the emitted-SQL product-hop checker. + +Main seed (datasource ``test``), with no join path between ``customers`` and ``events``:: + + customers (id, city, tenant): 1 A t1 | 2 A t1 | 3 B t2 + events (id, amount, created_at, kind, user_id, tenant): + 1 10 2024-01-01 x 1 t1 | 2 20 2024-01-02 y 1 t1 | 3 30 2024-02-01 x 2 t1 + 4 40 2024-02-02 x 2 t2 | 5 50 2024-03-01 y 3 t2 + users (id, name, org_id, tenant): 1 u1 1 t1 | 2 u2 1 t1 | 3 u3 2 t2 + orgs (id, name, tenant): 1 o1 t1 | 2 o2 t2 + +``events → users → orgs`` many-to-one; ``events.amount_x2`` is ``amount * 2``. + +Wide seed (datasource ``wide``): ``customers`` (200 rows over 7 cities) and the unrelated +``big`` (1,000 rows), ``small`` (3 rows) and ``empty`` (0 rows), each ``(id, v)``. +""" + +from __future__ import annotations + +import contextlib +import warnings +from collections.abc import AsyncGenerator, Iterable +from typing import Any, Optional + +import sqlglot +from sqlglot import exp +from sqlglot.optimizer.scope import Scope, build_scope + +from slayer.core.enums import DataType, JoinCardinality +from slayer.core.models import Column, ModelJoin, SlayerModel +from slayer.core.query import SlayerQuery +from slayer.engine.query_engine import SlayerQueryEngine, SlayerResponse + +from tests._dev1737_fixtures import TableSpec, seed_backend +from tests._engine_helpers import seeded_exec_engine + +BACKENDS = ("sqlite", "duckdb") + +CUSTOMERS = TableSpec( + name="customers", + columns=[("id", "INT"), ("city", "TEXT"), ("tenant", "TEXT")], + rows=[(1, "A", "t1"), (2, "A", "t1"), (3, "B", "t2")], +) +EVENT_ROWS: list[tuple] = [ + (1, 10.0, "2024-01-01", "x", 1, "t1"), (2, 20.0, "2024-01-02", "y", 1, "t1"), + (3, 30.0, "2024-02-01", "x", 2, "t1"), (4, 40.0, "2024-02-02", "x", 2, "t2"), + (5, 50.0, "2024-03-01", "y", 3, "t2"), +] +USERS = TableSpec( + name="users", + columns=[("id", "INT"), ("name", "TEXT"), ("org_id", "INT"), ("tenant", "TEXT")], + rows=[(1, "u1", 1, "t1"), (2, "u2", 1, "t1"), (3, "u3", 2, "t2")], +) +ORGS = TableSpec( + name="orgs", columns=[("id", "INT"), ("name", "TEXT"), ("tenant", "TEXT")], + rows=[(1, "o1", "t1"), (2, "o2", "t2")], +) + + +def events_table(rows: Optional[list[tuple]] = None) -> TableSpec: + return TableSpec( + name="events", + columns=[ + ("id", "INT"), ("amount", "DOUBLE"), ("created_at", "DATE"), ("kind", "TEXT"), + ("user_id", "INT"), ("tenant", "TEXT"), + ], + rows=EVENT_ROWS if rows is None else rows, + ) + + +def main_tables(*, event_rows: Optional[list[tuple]] = None) -> list[TableSpec]: + return [CUSTOMERS, events_table(event_rows), USERS, ORGS] + + +def _many_to_one(target: str, column: str) -> ModelJoin: + return ModelJoin(target_model=target, join_pairs=[[column, "id"]], cardinality=JoinCardinality.MANY_TO_ONE) + + +def customers_model(**extra: Any) -> SlayerModel: + columns = [ + Column(name="id", type=DataType.INT, primary_key=True), + Column(name="city", type=DataType.TEXT), + Column(name="tenant", type=DataType.TEXT), + *extra.pop("columns", []), + ] + return SlayerModel(name="customers", sql_table="customers", data_source="test", columns=columns, **extra) + + +def events_model() -> SlayerModel: + return SlayerModel( + name="events", sql_table="events", data_source="test", default_time_dimension="created_at", + columns=[ + Column(name="id", type=DataType.INT, primary_key=True), + Column(name="amount", type=DataType.DOUBLE), + Column(name="amount_x2", type=DataType.DOUBLE, sql="amount * 2"), + Column(name="created_at", type=DataType.DATE), + Column(name="kind", type=DataType.TEXT), + Column(name="user_id", type=DataType.INT), + Column(name="tenant", type=DataType.TEXT), + ], + joins=[_many_to_one("users", "user_id")], + ) + + +def users_model() -> SlayerModel: + return SlayerModel( + name="users", sql_table="users", data_source="test", + columns=[ + Column(name="id", type=DataType.INT, primary_key=True), + Column(name="name", type=DataType.TEXT), + Column(name="org_id", type=DataType.INT), + Column(name="tenant", type=DataType.TEXT), + ], + joins=[_many_to_one("orgs", "org_id")], + ) + + +def orgs_model() -> SlayerModel: + return SlayerModel( + name="orgs", sql_table="orgs", data_source="test", + columns=[ + Column(name="id", type=DataType.INT, primary_key=True), + Column(name="name", type=DataType.TEXT), + Column(name="tenant", type=DataType.TEXT), + ], + ) + + +def main_models() -> list[SlayerModel]: + return [customers_model(), events_model(), users_model(), orgs_model()] + + +@contextlib.asynccontextmanager +async def main_engine( + backend: str, *, models: Optional[list[SlayerModel]] = None, event_rows: Optional[list[tuple]] = None, +) -> AsyncGenerator[SlayerQueryEngine]: + """Executing engine over the main seed.""" + tables = main_tables(event_rows=event_rows) + async with seeded_exec_engine( + dialect=backend, seed=lambda p: seed_backend(backend, p, tables), + models=main_models() if models is None else models, + ) as (engine, _db): + yield engine + + +# --------------------------------------------------------------------------- +# Wide seed: three unrelated datasets of very different sizes +# --------------------------------------------------------------------------- + +WIDE_CITIES = ("c0", "c1", "c2", "c3", "c4", "c5", "c6") +WIDE_SIZES = {"big": 1000, "small": 3, "empty": 0} +WIDE_DATASETS = tuple(WIDE_SIZES) + + +def _wide_tables() -> list[TableSpec]: + customers = TableSpec( + name="customers", columns=[("id", "INT"), ("city", "TEXT")], + rows=[(i, WIDE_CITIES[i % len(WIDE_CITIES)]) for i in range(1, 201)], + ) + return [customers, *( + TableSpec(name=name, columns=[("id", "INT"), ("v", "DOUBLE")], + rows=[(i, float(i * i % 997 + 1)) for i in range(1, size + 1)]) + for name, size in WIDE_SIZES.items() + )] + + +def _wide_models() -> list[SlayerModel]: + def flat(name: str, *columns: Column) -> SlayerModel: + return SlayerModel( + name=name, sql_table=name, data_source="wide", + columns=[Column(name="id", type=DataType.INT, primary_key=True), *columns], + ) + + return [ + flat("customers", Column(name="city", type=DataType.TEXT)), + *(flat(name, Column(name="v", type=DataType.DOUBLE)) for name in WIDE_DATASETS), + ] + + +@contextlib.asynccontextmanager +async def wide_engine(backend: str) -> AsyncGenerator[SlayerQueryEngine]: + tables = _wide_tables() + async with seeded_exec_engine( + dialect=backend, seed=lambda p: seed_backend(backend, p, tables), models=_wide_models(), datasource="wide", + ) as (engine, _db): + yield engine + + +def wide_measures() -> list[dict[str, str]]: + """Two aggregates per unrelated dataset, three cross-dataset expressions, and ``count(*)``.""" + out = [m("count(*)", "n_customers")] + for name in WIDE_DATASETS: + out += [m(f"sum({name}.v)", f"{name}_sum"), m(f"count({name}.id)", f"{name}_n")] + out += [ + m("sum(big.v) + sum(small.v)", "big_plus_small"), + m("count(big.id) + count(small.id) + count(empty.id)", "all_rows"), + m("count(small.id) / count(*)", "small_per_customer"), + ] + return out + + +# --------------------------------------------------------------------------- +# Queries, rows, warnings +# --------------------------------------------------------------------------- + +def m(formula: str, name: str) -> dict[str, str]: + return {"formula": formula, "name": name} + + +RATIO = m("count(events.id) / count(*)", "events_per_customer") +GROUPED = [m("count(*)", "n_customers"), m("count(events.id)", "n_events")] + + +def query(**fields: Any) -> SlayerQuery: + return SlayerQuery.model_validate({"source_model": "customers", **fields}) + + +def ratio_query(**extra: Any) -> SlayerQuery: + return query(measures=[RATIO], **extra) + + +def grouped_query(**extra: Any) -> SlayerQuery: + return query(**{"dimensions": ["city"], "measures": GROUPED, **extra}) + + +def stages(*raw: dict[str, Any]) -> list[SlayerQuery]: + return [SlayerQuery.model_validate(s) for s in raw] + + +def key_of(row: dict[str, Any], name: str) -> str: + """The unique result key naming ``name`` (a bare name or its dotted tail).""" + hits = [k for k in row if k == name or k.endswith(f".{name}")] + assert len(hits) == 1, (name, list(row)) + return hits[0] + + +def value(row: dict[str, Any], name: str) -> Any: + v = row[key_of(row, name)] + return float(v) if isinstance(v, (int, float)) and not isinstance(v, bool) else v + + +def rows(resp: SlayerResponse, *names: str, by: str = "city") -> dict[Any, tuple]: + """``{by value: (values of names...)}``; asserts the ``by`` values are unique.""" + out: dict[Any, tuple] = {} + for row in resp.data: + k = value(row, by) + assert k not in out, k + out[k] = tuple(value(row, n) for n in names) + return out + + +def only_row(resp: SlayerResponse, *names: str) -> tuple: + assert len(resp.data) == 1, resp.data + return tuple(value(resp.data[0], n) for n in names) + + +def warnings_of(resp: SlayerResponse, kind: str) -> list: + return [w for w in (resp.warnings or []) if getattr(w, "kind", None) == kind] + + +def unrelated_warnings(resp: SlayerResponse) -> list: + return warnings_of(resp, "unrelated_dataset") + + +async def execute_capturing(engine: SlayerQueryEngine, q: Any) -> tuple[SlayerResponse, list[warnings.WarningMessage]]: + """Execute ``q``; the response and every Python warning raised meanwhile.""" + with warnings.catch_warnings(record=True) as caught: + warnings.simplefilter("always") + resp = await engine.execute(q) + return resp, list(caught) + + +# --------------------------------------------------------------------------- +# Emitted-SQL checker: unrelated tables only in their own producers and uncorrelated EXISTS +# --------------------------------------------------------------------------- + +def _aggregates(scope: Scope) -> bool: + select = scope.expression + if not isinstance(select, exp.Select): + return False + if select.args.get("group"): + return True + return any( + agg.find_ancestor(exp.Window) is None + for projection in select.expressions for agg in projection.find_all(exp.AggFunc) + ) + + +def _row_inputs(scope: Scope, physical: frozenset[str], memo: dict[int, frozenset[str]]) -> frozenset[str]: + """The physical tables whose rows reach ``scope``'s rows unaggregated.""" + if id(scope) in memo: + return memo[id(scope)] + found: set[str] = set() + for source in scope.sources.values(): + if isinstance(source, Scope): + if not _aggregates(source): + found |= _row_inputs(source, physical, memo) + elif isinstance(source, exp.Table) and source.name in physical: + found.add(source.name) + for union_branch in scope.union_scopes: + found |= _row_inputs(union_branch, physical, memo) + memo[id(scope)] = frozenset(found) + return memo[id(scope)] + + +def _correlated(scope: Scope) -> bool: + """Some qualified column names a table outside ``scope`` (unqualified ones are its own).""" + return any(col.table and col.table not in scope.sources for col in scope.columns) + + +def _nested_scopes(scope: Scope) -> Iterable[Scope]: + for child in (*scope.subquery_scopes, *scope.derived_table_scopes, *scope.cte_scopes, *scope.union_scopes): + yield child + yield from _nested_scopes(child) + + +def product_hop_violations( + sql: Optional[str], *, dialect: str, unrelated: Iterable[str], physical: Iterable[str], +) -> list[str]: + """Every place ``sql`` pairs an unrelated table's rows with other rows or correlates across it.""" + assert sql is not None + unrelated, physical = frozenset(unrelated), frozenset(physical) | frozenset(unrelated) + root = build_scope(sqlglot.parse_one(sql, dialect=dialect)) + assert root is not None, sql + scopes = [root, *_nested_scopes(root)] + memo: dict[int, frozenset[str]] = {} + out: list[str] = [] + seen: set[str] = set() + for scope in scopes: + inputs = _row_inputs(scope, physical, memo) + seen |= inputs & unrelated + for table in inputs & unrelated: + if inputs != {table}: + out.append(f"{table} rows meet {sorted(inputs - {table})}: {scope.expression.sql(dialect=dialect)}") + if inputs & unrelated: + correlated = [s for s in (scope, *_nested_scopes(scope)) if _correlated(s)] + out += [f"correlated beside {sorted(inputs & unrelated)}: {s.expression.sql(dialect=dialect)}" + for s in correlated] + reads_unrelated_inside = any(_row_inputs(s, physical, memo) & unrelated for s in _nested_scopes(scope)) + if reads_unrelated_inside and scope.is_subquery and _correlated(scope): + out.append(f"correlated subquery reads an unrelated table: {scope.expression.sql(dialect=dialect)}") + missing = unrelated - seen + assert not missing, f"{sorted(missing)} never read:\n{sql}" + return out diff --git a/tests/golden/dev1739_sql_baseline.json b/tests/golden/dev1739_sql_baseline.json index 5d788330..d2d39a9a 100644 --- a/tests/golden/dev1739_sql_baseline.json +++ b/tests/golden/dev1739_sql_baseline.json @@ -74,11 +74,11 @@ "local/multi_key::postgres": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.channel AS \"orders.channel\",\n orders.city AS \"orders.city\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.channel,\n orders.city\n), _cm_orders__amount_sum_partition_by_channel_region AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.channel AS \"orders.channel\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.rc\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.channel\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.channel\",\n _base.\"orders.city\",\n _cm_orders__amount_sum_partition_by_channel_region.\"orders.rc\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_channel_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_channel_region.\"orders.region\"\n AND _base.\"orders.channel\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_channel_region.\"orders.channel\"", "local/multi_key::sqlite": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.channel AS \"orders.channel\",\n orders.city AS \"orders.city\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.channel,\n orders.city\n), _cm_orders__amount_sum_partition_by_channel_region AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.channel AS \"orders.channel\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.rc\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.channel\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.channel\",\n _base.\"orders.city\",\n _cm_orders__amount_sum_partition_by_channel_region.\"orders.rc\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_channel_region\n ON _base.\"orders.region\" IS _cm_orders__amount_sum_partition_by_channel_region.\"orders.region\"\n AND _base.\"orders.channel\" IS _cm_orders__amount_sum_partition_by_channel_region.\"orders.channel\"", "local/multi_key::tsql": "WITH _base AS (\n SELECT\n orders.region AS [orders___region],\n orders.channel AS [orders___channel],\n orders.city AS [orders___city]\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.channel,\n orders.city\n), _cm_orders__amount_sum_partition_by_channel_region AS (\n SELECT\n orders.region AS [orders___region],\n orders.channel AS [orders___channel],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___rc]\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.channel\n)\nSELECT\n _base.[orders___region],\n _base.[orders___channel],\n _base.[orders___city],\n _cm_orders__amount_sum_partition_by_channel_region.[orders___rc]\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_channel_region\n ON (\n _base.[orders___region] = _cm_orders__amount_sum_partition_by_channel_region.[orders___region]\n OR (\n _base.[orders___region] IS NULL\n AND _cm_orders__amount_sum_partition_by_channel_region.[orders___region] IS NULL\n )\n )\n AND (\n _base.[orders___channel] = _cm_orders__amount_sum_partition_by_channel_region.[orders___channel]\n OR (\n _base.[orders___channel] IS NULL\n AND _cm_orders__amount_sum_partition_by_channel_region.[orders___channel] IS NULL\n )\n )", - "local/share_composite::bigquery": "WITH _base AS (\n SELECT\n orders.region AS `orders___region`,\n orders.city AS `orders___city`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city\n), _cm_orders__amount_sum_partition_by_region AS (\n SELECT\n orders.region AS `orders___region`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum_partition_by_region`\n FROM orders AS orders\n GROUP BY\n orders.region\n)\nSELECT\n _base.`orders___region`,\n _base.`orders___city`,\n _base.`orders___amount_sum` / _cm_orders__amount_sum_partition_by_region.`orders___amount_sum_partition_by_region` AS `orders___sh`\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_region.`orders___region`", - "local/share_composite::duckdb": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city\n), _cm_orders__amount_sum_partition_by_region AS (\n SELECT\n orders.region AS \"orders.region\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum_partition_by_region\"\n FROM orders AS orders\n GROUP BY\n orders.region\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.amount_sum\" / _cm_orders__amount_sum_partition_by_region.\"orders.amount_sum_partition_by_region\" AS \"orders.sh\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_region.\"orders.region\"", - "local/share_composite::postgres": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city\n), _cm_orders__amount_sum_partition_by_region AS (\n SELECT\n orders.region AS \"orders.region\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum_partition_by_region\"\n FROM orders AS orders\n GROUP BY\n orders.region\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n CAST(_base.\"orders.amount_sum\" AS DOUBLE PRECISION) / _cm_orders__amount_sum_partition_by_region.\"orders.amount_sum_partition_by_region\" AS \"orders.sh\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_region.\"orders.region\"", - "local/share_composite::sqlite": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city\n), _cm_orders__amount_sum_partition_by_region AS (\n SELECT\n orders.region AS \"orders.region\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum_partition_by_region\"\n FROM orders AS orders\n GROUP BY\n orders.region\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n CAST(_base.\"orders.amount_sum\" AS REAL) / _cm_orders__amount_sum_partition_by_region.\"orders.amount_sum_partition_by_region\" AS \"orders.sh\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON _base.\"orders.region\" IS _cm_orders__amount_sum_partition_by_region.\"orders.region\"", - "local/share_composite::tsql": "WITH _base AS (\n SELECT\n orders.region AS [orders___region],\n orders.city AS [orders___city],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city\n), _cm_orders__amount_sum_partition_by_region AS (\n SELECT\n orders.region AS [orders___region],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___amount_sum_partition_by_region]\n FROM orders AS orders\n GROUP BY\n orders.region\n)\nSELECT\n _base.[orders___region],\n _base.[orders___city],\n CAST(_base.[orders___amount_sum] AS FLOAT) / _cm_orders__amount_sum_partition_by_region.[orders___amount_sum_partition_by_region] AS [orders___sh]\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON (\n _base.[orders___region] = _cm_orders__amount_sum_partition_by_region.[orders___region]\n OR (\n _base.[orders___region] IS NULL\n AND _cm_orders__amount_sum_partition_by_region.[orders___region] IS NULL\n )\n )", + "local/share_composite::bigquery": "WITH _base AS (\n SELECT\n orders.region AS `orders___region`,\n orders.city AS `orders___city`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city\n), _cm_orders__amount_sum_partition_by_region AS (\n SELECT\n orders.region AS `orders___region`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum_partition_by_region`\n FROM orders AS orders\n GROUP BY\n orders.region\n)\nSELECT\n _base.`orders___region`,\n _base.`orders___city`,\n _base.`orders___amount_sum` / NULLIF(\n _cm_orders__amount_sum_partition_by_region.`orders___amount_sum_partition_by_region`,\n 0\n ) AS `orders___sh`\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_region.`orders___region`", + "local/share_composite::duckdb": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city\n), _cm_orders__amount_sum_partition_by_region AS (\n SELECT\n orders.region AS \"orders.region\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum_partition_by_region\"\n FROM orders AS orders\n GROUP BY\n orders.region\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.amount_sum\" / NULLIF(\n _cm_orders__amount_sum_partition_by_region.\"orders.amount_sum_partition_by_region\",\n 0\n ) AS \"orders.sh\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_region.\"orders.region\"", + "local/share_composite::postgres": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city\n), _cm_orders__amount_sum_partition_by_region AS (\n SELECT\n orders.region AS \"orders.region\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum_partition_by_region\"\n FROM orders AS orders\n GROUP BY\n orders.region\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n CAST(_base.\"orders.amount_sum\" AS DOUBLE PRECISION) / NULLIF(\n _cm_orders__amount_sum_partition_by_region.\"orders.amount_sum_partition_by_region\",\n 0\n ) AS \"orders.sh\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_region.\"orders.region\"", + "local/share_composite::sqlite": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city\n), _cm_orders__amount_sum_partition_by_region AS (\n SELECT\n orders.region AS \"orders.region\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum_partition_by_region\"\n FROM orders AS orders\n GROUP BY\n orders.region\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n CAST(_base.\"orders.amount_sum\" AS REAL) / NULLIF(\n _cm_orders__amount_sum_partition_by_region.\"orders.amount_sum_partition_by_region\",\n 0\n ) AS \"orders.sh\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON _base.\"orders.region\" IS _cm_orders__amount_sum_partition_by_region.\"orders.region\"", + "local/share_composite::tsql": "WITH _base AS (\n SELECT\n orders.region AS [orders___region],\n orders.city AS [orders___city],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city\n), _cm_orders__amount_sum_partition_by_region AS (\n SELECT\n orders.region AS [orders___region],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___amount_sum_partition_by_region]\n FROM orders AS orders\n GROUP BY\n orders.region\n)\nSELECT\n _base.[orders___region],\n _base.[orders___city],\n CAST(_base.[orders___amount_sum] AS FLOAT) / NULLIF(\n _cm_orders__amount_sum_partition_by_region.[orders___amount_sum_partition_by_region],\n 0\n ) AS [orders___sh]\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON (\n _base.[orders___region] = _cm_orders__amount_sum_partition_by_region.[orders___region]\n OR (\n _base.[orders___region] IS NULL\n AND _cm_orders__amount_sum_partition_by_region.[orders___region] IS NULL\n )\n )", "local/single_key::bigquery": "WITH _base AS (\n SELECT\n orders.region AS `orders___region`,\n orders.city AS `orders___city`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___city_rev`\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city\n), _cm_orders__amount_sum_partition_by_region AS (\n SELECT\n orders.region AS `orders___region`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___region_rev`\n FROM orders AS orders\n GROUP BY\n orders.region\n)\nSELECT\n _base.`orders___region`,\n _base.`orders___city`,\n _base.`orders___city_rev`,\n _cm_orders__amount_sum_partition_by_region.`orders___region_rev`\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_region.`orders___region`", "local/single_key::duckdb": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.city_rev\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city\n), _cm_orders__amount_sum_partition_by_region AS (\n SELECT\n orders.region AS \"orders.region\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.region_rev\"\n FROM orders AS orders\n GROUP BY\n orders.region\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.city_rev\",\n _cm_orders__amount_sum_partition_by_region.\"orders.region_rev\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_region.\"orders.region\"", "local/single_key::postgres": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.city_rev\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city\n), _cm_orders__amount_sum_partition_by_region AS (\n SELECT\n orders.region AS \"orders.region\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.region_rev\"\n FROM orders AS orders\n GROUP BY\n orders.region\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.city_rev\",\n _cm_orders__amount_sum_partition_by_region.\"orders.region_rev\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_region.\"orders.region\"", diff --git a/tests/golden/dev1750_sql_baseline.json b/tests/golden/dev1750_sql_baseline.json index a5cab6b3..b18c1c8a 100644 --- a/tests/golden/dev1750_sql_baseline.json +++ b/tests/golden/dev1750_sql_baseline.json @@ -49,11 +49,11 @@ "change/of_wscaled::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_wscaled_sum_w_customers_regions_weight AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount * customers__regions.weight) AS DOUBLE PRECISION) AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM _base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_wscaled_sum_w_customers_regions_weight\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\" - \"orders._time_shift_inner\" AS \"orders.delta\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.delta\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.delta\"\n FROM step1\n) AS _outer", "change/of_wscaled::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__amount_wscaled_sum_w_customers_regions_weight AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount * customers__regions.weight) AS REAL) AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM _base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON _base.\"orders.ordered_at\" IS _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_wscaled_sum_w_customers_regions_weight\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\" - \"orders._time_shift_inner\" AS \"orders.delta\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.delta\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.delta\"\n FROM step1\n) AS _outer", "change/of_wscaled::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), _cm_orders__amount_wscaled_sum_w_customers_regions_weight AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n CAST(SUM(orders.amount * customers__regions.weight) AS FLOAT) AS [orders___amount_wscaled_sum_w_customers_regions_weight]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), base AS (\n SELECT\n _base.[orders___ordered_at] AS [orders___ordered_at],\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___amount_wscaled_sum_w_customers_regions_weight] AS [orders___amount_wscaled_sum_w_customers_regions_weight]\n FROM _base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON (\n _base.[orders___ordered_at] = _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at]\n OR (\n _base.[orders___ordered_at] IS NULL\n AND _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at] IS NULL\n )\n )\n), sjoin__time_shift_inner AS (\n SELECT\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[orders___amount_wscaled_sum_w_customers_regions_weight] AS [orders___amount_wscaled_sum_w_customers_regions_weight],\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___amount_wscaled_sum_w_customers_regions_weight] AS [orders____time_shift_inner]\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at] IS NULL\n )\n )\n), step1 AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___amount_wscaled_sum_w_customers_regions_weight] AS [orders___amount_wscaled_sum_w_customers_regions_weight],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n [orders___amount_wscaled_sum_w_customers_regions_weight] - [orders____time_shift_inner] AS [orders___delta]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [orders___ordered_at],\n [orders___delta]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders___amount_wscaled_sum_w_customers_regions_weight],\n [orders____time_shift_inner],\n [orders___delta]\n FROM step1\n) AS _outer", - "change_pct/of_local_with_cm_sibling::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS FLOAT64) AS `customers___spend_sum`\n FROM customers AS customers\n), base AS (\n SELECT\n _base.`orders___ordered_at`,\n _cm_orders__customers__spend_sum.`customers___spend_sum` AS `orders___cm`,\n _base.`orders___amount_sum`\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), shifted__time_shift_inner AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), sjoin__time_shift_inner AS (\n SELECT\n base.`orders___ordered_at`,\n base.`orders___amount_sum`,\n base.`orders___cm`,\n shifted__time_shift_inner.`orders___amount_sum` AS `orders____time_shift_inner`\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON CAST(DATETIME_ADD(CAST(CAST(base.`orders___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___cm`,\n `orders____time_shift_inner`,\n (\n `orders___amount_sum` - `orders____time_shift_inner`\n ) / NULLIF(`orders____time_shift_inner`, 0) AS `orders___delta`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___cm`,\n `orders___delta`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___cm`,\n `orders____time_shift_inner`,\n `orders___delta`\n FROM step1\n) AS _outer", - "change_pct/of_local_with_cm_sibling::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS DOUBLE) AS \"customers.spend_sum\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.cm\",\n _base.\"orders.amount_sum\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), shifted__time_shift_inner AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.cm\",\n shifted__time_shift_inner.\"orders.amount_sum\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders._time_shift_inner\",\n (\n \"orders.amount_sum\" - \"orders._time_shift_inner\"\n ) / NULLIF(\"orders._time_shift_inner\", 0) AS \"orders.delta\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.cm\",\n \"orders.delta\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders._time_shift_inner\",\n \"orders.delta\"\n FROM step1\n) AS _outer", - "change_pct/of_local_with_cm_sibling::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS DOUBLE PRECISION) AS \"customers.spend_sum\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.cm\",\n _base.\"orders.amount_sum\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), shifted__time_shift_inner AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.cm\",\n shifted__time_shift_inner.\"orders.amount_sum\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders._time_shift_inner\",\n CAST((\n \"orders.amount_sum\" - \"orders._time_shift_inner\"\n ) AS DOUBLE PRECISION) / NULLIF(\"orders._time_shift_inner\", 0) AS \"orders.delta\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.cm\",\n \"orders.delta\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders._time_shift_inner\",\n \"orders.delta\"\n FROM step1\n) AS _outer", - "change_pct/of_local_with_cm_sibling::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS REAL) AS \"customers.spend_sum\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.cm\",\n _base.\"orders.amount_sum\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), shifted__time_shift_inner AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.cm\",\n shifted__time_shift_inner.\"orders.amount_sum\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders._time_shift_inner\",\n CAST((\n \"orders.amount_sum\" - \"orders._time_shift_inner\"\n ) AS REAL) / NULLIF(\"orders._time_shift_inner\", 0) AS \"orders.delta\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.cm\",\n \"orders.delta\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders._time_shift_inner\",\n \"orders.delta\"\n FROM step1\n) AS _outer", - "change_pct/of_local_with_cm_sibling::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS FLOAT) AS [customers___spend_sum]\n FROM customers AS customers\n), base AS (\n SELECT\n _base.[orders___ordered_at] AS [orders___ordered_at],\n _cm_orders__customers__spend_sum.[customers___spend_sum] AS [orders___cm],\n _base.[orders___amount_sum] AS [orders___amount_sum]\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), shifted__time_shift_inner AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___amount_sum]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[orders___amount_sum] AS [orders___amount_sum],\n base.[orders___cm] AS [orders___cm],\n shifted__time_shift_inner.[orders___amount_sum] AS [orders____time_shift_inner]\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\n )\n), step1 AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders___cm] AS [orders___cm],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n CAST((\n [orders___amount_sum] - [orders____time_shift_inner]\n ) AS FLOAT) / NULLIF([orders____time_shift_inner], 0) AS [orders___delta]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [orders___ordered_at],\n [orders___cm],\n [orders___delta]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders___amount_sum],\n [orders___cm],\n [orders____time_shift_inner],\n [orders___delta]\n FROM step1\n) AS _outer", + "change_pct/of_local_with_cm_sibling::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS FLOAT64) AS `customers___spend_sum`\n FROM customers AS customers\n), base AS (\n SELECT\n _base.`orders___ordered_at`,\n _cm_orders__customers__spend_sum.`customers___spend_sum` AS `orders___cm`,\n _base.`orders___amount_sum`\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), shifted__time_shift_inner AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), sjoin__time_shift_inner AS (\n SELECT\n base.`orders___ordered_at`,\n base.`orders___amount_sum`,\n base.`orders___cm`,\n shifted__time_shift_inner.`orders___amount_sum` AS `orders____time_shift_inner`\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON CAST(DATETIME_ADD(CAST(CAST(base.`orders___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___cm`,\n `orders____time_shift_inner`,\n (\n `orders___amount_sum` - `orders____time_shift_inner`\n ) / NULLIF(NULLIF(`orders____time_shift_inner`, 0), 0) AS `orders___delta`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___cm`,\n `orders___delta`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___cm`,\n `orders____time_shift_inner`,\n `orders___delta`\n FROM step1\n) AS _outer", + "change_pct/of_local_with_cm_sibling::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS DOUBLE) AS \"customers.spend_sum\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.cm\",\n _base.\"orders.amount_sum\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), shifted__time_shift_inner AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.cm\",\n shifted__time_shift_inner.\"orders.amount_sum\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders._time_shift_inner\",\n (\n \"orders.amount_sum\" - \"orders._time_shift_inner\"\n ) / NULLIF(NULLIF(\"orders._time_shift_inner\", 0), 0) AS \"orders.delta\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.cm\",\n \"orders.delta\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders._time_shift_inner\",\n \"orders.delta\"\n FROM step1\n) AS _outer", + "change_pct/of_local_with_cm_sibling::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS DOUBLE PRECISION) AS \"customers.spend_sum\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.cm\",\n _base.\"orders.amount_sum\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), shifted__time_shift_inner AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.cm\",\n shifted__time_shift_inner.\"orders.amount_sum\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders._time_shift_inner\",\n CAST((\n \"orders.amount_sum\" - \"orders._time_shift_inner\"\n ) AS DOUBLE PRECISION) / NULLIF(NULLIF(\"orders._time_shift_inner\", 0), 0) AS \"orders.delta\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.cm\",\n \"orders.delta\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders._time_shift_inner\",\n \"orders.delta\"\n FROM step1\n) AS _outer", + "change_pct/of_local_with_cm_sibling::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS REAL) AS \"customers.spend_sum\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.cm\",\n _base.\"orders.amount_sum\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), shifted__time_shift_inner AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.cm\",\n shifted__time_shift_inner.\"orders.amount_sum\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders._time_shift_inner\",\n CAST((\n \"orders.amount_sum\" - \"orders._time_shift_inner\"\n ) AS REAL) / NULLIF(NULLIF(\"orders._time_shift_inner\", 0), 0) AS \"orders.delta\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.cm\",\n \"orders.delta\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders._time_shift_inner\",\n \"orders.delta\"\n FROM step1\n) AS _outer", + "change_pct/of_local_with_cm_sibling::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS FLOAT) AS [customers___spend_sum]\n FROM customers AS customers\n), base AS (\n SELECT\n _base.[orders___ordered_at] AS [orders___ordered_at],\n _cm_orders__customers__spend_sum.[customers___spend_sum] AS [orders___cm],\n _base.[orders___amount_sum] AS [orders___amount_sum]\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), shifted__time_shift_inner AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___amount_sum]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[orders___amount_sum] AS [orders___amount_sum],\n base.[orders___cm] AS [orders___cm],\n shifted__time_shift_inner.[orders___amount_sum] AS [orders____time_shift_inner]\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\n )\n), step1 AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders___cm] AS [orders___cm],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n CAST((\n [orders___amount_sum] - [orders____time_shift_inner]\n ) AS FLOAT) / NULLIF(NULLIF([orders____time_shift_inner], 0), 0) AS [orders___delta]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [orders___ordered_at],\n [orders___cm],\n [orders___delta]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders___amount_sum],\n [orders___cm],\n [orders____time_shift_inner],\n [orders___delta]\n FROM step1\n) AS _outer", "composite/lifted::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS FLOAT64) AS `customers___spend_sum`\n FROM customers AS customers\n), base AS (\n SELECT\n _base.`orders___ordered_at`,\n _cm_orders__customers__spend_sum.`customers___spend_sum` AS `orders___cm`,\n _base.`orders___amount_sum`\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), shifted_prev AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n SUM(orders.amount) + SUM(orders.amount) AS `orders___shifted`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), sjoin_prev AS (\n SELECT\n base.`orders___ordered_at`,\n base.`orders___amount_sum`,\n base.`orders___cm`,\n shifted_prev.`orders___shifted` AS `orders___prev`\n FROM base\n LEFT JOIN shifted_prev\n ON CAST(DATETIME_ADD(CAST(CAST(base.`orders___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_prev.`orders___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `orders___ordered_at`,\n `orders___cm`,\n `orders___prev`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___cm`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", "composite/lifted::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS DOUBLE) AS \"customers.spend_sum\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.cm\",\n _base.\"orders.amount_sum\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), shifted_prev AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) + SUM(orders.amount) AS \"orders.shifted\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.cm\",\n shifted_prev.\"orders.shifted\" AS \"orders.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_prev.\"orders.ordered_at\"\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.cm\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "composite/lifted::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS DOUBLE PRECISION) AS \"customers.spend_sum\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.cm\",\n _base.\"orders.amount_sum\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), shifted_prev AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) + SUM(orders.amount) AS \"orders.shifted\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.cm\",\n shifted_prev.\"orders.shifted\" AS \"orders.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_prev.\"orders.ordered_at\"\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.cm\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", diff --git a/tests/golden/dev1800_sql_baseline.json b/tests/golden/dev1800_sql_baseline.json index 566aea10..6701db70 100644 --- a/tests/golden/dev1800_sql_baseline.json +++ b/tests/golden/dev1800_sql_baseline.json @@ -64,16 +64,16 @@ "named/change_cm::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS DOUBLE PRECISION) AS \"customers.spend_sum\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"customers.spend_sum\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), _base_2 AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.customers.spend_sum\"\n FROM _base_2\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"customers.spend_sum\",\n shifted__time_shift_inner.\"orders.customers.spend_sum\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"customers.spend_sum\" - \"orders._time_shift_inner\" AS \"orders.d\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.d\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.d\"\n FROM step1\n) AS _outer", "named/change_cm::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS REAL) AS \"customers.spend_sum\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"customers.spend_sum\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), _base_2 AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.customers.spend_sum\"\n FROM _base_2\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"customers.spend_sum\",\n shifted__time_shift_inner.\"orders.customers.spend_sum\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"customers.spend_sum\" - \"orders._time_shift_inner\" AS \"orders.d\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.d\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.d\"\n FROM step1\n) AS _outer", "named/change_cm::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS FLOAT) AS [customers___spend_sum]\n FROM customers AS customers\n), base AS (\n SELECT\n _base.[orders___ordered_at] AS [orders___ordered_at],\n _cm_orders__customers__spend_sum.[customers___spend_sum] AS [customers___spend_sum]\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), _base_2 AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.[orders___ordered_at] AS [orders___ordered_at],\n _cm_orders__customers__spend_sum.[customers___spend_sum] AS [orders___customers___spend_sum]\n FROM _base_2\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin__time_shift_inner AS (\n SELECT\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[customers___spend_sum] AS [customers___spend_sum],\n shifted__time_shift_inner.[orders___customers___spend_sum] AS [orders____time_shift_inner]\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\n )\n), step1 AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [customers___spend_sum] AS [customers___spend_sum],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n [customers___spend_sum] - [orders____time_shift_inner] AS [orders___d]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [orders___ordered_at],\n [orders___d]\nFROM (\n SELECT\n [orders___ordered_at],\n [customers___spend_sum],\n [orders____time_shift_inner],\n [orders___d]\n FROM step1\n) AS _outer", - "named/change_pct_cm::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS FLOAT64) AS `customers___spend_sum`\n FROM customers AS customers\n), base AS (\n SELECT\n _base.`orders___ordered_at`,\n _cm_orders__customers__spend_sum.`customers___spend_sum` AS `customers___spend_sum`\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), _base_2 AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.`orders___ordered_at`,\n _cm_orders__customers__spend_sum.`customers___spend_sum` AS `orders___customers___spend_sum`\n FROM _base_2\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin__time_shift_inner AS (\n SELECT\n base.`orders___ordered_at`,\n base.`customers___spend_sum`,\n shifted__time_shift_inner.`orders___customers___spend_sum` AS `orders____time_shift_inner`\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON CAST(DATETIME_ADD(CAST(CAST(base.`orders___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `orders___ordered_at`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n (\n `customers___spend_sum` - `orders____time_shift_inner`\n ) / NULLIF(`orders____time_shift_inner`, 0) AS `orders___d`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___d`\nFROM (\n SELECT\n `orders___ordered_at`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders___d`\n FROM step1\n) AS _outer", - "named/change_pct_cm::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS DOUBLE) AS \"customers.spend_sum\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"customers.spend_sum\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), _base_2 AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.customers.spend_sum\"\n FROM _base_2\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"customers.spend_sum\",\n shifted__time_shift_inner.\"orders.customers.spend_sum\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n (\n \"customers.spend_sum\" - \"orders._time_shift_inner\"\n ) / NULLIF(\"orders._time_shift_inner\", 0) AS \"orders.d\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.d\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.d\"\n FROM step1\n) AS _outer", - "named/change_pct_cm::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS DOUBLE PRECISION) AS \"customers.spend_sum\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"customers.spend_sum\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), _base_2 AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.customers.spend_sum\"\n FROM _base_2\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"customers.spend_sum\",\n shifted__time_shift_inner.\"orders.customers.spend_sum\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n CAST((\n \"customers.spend_sum\" - \"orders._time_shift_inner\"\n ) AS DOUBLE PRECISION) / NULLIF(\"orders._time_shift_inner\", 0) AS \"orders.d\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.d\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.d\"\n FROM step1\n) AS _outer", - "named/change_pct_cm::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS REAL) AS \"customers.spend_sum\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"customers.spend_sum\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), _base_2 AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.customers.spend_sum\"\n FROM _base_2\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"customers.spend_sum\",\n shifted__time_shift_inner.\"orders.customers.spend_sum\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n CAST((\n \"customers.spend_sum\" - \"orders._time_shift_inner\"\n ) AS REAL) / NULLIF(\"orders._time_shift_inner\", 0) AS \"orders.d\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.d\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.d\"\n FROM step1\n) AS _outer", - "named/change_pct_cm::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS FLOAT) AS [customers___spend_sum]\n FROM customers AS customers\n), base AS (\n SELECT\n _base.[orders___ordered_at] AS [orders___ordered_at],\n _cm_orders__customers__spend_sum.[customers___spend_sum] AS [customers___spend_sum]\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), _base_2 AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.[orders___ordered_at] AS [orders___ordered_at],\n _cm_orders__customers__spend_sum.[customers___spend_sum] AS [orders___customers___spend_sum]\n FROM _base_2\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin__time_shift_inner AS (\n SELECT\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[customers___spend_sum] AS [customers___spend_sum],\n shifted__time_shift_inner.[orders___customers___spend_sum] AS [orders____time_shift_inner]\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\n )\n), step1 AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [customers___spend_sum] AS [customers___spend_sum],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n CAST((\n [customers___spend_sum] - [orders____time_shift_inner]\n ) AS FLOAT) / NULLIF([orders____time_shift_inner], 0) AS [orders___d]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [orders___ordered_at],\n [orders___d]\nFROM (\n SELECT\n [orders___ordered_at],\n [customers___spend_sum],\n [orders____time_shift_inner],\n [orders___d]\n FROM step1\n) AS _outer", - "named/change_pct_wscaled::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_wscaled_sum_w_customers_regions_weight AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount * customers__regions.weight) AS FLOAT64) AS `orders___amount_wscaled_sum_w_customers_regions_weight`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`orders___ordered_at`,\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___amount_wscaled_sum_w_customers_regions_weight` AS `orders___amount_wscaled_sum_w_customers_regions_weight`\n FROM _base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___ordered_at`\n), sjoin__time_shift_inner AS (\n SELECT\n base.`orders___ordered_at`,\n base.`orders___amount_wscaled_sum_w_customers_regions_weight`,\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___amount_wscaled_sum_w_customers_regions_weight` AS `orders____time_shift_inner`\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON CAST(DATETIME_ADD(CAST(CAST(base.`orders___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(_cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_wscaled_sum_w_customers_regions_weight`,\n `orders____time_shift_inner`,\n (\n `orders___amount_wscaled_sum_w_customers_regions_weight` - `orders____time_shift_inner`\n ) / NULLIF(`orders____time_shift_inner`, 0) AS `orders___d`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___d`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_wscaled_sum_w_customers_regions_weight`,\n `orders____time_shift_inner`,\n `orders___d`\n FROM step1\n) AS _outer", - "named/change_pct_wscaled::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_wscaled_sum_w_customers_regions_weight AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount * customers__regions.weight) AS DOUBLE) AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM _base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_wscaled_sum_w_customers_regions_weight\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n (\n \"orders.amount_wscaled_sum_w_customers_regions_weight\" - \"orders._time_shift_inner\"\n ) / NULLIF(\"orders._time_shift_inner\", 0) AS \"orders.d\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.d\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.d\"\n FROM step1\n) AS _outer", - "named/change_pct_wscaled::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_wscaled_sum_w_customers_regions_weight AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount * customers__regions.weight) AS DOUBLE PRECISION) AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM _base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_wscaled_sum_w_customers_regions_weight\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n CAST((\n \"orders.amount_wscaled_sum_w_customers_regions_weight\" - \"orders._time_shift_inner\"\n ) AS DOUBLE PRECISION) / NULLIF(\"orders._time_shift_inner\", 0) AS \"orders.d\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.d\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.d\"\n FROM step1\n) AS _outer", - "named/change_pct_wscaled::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__amount_wscaled_sum_w_customers_regions_weight AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount * customers__regions.weight) AS REAL) AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM _base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON _base.\"orders.ordered_at\" IS _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_wscaled_sum_w_customers_regions_weight\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n CAST((\n \"orders.amount_wscaled_sum_w_customers_regions_weight\" - \"orders._time_shift_inner\"\n ) AS REAL) / NULLIF(\"orders._time_shift_inner\", 0) AS \"orders.d\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.d\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.d\"\n FROM step1\n) AS _outer", - "named/change_pct_wscaled::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), _cm_orders__amount_wscaled_sum_w_customers_regions_weight AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n CAST(SUM(orders.amount * customers__regions.weight) AS FLOAT) AS [orders___amount_wscaled_sum_w_customers_regions_weight]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), base AS (\n SELECT\n _base.[orders___ordered_at] AS [orders___ordered_at],\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___amount_wscaled_sum_w_customers_regions_weight] AS [orders___amount_wscaled_sum_w_customers_regions_weight]\n FROM _base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON (\n _base.[orders___ordered_at] = _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at]\n OR (\n _base.[orders___ordered_at] IS NULL\n AND _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at] IS NULL\n )\n )\n), sjoin__time_shift_inner AS (\n SELECT\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[orders___amount_wscaled_sum_w_customers_regions_weight] AS [orders___amount_wscaled_sum_w_customers_regions_weight],\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___amount_wscaled_sum_w_customers_regions_weight] AS [orders____time_shift_inner]\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at] IS NULL\n )\n )\n), step1 AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___amount_wscaled_sum_w_customers_regions_weight] AS [orders___amount_wscaled_sum_w_customers_regions_weight],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n CAST((\n [orders___amount_wscaled_sum_w_customers_regions_weight] - [orders____time_shift_inner]\n ) AS FLOAT) / NULLIF([orders____time_shift_inner], 0) AS [orders___d]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [orders___ordered_at],\n [orders___d]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders___amount_wscaled_sum_w_customers_regions_weight],\n [orders____time_shift_inner],\n [orders___d]\n FROM step1\n) AS _outer", + "named/change_pct_cm::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS FLOAT64) AS `customers___spend_sum`\n FROM customers AS customers\n), base AS (\n SELECT\n _base.`orders___ordered_at`,\n _cm_orders__customers__spend_sum.`customers___spend_sum` AS `customers___spend_sum`\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), _base_2 AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.`orders___ordered_at`,\n _cm_orders__customers__spend_sum.`customers___spend_sum` AS `orders___customers___spend_sum`\n FROM _base_2\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin__time_shift_inner AS (\n SELECT\n base.`orders___ordered_at`,\n base.`customers___spend_sum`,\n shifted__time_shift_inner.`orders___customers___spend_sum` AS `orders____time_shift_inner`\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON CAST(DATETIME_ADD(CAST(CAST(base.`orders___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `orders___ordered_at`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n (\n `customers___spend_sum` - `orders____time_shift_inner`\n ) / NULLIF(NULLIF(`orders____time_shift_inner`, 0), 0) AS `orders___d`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___d`\nFROM (\n SELECT\n `orders___ordered_at`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders___d`\n FROM step1\n) AS _outer", + "named/change_pct_cm::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS DOUBLE) AS \"customers.spend_sum\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"customers.spend_sum\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), _base_2 AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.customers.spend_sum\"\n FROM _base_2\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"customers.spend_sum\",\n shifted__time_shift_inner.\"orders.customers.spend_sum\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n (\n \"customers.spend_sum\" - \"orders._time_shift_inner\"\n ) / NULLIF(NULLIF(\"orders._time_shift_inner\", 0), 0) AS \"orders.d\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.d\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.d\"\n FROM step1\n) AS _outer", + "named/change_pct_cm::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS DOUBLE PRECISION) AS \"customers.spend_sum\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"customers.spend_sum\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), _base_2 AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.customers.spend_sum\"\n FROM _base_2\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"customers.spend_sum\",\n shifted__time_shift_inner.\"orders.customers.spend_sum\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n CAST((\n \"customers.spend_sum\" - \"orders._time_shift_inner\"\n ) AS DOUBLE PRECISION) / NULLIF(NULLIF(\"orders._time_shift_inner\", 0), 0) AS \"orders.d\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.d\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.d\"\n FROM step1\n) AS _outer", + "named/change_pct_cm::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS REAL) AS \"customers.spend_sum\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"customers.spend_sum\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), _base_2 AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.ordered_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.customers.spend_sum\"\n FROM _base_2\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"customers.spend_sum\",\n shifted__time_shift_inner.\"orders.customers.spend_sum\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n CAST((\n \"customers.spend_sum\" - \"orders._time_shift_inner\"\n ) AS REAL) / NULLIF(NULLIF(\"orders._time_shift_inner\", 0), 0) AS \"orders.d\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.d\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.d\"\n FROM step1\n) AS _outer", + "named/change_pct_cm::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), _cm_orders__customers__spend_sum AS (\n SELECT\n CAST(SUM(customers.spend) AS FLOAT) AS [customers___spend_sum]\n FROM customers AS customers\n), base AS (\n SELECT\n _base.[orders___ordered_at] AS [orders___ordered_at],\n _cm_orders__customers__spend_sum.[customers___spend_sum] AS [customers___spend_sum]\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), _base_2 AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.[orders___ordered_at] AS [orders___ordered_at],\n _cm_orders__customers__spend_sum.[customers___spend_sum] AS [orders___customers___spend_sum]\n FROM _base_2\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin__time_shift_inner AS (\n SELECT\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[customers___spend_sum] AS [customers___spend_sum],\n shifted__time_shift_inner.[orders___customers___spend_sum] AS [orders____time_shift_inner]\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\n )\n), step1 AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [customers___spend_sum] AS [customers___spend_sum],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n CAST((\n [customers___spend_sum] - [orders____time_shift_inner]\n ) AS FLOAT) / NULLIF(NULLIF([orders____time_shift_inner], 0), 0) AS [orders___d]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [orders___ordered_at],\n [orders___d]\nFROM (\n SELECT\n [orders___ordered_at],\n [customers___spend_sum],\n [orders____time_shift_inner],\n [orders___d]\n FROM step1\n) AS _outer", + "named/change_pct_wscaled::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_wscaled_sum_w_customers_regions_weight AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount * customers__regions.weight) AS FLOAT64) AS `orders___amount_wscaled_sum_w_customers_regions_weight`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`orders___ordered_at`,\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___amount_wscaled_sum_w_customers_regions_weight` AS `orders___amount_wscaled_sum_w_customers_regions_weight`\n FROM _base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___ordered_at`\n), sjoin__time_shift_inner AS (\n SELECT\n base.`orders___ordered_at`,\n base.`orders___amount_wscaled_sum_w_customers_regions_weight`,\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___amount_wscaled_sum_w_customers_regions_weight` AS `orders____time_shift_inner`\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON CAST(DATETIME_ADD(CAST(CAST(base.`orders___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(_cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_wscaled_sum_w_customers_regions_weight`,\n `orders____time_shift_inner`,\n (\n `orders___amount_wscaled_sum_w_customers_regions_weight` - `orders____time_shift_inner`\n ) / NULLIF(NULLIF(`orders____time_shift_inner`, 0), 0) AS `orders___d`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___d`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_wscaled_sum_w_customers_regions_weight`,\n `orders____time_shift_inner`,\n `orders___d`\n FROM step1\n) AS _outer", + "named/change_pct_wscaled::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_wscaled_sum_w_customers_regions_weight AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount * customers__regions.weight) AS DOUBLE) AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM _base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_wscaled_sum_w_customers_regions_weight\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n (\n \"orders.amount_wscaled_sum_w_customers_regions_weight\" - \"orders._time_shift_inner\"\n ) / NULLIF(NULLIF(\"orders._time_shift_inner\", 0), 0) AS \"orders.d\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.d\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.d\"\n FROM step1\n) AS _outer", + "named/change_pct_wscaled::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_wscaled_sum_w_customers_regions_weight AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount * customers__regions.weight) AS DOUBLE PRECISION) AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM _base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_wscaled_sum_w_customers_regions_weight\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n CAST((\n \"orders.amount_wscaled_sum_w_customers_regions_weight\" - \"orders._time_shift_inner\"\n ) AS DOUBLE PRECISION) / NULLIF(NULLIF(\"orders._time_shift_inner\", 0), 0) AS \"orders.d\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.d\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.d\"\n FROM step1\n) AS _outer", + "named/change_pct_wscaled::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__amount_wscaled_sum_w_customers_regions_weight AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount * customers__regions.weight) AS REAL) AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM _base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON _base.\"orders.ordered_at\" IS _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_wscaled_sum_w_customers_regions_weight\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n CAST((\n \"orders.amount_wscaled_sum_w_customers_regions_weight\" - \"orders._time_shift_inner\"\n ) AS REAL) / NULLIF(NULLIF(\"orders._time_shift_inner\", 0), 0) AS \"orders.d\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.d\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.d\"\n FROM step1\n) AS _outer", + "named/change_pct_wscaled::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), _cm_orders__amount_wscaled_sum_w_customers_regions_weight AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n CAST(SUM(orders.amount * customers__regions.weight) AS FLOAT) AS [orders___amount_wscaled_sum_w_customers_regions_weight]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), base AS (\n SELECT\n _base.[orders___ordered_at] AS [orders___ordered_at],\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___amount_wscaled_sum_w_customers_regions_weight] AS [orders___amount_wscaled_sum_w_customers_regions_weight]\n FROM _base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON (\n _base.[orders___ordered_at] = _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at]\n OR (\n _base.[orders___ordered_at] IS NULL\n AND _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at] IS NULL\n )\n )\n), sjoin__time_shift_inner AS (\n SELECT\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[orders___amount_wscaled_sum_w_customers_regions_weight] AS [orders___amount_wscaled_sum_w_customers_regions_weight],\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___amount_wscaled_sum_w_customers_regions_weight] AS [orders____time_shift_inner]\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at] IS NULL\n )\n )\n), step1 AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___amount_wscaled_sum_w_customers_regions_weight] AS [orders___amount_wscaled_sum_w_customers_regions_weight],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n CAST((\n [orders___amount_wscaled_sum_w_customers_regions_weight] - [orders____time_shift_inner]\n ) AS FLOAT) / NULLIF(NULLIF([orders____time_shift_inner], 0), 0) AS [orders___d]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [orders___ordered_at],\n [orders___d]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders___amount_wscaled_sum_w_customers_regions_weight],\n [orders____time_shift_inner],\n [orders___d]\n FROM step1\n) AS _outer", "named/change_wscaled::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_wscaled_sum_w_customers_regions_weight AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount * customers__regions.weight) AS FLOAT64) AS `orders___amount_wscaled_sum_w_customers_regions_weight`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`orders___ordered_at`,\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___amount_wscaled_sum_w_customers_regions_weight` AS `orders___amount_wscaled_sum_w_customers_regions_weight`\n FROM _base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___ordered_at`\n), sjoin__time_shift_inner AS (\n SELECT\n base.`orders___ordered_at`,\n base.`orders___amount_wscaled_sum_w_customers_regions_weight`,\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___amount_wscaled_sum_w_customers_regions_weight` AS `orders____time_shift_inner`\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON CAST(DATETIME_ADD(CAST(CAST(base.`orders___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(_cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_wscaled_sum_w_customers_regions_weight`,\n `orders____time_shift_inner`,\n `orders___amount_wscaled_sum_w_customers_regions_weight` - `orders____time_shift_inner` AS `orders___d`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___d`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_wscaled_sum_w_customers_regions_weight`,\n `orders____time_shift_inner`,\n `orders___d`\n FROM step1\n) AS _outer", "named/change_wscaled::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_wscaled_sum_w_customers_regions_weight AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount * customers__regions.weight) AS DOUBLE) AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM _base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_wscaled_sum_w_customers_regions_weight\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\" - \"orders._time_shift_inner\" AS \"orders.d\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.d\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.d\"\n FROM step1\n) AS _outer", "named/change_wscaled::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_wscaled_sum_w_customers_regions_weight AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount * customers__regions.weight) AS DOUBLE PRECISION) AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), base AS (\n SELECT\n _base.\"orders.ordered_at\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders.amount_wscaled_sum_w_customers_regions_weight\"\n FROM _base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_wscaled_sum_w_customers_regions_weight\",\n _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.amount_wscaled_sum_w_customers_regions_weight\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM _cm_orders__amount_wscaled_sum_w_customers_regions_weight.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\" - \"orders._time_shift_inner\" AS \"orders.d\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.d\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.d\"\n FROM step1\n) AS _outer", diff --git a/tests/golden/dev1839_sql_baseline.json b/tests/golden/dev1839_sql_baseline.json index cc394819..09ba1105 100644 --- a/tests/golden/dev1839_sql_baseline.json +++ b/tests/golden/dev1839_sql_baseline.json @@ -44,11 +44,11 @@ "lift/dim_explicit_partition::postgres": "WITH _base_2 AS (\n SELECT\n orders.city AS \"orders.city\",\n orders.region AS \"orders.region\"\n FROM orders AS orders\n GROUP BY\n orders.city,\n orders.region\n), _cm_orders__amount_sum_partition_by_region AS (\n SELECT\n orders.region AS \"orders.region\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum_partition_by_region\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_partition_by_city AS (\n SELECT\n orders.city AS \"orders.city\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum_partition_by_city\"\n FROM orders AS orders\n GROUP BY\n orders.city\n), base_2 AS (\n SELECT\n _base_2.\"orders.city\",\n _base_2.\"orders.region\",\n _cm_orders__amount_sum_partition_by_region.\"orders.amount_sum_partition_by_region\" AS \"orders.amount_sum_partition_by_region\",\n _cm_orders__amount_sum_partition_by_city.\"orders.amount_sum_partition_by_city\" AS \"orders.amount_sum_partition_by_city\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON _base_2.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_region.\"orders.region\"\n LEFT JOIN _cm_orders__amount_sum_partition_by_city\n ON _base_2.\"orders.city\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_city.\"orders.city\"\n), step1 AS (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.amount_sum_partition_by_region\",\n \"orders.amount_sum_partition_by_city\",\n CASE\n WHEN \"orders.amount_sum_partition_by_region\" - \"orders.amount_sum_partition_by_city\" IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY \"orders.region\", CASE\n WHEN \"orders.amount_sum_partition_by_region\" - \"orders.amount_sum_partition_by_city\" IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY \"orders.amount_sum_partition_by_region\" - \"orders.amount_sum_partition_by_city\" DESC\n )\n END AS \"orders.rank\"\n FROM base_2\n), _cm_rank AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.rank\" AS \"rank\"\n FROM (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.rank\"\n FROM (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.amount_sum_partition_by_region\",\n \"orders.amount_sum_partition_by_city\",\n \"orders.rank\"\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n)\nSELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n _cm_rank.\"rank\" AS \"orders.er\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.s\"\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON orders.city IS NOT DISTINCT FROM _cm_rank.\"city\"\n AND orders.region IS NOT DISTINCT FROM _cm_rank.\"region\"\nGROUP BY\n orders.region,\n orders.city,\n _cm_rank.\"rank\"", "lift/dim_explicit_partition::sqlite": "WITH _base_2 AS (\n SELECT\n orders.city AS \"orders.city\",\n orders.region AS \"orders.region\"\n FROM orders AS orders\n GROUP BY\n orders.city,\n orders.region\n), _cm_orders__amount_sum_partition_by_region AS (\n SELECT\n orders.region AS \"orders.region\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum_partition_by_region\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_partition_by_city AS (\n SELECT\n orders.city AS \"orders.city\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum_partition_by_city\"\n FROM orders AS orders\n GROUP BY\n orders.city\n), base_2 AS (\n SELECT\n _base_2.\"orders.city\",\n _base_2.\"orders.region\",\n _cm_orders__amount_sum_partition_by_region.\"orders.amount_sum_partition_by_region\" AS \"orders.amount_sum_partition_by_region\",\n _cm_orders__amount_sum_partition_by_city.\"orders.amount_sum_partition_by_city\" AS \"orders.amount_sum_partition_by_city\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON _base_2.\"orders.region\" IS _cm_orders__amount_sum_partition_by_region.\"orders.region\"\n LEFT JOIN _cm_orders__amount_sum_partition_by_city\n ON _base_2.\"orders.city\" IS _cm_orders__amount_sum_partition_by_city.\"orders.city\"\n), step1 AS (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.amount_sum_partition_by_region\",\n \"orders.amount_sum_partition_by_city\",\n CASE\n WHEN \"orders.amount_sum_partition_by_region\" - \"orders.amount_sum_partition_by_city\" IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY \"orders.region\", CASE\n WHEN \"orders.amount_sum_partition_by_region\" - \"orders.amount_sum_partition_by_city\" IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY \"orders.amount_sum_partition_by_region\" - \"orders.amount_sum_partition_by_city\" DESC\n )\n END AS \"orders.rank\"\n FROM base_2\n), _cm_rank AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.rank\" AS \"rank\"\n FROM (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.rank\"\n FROM (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.amount_sum_partition_by_region\",\n \"orders.amount_sum_partition_by_city\",\n \"orders.rank\"\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n)\nSELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n _cm_rank.\"rank\" AS \"orders.er\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.s\"\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON orders.city IS _cm_rank.\"city\" AND orders.region IS _cm_rank.\"region\"\nGROUP BY\n orders.region,\n orders.city,\n _cm_rank.\"rank\"", "lift/dim_explicit_partition::tsql": "WITH _base_2 AS (\n SELECT\n orders.city AS [orders___city],\n orders.region AS [orders___region]\n FROM orders AS orders\n GROUP BY\n orders.city,\n orders.region\n), _cm_orders__amount_sum_partition_by_region AS (\n SELECT\n orders.region AS [orders___region],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___amount_sum_partition_by_region]\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_partition_by_city AS (\n SELECT\n orders.city AS [orders___city],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___amount_sum_partition_by_city]\n FROM orders AS orders\n GROUP BY\n orders.city\n), base_2 AS (\n SELECT\n _base_2.[orders___city] AS [orders___city],\n _base_2.[orders___region] AS [orders___region],\n _cm_orders__amount_sum_partition_by_region.[orders___amount_sum_partition_by_region] AS [orders___amount_sum_partition_by_region],\n _cm_orders__amount_sum_partition_by_city.[orders___amount_sum_partition_by_city] AS [orders___amount_sum_partition_by_city]\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON (\n _base_2.[orders___region] = _cm_orders__amount_sum_partition_by_region.[orders___region]\n OR (\n _base_2.[orders___region] IS NULL\n AND _cm_orders__amount_sum_partition_by_region.[orders___region] IS NULL\n )\n )\n LEFT JOIN _cm_orders__amount_sum_partition_by_city\n ON (\n _base_2.[orders___city] = _cm_orders__amount_sum_partition_by_city.[orders___city]\n OR (\n _base_2.[orders___city] IS NULL\n AND _cm_orders__amount_sum_partition_by_city.[orders___city] IS NULL\n )\n )\n), step1 AS (\n SELECT\n [orders___city] AS [orders___city],\n [orders___region] AS [orders___region],\n [orders___amount_sum_partition_by_region] AS [orders___amount_sum_partition_by_region],\n [orders___amount_sum_partition_by_city] AS [orders___amount_sum_partition_by_city],\n CASE\n WHEN [orders___amount_sum_partition_by_region] - [orders___amount_sum_partition_by_city] IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY [orders___region], CASE\n WHEN [orders___amount_sum_partition_by_region] - [orders___amount_sum_partition_by_city] IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY [orders___amount_sum_partition_by_region] - [orders___amount_sum_partition_by_city] DESC\n )\n END AS [orders___rank]\n FROM base_2\n), _cm_rank AS (\n SELECT\n _stage_inner.[orders___city] AS [city],\n _stage_inner.[orders___region] AS [region],\n _stage_inner.[orders___rank] AS [rank]\n FROM (\n SELECT\n [orders___city] AS [orders___city],\n [orders___region] AS [orders___region],\n [orders___rank] AS [orders___rank]\n FROM (\n SELECT\n [orders___city],\n [orders___region],\n [orders___amount_sum_partition_by_region],\n [orders___amount_sum_partition_by_city],\n [orders___rank]\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n)\nSELECT\n orders.region AS [orders___region],\n orders.city AS [orders___city],\n _cm_rank.[rank] AS [orders___er],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___s]\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON (\n orders.city = _cm_rank.[city]\n OR (\n orders.city IS NULL AND _cm_rank.[city] IS NULL\n )\n )\n AND (\n orders.region = _cm_rank.[region]\n OR (\n orders.region IS NULL AND _cm_rank.[region] IS NULL\n )\n )\nGROUP BY\n orders.region,\n orders.city,\n _cm_rank.[rank]", - "lift/dim_keyless_share::bigquery": "WITH _base_2 AS (\n SELECT\n orders.region AS `orders___region`,\n SUM(orders.amount) AS `orders___amount_sum_partition_by_region`\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_partition_by AS (\n SELECT\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum_partition_by`\n FROM orders AS orders\n), base_2 AS (\n SELECT\n _base_2.`orders___region`,\n _base_2.`orders___amount_sum_partition_by_region`,\n _cm_orders__amount_sum_partition_by.`orders___amount_sum_partition_by` AS `orders___amount_sum_partition_by`\n FROM _base_2\n CROSS JOIN _cm_orders__amount_sum_partition_by\n), step1 AS (\n SELECT\n `orders___region`,\n `orders___amount_sum_partition_by_region`,\n `orders___amount_sum_partition_by`,\n CASE\n WHEN `orders___amount_sum_partition_by_region` / `orders___amount_sum_partition_by` IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN `orders___amount_sum_partition_by_region` / `orders___amount_sum_partition_by` IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY `orders___amount_sum_partition_by_region` / `orders___amount_sum_partition_by` DESC\n )\n END AS `orders___rank`\n FROM base_2\n), _cm_rank AS (\n SELECT\n _stage_inner.`orders___region` AS `region`,\n _stage_inner.`orders___rank` AS `rank`\n FROM (\n SELECT\n `orders___region`,\n `orders___rank`\n FROM (\n SELECT\n `orders___region`,\n `orders___amount_sum_partition_by_region`,\n `orders___amount_sum_partition_by`,\n `orders___rank`\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n)\nSELECT\n orders.region AS `orders___region`,\n _cm_rank.`rank` AS `orders___kr`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___s`\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON orders.region IS NOT DISTINCT FROM _cm_rank.`region`\nGROUP BY\n orders.region,\n _cm_rank.`rank`", - "lift/dim_keyless_share::duckdb": "WITH _base_2 AS (\n SELECT\n orders.region AS \"orders.region\",\n SUM(orders.amount) AS \"orders.amount_sum_partition_by_region\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_partition_by AS (\n SELECT\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum_partition_by\"\n FROM orders AS orders\n), base_2 AS (\n SELECT\n _base_2.\"orders.region\",\n _base_2.\"orders.amount_sum_partition_by_region\",\n _cm_orders__amount_sum_partition_by.\"orders.amount_sum_partition_by\" AS \"orders.amount_sum_partition_by\"\n FROM _base_2\n CROSS JOIN _cm_orders__amount_sum_partition_by\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.amount_sum_partition_by_region\",\n \"orders.amount_sum_partition_by\",\n CASE\n WHEN \"orders.amount_sum_partition_by_region\" / \"orders.amount_sum_partition_by\" IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN \"orders.amount_sum_partition_by_region\" / \"orders.amount_sum_partition_by\" IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY \"orders.amount_sum_partition_by_region\" / \"orders.amount_sum_partition_by\" DESC\n )\n END AS \"orders.rank\"\n FROM base_2\n), _cm_rank AS (\n SELECT\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.rank\" AS \"rank\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.rank\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.amount_sum_partition_by_region\",\n \"orders.amount_sum_partition_by\",\n \"orders.rank\"\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n)\nSELECT\n orders.region AS \"orders.region\",\n _cm_rank.\"rank\" AS \"orders.kr\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.s\"\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON orders.region IS NOT DISTINCT FROM _cm_rank.\"region\"\nGROUP BY\n orders.region,\n _cm_rank.\"rank\"", - "lift/dim_keyless_share::postgres": "WITH _base_2 AS (\n SELECT\n orders.region AS \"orders.region\",\n SUM(orders.amount) AS \"orders.amount_sum_partition_by_region\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_partition_by AS (\n SELECT\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum_partition_by\"\n FROM orders AS orders\n), base_2 AS (\n SELECT\n _base_2.\"orders.region\",\n _base_2.\"orders.amount_sum_partition_by_region\",\n _cm_orders__amount_sum_partition_by.\"orders.amount_sum_partition_by\" AS \"orders.amount_sum_partition_by\"\n FROM _base_2\n CROSS JOIN _cm_orders__amount_sum_partition_by\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.amount_sum_partition_by_region\",\n \"orders.amount_sum_partition_by\",\n CASE\n WHEN CAST(\"orders.amount_sum_partition_by_region\" AS DOUBLE PRECISION) / \"orders.amount_sum_partition_by\" IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN CAST(\"orders.amount_sum_partition_by_region\" AS DOUBLE PRECISION) / \"orders.amount_sum_partition_by\" IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY CAST(\"orders.amount_sum_partition_by_region\" AS DOUBLE PRECISION) / \"orders.amount_sum_partition_by\" DESC\n )\n END AS \"orders.rank\"\n FROM base_2\n), _cm_rank AS (\n SELECT\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.rank\" AS \"rank\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.rank\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.amount_sum_partition_by_region\",\n \"orders.amount_sum_partition_by\",\n \"orders.rank\"\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n)\nSELECT\n orders.region AS \"orders.region\",\n _cm_rank.\"rank\" AS \"orders.kr\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.s\"\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON orders.region IS NOT DISTINCT FROM _cm_rank.\"region\"\nGROUP BY\n orders.region,\n _cm_rank.\"rank\"", - "lift/dim_keyless_share::sqlite": "WITH _base_2 AS (\n SELECT\n orders.region AS \"orders.region\",\n SUM(orders.amount) AS \"orders.amount_sum_partition_by_region\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_partition_by AS (\n SELECT\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum_partition_by\"\n FROM orders AS orders\n), base_2 AS (\n SELECT\n _base_2.\"orders.region\",\n _base_2.\"orders.amount_sum_partition_by_region\",\n _cm_orders__amount_sum_partition_by.\"orders.amount_sum_partition_by\" AS \"orders.amount_sum_partition_by\"\n FROM _base_2\n CROSS JOIN _cm_orders__amount_sum_partition_by\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.amount_sum_partition_by_region\",\n \"orders.amount_sum_partition_by\",\n CASE\n WHEN CAST(\"orders.amount_sum_partition_by_region\" AS REAL) / \"orders.amount_sum_partition_by\" IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN CAST(\"orders.amount_sum_partition_by_region\" AS REAL) / \"orders.amount_sum_partition_by\" IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY CAST(\"orders.amount_sum_partition_by_region\" AS REAL) / \"orders.amount_sum_partition_by\" DESC\n )\n END AS \"orders.rank\"\n FROM base_2\n), _cm_rank AS (\n SELECT\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.rank\" AS \"rank\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.rank\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.amount_sum_partition_by_region\",\n \"orders.amount_sum_partition_by\",\n \"orders.rank\"\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n)\nSELECT\n orders.region AS \"orders.region\",\n _cm_rank.\"rank\" AS \"orders.kr\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.s\"\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON orders.region IS _cm_rank.\"region\"\nGROUP BY\n orders.region,\n _cm_rank.\"rank\"", - "lift/dim_keyless_share::tsql": "WITH _base_2 AS (\n SELECT\n orders.region AS [orders___region],\n SUM(orders.amount) AS [orders___amount_sum_partition_by_region]\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_partition_by AS (\n SELECT\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___amount_sum_partition_by]\n FROM orders AS orders\n), base_2 AS (\n SELECT\n _base_2.[orders___region] AS [orders___region],\n _base_2.[orders___amount_sum_partition_by_region] AS [orders___amount_sum_partition_by_region],\n _cm_orders__amount_sum_partition_by.[orders___amount_sum_partition_by] AS [orders___amount_sum_partition_by]\n FROM _base_2\n CROSS JOIN _cm_orders__amount_sum_partition_by\n), step1 AS (\n SELECT\n [orders___region] AS [orders___region],\n [orders___amount_sum_partition_by_region] AS [orders___amount_sum_partition_by_region],\n [orders___amount_sum_partition_by] AS [orders___amount_sum_partition_by],\n CASE\n WHEN CAST([orders___amount_sum_partition_by_region] AS FLOAT) / [orders___amount_sum_partition_by] IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN CAST([orders___amount_sum_partition_by_region] AS FLOAT) / [orders___amount_sum_partition_by] IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY CAST([orders___amount_sum_partition_by_region] AS FLOAT) / [orders___amount_sum_partition_by] DESC\n )\n END AS [orders___rank]\n FROM base_2\n), _cm_rank AS (\n SELECT\n _stage_inner.[orders___region] AS [region],\n _stage_inner.[orders___rank] AS [rank]\n FROM (\n SELECT\n [orders___region] AS [orders___region],\n [orders___rank] AS [orders___rank]\n FROM (\n SELECT\n [orders___region],\n [orders___amount_sum_partition_by_region],\n [orders___amount_sum_partition_by],\n [orders___rank]\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n)\nSELECT\n orders.region AS [orders___region],\n _cm_rank.[rank] AS [orders___kr],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___s]\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON (\n orders.region = _cm_rank.[region]\n OR (\n orders.region IS NULL AND _cm_rank.[region] IS NULL\n )\n )\nGROUP BY\n orders.region,\n _cm_rank.[rank]", + "lift/dim_keyless_share::bigquery": "WITH _base_2 AS (\n SELECT\n orders.region AS `orders___region`,\n SUM(orders.amount) AS `orders___amount_sum_partition_by_region`\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_partition_by AS (\n SELECT\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum_partition_by`\n FROM orders AS orders\n), base_2 AS (\n SELECT\n _base_2.`orders___region`,\n _base_2.`orders___amount_sum_partition_by_region`,\n _cm_orders__amount_sum_partition_by.`orders___amount_sum_partition_by` AS `orders___amount_sum_partition_by`\n FROM _base_2\n CROSS JOIN _cm_orders__amount_sum_partition_by\n), step1 AS (\n SELECT\n `orders___region`,\n `orders___amount_sum_partition_by_region`,\n `orders___amount_sum_partition_by`,\n CASE\n WHEN `orders___amount_sum_partition_by_region` / NULLIF(`orders___amount_sum_partition_by`, 0) IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN `orders___amount_sum_partition_by_region` / NULLIF(`orders___amount_sum_partition_by`, 0) IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY `orders___amount_sum_partition_by_region` / NULLIF(`orders___amount_sum_partition_by`, 0) DESC\n )\n END AS `orders___rank`\n FROM base_2\n), _cm_rank AS (\n SELECT\n _stage_inner.`orders___region` AS `region`,\n _stage_inner.`orders___rank` AS `rank`\n FROM (\n SELECT\n `orders___region`,\n `orders___rank`\n FROM (\n SELECT\n `orders___region`,\n `orders___amount_sum_partition_by_region`,\n `orders___amount_sum_partition_by`,\n `orders___rank`\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n)\nSELECT\n orders.region AS `orders___region`,\n _cm_rank.`rank` AS `orders___kr`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___s`\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON orders.region IS NOT DISTINCT FROM _cm_rank.`region`\nGROUP BY\n orders.region,\n _cm_rank.`rank`", + "lift/dim_keyless_share::duckdb": "WITH _base_2 AS (\n SELECT\n orders.region AS \"orders.region\",\n SUM(orders.amount) AS \"orders.amount_sum_partition_by_region\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_partition_by AS (\n SELECT\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum_partition_by\"\n FROM orders AS orders\n), base_2 AS (\n SELECT\n _base_2.\"orders.region\",\n _base_2.\"orders.amount_sum_partition_by_region\",\n _cm_orders__amount_sum_partition_by.\"orders.amount_sum_partition_by\" AS \"orders.amount_sum_partition_by\"\n FROM _base_2\n CROSS JOIN _cm_orders__amount_sum_partition_by\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.amount_sum_partition_by_region\",\n \"orders.amount_sum_partition_by\",\n CASE\n WHEN \"orders.amount_sum_partition_by_region\" / NULLIF(\"orders.amount_sum_partition_by\", 0) IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN \"orders.amount_sum_partition_by_region\" / NULLIF(\"orders.amount_sum_partition_by\", 0) IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY \"orders.amount_sum_partition_by_region\" / NULLIF(\"orders.amount_sum_partition_by\", 0) DESC\n )\n END AS \"orders.rank\"\n FROM base_2\n), _cm_rank AS (\n SELECT\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.rank\" AS \"rank\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.rank\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.amount_sum_partition_by_region\",\n \"orders.amount_sum_partition_by\",\n \"orders.rank\"\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n)\nSELECT\n orders.region AS \"orders.region\",\n _cm_rank.\"rank\" AS \"orders.kr\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.s\"\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON orders.region IS NOT DISTINCT FROM _cm_rank.\"region\"\nGROUP BY\n orders.region,\n _cm_rank.\"rank\"", + "lift/dim_keyless_share::postgres": "WITH _base_2 AS (\n SELECT\n orders.region AS \"orders.region\",\n SUM(orders.amount) AS \"orders.amount_sum_partition_by_region\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_partition_by AS (\n SELECT\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum_partition_by\"\n FROM orders AS orders\n), base_2 AS (\n SELECT\n _base_2.\"orders.region\",\n _base_2.\"orders.amount_sum_partition_by_region\",\n _cm_orders__amount_sum_partition_by.\"orders.amount_sum_partition_by\" AS \"orders.amount_sum_partition_by\"\n FROM _base_2\n CROSS JOIN _cm_orders__amount_sum_partition_by\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.amount_sum_partition_by_region\",\n \"orders.amount_sum_partition_by\",\n CASE\n WHEN CAST(\"orders.amount_sum_partition_by_region\" AS DOUBLE PRECISION) / NULLIF(\"orders.amount_sum_partition_by\", 0) IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN CAST(\"orders.amount_sum_partition_by_region\" AS DOUBLE PRECISION) / NULLIF(\"orders.amount_sum_partition_by\", 0) IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY CAST(\"orders.amount_sum_partition_by_region\" AS DOUBLE PRECISION) / NULLIF(\"orders.amount_sum_partition_by\", 0) DESC\n )\n END AS \"orders.rank\"\n FROM base_2\n), _cm_rank AS (\n SELECT\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.rank\" AS \"rank\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.rank\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.amount_sum_partition_by_region\",\n \"orders.amount_sum_partition_by\",\n \"orders.rank\"\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n)\nSELECT\n orders.region AS \"orders.region\",\n _cm_rank.\"rank\" AS \"orders.kr\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.s\"\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON orders.region IS NOT DISTINCT FROM _cm_rank.\"region\"\nGROUP BY\n orders.region,\n _cm_rank.\"rank\"", + "lift/dim_keyless_share::sqlite": "WITH _base_2 AS (\n SELECT\n orders.region AS \"orders.region\",\n SUM(orders.amount) AS \"orders.amount_sum_partition_by_region\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_partition_by AS (\n SELECT\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum_partition_by\"\n FROM orders AS orders\n), base_2 AS (\n SELECT\n _base_2.\"orders.region\",\n _base_2.\"orders.amount_sum_partition_by_region\",\n _cm_orders__amount_sum_partition_by.\"orders.amount_sum_partition_by\" AS \"orders.amount_sum_partition_by\"\n FROM _base_2\n CROSS JOIN _cm_orders__amount_sum_partition_by\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.amount_sum_partition_by_region\",\n \"orders.amount_sum_partition_by\",\n CASE\n WHEN CAST(\"orders.amount_sum_partition_by_region\" AS REAL) / NULLIF(\"orders.amount_sum_partition_by\", 0) IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN CAST(\"orders.amount_sum_partition_by_region\" AS REAL) / NULLIF(\"orders.amount_sum_partition_by\", 0) IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY CAST(\"orders.amount_sum_partition_by_region\" AS REAL) / NULLIF(\"orders.amount_sum_partition_by\", 0) DESC\n )\n END AS \"orders.rank\"\n FROM base_2\n), _cm_rank AS (\n SELECT\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.rank\" AS \"rank\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.rank\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.amount_sum_partition_by_region\",\n \"orders.amount_sum_partition_by\",\n \"orders.rank\"\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n)\nSELECT\n orders.region AS \"orders.region\",\n _cm_rank.\"rank\" AS \"orders.kr\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.s\"\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON orders.region IS _cm_rank.\"region\"\nGROUP BY\n orders.region,\n _cm_rank.\"rank\"", + "lift/dim_keyless_share::tsql": "WITH _base_2 AS (\n SELECT\n orders.region AS [orders___region],\n SUM(orders.amount) AS [orders___amount_sum_partition_by_region]\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_partition_by AS (\n SELECT\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___amount_sum_partition_by]\n FROM orders AS orders\n), base_2 AS (\n SELECT\n _base_2.[orders___region] AS [orders___region],\n _base_2.[orders___amount_sum_partition_by_region] AS [orders___amount_sum_partition_by_region],\n _cm_orders__amount_sum_partition_by.[orders___amount_sum_partition_by] AS [orders___amount_sum_partition_by]\n FROM _base_2\n CROSS JOIN _cm_orders__amount_sum_partition_by\n), step1 AS (\n SELECT\n [orders___region] AS [orders___region],\n [orders___amount_sum_partition_by_region] AS [orders___amount_sum_partition_by_region],\n [orders___amount_sum_partition_by] AS [orders___amount_sum_partition_by],\n CASE\n WHEN CAST([orders___amount_sum_partition_by_region] AS FLOAT) / NULLIF([orders___amount_sum_partition_by], 0) IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN CAST([orders___amount_sum_partition_by_region] AS FLOAT) / NULLIF([orders___amount_sum_partition_by], 0) IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY CAST([orders___amount_sum_partition_by_region] AS FLOAT) / NULLIF([orders___amount_sum_partition_by], 0) DESC\n )\n END AS [orders___rank]\n FROM base_2\n), _cm_rank AS (\n SELECT\n _stage_inner.[orders___region] AS [region],\n _stage_inner.[orders___rank] AS [rank]\n FROM (\n SELECT\n [orders___region] AS [orders___region],\n [orders___rank] AS [orders___rank]\n FROM (\n SELECT\n [orders___region],\n [orders___amount_sum_partition_by_region],\n [orders___amount_sum_partition_by],\n [orders___rank]\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n)\nSELECT\n orders.region AS [orders___region],\n _cm_rank.[rank] AS [orders___kr],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___s]\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON (\n orders.region = _cm_rank.[region]\n OR (\n orders.region IS NULL AND _cm_rank.[region] IS NULL\n )\n )\nGROUP BY\n orders.region,\n _cm_rank.[rank]", "lift/dim_mixed_first_last::bigquery": "WITH _base_2 AS (\n SELECT\n orders.city AS `orders___city`,\n orders.region AS `orders___region`\n FROM orders AS orders\n GROUP BY\n orders.city,\n orders.region\n), _cm_orders__amount_last_partition_by_region AS (\n SELECT\n _val_0 AS `orders___region`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS FLOAT64) AS `orders___amount_last_partition_by_region`\n FROM (\n SELECT\n orders.region AS _val_0,\n orders.amount AS _val_1,\n ROW_NUMBER() OVER (PARTITION BY orders.region ORDER BY orders.ordered_at DESC) AS _ranked_rn\n FROM orders AS orders\n ) AS _ranked_src\n GROUP BY\n _val_0\n), _cm_orders__amount_sum_partition_by_city AS (\n SELECT\n orders.city AS `orders___city`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum_partition_by_city`\n FROM orders AS orders\n GROUP BY\n orders.city\n), base_2 AS (\n SELECT\n _base_2.`orders___city`,\n _base_2.`orders___region`,\n _cm_orders__amount_last_partition_by_region.`orders___amount_last_partition_by_region` AS `orders___amount_last_partition_by_region`,\n _cm_orders__amount_sum_partition_by_city.`orders___amount_sum_partition_by_city` AS `orders___amount_sum_partition_by_city`\n FROM _base_2\n LEFT JOIN _cm_orders__amount_last_partition_by_region\n ON _base_2.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_last_partition_by_region.`orders___region`\n LEFT JOIN _cm_orders__amount_sum_partition_by_city\n ON _base_2.`orders___city` IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_city.`orders___city`\n), step1 AS (\n SELECT\n `orders___city`,\n `orders___region`,\n `orders___amount_last_partition_by_region`,\n `orders___amount_sum_partition_by_city`,\n CASE\n WHEN `orders___amount_last_partition_by_region` - `orders___amount_sum_partition_by_city` IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN `orders___amount_last_partition_by_region` - `orders___amount_sum_partition_by_city` IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY `orders___amount_last_partition_by_region` - `orders___amount_sum_partition_by_city` DESC\n )\n END AS `orders___rank`\n FROM base_2\n), _cm_rank AS (\n SELECT\n _stage_inner.`orders___city` AS `city`,\n _stage_inner.`orders___region` AS `region`,\n _stage_inner.`orders___rank` AS `rank`\n FROM (\n SELECT\n `orders___city`,\n `orders___region`,\n `orders___rank`\n FROM (\n SELECT\n `orders___city`,\n `orders___region`,\n `orders___amount_last_partition_by_region`,\n `orders___amount_sum_partition_by_city`,\n `orders___rank`\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n)\nSELECT\n orders.region AS `orders___region`,\n orders.city AS `orders___city`,\n _cm_rank.`rank` AS `orders___x`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___s`\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON orders.city IS NOT DISTINCT FROM _cm_rank.`city`\n AND orders.region IS NOT DISTINCT FROM _cm_rank.`region`\nGROUP BY\n orders.region,\n orders.city,\n _cm_rank.`rank`", "lift/dim_mixed_first_last::duckdb": "WITH _base_2 AS (\n SELECT\n orders.city AS \"orders.city\",\n orders.region AS \"orders.region\"\n FROM orders AS orders\n GROUP BY\n orders.city,\n orders.region\n), _cm_orders__amount_last_partition_by_region AS (\n SELECT\n _val_0 AS \"orders.region\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS DOUBLE) AS \"orders.amount_last_partition_by_region\"\n FROM (\n SELECT\n orders.region AS _val_0,\n orders.amount AS _val_1,\n ROW_NUMBER() OVER (PARTITION BY orders.region ORDER BY orders.ordered_at DESC) AS _ranked_rn\n FROM orders AS orders\n ) AS _ranked_src\n GROUP BY\n _val_0\n), _cm_orders__amount_sum_partition_by_city AS (\n SELECT\n orders.city AS \"orders.city\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum_partition_by_city\"\n FROM orders AS orders\n GROUP BY\n orders.city\n), base_2 AS (\n SELECT\n _base_2.\"orders.city\",\n _base_2.\"orders.region\",\n _cm_orders__amount_last_partition_by_region.\"orders.amount_last_partition_by_region\" AS \"orders.amount_last_partition_by_region\",\n _cm_orders__amount_sum_partition_by_city.\"orders.amount_sum_partition_by_city\" AS \"orders.amount_sum_partition_by_city\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_last_partition_by_region\n ON _base_2.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_last_partition_by_region.\"orders.region\"\n LEFT JOIN _cm_orders__amount_sum_partition_by_city\n ON _base_2.\"orders.city\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_city.\"orders.city\"\n), step1 AS (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.amount_last_partition_by_region\",\n \"orders.amount_sum_partition_by_city\",\n CASE\n WHEN \"orders.amount_last_partition_by_region\" - \"orders.amount_sum_partition_by_city\" IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN \"orders.amount_last_partition_by_region\" - \"orders.amount_sum_partition_by_city\" IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY \"orders.amount_last_partition_by_region\" - \"orders.amount_sum_partition_by_city\" DESC\n )\n END AS \"orders.rank\"\n FROM base_2\n), _cm_rank AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.rank\" AS \"rank\"\n FROM (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.rank\"\n FROM (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.amount_last_partition_by_region\",\n \"orders.amount_sum_partition_by_city\",\n \"orders.rank\"\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n)\nSELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n _cm_rank.\"rank\" AS \"orders.x\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.s\"\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON orders.city IS NOT DISTINCT FROM _cm_rank.\"city\"\n AND orders.region IS NOT DISTINCT FROM _cm_rank.\"region\"\nGROUP BY\n orders.region,\n orders.city,\n _cm_rank.\"rank\"", "lift/dim_mixed_first_last::postgres": "WITH _base_2 AS (\n SELECT\n orders.city AS \"orders.city\",\n orders.region AS \"orders.region\"\n FROM orders AS orders\n GROUP BY\n orders.city,\n orders.region\n), _cm_orders__amount_last_partition_by_region AS (\n SELECT\n _val_0 AS \"orders.region\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS DOUBLE PRECISION) AS \"orders.amount_last_partition_by_region\"\n FROM (\n SELECT\n orders.region AS _val_0,\n orders.amount AS _val_1,\n ROW_NUMBER() OVER (PARTITION BY orders.region ORDER BY orders.ordered_at DESC) AS _ranked_rn\n FROM orders AS orders\n ) AS _ranked_src\n GROUP BY\n _val_0\n), _cm_orders__amount_sum_partition_by_city AS (\n SELECT\n orders.city AS \"orders.city\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum_partition_by_city\"\n FROM orders AS orders\n GROUP BY\n orders.city\n), base_2 AS (\n SELECT\n _base_2.\"orders.city\",\n _base_2.\"orders.region\",\n _cm_orders__amount_last_partition_by_region.\"orders.amount_last_partition_by_region\" AS \"orders.amount_last_partition_by_region\",\n _cm_orders__amount_sum_partition_by_city.\"orders.amount_sum_partition_by_city\" AS \"orders.amount_sum_partition_by_city\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_last_partition_by_region\n ON _base_2.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_last_partition_by_region.\"orders.region\"\n LEFT JOIN _cm_orders__amount_sum_partition_by_city\n ON _base_2.\"orders.city\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_city.\"orders.city\"\n), step1 AS (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.amount_last_partition_by_region\",\n \"orders.amount_sum_partition_by_city\",\n CASE\n WHEN \"orders.amount_last_partition_by_region\" - \"orders.amount_sum_partition_by_city\" IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN \"orders.amount_last_partition_by_region\" - \"orders.amount_sum_partition_by_city\" IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY \"orders.amount_last_partition_by_region\" - \"orders.amount_sum_partition_by_city\" DESC\n )\n END AS \"orders.rank\"\n FROM base_2\n), _cm_rank AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.rank\" AS \"rank\"\n FROM (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.rank\"\n FROM (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.amount_last_partition_by_region\",\n \"orders.amount_sum_partition_by_city\",\n \"orders.rank\"\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n)\nSELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n _cm_rank.\"rank\" AS \"orders.x\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.s\"\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON orders.city IS NOT DISTINCT FROM _cm_rank.\"city\"\n AND orders.region IS NOT DISTINCT FROM _cm_rank.\"region\"\nGROUP BY\n orders.region,\n orders.city,\n _cm_rank.\"rank\"", diff --git a/tests/golden/dev1846_sql_baseline.json b/tests/golden/dev1846_sql_baseline.json index 23bdd43a..2b334e8a 100644 --- a/tests/golden/dev1846_sql_baseline.json +++ b/tests/golden/dev1846_sql_baseline.json @@ -84,11 +84,11 @@ "error": "ValueError", "message": "'consecutive_periods' cannot use a string-valued predicate (lower(...)): a string has no truthiness. Compare it explicitly (e.g. `length(...) > 0`) to form a predicate." }, - "ts/change_pct_ratio::bigquery": "WITH base AS (\n SELECT\n sales.store AS `sales___store`,\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`,\n SUM(sales.revenue) AS `sales___revenue_sum`,\n COUNT(*) AS `sales____count`\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC(sales.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n sales.store AS `sales___store`,\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`,\n SUM(sales.revenue) / COUNT(*) AS `sales___shifted`\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC(sales.ordered_at, MONTH)\n), sjoin__time_shift_inner AS (\n SELECT\n base.`sales___store`,\n base.`sales___ordered_at`,\n base.`sales___revenue_sum`,\n base.`sales____count`,\n shifted__time_shift_inner.`sales___shifted` AS `sales____time_shift_inner`\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.`sales___store` IS NOT DISTINCT FROM shifted__time_shift_inner.`sales___store`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`sales___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____count`,\n `sales____time_shift_inner`,\n (\n `sales___revenue_sum` / `sales____count` - `sales____time_shift_inner`\n ) / NULLIF(`sales____time_shift_inner`, 0) AS `sales___pct`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___pct`\nFROM (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____count`,\n `sales____time_shift_inner`,\n `sales___pct`\n FROM step1\n) AS _outer", - "ts/change_pct_ratio::duckdb": "WITH base AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\",\n COUNT(*) AS \"sales._count\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) / COUNT(*) AS \"sales.shifted\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"sales.store\",\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n base.\"sales._count\",\n shifted__time_shift_inner.\"sales.shifted\" AS \"sales._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"sales.store\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"sales.store\"\n AND base.\"sales.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner.\"sales.ordered_at\"\n), step1 AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._count\",\n \"sales._time_shift_inner\",\n (\n \"sales.revenue_sum\" / \"sales._count\" - \"sales._time_shift_inner\"\n ) / NULLIF(\"sales._time_shift_inner\", 0) AS \"sales.pct\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.pct\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._count\",\n \"sales._time_shift_inner\",\n \"sales.pct\"\n FROM step1\n) AS _outer", - "ts/change_pct_ratio::postgres": "WITH base AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\",\n COUNT(*) AS \"sales._count\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n CAST(SUM(sales.revenue) AS DOUBLE PRECISION) / COUNT(*) AS \"sales.shifted\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"sales.store\",\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n base.\"sales._count\",\n shifted__time_shift_inner.\"sales.shifted\" AS \"sales._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"sales.store\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"sales.store\"\n AND base.\"sales.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"sales.ordered_at\"\n), step1 AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._count\",\n \"sales._time_shift_inner\",\n CAST((\n CAST(\"sales.revenue_sum\" AS DOUBLE PRECISION) / \"sales._count\" - \"sales._time_shift_inner\"\n ) AS DOUBLE PRECISION) / NULLIF(\"sales._time_shift_inner\", 0) AS \"sales.pct\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.pct\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._count\",\n \"sales._time_shift_inner\",\n \"sales.pct\"\n FROM step1\n) AS _outer", - "ts/change_pct_ratio::sqlite": "WITH base AS (\n SELECT\n sales.store AS \"sales.store\",\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\",\n COUNT(*) AS \"sales._count\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n sales.store AS \"sales.store\",\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n CAST(SUM(sales.revenue) AS REAL) / COUNT(*) AS \"sales.shifted\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"sales.store\",\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n base.\"sales._count\",\n shifted__time_shift_inner.\"sales.shifted\" AS \"sales._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"sales.store\" IS shifted__time_shift_inner.\"sales.store\"\n AND SLAYER_DATE_ADD(base.\"sales.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"sales.ordered_at\"\n), step1 AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._count\",\n \"sales._time_shift_inner\",\n CAST((\n CAST(\"sales.revenue_sum\" AS REAL) / \"sales._count\" - \"sales._time_shift_inner\"\n ) AS REAL) / NULLIF(\"sales._time_shift_inner\", 0) AS \"sales.pct\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.pct\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._count\",\n \"sales._time_shift_inner\",\n \"sales.pct\"\n FROM step1\n) AS _outer", - "ts/change_pct_ratio::tsql": "WITH base AS (\n SELECT\n sales.store AS [sales___store],\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at],\n SUM(sales.revenue) AS [sales___revenue_sum],\n COUNT(*) AS [sales____count]\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATETRUNC(month, sales.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n sales.store AS [sales___store],\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at],\n CAST(SUM(sales.revenue) AS FLOAT) / COUNT(*) AS [sales___shifted]\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATETRUNC(month, sales.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.[sales___store] AS [sales___store],\n base.[sales___ordered_at] AS [sales___ordered_at],\n base.[sales___revenue_sum] AS [sales___revenue_sum],\n base.[sales____count] AS [sales____count],\n shifted__time_shift_inner.[sales___shifted] AS [sales____time_shift_inner]\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON (\n base.[sales___store] = shifted__time_shift_inner.[sales___store]\n OR (\n base.[sales___store] IS NULL AND shifted__time_shift_inner.[sales___store] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) = shifted__time_shift_inner.[sales___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) IS NULL\n AND shifted__time_shift_inner.[sales___ordered_at] IS NULL\n )\n )\n), step1 AS (\n SELECT\n [sales___store] AS [sales___store],\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales____count] AS [sales____count],\n [sales____time_shift_inner] AS [sales____time_shift_inner],\n CAST((\n CAST([sales___revenue_sum] AS FLOAT) / [sales____count] - [sales____time_shift_inner]\n ) AS FLOAT) / NULLIF([sales____time_shift_inner], 0) AS [sales___pct]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [sales___store],\n [sales___ordered_at],\n [sales___pct]\nFROM (\n SELECT\n [sales___store],\n [sales___ordered_at],\n [sales___revenue_sum],\n [sales____count],\n [sales____time_shift_inner],\n [sales___pct]\n FROM step1\n) AS _outer", + "ts/change_pct_ratio::bigquery": "WITH base AS (\n SELECT\n sales.store AS `sales___store`,\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`,\n SUM(sales.revenue) AS `sales___revenue_sum`,\n COUNT(*) AS `sales____count`\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC(sales.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n sales.store AS `sales___store`,\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`,\n SUM(sales.revenue) / NULLIF(COUNT(*), 0) AS `sales___shifted`\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC(sales.ordered_at, MONTH)\n), sjoin__time_shift_inner AS (\n SELECT\n base.`sales___store`,\n base.`sales___ordered_at`,\n base.`sales___revenue_sum`,\n base.`sales____count`,\n shifted__time_shift_inner.`sales___shifted` AS `sales____time_shift_inner`\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.`sales___store` IS NOT DISTINCT FROM shifted__time_shift_inner.`sales___store`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`sales___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____count`,\n `sales____time_shift_inner`,\n (\n `sales___revenue_sum` / NULLIF(`sales____count`, 0) - `sales____time_shift_inner`\n ) / NULLIF(NULLIF(`sales____time_shift_inner`, 0), 0) AS `sales___pct`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___pct`\nFROM (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____count`,\n `sales____time_shift_inner`,\n `sales___pct`\n FROM step1\n) AS _outer", + "ts/change_pct_ratio::duckdb": "WITH base AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\",\n COUNT(*) AS \"sales._count\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) / NULLIF(COUNT(*), 0) AS \"sales.shifted\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"sales.store\",\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n base.\"sales._count\",\n shifted__time_shift_inner.\"sales.shifted\" AS \"sales._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"sales.store\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"sales.store\"\n AND base.\"sales.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner.\"sales.ordered_at\"\n), step1 AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._count\",\n \"sales._time_shift_inner\",\n (\n \"sales.revenue_sum\" / NULLIF(\"sales._count\", 0) - \"sales._time_shift_inner\"\n ) / NULLIF(NULLIF(\"sales._time_shift_inner\", 0), 0) AS \"sales.pct\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.pct\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._count\",\n \"sales._time_shift_inner\",\n \"sales.pct\"\n FROM step1\n) AS _outer", + "ts/change_pct_ratio::postgres": "WITH base AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\",\n COUNT(*) AS \"sales._count\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n CAST(SUM(sales.revenue) AS DOUBLE PRECISION) / NULLIF(COUNT(*), 0) AS \"sales.shifted\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"sales.store\",\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n base.\"sales._count\",\n shifted__time_shift_inner.\"sales.shifted\" AS \"sales._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"sales.store\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"sales.store\"\n AND base.\"sales.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"sales.ordered_at\"\n), step1 AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._count\",\n \"sales._time_shift_inner\",\n CAST((\n CAST(\"sales.revenue_sum\" AS DOUBLE PRECISION) / NULLIF(\"sales._count\", 0) - \"sales._time_shift_inner\"\n ) AS DOUBLE PRECISION) / NULLIF(NULLIF(\"sales._time_shift_inner\", 0), 0) AS \"sales.pct\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.pct\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._count\",\n \"sales._time_shift_inner\",\n \"sales.pct\"\n FROM step1\n) AS _outer", + "ts/change_pct_ratio::sqlite": "WITH base AS (\n SELECT\n sales.store AS \"sales.store\",\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\",\n COUNT(*) AS \"sales._count\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n sales.store AS \"sales.store\",\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n CAST(SUM(sales.revenue) AS REAL) / NULLIF(COUNT(*), 0) AS \"sales.shifted\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"sales.store\",\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n base.\"sales._count\",\n shifted__time_shift_inner.\"sales.shifted\" AS \"sales._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"sales.store\" IS shifted__time_shift_inner.\"sales.store\"\n AND SLAYER_DATE_ADD(base.\"sales.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"sales.ordered_at\"\n), step1 AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._count\",\n \"sales._time_shift_inner\",\n CAST((\n CAST(\"sales.revenue_sum\" AS REAL) / NULLIF(\"sales._count\", 0) - \"sales._time_shift_inner\"\n ) AS REAL) / NULLIF(NULLIF(\"sales._time_shift_inner\", 0), 0) AS \"sales.pct\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.pct\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._count\",\n \"sales._time_shift_inner\",\n \"sales.pct\"\n FROM step1\n) AS _outer", + "ts/change_pct_ratio::tsql": "WITH base AS (\n SELECT\n sales.store AS [sales___store],\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at],\n SUM(sales.revenue) AS [sales___revenue_sum],\n COUNT(*) AS [sales____count]\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATETRUNC(month, sales.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n sales.store AS [sales___store],\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at],\n CAST(SUM(sales.revenue) AS FLOAT) / NULLIF(COUNT(*), 0) AS [sales___shifted]\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATETRUNC(month, sales.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.[sales___store] AS [sales___store],\n base.[sales___ordered_at] AS [sales___ordered_at],\n base.[sales___revenue_sum] AS [sales___revenue_sum],\n base.[sales____count] AS [sales____count],\n shifted__time_shift_inner.[sales___shifted] AS [sales____time_shift_inner]\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON (\n base.[sales___store] = shifted__time_shift_inner.[sales___store]\n OR (\n base.[sales___store] IS NULL AND shifted__time_shift_inner.[sales___store] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) = shifted__time_shift_inner.[sales___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) IS NULL\n AND shifted__time_shift_inner.[sales___ordered_at] IS NULL\n )\n )\n), step1 AS (\n SELECT\n [sales___store] AS [sales___store],\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales____count] AS [sales____count],\n [sales____time_shift_inner] AS [sales____time_shift_inner],\n CAST((\n CAST([sales___revenue_sum] AS FLOAT) / NULLIF([sales____count], 0) - [sales____time_shift_inner]\n ) AS FLOAT) / NULLIF(NULLIF([sales____time_shift_inner], 0), 0) AS [sales___pct]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [sales___store],\n [sales___ordered_at],\n [sales___pct]\nFROM (\n SELECT\n [sales___store],\n [sales___ordered_at],\n [sales___revenue_sum],\n [sales____count],\n [sales____time_shift_inner],\n [sales___pct]\n FROM step1\n) AS _outer", "ts/coalesce_missing::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`,\n SUM(sales.revenue) AS `sales___revenue_sum`\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), shifted_prev AS (\n SELECT\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`,\n COALESCE(SUM(sales.revenue), 0) AS `sales___shifted`\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), sjoin_prev AS (\n SELECT\n base.`sales___ordered_at`,\n base.`sales___revenue_sum`,\n shifted_prev.`sales___shifted` AS `sales___prev`\n FROM base\n LEFT JOIN shifted_prev\n ON CAST(DATETIME_ADD(CAST(CAST(base.`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_prev.`sales___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `sales___ordered_at`,\n `sales___prev`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___prev`\n FROM sjoin_prev\n) AS _outer", "ts/coalesce_missing::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), shifted_prev AS (\n SELECT\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n COALESCE(SUM(sales.revenue), 0) AS \"sales.shifted\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n shifted_prev.\"sales.shifted\" AS \"sales.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"sales.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_prev.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.prev\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.prev\"\n FROM sjoin_prev\n) AS _outer", "ts/coalesce_missing::postgres": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), shifted_prev AS (\n SELECT\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n COALESCE(SUM(sales.revenue), 0) AS \"sales.shifted\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n shifted_prev.\"sales.shifted\" AS \"sales.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"sales.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_prev.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.prev\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.prev\"\n FROM sjoin_prev\n) AS _outer", @@ -99,11 +99,11 @@ "ts/crossing_join::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), _cm_sales__revenue_wrevenue_sum_f_regions_factor AS (\n SELECT\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n CAST(SUM(sales.revenue * regions.factor) AS DOUBLE PRECISION) AS \"sales.revenue_wrevenue_sum_f_regions_factor\"\n FROM sales AS sales\n LEFT JOIN regions AS regions\n ON sales.region_id = regions.id\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), base AS (\n SELECT\n _base.\"sales.ordered_at\",\n _cm_sales__revenue_wrevenue_sum_f_regions_factor.\"sales.revenue_wrevenue_sum_f_regions_factor\" AS \"sales.revenue_wrevenue_sum_f_regions_factor\"\n FROM _base\n LEFT JOIN _cm_sales__revenue_wrevenue_sum_f_regions_factor\n ON _base.\"sales.ordered_at\" IS NOT DISTINCT FROM _cm_sales__revenue_wrevenue_sum_f_regions_factor.\"sales.ordered_at\"\n), shifted_prev AS (\n SELECT\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue * regions.factor) * 2 AS \"sales.shifted\"\n FROM sales AS sales\n LEFT JOIN regions AS regions\n ON sales.region_id = regions.id\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"sales.ordered_at\",\n base.\"sales.revenue_wrevenue_sum_f_regions_factor\",\n shifted_prev.\"sales.shifted\" AS \"sales.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"sales.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_prev.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.prev\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_wrevenue_sum_f_regions_factor\",\n \"sales.prev\"\n FROM sjoin_prev\n) AS _outer", "ts/crossing_join::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\"\n FROM sales AS sales\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), _cm_sales__revenue_wrevenue_sum_f_regions_factor AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n CAST(SUM(sales.revenue * regions.factor) AS REAL) AS \"sales.revenue_wrevenue_sum_f_regions_factor\"\n FROM sales AS sales\n LEFT JOIN regions AS regions\n ON sales.region_id = regions.id\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), base AS (\n SELECT\n _base.\"sales.ordered_at\",\n _cm_sales__revenue_wrevenue_sum_f_regions_factor.\"sales.revenue_wrevenue_sum_f_regions_factor\" AS \"sales.revenue_wrevenue_sum_f_regions_factor\"\n FROM _base\n LEFT JOIN _cm_sales__revenue_wrevenue_sum_f_regions_factor\n ON _base.\"sales.ordered_at\" IS _cm_sales__revenue_wrevenue_sum_f_regions_factor.\"sales.ordered_at\"\n), shifted_prev AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue * regions.factor) * 2 AS \"sales.shifted\"\n FROM sales AS sales\n LEFT JOIN regions AS regions\n ON sales.region_id = regions.id\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"sales.ordered_at\",\n base.\"sales.revenue_wrevenue_sum_f_regions_factor\",\n shifted_prev.\"sales.shifted\" AS \"sales.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON SLAYER_DATE_ADD(base.\"sales.ordered_at\", -1, 'month') IS shifted_prev.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.prev\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_wrevenue_sum_f_regions_factor\",\n \"sales.prev\"\n FROM sjoin_prev\n) AS _outer", "ts/crossing_join::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at]\n FROM sales AS sales\n GROUP BY\n DATETRUNC(month, sales.ordered_at)\n), _cm_sales__revenue_wrevenue_sum_f_regions_factor AS (\n SELECT\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at],\n CAST(SUM(sales.revenue * regions.factor) AS FLOAT) AS [sales___revenue_wrevenue_sum_f_regions_factor]\n FROM sales AS sales\n LEFT JOIN regions AS regions\n ON sales.region_id = regions.id\n GROUP BY\n DATETRUNC(month, sales.ordered_at)\n), base AS (\n SELECT\n _base.[sales___ordered_at] AS [sales___ordered_at],\n _cm_sales__revenue_wrevenue_sum_f_regions_factor.[sales___revenue_wrevenue_sum_f_regions_factor] AS [sales___revenue_wrevenue_sum_f_regions_factor]\n FROM _base\n LEFT JOIN _cm_sales__revenue_wrevenue_sum_f_regions_factor\n ON (\n _base.[sales___ordered_at] = _cm_sales__revenue_wrevenue_sum_f_regions_factor.[sales___ordered_at]\n OR (\n _base.[sales___ordered_at] IS NULL\n AND _cm_sales__revenue_wrevenue_sum_f_regions_factor.[sales___ordered_at] IS NULL\n )\n )\n), shifted_prev AS (\n SELECT\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at],\n SUM(sales.revenue * regions.factor) * 2 AS [sales___shifted]\n FROM sales AS sales\n LEFT JOIN regions AS regions\n ON sales.region_id = regions.id\n GROUP BY\n DATETRUNC(month, sales.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.[sales___ordered_at] AS [sales___ordered_at],\n base.[sales___revenue_wrevenue_sum_f_regions_factor] AS [sales___revenue_wrevenue_sum_f_regions_factor],\n shifted_prev.[sales___shifted] AS [sales___prev]\n FROM base\n LEFT JOIN shifted_prev\n ON (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) = shifted_prev.[sales___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) IS NULL\n AND shifted_prev.[sales___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [sales___ordered_at],\n [sales___prev]\nFROM (\n SELECT\n [sales___ordered_at],\n [sales___revenue_wrevenue_sum_f_regions_factor],\n [sales___prev]\n FROM sjoin_prev\n) AS _outer", - "ts/ratio_by_store::bigquery": "WITH base AS (\n SELECT\n sales.store AS `sales___store`,\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`,\n SUM(sales.revenue) AS `sales___revenue_sum`,\n SUM(sales.qty) AS `sales___qty_sum`\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC(sales.ordered_at, MONTH)\n), shifted_prev AS (\n SELECT\n sales.store AS `sales___store`,\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`,\n SUM(sales.revenue) / SUM(sales.qty) AS `sales___shifted`\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC(sales.ordered_at, MONTH)\n), sjoin_prev AS (\n SELECT\n base.`sales___store`,\n base.`sales___ordered_at`,\n base.`sales___revenue_sum`,\n base.`sales___qty_sum`,\n shifted_prev.`sales___shifted` AS `sales___prev`\n FROM base\n LEFT JOIN shifted_prev\n ON base.`sales___store` IS NOT DISTINCT FROM shifted_prev.`sales___store`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_prev.`sales___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___prev`\nFROM (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___qty_sum`,\n `sales___prev`\n FROM sjoin_prev\n) AS _outer", - "ts/ratio_by_store::duckdb": "WITH base AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\",\n SUM(sales.qty) AS \"sales.qty_sum\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), shifted_prev AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) / SUM(sales.qty) AS \"sales.shifted\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"sales.store\",\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n base.\"sales.qty_sum\",\n shifted_prev.\"sales.shifted\" AS \"sales.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"sales.store\" IS NOT DISTINCT FROM shifted_prev.\"sales.store\"\n AND base.\"sales.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_prev.\"sales.ordered_at\"\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.prev\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.qty_sum\",\n \"sales.prev\"\n FROM sjoin_prev\n) AS _outer", - "ts/ratio_by_store::postgres": "WITH base AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\",\n SUM(sales.qty) AS \"sales.qty_sum\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), shifted_prev AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n CAST(SUM(sales.revenue) AS DOUBLE PRECISION) / SUM(sales.qty) AS \"sales.shifted\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"sales.store\",\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n base.\"sales.qty_sum\",\n shifted_prev.\"sales.shifted\" AS \"sales.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"sales.store\" IS NOT DISTINCT FROM shifted_prev.\"sales.store\"\n AND base.\"sales.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_prev.\"sales.ordered_at\"\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.prev\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.qty_sum\",\n \"sales.prev\"\n FROM sjoin_prev\n) AS _outer", - "ts/ratio_by_store::sqlite": "WITH base AS (\n SELECT\n sales.store AS \"sales.store\",\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\",\n SUM(sales.qty) AS \"sales.qty_sum\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), shifted_prev AS (\n SELECT\n sales.store AS \"sales.store\",\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n CAST(SUM(sales.revenue) AS REAL) / SUM(sales.qty) AS \"sales.shifted\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"sales.store\",\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n base.\"sales.qty_sum\",\n shifted_prev.\"sales.shifted\" AS \"sales.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"sales.store\" IS shifted_prev.\"sales.store\"\n AND SLAYER_DATE_ADD(base.\"sales.ordered_at\", -1, 'month') IS shifted_prev.\"sales.ordered_at\"\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.prev\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.qty_sum\",\n \"sales.prev\"\n FROM sjoin_prev\n) AS _outer", - "ts/ratio_by_store::tsql": "WITH base AS (\n SELECT\n sales.store AS [sales___store],\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at],\n SUM(sales.revenue) AS [sales___revenue_sum],\n SUM(sales.qty) AS [sales___qty_sum]\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATETRUNC(month, sales.ordered_at)\n), shifted_prev AS (\n SELECT\n sales.store AS [sales___store],\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at],\n CAST(SUM(sales.revenue) AS FLOAT) / SUM(sales.qty) AS [sales___shifted]\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATETRUNC(month, sales.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.[sales___store] AS [sales___store],\n base.[sales___ordered_at] AS [sales___ordered_at],\n base.[sales___revenue_sum] AS [sales___revenue_sum],\n base.[sales___qty_sum] AS [sales___qty_sum],\n shifted_prev.[sales___shifted] AS [sales___prev]\n FROM base\n LEFT JOIN shifted_prev\n ON (\n base.[sales___store] = shifted_prev.[sales___store]\n OR (\n base.[sales___store] IS NULL AND shifted_prev.[sales___store] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) = shifted_prev.[sales___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) IS NULL\n AND shifted_prev.[sales___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [sales___store],\n [sales___ordered_at],\n [sales___prev]\nFROM (\n SELECT\n [sales___store],\n [sales___ordered_at],\n [sales___revenue_sum],\n [sales___qty_sum],\n [sales___prev]\n FROM sjoin_prev\n) AS _outer", + "ts/ratio_by_store::bigquery": "WITH base AS (\n SELECT\n sales.store AS `sales___store`,\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`,\n SUM(sales.revenue) AS `sales___revenue_sum`,\n SUM(sales.qty) AS `sales___qty_sum`\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC(sales.ordered_at, MONTH)\n), shifted_prev AS (\n SELECT\n sales.store AS `sales___store`,\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`,\n SUM(sales.revenue) / NULLIF(SUM(sales.qty), 0) AS `sales___shifted`\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC(sales.ordered_at, MONTH)\n), sjoin_prev AS (\n SELECT\n base.`sales___store`,\n base.`sales___ordered_at`,\n base.`sales___revenue_sum`,\n base.`sales___qty_sum`,\n shifted_prev.`sales___shifted` AS `sales___prev`\n FROM base\n LEFT JOIN shifted_prev\n ON base.`sales___store` IS NOT DISTINCT FROM shifted_prev.`sales___store`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_prev.`sales___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___prev`\nFROM (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___qty_sum`,\n `sales___prev`\n FROM sjoin_prev\n) AS _outer", + "ts/ratio_by_store::duckdb": "WITH base AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\",\n SUM(sales.qty) AS \"sales.qty_sum\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), shifted_prev AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) / NULLIF(SUM(sales.qty), 0) AS \"sales.shifted\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"sales.store\",\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n base.\"sales.qty_sum\",\n shifted_prev.\"sales.shifted\" AS \"sales.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"sales.store\" IS NOT DISTINCT FROM shifted_prev.\"sales.store\"\n AND base.\"sales.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_prev.\"sales.ordered_at\"\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.prev\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.qty_sum\",\n \"sales.prev\"\n FROM sjoin_prev\n) AS _outer", + "ts/ratio_by_store::postgres": "WITH base AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\",\n SUM(sales.qty) AS \"sales.qty_sum\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), shifted_prev AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n CAST(SUM(sales.revenue) AS DOUBLE PRECISION) / NULLIF(SUM(sales.qty), 0) AS \"sales.shifted\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"sales.store\",\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n base.\"sales.qty_sum\",\n shifted_prev.\"sales.shifted\" AS \"sales.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"sales.store\" IS NOT DISTINCT FROM shifted_prev.\"sales.store\"\n AND base.\"sales.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_prev.\"sales.ordered_at\"\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.prev\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.qty_sum\",\n \"sales.prev\"\n FROM sjoin_prev\n) AS _outer", + "ts/ratio_by_store::sqlite": "WITH base AS (\n SELECT\n sales.store AS \"sales.store\",\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\",\n SUM(sales.qty) AS \"sales.qty_sum\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), shifted_prev AS (\n SELECT\n sales.store AS \"sales.store\",\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n CAST(SUM(sales.revenue) AS REAL) / NULLIF(SUM(sales.qty), 0) AS \"sales.shifted\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"sales.store\",\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n base.\"sales.qty_sum\",\n shifted_prev.\"sales.shifted\" AS \"sales.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"sales.store\" IS shifted_prev.\"sales.store\"\n AND SLAYER_DATE_ADD(base.\"sales.ordered_at\", -1, 'month') IS shifted_prev.\"sales.ordered_at\"\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.prev\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.qty_sum\",\n \"sales.prev\"\n FROM sjoin_prev\n) AS _outer", + "ts/ratio_by_store::tsql": "WITH base AS (\n SELECT\n sales.store AS [sales___store],\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at],\n SUM(sales.revenue) AS [sales___revenue_sum],\n SUM(sales.qty) AS [sales___qty_sum]\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATETRUNC(month, sales.ordered_at)\n), shifted_prev AS (\n SELECT\n sales.store AS [sales___store],\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at],\n CAST(SUM(sales.revenue) AS FLOAT) / NULLIF(SUM(sales.qty), 0) AS [sales___shifted]\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATETRUNC(month, sales.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.[sales___store] AS [sales___store],\n base.[sales___ordered_at] AS [sales___ordered_at],\n base.[sales___revenue_sum] AS [sales___revenue_sum],\n base.[sales___qty_sum] AS [sales___qty_sum],\n shifted_prev.[sales___shifted] AS [sales___prev]\n FROM base\n LEFT JOIN shifted_prev\n ON (\n base.[sales___store] = shifted_prev.[sales___store]\n OR (\n base.[sales___store] IS NULL AND shifted_prev.[sales___store] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) = shifted_prev.[sales___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) IS NULL\n AND shifted_prev.[sales___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [sales___store],\n [sales___ordered_at],\n [sales___prev]\nFROM (\n SELECT\n [sales___store],\n [sales___ordered_at],\n [sales___revenue_sum],\n [sales___qty_sum],\n [sales___prev]\n FROM sjoin_prev\n) AS _outer", "ts/two_leaves::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`,\n SUM(CASE WHEN sales.revenue > 15 THEN sales.revenue END) AS `sales___hi_rev_sum`\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), _cm_sales__revenue_wrevenue_sum_f_regions_factor AS (\n SELECT\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`,\n CAST(SUM(sales.revenue * regions.factor) AS FLOAT64) AS `sales___revenue_wrevenue_sum_f_regions_factor`\n FROM sales AS sales\n LEFT JOIN regions AS regions\n ON sales.region_id = regions.id\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`sales___ordered_at`,\n _base.`sales___hi_rev_sum`,\n _cm_sales__revenue_wrevenue_sum_f_regions_factor.`sales___revenue_wrevenue_sum_f_regions_factor` AS `sales___revenue_wrevenue_sum_f_regions_factor`\n FROM _base\n LEFT JOIN _cm_sales__revenue_wrevenue_sum_f_regions_factor\n ON _base.`sales___ordered_at` IS NOT DISTINCT FROM _cm_sales__revenue_wrevenue_sum_f_regions_factor.`sales___ordered_at`\n), shifted_prev AS (\n SELECT\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`,\n SUM(sales.revenue * regions.factor) + SUM(CASE WHEN sales.revenue > 15 THEN sales.revenue END) AS `sales___shifted`\n FROM sales AS sales\n LEFT JOIN regions AS regions\n ON sales.region_id = regions.id\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), sjoin_prev AS (\n SELECT\n base.`sales___ordered_at`,\n base.`sales___hi_rev_sum`,\n base.`sales___revenue_wrevenue_sum_f_regions_factor`,\n shifted_prev.`sales___shifted` AS `sales___prev`\n FROM base\n LEFT JOIN shifted_prev\n ON CAST(DATETIME_ADD(CAST(CAST(base.`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_prev.`sales___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `sales___ordered_at`,\n `sales___prev`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n `sales___revenue_wrevenue_sum_f_regions_factor`,\n `sales___prev`\n FROM sjoin_prev\n) AS _outer", "ts/two_leaves::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(CASE WHEN sales.revenue > 15 THEN sales.revenue END) AS \"sales.hi_rev_sum\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), _cm_sales__revenue_wrevenue_sum_f_regions_factor AS (\n SELECT\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n CAST(SUM(sales.revenue * regions.factor) AS DOUBLE) AS \"sales.revenue_wrevenue_sum_f_regions_factor\"\n FROM sales AS sales\n LEFT JOIN regions AS regions\n ON sales.region_id = regions.id\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), base AS (\n SELECT\n _base.\"sales.ordered_at\",\n _base.\"sales.hi_rev_sum\",\n _cm_sales__revenue_wrevenue_sum_f_regions_factor.\"sales.revenue_wrevenue_sum_f_regions_factor\" AS \"sales.revenue_wrevenue_sum_f_regions_factor\"\n FROM _base\n LEFT JOIN _cm_sales__revenue_wrevenue_sum_f_regions_factor\n ON _base.\"sales.ordered_at\" IS NOT DISTINCT FROM _cm_sales__revenue_wrevenue_sum_f_regions_factor.\"sales.ordered_at\"\n), shifted_prev AS (\n SELECT\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue * regions.factor) + SUM(CASE WHEN sales.revenue > 15 THEN sales.revenue END) AS \"sales.shifted\"\n FROM sales AS sales\n LEFT JOIN regions AS regions\n ON sales.region_id = regions.id\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"sales.ordered_at\",\n base.\"sales.hi_rev_sum\",\n base.\"sales.revenue_wrevenue_sum_f_regions_factor\",\n shifted_prev.\"sales.shifted\" AS \"sales.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"sales.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_prev.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.prev\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.revenue_wrevenue_sum_f_regions_factor\",\n \"sales.prev\"\n FROM sjoin_prev\n) AS _outer", "ts/two_leaves::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(CASE WHEN sales.revenue > 15 THEN sales.revenue END) AS \"sales.hi_rev_sum\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), _cm_sales__revenue_wrevenue_sum_f_regions_factor AS (\n SELECT\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n CAST(SUM(sales.revenue * regions.factor) AS DOUBLE PRECISION) AS \"sales.revenue_wrevenue_sum_f_regions_factor\"\n FROM sales AS sales\n LEFT JOIN regions AS regions\n ON sales.region_id = regions.id\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), base AS (\n SELECT\n _base.\"sales.ordered_at\",\n _base.\"sales.hi_rev_sum\",\n _cm_sales__revenue_wrevenue_sum_f_regions_factor.\"sales.revenue_wrevenue_sum_f_regions_factor\" AS \"sales.revenue_wrevenue_sum_f_regions_factor\"\n FROM _base\n LEFT JOIN _cm_sales__revenue_wrevenue_sum_f_regions_factor\n ON _base.\"sales.ordered_at\" IS NOT DISTINCT FROM _cm_sales__revenue_wrevenue_sum_f_regions_factor.\"sales.ordered_at\"\n), shifted_prev AS (\n SELECT\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue * regions.factor) + SUM(CASE WHEN sales.revenue > 15 THEN sales.revenue END) AS \"sales.shifted\"\n FROM sales AS sales\n LEFT JOIN regions AS regions\n ON sales.region_id = regions.id\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"sales.ordered_at\",\n base.\"sales.hi_rev_sum\",\n base.\"sales.revenue_wrevenue_sum_f_regions_factor\",\n shifted_prev.\"sales.shifted\" AS \"sales.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"sales.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_prev.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.prev\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.revenue_wrevenue_sum_f_regions_factor\",\n \"sales.prev\"\n FROM sjoin_prev\n) AS _outer", diff --git a/tests/golden/dev1868_sql_baseline.json b/tests/golden/dev1868_sql_baseline.json index f548e9ad..8261829d 100644 --- a/tests/golden/dev1868_sql_baseline.json +++ b/tests/golden/dev1868_sql_baseline.json @@ -104,14 +104,14 @@ "w3/multi_remote::postgres": "WITH _base AS (\n SELECT\n customers.tier AS \"orders.customers.tier\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_sum AS (\n SELECT\n customers.tier AS \"customers.tier\",\n CAST(SUM(customers.spend) AS DOUBLE PRECISION) AS \"customers.spend_sum\"\n FROM customers AS customers\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_max AS (\n SELECT\n customers.tier AS \"customers.tier\",\n CAST(MAX(customers.spend) AS DOUBLE PRECISION) AS \"customers.spend_max\"\n FROM customers AS customers\n GROUP BY\n customers.tier\n)\nSELECT\n _base.\"orders.customers.tier\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" - _cm_orders__customers__spend_max.\"customers.spend_max\" AS \"orders.r\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.\"orders.customers.tier\" IS NOT DISTINCT FROM _cm_orders__customers__spend_sum.\"customers.tier\"\nLEFT JOIN _cm_orders__customers__spend_max\n ON _base.\"orders.customers.tier\" IS NOT DISTINCT FROM _cm_orders__customers__spend_max.\"customers.tier\"", "w3/multi_remote::sqlite": "WITH _base AS (\n SELECT\n customers.tier AS \"orders.customers.tier\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_sum AS (\n SELECT\n customers.tier AS \"customers.tier\",\n CAST(SUM(customers.spend) AS REAL) AS \"customers.spend_sum\"\n FROM customers AS customers\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_max AS (\n SELECT\n customers.tier AS \"customers.tier\",\n CAST(MAX(customers.spend) AS REAL) AS \"customers.spend_max\"\n FROM customers AS customers\n GROUP BY\n customers.tier\n)\nSELECT\n _base.\"orders.customers.tier\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" - _cm_orders__customers__spend_max.\"customers.spend_max\" AS \"orders.r\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.\"orders.customers.tier\" IS _cm_orders__customers__spend_sum.\"customers.tier\"\nLEFT JOIN _cm_orders__customers__spend_max\n ON _base.\"orders.customers.tier\" IS _cm_orders__customers__spend_max.\"customers.tier\"", "w3/multi_remote::tsql": "WITH _base AS (\n SELECT\n customers.tier AS [orders___customers___tier]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_sum AS (\n SELECT\n customers.tier AS [customers___tier],\n CAST(SUM(customers.spend) AS FLOAT) AS [customers___spend_sum]\n FROM customers AS customers\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_max AS (\n SELECT\n customers.tier AS [customers___tier],\n CAST(MAX(customers.spend) AS FLOAT) AS [customers___spend_max]\n FROM customers AS customers\n GROUP BY\n customers.tier\n)\nSELECT\n _base.[orders___customers___tier],\n _cm_orders__customers__spend_sum.[customers___spend_sum] - _cm_orders__customers__spend_max.[customers___spend_max] AS [orders___r]\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON (\n _base.[orders___customers___tier] = _cm_orders__customers__spend_sum.[customers___tier]\n OR (\n _base.[orders___customers___tier] IS NULL\n AND _cm_orders__customers__spend_sum.[customers___tier] IS NULL\n )\n )\nLEFT JOIN _cm_orders__customers__spend_max\n ON (\n _base.[orders___customers___tier] = _cm_orders__customers__spend_max.[customers___tier]\n OR (\n _base.[orders___customers___tier] IS NULL\n AND _cm_orders__customers__spend_max.[customers___tier] IS NULL\n )\n )", - "w3/scalar_call::bigquery": "WITH _base AS (\n SELECT\n customers.tier AS `orders___customers___tier`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_sum AS (\n SELECT\n customers.tier AS `customers___tier`,\n CAST(SUM(customers.spend) AS FLOAT64) AS `customers___spend_sum`\n FROM customers AS customers\n GROUP BY\n customers.tier\n)\nSELECT\n _base.`orders___customers___tier`,\n ROUND(\n _cm_orders__customers__spend_sum.`customers___spend_sum` / _base.`orders___amount_sum`,\n 2\n ) AS `orders___r`\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.`orders___customers___tier` IS NOT DISTINCT FROM _cm_orders__customers__spend_sum.`customers___tier`", - "w3/scalar_call::duckdb": "WITH _base AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_sum AS (\n SELECT\n customers.tier AS \"customers.tier\",\n CAST(SUM(customers.spend) AS DOUBLE) AS \"customers.spend_sum\"\n FROM customers AS customers\n GROUP BY\n customers.tier\n)\nSELECT\n _base.\"orders.customers.tier\",\n ROUND(\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" / _base.\"orders.amount_sum\",\n 2\n ) AS \"orders.r\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.\"orders.customers.tier\" IS NOT DISTINCT FROM _cm_orders__customers__spend_sum.\"customers.tier\"", - "w3/scalar_call::postgres": "WITH _base AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_sum AS (\n SELECT\n customers.tier AS \"customers.tier\",\n CAST(SUM(customers.spend) AS DOUBLE PRECISION) AS \"customers.spend_sum\"\n FROM customers AS customers\n GROUP BY\n customers.tier\n)\nSELECT\n _base.\"orders.customers.tier\",\n ROUND(\n CAST(CAST(_cm_orders__customers__spend_sum.\"customers.spend_sum\" AS DOUBLE PRECISION) / _base.\"orders.amount_sum\" AS DECIMAL),\n 2\n ) AS \"orders.r\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.\"orders.customers.tier\" IS NOT DISTINCT FROM _cm_orders__customers__spend_sum.\"customers.tier\"", - "w3/scalar_call::sqlite": "WITH _base AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_sum AS (\n SELECT\n customers.tier AS \"customers.tier\",\n CAST(SUM(customers.spend) AS REAL) AS \"customers.spend_sum\"\n FROM customers AS customers\n GROUP BY\n customers.tier\n)\nSELECT\n _base.\"orders.customers.tier\",\n ROUND(\n CAST(_cm_orders__customers__spend_sum.\"customers.spend_sum\" AS REAL) / _base.\"orders.amount_sum\",\n 2\n ) AS \"orders.r\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.\"orders.customers.tier\" IS _cm_orders__customers__spend_sum.\"customers.tier\"", - "w3/scalar_call::tsql": "WITH _base AS (\n SELECT\n customers.tier AS [orders___customers___tier],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_sum AS (\n SELECT\n customers.tier AS [customers___tier],\n CAST(SUM(customers.spend) AS FLOAT) AS [customers___spend_sum]\n FROM customers AS customers\n GROUP BY\n customers.tier\n)\nSELECT\n _base.[orders___customers___tier],\n ROUND(\n CAST(_cm_orders__customers__spend_sum.[customers___spend_sum] AS FLOAT) / _base.[orders___amount_sum],\n 2\n ) AS [orders___r]\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON (\n _base.[orders___customers___tier] = _cm_orders__customers__spend_sum.[customers___tier]\n OR (\n _base.[orders___customers___tier] IS NULL\n AND _cm_orders__customers__spend_sum.[customers___tier] IS NULL\n )\n )", - "w3/two_roots::bigquery": "WITH _base AS (\n SELECT\n customers__regions.name AS `orders___customers___regions___name`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n customers__regions.name\n), _cm_orders__customers__spend_sum AS (\n SELECT\n regions.name AS `customers___regions___name`,\n CAST(SUM(customers.spend) AS FLOAT64) AS `customers___spend_sum`\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n GROUP BY\n regions.name\n), _cm_orders__customers__regions__pop_sum AS (\n SELECT\n regions.name AS `regions___name`,\n CAST(SUM(regions.pop) AS FLOAT64) AS `regions___pop_sum`\n FROM regions AS regions\n GROUP BY\n regions.name\n)\nSELECT\n _base.`orders___customers___regions___name`,\n _cm_orders__customers__spend_sum.`customers___spend_sum` / _cm_orders__customers__regions__pop_sum.`regions___pop_sum` AS `orders___r`\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.`orders___customers___regions___name` IS NOT DISTINCT FROM _cm_orders__customers__spend_sum.`customers___regions___name`\nLEFT JOIN _cm_orders__customers__regions__pop_sum\n ON _base.`orders___customers___regions___name` IS NOT DISTINCT FROM _cm_orders__customers__regions__pop_sum.`regions___name`", - "w3/two_roots::duckdb": "WITH _base AS (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n customers__regions.name\n), _cm_orders__customers__spend_sum AS (\n SELECT\n regions.name AS \"customers.regions.name\",\n CAST(SUM(customers.spend) AS DOUBLE) AS \"customers.spend_sum\"\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n GROUP BY\n regions.name\n), _cm_orders__customers__regions__pop_sum AS (\n SELECT\n regions.name AS \"regions.name\",\n CAST(SUM(regions.pop) AS DOUBLE) AS \"regions.pop_sum\"\n FROM regions AS regions\n GROUP BY\n regions.name\n)\nSELECT\n _base.\"orders.customers.regions.name\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" / _cm_orders__customers__regions__pop_sum.\"regions.pop_sum\" AS \"orders.r\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.\"orders.customers.regions.name\" IS NOT DISTINCT FROM _cm_orders__customers__spend_sum.\"customers.regions.name\"\nLEFT JOIN _cm_orders__customers__regions__pop_sum\n ON _base.\"orders.customers.regions.name\" IS NOT DISTINCT FROM _cm_orders__customers__regions__pop_sum.\"regions.name\"", - "w3/two_roots::postgres": "WITH _base AS (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n customers__regions.name\n), _cm_orders__customers__spend_sum AS (\n SELECT\n regions.name AS \"customers.regions.name\",\n CAST(SUM(customers.spend) AS DOUBLE PRECISION) AS \"customers.spend_sum\"\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n GROUP BY\n regions.name\n), _cm_orders__customers__regions__pop_sum AS (\n SELECT\n regions.name AS \"regions.name\",\n CAST(SUM(regions.pop) AS DOUBLE PRECISION) AS \"regions.pop_sum\"\n FROM regions AS regions\n GROUP BY\n regions.name\n)\nSELECT\n _base.\"orders.customers.regions.name\",\n CAST(_cm_orders__customers__spend_sum.\"customers.spend_sum\" AS DOUBLE PRECISION) / _cm_orders__customers__regions__pop_sum.\"regions.pop_sum\" AS \"orders.r\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.\"orders.customers.regions.name\" IS NOT DISTINCT FROM _cm_orders__customers__spend_sum.\"customers.regions.name\"\nLEFT JOIN _cm_orders__customers__regions__pop_sum\n ON _base.\"orders.customers.regions.name\" IS NOT DISTINCT FROM _cm_orders__customers__regions__pop_sum.\"regions.name\"", - "w3/two_roots::sqlite": "WITH _base AS (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n customers__regions.name\n), _cm_orders__customers__spend_sum AS (\n SELECT\n regions.name AS \"customers.regions.name\",\n CAST(SUM(customers.spend) AS REAL) AS \"customers.spend_sum\"\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n GROUP BY\n regions.name\n), _cm_orders__customers__regions__pop_sum AS (\n SELECT\n regions.name AS \"regions.name\",\n CAST(SUM(regions.pop) AS REAL) AS \"regions.pop_sum\"\n FROM regions AS regions\n GROUP BY\n regions.name\n)\nSELECT\n _base.\"orders.customers.regions.name\",\n CAST(_cm_orders__customers__spend_sum.\"customers.spend_sum\" AS REAL) / _cm_orders__customers__regions__pop_sum.\"regions.pop_sum\" AS \"orders.r\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.\"orders.customers.regions.name\" IS _cm_orders__customers__spend_sum.\"customers.regions.name\"\nLEFT JOIN _cm_orders__customers__regions__pop_sum\n ON _base.\"orders.customers.regions.name\" IS _cm_orders__customers__regions__pop_sum.\"regions.name\"", - "w3/two_roots::tsql": "WITH _base AS (\n SELECT\n customers__regions.name AS [orders___customers___regions___name]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n customers__regions.name\n), _cm_orders__customers__spend_sum AS (\n SELECT\n regions.name AS [customers___regions___name],\n CAST(SUM(customers.spend) AS FLOAT) AS [customers___spend_sum]\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n GROUP BY\n regions.name\n), _cm_orders__customers__regions__pop_sum AS (\n SELECT\n regions.name AS [regions___name],\n CAST(SUM(regions.pop) AS FLOAT) AS [regions___pop_sum]\n FROM regions AS regions\n GROUP BY\n regions.name\n)\nSELECT\n _base.[orders___customers___regions___name],\n CAST(_cm_orders__customers__spend_sum.[customers___spend_sum] AS FLOAT) / _cm_orders__customers__regions__pop_sum.[regions___pop_sum] AS [orders___r]\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON (\n _base.[orders___customers___regions___name] = _cm_orders__customers__spend_sum.[customers___regions___name]\n OR (\n _base.[orders___customers___regions___name] IS NULL\n AND _cm_orders__customers__spend_sum.[customers___regions___name] IS NULL\n )\n )\nLEFT JOIN _cm_orders__customers__regions__pop_sum\n ON (\n _base.[orders___customers___regions___name] = _cm_orders__customers__regions__pop_sum.[regions___name]\n OR (\n _base.[orders___customers___regions___name] IS NULL\n AND _cm_orders__customers__regions__pop_sum.[regions___name] IS NULL\n )\n )" + "w3/scalar_call::bigquery": "WITH _base AS (\n SELECT\n customers.tier AS `orders___customers___tier`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_sum AS (\n SELECT\n customers.tier AS `customers___tier`,\n CAST(SUM(customers.spend) AS FLOAT64) AS `customers___spend_sum`\n FROM customers AS customers\n GROUP BY\n customers.tier\n)\nSELECT\n _base.`orders___customers___tier`,\n ROUND(\n _cm_orders__customers__spend_sum.`customers___spend_sum` / NULLIF(_base.`orders___amount_sum`, 0),\n 2\n ) AS `orders___r`\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.`orders___customers___tier` IS NOT DISTINCT FROM _cm_orders__customers__spend_sum.`customers___tier`", + "w3/scalar_call::duckdb": "WITH _base AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_sum AS (\n SELECT\n customers.tier AS \"customers.tier\",\n CAST(SUM(customers.spend) AS DOUBLE) AS \"customers.spend_sum\"\n FROM customers AS customers\n GROUP BY\n customers.tier\n)\nSELECT\n _base.\"orders.customers.tier\",\n ROUND(\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" / NULLIF(_base.\"orders.amount_sum\", 0),\n 2\n ) AS \"orders.r\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.\"orders.customers.tier\" IS NOT DISTINCT FROM _cm_orders__customers__spend_sum.\"customers.tier\"", + "w3/scalar_call::postgres": "WITH _base AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_sum AS (\n SELECT\n customers.tier AS \"customers.tier\",\n CAST(SUM(customers.spend) AS DOUBLE PRECISION) AS \"customers.spend_sum\"\n FROM customers AS customers\n GROUP BY\n customers.tier\n)\nSELECT\n _base.\"orders.customers.tier\",\n ROUND(\n CAST(CAST(_cm_orders__customers__spend_sum.\"customers.spend_sum\" AS DOUBLE PRECISION) / NULLIF(_base.\"orders.amount_sum\", 0) AS DECIMAL),\n 2\n ) AS \"orders.r\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.\"orders.customers.tier\" IS NOT DISTINCT FROM _cm_orders__customers__spend_sum.\"customers.tier\"", + "w3/scalar_call::sqlite": "WITH _base AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_sum AS (\n SELECT\n customers.tier AS \"customers.tier\",\n CAST(SUM(customers.spend) AS REAL) AS \"customers.spend_sum\"\n FROM customers AS customers\n GROUP BY\n customers.tier\n)\nSELECT\n _base.\"orders.customers.tier\",\n ROUND(\n CAST(_cm_orders__customers__spend_sum.\"customers.spend_sum\" AS REAL) / NULLIF(_base.\"orders.amount_sum\", 0),\n 2\n ) AS \"orders.r\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.\"orders.customers.tier\" IS _cm_orders__customers__spend_sum.\"customers.tier\"", + "w3/scalar_call::tsql": "WITH _base AS (\n SELECT\n customers.tier AS [orders___customers___tier],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_sum AS (\n SELECT\n customers.tier AS [customers___tier],\n CAST(SUM(customers.spend) AS FLOAT) AS [customers___spend_sum]\n FROM customers AS customers\n GROUP BY\n customers.tier\n)\nSELECT\n _base.[orders___customers___tier],\n ROUND(\n CAST(_cm_orders__customers__spend_sum.[customers___spend_sum] AS FLOAT) / NULLIF(_base.[orders___amount_sum], 0),\n 2\n ) AS [orders___r]\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON (\n _base.[orders___customers___tier] = _cm_orders__customers__spend_sum.[customers___tier]\n OR (\n _base.[orders___customers___tier] IS NULL\n AND _cm_orders__customers__spend_sum.[customers___tier] IS NULL\n )\n )", + "w3/two_roots::bigquery": "WITH _base AS (\n SELECT\n customers__regions.name AS `orders___customers___regions___name`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n customers__regions.name\n), _cm_orders__customers__spend_sum AS (\n SELECT\n regions.name AS `customers___regions___name`,\n CAST(SUM(customers.spend) AS FLOAT64) AS `customers___spend_sum`\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n GROUP BY\n regions.name\n), _cm_orders__customers__regions__pop_sum AS (\n SELECT\n regions.name AS `regions___name`,\n CAST(SUM(regions.pop) AS FLOAT64) AS `regions___pop_sum`\n FROM regions AS regions\n GROUP BY\n regions.name\n)\nSELECT\n _base.`orders___customers___regions___name`,\n _cm_orders__customers__spend_sum.`customers___spend_sum` / NULLIF(_cm_orders__customers__regions__pop_sum.`regions___pop_sum`, 0) AS `orders___r`\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.`orders___customers___regions___name` IS NOT DISTINCT FROM _cm_orders__customers__spend_sum.`customers___regions___name`\nLEFT JOIN _cm_orders__customers__regions__pop_sum\n ON _base.`orders___customers___regions___name` IS NOT DISTINCT FROM _cm_orders__customers__regions__pop_sum.`regions___name`", + "w3/two_roots::duckdb": "WITH _base AS (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n customers__regions.name\n), _cm_orders__customers__spend_sum AS (\n SELECT\n regions.name AS \"customers.regions.name\",\n CAST(SUM(customers.spend) AS DOUBLE) AS \"customers.spend_sum\"\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n GROUP BY\n regions.name\n), _cm_orders__customers__regions__pop_sum AS (\n SELECT\n regions.name AS \"regions.name\",\n CAST(SUM(regions.pop) AS DOUBLE) AS \"regions.pop_sum\"\n FROM regions AS regions\n GROUP BY\n regions.name\n)\nSELECT\n _base.\"orders.customers.regions.name\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" / NULLIF(_cm_orders__customers__regions__pop_sum.\"regions.pop_sum\", 0) AS \"orders.r\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.\"orders.customers.regions.name\" IS NOT DISTINCT FROM _cm_orders__customers__spend_sum.\"customers.regions.name\"\nLEFT JOIN _cm_orders__customers__regions__pop_sum\n ON _base.\"orders.customers.regions.name\" IS NOT DISTINCT FROM _cm_orders__customers__regions__pop_sum.\"regions.name\"", + "w3/two_roots::postgres": "WITH _base AS (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n customers__regions.name\n), _cm_orders__customers__spend_sum AS (\n SELECT\n regions.name AS \"customers.regions.name\",\n CAST(SUM(customers.spend) AS DOUBLE PRECISION) AS \"customers.spend_sum\"\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n GROUP BY\n regions.name\n), _cm_orders__customers__regions__pop_sum AS (\n SELECT\n regions.name AS \"regions.name\",\n CAST(SUM(regions.pop) AS DOUBLE PRECISION) AS \"regions.pop_sum\"\n FROM regions AS regions\n GROUP BY\n regions.name\n)\nSELECT\n _base.\"orders.customers.regions.name\",\n CAST(_cm_orders__customers__spend_sum.\"customers.spend_sum\" AS DOUBLE PRECISION) / NULLIF(_cm_orders__customers__regions__pop_sum.\"regions.pop_sum\", 0) AS \"orders.r\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.\"orders.customers.regions.name\" IS NOT DISTINCT FROM _cm_orders__customers__spend_sum.\"customers.regions.name\"\nLEFT JOIN _cm_orders__customers__regions__pop_sum\n ON _base.\"orders.customers.regions.name\" IS NOT DISTINCT FROM _cm_orders__customers__regions__pop_sum.\"regions.name\"", + "w3/two_roots::sqlite": "WITH _base AS (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n customers__regions.name\n), _cm_orders__customers__spend_sum AS (\n SELECT\n regions.name AS \"customers.regions.name\",\n CAST(SUM(customers.spend) AS REAL) AS \"customers.spend_sum\"\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n GROUP BY\n regions.name\n), _cm_orders__customers__regions__pop_sum AS (\n SELECT\n regions.name AS \"regions.name\",\n CAST(SUM(regions.pop) AS REAL) AS \"regions.pop_sum\"\n FROM regions AS regions\n GROUP BY\n regions.name\n)\nSELECT\n _base.\"orders.customers.regions.name\",\n CAST(_cm_orders__customers__spend_sum.\"customers.spend_sum\" AS REAL) / NULLIF(_cm_orders__customers__regions__pop_sum.\"regions.pop_sum\", 0) AS \"orders.r\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON _base.\"orders.customers.regions.name\" IS _cm_orders__customers__spend_sum.\"customers.regions.name\"\nLEFT JOIN _cm_orders__customers__regions__pop_sum\n ON _base.\"orders.customers.regions.name\" IS _cm_orders__customers__regions__pop_sum.\"regions.name\"", + "w3/two_roots::tsql": "WITH _base AS (\n SELECT\n customers__regions.name AS [orders___customers___regions___name]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n GROUP BY\n customers__regions.name\n), _cm_orders__customers__spend_sum AS (\n SELECT\n regions.name AS [customers___regions___name],\n CAST(SUM(customers.spend) AS FLOAT) AS [customers___spend_sum]\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n GROUP BY\n regions.name\n), _cm_orders__customers__regions__pop_sum AS (\n SELECT\n regions.name AS [regions___name],\n CAST(SUM(regions.pop) AS FLOAT) AS [regions___pop_sum]\n FROM regions AS regions\n GROUP BY\n regions.name\n)\nSELECT\n _base.[orders___customers___regions___name],\n CAST(_cm_orders__customers__spend_sum.[customers___spend_sum] AS FLOAT) / NULLIF(_cm_orders__customers__regions__pop_sum.[regions___pop_sum], 0) AS [orders___r]\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_sum\n ON (\n _base.[orders___customers___regions___name] = _cm_orders__customers__spend_sum.[customers___regions___name]\n OR (\n _base.[orders___customers___regions___name] IS NULL\n AND _cm_orders__customers__spend_sum.[customers___regions___name] IS NULL\n )\n )\nLEFT JOIN _cm_orders__customers__regions__pop_sum\n ON (\n _base.[orders___customers___regions___name] = _cm_orders__customers__regions__pop_sum.[regions___name]\n OR (\n _base.[orders___customers___regions___name] IS NULL\n AND _cm_orders__customers__regions__pop_sum.[regions___name] IS NULL\n )\n )" } diff --git a/tests/golden/dev1958_sql_baseline.json b/tests/golden/dev1958_sql_baseline.json index a7c85fa3..a4e859c0 100644 --- a/tests/golden/dev1958_sql_baseline.json +++ b/tests/golden/dev1958_sql_baseline.json @@ -19,56 +19,56 @@ "frame/mixed_conjunction::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND monthly.region = 'North'\n )\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND monthly.region = 'North'\n )\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n WHERE\n monthly.region = 'North'\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at_2 AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n WHERE\n monthly.region = 'North'\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _base_2.\"monthly.amount_sum\" + _cm_monthly__amount_sum_partition_by_ordered_at_2.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at_2\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at_2.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "frame/mixed_conjunction::sqlite": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= '2024-02-01' AND monthly.region = 'North'\n )\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= '2024-02-01' AND monthly.region = 'North'\n )\n GROUP BY\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n WHERE\n monthly.region = 'North'\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at_2 AS (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n WHERE\n monthly.region = 'North'\n GROUP BY\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _base_2.\"monthly.amount_sum\" + _cm_monthly__amount_sum_partition_by_ordered_at_2.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at_2\n ON _base_2.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at_2.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS shifted_t.\"monthly.region\"\n AND SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'month') IS shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "frame/mixed_conjunction::tsql": "WITH _base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= CAST('2024-02-01 00:00:00' AS DATETIME2)\n AND monthly.region = 'North'\n )\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_ordered_at]\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= CAST('2024-02-01 00:00:00' AS DATETIME2)\n AND monthly.region = 'North'\n )\n GROUP BY\n DATETRUNC(month, monthly.ordered_at)\n), base AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n _base.[monthly___amount_sum] AS [monthly___amount_sum],\n _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at]\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n WHERE\n monthly.region = 'North'\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at_2 AS (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_ordered_at]\n FROM monthly AS monthly\n WHERE\n monthly.region = 'North'\n GROUP BY\n DATETRUNC(month, monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at] AS [monthly___ordered_at],\n _base_2.[monthly___amount_sum] + _cm_monthly__amount_sum_partition_by_ordered_at_2.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at_2\n ON (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at_2.[monthly___ordered_at]\n OR (\n _base_2.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at_2.[monthly___ordered_at] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_sum] AS [monthly___amount_sum],\n base.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n shifted_t.[monthly___shifted] AS [monthly___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[monthly___region] = shifted_t.[monthly___region]\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND shifted_t.[monthly___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_sum],\n [monthly___amount_sum_partition_by_ordered_at],\n [monthly___t]\n FROM sjoin_t\n) AS _outer", - "frame/non_time_partition::bigquery": "WITH _base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= '2024-02-01 00:00:00'\n AND monthly.ordered_at < '2024-04-01 00:00:00'\n )\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS `monthly___region`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_region`\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= '2024-02-01 00:00:00'\n AND monthly.ordered_at < '2024-04-01 00:00:00'\n )\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _base.`monthly___amount_sum`,\n _cm_monthly__amount_sum_partition_by_region.`monthly___amount_sum_partition_by_region` AS `monthly___amount_sum_partition_by_region`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.`monthly___region`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted_t AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at`,\n _base_2.`monthly___amount_sum` / _cm_monthly__amount_sum_partition_by_region.`monthly___amount_sum_partition_by_region` AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base_2.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.`monthly___region`\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum`,\n base.`monthly___amount_sum_partition_by_region`,\n shifted_t.`monthly___shifted` AS `monthly___t`\n FROM base\n LEFT JOIN shifted_t\n ON base.`monthly___region` IS NOT DISTINCT FROM shifted_t.`monthly___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___amount_sum_partition_by_region`,\n `monthly___t`\n FROM sjoin_t\n) AS _outer", - "frame/non_time_partition::duckdb": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND monthly.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND monthly.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _base_2.\"monthly.amount_sum\" / _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", - "frame/non_time_partition::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND monthly.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND monthly.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS DOUBLE PRECISION) / _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", - "frame/non_time_partition::sqlite": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= '2024-02-01' AND monthly.ordered_at < '2024-04-01'\n )\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= '2024-02-01' AND monthly.ordered_at < '2024-04-01'\n )\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base.\"monthly.region\" IS _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS REAL) / _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base_2.\"monthly.region\" IS _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS shifted_t.\"monthly.region\"\n AND SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'month') IS shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", - "frame/non_time_partition::tsql": "WITH _base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= CAST('2024-02-01 00:00:00' AS DATETIME2)\n AND monthly.ordered_at < CAST('2024-04-01 00:00:00' AS DATETIME2)\n )\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS [monthly___region],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_region]\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= CAST('2024-02-01 00:00:00' AS DATETIME2)\n AND monthly.ordered_at < CAST('2024-04-01 00:00:00' AS DATETIME2)\n )\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n _base.[monthly___amount_sum] AS [monthly___amount_sum],\n _cm_monthly__amount_sum_partition_by_region.[monthly___amount_sum_partition_by_region] AS [monthly___amount_sum_partition_by_region]\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON (\n _base.[monthly___region] = _cm_monthly__amount_sum_partition_by_region.[monthly___region]\n OR (\n _base.[monthly___region] IS NULL\n AND _cm_monthly__amount_sum_partition_by_region.[monthly___region] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(_base_2.[monthly___amount_sum] AS FLOAT) / _cm_monthly__amount_sum_partition_by_region.[monthly___amount_sum_partition_by_region] AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON (\n _base_2.[monthly___region] = _cm_monthly__amount_sum_partition_by_region.[monthly___region]\n OR (\n _base_2.[monthly___region] IS NULL\n AND _cm_monthly__amount_sum_partition_by_region.[monthly___region] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_sum] AS [monthly___amount_sum],\n base.[monthly___amount_sum_partition_by_region] AS [monthly___amount_sum_partition_by_region],\n shifted_t.[monthly___shifted] AS [monthly___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[monthly___region] = shifted_t.[monthly___region]\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND shifted_t.[monthly___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_sum],\n [monthly___amount_sum_partition_by_region],\n [monthly___t]\n FROM sjoin_t\n) AS _outer", - "join/two_offsets::bigquery": "WITH _base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_ordered_at`\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _base.`monthly___amount_sum`,\n _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at` AS `monthly___amount_sum_partition_by_ordered_at`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted_t1 AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at`,\n _base_2.`monthly___amount_sum` / _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at` AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), sjoin_t1 AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum`,\n base.`monthly___amount_sum_partition_by_ordered_at`,\n shifted_t1.`monthly___shifted` AS `monthly___t1`\n FROM base\n LEFT JOIN shifted_t1\n ON base.`monthly___region` IS NOT DISTINCT FROM shifted_t1.`monthly___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t1.`monthly___ordered_at` AS TIMESTAMP)\n), sjoin_t2 AS (\n SELECT\n sjoin_t1.`monthly___region`,\n sjoin_t1.`monthly___ordered_at`,\n sjoin_t1.`monthly___amount_sum`,\n sjoin_t1.`monthly___amount_sum_partition_by_ordered_at`,\n sjoin_t1.`monthly___t1`,\n shifted_t1.`monthly___shifted` AS `monthly___t2`\n FROM sjoin_t1\n LEFT JOIN shifted_t1\n ON sjoin_t1.`monthly___region` IS NOT DISTINCT FROM shifted_t1.`monthly___region`\n AND CAST(DATETIME_ADD(\n CAST(CAST(sjoin_t1.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME),\n INTERVAL -2 MONTH\n ) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t1.`monthly___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t1`,\n `monthly___t2`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___amount_sum_partition_by_ordered_at`,\n `monthly___t1`,\n `monthly___t2`\n FROM sjoin_t2\n) AS _outer", - "join/two_offsets::duckdb": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t1 AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _base_2.\"monthly.amount_sum\" / _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin_t1 AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_t1.\"monthly.shifted\" AS \"monthly.t1\"\n FROM base\n LEFT JOIN shifted_t1\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t1.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t1.\"monthly.ordered_at\"\n), sjoin_t2 AS (\n SELECT\n sjoin_t1.\"monthly.region\",\n sjoin_t1.\"monthly.ordered_at\",\n sjoin_t1.\"monthly.amount_sum\",\n sjoin_t1.\"monthly.amount_sum_partition_by_ordered_at\",\n sjoin_t1.\"monthly.t1\",\n shifted_t1.\"monthly.shifted\" AS \"monthly.t2\"\n FROM sjoin_t1\n LEFT JOIN shifted_t1\n ON sjoin_t1.\"monthly.region\" IS NOT DISTINCT FROM shifted_t1.\"monthly.region\"\n AND sjoin_t1.\"monthly.ordered_at\" - INTERVAL 2 MONTH IS NOT DISTINCT FROM shifted_t1.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t1\",\n \"monthly.t2\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.t1\",\n \"monthly.t2\"\n FROM sjoin_t2\n) AS _outer", - "join/two_offsets::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t1 AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS DOUBLE PRECISION) / _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin_t1 AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_t1.\"monthly.shifted\" AS \"monthly.t1\"\n FROM base\n LEFT JOIN shifted_t1\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t1.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t1.\"monthly.ordered_at\"\n), sjoin_t2 AS (\n SELECT\n sjoin_t1.\"monthly.region\",\n sjoin_t1.\"monthly.ordered_at\",\n sjoin_t1.\"monthly.amount_sum\",\n sjoin_t1.\"monthly.amount_sum_partition_by_ordered_at\",\n sjoin_t1.\"monthly.t1\",\n shifted_t1.\"monthly.shifted\" AS \"monthly.t2\"\n FROM sjoin_t1\n LEFT JOIN shifted_t1\n ON sjoin_t1.\"monthly.region\" IS NOT DISTINCT FROM shifted_t1.\"monthly.region\"\n AND sjoin_t1.\"monthly.ordered_at\" - INTERVAL '2 MONTH' IS NOT DISTINCT FROM shifted_t1.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t1\",\n \"monthly.t2\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.t1\",\n \"monthly.t2\"\n FROM sjoin_t2\n) AS _outer", - "join/two_offsets::sqlite": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted_t1 AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS REAL) / _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin_t1 AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_t1.\"monthly.shifted\" AS \"monthly.t1\"\n FROM base\n LEFT JOIN shifted_t1\n ON base.\"monthly.region\" IS shifted_t1.\"monthly.region\"\n AND SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'month') IS shifted_t1.\"monthly.ordered_at\"\n), sjoin_t2 AS (\n SELECT\n sjoin_t1.\"monthly.region\",\n sjoin_t1.\"monthly.ordered_at\",\n sjoin_t1.\"monthly.amount_sum\",\n sjoin_t1.\"monthly.amount_sum_partition_by_ordered_at\",\n sjoin_t1.\"monthly.t1\",\n shifted_t1.\"monthly.shifted\" AS \"monthly.t2\"\n FROM sjoin_t1\n LEFT JOIN shifted_t1\n ON sjoin_t1.\"monthly.region\" IS shifted_t1.\"monthly.region\"\n AND SLAYER_DATE_ADD(sjoin_t1.\"monthly.ordered_at\", -2, 'month') IS shifted_t1.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t1\",\n \"monthly.t2\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.t1\",\n \"monthly.t2\"\n FROM sjoin_t2\n) AS _outer", - "join/two_offsets::tsql": "WITH _base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_ordered_at]\n FROM monthly AS monthly\n GROUP BY\n DATETRUNC(month, monthly.ordered_at)\n), base AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n _base.[monthly___amount_sum] AS [monthly___amount_sum],\n _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at]\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted_t1 AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(_base_2.[monthly___amount_sum] AS FLOAT) / _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base_2.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), sjoin_t1 AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_sum] AS [monthly___amount_sum],\n base.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n shifted_t1.[monthly___shifted] AS [monthly___t1]\n FROM base\n LEFT JOIN shifted_t1\n ON (\n base.[monthly___region] = shifted_t1.[monthly___region]\n OR (\n base.[monthly___region] IS NULL AND shifted_t1.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t1.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND shifted_t1.[monthly___ordered_at] IS NULL\n )\n )\n), sjoin_t2 AS (\n SELECT\n sjoin_t1.[monthly___region] AS [monthly___region],\n sjoin_t1.[monthly___ordered_at] AS [monthly___ordered_at],\n sjoin_t1.[monthly___amount_sum] AS [monthly___amount_sum],\n sjoin_t1.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n sjoin_t1.[monthly___t1] AS [monthly___t1],\n shifted_t1.[monthly___shifted] AS [monthly___t2]\n FROM sjoin_t1\n LEFT JOIN shifted_t1\n ON (\n sjoin_t1.[monthly___region] = shifted_t1.[monthly___region]\n OR (\n sjoin_t1.[monthly___region] IS NULL AND shifted_t1.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -2, sjoin_t1.[monthly___ordered_at]) = shifted_t1.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -2, sjoin_t1.[monthly___ordered_at]) IS NULL\n AND shifted_t1.[monthly___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t1],\n [monthly___t2]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_sum],\n [monthly___amount_sum_partition_by_ordered_at],\n [monthly___t1],\n [monthly___t2]\n FROM sjoin_t2\n) AS _outer", + "frame/non_time_partition::bigquery": "WITH _base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= '2024-02-01 00:00:00'\n AND monthly.ordered_at < '2024-04-01 00:00:00'\n )\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS `monthly___region`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_region`\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= '2024-02-01 00:00:00'\n AND monthly.ordered_at < '2024-04-01 00:00:00'\n )\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _base.`monthly___amount_sum`,\n _cm_monthly__amount_sum_partition_by_region.`monthly___amount_sum_partition_by_region` AS `monthly___amount_sum_partition_by_region`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.`monthly___region`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted_t AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at`,\n _base_2.`monthly___amount_sum` / NULLIF(\n _cm_monthly__amount_sum_partition_by_region.`monthly___amount_sum_partition_by_region`,\n 0\n ) AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base_2.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.`monthly___region`\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum`,\n base.`monthly___amount_sum_partition_by_region`,\n shifted_t.`monthly___shifted` AS `monthly___t`\n FROM base\n LEFT JOIN shifted_t\n ON base.`monthly___region` IS NOT DISTINCT FROM shifted_t.`monthly___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___amount_sum_partition_by_region`,\n `monthly___t`\n FROM sjoin_t\n) AS _outer", + "frame/non_time_partition::duckdb": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND monthly.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND monthly.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _base_2.\"monthly.amount_sum\" / NULLIF(\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", + "frame/non_time_partition::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND monthly.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND monthly.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS DOUBLE PRECISION) / NULLIF(\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", + "frame/non_time_partition::sqlite": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= '2024-02-01' AND monthly.ordered_at < '2024-04-01'\n )\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= '2024-02-01' AND monthly.ordered_at < '2024-04-01'\n )\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base.\"monthly.region\" IS _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS REAL) / NULLIF(\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base_2.\"monthly.region\" IS _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS shifted_t.\"monthly.region\"\n AND SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'month') IS shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", + "frame/non_time_partition::tsql": "WITH _base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= CAST('2024-02-01 00:00:00' AS DATETIME2)\n AND monthly.ordered_at < CAST('2024-04-01 00:00:00' AS DATETIME2)\n )\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS [monthly___region],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_region]\n FROM monthly AS monthly\n WHERE\n (\n monthly.ordered_at >= CAST('2024-02-01 00:00:00' AS DATETIME2)\n AND monthly.ordered_at < CAST('2024-04-01 00:00:00' AS DATETIME2)\n )\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n _base.[monthly___amount_sum] AS [monthly___amount_sum],\n _cm_monthly__amount_sum_partition_by_region.[monthly___amount_sum_partition_by_region] AS [monthly___amount_sum_partition_by_region]\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON (\n _base.[monthly___region] = _cm_monthly__amount_sum_partition_by_region.[monthly___region]\n OR (\n _base.[monthly___region] IS NULL\n AND _cm_monthly__amount_sum_partition_by_region.[monthly___region] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(_base_2.[monthly___amount_sum] AS FLOAT) / NULLIF(\n _cm_monthly__amount_sum_partition_by_region.[monthly___amount_sum_partition_by_region],\n 0\n ) AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON (\n _base_2.[monthly___region] = _cm_monthly__amount_sum_partition_by_region.[monthly___region]\n OR (\n _base_2.[monthly___region] IS NULL\n AND _cm_monthly__amount_sum_partition_by_region.[monthly___region] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_sum] AS [monthly___amount_sum],\n base.[monthly___amount_sum_partition_by_region] AS [monthly___amount_sum_partition_by_region],\n shifted_t.[monthly___shifted] AS [monthly___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[monthly___region] = shifted_t.[monthly___region]\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND shifted_t.[monthly___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_sum],\n [monthly___amount_sum_partition_by_region],\n [monthly___t]\n FROM sjoin_t\n) AS _outer", + "join/two_offsets::bigquery": "WITH _base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_ordered_at`\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _base.`monthly___amount_sum`,\n _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at` AS `monthly___amount_sum_partition_by_ordered_at`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted_t1 AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at`,\n _base_2.`monthly___amount_sum` / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at`,\n 0\n ) AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), sjoin_t1 AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum`,\n base.`monthly___amount_sum_partition_by_ordered_at`,\n shifted_t1.`monthly___shifted` AS `monthly___t1`\n FROM base\n LEFT JOIN shifted_t1\n ON base.`monthly___region` IS NOT DISTINCT FROM shifted_t1.`monthly___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t1.`monthly___ordered_at` AS TIMESTAMP)\n), sjoin_t2 AS (\n SELECT\n sjoin_t1.`monthly___region`,\n sjoin_t1.`monthly___ordered_at`,\n sjoin_t1.`monthly___amount_sum`,\n sjoin_t1.`monthly___amount_sum_partition_by_ordered_at`,\n sjoin_t1.`monthly___t1`,\n shifted_t1.`monthly___shifted` AS `monthly___t2`\n FROM sjoin_t1\n LEFT JOIN shifted_t1\n ON sjoin_t1.`monthly___region` IS NOT DISTINCT FROM shifted_t1.`monthly___region`\n AND CAST(DATETIME_ADD(\n CAST(CAST(sjoin_t1.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME),\n INTERVAL -2 MONTH\n ) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t1.`monthly___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t1`,\n `monthly___t2`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___amount_sum_partition_by_ordered_at`,\n `monthly___t1`,\n `monthly___t2`\n FROM sjoin_t2\n) AS _outer", + "join/two_offsets::duckdb": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t1 AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _base_2.\"monthly.amount_sum\" / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin_t1 AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_t1.\"monthly.shifted\" AS \"monthly.t1\"\n FROM base\n LEFT JOIN shifted_t1\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t1.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t1.\"monthly.ordered_at\"\n), sjoin_t2 AS (\n SELECT\n sjoin_t1.\"monthly.region\",\n sjoin_t1.\"monthly.ordered_at\",\n sjoin_t1.\"monthly.amount_sum\",\n sjoin_t1.\"monthly.amount_sum_partition_by_ordered_at\",\n sjoin_t1.\"monthly.t1\",\n shifted_t1.\"monthly.shifted\" AS \"monthly.t2\"\n FROM sjoin_t1\n LEFT JOIN shifted_t1\n ON sjoin_t1.\"monthly.region\" IS NOT DISTINCT FROM shifted_t1.\"monthly.region\"\n AND sjoin_t1.\"monthly.ordered_at\" - INTERVAL 2 MONTH IS NOT DISTINCT FROM shifted_t1.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t1\",\n \"monthly.t2\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.t1\",\n \"monthly.t2\"\n FROM sjoin_t2\n) AS _outer", + "join/two_offsets::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t1 AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS DOUBLE PRECISION) / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin_t1 AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_t1.\"monthly.shifted\" AS \"monthly.t1\"\n FROM base\n LEFT JOIN shifted_t1\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t1.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t1.\"monthly.ordered_at\"\n), sjoin_t2 AS (\n SELECT\n sjoin_t1.\"monthly.region\",\n sjoin_t1.\"monthly.ordered_at\",\n sjoin_t1.\"monthly.amount_sum\",\n sjoin_t1.\"monthly.amount_sum_partition_by_ordered_at\",\n sjoin_t1.\"monthly.t1\",\n shifted_t1.\"monthly.shifted\" AS \"monthly.t2\"\n FROM sjoin_t1\n LEFT JOIN shifted_t1\n ON sjoin_t1.\"monthly.region\" IS NOT DISTINCT FROM shifted_t1.\"monthly.region\"\n AND sjoin_t1.\"monthly.ordered_at\" - INTERVAL '2 MONTH' IS NOT DISTINCT FROM shifted_t1.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t1\",\n \"monthly.t2\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.t1\",\n \"monthly.t2\"\n FROM sjoin_t2\n) AS _outer", + "join/two_offsets::sqlite": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted_t1 AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS REAL) / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin_t1 AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_t1.\"monthly.shifted\" AS \"monthly.t1\"\n FROM base\n LEFT JOIN shifted_t1\n ON base.\"monthly.region\" IS shifted_t1.\"monthly.region\"\n AND SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'month') IS shifted_t1.\"monthly.ordered_at\"\n), sjoin_t2 AS (\n SELECT\n sjoin_t1.\"monthly.region\",\n sjoin_t1.\"monthly.ordered_at\",\n sjoin_t1.\"monthly.amount_sum\",\n sjoin_t1.\"monthly.amount_sum_partition_by_ordered_at\",\n sjoin_t1.\"monthly.t1\",\n shifted_t1.\"monthly.shifted\" AS \"monthly.t2\"\n FROM sjoin_t1\n LEFT JOIN shifted_t1\n ON sjoin_t1.\"monthly.region\" IS shifted_t1.\"monthly.region\"\n AND SLAYER_DATE_ADD(sjoin_t1.\"monthly.ordered_at\", -2, 'month') IS shifted_t1.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t1\",\n \"monthly.t2\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.t1\",\n \"monthly.t2\"\n FROM sjoin_t2\n) AS _outer", + "join/two_offsets::tsql": "WITH _base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_ordered_at]\n FROM monthly AS monthly\n GROUP BY\n DATETRUNC(month, monthly.ordered_at)\n), base AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n _base.[monthly___amount_sum] AS [monthly___amount_sum],\n _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at]\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted_t1 AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(_base_2.[monthly___amount_sum] AS FLOAT) / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at],\n 0\n ) AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base_2.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), sjoin_t1 AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_sum] AS [monthly___amount_sum],\n base.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n shifted_t1.[monthly___shifted] AS [monthly___t1]\n FROM base\n LEFT JOIN shifted_t1\n ON (\n base.[monthly___region] = shifted_t1.[monthly___region]\n OR (\n base.[monthly___region] IS NULL AND shifted_t1.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t1.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND shifted_t1.[monthly___ordered_at] IS NULL\n )\n )\n), sjoin_t2 AS (\n SELECT\n sjoin_t1.[monthly___region] AS [monthly___region],\n sjoin_t1.[monthly___ordered_at] AS [monthly___ordered_at],\n sjoin_t1.[monthly___amount_sum] AS [monthly___amount_sum],\n sjoin_t1.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n sjoin_t1.[monthly___t1] AS [monthly___t1],\n shifted_t1.[monthly___shifted] AS [monthly___t2]\n FROM sjoin_t1\n LEFT JOIN shifted_t1\n ON (\n sjoin_t1.[monthly___region] = shifted_t1.[monthly___region]\n OR (\n sjoin_t1.[monthly___region] IS NULL AND shifted_t1.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -2, sjoin_t1.[monthly___ordered_at]) = shifted_t1.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -2, sjoin_t1.[monthly___ordered_at]) IS NULL\n AND shifted_t1.[monthly___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t1],\n [monthly___t2]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_sum],\n [monthly___amount_sum_partition_by_ordered_at],\n [monthly___t1],\n [monthly___t2]\n FROM sjoin_t2\n) AS _outer", "join/unaligned_day::bigquery": "WITH base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted_t AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum`,\n shifted_t.`monthly___amount_sum` AS `monthly___t`\n FROM base\n LEFT JOIN shifted_t\n ON base.`monthly___region` IS NOT DISTINCT FROM shifted_t.`monthly___region`\n AND CAST(DATE_TRUNC(\n CAST(TIMESTAMP_ADD(CAST(base.`monthly___ordered_at` AS TIMESTAMP), INTERVAL -1 DAY) AS DATETIME),\n MONTH\n ) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___t`\n FROM sjoin_t\n) AS _outer", "join/unaligned_day::duckdb": "WITH base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n shifted_t.\"monthly.amount_sum\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND DATE_TRUNC('MONTH', CAST(base.\"monthly.ordered_at\" - INTERVAL 1 DAY AS TIMESTAMP)) IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "join/unaligned_day::postgres": "WITH base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n shifted_t.\"monthly.amount_sum\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND DATE_TRUNC('MONTH', CAST(base.\"monthly.ordered_at\" - INTERVAL '1 DAY' AS TIMESTAMP)) IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "join/unaligned_day::sqlite": "WITH base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n shifted_t.\"monthly.amount_sum\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS shifted_t.\"monthly.region\"\n AND STRFTIME('%Y-%m-01', SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'day')) IS shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "join/unaligned_day::tsql": "WITH base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted_t AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), sjoin_t AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_sum] AS [monthly___amount_sum],\n shifted_t.[monthly___amount_sum] AS [monthly___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[monthly___region] = shifted_t.[monthly___region]\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n DATETRUNC(month, CAST(DATEADD(DAY, -1, base.[monthly___ordered_at]) AS DATETIME2)) = shifted_t.[monthly___ordered_at]\n OR (\n DATETRUNC(month, CAST(DATEADD(DAY, -1, base.[monthly___ordered_at]) AS DATETIME2)) IS NULL\n AND shifted_t.[monthly___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_sum],\n [monthly___t]\n FROM sjoin_t\n) AS _outer", - "leaf/carried_degenerate::bigquery": "WITH _base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_amount_sum_partition_by_region AS (\n SELECT\n _stage_inner.`monthly___region` AS `region`,\n _stage_inner.`monthly___amount_sum_partition_by_region` AS `amount_sum_partition_by_region`\n FROM (\n SELECT\n monthly.region AS `monthly___region`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_region`\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n ) AS _stage_inner\n), _cm_monthly___max_partition_by_region AS (\n SELECT\n _base.`monthly___region` AS `monthly___region`,\n MAX(_base._v) AS `monthly___max_amount_sum_partition_by_region`\n FROM (\n SELECT\n monthly.region AS `monthly___region`,\n monthly.region AS _ek0,\n MAX(_cm_amount_sum_partition_by_region.`amount_sum_partition_by_region`) AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_amount_sum_partition_by_region\n ON monthly.region IS NOT DISTINCT FROM _cm_amount_sum_partition_by_region.`region`\n GROUP BY\n monthly.region,\n monthly.region\n ) AS _base\n GROUP BY\n _base.`monthly___region`\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _base.`monthly___amount_sum`,\n _cm_monthly___max_partition_by_region.`monthly___max_amount_sum_partition_by_region` AS `monthly___max_amount_sum_partition_by_region`\n FROM _base\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON _base.`monthly___region` IS NOT DISTINCT FROM _cm_monthly___max_partition_by_region.`monthly___region`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted_t AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at`,\n _base_2.`monthly___amount_sum` / _cm_monthly___max_partition_by_region.`monthly___max_amount_sum_partition_by_region` AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON _base_2.`monthly___region` IS NOT DISTINCT FROM _cm_monthly___max_partition_by_region.`monthly___region`\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum`,\n base.`monthly___max_amount_sum_partition_by_region`,\n shifted_t.`monthly___shifted` AS `monthly___t`\n FROM base\n LEFT JOIN shifted_t\n ON base.`monthly___region` IS NOT DISTINCT FROM shifted_t.`monthly___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___max_amount_sum_partition_by_region`,\n `monthly___t`\n FROM sjoin_t\n) AS _outer", - "leaf/carried_degenerate::duckdb": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_amount_sum_partition_by_region AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.amount_sum_partition_by_region\" AS \"amount_sum_partition_by_region\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n ) AS _stage_inner\n), _cm_monthly___max_partition_by_region AS (\n SELECT\n _base.\"monthly.region\" AS \"monthly.region\",\n MAX(_base._v) AS \"monthly.max_amount_sum_partition_by_region\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n monthly.region AS _ek0,\n MAX(_cm_amount_sum_partition_by_region.\"amount_sum_partition_by_region\") AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_amount_sum_partition_by_region\n ON monthly.region IS NOT DISTINCT FROM _cm_amount_sum_partition_by_region.\"region\"\n GROUP BY\n monthly.region,\n monthly.region\n ) AS _base\n GROUP BY\n _base.\"monthly.region\"\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly___max_partition_by_region.\"monthly.max_amount_sum_partition_by_region\" AS \"monthly.max_amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly___max_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _base_2.\"monthly.amount_sum\" / _cm_monthly___max_partition_by_region.\"monthly.max_amount_sum_partition_by_region\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly___max_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.max_amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.max_amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", - "leaf/carried_degenerate::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_amount_sum_partition_by_region AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.amount_sum_partition_by_region\" AS \"amount_sum_partition_by_region\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n ) AS _stage_inner\n), _cm_monthly___max_partition_by_region AS (\n SELECT\n _base.\"monthly.region\" AS \"monthly.region\",\n MAX(_base._v) AS \"monthly.max_amount_sum_partition_by_region\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n monthly.region AS _ek0,\n MAX(_cm_amount_sum_partition_by_region.\"amount_sum_partition_by_region\") AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_amount_sum_partition_by_region\n ON monthly.region IS NOT DISTINCT FROM _cm_amount_sum_partition_by_region.\"region\"\n GROUP BY\n monthly.region,\n monthly.region\n ) AS _base\n GROUP BY\n _base.\"monthly.region\"\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly___max_partition_by_region.\"monthly.max_amount_sum_partition_by_region\" AS \"monthly.max_amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly___max_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS DOUBLE PRECISION) / _cm_monthly___max_partition_by_region.\"monthly.max_amount_sum_partition_by_region\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly___max_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.max_amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.max_amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", - "leaf/carried_degenerate::sqlite": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_amount_sum_partition_by_region AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.amount_sum_partition_by_region\" AS \"amount_sum_partition_by_region\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n ) AS _stage_inner\n), _cm_monthly___max_partition_by_region AS (\n SELECT\n _base.\"monthly.region\" AS \"monthly.region\",\n MAX(_base._v) AS \"monthly.max_amount_sum_partition_by_region\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n monthly.region AS _ek0,\n MAX(_cm_amount_sum_partition_by_region.\"amount_sum_partition_by_region\") AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_amount_sum_partition_by_region\n ON monthly.region IS _cm_amount_sum_partition_by_region.\"region\"\n GROUP BY\n monthly.region,\n monthly.region\n ) AS _base\n GROUP BY\n _base.\"monthly.region\"\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly___max_partition_by_region.\"monthly.max_amount_sum_partition_by_region\" AS \"monthly.max_amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON _base.\"monthly.region\" IS _cm_monthly___max_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS REAL) / _cm_monthly___max_partition_by_region.\"monthly.max_amount_sum_partition_by_region\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON _base_2.\"monthly.region\" IS _cm_monthly___max_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.max_amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS shifted_t.\"monthly.region\"\n AND SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'month') IS shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.max_amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", - "leaf/carried_degenerate::tsql": "WITH _base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_amount_sum_partition_by_region AS (\n SELECT\n _stage_inner.[monthly___region] AS [region],\n _stage_inner.[monthly___amount_sum_partition_by_region] AS [amount_sum_partition_by_region]\n FROM (\n SELECT\n monthly.region AS [monthly___region],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_region]\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n ) AS _stage_inner\n), _cm_monthly___max_partition_by_region AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n MAX(_base._v) AS [monthly___max_amount_sum_partition_by_region]\n FROM (\n SELECT\n monthly.region AS [monthly___region],\n monthly.region AS _ek0,\n MAX(_cm_amount_sum_partition_by_region.[amount_sum_partition_by_region]) AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_amount_sum_partition_by_region\n ON (\n monthly.region = _cm_amount_sum_partition_by_region.[region]\n OR (\n monthly.region IS NULL AND _cm_amount_sum_partition_by_region.[region] IS NULL\n )\n )\n GROUP BY\n monthly.region,\n monthly.region\n ) AS _base\n GROUP BY\n _base.[monthly___region]\n), base AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n _base.[monthly___amount_sum] AS [monthly___amount_sum],\n _cm_monthly___max_partition_by_region.[monthly___max_amount_sum_partition_by_region] AS [monthly___max_amount_sum_partition_by_region]\n FROM _base\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON (\n _base.[monthly___region] = _cm_monthly___max_partition_by_region.[monthly___region]\n OR (\n _base.[monthly___region] IS NULL\n AND _cm_monthly___max_partition_by_region.[monthly___region] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(_base_2.[monthly___amount_sum] AS FLOAT) / _cm_monthly___max_partition_by_region.[monthly___max_amount_sum_partition_by_region] AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON (\n _base_2.[monthly___region] = _cm_monthly___max_partition_by_region.[monthly___region]\n OR (\n _base_2.[monthly___region] IS NULL\n AND _cm_monthly___max_partition_by_region.[monthly___region] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_sum] AS [monthly___amount_sum],\n base.[monthly___max_amount_sum_partition_by_region] AS [monthly___max_amount_sum_partition_by_region],\n shifted_t.[monthly___shifted] AS [monthly___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[monthly___region] = shifted_t.[monthly___region]\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND shifted_t.[monthly___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_sum],\n [monthly___max_amount_sum_partition_by_region],\n [monthly___t]\n FROM sjoin_t\n) AS _outer", - "leaf/change::bigquery": "WITH _base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_ordered_at`\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _base.`monthly___amount_sum`,\n _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at` AS `monthly___amount_sum_partition_by_ordered_at`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at`,\n _base_2.`monthly___amount_sum` / _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at` AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), sjoin__time_shift_inner AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum`,\n base.`monthly___amount_sum_partition_by_ordered_at`,\n shifted__time_shift_inner.`monthly___shifted` AS `monthly____time_shift_inner`\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.`monthly___region` IS NOT DISTINCT FROM shifted__time_shift_inner.`monthly___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`monthly___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___amount_sum_partition_by_ordered_at`,\n `monthly____time_shift_inner`,\n `monthly___amount_sum` / `monthly___amount_sum_partition_by_ordered_at` - `monthly____time_shift_inner` AS `monthly___t`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___amount_sum_partition_by_ordered_at`,\n `monthly____time_shift_inner`,\n `monthly___t`\n FROM step1\n) AS _outer", - "leaf/change::duckdb": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _base_2.\"monthly.amount_sum\" / _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted__time_shift_inner.\"monthly.shifted\" AS \"monthly._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner.\"monthly.ordered_at\"\n), step1 AS (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n \"monthly.amount_sum\" / \"monthly.amount_sum_partition_by_ordered_at\" - \"monthly._time_shift_inner\" AS \"monthly.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n \"monthly.t\"\n FROM step1\n) AS _outer", - "leaf/change::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS DOUBLE PRECISION) / _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted__time_shift_inner.\"monthly.shifted\" AS \"monthly._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"monthly.ordered_at\"\n), step1 AS (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n CAST(\"monthly.amount_sum\" AS DOUBLE PRECISION) / \"monthly.amount_sum_partition_by_ordered_at\" - \"monthly._time_shift_inner\" AS \"monthly.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n \"monthly.t\"\n FROM step1\n) AS _outer", - "leaf/change::sqlite": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS REAL) / _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted__time_shift_inner.\"monthly.shifted\" AS \"monthly._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"monthly.region\" IS shifted__time_shift_inner.\"monthly.region\"\n AND SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"monthly.ordered_at\"\n), step1 AS (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n CAST(\"monthly.amount_sum\" AS REAL) / \"monthly.amount_sum_partition_by_ordered_at\" - \"monthly._time_shift_inner\" AS \"monthly.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n \"monthly.t\"\n FROM step1\n) AS _outer", - "leaf/change::tsql": "WITH _base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_ordered_at]\n FROM monthly AS monthly\n GROUP BY\n DATETRUNC(month, monthly.ordered_at)\n), base AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n _base.[monthly___amount_sum] AS [monthly___amount_sum],\n _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at]\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(_base_2.[monthly___amount_sum] AS FLOAT) / _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base_2.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), sjoin__time_shift_inner AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_sum] AS [monthly___amount_sum],\n base.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n shifted__time_shift_inner.[monthly___shifted] AS [monthly____time_shift_inner]\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON (\n base.[monthly___region] = shifted__time_shift_inner.[monthly___region]\n OR (\n base.[monthly___region] IS NULL\n AND shifted__time_shift_inner.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted__time_shift_inner.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND shifted__time_shift_inner.[monthly___ordered_at] IS NULL\n )\n )\n), step1 AS (\n SELECT\n [monthly___region] AS [monthly___region],\n [monthly___ordered_at] AS [monthly___ordered_at],\n [monthly___amount_sum] AS [monthly___amount_sum],\n [monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n [monthly____time_shift_inner] AS [monthly____time_shift_inner],\n CAST([monthly___amount_sum] AS FLOAT) / [monthly___amount_sum_partition_by_ordered_at] - [monthly____time_shift_inner] AS [monthly___t]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_sum],\n [monthly___amount_sum_partition_by_ordered_at],\n [monthly____time_shift_inner],\n [monthly___t]\n FROM step1\n) AS _outer", - "leaf/change_pct::bigquery": "WITH _base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_ordered_at`\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _base.`monthly___amount_sum`,\n _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at` AS `monthly___amount_sum_partition_by_ordered_at`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at`,\n _base_2.`monthly___amount_sum` / _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at` AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), sjoin__time_shift_inner AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum`,\n base.`monthly___amount_sum_partition_by_ordered_at`,\n shifted__time_shift_inner.`monthly___shifted` AS `monthly____time_shift_inner`\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.`monthly___region` IS NOT DISTINCT FROM shifted__time_shift_inner.`monthly___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`monthly___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___amount_sum_partition_by_ordered_at`,\n `monthly____time_shift_inner`,\n (\n `monthly___amount_sum` / `monthly___amount_sum_partition_by_ordered_at` - `monthly____time_shift_inner`\n ) / NULLIF(`monthly____time_shift_inner`, 0) AS `monthly___t`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___amount_sum_partition_by_ordered_at`,\n `monthly____time_shift_inner`,\n `monthly___t`\n FROM step1\n) AS _outer", - "leaf/change_pct::duckdb": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _base_2.\"monthly.amount_sum\" / _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted__time_shift_inner.\"monthly.shifted\" AS \"monthly._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner.\"monthly.ordered_at\"\n), step1 AS (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n (\n \"monthly.amount_sum\" / \"monthly.amount_sum_partition_by_ordered_at\" - \"monthly._time_shift_inner\"\n ) / NULLIF(\"monthly._time_shift_inner\", 0) AS \"monthly.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n \"monthly.t\"\n FROM step1\n) AS _outer", - "leaf/change_pct::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS DOUBLE PRECISION) / _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted__time_shift_inner.\"monthly.shifted\" AS \"monthly._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"monthly.ordered_at\"\n), step1 AS (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n CAST((\n CAST(\"monthly.amount_sum\" AS DOUBLE PRECISION) / \"monthly.amount_sum_partition_by_ordered_at\" - \"monthly._time_shift_inner\"\n ) AS DOUBLE PRECISION) / NULLIF(\"monthly._time_shift_inner\", 0) AS \"monthly.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n \"monthly.t\"\n FROM step1\n) AS _outer", - "leaf/change_pct::sqlite": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS REAL) / _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted__time_shift_inner.\"monthly.shifted\" AS \"monthly._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"monthly.region\" IS shifted__time_shift_inner.\"monthly.region\"\n AND SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"monthly.ordered_at\"\n), step1 AS (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n CAST((\n CAST(\"monthly.amount_sum\" AS REAL) / \"monthly.amount_sum_partition_by_ordered_at\" - \"monthly._time_shift_inner\"\n ) AS REAL) / NULLIF(\"monthly._time_shift_inner\", 0) AS \"monthly.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n \"monthly.t\"\n FROM step1\n) AS _outer", - "leaf/change_pct::tsql": "WITH _base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_ordered_at]\n FROM monthly AS monthly\n GROUP BY\n DATETRUNC(month, monthly.ordered_at)\n), base AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n _base.[monthly___amount_sum] AS [monthly___amount_sum],\n _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at]\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(_base_2.[monthly___amount_sum] AS FLOAT) / _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base_2.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), sjoin__time_shift_inner AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_sum] AS [monthly___amount_sum],\n base.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n shifted__time_shift_inner.[monthly___shifted] AS [monthly____time_shift_inner]\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON (\n base.[monthly___region] = shifted__time_shift_inner.[monthly___region]\n OR (\n base.[monthly___region] IS NULL\n AND shifted__time_shift_inner.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted__time_shift_inner.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND shifted__time_shift_inner.[monthly___ordered_at] IS NULL\n )\n )\n), step1 AS (\n SELECT\n [monthly___region] AS [monthly___region],\n [monthly___ordered_at] AS [monthly___ordered_at],\n [monthly___amount_sum] AS [monthly___amount_sum],\n [monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n [monthly____time_shift_inner] AS [monthly____time_shift_inner],\n CAST((\n CAST([monthly___amount_sum] AS FLOAT) / [monthly___amount_sum_partition_by_ordered_at] - [monthly____time_shift_inner]\n ) AS FLOAT) / NULLIF([monthly____time_shift_inner], 0) AS [monthly___t]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_sum],\n [monthly___amount_sum_partition_by_ordered_at],\n [monthly____time_shift_inner],\n [monthly___t]\n FROM step1\n) AS _outer", - "leaf/non_time_partition::bigquery": "WITH _base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS `monthly___region`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_region`\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _base.`monthly___amount_sum`,\n _cm_monthly__amount_sum_partition_by_region.`monthly___amount_sum_partition_by_region` AS `monthly___amount_sum_partition_by_region`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.`monthly___region`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted_t AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at`,\n _base_2.`monthly___amount_sum` / _cm_monthly__amount_sum_partition_by_region.`monthly___amount_sum_partition_by_region` AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base_2.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.`monthly___region`\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum`,\n base.`monthly___amount_sum_partition_by_region`,\n shifted_t.`monthly___shifted` AS `monthly___t`\n FROM base\n LEFT JOIN shifted_t\n ON base.`monthly___region` IS NOT DISTINCT FROM shifted_t.`monthly___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___amount_sum_partition_by_region`,\n `monthly___t`\n FROM sjoin_t\n) AS _outer", - "leaf/non_time_partition::duckdb": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _base_2.\"monthly.amount_sum\" / _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", - "leaf/non_time_partition::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS DOUBLE PRECISION) / _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", - "leaf/non_time_partition::sqlite": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base.\"monthly.region\" IS _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS REAL) / _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base_2.\"monthly.region\" IS _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS shifted_t.\"monthly.region\"\n AND SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'month') IS shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", - "leaf/non_time_partition::tsql": "WITH _base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS [monthly___region],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_region]\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n _base.[monthly___amount_sum] AS [monthly___amount_sum],\n _cm_monthly__amount_sum_partition_by_region.[monthly___amount_sum_partition_by_region] AS [monthly___amount_sum_partition_by_region]\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON (\n _base.[monthly___region] = _cm_monthly__amount_sum_partition_by_region.[monthly___region]\n OR (\n _base.[monthly___region] IS NULL\n AND _cm_monthly__amount_sum_partition_by_region.[monthly___region] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(_base_2.[monthly___amount_sum] AS FLOAT) / _cm_monthly__amount_sum_partition_by_region.[monthly___amount_sum_partition_by_region] AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON (\n _base_2.[monthly___region] = _cm_monthly__amount_sum_partition_by_region.[monthly___region]\n OR (\n _base_2.[monthly___region] IS NULL\n AND _cm_monthly__amount_sum_partition_by_region.[monthly___region] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_sum] AS [monthly___amount_sum],\n base.[monthly___amount_sum_partition_by_region] AS [monthly___amount_sum_partition_by_region],\n shifted_t.[monthly___shifted] AS [monthly___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[monthly___region] = shifted_t.[monthly___region]\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND shifted_t.[monthly___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_sum],\n [monthly___amount_sum_partition_by_region],\n [monthly___t]\n FROM sjoin_t\n) AS _outer", + "leaf/carried_degenerate::bigquery": "WITH _base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_amount_sum_partition_by_region AS (\n SELECT\n _stage_inner.`monthly___region` AS `region`,\n _stage_inner.`monthly___amount_sum_partition_by_region` AS `amount_sum_partition_by_region`\n FROM (\n SELECT\n monthly.region AS `monthly___region`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_region`\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n ) AS _stage_inner\n), _cm_monthly___max_partition_by_region AS (\n SELECT\n _base.`monthly___region` AS `monthly___region`,\n MAX(_base._v) AS `monthly___max_amount_sum_partition_by_region`\n FROM (\n SELECT\n monthly.region AS `monthly___region`,\n monthly.region AS _ek0,\n MAX(_cm_amount_sum_partition_by_region.`amount_sum_partition_by_region`) AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_amount_sum_partition_by_region\n ON monthly.region IS NOT DISTINCT FROM _cm_amount_sum_partition_by_region.`region`\n GROUP BY\n monthly.region,\n monthly.region\n ) AS _base\n GROUP BY\n _base.`monthly___region`\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _base.`monthly___amount_sum`,\n _cm_monthly___max_partition_by_region.`monthly___max_amount_sum_partition_by_region` AS `monthly___max_amount_sum_partition_by_region`\n FROM _base\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON _base.`monthly___region` IS NOT DISTINCT FROM _cm_monthly___max_partition_by_region.`monthly___region`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted_t AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at`,\n _base_2.`monthly___amount_sum` / NULLIF(\n _cm_monthly___max_partition_by_region.`monthly___max_amount_sum_partition_by_region`,\n 0\n ) AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON _base_2.`monthly___region` IS NOT DISTINCT FROM _cm_monthly___max_partition_by_region.`monthly___region`\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum`,\n base.`monthly___max_amount_sum_partition_by_region`,\n shifted_t.`monthly___shifted` AS `monthly___t`\n FROM base\n LEFT JOIN shifted_t\n ON base.`monthly___region` IS NOT DISTINCT FROM shifted_t.`monthly___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___max_amount_sum_partition_by_region`,\n `monthly___t`\n FROM sjoin_t\n) AS _outer", + "leaf/carried_degenerate::duckdb": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_amount_sum_partition_by_region AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.amount_sum_partition_by_region\" AS \"amount_sum_partition_by_region\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n ) AS _stage_inner\n), _cm_monthly___max_partition_by_region AS (\n SELECT\n _base.\"monthly.region\" AS \"monthly.region\",\n MAX(_base._v) AS \"monthly.max_amount_sum_partition_by_region\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n monthly.region AS _ek0,\n MAX(_cm_amount_sum_partition_by_region.\"amount_sum_partition_by_region\") AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_amount_sum_partition_by_region\n ON monthly.region IS NOT DISTINCT FROM _cm_amount_sum_partition_by_region.\"region\"\n GROUP BY\n monthly.region,\n monthly.region\n ) AS _base\n GROUP BY\n _base.\"monthly.region\"\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly___max_partition_by_region.\"monthly.max_amount_sum_partition_by_region\" AS \"monthly.max_amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly___max_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _base_2.\"monthly.amount_sum\" / NULLIF(\n _cm_monthly___max_partition_by_region.\"monthly.max_amount_sum_partition_by_region\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly___max_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.max_amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.max_amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", + "leaf/carried_degenerate::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_amount_sum_partition_by_region AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.amount_sum_partition_by_region\" AS \"amount_sum_partition_by_region\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n ) AS _stage_inner\n), _cm_monthly___max_partition_by_region AS (\n SELECT\n _base.\"monthly.region\" AS \"monthly.region\",\n MAX(_base._v) AS \"monthly.max_amount_sum_partition_by_region\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n monthly.region AS _ek0,\n MAX(_cm_amount_sum_partition_by_region.\"amount_sum_partition_by_region\") AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_amount_sum_partition_by_region\n ON monthly.region IS NOT DISTINCT FROM _cm_amount_sum_partition_by_region.\"region\"\n GROUP BY\n monthly.region,\n monthly.region\n ) AS _base\n GROUP BY\n _base.\"monthly.region\"\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly___max_partition_by_region.\"monthly.max_amount_sum_partition_by_region\" AS \"monthly.max_amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly___max_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS DOUBLE PRECISION) / NULLIF(\n _cm_monthly___max_partition_by_region.\"monthly.max_amount_sum_partition_by_region\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly___max_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.max_amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.max_amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", + "leaf/carried_degenerate::sqlite": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_amount_sum_partition_by_region AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.amount_sum_partition_by_region\" AS \"amount_sum_partition_by_region\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n ) AS _stage_inner\n), _cm_monthly___max_partition_by_region AS (\n SELECT\n _base.\"monthly.region\" AS \"monthly.region\",\n MAX(_base._v) AS \"monthly.max_amount_sum_partition_by_region\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n monthly.region AS _ek0,\n MAX(_cm_amount_sum_partition_by_region.\"amount_sum_partition_by_region\") AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_amount_sum_partition_by_region\n ON monthly.region IS _cm_amount_sum_partition_by_region.\"region\"\n GROUP BY\n monthly.region,\n monthly.region\n ) AS _base\n GROUP BY\n _base.\"monthly.region\"\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly___max_partition_by_region.\"monthly.max_amount_sum_partition_by_region\" AS \"monthly.max_amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON _base.\"monthly.region\" IS _cm_monthly___max_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS REAL) / NULLIF(\n _cm_monthly___max_partition_by_region.\"monthly.max_amount_sum_partition_by_region\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON _base_2.\"monthly.region\" IS _cm_monthly___max_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.max_amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS shifted_t.\"monthly.region\"\n AND SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'month') IS shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.max_amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", + "leaf/carried_degenerate::tsql": "WITH _base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_amount_sum_partition_by_region AS (\n SELECT\n _stage_inner.[monthly___region] AS [region],\n _stage_inner.[monthly___amount_sum_partition_by_region] AS [amount_sum_partition_by_region]\n FROM (\n SELECT\n monthly.region AS [monthly___region],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_region]\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n ) AS _stage_inner\n), _cm_monthly___max_partition_by_region AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n MAX(_base._v) AS [monthly___max_amount_sum_partition_by_region]\n FROM (\n SELECT\n monthly.region AS [monthly___region],\n monthly.region AS _ek0,\n MAX(_cm_amount_sum_partition_by_region.[amount_sum_partition_by_region]) AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_amount_sum_partition_by_region\n ON (\n monthly.region = _cm_amount_sum_partition_by_region.[region]\n OR (\n monthly.region IS NULL AND _cm_amount_sum_partition_by_region.[region] IS NULL\n )\n )\n GROUP BY\n monthly.region,\n monthly.region\n ) AS _base\n GROUP BY\n _base.[monthly___region]\n), base AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n _base.[monthly___amount_sum] AS [monthly___amount_sum],\n _cm_monthly___max_partition_by_region.[monthly___max_amount_sum_partition_by_region] AS [monthly___max_amount_sum_partition_by_region]\n FROM _base\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON (\n _base.[monthly___region] = _cm_monthly___max_partition_by_region.[monthly___region]\n OR (\n _base.[monthly___region] IS NULL\n AND _cm_monthly___max_partition_by_region.[monthly___region] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(_base_2.[monthly___amount_sum] AS FLOAT) / NULLIF(\n _cm_monthly___max_partition_by_region.[monthly___max_amount_sum_partition_by_region],\n 0\n ) AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly___max_partition_by_region\n ON (\n _base_2.[monthly___region] = _cm_monthly___max_partition_by_region.[monthly___region]\n OR (\n _base_2.[monthly___region] IS NULL\n AND _cm_monthly___max_partition_by_region.[monthly___region] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_sum] AS [monthly___amount_sum],\n base.[monthly___max_amount_sum_partition_by_region] AS [monthly___max_amount_sum_partition_by_region],\n shifted_t.[monthly___shifted] AS [monthly___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[monthly___region] = shifted_t.[monthly___region]\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND shifted_t.[monthly___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_sum],\n [monthly___max_amount_sum_partition_by_region],\n [monthly___t]\n FROM sjoin_t\n) AS _outer", + "leaf/change::bigquery": "WITH _base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_ordered_at`\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _base.`monthly___amount_sum`,\n _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at` AS `monthly___amount_sum_partition_by_ordered_at`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at`,\n _base_2.`monthly___amount_sum` / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at`,\n 0\n ) AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), sjoin__time_shift_inner AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum`,\n base.`monthly___amount_sum_partition_by_ordered_at`,\n shifted__time_shift_inner.`monthly___shifted` AS `monthly____time_shift_inner`\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.`monthly___region` IS NOT DISTINCT FROM shifted__time_shift_inner.`monthly___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`monthly___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___amount_sum_partition_by_ordered_at`,\n `monthly____time_shift_inner`,\n `monthly___amount_sum` / NULLIF(`monthly___amount_sum_partition_by_ordered_at`, 0) - `monthly____time_shift_inner` AS `monthly___t`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___amount_sum_partition_by_ordered_at`,\n `monthly____time_shift_inner`,\n `monthly___t`\n FROM step1\n) AS _outer", + "leaf/change::duckdb": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _base_2.\"monthly.amount_sum\" / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted__time_shift_inner.\"monthly.shifted\" AS \"monthly._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner.\"monthly.ordered_at\"\n), step1 AS (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n \"monthly.amount_sum\" / NULLIF(\"monthly.amount_sum_partition_by_ordered_at\", 0) - \"monthly._time_shift_inner\" AS \"monthly.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n \"monthly.t\"\n FROM step1\n) AS _outer", + "leaf/change::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS DOUBLE PRECISION) / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted__time_shift_inner.\"monthly.shifted\" AS \"monthly._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"monthly.ordered_at\"\n), step1 AS (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n CAST(\"monthly.amount_sum\" AS DOUBLE PRECISION) / NULLIF(\"monthly.amount_sum_partition_by_ordered_at\", 0) - \"monthly._time_shift_inner\" AS \"monthly.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n \"monthly.t\"\n FROM step1\n) AS _outer", + "leaf/change::sqlite": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS REAL) / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted__time_shift_inner.\"monthly.shifted\" AS \"monthly._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"monthly.region\" IS shifted__time_shift_inner.\"monthly.region\"\n AND SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"monthly.ordered_at\"\n), step1 AS (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n CAST(\"monthly.amount_sum\" AS REAL) / NULLIF(\"monthly.amount_sum_partition_by_ordered_at\", 0) - \"monthly._time_shift_inner\" AS \"monthly.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n \"monthly.t\"\n FROM step1\n) AS _outer", + "leaf/change::tsql": "WITH _base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_ordered_at]\n FROM monthly AS monthly\n GROUP BY\n DATETRUNC(month, monthly.ordered_at)\n), base AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n _base.[monthly___amount_sum] AS [monthly___amount_sum],\n _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at]\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(_base_2.[monthly___amount_sum] AS FLOAT) / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at],\n 0\n ) AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base_2.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), sjoin__time_shift_inner AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_sum] AS [monthly___amount_sum],\n base.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n shifted__time_shift_inner.[monthly___shifted] AS [monthly____time_shift_inner]\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON (\n base.[monthly___region] = shifted__time_shift_inner.[monthly___region]\n OR (\n base.[monthly___region] IS NULL\n AND shifted__time_shift_inner.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted__time_shift_inner.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND shifted__time_shift_inner.[monthly___ordered_at] IS NULL\n )\n )\n), step1 AS (\n SELECT\n [monthly___region] AS [monthly___region],\n [monthly___ordered_at] AS [monthly___ordered_at],\n [monthly___amount_sum] AS [monthly___amount_sum],\n [monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n [monthly____time_shift_inner] AS [monthly____time_shift_inner],\n CAST([monthly___amount_sum] AS FLOAT) / NULLIF([monthly___amount_sum_partition_by_ordered_at], 0) - [monthly____time_shift_inner] AS [monthly___t]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_sum],\n [monthly___amount_sum_partition_by_ordered_at],\n [monthly____time_shift_inner],\n [monthly___t]\n FROM step1\n) AS _outer", + "leaf/change_pct::bigquery": "WITH _base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_ordered_at`\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _base.`monthly___amount_sum`,\n _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at` AS `monthly___amount_sum_partition_by_ordered_at`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at`,\n _base_2.`monthly___amount_sum` / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at`,\n 0\n ) AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), sjoin__time_shift_inner AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum`,\n base.`monthly___amount_sum_partition_by_ordered_at`,\n shifted__time_shift_inner.`monthly___shifted` AS `monthly____time_shift_inner`\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.`monthly___region` IS NOT DISTINCT FROM shifted__time_shift_inner.`monthly___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`monthly___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___amount_sum_partition_by_ordered_at`,\n `monthly____time_shift_inner`,\n (\n `monthly___amount_sum` / NULLIF(`monthly___amount_sum_partition_by_ordered_at`, 0) - `monthly____time_shift_inner`\n ) / NULLIF(NULLIF(`monthly____time_shift_inner`, 0), 0) AS `monthly___t`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___amount_sum_partition_by_ordered_at`,\n `monthly____time_shift_inner`,\n `monthly___t`\n FROM step1\n) AS _outer", + "leaf/change_pct::duckdb": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _base_2.\"monthly.amount_sum\" / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted__time_shift_inner.\"monthly.shifted\" AS \"monthly._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner.\"monthly.ordered_at\"\n), step1 AS (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n (\n \"monthly.amount_sum\" / NULLIF(\"monthly.amount_sum_partition_by_ordered_at\", 0) - \"monthly._time_shift_inner\"\n ) / NULLIF(NULLIF(\"monthly._time_shift_inner\", 0), 0) AS \"monthly.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n \"monthly.t\"\n FROM step1\n) AS _outer", + "leaf/change_pct::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS DOUBLE PRECISION) / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted__time_shift_inner.\"monthly.shifted\" AS \"monthly._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"monthly.ordered_at\"\n), step1 AS (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n CAST((\n CAST(\"monthly.amount_sum\" AS DOUBLE PRECISION) / NULLIF(\"monthly.amount_sum_partition_by_ordered_at\", 0) - \"monthly._time_shift_inner\"\n ) AS DOUBLE PRECISION) / NULLIF(NULLIF(\"monthly._time_shift_inner\", 0), 0) AS \"monthly.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n \"monthly.t\"\n FROM step1\n) AS _outer", + "leaf/change_pct::sqlite": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS REAL) / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted__time_shift_inner.\"monthly.shifted\" AS \"monthly._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"monthly.region\" IS shifted__time_shift_inner.\"monthly.region\"\n AND SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"monthly.ordered_at\"\n), step1 AS (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n CAST((\n CAST(\"monthly.amount_sum\" AS REAL) / NULLIF(\"monthly.amount_sum_partition_by_ordered_at\", 0) - \"monthly._time_shift_inner\"\n ) AS REAL) / NULLIF(NULLIF(\"monthly._time_shift_inner\", 0), 0) AS \"monthly.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly._time_shift_inner\",\n \"monthly.t\"\n FROM step1\n) AS _outer", + "leaf/change_pct::tsql": "WITH _base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_ordered_at]\n FROM monthly AS monthly\n GROUP BY\n DATETRUNC(month, monthly.ordered_at)\n), base AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n _base.[monthly___amount_sum] AS [monthly___amount_sum],\n _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at]\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(_base_2.[monthly___amount_sum] AS FLOAT) / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at],\n 0\n ) AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base_2.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), sjoin__time_shift_inner AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_sum] AS [monthly___amount_sum],\n base.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n shifted__time_shift_inner.[monthly___shifted] AS [monthly____time_shift_inner]\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON (\n base.[monthly___region] = shifted__time_shift_inner.[monthly___region]\n OR (\n base.[monthly___region] IS NULL\n AND shifted__time_shift_inner.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted__time_shift_inner.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND shifted__time_shift_inner.[monthly___ordered_at] IS NULL\n )\n )\n), step1 AS (\n SELECT\n [monthly___region] AS [monthly___region],\n [monthly___ordered_at] AS [monthly___ordered_at],\n [monthly___amount_sum] AS [monthly___amount_sum],\n [monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n [monthly____time_shift_inner] AS [monthly____time_shift_inner],\n CAST((\n CAST([monthly___amount_sum] AS FLOAT) / NULLIF([monthly___amount_sum_partition_by_ordered_at], 0) - [monthly____time_shift_inner]\n ) AS FLOAT) / NULLIF(NULLIF([monthly____time_shift_inner], 0), 0) AS [monthly___t]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_sum],\n [monthly___amount_sum_partition_by_ordered_at],\n [monthly____time_shift_inner],\n [monthly___t]\n FROM step1\n) AS _outer", + "leaf/non_time_partition::bigquery": "WITH _base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS `monthly___region`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_region`\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _base.`monthly___amount_sum`,\n _cm_monthly__amount_sum_partition_by_region.`monthly___amount_sum_partition_by_region` AS `monthly___amount_sum_partition_by_region`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.`monthly___region`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted_t AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at`,\n _base_2.`monthly___amount_sum` / NULLIF(\n _cm_monthly__amount_sum_partition_by_region.`monthly___amount_sum_partition_by_region`,\n 0\n ) AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base_2.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.`monthly___region`\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum`,\n base.`monthly___amount_sum_partition_by_region`,\n shifted_t.`monthly___shifted` AS `monthly___t`\n FROM base\n LEFT JOIN shifted_t\n ON base.`monthly___region` IS NOT DISTINCT FROM shifted_t.`monthly___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___amount_sum_partition_by_region`,\n `monthly___t`\n FROM sjoin_t\n) AS _outer", + "leaf/non_time_partition::duckdb": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _base_2.\"monthly.amount_sum\" / NULLIF(\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", + "leaf/non_time_partition::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS DOUBLE PRECISION) / NULLIF(\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", + "leaf/non_time_partition::sqlite": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS \"monthly.region\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\" AS \"monthly.amount_sum_partition_by_region\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base.\"monthly.region\" IS _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS REAL) / NULLIF(\n _cm_monthly__amount_sum_partition_by_region.\"monthly.amount_sum_partition_by_region\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON _base_2.\"monthly.region\" IS _cm_monthly__amount_sum_partition_by_region.\"monthly.region\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_region\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS shifted_t.\"monthly.region\"\n AND SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'month') IS shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_region\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", + "leaf/non_time_partition::tsql": "WITH _base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_region AS (\n SELECT\n monthly.region AS [monthly___region],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_region]\n FROM monthly AS monthly\n GROUP BY\n monthly.region\n), base AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n _base.[monthly___amount_sum] AS [monthly___amount_sum],\n _cm_monthly__amount_sum_partition_by_region.[monthly___amount_sum_partition_by_region] AS [monthly___amount_sum_partition_by_region]\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON (\n _base.[monthly___region] = _cm_monthly__amount_sum_partition_by_region.[monthly___region]\n OR (\n _base.[monthly___region] IS NULL\n AND _cm_monthly__amount_sum_partition_by_region.[monthly___region] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(_base_2.[monthly___amount_sum] AS FLOAT) / NULLIF(\n _cm_monthly__amount_sum_partition_by_region.[monthly___amount_sum_partition_by_region],\n 0\n ) AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_region\n ON (\n _base_2.[monthly___region] = _cm_monthly__amount_sum_partition_by_region.[monthly___region]\n OR (\n _base_2.[monthly___region] IS NULL\n AND _cm_monthly__amount_sum_partition_by_region.[monthly___region] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_sum] AS [monthly___amount_sum],\n base.[monthly___amount_sum_partition_by_region] AS [monthly___amount_sum_partition_by_region],\n shifted_t.[monthly___shifted] AS [monthly___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[monthly___region] = shifted_t.[monthly___region]\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND shifted_t.[monthly___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_sum],\n [monthly___amount_sum_partition_by_region],\n [monthly___t]\n FROM sjoin_t\n) AS _outer", "leaf/ranked_composite::bigquery": "WITH _base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_last AS (\n SELECT\n _val_1 AS `monthly___ordered_at`,\n _val_0 AS `monthly___region`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_2 END) AS FLOAT64) AS `monthly___amount_last`\n FROM (\n SELECT\n monthly.region AS _val_0,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS _val_1,\n monthly.amount AS _val_2,\n ROW_NUMBER() OVER (\n PARTITION BY monthly.region, DATE_TRUNC(monthly.ordered_at, MONTH)\n ORDER BY monthly.ordered_at DESC\n ) AS _ranked_rn\n FROM monthly AS monthly\n ) AS _ranked_src\n GROUP BY\n _val_1,\n _val_0\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _cm_monthly__amount_last.`monthly___amount_last` AS `monthly___amount_last`\n FROM _base\n LEFT JOIN _cm_monthly__amount_last\n ON _base.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_last.`monthly___region`\n AND _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_last.`monthly___ordered_at`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted_t AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at`,\n _cm_monthly__amount_last.`monthly___amount_last` / 2 AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_last\n ON _base_2.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_last.`monthly___region`\n AND _base_2.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_last.`monthly___ordered_at`\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_last`,\n shifted_t.`monthly___shifted` AS `monthly___t`\n FROM base\n LEFT JOIN shifted_t\n ON base.`monthly___region` IS NOT DISTINCT FROM shifted_t.`monthly___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_last`,\n `monthly___t`\n FROM sjoin_t\n) AS _outer", "leaf/ranked_composite::duckdb": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_last AS (\n SELECT\n _val_1 AS \"monthly.ordered_at\",\n _val_0 AS \"monthly.region\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_2 END) AS DOUBLE) AS \"monthly.amount_last\"\n FROM (\n SELECT\n monthly.region AS _val_0,\n DATE_TRUNC('MONTH', monthly.ordered_at) AS _val_1,\n monthly.amount AS _val_2,\n ROW_NUMBER() OVER (\n PARTITION BY monthly.region, DATE_TRUNC('MONTH', monthly.ordered_at)\n ORDER BY monthly.ordered_at DESC\n ) AS _ranked_rn\n FROM monthly AS monthly\n ) AS _ranked_src\n GROUP BY\n _val_1,\n _val_0\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _cm_monthly__amount_last.\"monthly.amount_last\" AS \"monthly.amount_last\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_last\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_last.\"monthly.region\"\n AND _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_last.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _cm_monthly__amount_last.\"monthly.amount_last\" / 2 AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_last\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_last.\"monthly.region\"\n AND _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_last.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_last\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_last\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "leaf/ranked_composite::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_last AS (\n SELECT\n _val_1 AS \"monthly.ordered_at\",\n _val_0 AS \"monthly.region\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_2 END) AS DOUBLE PRECISION) AS \"monthly.amount_last\"\n FROM (\n SELECT\n monthly.region AS _val_0,\n DATE_TRUNC('MONTH', monthly.ordered_at) AS _val_1,\n monthly.amount AS _val_2,\n ROW_NUMBER() OVER (\n PARTITION BY monthly.region, DATE_TRUNC('MONTH', monthly.ordered_at)\n ORDER BY monthly.ordered_at DESC\n ) AS _ranked_rn\n FROM monthly AS monthly\n ) AS _ranked_src\n GROUP BY\n _val_1,\n _val_0\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _cm_monthly__amount_last.\"monthly.amount_last\" AS \"monthly.amount_last\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_last\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_last.\"monthly.region\"\n AND _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_last.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_cm_monthly__amount_last.\"monthly.amount_last\" AS DOUBLE PRECISION) / 2 AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_last\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_last.\"monthly.region\"\n AND _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_last.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_last\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_last\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "leaf/ranked_composite::sqlite": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_last AS (\n SELECT\n _val_1 AS \"monthly.ordered_at\",\n _val_0 AS \"monthly.region\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_2 END) AS REAL) AS \"monthly.amount_last\"\n FROM (\n SELECT\n monthly.region AS _val_0,\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS _val_1,\n monthly.amount AS _val_2,\n ROW_NUMBER() OVER (\n PARTITION BY monthly.region, STRFTIME('%Y-%m-01', monthly.ordered_at)\n ORDER BY monthly.ordered_at DESC\n ) AS _ranked_rn\n FROM monthly AS monthly\n ) AS _ranked_src\n GROUP BY\n _val_1,\n _val_0\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _cm_monthly__amount_last.\"monthly.amount_last\" AS \"monthly.amount_last\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_last\n ON _base.\"monthly.region\" IS _cm_monthly__amount_last.\"monthly.region\"\n AND _base.\"monthly.ordered_at\" IS _cm_monthly__amount_last.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_cm_monthly__amount_last.\"monthly.amount_last\" AS REAL) / 2 AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_last\n ON _base_2.\"monthly.region\" IS _cm_monthly__amount_last.\"monthly.region\"\n AND _base_2.\"monthly.ordered_at\" IS _cm_monthly__amount_last.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_last\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS shifted_t.\"monthly.region\"\n AND SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'month') IS shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_last\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "leaf/ranked_composite::tsql": "WITH _base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_last AS (\n SELECT\n _val_1 AS [monthly___ordered_at],\n _val_0 AS [monthly___region],\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_2 END) AS FLOAT) AS [monthly___amount_last]\n FROM (\n SELECT\n monthly.region AS _val_0,\n DATETRUNC(month, monthly.ordered_at) AS _val_1,\n monthly.amount AS _val_2,\n ROW_NUMBER() OVER (\n PARTITION BY monthly.region, DATETRUNC(month, monthly.ordered_at)\n ORDER BY monthly.ordered_at DESC\n ) AS _ranked_rn\n FROM monthly AS monthly\n ) AS _ranked_src\n GROUP BY\n _val_1,\n _val_0\n), base AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n _cm_monthly__amount_last.[monthly___amount_last] AS [monthly___amount_last]\n FROM _base\n LEFT JOIN _cm_monthly__amount_last\n ON (\n _base.[monthly___region] = _cm_monthly__amount_last.[monthly___region]\n OR (\n _base.[monthly___region] IS NULL\n AND _cm_monthly__amount_last.[monthly___region] IS NULL\n )\n )\n AND (\n _base.[monthly___ordered_at] = _cm_monthly__amount_last.[monthly___ordered_at]\n OR (\n _base.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_last.[monthly___ordered_at] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(_cm_monthly__amount_last.[monthly___amount_last] AS FLOAT) / 2 AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_last\n ON (\n _base_2.[monthly___region] = _cm_monthly__amount_last.[monthly___region]\n OR (\n _base_2.[monthly___region] IS NULL\n AND _cm_monthly__amount_last.[monthly___region] IS NULL\n )\n )\n AND (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_last.[monthly___ordered_at]\n OR (\n _base_2.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_last.[monthly___ordered_at] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_last] AS [monthly___amount_last],\n shifted_t.[monthly___shifted] AS [monthly___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[monthly___region] = shifted_t.[monthly___region]\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND shifted_t.[monthly___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_last],\n [monthly___t]\n FROM sjoin_t\n) AS _outer", - "leaf/reaggregation::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _base_3 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at_month`,\n SUM(monthly.amount) AS `monthly___amount_sum_partition_by_ordered_at_region`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at_month`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_ordered_at`\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), base_2 AS (\n SELECT\n _base_3.`monthly___region`,\n _base_3.`monthly___ordered_at_month`,\n _base_3.`monthly___amount_sum_partition_by_ordered_at_region`,\n _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at` AS `monthly___amount_sum_partition_by_ordered_at`\n FROM _base_3\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_3.`monthly___ordered_at_month` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at_month`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at_month`,\n SUM(monthly.amount) AS `monthly___amount_sum_partition_by_ordered_at_region`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted_time_shift AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at_month`,\n _base_2.`monthly___amount_sum_partition_by_ordered_at_region` / _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at` AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.`monthly___ordered_at_month` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at_month`\n), sjoin_time_shift AS (\n SELECT\n base_2.`monthly___region`,\n base_2.`monthly___ordered_at_month`,\n base_2.`monthly___amount_sum_partition_by_ordered_at_region`,\n base_2.`monthly___amount_sum_partition_by_ordered_at`,\n shifted_time_shift.`monthly___shifted` AS `monthly___time_shift`\n FROM base_2\n LEFT JOIN shifted_time_shift\n ON base_2.`monthly___region` IS NOT DISTINCT FROM shifted_time_shift.`monthly___region`\n AND CAST(DATETIME_ADD(\n CAST(CAST(base_2.`monthly___ordered_at_month` AS TIMESTAMP) AS DATETIME),\n INTERVAL -1 MONTH\n ) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_time_shift.`monthly___ordered_at_month` AS TIMESTAMP)\n), _cm_time_shift AS (\n SELECT\n _stage_inner.`monthly___region` AS `region`,\n _stage_inner.`monthly___ordered_at_month` AS `ordered_at_month`,\n _stage_inner.`monthly___time_shift` AS `time_shift`\n FROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at_month`,\n `monthly___time_shift`\n FROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at_month`,\n `monthly___amount_sum_partition_by_ordered_at_region`,\n `monthly___amount_sum_partition_by_ordered_at`,\n `monthly___time_shift`\n FROM sjoin_time_shift\n ) AS _outer\n ) AS _stage_inner\n), _cm_monthly___avg AS (\n SELECT\n _base.`monthly___ordered_at_month` AS `monthly___ordered_at_month`,\n CAST(AVG(_base._v) AS FLOAT64) AS `monthly___t`\n FROM (\n SELECT\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at_month`,\n monthly.region AS _ek0,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS _ek1,\n MAX(_cm_time_shift.`time_shift`) AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_time_shift\n ON monthly.region IS NOT DISTINCT FROM _cm_time_shift.`region`\n AND DATE_TRUNC(monthly.ordered_at, MONTH) IS NOT DISTINCT FROM _cm_time_shift.`ordered_at_month`\n GROUP BY\n DATE_TRUNC(monthly.ordered_at, MONTH),\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n ) AS _base\n GROUP BY\n _base.`monthly___ordered_at_month`\n)\nSELECT\n _base.`monthly___ordered_at`,\n _cm_monthly___avg.`monthly___t`\nFROM _base\nLEFT JOIN _cm_monthly___avg\n ON _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly___avg.`monthly___ordered_at_month`", - "leaf/reaggregation::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _base_3 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n SUM(monthly.amount) AS \"monthly.amount_sum_partition_by_ordered_at_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base_2 AS (\n SELECT\n _base_3.\"monthly.region\",\n _base_3.\"monthly.ordered_at_month\",\n _base_3.\"monthly.amount_sum_partition_by_ordered_at_region\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base_3\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_3.\"monthly.ordered_at_month\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at_month\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n SUM(monthly.amount) AS \"monthly.amount_sum_partition_by_ordered_at_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_time_shift AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at_month\",\n _base_2.\"monthly.amount_sum_partition_by_ordered_at_region\" / _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at_month\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at_month\"\n), sjoin_time_shift AS (\n SELECT\n base_2.\"monthly.region\",\n base_2.\"monthly.ordered_at_month\",\n base_2.\"monthly.amount_sum_partition_by_ordered_at_region\",\n base_2.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_time_shift.\"monthly.shifted\" AS \"monthly.time_shift\"\n FROM base_2\n LEFT JOIN shifted_time_shift\n ON base_2.\"monthly.region\" IS NOT DISTINCT FROM shifted_time_shift.\"monthly.region\"\n AND base_2.\"monthly.ordered_at_month\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_time_shift.\"monthly.ordered_at_month\"\n), _cm_time_shift AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.ordered_at_month\" AS \"ordered_at_month\",\n _stage_inner.\"monthly.time_shift\" AS \"time_shift\"\n FROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.time_shift\"\n FROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.amount_sum_partition_by_ordered_at_region\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.time_shift\"\n FROM sjoin_time_shift\n ) AS _outer\n ) AS _stage_inner\n), _cm_monthly___avg AS (\n SELECT\n _base.\"monthly.ordered_at_month\" AS \"monthly.ordered_at_month\",\n CAST(AVG(_base._v) AS DOUBLE) AS \"monthly.t\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n monthly.region AS _ek0,\n DATE_TRUNC('MONTH', monthly.ordered_at) AS _ek1,\n MAX(_cm_time_shift.\"time_shift\") AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_time_shift\n ON monthly.region IS NOT DISTINCT FROM _cm_time_shift.\"region\"\n AND DATE_TRUNC('MONTH', monthly.ordered_at) IS NOT DISTINCT FROM _cm_time_shift.\"ordered_at_month\"\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at),\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n ) AS _base\n GROUP BY\n _base.\"monthly.ordered_at_month\"\n)\nSELECT\n _base.\"monthly.ordered_at\",\n _cm_monthly___avg.\"monthly.t\"\nFROM _base\nLEFT JOIN _cm_monthly___avg\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly___avg.\"monthly.ordered_at_month\"", - "leaf/reaggregation::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _base_3 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n SUM(monthly.amount) AS \"monthly.amount_sum_partition_by_ordered_at_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base_2 AS (\n SELECT\n _base_3.\"monthly.region\",\n _base_3.\"monthly.ordered_at_month\",\n _base_3.\"monthly.amount_sum_partition_by_ordered_at_region\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base_3\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_3.\"monthly.ordered_at_month\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at_month\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n SUM(monthly.amount) AS \"monthly.amount_sum_partition_by_ordered_at_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_time_shift AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at_month\",\n CAST(_base_2.\"monthly.amount_sum_partition_by_ordered_at_region\" AS DOUBLE PRECISION) / _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at_month\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at_month\"\n), sjoin_time_shift AS (\n SELECT\n base_2.\"monthly.region\",\n base_2.\"monthly.ordered_at_month\",\n base_2.\"monthly.amount_sum_partition_by_ordered_at_region\",\n base_2.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_time_shift.\"monthly.shifted\" AS \"monthly.time_shift\"\n FROM base_2\n LEFT JOIN shifted_time_shift\n ON base_2.\"monthly.region\" IS NOT DISTINCT FROM shifted_time_shift.\"monthly.region\"\n AND base_2.\"monthly.ordered_at_month\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_time_shift.\"monthly.ordered_at_month\"\n), _cm_time_shift AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.ordered_at_month\" AS \"ordered_at_month\",\n _stage_inner.\"monthly.time_shift\" AS \"time_shift\"\n FROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.time_shift\"\n FROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.amount_sum_partition_by_ordered_at_region\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.time_shift\"\n FROM sjoin_time_shift\n ) AS _outer\n ) AS _stage_inner\n), _cm_monthly___avg AS (\n SELECT\n _base.\"monthly.ordered_at_month\" AS \"monthly.ordered_at_month\",\n CAST(AVG(_base._v) AS DOUBLE PRECISION) AS \"monthly.t\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n monthly.region AS _ek0,\n DATE_TRUNC('MONTH', monthly.ordered_at) AS _ek1,\n MAX(_cm_time_shift.\"time_shift\") AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_time_shift\n ON monthly.region IS NOT DISTINCT FROM _cm_time_shift.\"region\"\n AND DATE_TRUNC('MONTH', monthly.ordered_at) IS NOT DISTINCT FROM _cm_time_shift.\"ordered_at_month\"\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at),\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n ) AS _base\n GROUP BY\n _base.\"monthly.ordered_at_month\"\n)\nSELECT\n _base.\"monthly.ordered_at\",\n _cm_monthly___avg.\"monthly.t\"\nFROM _base\nLEFT JOIN _cm_monthly___avg\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly___avg.\"monthly.ordered_at_month\"", - "leaf/reaggregation::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _base_3 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n SUM(monthly.amount) AS \"monthly.amount_sum_partition_by_ordered_at_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), base_2 AS (\n SELECT\n _base_3.\"monthly.region\",\n _base_3.\"monthly.ordered_at_month\",\n _base_3.\"monthly.amount_sum_partition_by_ordered_at_region\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base_3\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_3.\"monthly.ordered_at_month\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at_month\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n SUM(monthly.amount) AS \"monthly.amount_sum_partition_by_ordered_at_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted_time_shift AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at_month\",\n CAST(_base_2.\"monthly.amount_sum_partition_by_ordered_at_region\" AS REAL) / _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at_month\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at_month\"\n), sjoin_time_shift AS (\n SELECT\n base_2.\"monthly.region\",\n base_2.\"monthly.ordered_at_month\",\n base_2.\"monthly.amount_sum_partition_by_ordered_at_region\",\n base_2.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_time_shift.\"monthly.shifted\" AS \"monthly.time_shift\"\n FROM base_2\n LEFT JOIN shifted_time_shift\n ON base_2.\"monthly.region\" IS shifted_time_shift.\"monthly.region\"\n AND SLAYER_DATE_ADD(base_2.\"monthly.ordered_at_month\", -1, 'month') IS shifted_time_shift.\"monthly.ordered_at_month\"\n), _cm_time_shift AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.ordered_at_month\" AS \"ordered_at_month\",\n _stage_inner.\"monthly.time_shift\" AS \"time_shift\"\n FROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.time_shift\"\n FROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.amount_sum_partition_by_ordered_at_region\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.time_shift\"\n FROM sjoin_time_shift\n ) AS _outer\n ) AS _stage_inner\n), _cm_monthly___avg AS (\n SELECT\n _base.\"monthly.ordered_at_month\" AS \"monthly.ordered_at_month\",\n CAST(AVG(_base._v) AS REAL) AS \"monthly.t\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n monthly.region AS _ek0,\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS _ek1,\n MAX(_cm_time_shift.\"time_shift\") AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_time_shift\n ON monthly.region IS _cm_time_shift.\"region\"\n AND STRFTIME('%Y-%m-01', monthly.ordered_at) IS _cm_time_shift.\"ordered_at_month\"\n GROUP BY\n STRFTIME('%Y-%m-01', monthly.ordered_at),\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n ) AS _base\n GROUP BY\n _base.\"monthly.ordered_at_month\"\n)\nSELECT\n _base.\"monthly.ordered_at\",\n _cm_monthly___avg.\"monthly.t\"\nFROM _base\nLEFT JOIN _cm_monthly___avg\n ON _base.\"monthly.ordered_at\" IS _cm_monthly___avg.\"monthly.ordered_at_month\"", - "leaf/reaggregation::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at]\n FROM monthly AS monthly\n GROUP BY\n DATETRUNC(month, monthly.ordered_at)\n), _base_3 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at_month],\n SUM(monthly.amount) AS [monthly___amount_sum_partition_by_ordered_at_region]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at_month],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_ordered_at]\n FROM monthly AS monthly\n GROUP BY\n DATETRUNC(month, monthly.ordered_at)\n), base_2 AS (\n SELECT\n _base_3.[monthly___region] AS [monthly___region],\n _base_3.[monthly___ordered_at_month] AS [monthly___ordered_at_month],\n _base_3.[monthly___amount_sum_partition_by_ordered_at_region] AS [monthly___amount_sum_partition_by_ordered_at_region],\n _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at]\n FROM _base_3\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base_3.[monthly___ordered_at_month] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at_month]\n OR (\n _base_3.[monthly___ordered_at_month] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at_month] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at_month],\n SUM(monthly.amount) AS [monthly___amount_sum_partition_by_ordered_at_region]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted_time_shift AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at_month] AS [monthly___ordered_at_month],\n CAST(_base_2.[monthly___amount_sum_partition_by_ordered_at_region] AS FLOAT) / _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base_2.[monthly___ordered_at_month] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at_month]\n OR (\n _base_2.[monthly___ordered_at_month] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at_month] IS NULL\n )\n )\n), sjoin_time_shift AS (\n SELECT\n base_2.[monthly___region] AS [monthly___region],\n base_2.[monthly___ordered_at_month] AS [monthly___ordered_at_month],\n base_2.[monthly___amount_sum_partition_by_ordered_at_region] AS [monthly___amount_sum_partition_by_ordered_at_region],\n base_2.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n shifted_time_shift.[monthly___shifted] AS [monthly___time_shift]\n FROM base_2\n LEFT JOIN shifted_time_shift\n ON (\n base_2.[monthly___region] = shifted_time_shift.[monthly___region]\n OR (\n base_2.[monthly___region] IS NULL AND shifted_time_shift.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base_2.[monthly___ordered_at_month]) = shifted_time_shift.[monthly___ordered_at_month]\n OR (\n DATEADD(MONTH, -1, base_2.[monthly___ordered_at_month]) IS NULL\n AND shifted_time_shift.[monthly___ordered_at_month] IS NULL\n )\n )\n), _cm_time_shift AS (\n SELECT\n _stage_inner.[monthly___region] AS [region],\n _stage_inner.[monthly___ordered_at_month] AS [ordered_at_month],\n _stage_inner.[monthly___time_shift] AS [time_shift]\n FROM (\n SELECT\n [monthly___region] AS [monthly___region],\n [monthly___ordered_at_month] AS [monthly___ordered_at_month],\n [monthly___time_shift] AS [monthly___time_shift]\n FROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at_month],\n [monthly___amount_sum_partition_by_ordered_at_region],\n [monthly___amount_sum_partition_by_ordered_at],\n [monthly___time_shift]\n FROM sjoin_time_shift\n ) AS _outer\n ) AS _stage_inner\n), _cm_monthly___avg AS (\n SELECT\n _base.[monthly___ordered_at_month] AS [monthly___ordered_at_month],\n CAST(AVG(CAST(_base._v AS FLOAT)) AS FLOAT) AS [monthly___t]\n FROM (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at_month],\n monthly.region AS _ek0,\n DATETRUNC(month, monthly.ordered_at) AS _ek1,\n MAX(_cm_time_shift.[time_shift]) AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_time_shift\n ON (\n monthly.region = _cm_time_shift.[region]\n OR (\n monthly.region IS NULL AND _cm_time_shift.[region] IS NULL\n )\n )\n AND (\n DATETRUNC(month, monthly.ordered_at) = _cm_time_shift.[ordered_at_month]\n OR (\n DATETRUNC(month, monthly.ordered_at) IS NULL\n AND _cm_time_shift.[ordered_at_month] IS NULL\n )\n )\n GROUP BY\n DATETRUNC(month, monthly.ordered_at),\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n ) AS _base\n GROUP BY\n _base.[monthly___ordered_at_month]\n)\nSELECT\n _base.[monthly___ordered_at],\n _cm_monthly___avg.[monthly___t]\nFROM _base\nLEFT JOIN _cm_monthly___avg\n ON (\n _base.[monthly___ordered_at] = _cm_monthly___avg.[monthly___ordered_at_month]\n OR (\n _base.[monthly___ordered_at] IS NULL\n AND _cm_monthly___avg.[monthly___ordered_at_month] IS NULL\n )\n )", - "leaf/share::bigquery": "WITH _base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_ordered_at`\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _base.`monthly___amount_sum`,\n _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at` AS `monthly___amount_sum_partition_by_ordered_at`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted_t AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at`,\n _base_2.`monthly___amount_sum` / _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at` AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum`,\n base.`monthly___amount_sum_partition_by_ordered_at`,\n shifted_t.`monthly___shifted` AS `monthly___t`\n FROM base\n LEFT JOIN shifted_t\n ON base.`monthly___region` IS NOT DISTINCT FROM shifted_t.`monthly___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___amount_sum_partition_by_ordered_at`,\n `monthly___t`\n FROM sjoin_t\n) AS _outer", - "leaf/share::duckdb": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _base_2.\"monthly.amount_sum\" / _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", - "leaf/share::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS DOUBLE PRECISION) / _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", - "leaf/share::sqlite": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS REAL) / _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS shifted_t.\"monthly.region\"\n AND SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'month') IS shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", - "leaf/share::tsql": "WITH _base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_ordered_at]\n FROM monthly AS monthly\n GROUP BY\n DATETRUNC(month, monthly.ordered_at)\n), base AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n _base.[monthly___amount_sum] AS [monthly___amount_sum],\n _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at]\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(_base_2.[monthly___amount_sum] AS FLOAT) / _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base_2.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_sum] AS [monthly___amount_sum],\n base.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n shifted_t.[monthly___shifted] AS [monthly___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[monthly___region] = shifted_t.[monthly___region]\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND shifted_t.[monthly___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_sum],\n [monthly___amount_sum_partition_by_ordered_at],\n [monthly___t]\n FROM sjoin_t\n) AS _outer", + "leaf/reaggregation::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _base_3 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at_month`,\n SUM(monthly.amount) AS `monthly___amount_sum_partition_by_ordered_at_region`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at_month`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_ordered_at`\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), base_2 AS (\n SELECT\n _base_3.`monthly___region`,\n _base_3.`monthly___ordered_at_month`,\n _base_3.`monthly___amount_sum_partition_by_ordered_at_region`,\n _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at` AS `monthly___amount_sum_partition_by_ordered_at`\n FROM _base_3\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_3.`monthly___ordered_at_month` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at_month`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at_month`,\n SUM(monthly.amount) AS `monthly___amount_sum_partition_by_ordered_at_region`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted_time_shift AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at_month`,\n _base_2.`monthly___amount_sum_partition_by_ordered_at_region` / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at`,\n 0\n ) AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.`monthly___ordered_at_month` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at_month`\n), sjoin_time_shift AS (\n SELECT\n base_2.`monthly___region`,\n base_2.`monthly___ordered_at_month`,\n base_2.`monthly___amount_sum_partition_by_ordered_at_region`,\n base_2.`monthly___amount_sum_partition_by_ordered_at`,\n shifted_time_shift.`monthly___shifted` AS `monthly___time_shift`\n FROM base_2\n LEFT JOIN shifted_time_shift\n ON base_2.`monthly___region` IS NOT DISTINCT FROM shifted_time_shift.`monthly___region`\n AND CAST(DATETIME_ADD(\n CAST(CAST(base_2.`monthly___ordered_at_month` AS TIMESTAMP) AS DATETIME),\n INTERVAL -1 MONTH\n ) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_time_shift.`monthly___ordered_at_month` AS TIMESTAMP)\n), _cm_time_shift AS (\n SELECT\n _stage_inner.`monthly___region` AS `region`,\n _stage_inner.`monthly___ordered_at_month` AS `ordered_at_month`,\n _stage_inner.`monthly___time_shift` AS `time_shift`\n FROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at_month`,\n `monthly___time_shift`\n FROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at_month`,\n `monthly___amount_sum_partition_by_ordered_at_region`,\n `monthly___amount_sum_partition_by_ordered_at`,\n `monthly___time_shift`\n FROM sjoin_time_shift\n ) AS _outer\n ) AS _stage_inner\n), _cm_monthly___avg AS (\n SELECT\n _base.`monthly___ordered_at_month` AS `monthly___ordered_at_month`,\n CAST(AVG(_base._v) AS FLOAT64) AS `monthly___t`\n FROM (\n SELECT\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at_month`,\n monthly.region AS _ek0,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS _ek1,\n MAX(_cm_time_shift.`time_shift`) AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_time_shift\n ON monthly.region IS NOT DISTINCT FROM _cm_time_shift.`region`\n AND DATE_TRUNC(monthly.ordered_at, MONTH) IS NOT DISTINCT FROM _cm_time_shift.`ordered_at_month`\n GROUP BY\n DATE_TRUNC(monthly.ordered_at, MONTH),\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n ) AS _base\n GROUP BY\n _base.`monthly___ordered_at_month`\n)\nSELECT\n _base.`monthly___ordered_at`,\n _cm_monthly___avg.`monthly___t`\nFROM _base\nLEFT JOIN _cm_monthly___avg\n ON _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly___avg.`monthly___ordered_at_month`", + "leaf/reaggregation::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _base_3 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n SUM(monthly.amount) AS \"monthly.amount_sum_partition_by_ordered_at_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base_2 AS (\n SELECT\n _base_3.\"monthly.region\",\n _base_3.\"monthly.ordered_at_month\",\n _base_3.\"monthly.amount_sum_partition_by_ordered_at_region\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base_3\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_3.\"monthly.ordered_at_month\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at_month\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n SUM(monthly.amount) AS \"monthly.amount_sum_partition_by_ordered_at_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_time_shift AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at_month\",\n _base_2.\"monthly.amount_sum_partition_by_ordered_at_region\" / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at_month\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at_month\"\n), sjoin_time_shift AS (\n SELECT\n base_2.\"monthly.region\",\n base_2.\"monthly.ordered_at_month\",\n base_2.\"monthly.amount_sum_partition_by_ordered_at_region\",\n base_2.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_time_shift.\"monthly.shifted\" AS \"monthly.time_shift\"\n FROM base_2\n LEFT JOIN shifted_time_shift\n ON base_2.\"monthly.region\" IS NOT DISTINCT FROM shifted_time_shift.\"monthly.region\"\n AND base_2.\"monthly.ordered_at_month\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_time_shift.\"monthly.ordered_at_month\"\n), _cm_time_shift AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.ordered_at_month\" AS \"ordered_at_month\",\n _stage_inner.\"monthly.time_shift\" AS \"time_shift\"\n FROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.time_shift\"\n FROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.amount_sum_partition_by_ordered_at_region\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.time_shift\"\n FROM sjoin_time_shift\n ) AS _outer\n ) AS _stage_inner\n), _cm_monthly___avg AS (\n SELECT\n _base.\"monthly.ordered_at_month\" AS \"monthly.ordered_at_month\",\n CAST(AVG(_base._v) AS DOUBLE) AS \"monthly.t\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n monthly.region AS _ek0,\n DATE_TRUNC('MONTH', monthly.ordered_at) AS _ek1,\n MAX(_cm_time_shift.\"time_shift\") AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_time_shift\n ON monthly.region IS NOT DISTINCT FROM _cm_time_shift.\"region\"\n AND DATE_TRUNC('MONTH', monthly.ordered_at) IS NOT DISTINCT FROM _cm_time_shift.\"ordered_at_month\"\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at),\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n ) AS _base\n GROUP BY\n _base.\"monthly.ordered_at_month\"\n)\nSELECT\n _base.\"monthly.ordered_at\",\n _cm_monthly___avg.\"monthly.t\"\nFROM _base\nLEFT JOIN _cm_monthly___avg\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly___avg.\"monthly.ordered_at_month\"", + "leaf/reaggregation::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _base_3 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n SUM(monthly.amount) AS \"monthly.amount_sum_partition_by_ordered_at_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base_2 AS (\n SELECT\n _base_3.\"monthly.region\",\n _base_3.\"monthly.ordered_at_month\",\n _base_3.\"monthly.amount_sum_partition_by_ordered_at_region\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base_3\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_3.\"monthly.ordered_at_month\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at_month\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n SUM(monthly.amount) AS \"monthly.amount_sum_partition_by_ordered_at_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_time_shift AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at_month\",\n CAST(_base_2.\"monthly.amount_sum_partition_by_ordered_at_region\" AS DOUBLE PRECISION) / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at_month\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at_month\"\n), sjoin_time_shift AS (\n SELECT\n base_2.\"monthly.region\",\n base_2.\"monthly.ordered_at_month\",\n base_2.\"monthly.amount_sum_partition_by_ordered_at_region\",\n base_2.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_time_shift.\"monthly.shifted\" AS \"monthly.time_shift\"\n FROM base_2\n LEFT JOIN shifted_time_shift\n ON base_2.\"monthly.region\" IS NOT DISTINCT FROM shifted_time_shift.\"monthly.region\"\n AND base_2.\"monthly.ordered_at_month\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_time_shift.\"monthly.ordered_at_month\"\n), _cm_time_shift AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.ordered_at_month\" AS \"ordered_at_month\",\n _stage_inner.\"monthly.time_shift\" AS \"time_shift\"\n FROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.time_shift\"\n FROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.amount_sum_partition_by_ordered_at_region\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.time_shift\"\n FROM sjoin_time_shift\n ) AS _outer\n ) AS _stage_inner\n), _cm_monthly___avg AS (\n SELECT\n _base.\"monthly.ordered_at_month\" AS \"monthly.ordered_at_month\",\n CAST(AVG(_base._v) AS DOUBLE PRECISION) AS \"monthly.t\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n monthly.region AS _ek0,\n DATE_TRUNC('MONTH', monthly.ordered_at) AS _ek1,\n MAX(_cm_time_shift.\"time_shift\") AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_time_shift\n ON monthly.region IS NOT DISTINCT FROM _cm_time_shift.\"region\"\n AND DATE_TRUNC('MONTH', monthly.ordered_at) IS NOT DISTINCT FROM _cm_time_shift.\"ordered_at_month\"\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at),\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n ) AS _base\n GROUP BY\n _base.\"monthly.ordered_at_month\"\n)\nSELECT\n _base.\"monthly.ordered_at\",\n _cm_monthly___avg.\"monthly.t\"\nFROM _base\nLEFT JOIN _cm_monthly___avg\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly___avg.\"monthly.ordered_at_month\"", + "leaf/reaggregation::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _base_3 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n SUM(monthly.amount) AS \"monthly.amount_sum_partition_by_ordered_at_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), base_2 AS (\n SELECT\n _base_3.\"monthly.region\",\n _base_3.\"monthly.ordered_at_month\",\n _base_3.\"monthly.amount_sum_partition_by_ordered_at_region\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base_3\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_3.\"monthly.ordered_at_month\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at_month\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n SUM(monthly.amount) AS \"monthly.amount_sum_partition_by_ordered_at_region\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted_time_shift AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at_month\",\n CAST(_base_2.\"monthly.amount_sum_partition_by_ordered_at_region\" AS REAL) / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at_month\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at_month\"\n), sjoin_time_shift AS (\n SELECT\n base_2.\"monthly.region\",\n base_2.\"monthly.ordered_at_month\",\n base_2.\"monthly.amount_sum_partition_by_ordered_at_region\",\n base_2.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_time_shift.\"monthly.shifted\" AS \"monthly.time_shift\"\n FROM base_2\n LEFT JOIN shifted_time_shift\n ON base_2.\"monthly.region\" IS shifted_time_shift.\"monthly.region\"\n AND SLAYER_DATE_ADD(base_2.\"monthly.ordered_at_month\", -1, 'month') IS shifted_time_shift.\"monthly.ordered_at_month\"\n), _cm_time_shift AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.ordered_at_month\" AS \"ordered_at_month\",\n _stage_inner.\"monthly.time_shift\" AS \"time_shift\"\n FROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.time_shift\"\n FROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.amount_sum_partition_by_ordered_at_region\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.time_shift\"\n FROM sjoin_time_shift\n ) AS _outer\n ) AS _stage_inner\n), _cm_monthly___avg AS (\n SELECT\n _base.\"monthly.ordered_at_month\" AS \"monthly.ordered_at_month\",\n CAST(AVG(_base._v) AS REAL) AS \"monthly.t\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at_month\",\n monthly.region AS _ek0,\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS _ek1,\n MAX(_cm_time_shift.\"time_shift\") AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_time_shift\n ON monthly.region IS _cm_time_shift.\"region\"\n AND STRFTIME('%Y-%m-01', monthly.ordered_at) IS _cm_time_shift.\"ordered_at_month\"\n GROUP BY\n STRFTIME('%Y-%m-01', monthly.ordered_at),\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n ) AS _base\n GROUP BY\n _base.\"monthly.ordered_at_month\"\n)\nSELECT\n _base.\"monthly.ordered_at\",\n _cm_monthly___avg.\"monthly.t\"\nFROM _base\nLEFT JOIN _cm_monthly___avg\n ON _base.\"monthly.ordered_at\" IS _cm_monthly___avg.\"monthly.ordered_at_month\"", + "leaf/reaggregation::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at]\n FROM monthly AS monthly\n GROUP BY\n DATETRUNC(month, monthly.ordered_at)\n), _base_3 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at_month],\n SUM(monthly.amount) AS [monthly___amount_sum_partition_by_ordered_at_region]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at_month],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_ordered_at]\n FROM monthly AS monthly\n GROUP BY\n DATETRUNC(month, monthly.ordered_at)\n), base_2 AS (\n SELECT\n _base_3.[monthly___region] AS [monthly___region],\n _base_3.[monthly___ordered_at_month] AS [monthly___ordered_at_month],\n _base_3.[monthly___amount_sum_partition_by_ordered_at_region] AS [monthly___amount_sum_partition_by_ordered_at_region],\n _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at]\n FROM _base_3\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base_3.[monthly___ordered_at_month] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at_month]\n OR (\n _base_3.[monthly___ordered_at_month] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at_month] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at_month],\n SUM(monthly.amount) AS [monthly___amount_sum_partition_by_ordered_at_region]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted_time_shift AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at_month] AS [monthly___ordered_at_month],\n CAST(_base_2.[monthly___amount_sum_partition_by_ordered_at_region] AS FLOAT) / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at],\n 0\n ) AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base_2.[monthly___ordered_at_month] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at_month]\n OR (\n _base_2.[monthly___ordered_at_month] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at_month] IS NULL\n )\n )\n), sjoin_time_shift AS (\n SELECT\n base_2.[monthly___region] AS [monthly___region],\n base_2.[monthly___ordered_at_month] AS [monthly___ordered_at_month],\n base_2.[monthly___amount_sum_partition_by_ordered_at_region] AS [monthly___amount_sum_partition_by_ordered_at_region],\n base_2.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n shifted_time_shift.[monthly___shifted] AS [monthly___time_shift]\n FROM base_2\n LEFT JOIN shifted_time_shift\n ON (\n base_2.[monthly___region] = shifted_time_shift.[monthly___region]\n OR (\n base_2.[monthly___region] IS NULL AND shifted_time_shift.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base_2.[monthly___ordered_at_month]) = shifted_time_shift.[monthly___ordered_at_month]\n OR (\n DATEADD(MONTH, -1, base_2.[monthly___ordered_at_month]) IS NULL\n AND shifted_time_shift.[monthly___ordered_at_month] IS NULL\n )\n )\n), _cm_time_shift AS (\n SELECT\n _stage_inner.[monthly___region] AS [region],\n _stage_inner.[monthly___ordered_at_month] AS [ordered_at_month],\n _stage_inner.[monthly___time_shift] AS [time_shift]\n FROM (\n SELECT\n [monthly___region] AS [monthly___region],\n [monthly___ordered_at_month] AS [monthly___ordered_at_month],\n [monthly___time_shift] AS [monthly___time_shift]\n FROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at_month],\n [monthly___amount_sum_partition_by_ordered_at_region],\n [monthly___amount_sum_partition_by_ordered_at],\n [monthly___time_shift]\n FROM sjoin_time_shift\n ) AS _outer\n ) AS _stage_inner\n), _cm_monthly___avg AS (\n SELECT\n _base.[monthly___ordered_at_month] AS [monthly___ordered_at_month],\n CAST(AVG(CAST(_base._v AS FLOAT)) AS FLOAT) AS [monthly___t]\n FROM (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at_month],\n monthly.region AS _ek0,\n DATETRUNC(month, monthly.ordered_at) AS _ek1,\n MAX(_cm_time_shift.[time_shift]) AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_time_shift\n ON (\n monthly.region = _cm_time_shift.[region]\n OR (\n monthly.region IS NULL AND _cm_time_shift.[region] IS NULL\n )\n )\n AND (\n DATETRUNC(month, monthly.ordered_at) = _cm_time_shift.[ordered_at_month]\n OR (\n DATETRUNC(month, monthly.ordered_at) IS NULL\n AND _cm_time_shift.[ordered_at_month] IS NULL\n )\n )\n GROUP BY\n DATETRUNC(month, monthly.ordered_at),\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n ) AS _base\n GROUP BY\n _base.[monthly___ordered_at_month]\n)\nSELECT\n _base.[monthly___ordered_at],\n _cm_monthly___avg.[monthly___t]\nFROM _base\nLEFT JOIN _cm_monthly___avg\n ON (\n _base.[monthly___ordered_at] = _cm_monthly___avg.[monthly___ordered_at_month]\n OR (\n _base.[monthly___ordered_at] IS NULL\n AND _cm_monthly___avg.[monthly___ordered_at_month] IS NULL\n )\n )", + "leaf/share::bigquery": "WITH _base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_ordered_at`\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _base.`monthly___amount_sum`,\n _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at` AS `monthly___amount_sum_partition_by_ordered_at`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) AS `monthly___amount_sum`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), shifted_t AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at`,\n _base_2.`monthly___amount_sum` / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at`,\n 0\n ) AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum`,\n base.`monthly___amount_sum_partition_by_ordered_at`,\n shifted_t.`monthly___shifted` AS `monthly___t`\n FROM base\n LEFT JOIN shifted_t\n ON base.`monthly___region` IS NOT DISTINCT FROM shifted_t.`monthly___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum`,\n `monthly___amount_sum_partition_by_ordered_at`,\n `monthly___t`\n FROM sjoin_t\n) AS _outer", + "leaf/share::duckdb": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n _base_2.\"monthly.amount_sum\" / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", + "leaf/share::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS DOUBLE PRECISION) / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS NOT DISTINCT FROM shifted_t.\"monthly.region\"\n AND base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", + "leaf/share::sqlite": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _base.\"monthly.amount_sum\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), _base_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) AS \"monthly.amount_sum\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at\",\n CAST(_base_2.\"monthly.amount_sum\" AS REAL) / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base_2.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.region\" IS shifted_t.\"monthly.region\"\n AND SLAYER_DATE_ADD(base.\"monthly.ordered_at\", -1, 'month') IS shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", + "leaf/share::tsql": "WITH _base AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___amount_sum_partition_by_ordered_at]\n FROM monthly AS monthly\n GROUP BY\n DATETRUNC(month, monthly.ordered_at)\n), base AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n _base.[monthly___amount_sum] AS [monthly___amount_sum],\n _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at]\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n SUM(monthly.amount) AS [monthly___amount_sum]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[monthly___region] AS [monthly___region],\n _base_2.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(_base_2.[monthly___amount_sum] AS FLOAT) / NULLIF(\n _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___amount_sum_partition_by_ordered_at],\n 0\n ) AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n OR (\n _base_2.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[monthly___region] AS [monthly___region],\n base.[monthly___ordered_at] AS [monthly___ordered_at],\n base.[monthly___amount_sum] AS [monthly___amount_sum],\n base.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n shifted_t.[monthly___shifted] AS [monthly___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[monthly___region] = shifted_t.[monthly___region]\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND shifted_t.[monthly___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___t]\nFROM (\n SELECT\n [monthly___region],\n [monthly___ordered_at],\n [monthly___amount_sum],\n [monthly___amount_sum_partition_by_ordered_at],\n [monthly___t]\n FROM sjoin_t\n) AS _outer", "leaf/trivial_composite::bigquery": "WITH _base AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___amount_sum_partition_by_ordered_at`\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___amount_sum_partition_by_ordered_at` AS `monthly___amount_sum_partition_by_ordered_at`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.`monthly___ordered_at`\n), shifted_t AS (\n SELECT\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n SUM(monthly.amount) / 2 AS `monthly___shifted`\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum_partition_by_ordered_at`,\n shifted_t.`monthly___shifted` AS `monthly___t`\n FROM base\n LEFT JOIN shifted_t\n ON CAST(DATETIME_ADD(CAST(CAST(base.`monthly___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___t`\nFROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at`,\n `monthly___amount_sum_partition_by_ordered_at`,\n `monthly___t`\n FROM sjoin_t\n) AS _outer", "leaf/trivial_composite::duckdb": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), shifted_t AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n SUM(monthly.amount) / 2 AS \"monthly.shifted\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "leaf/trivial_composite::postgres": "WITH _base AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.amount_sum_partition_by_ordered_at\" AS \"monthly.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_partition_by_ordered_at\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_partition_by_ordered_at.\"monthly.ordered_at\"\n), shifted_t AS (\n SELECT\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) / 2 AS \"monthly.shifted\"\n FROM monthly AS monthly\n GROUP BY\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum_partition_by_ordered_at\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"monthly.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"monthly.ordered_at\"\n)\nSELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.t\"\nFROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at\",\n \"monthly.amount_sum_partition_by_ordered_at\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", @@ -84,11 +84,11 @@ "population/associate_dimension::postgres": "WITH _base AS (\n SELECT\n customers__regions__region_events.value AS \"orders.customers.regions.region_events.value\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n LEFT JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n GROUP BY\n customers__regions__region_events.value,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum AS (\n SELECT\n _base.\"orders.customers.regions.region_events.value\" AS \"orders.customers.regions.region_events.value\",\n _base.\"orders.ordered_at_month\" AS \"orders.ordered_at_month\",\n CAST(SUM(_base._v) AS DOUBLE PRECISION) AS \"orders.amount_sum_host\"\n FROM (\n SELECT\n customers__regions__region_events.value AS \"orders.customers.regions.region_events.value\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at_month\",\n orders.id AS _ek0,\n MAX(orders.amount) AS _v\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n LEFT JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n NOT orders.id IS NULL\n GROUP BY\n customers__regions__region_events.value,\n DATE_TRUNC('MONTH', orders.ordered_at),\n orders.id\n ) AS _base\n GROUP BY\n _base.\"orders.customers.regions.region_events.value\",\n _base.\"orders.ordered_at_month\"\n), base AS (\n SELECT\n _base.\"orders.customers.regions.region_events.value\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_sum.\"orders.amount_sum_host\" AS \"orders.amount_sum_host\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum\n ON _base.\"orders.customers.regions.region_events.value\" IS NOT DISTINCT FROM _cm_orders__amount_sum.\"orders.customers.regions.region_events.value\"\n AND _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum.\"orders.ordered_at_month\"\n), _base_2 AS (\n SELECT\n customers__regions__region_events.value AS \"orders.customers.regions.region_events.value\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n LEFT JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n GROUP BY\n customers__regions__region_events.value,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"orders.customers.regions.region_events.value\",\n _base_2.\"orders.ordered_at\",\n _cm_orders__amount_sum.\"orders.amount_sum_host\" AS \"orders.amount_sum\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum\n ON _base_2.\"orders.customers.regions.region_events.value\" IS NOT DISTINCT FROM _cm_orders__amount_sum.\"orders.customers.regions.region_events.value\"\n AND _base_2.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum.\"orders.ordered_at_month\"\n), sjoin_t AS (\n SELECT\n base.\"orders.customers.regions.region_events.value\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum_host\",\n shifted_t.\"orders.amount_sum\" AS \"orders.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"orders.customers.regions.region_events.value\" IS NOT DISTINCT FROM shifted_t.\"orders.customers.regions.region_events.value\"\n AND base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"orders.ordered_at\"\n)\nSELECT\n \"orders.customers.regions.region_events.value\",\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.customers.regions.region_events.value\",\n \"orders.ordered_at\",\n \"orders.amount_sum_host\",\n \"orders.t\"\n FROM sjoin_t\n) AS _outer", "population/associate_dimension::sqlite": "WITH _base AS (\n SELECT\n customers__regions__region_events.value AS \"orders.customers.regions.region_events.value\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n LEFT JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n GROUP BY\n customers__regions__region_events.value,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__amount_sum AS (\n SELECT\n _base.\"orders.customers.regions.region_events.value\" AS \"orders.customers.regions.region_events.value\",\n _base.\"orders.ordered_at_month\" AS \"orders.ordered_at_month\",\n CAST(SUM(_base._v) AS REAL) AS \"orders.amount_sum_host\"\n FROM (\n SELECT\n customers__regions__region_events.value AS \"orders.customers.regions.region_events.value\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at_month\",\n orders.id AS _ek0,\n MAX(orders.amount) AS _v\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n LEFT JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n NOT orders.id IS NULL\n GROUP BY\n customers__regions__region_events.value,\n STRFTIME('%Y-%m-01', orders.ordered_at),\n orders.id\n ) AS _base\n GROUP BY\n _base.\"orders.customers.regions.region_events.value\",\n _base.\"orders.ordered_at_month\"\n), base AS (\n SELECT\n _base.\"orders.customers.regions.region_events.value\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_sum.\"orders.amount_sum_host\" AS \"orders.amount_sum_host\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum\n ON _base.\"orders.customers.regions.region_events.value\" IS _cm_orders__amount_sum.\"orders.customers.regions.region_events.value\"\n AND _base.\"orders.ordered_at\" IS _cm_orders__amount_sum.\"orders.ordered_at_month\"\n), _base_2 AS (\n SELECT\n customers__regions__region_events.value AS \"orders.customers.regions.region_events.value\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n LEFT JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n GROUP BY\n customers__regions__region_events.value,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"orders.customers.regions.region_events.value\",\n _base_2.\"orders.ordered_at\",\n _cm_orders__amount_sum.\"orders.amount_sum_host\" AS \"orders.amount_sum\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum\n ON _base_2.\"orders.customers.regions.region_events.value\" IS _cm_orders__amount_sum.\"orders.customers.regions.region_events.value\"\n AND _base_2.\"orders.ordered_at\" IS _cm_orders__amount_sum.\"orders.ordered_at_month\"\n), sjoin_t AS (\n SELECT\n base.\"orders.customers.regions.region_events.value\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum_host\",\n shifted_t.\"orders.amount_sum\" AS \"orders.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"orders.customers.regions.region_events.value\" IS shifted_t.\"orders.customers.regions.region_events.value\"\n AND SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted_t.\"orders.ordered_at\"\n)\nSELECT\n \"orders.customers.regions.region_events.value\",\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.customers.regions.region_events.value\",\n \"orders.ordered_at\",\n \"orders.amount_sum_host\",\n \"orders.t\"\n FROM sjoin_t\n) AS _outer", "population/associate_dimension::tsql": "WITH _base AS (\n SELECT\n customers__regions__region_events.value AS [orders___customers___regions___region_events___value],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n LEFT JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n GROUP BY\n customers__regions__region_events.value,\n DATETRUNC(month, orders.ordered_at)\n), _cm_orders__amount_sum AS (\n SELECT\n _base.[orders___customers___regions___region_events___value] AS [orders___customers___regions___region_events___value],\n _base.[orders___ordered_at_month] AS [orders___ordered_at_month],\n CAST(SUM(_base._v) AS FLOAT) AS [orders___amount_sum_host]\n FROM (\n SELECT\n customers__regions__region_events.value AS [orders___customers___regions___region_events___value],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at_month],\n orders.id AS _ek0,\n MAX(orders.amount) AS _v\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n LEFT JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n NOT orders.id IS NULL\n GROUP BY\n customers__regions__region_events.value,\n DATETRUNC(month, orders.ordered_at),\n orders.id\n ) AS _base\n GROUP BY\n _base.[orders___customers___regions___region_events___value],\n _base.[orders___ordered_at_month]\n), base AS (\n SELECT\n _base.[orders___customers___regions___region_events___value] AS [orders___customers___regions___region_events___value],\n _base.[orders___ordered_at] AS [orders___ordered_at],\n _cm_orders__amount_sum.[orders___amount_sum_host] AS [orders___amount_sum_host]\n FROM _base\n LEFT JOIN _cm_orders__amount_sum\n ON (\n _base.[orders___customers___regions___region_events___value] = _cm_orders__amount_sum.[orders___customers___regions___region_events___value]\n OR (\n _base.[orders___customers___regions___region_events___value] IS NULL\n AND _cm_orders__amount_sum.[orders___customers___regions___region_events___value] IS NULL\n )\n )\n AND (\n _base.[orders___ordered_at] = _cm_orders__amount_sum.[orders___ordered_at_month]\n OR (\n _base.[orders___ordered_at] IS NULL\n AND _cm_orders__amount_sum.[orders___ordered_at_month] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n customers__regions__region_events.value AS [orders___customers___regions___region_events___value],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n LEFT JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n GROUP BY\n customers__regions__region_events.value,\n DATETRUNC(month, orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[orders___customers___regions___region_events___value] AS [orders___customers___regions___region_events___value],\n _base_2.[orders___ordered_at] AS [orders___ordered_at],\n _cm_orders__amount_sum.[orders___amount_sum_host] AS [orders___amount_sum]\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum\n ON (\n _base_2.[orders___customers___regions___region_events___value] = _cm_orders__amount_sum.[orders___customers___regions___region_events___value]\n OR (\n _base_2.[orders___customers___regions___region_events___value] IS NULL\n AND _cm_orders__amount_sum.[orders___customers___regions___region_events___value] IS NULL\n )\n )\n AND (\n _base_2.[orders___ordered_at] = _cm_orders__amount_sum.[orders___ordered_at_month]\n OR (\n _base_2.[orders___ordered_at] IS NULL\n AND _cm_orders__amount_sum.[orders___ordered_at_month] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[orders___customers___regions___region_events___value] AS [orders___customers___regions___region_events___value],\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[orders___amount_sum_host] AS [orders___amount_sum_host],\n shifted_t.[orders___amount_sum] AS [orders___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[orders___customers___regions___region_events___value] = shifted_t.[orders___customers___regions___region_events___value]\n OR (\n base.[orders___customers___regions___region_events___value] IS NULL\n AND shifted_t.[orders___customers___regions___region_events___value] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted_t.[orders___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND shifted_t.[orders___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [orders___customers___regions___region_events___value],\n [orders___ordered_at],\n [orders___t]\nFROM (\n SELECT\n [orders___customers___regions___region_events___value],\n [orders___ordered_at],\n [orders___amount_sum_host],\n [orders___t]\n FROM sjoin_t\n) AS _outer", - "population/association_filter::bigquery": "WITH _base AS (\n SELECT\n orders.status AS `orders___status`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum_partition_by_ordered_at`\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`orders___status`,\n _base.`orders___ordered_at`,\n _base.`orders___amount_sum`,\n _cm_orders__amount_sum_partition_by_ordered_at.`orders___amount_sum_partition_by_ordered_at` AS `orders___amount_sum_partition_by_ordered_at`\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_ordered_at.`orders___ordered_at`\n), _base_2 AS (\n SELECT\n orders.status AS `orders___status`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted_t AS (\n SELECT\n _base_2.`orders___status`,\n _base_2.`orders___ordered_at`,\n _base_2.`orders___amount_sum` / _cm_orders__amount_sum_partition_by_ordered_at.`orders___amount_sum_partition_by_ordered_at` AS `orders___shifted`\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON _base_2.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_ordered_at.`orders___ordered_at`\n), sjoin_t AS (\n SELECT\n base.`orders___status`,\n base.`orders___ordered_at`,\n base.`orders___amount_sum`,\n base.`orders___amount_sum_partition_by_ordered_at`,\n shifted_t.`orders___shifted` AS `orders___t`\n FROM base\n LEFT JOIN shifted_t\n ON base.`orders___status` IS NOT DISTINCT FROM shifted_t.`orders___status`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`orders___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`orders___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___t`\nFROM (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___amount_sum_partition_by_ordered_at`,\n `orders___t`\n FROM sjoin_t\n) AS _outer", - "population/association_filter::duckdb": "WITH _base AS (\n SELECT\n orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum_partition_by_ordered_at\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), base AS (\n SELECT\n _base.\"orders.status\",\n _base.\"orders.ordered_at\",\n _base.\"orders.amount_sum\",\n _cm_orders__amount_sum_partition_by_ordered_at.\"orders.amount_sum_partition_by_ordered_at\" AS \"orders.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_ordered_at.\"orders.ordered_at\"\n), _base_2 AS (\n SELECT\n orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"orders.status\",\n _base_2.\"orders.ordered_at\",\n _base_2.\"orders.amount_sum\" / _cm_orders__amount_sum_partition_by_ordered_at.\"orders.amount_sum_partition_by_ordered_at\" AS \"orders.shifted\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON _base_2.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_ordered_at.\"orders.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"orders.status\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.amount_sum_partition_by_ordered_at\",\n shifted_t.\"orders.shifted\" AS \"orders.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"orders.status\" IS NOT DISTINCT FROM shifted_t.\"orders.status\"\n AND base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"orders.ordered_at\"\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.amount_sum_partition_by_ordered_at\",\n \"orders.t\"\n FROM sjoin_t\n) AS _outer", - "population/association_filter::postgres": "WITH _base AS (\n SELECT\n orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum_partition_by_ordered_at\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), base AS (\n SELECT\n _base.\"orders.status\",\n _base.\"orders.ordered_at\",\n _base.\"orders.amount_sum\",\n _cm_orders__amount_sum_partition_by_ordered_at.\"orders.amount_sum_partition_by_ordered_at\" AS \"orders.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_ordered_at.\"orders.ordered_at\"\n), _base_2 AS (\n SELECT\n orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"orders.status\",\n _base_2.\"orders.ordered_at\",\n CAST(_base_2.\"orders.amount_sum\" AS DOUBLE PRECISION) / _cm_orders__amount_sum_partition_by_ordered_at.\"orders.amount_sum_partition_by_ordered_at\" AS \"orders.shifted\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON _base_2.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_ordered_at.\"orders.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"orders.status\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.amount_sum_partition_by_ordered_at\",\n shifted_t.\"orders.shifted\" AS \"orders.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"orders.status\" IS NOT DISTINCT FROM shifted_t.\"orders.status\"\n AND base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"orders.ordered_at\"\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.amount_sum_partition_by_ordered_at\",\n \"orders.t\"\n FROM sjoin_t\n) AS _outer", - "population/association_filter::sqlite": "WITH _base AS (\n SELECT\n orders.status AS \"orders.status\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__amount_sum_partition_by_ordered_at AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum_partition_by_ordered_at\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), base AS (\n SELECT\n _base.\"orders.status\",\n _base.\"orders.ordered_at\",\n _base.\"orders.amount_sum\",\n _cm_orders__amount_sum_partition_by_ordered_at.\"orders.amount_sum_partition_by_ordered_at\" AS \"orders.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON _base.\"orders.ordered_at\" IS _cm_orders__amount_sum_partition_by_ordered_at.\"orders.ordered_at\"\n), _base_2 AS (\n SELECT\n orders.status AS \"orders.status\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"orders.status\",\n _base_2.\"orders.ordered_at\",\n CAST(_base_2.\"orders.amount_sum\" AS REAL) / _cm_orders__amount_sum_partition_by_ordered_at.\"orders.amount_sum_partition_by_ordered_at\" AS \"orders.shifted\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON _base_2.\"orders.ordered_at\" IS _cm_orders__amount_sum_partition_by_ordered_at.\"orders.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"orders.status\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.amount_sum_partition_by_ordered_at\",\n shifted_t.\"orders.shifted\" AS \"orders.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"orders.status\" IS shifted_t.\"orders.status\"\n AND SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted_t.\"orders.ordered_at\"\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.amount_sum_partition_by_ordered_at\",\n \"orders.t\"\n FROM sjoin_t\n) AS _outer", - "population/association_filter::tsql": "WITH _base AS (\n SELECT\n orders.status AS [orders___status],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n DATETRUNC(month, orders.ordered_at)\n), _cm_orders__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___amount_sum_partition_by_ordered_at]\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), base AS (\n SELECT\n _base.[orders___status] AS [orders___status],\n _base.[orders___ordered_at] AS [orders___ordered_at],\n _base.[orders___amount_sum] AS [orders___amount_sum],\n _cm_orders__amount_sum_partition_by_ordered_at.[orders___amount_sum_partition_by_ordered_at] AS [orders___amount_sum_partition_by_ordered_at]\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON (\n _base.[orders___ordered_at] = _cm_orders__amount_sum_partition_by_ordered_at.[orders___ordered_at]\n OR (\n _base.[orders___ordered_at] IS NULL\n AND _cm_orders__amount_sum_partition_by_ordered_at.[orders___ordered_at] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n orders.status AS [orders___status],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n DATETRUNC(month, orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[orders___status] AS [orders___status],\n _base_2.[orders___ordered_at] AS [orders___ordered_at],\n CAST(_base_2.[orders___amount_sum] AS FLOAT) / _cm_orders__amount_sum_partition_by_ordered_at.[orders___amount_sum_partition_by_ordered_at] AS [orders___shifted]\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON (\n _base_2.[orders___ordered_at] = _cm_orders__amount_sum_partition_by_ordered_at.[orders___ordered_at]\n OR (\n _base_2.[orders___ordered_at] IS NULL\n AND _cm_orders__amount_sum_partition_by_ordered_at.[orders___ordered_at] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[orders___status] AS [orders___status],\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[orders___amount_sum] AS [orders___amount_sum],\n base.[orders___amount_sum_partition_by_ordered_at] AS [orders___amount_sum_partition_by_ordered_at],\n shifted_t.[orders___shifted] AS [orders___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[orders___status] = shifted_t.[orders___status]\n OR (\n base.[orders___status] IS NULL AND shifted_t.[orders___status] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted_t.[orders___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND shifted_t.[orders___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [orders___status],\n [orders___ordered_at],\n [orders___t]\nFROM (\n SELECT\n [orders___status],\n [orders___ordered_at],\n [orders___amount_sum],\n [orders___amount_sum_partition_by_ordered_at],\n [orders___t]\n FROM sjoin_t\n) AS _outer", + "population/association_filter::bigquery": "WITH _base AS (\n SELECT\n orders.status AS `orders___status`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum_partition_by_ordered_at`\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n DATE_TRUNC(orders.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`orders___status`,\n _base.`orders___ordered_at`,\n _base.`orders___amount_sum`,\n _cm_orders__amount_sum_partition_by_ordered_at.`orders___amount_sum_partition_by_ordered_at` AS `orders___amount_sum_partition_by_ordered_at`\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_ordered_at.`orders___ordered_at`\n), _base_2 AS (\n SELECT\n orders.status AS `orders___status`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted_t AS (\n SELECT\n _base_2.`orders___status`,\n _base_2.`orders___ordered_at`,\n _base_2.`orders___amount_sum` / NULLIF(\n _cm_orders__amount_sum_partition_by_ordered_at.`orders___amount_sum_partition_by_ordered_at`,\n 0\n ) AS `orders___shifted`\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON _base_2.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_ordered_at.`orders___ordered_at`\n), sjoin_t AS (\n SELECT\n base.`orders___status`,\n base.`orders___ordered_at`,\n base.`orders___amount_sum`,\n base.`orders___amount_sum_partition_by_ordered_at`,\n shifted_t.`orders___shifted` AS `orders___t`\n FROM base\n LEFT JOIN shifted_t\n ON base.`orders___status` IS NOT DISTINCT FROM shifted_t.`orders___status`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`orders___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`orders___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___t`\nFROM (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___amount_sum_partition_by_ordered_at`,\n `orders___t`\n FROM sjoin_t\n) AS _outer", + "population/association_filter::duckdb": "WITH _base AS (\n SELECT\n orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum_partition_by_ordered_at\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), base AS (\n SELECT\n _base.\"orders.status\",\n _base.\"orders.ordered_at\",\n _base.\"orders.amount_sum\",\n _cm_orders__amount_sum_partition_by_ordered_at.\"orders.amount_sum_partition_by_ordered_at\" AS \"orders.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_ordered_at.\"orders.ordered_at\"\n), _base_2 AS (\n SELECT\n orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"orders.status\",\n _base_2.\"orders.ordered_at\",\n _base_2.\"orders.amount_sum\" / NULLIF(\n _cm_orders__amount_sum_partition_by_ordered_at.\"orders.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"orders.shifted\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON _base_2.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_ordered_at.\"orders.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"orders.status\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.amount_sum_partition_by_ordered_at\",\n shifted_t.\"orders.shifted\" AS \"orders.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"orders.status\" IS NOT DISTINCT FROM shifted_t.\"orders.status\"\n AND base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"orders.ordered_at\"\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.amount_sum_partition_by_ordered_at\",\n \"orders.t\"\n FROM sjoin_t\n) AS _outer", + "population/association_filter::postgres": "WITH _base AS (\n SELECT\n orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum_partition_by_ordered_at\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n DATE_TRUNC('MONTH', orders.ordered_at)\n), base AS (\n SELECT\n _base.\"orders.status\",\n _base.\"orders.ordered_at\",\n _base.\"orders.amount_sum\",\n _cm_orders__amount_sum_partition_by_ordered_at.\"orders.amount_sum_partition_by_ordered_at\" AS \"orders.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_ordered_at.\"orders.ordered_at\"\n), _base_2 AS (\n SELECT\n orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"orders.status\",\n _base_2.\"orders.ordered_at\",\n CAST(_base_2.\"orders.amount_sum\" AS DOUBLE PRECISION) / NULLIF(\n _cm_orders__amount_sum_partition_by_ordered_at.\"orders.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"orders.shifted\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON _base_2.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_ordered_at.\"orders.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"orders.status\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.amount_sum_partition_by_ordered_at\",\n shifted_t.\"orders.shifted\" AS \"orders.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"orders.status\" IS NOT DISTINCT FROM shifted_t.\"orders.status\"\n AND base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"orders.ordered_at\"\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.amount_sum_partition_by_ordered_at\",\n \"orders.t\"\n FROM sjoin_t\n) AS _outer", + "population/association_filter::sqlite": "WITH _base AS (\n SELECT\n orders.status AS \"orders.status\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__amount_sum_partition_by_ordered_at AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum_partition_by_ordered_at\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), base AS (\n SELECT\n _base.\"orders.status\",\n _base.\"orders.ordered_at\",\n _base.\"orders.amount_sum\",\n _cm_orders__amount_sum_partition_by_ordered_at.\"orders.amount_sum_partition_by_ordered_at\" AS \"orders.amount_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON _base.\"orders.ordered_at\" IS _cm_orders__amount_sum_partition_by_ordered_at.\"orders.ordered_at\"\n), _base_2 AS (\n SELECT\n orders.status AS \"orders.status\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"orders.status\",\n _base_2.\"orders.ordered_at\",\n CAST(_base_2.\"orders.amount_sum\" AS REAL) / NULLIF(\n _cm_orders__amount_sum_partition_by_ordered_at.\"orders.amount_sum_partition_by_ordered_at\",\n 0\n ) AS \"orders.shifted\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON _base_2.\"orders.ordered_at\" IS _cm_orders__amount_sum_partition_by_ordered_at.\"orders.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"orders.status\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.amount_sum_partition_by_ordered_at\",\n shifted_t.\"orders.shifted\" AS \"orders.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"orders.status\" IS shifted_t.\"orders.status\"\n AND SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted_t.\"orders.ordered_at\"\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.amount_sum_partition_by_ordered_at\",\n \"orders.t\"\n FROM sjoin_t\n) AS _outer", + "population/association_filter::tsql": "WITH _base AS (\n SELECT\n orders.status AS [orders___status],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n DATETRUNC(month, orders.ordered_at)\n), _cm_orders__amount_sum_partition_by_ordered_at AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___amount_sum_partition_by_ordered_at]\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n DATETRUNC(month, orders.ordered_at)\n), base AS (\n SELECT\n _base.[orders___status] AS [orders___status],\n _base.[orders___ordered_at] AS [orders___ordered_at],\n _base.[orders___amount_sum] AS [orders___amount_sum],\n _cm_orders__amount_sum_partition_by_ordered_at.[orders___amount_sum_partition_by_ordered_at] AS [orders___amount_sum_partition_by_ordered_at]\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON (\n _base.[orders___ordered_at] = _cm_orders__amount_sum_partition_by_ordered_at.[orders___ordered_at]\n OR (\n _base.[orders___ordered_at] IS NULL\n AND _cm_orders__amount_sum_partition_by_ordered_at.[orders___ordered_at] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n orders.status AS [orders___status],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n WHERE\n EXISTS(\n SELECT\n 1\n FROM customers AS customers\n INNER JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\n INNER JOIN region_events AS customers__regions__region_events\n ON customers__regions.id = customers__regions__region_events.region_id\n WHERE\n orders.customer_id = customers.id\n AND customers__regions__region_events.value > 40\n )\n GROUP BY\n orders.status,\n DATETRUNC(month, orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[orders___status] AS [orders___status],\n _base_2.[orders___ordered_at] AS [orders___ordered_at],\n CAST(_base_2.[orders___amount_sum] AS FLOAT) / NULLIF(\n _cm_orders__amount_sum_partition_by_ordered_at.[orders___amount_sum_partition_by_ordered_at],\n 0\n ) AS [orders___shifted]\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_ordered_at\n ON (\n _base_2.[orders___ordered_at] = _cm_orders__amount_sum_partition_by_ordered_at.[orders___ordered_at]\n OR (\n _base_2.[orders___ordered_at] IS NULL\n AND _cm_orders__amount_sum_partition_by_ordered_at.[orders___ordered_at] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[orders___status] AS [orders___status],\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[orders___amount_sum] AS [orders___amount_sum],\n base.[orders___amount_sum_partition_by_ordered_at] AS [orders___amount_sum_partition_by_ordered_at],\n shifted_t.[orders___shifted] AS [orders___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[orders___status] = shifted_t.[orders___status]\n OR (\n base.[orders___status] IS NULL AND shifted_t.[orders___status] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted_t.[orders___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND shifted_t.[orders___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [orders___status],\n [orders___ordered_at],\n [orders___t]\nFROM (\n SELECT\n [orders___status],\n [orders___ordered_at],\n [orders___amount_sum],\n [orders___amount_sum_partition_by_ordered_at],\n [orders___t]\n FROM sjoin_t\n) AS _outer", "population/fanning_partition::bigquery": { "error": "PartitionKeyError", "message": "PartitionKeyError: The partition_by column 'customers.regions.region_events.value' crosses a fanning or unproven join hop to region_events; every partition key must be attributable from the aggregate's root.\n at aggregation 'sum'\n suggestion: Declare join cardinality or a covering unique key on the target." @@ -109,14 +109,14 @@ "error": "PartitionKeyError", "message": "PartitionKeyError: The partition_by column 'customers.regions.region_events.value' crosses a fanning or unproven join hop to region_events; every partition key must be attributable from the aggregate's root.\n at aggregation 'sum'\n suggestion: Declare join cardinality or a covering unique key on the target." }, - "population/tier_partition::bigquery": "WITH _base AS (\n SELECT\n customers.tier AS `orders___customers___tier`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_sum_partition_by_customers_tier AS (\n SELECT\n customers.tier AS `orders___customers___tier`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum_partition_by_customers_tier`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), base AS (\n SELECT\n _base.`orders___customers___tier`,\n _base.`orders___ordered_at`,\n _base.`orders___amount_sum`,\n _cm_orders__amount_sum_partition_by_customers_tier.`orders___amount_sum_partition_by_customers_tier` AS `orders___amount_sum_partition_by_customers_tier`\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON _base.`orders___customers___tier` IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_customers_tier.`orders___customers___tier`\n), _base_2 AS (\n SELECT\n customers.tier AS `orders___customers___tier`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted_t AS (\n SELECT\n _base_2.`orders___customers___tier`,\n _base_2.`orders___ordered_at`,\n _base_2.`orders___amount_sum` / _cm_orders__amount_sum_partition_by_customers_tier.`orders___amount_sum_partition_by_customers_tier` AS `orders___shifted`\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON _base_2.`orders___customers___tier` IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_customers_tier.`orders___customers___tier`\n), sjoin_t AS (\n SELECT\n base.`orders___customers___tier`,\n base.`orders___ordered_at`,\n base.`orders___amount_sum`,\n base.`orders___amount_sum_partition_by_customers_tier`,\n shifted_t.`orders___shifted` AS `orders___t`\n FROM base\n LEFT JOIN shifted_t\n ON base.`orders___customers___tier` IS NOT DISTINCT FROM shifted_t.`orders___customers___tier`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`orders___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`orders___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `orders___customers___tier`,\n `orders___ordered_at`,\n `orders___t`\nFROM (\n SELECT\n `orders___customers___tier`,\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___amount_sum_partition_by_customers_tier`,\n `orders___t`\n FROM sjoin_t\n) AS _outer", - "population/tier_partition::duckdb": "WITH _base AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_partition_by_customers_tier AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum_partition_by_customers_tier\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), base AS (\n SELECT\n _base.\"orders.customers.tier\",\n _base.\"orders.ordered_at\",\n _base.\"orders.amount_sum\",\n _cm_orders__amount_sum_partition_by_customers_tier.\"orders.amount_sum_partition_by_customers_tier\" AS \"orders.amount_sum_partition_by_customers_tier\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON _base.\"orders.customers.tier\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_customers_tier.\"orders.customers.tier\"\n), _base_2 AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"orders.customers.tier\",\n _base_2.\"orders.ordered_at\",\n _base_2.\"orders.amount_sum\" / _cm_orders__amount_sum_partition_by_customers_tier.\"orders.amount_sum_partition_by_customers_tier\" AS \"orders.shifted\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON _base_2.\"orders.customers.tier\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_customers_tier.\"orders.customers.tier\"\n), sjoin_t AS (\n SELECT\n base.\"orders.customers.tier\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.amount_sum_partition_by_customers_tier\",\n shifted_t.\"orders.shifted\" AS \"orders.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"orders.customers.tier\" IS NOT DISTINCT FROM shifted_t.\"orders.customers.tier\"\n AND base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"orders.ordered_at\"\n)\nSELECT\n \"orders.customers.tier\",\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.customers.tier\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.amount_sum_partition_by_customers_tier\",\n \"orders.t\"\n FROM sjoin_t\n) AS _outer", - "population/tier_partition::postgres": "WITH _base AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_partition_by_customers_tier AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum_partition_by_customers_tier\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), base AS (\n SELECT\n _base.\"orders.customers.tier\",\n _base.\"orders.ordered_at\",\n _base.\"orders.amount_sum\",\n _cm_orders__amount_sum_partition_by_customers_tier.\"orders.amount_sum_partition_by_customers_tier\" AS \"orders.amount_sum_partition_by_customers_tier\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON _base.\"orders.customers.tier\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_customers_tier.\"orders.customers.tier\"\n), _base_2 AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"orders.customers.tier\",\n _base_2.\"orders.ordered_at\",\n CAST(_base_2.\"orders.amount_sum\" AS DOUBLE PRECISION) / _cm_orders__amount_sum_partition_by_customers_tier.\"orders.amount_sum_partition_by_customers_tier\" AS \"orders.shifted\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON _base_2.\"orders.customers.tier\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_customers_tier.\"orders.customers.tier\"\n), sjoin_t AS (\n SELECT\n base.\"orders.customers.tier\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.amount_sum_partition_by_customers_tier\",\n shifted_t.\"orders.shifted\" AS \"orders.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"orders.customers.tier\" IS NOT DISTINCT FROM shifted_t.\"orders.customers.tier\"\n AND base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"orders.ordered_at\"\n)\nSELECT\n \"orders.customers.tier\",\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.customers.tier\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.amount_sum_partition_by_customers_tier\",\n \"orders.t\"\n FROM sjoin_t\n) AS _outer", - "population/tier_partition::sqlite": "WITH _base AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__amount_sum_partition_by_customers_tier AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum_partition_by_customers_tier\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), base AS (\n SELECT\n _base.\"orders.customers.tier\",\n _base.\"orders.ordered_at\",\n _base.\"orders.amount_sum\",\n _cm_orders__amount_sum_partition_by_customers_tier.\"orders.amount_sum_partition_by_customers_tier\" AS \"orders.amount_sum_partition_by_customers_tier\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON _base.\"orders.customers.tier\" IS _cm_orders__amount_sum_partition_by_customers_tier.\"orders.customers.tier\"\n), _base_2 AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"orders.customers.tier\",\n _base_2.\"orders.ordered_at\",\n CAST(_base_2.\"orders.amount_sum\" AS REAL) / _cm_orders__amount_sum_partition_by_customers_tier.\"orders.amount_sum_partition_by_customers_tier\" AS \"orders.shifted\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON _base_2.\"orders.customers.tier\" IS _cm_orders__amount_sum_partition_by_customers_tier.\"orders.customers.tier\"\n), sjoin_t AS (\n SELECT\n base.\"orders.customers.tier\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.amount_sum_partition_by_customers_tier\",\n shifted_t.\"orders.shifted\" AS \"orders.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"orders.customers.tier\" IS shifted_t.\"orders.customers.tier\"\n AND SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted_t.\"orders.ordered_at\"\n)\nSELECT\n \"orders.customers.tier\",\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.customers.tier\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.amount_sum_partition_by_customers_tier\",\n \"orders.t\"\n FROM sjoin_t\n) AS _outer", - "population/tier_partition::tsql": "WITH _base AS (\n SELECT\n customers.tier AS [orders___customers___tier],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n DATETRUNC(month, orders.ordered_at)\n), _cm_orders__amount_sum_partition_by_customers_tier AS (\n SELECT\n customers.tier AS [orders___customers___tier],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___amount_sum_partition_by_customers_tier]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), base AS (\n SELECT\n _base.[orders___customers___tier] AS [orders___customers___tier],\n _base.[orders___ordered_at] AS [orders___ordered_at],\n _base.[orders___amount_sum] AS [orders___amount_sum],\n _cm_orders__amount_sum_partition_by_customers_tier.[orders___amount_sum_partition_by_customers_tier] AS [orders___amount_sum_partition_by_customers_tier]\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON (\n _base.[orders___customers___tier] = _cm_orders__amount_sum_partition_by_customers_tier.[orders___customers___tier]\n OR (\n _base.[orders___customers___tier] IS NULL\n AND _cm_orders__amount_sum_partition_by_customers_tier.[orders___customers___tier] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n customers.tier AS [orders___customers___tier],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n DATETRUNC(month, orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[orders___customers___tier] AS [orders___customers___tier],\n _base_2.[orders___ordered_at] AS [orders___ordered_at],\n CAST(_base_2.[orders___amount_sum] AS FLOAT) / _cm_orders__amount_sum_partition_by_customers_tier.[orders___amount_sum_partition_by_customers_tier] AS [orders___shifted]\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON (\n _base_2.[orders___customers___tier] = _cm_orders__amount_sum_partition_by_customers_tier.[orders___customers___tier]\n OR (\n _base_2.[orders___customers___tier] IS NULL\n AND _cm_orders__amount_sum_partition_by_customers_tier.[orders___customers___tier] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[orders___customers___tier] AS [orders___customers___tier],\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[orders___amount_sum] AS [orders___amount_sum],\n base.[orders___amount_sum_partition_by_customers_tier] AS [orders___amount_sum_partition_by_customers_tier],\n shifted_t.[orders___shifted] AS [orders___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[orders___customers___tier] = shifted_t.[orders___customers___tier]\n OR (\n base.[orders___customers___tier] IS NULL\n AND shifted_t.[orders___customers___tier] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted_t.[orders___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND shifted_t.[orders___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [orders___customers___tier],\n [orders___ordered_at],\n [orders___t]\nFROM (\n SELECT\n [orders___customers___tier],\n [orders___ordered_at],\n [orders___amount_sum],\n [orders___amount_sum_partition_by_customers_tier],\n [orders___t]\n FROM sjoin_t\n) AS _outer", - "stage/share::bigquery": "WITH __slayer_stage_s1 AS (\n SELECT\n _stage_inner.`monthly___region` AS `region`,\n _stage_inner.`monthly___ordered_at` AS `ordered_at`,\n _stage_inner.`monthly___rev` AS `rev`\n FROM (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___rev`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n ) AS _stage_inner\n), _base AS (\n SELECT\n s1.region AS `s1___region`,\n DATE_TRUNC(s1.ordered_at, MONTH) AS `s1___ordered_at`,\n SUM(s1.rev) AS `s1___rev_sum`\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= '2024-02-01 00:00:00' AND s1.ordered_at < '2024-04-01 00:00:00'\n )\n GROUP BY\n s1.region,\n DATE_TRUNC(s1.ordered_at, MONTH)\n), _cm_s1__rev_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC(s1.ordered_at, MONTH) AS `s1___ordered_at`,\n SUM(s1.rev) AS `s1___rev_sum_partition_by_ordered_at`\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= '2024-02-01 00:00:00' AND s1.ordered_at < '2024-04-01 00:00:00'\n )\n GROUP BY\n DATE_TRUNC(s1.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`s1___region`,\n _base.`s1___ordered_at`,\n _base.`s1___rev_sum`,\n _cm_s1__rev_sum_partition_by_ordered_at.`s1___rev_sum_partition_by_ordered_at` AS `s1___rev_sum_partition_by_ordered_at`\n FROM _base\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at\n ON _base.`s1___ordered_at` IS NOT DISTINCT FROM _cm_s1__rev_sum_partition_by_ordered_at.`s1___ordered_at`\n), _base_2 AS (\n SELECT\n s1.region AS `s1___region`,\n DATE_TRUNC(s1.ordered_at, MONTH) AS `s1___ordered_at`,\n SUM(s1.rev) AS `s1___rev_sum`\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n s1.region,\n DATE_TRUNC(s1.ordered_at, MONTH)\n), _cm_s1__rev_sum_partition_by_ordered_at_2 AS (\n SELECT\n DATE_TRUNC(s1.ordered_at, MONTH) AS `s1___ordered_at`,\n SUM(s1.rev) AS `s1___rev_sum_partition_by_ordered_at`\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n DATE_TRUNC(s1.ordered_at, MONTH)\n), shifted_t AS (\n SELECT\n _base_2.`s1___region`,\n _base_2.`s1___ordered_at`,\n _base_2.`s1___rev_sum` / _cm_s1__rev_sum_partition_by_ordered_at_2.`s1___rev_sum_partition_by_ordered_at` AS `s1___shifted`\n FROM _base_2\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at_2\n ON _base_2.`s1___ordered_at` IS NOT DISTINCT FROM _cm_s1__rev_sum_partition_by_ordered_at_2.`s1___ordered_at`\n), sjoin_t AS (\n SELECT\n base.`s1___region`,\n base.`s1___ordered_at`,\n base.`s1___rev_sum`,\n base.`s1___rev_sum_partition_by_ordered_at`,\n shifted_t.`s1___shifted` AS `s1___t`\n FROM base\n LEFT JOIN shifted_t\n ON base.`s1___region` IS NOT DISTINCT FROM shifted_t.`s1___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`s1___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`s1___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `s1___region`,\n `s1___ordered_at`,\n `s1___t`\nFROM (\n SELECT\n `s1___region`,\n `s1___ordered_at`,\n `s1___rev_sum`,\n `s1___rev_sum_partition_by_ordered_at`,\n `s1___t`\n FROM sjoin_t\n) AS _outer", - "stage/share::duckdb": "WITH __slayer_stage_s1 AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.ordered_at\" AS \"ordered_at\",\n _stage_inner.\"monthly.rev\" AS \"rev\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.rev\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n ) AS _stage_inner\n), _base AS (\n SELECT\n s1.region AS \"s1.region\",\n DATE_TRUNC('MONTH', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum\"\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND s1.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n s1.region,\n DATE_TRUNC('MONTH', s1.ordered_at)\n), _cm_s1__rev_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND s1.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n DATE_TRUNC('MONTH', s1.ordered_at)\n), base AS (\n SELECT\n _base.\"s1.region\",\n _base.\"s1.ordered_at\",\n _base.\"s1.rev_sum\",\n _cm_s1__rev_sum_partition_by_ordered_at.\"s1.rev_sum_partition_by_ordered_at\" AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at\n ON _base.\"s1.ordered_at\" IS NOT DISTINCT FROM _cm_s1__rev_sum_partition_by_ordered_at.\"s1.ordered_at\"\n), _base_2 AS (\n SELECT\n s1.region AS \"s1.region\",\n DATE_TRUNC('MONTH', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum\"\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n s1.region,\n DATE_TRUNC('MONTH', s1.ordered_at)\n), _cm_s1__rev_sum_partition_by_ordered_at_2 AS (\n SELECT\n DATE_TRUNC('MONTH', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n DATE_TRUNC('MONTH', s1.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"s1.region\",\n _base_2.\"s1.ordered_at\",\n _base_2.\"s1.rev_sum\" / _cm_s1__rev_sum_partition_by_ordered_at_2.\"s1.rev_sum_partition_by_ordered_at\" AS \"s1.shifted\"\n FROM _base_2\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at_2\n ON _base_2.\"s1.ordered_at\" IS NOT DISTINCT FROM _cm_s1__rev_sum_partition_by_ordered_at_2.\"s1.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"s1.region\",\n base.\"s1.ordered_at\",\n base.\"s1.rev_sum\",\n base.\"s1.rev_sum_partition_by_ordered_at\",\n shifted_t.\"s1.shifted\" AS \"s1.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"s1.region\" IS NOT DISTINCT FROM shifted_t.\"s1.region\"\n AND base.\"s1.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"s1.ordered_at\"\n)\nSELECT\n \"s1.region\",\n \"s1.ordered_at\",\n \"s1.t\"\nFROM (\n SELECT\n \"s1.region\",\n \"s1.ordered_at\",\n \"s1.rev_sum\",\n \"s1.rev_sum_partition_by_ordered_at\",\n \"s1.t\"\n FROM sjoin_t\n) AS _outer", - "stage/share::postgres": "WITH __slayer_stage_s1 AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.ordered_at\" AS \"ordered_at\",\n _stage_inner.\"monthly.rev\" AS \"rev\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.rev\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n ) AS _stage_inner\n), _base AS (\n SELECT\n s1.region AS \"s1.region\",\n DATE_TRUNC('MONTH', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum\"\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND s1.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n s1.region,\n DATE_TRUNC('MONTH', s1.ordered_at)\n), _cm_s1__rev_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND s1.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n DATE_TRUNC('MONTH', s1.ordered_at)\n), base AS (\n SELECT\n _base.\"s1.region\",\n _base.\"s1.ordered_at\",\n _base.\"s1.rev_sum\",\n _cm_s1__rev_sum_partition_by_ordered_at.\"s1.rev_sum_partition_by_ordered_at\" AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at\n ON _base.\"s1.ordered_at\" IS NOT DISTINCT FROM _cm_s1__rev_sum_partition_by_ordered_at.\"s1.ordered_at\"\n), _base_2 AS (\n SELECT\n s1.region AS \"s1.region\",\n DATE_TRUNC('MONTH', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum\"\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n s1.region,\n DATE_TRUNC('MONTH', s1.ordered_at)\n), _cm_s1__rev_sum_partition_by_ordered_at_2 AS (\n SELECT\n DATE_TRUNC('MONTH', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n DATE_TRUNC('MONTH', s1.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"s1.region\",\n _base_2.\"s1.ordered_at\",\n CAST(_base_2.\"s1.rev_sum\" AS DOUBLE PRECISION) / _cm_s1__rev_sum_partition_by_ordered_at_2.\"s1.rev_sum_partition_by_ordered_at\" AS \"s1.shifted\"\n FROM _base_2\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at_2\n ON _base_2.\"s1.ordered_at\" IS NOT DISTINCT FROM _cm_s1__rev_sum_partition_by_ordered_at_2.\"s1.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"s1.region\",\n base.\"s1.ordered_at\",\n base.\"s1.rev_sum\",\n base.\"s1.rev_sum_partition_by_ordered_at\",\n shifted_t.\"s1.shifted\" AS \"s1.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"s1.region\" IS NOT DISTINCT FROM shifted_t.\"s1.region\"\n AND base.\"s1.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"s1.ordered_at\"\n)\nSELECT\n \"s1.region\",\n \"s1.ordered_at\",\n \"s1.t\"\nFROM (\n SELECT\n \"s1.region\",\n \"s1.ordered_at\",\n \"s1.rev_sum\",\n \"s1.rev_sum_partition_by_ordered_at\",\n \"s1.t\"\n FROM sjoin_t\n) AS _outer", - "stage/share::sqlite": "WITH __slayer_stage_s1 AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.ordered_at\" AS \"ordered_at\",\n _stage_inner.\"monthly.rev\" AS \"rev\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.rev\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n ) AS _stage_inner\n), _base AS (\n SELECT\n s1.region AS \"s1.region\",\n STRFTIME('%Y-%m-01', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum\"\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= '2024-02-01' AND s1.ordered_at < '2024-04-01'\n )\n GROUP BY\n s1.region,\n STRFTIME('%Y-%m-01', s1.ordered_at)\n), _cm_s1__rev_sum_partition_by_ordered_at AS (\n SELECT\n STRFTIME('%Y-%m-01', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= '2024-02-01' AND s1.ordered_at < '2024-04-01'\n )\n GROUP BY\n STRFTIME('%Y-%m-01', s1.ordered_at)\n), base AS (\n SELECT\n _base.\"s1.region\",\n _base.\"s1.ordered_at\",\n _base.\"s1.rev_sum\",\n _cm_s1__rev_sum_partition_by_ordered_at.\"s1.rev_sum_partition_by_ordered_at\" AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at\n ON _base.\"s1.ordered_at\" IS _cm_s1__rev_sum_partition_by_ordered_at.\"s1.ordered_at\"\n), _base_2 AS (\n SELECT\n s1.region AS \"s1.region\",\n STRFTIME('%Y-%m-01', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum\"\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n s1.region,\n STRFTIME('%Y-%m-01', s1.ordered_at)\n), _cm_s1__rev_sum_partition_by_ordered_at_2 AS (\n SELECT\n STRFTIME('%Y-%m-01', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n STRFTIME('%Y-%m-01', s1.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"s1.region\",\n _base_2.\"s1.ordered_at\",\n CAST(_base_2.\"s1.rev_sum\" AS REAL) / _cm_s1__rev_sum_partition_by_ordered_at_2.\"s1.rev_sum_partition_by_ordered_at\" AS \"s1.shifted\"\n FROM _base_2\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at_2\n ON _base_2.\"s1.ordered_at\" IS _cm_s1__rev_sum_partition_by_ordered_at_2.\"s1.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"s1.region\",\n base.\"s1.ordered_at\",\n base.\"s1.rev_sum\",\n base.\"s1.rev_sum_partition_by_ordered_at\",\n shifted_t.\"s1.shifted\" AS \"s1.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"s1.region\" IS shifted_t.\"s1.region\"\n AND SLAYER_DATE_ADD(base.\"s1.ordered_at\", -1, 'month') IS shifted_t.\"s1.ordered_at\"\n)\nSELECT\n \"s1.region\",\n \"s1.ordered_at\",\n \"s1.t\"\nFROM (\n SELECT\n \"s1.region\",\n \"s1.ordered_at\",\n \"s1.rev_sum\",\n \"s1.rev_sum_partition_by_ordered_at\",\n \"s1.t\"\n FROM sjoin_t\n) AS _outer", - "stage/share::tsql": "WITH __slayer_stage_s1 AS (\n SELECT\n _stage_inner.[monthly___region] AS [region],\n _stage_inner.[monthly___ordered_at] AS [ordered_at],\n _stage_inner.[monthly___rev] AS [rev]\n FROM (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___rev]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n ) AS _stage_inner\n), _base AS (\n SELECT\n s1.region AS [s1___region],\n DATETRUNC(month, s1.ordered_at) AS [s1___ordered_at],\n SUM(s1.rev) AS [s1___rev_sum]\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= CAST('2024-02-01 00:00:00' AS DATETIME2)\n AND s1.ordered_at < CAST('2024-04-01 00:00:00' AS DATETIME2)\n )\n GROUP BY\n s1.region,\n DATETRUNC(month, s1.ordered_at)\n), _cm_s1__rev_sum_partition_by_ordered_at AS (\n SELECT\n DATETRUNC(month, s1.ordered_at) AS [s1___ordered_at],\n SUM(s1.rev) AS [s1___rev_sum_partition_by_ordered_at]\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= CAST('2024-02-01 00:00:00' AS DATETIME2)\n AND s1.ordered_at < CAST('2024-04-01 00:00:00' AS DATETIME2)\n )\n GROUP BY\n DATETRUNC(month, s1.ordered_at)\n), base AS (\n SELECT\n _base.[s1___region] AS [s1___region],\n _base.[s1___ordered_at] AS [s1___ordered_at],\n _base.[s1___rev_sum] AS [s1___rev_sum],\n _cm_s1__rev_sum_partition_by_ordered_at.[s1___rev_sum_partition_by_ordered_at] AS [s1___rev_sum_partition_by_ordered_at]\n FROM _base\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at\n ON (\n _base.[s1___ordered_at] = _cm_s1__rev_sum_partition_by_ordered_at.[s1___ordered_at]\n OR (\n _base.[s1___ordered_at] IS NULL\n AND _cm_s1__rev_sum_partition_by_ordered_at.[s1___ordered_at] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n s1.region AS [s1___region],\n DATETRUNC(month, s1.ordered_at) AS [s1___ordered_at],\n SUM(s1.rev) AS [s1___rev_sum]\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n s1.region,\n DATETRUNC(month, s1.ordered_at)\n), _cm_s1__rev_sum_partition_by_ordered_at_2 AS (\n SELECT\n DATETRUNC(month, s1.ordered_at) AS [s1___ordered_at],\n SUM(s1.rev) AS [s1___rev_sum_partition_by_ordered_at]\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n DATETRUNC(month, s1.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[s1___region] AS [s1___region],\n _base_2.[s1___ordered_at] AS [s1___ordered_at],\n CAST(_base_2.[s1___rev_sum] AS FLOAT) / _cm_s1__rev_sum_partition_by_ordered_at_2.[s1___rev_sum_partition_by_ordered_at] AS [s1___shifted]\n FROM _base_2\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at_2\n ON (\n _base_2.[s1___ordered_at] = _cm_s1__rev_sum_partition_by_ordered_at_2.[s1___ordered_at]\n OR (\n _base_2.[s1___ordered_at] IS NULL\n AND _cm_s1__rev_sum_partition_by_ordered_at_2.[s1___ordered_at] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[s1___region] AS [s1___region],\n base.[s1___ordered_at] AS [s1___ordered_at],\n base.[s1___rev_sum] AS [s1___rev_sum],\n base.[s1___rev_sum_partition_by_ordered_at] AS [s1___rev_sum_partition_by_ordered_at],\n shifted_t.[s1___shifted] AS [s1___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[s1___region] = shifted_t.[s1___region]\n OR (\n base.[s1___region] IS NULL AND shifted_t.[s1___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[s1___ordered_at]) = shifted_t.[s1___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[s1___ordered_at]) IS NULL\n AND shifted_t.[s1___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [s1___region],\n [s1___ordered_at],\n [s1___t]\nFROM (\n SELECT\n [s1___region],\n [s1___ordered_at],\n [s1___rev_sum],\n [s1___rev_sum_partition_by_ordered_at],\n [s1___t]\n FROM sjoin_t\n) AS _outer" + "population/tier_partition::bigquery": "WITH _base AS (\n SELECT\n customers.tier AS `orders___customers___tier`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_sum_partition_by_customers_tier AS (\n SELECT\n customers.tier AS `orders___customers___tier`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum_partition_by_customers_tier`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), base AS (\n SELECT\n _base.`orders___customers___tier`,\n _base.`orders___ordered_at`,\n _base.`orders___amount_sum`,\n _cm_orders__amount_sum_partition_by_customers_tier.`orders___amount_sum_partition_by_customers_tier` AS `orders___amount_sum_partition_by_customers_tier`\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON _base.`orders___customers___tier` IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_customers_tier.`orders___customers___tier`\n), _base_2 AS (\n SELECT\n customers.tier AS `orders___customers___tier`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted_t AS (\n SELECT\n _base_2.`orders___customers___tier`,\n _base_2.`orders___ordered_at`,\n _base_2.`orders___amount_sum` / NULLIF(\n _cm_orders__amount_sum_partition_by_customers_tier.`orders___amount_sum_partition_by_customers_tier`,\n 0\n ) AS `orders___shifted`\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON _base_2.`orders___customers___tier` IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_customers_tier.`orders___customers___tier`\n), sjoin_t AS (\n SELECT\n base.`orders___customers___tier`,\n base.`orders___ordered_at`,\n base.`orders___amount_sum`,\n base.`orders___amount_sum_partition_by_customers_tier`,\n shifted_t.`orders___shifted` AS `orders___t`\n FROM base\n LEFT JOIN shifted_t\n ON base.`orders___customers___tier` IS NOT DISTINCT FROM shifted_t.`orders___customers___tier`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`orders___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`orders___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `orders___customers___tier`,\n `orders___ordered_at`,\n `orders___t`\nFROM (\n SELECT\n `orders___customers___tier`,\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___amount_sum_partition_by_customers_tier`,\n `orders___t`\n FROM sjoin_t\n) AS _outer", + "population/tier_partition::duckdb": "WITH _base AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_partition_by_customers_tier AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum_partition_by_customers_tier\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), base AS (\n SELECT\n _base.\"orders.customers.tier\",\n _base.\"orders.ordered_at\",\n _base.\"orders.amount_sum\",\n _cm_orders__amount_sum_partition_by_customers_tier.\"orders.amount_sum_partition_by_customers_tier\" AS \"orders.amount_sum_partition_by_customers_tier\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON _base.\"orders.customers.tier\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_customers_tier.\"orders.customers.tier\"\n), _base_2 AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"orders.customers.tier\",\n _base_2.\"orders.ordered_at\",\n _base_2.\"orders.amount_sum\" / NULLIF(\n _cm_orders__amount_sum_partition_by_customers_tier.\"orders.amount_sum_partition_by_customers_tier\",\n 0\n ) AS \"orders.shifted\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON _base_2.\"orders.customers.tier\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_customers_tier.\"orders.customers.tier\"\n), sjoin_t AS (\n SELECT\n base.\"orders.customers.tier\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.amount_sum_partition_by_customers_tier\",\n shifted_t.\"orders.shifted\" AS \"orders.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"orders.customers.tier\" IS NOT DISTINCT FROM shifted_t.\"orders.customers.tier\"\n AND base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"orders.ordered_at\"\n)\nSELECT\n \"orders.customers.tier\",\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.customers.tier\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.amount_sum_partition_by_customers_tier\",\n \"orders.t\"\n FROM sjoin_t\n) AS _outer", + "population/tier_partition::postgres": "WITH _base AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_partition_by_customers_tier AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum_partition_by_customers_tier\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), base AS (\n SELECT\n _base.\"orders.customers.tier\",\n _base.\"orders.ordered_at\",\n _base.\"orders.amount_sum\",\n _cm_orders__amount_sum_partition_by_customers_tier.\"orders.amount_sum_partition_by_customers_tier\" AS \"orders.amount_sum_partition_by_customers_tier\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON _base.\"orders.customers.tier\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_customers_tier.\"orders.customers.tier\"\n), _base_2 AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"orders.customers.tier\",\n _base_2.\"orders.ordered_at\",\n CAST(_base_2.\"orders.amount_sum\" AS DOUBLE PRECISION) / NULLIF(\n _cm_orders__amount_sum_partition_by_customers_tier.\"orders.amount_sum_partition_by_customers_tier\",\n 0\n ) AS \"orders.shifted\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON _base_2.\"orders.customers.tier\" IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_customers_tier.\"orders.customers.tier\"\n), sjoin_t AS (\n SELECT\n base.\"orders.customers.tier\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.amount_sum_partition_by_customers_tier\",\n shifted_t.\"orders.shifted\" AS \"orders.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"orders.customers.tier\" IS NOT DISTINCT FROM shifted_t.\"orders.customers.tier\"\n AND base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"orders.ordered_at\"\n)\nSELECT\n \"orders.customers.tier\",\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.customers.tier\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.amount_sum_partition_by_customers_tier\",\n \"orders.t\"\n FROM sjoin_t\n) AS _outer", + "population/tier_partition::sqlite": "WITH _base AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__amount_sum_partition_by_customers_tier AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum_partition_by_customers_tier\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), base AS (\n SELECT\n _base.\"orders.customers.tier\",\n _base.\"orders.ordered_at\",\n _base.\"orders.amount_sum\",\n _cm_orders__amount_sum_partition_by_customers_tier.\"orders.amount_sum_partition_by_customers_tier\" AS \"orders.amount_sum_partition_by_customers_tier\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON _base.\"orders.customers.tier\" IS _cm_orders__amount_sum_partition_by_customers_tier.\"orders.customers.tier\"\n), _base_2 AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"orders.customers.tier\",\n _base_2.\"orders.ordered_at\",\n CAST(_base_2.\"orders.amount_sum\" AS REAL) / NULLIF(\n _cm_orders__amount_sum_partition_by_customers_tier.\"orders.amount_sum_partition_by_customers_tier\",\n 0\n ) AS \"orders.shifted\"\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON _base_2.\"orders.customers.tier\" IS _cm_orders__amount_sum_partition_by_customers_tier.\"orders.customers.tier\"\n), sjoin_t AS (\n SELECT\n base.\"orders.customers.tier\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.amount_sum_partition_by_customers_tier\",\n shifted_t.\"orders.shifted\" AS \"orders.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"orders.customers.tier\" IS shifted_t.\"orders.customers.tier\"\n AND SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted_t.\"orders.ordered_at\"\n)\nSELECT\n \"orders.customers.tier\",\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.customers.tier\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.amount_sum_partition_by_customers_tier\",\n \"orders.t\"\n FROM sjoin_t\n) AS _outer", + "population/tier_partition::tsql": "WITH _base AS (\n SELECT\n customers.tier AS [orders___customers___tier],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n DATETRUNC(month, orders.ordered_at)\n), _cm_orders__amount_sum_partition_by_customers_tier AS (\n SELECT\n customers.tier AS [orders___customers___tier],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___amount_sum_partition_by_customers_tier]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier\n), base AS (\n SELECT\n _base.[orders___customers___tier] AS [orders___customers___tier],\n _base.[orders___ordered_at] AS [orders___ordered_at],\n _base.[orders___amount_sum] AS [orders___amount_sum],\n _cm_orders__amount_sum_partition_by_customers_tier.[orders___amount_sum_partition_by_customers_tier] AS [orders___amount_sum_partition_by_customers_tier]\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON (\n _base.[orders___customers___tier] = _cm_orders__amount_sum_partition_by_customers_tier.[orders___customers___tier]\n OR (\n _base.[orders___customers___tier] IS NULL\n AND _cm_orders__amount_sum_partition_by_customers_tier.[orders___customers___tier] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n customers.tier AS [orders___customers___tier],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n customers.tier,\n DATETRUNC(month, orders.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[orders___customers___tier] AS [orders___customers___tier],\n _base_2.[orders___ordered_at] AS [orders___ordered_at],\n CAST(_base_2.[orders___amount_sum] AS FLOAT) / NULLIF(\n _cm_orders__amount_sum_partition_by_customers_tier.[orders___amount_sum_partition_by_customers_tier],\n 0\n ) AS [orders___shifted]\n FROM _base_2\n LEFT JOIN _cm_orders__amount_sum_partition_by_customers_tier\n ON (\n _base_2.[orders___customers___tier] = _cm_orders__amount_sum_partition_by_customers_tier.[orders___customers___tier]\n OR (\n _base_2.[orders___customers___tier] IS NULL\n AND _cm_orders__amount_sum_partition_by_customers_tier.[orders___customers___tier] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[orders___customers___tier] AS [orders___customers___tier],\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[orders___amount_sum] AS [orders___amount_sum],\n base.[orders___amount_sum_partition_by_customers_tier] AS [orders___amount_sum_partition_by_customers_tier],\n shifted_t.[orders___shifted] AS [orders___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[orders___customers___tier] = shifted_t.[orders___customers___tier]\n OR (\n base.[orders___customers___tier] IS NULL\n AND shifted_t.[orders___customers___tier] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted_t.[orders___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND shifted_t.[orders___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [orders___customers___tier],\n [orders___ordered_at],\n [orders___t]\nFROM (\n SELECT\n [orders___customers___tier],\n [orders___ordered_at],\n [orders___amount_sum],\n [orders___amount_sum_partition_by_customers_tier],\n [orders___t]\n FROM sjoin_t\n) AS _outer", + "stage/share::bigquery": "WITH __slayer_stage_s1 AS (\n SELECT\n _stage_inner.`monthly___region` AS `region`,\n _stage_inner.`monthly___ordered_at` AS `ordered_at`,\n _stage_inner.`monthly___rev` AS `rev`\n FROM (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at`,\n CAST(SUM(monthly.amount) AS FLOAT64) AS `monthly___rev`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n ) AS _stage_inner\n), _base AS (\n SELECT\n s1.region AS `s1___region`,\n DATE_TRUNC(s1.ordered_at, MONTH) AS `s1___ordered_at`,\n SUM(s1.rev) AS `s1___rev_sum`\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= '2024-02-01 00:00:00' AND s1.ordered_at < '2024-04-01 00:00:00'\n )\n GROUP BY\n s1.region,\n DATE_TRUNC(s1.ordered_at, MONTH)\n), _cm_s1__rev_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC(s1.ordered_at, MONTH) AS `s1___ordered_at`,\n SUM(s1.rev) AS `s1___rev_sum_partition_by_ordered_at`\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= '2024-02-01 00:00:00' AND s1.ordered_at < '2024-04-01 00:00:00'\n )\n GROUP BY\n DATE_TRUNC(s1.ordered_at, MONTH)\n), base AS (\n SELECT\n _base.`s1___region`,\n _base.`s1___ordered_at`,\n _base.`s1___rev_sum`,\n _cm_s1__rev_sum_partition_by_ordered_at.`s1___rev_sum_partition_by_ordered_at` AS `s1___rev_sum_partition_by_ordered_at`\n FROM _base\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at\n ON _base.`s1___ordered_at` IS NOT DISTINCT FROM _cm_s1__rev_sum_partition_by_ordered_at.`s1___ordered_at`\n), _base_2 AS (\n SELECT\n s1.region AS `s1___region`,\n DATE_TRUNC(s1.ordered_at, MONTH) AS `s1___ordered_at`,\n SUM(s1.rev) AS `s1___rev_sum`\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n s1.region,\n DATE_TRUNC(s1.ordered_at, MONTH)\n), _cm_s1__rev_sum_partition_by_ordered_at_2 AS (\n SELECT\n DATE_TRUNC(s1.ordered_at, MONTH) AS `s1___ordered_at`,\n SUM(s1.rev) AS `s1___rev_sum_partition_by_ordered_at`\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n DATE_TRUNC(s1.ordered_at, MONTH)\n), shifted_t AS (\n SELECT\n _base_2.`s1___region`,\n _base_2.`s1___ordered_at`,\n _base_2.`s1___rev_sum` / NULLIF(_cm_s1__rev_sum_partition_by_ordered_at_2.`s1___rev_sum_partition_by_ordered_at`, 0) AS `s1___shifted`\n FROM _base_2\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at_2\n ON _base_2.`s1___ordered_at` IS NOT DISTINCT FROM _cm_s1__rev_sum_partition_by_ordered_at_2.`s1___ordered_at`\n), sjoin_t AS (\n SELECT\n base.`s1___region`,\n base.`s1___ordered_at`,\n base.`s1___rev_sum`,\n base.`s1___rev_sum_partition_by_ordered_at`,\n shifted_t.`s1___shifted` AS `s1___t`\n FROM base\n LEFT JOIN shifted_t\n ON base.`s1___region` IS NOT DISTINCT FROM shifted_t.`s1___region`\n AND CAST(DATETIME_ADD(CAST(CAST(base.`s1___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`s1___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `s1___region`,\n `s1___ordered_at`,\n `s1___t`\nFROM (\n SELECT\n `s1___region`,\n `s1___ordered_at`,\n `s1___rev_sum`,\n `s1___rev_sum_partition_by_ordered_at`,\n `s1___t`\n FROM sjoin_t\n) AS _outer", + "stage/share::duckdb": "WITH __slayer_stage_s1 AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.ordered_at\" AS \"ordered_at\",\n _stage_inner.\"monthly.rev\" AS \"rev\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE) AS \"monthly.rev\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n ) AS _stage_inner\n), _base AS (\n SELECT\n s1.region AS \"s1.region\",\n DATE_TRUNC('MONTH', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum\"\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND s1.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n s1.region,\n DATE_TRUNC('MONTH', s1.ordered_at)\n), _cm_s1__rev_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND s1.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n DATE_TRUNC('MONTH', s1.ordered_at)\n), base AS (\n SELECT\n _base.\"s1.region\",\n _base.\"s1.ordered_at\",\n _base.\"s1.rev_sum\",\n _cm_s1__rev_sum_partition_by_ordered_at.\"s1.rev_sum_partition_by_ordered_at\" AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at\n ON _base.\"s1.ordered_at\" IS NOT DISTINCT FROM _cm_s1__rev_sum_partition_by_ordered_at.\"s1.ordered_at\"\n), _base_2 AS (\n SELECT\n s1.region AS \"s1.region\",\n DATE_TRUNC('MONTH', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum\"\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n s1.region,\n DATE_TRUNC('MONTH', s1.ordered_at)\n), _cm_s1__rev_sum_partition_by_ordered_at_2 AS (\n SELECT\n DATE_TRUNC('MONTH', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n DATE_TRUNC('MONTH', s1.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"s1.region\",\n _base_2.\"s1.ordered_at\",\n _base_2.\"s1.rev_sum\" / NULLIF(_cm_s1__rev_sum_partition_by_ordered_at_2.\"s1.rev_sum_partition_by_ordered_at\", 0) AS \"s1.shifted\"\n FROM _base_2\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at_2\n ON _base_2.\"s1.ordered_at\" IS NOT DISTINCT FROM _cm_s1__rev_sum_partition_by_ordered_at_2.\"s1.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"s1.region\",\n base.\"s1.ordered_at\",\n base.\"s1.rev_sum\",\n base.\"s1.rev_sum_partition_by_ordered_at\",\n shifted_t.\"s1.shifted\" AS \"s1.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"s1.region\" IS NOT DISTINCT FROM shifted_t.\"s1.region\"\n AND base.\"s1.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"s1.ordered_at\"\n)\nSELECT\n \"s1.region\",\n \"s1.ordered_at\",\n \"s1.t\"\nFROM (\n SELECT\n \"s1.region\",\n \"s1.ordered_at\",\n \"s1.rev_sum\",\n \"s1.rev_sum_partition_by_ordered_at\",\n \"s1.t\"\n FROM sjoin_t\n) AS _outer", + "stage/share::postgres": "WITH __slayer_stage_s1 AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.ordered_at\" AS \"ordered_at\",\n _stage_inner.\"monthly.rev\" AS \"rev\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS DOUBLE PRECISION) AS \"monthly.rev\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n ) AS _stage_inner\n), _base AS (\n SELECT\n s1.region AS \"s1.region\",\n DATE_TRUNC('MONTH', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum\"\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND s1.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n s1.region,\n DATE_TRUNC('MONTH', s1.ordered_at)\n), _cm_s1__rev_sum_partition_by_ordered_at AS (\n SELECT\n DATE_TRUNC('MONTH', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= CAST('2024-02-01 00:00:00' AS TIMESTAMP)\n AND s1.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n DATE_TRUNC('MONTH', s1.ordered_at)\n), base AS (\n SELECT\n _base.\"s1.region\",\n _base.\"s1.ordered_at\",\n _base.\"s1.rev_sum\",\n _cm_s1__rev_sum_partition_by_ordered_at.\"s1.rev_sum_partition_by_ordered_at\" AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at\n ON _base.\"s1.ordered_at\" IS NOT DISTINCT FROM _cm_s1__rev_sum_partition_by_ordered_at.\"s1.ordered_at\"\n), _base_2 AS (\n SELECT\n s1.region AS \"s1.region\",\n DATE_TRUNC('MONTH', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum\"\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n s1.region,\n DATE_TRUNC('MONTH', s1.ordered_at)\n), _cm_s1__rev_sum_partition_by_ordered_at_2 AS (\n SELECT\n DATE_TRUNC('MONTH', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n DATE_TRUNC('MONTH', s1.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"s1.region\",\n _base_2.\"s1.ordered_at\",\n CAST(_base_2.\"s1.rev_sum\" AS DOUBLE PRECISION) / NULLIF(_cm_s1__rev_sum_partition_by_ordered_at_2.\"s1.rev_sum_partition_by_ordered_at\", 0) AS \"s1.shifted\"\n FROM _base_2\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at_2\n ON _base_2.\"s1.ordered_at\" IS NOT DISTINCT FROM _cm_s1__rev_sum_partition_by_ordered_at_2.\"s1.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"s1.region\",\n base.\"s1.ordered_at\",\n base.\"s1.rev_sum\",\n base.\"s1.rev_sum_partition_by_ordered_at\",\n shifted_t.\"s1.shifted\" AS \"s1.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"s1.region\" IS NOT DISTINCT FROM shifted_t.\"s1.region\"\n AND base.\"s1.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"s1.ordered_at\"\n)\nSELECT\n \"s1.region\",\n \"s1.ordered_at\",\n \"s1.t\"\nFROM (\n SELECT\n \"s1.region\",\n \"s1.ordered_at\",\n \"s1.rev_sum\",\n \"s1.rev_sum_partition_by_ordered_at\",\n \"s1.t\"\n FROM sjoin_t\n) AS _outer", + "stage/share::sqlite": "WITH __slayer_stage_s1 AS (\n SELECT\n _stage_inner.\"monthly.region\" AS \"region\",\n _stage_inner.\"monthly.ordered_at\" AS \"ordered_at\",\n _stage_inner.\"monthly.rev\" AS \"rev\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS REAL) AS \"monthly.rev\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STRFTIME('%Y-%m-01', monthly.ordered_at)\n ) AS _stage_inner\n), _base AS (\n SELECT\n s1.region AS \"s1.region\",\n STRFTIME('%Y-%m-01', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum\"\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= '2024-02-01' AND s1.ordered_at < '2024-04-01'\n )\n GROUP BY\n s1.region,\n STRFTIME('%Y-%m-01', s1.ordered_at)\n), _cm_s1__rev_sum_partition_by_ordered_at AS (\n SELECT\n STRFTIME('%Y-%m-01', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= '2024-02-01' AND s1.ordered_at < '2024-04-01'\n )\n GROUP BY\n STRFTIME('%Y-%m-01', s1.ordered_at)\n), base AS (\n SELECT\n _base.\"s1.region\",\n _base.\"s1.ordered_at\",\n _base.\"s1.rev_sum\",\n _cm_s1__rev_sum_partition_by_ordered_at.\"s1.rev_sum_partition_by_ordered_at\" AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM _base\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at\n ON _base.\"s1.ordered_at\" IS _cm_s1__rev_sum_partition_by_ordered_at.\"s1.ordered_at\"\n), _base_2 AS (\n SELECT\n s1.region AS \"s1.region\",\n STRFTIME('%Y-%m-01', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum\"\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n s1.region,\n STRFTIME('%Y-%m-01', s1.ordered_at)\n), _cm_s1__rev_sum_partition_by_ordered_at_2 AS (\n SELECT\n STRFTIME('%Y-%m-01', s1.ordered_at) AS \"s1.ordered_at\",\n SUM(s1.rev) AS \"s1.rev_sum_partition_by_ordered_at\"\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n STRFTIME('%Y-%m-01', s1.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.\"s1.region\",\n _base_2.\"s1.ordered_at\",\n CAST(_base_2.\"s1.rev_sum\" AS REAL) / NULLIF(_cm_s1__rev_sum_partition_by_ordered_at_2.\"s1.rev_sum_partition_by_ordered_at\", 0) AS \"s1.shifted\"\n FROM _base_2\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at_2\n ON _base_2.\"s1.ordered_at\" IS _cm_s1__rev_sum_partition_by_ordered_at_2.\"s1.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"s1.region\",\n base.\"s1.ordered_at\",\n base.\"s1.rev_sum\",\n base.\"s1.rev_sum_partition_by_ordered_at\",\n shifted_t.\"s1.shifted\" AS \"s1.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"s1.region\" IS shifted_t.\"s1.region\"\n AND SLAYER_DATE_ADD(base.\"s1.ordered_at\", -1, 'month') IS shifted_t.\"s1.ordered_at\"\n)\nSELECT\n \"s1.region\",\n \"s1.ordered_at\",\n \"s1.t\"\nFROM (\n SELECT\n \"s1.region\",\n \"s1.ordered_at\",\n \"s1.rev_sum\",\n \"s1.rev_sum_partition_by_ordered_at\",\n \"s1.t\"\n FROM sjoin_t\n) AS _outer", + "stage/share::tsql": "WITH __slayer_stage_s1 AS (\n SELECT\n _stage_inner.[monthly___region] AS [region],\n _stage_inner.[monthly___ordered_at] AS [ordered_at],\n _stage_inner.[monthly___rev] AS [rev]\n FROM (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n CAST(SUM(monthly.amount) AS FLOAT) AS [monthly___rev]\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATETRUNC(month, monthly.ordered_at)\n ) AS _stage_inner\n), _base AS (\n SELECT\n s1.region AS [s1___region],\n DATETRUNC(month, s1.ordered_at) AS [s1___ordered_at],\n SUM(s1.rev) AS [s1___rev_sum]\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= CAST('2024-02-01 00:00:00' AS DATETIME2)\n AND s1.ordered_at < CAST('2024-04-01 00:00:00' AS DATETIME2)\n )\n GROUP BY\n s1.region,\n DATETRUNC(month, s1.ordered_at)\n), _cm_s1__rev_sum_partition_by_ordered_at AS (\n SELECT\n DATETRUNC(month, s1.ordered_at) AS [s1___ordered_at],\n SUM(s1.rev) AS [s1___rev_sum_partition_by_ordered_at]\n FROM __slayer_stage_s1 AS s1\n WHERE\n (\n s1.ordered_at >= CAST('2024-02-01 00:00:00' AS DATETIME2)\n AND s1.ordered_at < CAST('2024-04-01 00:00:00' AS DATETIME2)\n )\n GROUP BY\n DATETRUNC(month, s1.ordered_at)\n), base AS (\n SELECT\n _base.[s1___region] AS [s1___region],\n _base.[s1___ordered_at] AS [s1___ordered_at],\n _base.[s1___rev_sum] AS [s1___rev_sum],\n _cm_s1__rev_sum_partition_by_ordered_at.[s1___rev_sum_partition_by_ordered_at] AS [s1___rev_sum_partition_by_ordered_at]\n FROM _base\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at\n ON (\n _base.[s1___ordered_at] = _cm_s1__rev_sum_partition_by_ordered_at.[s1___ordered_at]\n OR (\n _base.[s1___ordered_at] IS NULL\n AND _cm_s1__rev_sum_partition_by_ordered_at.[s1___ordered_at] IS NULL\n )\n )\n), _base_2 AS (\n SELECT\n s1.region AS [s1___region],\n DATETRUNC(month, s1.ordered_at) AS [s1___ordered_at],\n SUM(s1.rev) AS [s1___rev_sum]\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n s1.region,\n DATETRUNC(month, s1.ordered_at)\n), _cm_s1__rev_sum_partition_by_ordered_at_2 AS (\n SELECT\n DATETRUNC(month, s1.ordered_at) AS [s1___ordered_at],\n SUM(s1.rev) AS [s1___rev_sum_partition_by_ordered_at]\n FROM __slayer_stage_s1 AS s1\n GROUP BY\n DATETRUNC(month, s1.ordered_at)\n), shifted_t AS (\n SELECT\n _base_2.[s1___region] AS [s1___region],\n _base_2.[s1___ordered_at] AS [s1___ordered_at],\n CAST(_base_2.[s1___rev_sum] AS FLOAT) / NULLIF(_cm_s1__rev_sum_partition_by_ordered_at_2.[s1___rev_sum_partition_by_ordered_at], 0) AS [s1___shifted]\n FROM _base_2\n LEFT JOIN _cm_s1__rev_sum_partition_by_ordered_at_2\n ON (\n _base_2.[s1___ordered_at] = _cm_s1__rev_sum_partition_by_ordered_at_2.[s1___ordered_at]\n OR (\n _base_2.[s1___ordered_at] IS NULL\n AND _cm_s1__rev_sum_partition_by_ordered_at_2.[s1___ordered_at] IS NULL\n )\n )\n), sjoin_t AS (\n SELECT\n base.[s1___region] AS [s1___region],\n base.[s1___ordered_at] AS [s1___ordered_at],\n base.[s1___rev_sum] AS [s1___rev_sum],\n base.[s1___rev_sum_partition_by_ordered_at] AS [s1___rev_sum_partition_by_ordered_at],\n shifted_t.[s1___shifted] AS [s1___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n base.[s1___region] = shifted_t.[s1___region]\n OR (\n base.[s1___region] IS NULL AND shifted_t.[s1___region] IS NULL\n )\n )\n AND (\n DATEADD(MONTH, -1, base.[s1___ordered_at]) = shifted_t.[s1___ordered_at]\n OR (\n DATEADD(MONTH, -1, base.[s1___ordered_at]) IS NULL\n AND shifted_t.[s1___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [s1___region],\n [s1___ordered_at],\n [s1___t]\nFROM (\n SELECT\n [s1___region],\n [s1___ordered_at],\n [s1___rev_sum],\n [s1___rev_sum_partition_by_ordered_at],\n [s1___t]\n FROM sjoin_t\n) AS _outer" } diff --git a/tests/golden/dev2062_sql_baseline.json b/tests/golden/dev2062_sql_baseline.json index eb7ee56b..62abb95d 100644 --- a/tests/golden/dev2062_sql_baseline.json +++ b/tests/golden/dev2062_sql_baseline.json @@ -1,10 +1,10 @@ { - "cross/filter::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), _cm_orders__customers__score_max AS (\n SELECT\n MAX(customers.score) AS \"customers.score_max\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.order_date\",\n CAST(_base.\"orders.amount_sum\" AS DOUBLE PRECISION) / _cm_orders__customers__score_max.\"customers.score_max\" AS \"orders.a\",\n _base.\"orders.amount_sum\",\n _cm_orders__customers__score_max.\"customers.score_max\" AS \"customers.score_max\"\n FROM _base\n CROSS JOIN _cm_orders__customers__score_max\n), step1 AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.a\",\n \"customers.score_max\",\n SUM(\"orders.a\") OVER (ORDER BY \"orders.order_date\") AS \"orders._cumsum_inner\"\n FROM base\n)\nSELECT\n \"orders.order_date\",\n \"orders.a\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.a\",\n \"customers.score_max\",\n \"orders._cumsum_inner\"\n FROM step1\n WHERE\n \"orders._cumsum_inner\" > 9\n) AS _outer", - "cross/filter::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.order_date) AS [orders___order_date],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.order_date)\n), _cm_orders__customers__score_max AS (\n SELECT\n MAX(customers.score) AS [customers___score_max]\n FROM customers AS customers\n), base AS (\n SELECT\n _base.[orders___order_date] AS [orders___order_date],\n CAST(_base.[orders___amount_sum] AS FLOAT) / _cm_orders__customers__score_max.[customers___score_max] AS [orders___a],\n _base.[orders___amount_sum] AS [orders___amount_sum],\n _cm_orders__customers__score_max.[customers___score_max] AS [customers___score_max]\n FROM _base\n CROSS JOIN _cm_orders__customers__score_max\n), step1 AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders___a] AS [orders___a],\n [customers___score_max] AS [customers___score_max],\n SUM([orders___a]) OVER (ORDER BY [orders___order_date]) AS [orders____cumsum_inner]\n FROM base\n)\nSELECT\n [orders___order_date],\n [orders___a]\nFROM (\n SELECT\n [orders___order_date],\n [orders___amount_sum],\n [orders___a],\n [customers___score_max],\n [orders____cumsum_inner]\n FROM step1\n WHERE\n [orders____cumsum_inner] > 9\n) AS _outer", - "cross/order_composite::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), _cm_orders__customers__score_max AS (\n SELECT\n MAX(customers.score) AS \"customers.score_max\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.order_date\",\n CAST(_base.\"orders.amount_sum\" AS DOUBLE PRECISION) / _cm_orders__customers__score_max.\"customers.score_max\" AS \"orders.a\",\n _base.\"orders.amount_sum\",\n _cm_orders__customers__score_max.\"customers.score_max\" AS \"customers.score_max\"\n FROM _base\n CROSS JOIN _cm_orders__customers__score_max\n), step1 AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.a\",\n \"customers.score_max\",\n SUM(\"orders.a\") OVER (ORDER BY \"orders.order_date\") AS \"orders._cumsum_inner\"\n FROM base\n), step2 AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.a\",\n \"customers.score_max\",\n \"orders._cumsum_inner\",\n \"orders._cumsum_inner\" + 1 AS \"orders._arith_+\"\n FROM step1\n)\nSELECT\n \"orders.order_date\",\n \"orders.a\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.a\",\n \"customers.score_max\",\n \"orders._cumsum_inner\",\n \"orders._arith_+\"\n FROM step2\n) AS _outer\nORDER BY\n \"orders._arith_+\" DESC NULLS LAST", - "cross/order_composite::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.order_date) AS [orders___order_date],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.order_date)\n), _cm_orders__customers__score_max AS (\n SELECT\n MAX(customers.score) AS [customers___score_max]\n FROM customers AS customers\n), base AS (\n SELECT\n _base.[orders___order_date] AS [orders___order_date],\n CAST(_base.[orders___amount_sum] AS FLOAT) / _cm_orders__customers__score_max.[customers___score_max] AS [orders___a],\n _base.[orders___amount_sum] AS [orders___amount_sum],\n _cm_orders__customers__score_max.[customers___score_max] AS [customers___score_max]\n FROM _base\n CROSS JOIN _cm_orders__customers__score_max\n), step1 AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders___a] AS [orders___a],\n [customers___score_max] AS [customers___score_max],\n SUM([orders___a]) OVER (ORDER BY [orders___order_date]) AS [orders____cumsum_inner]\n FROM base\n), step2 AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders___a] AS [orders___a],\n [customers___score_max] AS [customers___score_max],\n [orders____cumsum_inner] AS [orders____cumsum_inner],\n [orders____cumsum_inner] + 1 AS [orders._arith_+]\n FROM step1\n)\nSELECT\n [orders___order_date],\n [orders___a]\nFROM (\n SELECT\n [orders___order_date],\n [orders___amount_sum],\n [orders___a],\n [customers___score_max],\n [orders____cumsum_inner],\n [orders._arith_+]\n FROM step2\n) AS _outer\nORDER BY\n [orders._arith_+] DESC", - "local/filter::postgres": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.order_date) AS \"orders.order_date\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) / COUNT(*) AS \"orders.a\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), step1 AS (\n SELECT\n \"orders.order_date\",\n \"orders.a\",\n SUM(\"orders.a\") OVER (ORDER BY \"orders.order_date\") AS \"orders._cumsum_inner\"\n FROM base\n)\nSELECT\n \"orders.order_date\",\n \"orders.a\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.a\",\n \"orders._cumsum_inner\"\n FROM step1\n WHERE\n \"orders._cumsum_inner\" > 9\n) AS _outer", - "local/filter::tsql": "WITH base AS (\n SELECT\n DATETRUNC(month, orders.order_date) AS [orders___order_date],\n CAST(SUM(orders.amount) AS FLOAT) / COUNT(*) AS [orders___a]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.order_date)\n), step1 AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___a] AS [orders___a],\n SUM([orders___a]) OVER (ORDER BY [orders___order_date]) AS [orders____cumsum_inner]\n FROM base\n)\nSELECT\n [orders___order_date],\n [orders___a]\nFROM (\n SELECT\n [orders___order_date],\n [orders___a],\n [orders____cumsum_inner]\n FROM step1\n WHERE\n [orders____cumsum_inner] > 9\n) AS _outer", - "local/order_composite::postgres": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.order_date) AS \"orders.order_date\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) / COUNT(*) AS \"orders.a\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), step1 AS (\n SELECT\n \"orders.order_date\",\n \"orders.a\",\n SUM(\"orders.a\") OVER (ORDER BY \"orders.order_date\") AS \"orders._cumsum_inner\"\n FROM base\n), step2 AS (\n SELECT\n \"orders.order_date\",\n \"orders.a\",\n \"orders._cumsum_inner\",\n \"orders._cumsum_inner\" + 1 AS \"orders._arith_+\"\n FROM step1\n)\nSELECT\n \"orders.order_date\",\n \"orders.a\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.a\",\n \"orders._cumsum_inner\",\n \"orders._arith_+\"\n FROM step2\n) AS _outer\nORDER BY\n \"orders._arith_+\" DESC NULLS LAST", - "local/order_composite::tsql": "WITH base AS (\n SELECT\n DATETRUNC(month, orders.order_date) AS [orders___order_date],\n CAST(SUM(orders.amount) AS FLOAT) / COUNT(*) AS [orders___a]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.order_date)\n), step1 AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___a] AS [orders___a],\n SUM([orders___a]) OVER (ORDER BY [orders___order_date]) AS [orders____cumsum_inner]\n FROM base\n), step2 AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___a] AS [orders___a],\n [orders____cumsum_inner] AS [orders____cumsum_inner],\n [orders____cumsum_inner] + 1 AS [orders._arith_+]\n FROM step1\n)\nSELECT\n [orders___order_date],\n [orders___a]\nFROM (\n SELECT\n [orders___order_date],\n [orders___a],\n [orders____cumsum_inner],\n [orders._arith_+]\n FROM step2\n) AS _outer\nORDER BY\n [orders._arith_+] DESC" + "cross/filter::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), _cm_orders__customers__score_max AS (\n SELECT\n MAX(customers.score) AS \"customers.score_max\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.order_date\",\n CAST(_base.\"orders.amount_sum\" AS DOUBLE PRECISION) / NULLIF(_cm_orders__customers__score_max.\"customers.score_max\", 0) AS \"orders.a\",\n _base.\"orders.amount_sum\",\n _cm_orders__customers__score_max.\"customers.score_max\" AS \"customers.score_max\"\n FROM _base\n CROSS JOIN _cm_orders__customers__score_max\n), step1 AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.a\",\n \"customers.score_max\",\n SUM(\"orders.a\") OVER (ORDER BY \"orders.order_date\") AS \"orders._cumsum_inner\"\n FROM base\n)\nSELECT\n \"orders.order_date\",\n \"orders.a\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.a\",\n \"customers.score_max\",\n \"orders._cumsum_inner\"\n FROM step1\n WHERE\n \"orders._cumsum_inner\" > 9\n) AS _outer", + "cross/filter::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.order_date) AS [orders___order_date],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.order_date)\n), _cm_orders__customers__score_max AS (\n SELECT\n MAX(customers.score) AS [customers___score_max]\n FROM customers AS customers\n), base AS (\n SELECT\n _base.[orders___order_date] AS [orders___order_date],\n CAST(_base.[orders___amount_sum] AS FLOAT) / NULLIF(_cm_orders__customers__score_max.[customers___score_max], 0) AS [orders___a],\n _base.[orders___amount_sum] AS [orders___amount_sum],\n _cm_orders__customers__score_max.[customers___score_max] AS [customers___score_max]\n FROM _base\n CROSS JOIN _cm_orders__customers__score_max\n), step1 AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders___a] AS [orders___a],\n [customers___score_max] AS [customers___score_max],\n SUM([orders___a]) OVER (ORDER BY [orders___order_date]) AS [orders____cumsum_inner]\n FROM base\n)\nSELECT\n [orders___order_date],\n [orders___a]\nFROM (\n SELECT\n [orders___order_date],\n [orders___amount_sum],\n [orders___a],\n [customers___score_max],\n [orders____cumsum_inner]\n FROM step1\n WHERE\n [orders____cumsum_inner] > 9\n) AS _outer", + "cross/order_composite::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), _cm_orders__customers__score_max AS (\n SELECT\n MAX(customers.score) AS \"customers.score_max\"\n FROM customers AS customers\n), base AS (\n SELECT\n _base.\"orders.order_date\",\n CAST(_base.\"orders.amount_sum\" AS DOUBLE PRECISION) / NULLIF(_cm_orders__customers__score_max.\"customers.score_max\", 0) AS \"orders.a\",\n _base.\"orders.amount_sum\",\n _cm_orders__customers__score_max.\"customers.score_max\" AS \"customers.score_max\"\n FROM _base\n CROSS JOIN _cm_orders__customers__score_max\n), step1 AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.a\",\n \"customers.score_max\",\n SUM(\"orders.a\") OVER (ORDER BY \"orders.order_date\") AS \"orders._cumsum_inner\"\n FROM base\n), step2 AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.a\",\n \"customers.score_max\",\n \"orders._cumsum_inner\",\n \"orders._cumsum_inner\" + 1 AS \"orders._arith_+\"\n FROM step1\n)\nSELECT\n \"orders.order_date\",\n \"orders.a\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.a\",\n \"customers.score_max\",\n \"orders._cumsum_inner\",\n \"orders._arith_+\"\n FROM step2\n) AS _outer\nORDER BY\n \"orders._arith_+\" DESC NULLS LAST", + "cross/order_composite::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.order_date) AS [orders___order_date],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.order_date)\n), _cm_orders__customers__score_max AS (\n SELECT\n MAX(customers.score) AS [customers___score_max]\n FROM customers AS customers\n), base AS (\n SELECT\n _base.[orders___order_date] AS [orders___order_date],\n CAST(_base.[orders___amount_sum] AS FLOAT) / NULLIF(_cm_orders__customers__score_max.[customers___score_max], 0) AS [orders___a],\n _base.[orders___amount_sum] AS [orders___amount_sum],\n _cm_orders__customers__score_max.[customers___score_max] AS [customers___score_max]\n FROM _base\n CROSS JOIN _cm_orders__customers__score_max\n), step1 AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders___a] AS [orders___a],\n [customers___score_max] AS [customers___score_max],\n SUM([orders___a]) OVER (ORDER BY [orders___order_date]) AS [orders____cumsum_inner]\n FROM base\n), step2 AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders___a] AS [orders___a],\n [customers___score_max] AS [customers___score_max],\n [orders____cumsum_inner] AS [orders____cumsum_inner],\n [orders____cumsum_inner] + 1 AS [orders._arith_+]\n FROM step1\n)\nSELECT\n [orders___order_date],\n [orders___a]\nFROM (\n SELECT\n [orders___order_date],\n [orders___amount_sum],\n [orders___a],\n [customers___score_max],\n [orders____cumsum_inner],\n [orders._arith_+]\n FROM step2\n) AS _outer\nORDER BY\n [orders._arith_+] DESC", + "local/filter::postgres": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.order_date) AS \"orders.order_date\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) / NULLIF(COUNT(*), 0) AS \"orders.a\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), step1 AS (\n SELECT\n \"orders.order_date\",\n \"orders.a\",\n SUM(\"orders.a\") OVER (ORDER BY \"orders.order_date\") AS \"orders._cumsum_inner\"\n FROM base\n)\nSELECT\n \"orders.order_date\",\n \"orders.a\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.a\",\n \"orders._cumsum_inner\"\n FROM step1\n WHERE\n \"orders._cumsum_inner\" > 9\n) AS _outer", + "local/filter::tsql": "WITH base AS (\n SELECT\n DATETRUNC(month, orders.order_date) AS [orders___order_date],\n CAST(SUM(orders.amount) AS FLOAT) / NULLIF(COUNT(*), 0) AS [orders___a]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.order_date)\n), step1 AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___a] AS [orders___a],\n SUM([orders___a]) OVER (ORDER BY [orders___order_date]) AS [orders____cumsum_inner]\n FROM base\n)\nSELECT\n [orders___order_date],\n [orders___a]\nFROM (\n SELECT\n [orders___order_date],\n [orders___a],\n [orders____cumsum_inner]\n FROM step1\n WHERE\n [orders____cumsum_inner] > 9\n) AS _outer", + "local/order_composite::postgres": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.order_date) AS \"orders.order_date\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) / NULLIF(COUNT(*), 0) AS \"orders.a\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), step1 AS (\n SELECT\n \"orders.order_date\",\n \"orders.a\",\n SUM(\"orders.a\") OVER (ORDER BY \"orders.order_date\") AS \"orders._cumsum_inner\"\n FROM base\n), step2 AS (\n SELECT\n \"orders.order_date\",\n \"orders.a\",\n \"orders._cumsum_inner\",\n \"orders._cumsum_inner\" + 1 AS \"orders._arith_+\"\n FROM step1\n)\nSELECT\n \"orders.order_date\",\n \"orders.a\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.a\",\n \"orders._cumsum_inner\",\n \"orders._arith_+\"\n FROM step2\n) AS _outer\nORDER BY\n \"orders._arith_+\" DESC NULLS LAST", + "local/order_composite::tsql": "WITH base AS (\n SELECT\n DATETRUNC(month, orders.order_date) AS [orders___order_date],\n CAST(SUM(orders.amount) AS FLOAT) / NULLIF(COUNT(*), 0) AS [orders___a]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.order_date)\n), step1 AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___a] AS [orders___a],\n SUM([orders___a]) OVER (ORDER BY [orders___order_date]) AS [orders____cumsum_inner]\n FROM base\n), step2 AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___a] AS [orders___a],\n [orders____cumsum_inner] AS [orders____cumsum_inner],\n [orders____cumsum_inner] + 1 AS [orders._arith_+]\n FROM step1\n)\nSELECT\n [orders___order_date],\n [orders___a]\nFROM (\n SELECT\n [orders___order_date],\n [orders___a],\n [orders____cumsum_inner],\n [orders._arith_+]\n FROM step2\n) AS _outer\nORDER BY\n [orders._arith_+] DESC" } diff --git a/tests/test_dev1449_flat_stage_schema_refs.py b/tests/test_dev1449_flat_stage_schema_refs.py index 690d3581..5a2e82f1 100644 --- a/tests/test_dev1449_flat_stage_schema_refs.py +++ b/tests/test_dev1449_flat_stage_schema_refs.py @@ -1,10 +1,10 @@ -"""DEV-1450 stage 7b.15e — DEV-1449 acceptance via ``engine.execute``. +"""Flat stage-schema references, end to end via ``engine.execute``. -DEV-1449: a downstream stage sees its upstream as a FLAT ``StageSchema``, not +A downstream stage sees its upstream as a FLAT ``StageSchema``, not as a model with joins (P5/P6). A multi-hop upstream dimension (``customers.region``) surfaces downstream under its flat name -(``customers__region``); the dotted join form is illegal in stage scope and -raises ``IllegalScopeReferenceError``. +(``customers__region``); the dotted form names ``customers``, which no join path +reaches from the stage, so a row-level read of it raises ``UnrelatedDatasetError``. End-to-end through ``engine.execute([stage1, root])``. The planner-level behavior is pinned in ``tests/test_generator2_multistage.py``; this asserts @@ -20,7 +20,7 @@ import pytest from slayer.core.enums import DataType -from slayer.core.errors import IllegalScopeReferenceError +from slayer.core.errors import UnrelatedDatasetError from slayer.core.models import Column, DatasourceConfig, ModelJoin, SlayerModel from slayer.core.query import SlayerQuery from slayer.engine.query_engine import SlayerQueryEngine @@ -129,7 +129,7 @@ async def test_dev1449_flat_name_resolves(engine): async def test_dev1449_dotted_form_raises(engine): - """The dotted join form is illegal against a flat upstream stage schema.""" + """The dotted form reads a model no join path reaches from the flat upstream stage.""" eng, _ = engine root = SlayerQuery( source_model="stage1", @@ -137,5 +137,5 @@ async def test_dev1449_dotted_form_raises(engine): measures=[{"formula": "amount_sum:sum"}], ) stage1 = _stage1() - with pytest.raises(IllegalScopeReferenceError): + with pytest.raises(UnrelatedDatasetError): await eng.execute([stage1, root]) diff --git a/tests/test_dev1746_empty_base_plan.py b/tests/test_dev1746_empty_base_plan.py index fbcaff6f..fb3b9bdb 100644 --- a/tests/test_dev1746_empty_base_plan.py +++ b/tests/test_dev1746_empty_base_plan.py @@ -1,4 +1,4 @@ -"""DEV-1746 §5.12 — the empty-base grain becomes a typed planner node. +"""The empty-base grain is a typed planner node. When a query asks only for isolated aggregates — no host row slots and no host-local aggregates — the host base has nothing to project, so the generator @@ -175,7 +175,7 @@ def test_node_presence_implies_the_projection_is_isolated_only(self) -> None: for factory in (_unfiltered_query, _filtered_query): planned = plan_query(query=factory(), bundle=_bundle()) assert planned.empty_base_plan is not None - # DEV-1836: a cross-model aggregate is now an isolated regroup-attach + # A cross-model aggregate is an isolated regroup-attach # placeholder (its producer is a target-rooted _cm_ CTE), so its host # projection slot carries the substitution placeholder key. attach_placeholders = { @@ -284,7 +284,7 @@ async def test_scalar_aggregate_is_not_multiplied( async def test_host_filter_gates_the_whole_result( self, exec_engine: SlayerQueryEngine, ) -> None: - """A host-local filter that MATCHES gates the spine AND (DEV-1840) + """A host-local filter that MATCHES gates the spine AND restricts the isolated CTE by semi-join: only customer 100 has a paid order, so the scalar is 1000, not the unfiltered 1325.""" query = SlayerQuery( @@ -310,3 +310,15 @@ async def test_host_filter_matching_nothing_yields_no_rows( assert resp.data == [], ( f"a non-matching host filter still returned rows:\n{resp.data}" ) + + async def test_expression_over_isolated_aggregates_alone( + self, exec_engine: SlayerQueryEngine, + ) -> None: + """An expression of cross-model aggregates alone also leaves ``_base`` a placeholder spine.""" + query = SlayerQuery( + source_model="orders", + measures=[ModelMeasure(formula="customers.spend:sum * 2", name="twice")], + ) + resp = await exec_engine.execute(query) + assert len(resp.data) == 1, resp.data + assert resp.data[0]["orders.twice"] == pytest.approx(2650.0), resp.data diff --git a/tests/test_dev1780_missing_join_path.py b/tests/test_dev1780_missing_join_path.py index b79888f8..2defbe67 100644 --- a/tests/test_dev1780_missing_join_path.py +++ b/tests/test_dev1780_missing_join_path.py @@ -1,5 +1,5 @@ -"""DEV-1780/1856 — a non-direct-join dotted dim/time-dim binds hop-by-hop so no unbound ``A__B`` alias reaches the SQL. -DEV-1856 turned short-form auto-routing on (broken chains never auto-fixed); full routing behaviour in test_dev1856.""" +"""A non-direct-join dotted dim/time-dim binds hop-by-hop so no unbound ``A__B`` alias reaches the SQL. +Short-form auto-routing is on (broken chains never auto-fixed); full routing behaviour in test_dev1856.""" from __future__ import annotations @@ -8,8 +8,8 @@ from slayer.core.enums import DataType from slayer.core.errors import ( - IllegalScopeReferenceError, UnknownReferenceError, + UnrelatedDatasetError, UnresolvableDimensionJoinError, ) from slayer.core.join_search import count_routes @@ -190,9 +190,10 @@ async def test_short_form_ambiguous_target_rejects(self, tmp_path) -> None: async def test_unreachable_target_rejects_without_suggestion(self, tmp_path) -> None: engine = await _engine(tmp_path, drop_customer_consumer=True) q = SlayerQuery(**_amount_query(dimensions=["Consumer.name"])) - with pytest.raises(UnresolvableDimensionJoinError) as ei: + with pytest.raises(UnrelatedDatasetError) as ei: await _dry_sql(engine, q) - assert ei.value.suggested_path is None + assert "Consumer.name" in str(ei.value) + assert "Invoice" in str(ei.value) async def test_broken_time_dimension_chain_rejects(self, tmp_path) -> None: engine = await _engine(tmp_path) @@ -227,7 +228,7 @@ async def test_circular_join_keeps_its_own_error(self, tmp_path) -> None: DatasourceConfig(name="test", type="sqlite", database=":memory:") ) # A <-> B cycle over two DISTINCT edges; named so each hop resolves - # unambiguously (DEV-1853: two edges on one pair fail closed on a bare + # unambiguously (two edges on one pair fail closed on a bare # model-name token) and the revisit check still fires. await storage.save_model(SlayerModel( name="B", sql_table="B", data_source="test", @@ -276,8 +277,8 @@ async def test_cross_model_rerooting_still_binds(self, tmp_path) -> None: class TestDownstreamStageScope: async def test_downstream_stage_dotted_ref_rejects(self, tmp_path) -> None: - """A named-query stage sees a FLAT schema, so an outer-stage dotted ref is - ``IllegalScopeReferenceError``; the inner stage's full-path dim resolves.""" + """An outer-stage dotted ref names a model no join path reaches from the flat + stage: ``UnrelatedDatasetError``; the inner stage's full-path dim resolves.""" engine = await _engine(tmp_path) inner = SlayerQuery( name="s1", source_model="Invoice", @@ -289,7 +290,7 @@ async def test_downstream_stage_dotted_ref_rejects(self, tmp_path) -> None: dimensions=["Subscription.Customer.Consumer.email"], measures=[{"formula": "*:count"}], ) - with pytest.raises(IllegalScopeReferenceError): + with pytest.raises(UnrelatedDatasetError): await engine.execute(query=[inner, outer], dry_run=True) diff --git a/tests/test_dev1856_short_form_routing.py b/tests/test_dev1856_short_form_routing.py index c26ca943..732f395f 100644 --- a/tests/test_dev1856_short_form_routing.py +++ b/tests/test_dev1856_short_form_routing.py @@ -1,4 +1,4 @@ -"""DEV-1856 — short-form dotted-dimension auto-routing, end to end; covers every spec scenario.""" +"""Short-form dotted-dimension auto-routing, end to end; covers every spec scenario.""" from __future__ import annotations @@ -10,8 +10,8 @@ from slayer.core.enums import DataType, JoinCardinality, JoinType from slayer.core.errors import ( AmbiguousJoinPathError, - IllegalScopeReferenceError, UnknownReferenceError, + UnrelatedDatasetError, UnresolvableDimensionJoinError, ) from slayer.core.models import ( @@ -309,7 +309,7 @@ async def test_reverse_orientation_arity_is_respected(self, tmp_path) -> None: ) -# Requirement: Routed paths are executable (DEV-1853 bidirectional/parallel interplay) +# Requirement: Routed paths are executable (bidirectional/parallel interplay) class TestBidirectionalAndParallelEdges: async def test_unique_route_through_reverse_hop_resolves(self, tmp_path) -> None: @@ -391,7 +391,7 @@ async def test_unnamed_parallel_pair_is_unroutable(self, tmp_path) -> None: async def test_adjacent_parallel_edges_stay_ambiguous_hop(self, tmp_path) -> None: """Root itself has two named edges to Leaf: the bare ``Leaf.x`` hop fails - closed as DEV-1853's ambiguous join hop — routing never applies. Boundary + closed as the ambiguous join hop — routing never applies. Boundary guard; passes pre-implementation.""" leaf = SlayerModel( name="Leaf", sql_table="Leaf", data_source="test", @@ -417,7 +417,7 @@ async def test_adjacent_parallel_edges_stay_ambiguous_hop(self, tmp_path) -> Non # Requirement: an adjacent (direct) parallel pair is a fail-closed hop, never routed class TestAdjacentParallelParity: - """A parallel pair DIRECTLY off the root is DEV-1853's fail-closed ambiguous hop, not a + """A parallel pair DIRECTLY off the root is the fail-closed ambiguous hop, not a short-form route — identically across dimensions, saved measures, and schema-drift.""" def _models(self) -> list[SlayerModel]: @@ -493,11 +493,10 @@ async def test_ambiguous_target_suggests_a_full_path(self, tmp_path) -> None: async def test_unreachable_target_has_no_suggestion(self, tmp_path) -> None: engine = await _chain_engine(tmp_path, drop_customer_consumer=True) q = _q(dimensions=["Consumer.name"]) - with pytest.raises(UnresolvableDimensionJoinError) as ei: + with pytest.raises(UnrelatedDatasetError) as ei: await _cols_sql(engine, q) - assert ei.value.suggested_path is None - assert ei.value.reference == "Consumer.name" - assert ei.value.root_model == "Invoice" + assert "Consumer.name" in str(ei.value) + assert "Invoice" in str(ei.value) # Requirement: Broken explicit chains are never auto-fixed @@ -702,7 +701,7 @@ async def test_rerooted_saved_measure_nested_routing_round_trips(self, tmp_path) class TestScoping: async def test_cross_datasource_target_is_not_a_candidate(self, tmp_path) -> None: """A same-named ``Consumer`` in another datasource is never a route candidate; - with the in-datasource Consumer unreachable, the short form is rejected.""" + the in-datasource Consumer, unreachable, is read only through aggregates.""" storage = resolve_storage(str(tmp_path)) await _save(storage, _chain_models(drop_customer_consumer=True)) await storage.save_datasource( @@ -714,12 +713,14 @@ async def test_cross_datasource_target_is_not_a_candidate(self, tmp_path) -> Non )) engine = SlayerQueryEngine(storage=storage) q = _q(dimensions=["Consumer.name"]) - with pytest.raises(UnresolvableDimensionJoinError): + with pytest.raises(UnrelatedDatasetError) as ei: await _cols_sql(engine, q) + assert "Consumer.name" in str(ei.value) + assert "Invoice" in str(ei.value) async def test_downstream_stage_dotted_ref_stays_illegal(self, tmp_path) -> None: - """A short form in a downstream stage (flat schema) stays an illegal-scope - reference — routing is a base-scope rule, never applied past a stage boundary.""" + """A short form in a downstream stage (flat schema) is never routed past the stage + boundary: it names a model no join path reaches from the stage, read only through aggregates.""" engine = await _chain_engine(tmp_path) inner = SlayerQuery( name="s1", source_model="Invoice", @@ -730,7 +731,7 @@ async def test_downstream_stage_dotted_ref_stays_illegal(self, tmp_path) -> None source_model="s1", dimensions=["Consumer.email"], measures=[{"formula": "*:count"}], ) - with pytest.raises(IllegalScopeReferenceError): + with pytest.raises(UnrelatedDatasetError): await engine.execute(query=[inner, outer], dry_run=True) async def test_declared_join_absent_target_stays_unknown_ref(self, tmp_path) -> None: diff --git a/tests/test_dev1911_fanning_partition_key.py b/tests/test_dev1911_fanning_partition_key.py index 174dcb50..037847d1 100644 --- a/tests/test_dev1911_fanning_partition_key.py +++ b/tests/test_dev1911_fanning_partition_key.py @@ -1,4 +1,4 @@ -"""DEV-1911 — a path-less derived partition key fanning from its host fails closed +"""A path-less derived partition key fanning from its host fails closed in every mode. A ``partition_by=`` naming a host-local derived column whose definition crosses the @@ -7,7 +7,7 @@ inline — it is a mode-invariant input-safety error, distinct from a dimension merely unattributable from a further (cross-model) root, which still resolves by mode. The guard runs at bind (mode-unaware, one chokepoint), so it fires uniformly across every -position the key can appear in. On the DEV-1900 fixture graph, dual-engine. +position the key can appear in. On the shared fixture graph, dual-engine. Covers ``queries/attribution-modes``. """ @@ -17,7 +17,7 @@ import pytest from slayer.core.enums import JoinCardinality -from slayer.core.errors import AmbiguousJoinPathError, UnresolvableDimensionJoinError +from slayer.core.errors import AmbiguousJoinPathError, UnrelatedDatasetError from slayer.core.models import ( Column, DataType, @@ -277,16 +277,16 @@ async def test_error_names_the_remedy(self, engine): class TestUnreachableAndAmbiguousFailClosed: - """An unreachable or ambiguous partition_by path is caught upstream at dimension - resolution — never reaching the fanning guard — so it fails closed - deterministically without falsely naming the fanning hop.""" + """An unreachable partition_by path is a row-level read of an unrelated dataset and an + ambiguous one fails at dimension resolution — neither reaches the fanning guard, so + each fails closed deterministically without falsely naming the fanning hop.""" async def test_unreachable_path_fails_closed_no_false_hop(self, island_engine): query = _regions_q( dimensions=["name"], measures=[ModelMeasure( formula="pop:sum(partition_by=island.value)", name="w")]) - with pytest.raises(UnresolvableDimensionJoinError) as ei: + with pytest.raises(UnrelatedDatasetError) as ei: await island_engine.execute(query) assert HOP not in str(ei.value), str(ei.value) diff --git a/tests/test_division_by_zero.py b/tests/test_division_by_zero.py new file mode 100644 index 00000000..30d7a907 --- /dev/null +++ b/tests/test_division_by_zero.py @@ -0,0 +1,70 @@ +"""A division whose divisor is 0 is NULL on every backend, never an error, an infinity or NaN.""" + +from __future__ import annotations + +import sqlglot +import pytest +from sqlglot import exp + +from slayer.core.enums import DataType +from slayer.core.models import Column, SlayerModel +from slayer.core.query import SlayerQuery +from slayer.sql.dialects import SQLGLOT_NAMES + +from tests._dev1737_fixtures import TableSpec, seed_backend +from tests._engine_helpers import _engine_generate, seeded_exec_engine + +ORDERS = TableSpec( + name="orders", columns=[("id", "INT"), ("amount", "DOUBLE"), ("status", "TEXT")], + rows=[(1, 10.0, "ok"), (2, 20.0, "ok")], +) + + +def _orders() -> SlayerModel: + return SlayerModel( + name="orders", sql_table="orders", data_source="test", + columns=[ + Column(name="id", type=DataType.INT, primary_key=True), + Column(name="amount", type=DataType.DOUBLE), + Column(name="status", type=DataType.TEXT), + ], + ) + + +def _empty_population_ratios() -> SlayerQuery: + return SlayerQuery.model_validate({ + "source_model": "orders", + "measures": [ + {"formula": "sum(amount) / count(*)", "name": "avg_amount"}, + {"formula": "count(id) / count(*)", "name": "share"}, + ], + "filters": ["status = 'none'"], + }) + + +@pytest.mark.parametrize("backend", ["sqlite", "duckdb"]) +async def test_a_ratio_over_an_empty_population_is_null(backend: str) -> None: + async with seeded_exec_engine( + dialect=backend, seed=lambda p: seed_backend(backend, p, [ORDERS]), models=[_orders()], + ) as (engine, _db): + resp = await engine.execute(_empty_population_ratios()) + assert [(r["orders.avg_amount"], r["orders.share"]) for r in resp.data] == [(None, None)] + + +@pytest.mark.parametrize("dialect", SQLGLOT_NAMES) +async def test_every_dialect_guards_the_divisor(dialect: str) -> None: + sql = await _engine_generate(query=_empty_population_ratios(), model=_orders(), dialect=dialect) + divisions = list(sqlglot.parse_one(sql, dialect=dialect).find_all(exp.Div)) + assert divisions, sql + assert all( + isinstance(d.expression, exp.Nullif) or ( + isinstance(d.expression, exp.Anonymous) and d.expression.name.upper() == "NULLIF" + ) + for d in divisions + ), sql + + +async def test_a_nonzero_literal_divisor_is_not_guarded() -> None: + query = SlayerQuery.model_validate({"source_model": "orders", "measures": [{"formula": "sum(amount) / 2", "name": "half"}]}) + sql = await _engine_generate(query=query, model=_orders(), dialect="postgres") + assert "NULLIF" not in sql.upper(), sql diff --git a/tests/test_generator2_multistage.py b/tests/test_generator2_multistage.py index 1d2b6fd3..f0d294f0 100644 --- a/tests/test_generator2_multistage.py +++ b/tests/test_generator2_multistage.py @@ -1,4 +1,4 @@ -"""DEV-1450 stage 7b.15c — multi-stage DAG rendering for the typed pipeline. +"""Multi-stage DAG rendering for the typed pipeline. ``plan_stages`` returns a ``List[PlannedQuery]`` (root last). The legacy engine renders a multi-stage DAG as nested rename-subqueries via @@ -7,7 +7,7 @@ these tests are execution-based: render the new SQL, run it against the same seeded SQLite the legacy ``engine.execute([...])`` ran against, and assert identical result-key columns and row sets — plus structural shape (CTE per -non-root stage, flat downstream binding, the DEV-1448/1449 contracts). +non-root stage, flat downstream binding, the stage-alias and flat-schema contracts). """ from __future__ import annotations @@ -22,7 +22,7 @@ import pytest from slayer.core.enums import DataType -from slayer.core.errors import IllegalScopeReferenceError +from slayer.core.errors import UnrelatedDatasetError from slayer.core.models import Column, DatasourceConfig, ModelJoin, SlayerModel from slayer.core.query import SlayerQuery from slayer.engine.query_engine import SlayerQueryEngine @@ -246,7 +246,7 @@ async def test_mixed_local_and_cross_model_intermediate_matches_legacy(harness): # --------------------------------------------------------------------------- -# DEV-1448 — user ``name`` on a join-traversed measure governs the stage +# User ``name`` on a join-traversed measure governs the stage # column alias and downstream references resolve it. # --------------------------------------------------------------------------- @@ -279,7 +279,7 @@ async def test_dev1448_named_join_measure_alias(harness): # --------------------------------------------------------------------------- -# DEV-1449 — downstream stage sees the upstream as a FLAT schema. +# A downstream stage sees the upstream as a FLAT schema. # --------------------------------------------------------------------------- @@ -314,7 +314,7 @@ async def test_dev1449_dotted_form_raises(harness): dimensions=["customers.region"], measures=[{"formula": "amount:sum"}], ) - # Dotted form against a flat upstream schema is illegal. + # The dotted form reads a model no join path reaches from the flat upstream stage. root = SlayerQuery( source_model="stage1", dimensions=["customers.region"], @@ -323,12 +323,12 @@ async def test_dev1449_dotted_form_raises(harness): bundle = await slayer.engine.bundle_builder.build_resolved_source_bundle( query=root, storage=storage, named_queries={"stage1": stage1} ) - with pytest.raises(IllegalScopeReferenceError): + with pytest.raises(UnrelatedDatasetError): plan_stages(queries=[stage1, root], bundle=bundle) # --------------------------------------------------------------------------- -# DEV-1716 (Codex test-review High 1) — the terminal emit of the module-level +# The terminal emit of the module-level # ``generate_planned_stages`` (multi-stage root) must also route through the # dialect ``rewrite_emitted_sql`` hook. The BigQuery TestBigQueryAliasMangling # pins only exercise ``SQLGenerator.generate()`` / single-stage @@ -399,7 +399,7 @@ async def test_opaque_dim_grouped_in_downstream_stage_rejected(tmp_path): across the ``StageSchema`` boundary, not only at the ``ModelScope`` origin. Regression for the downstream-grouping gap that allowing raw-row opaque - projection (``distinct_dimension_values=False``, DEV-1543) opened: stage 1 + projection (``distinct_dimension_values=False``) opened: stage 1 legally projects the opaque ``loc`` as a raw value, but the root stage groups by it — which the database would reject (a ``point`` has no equality operator), so generation must fail up front with an actionable message. diff --git a/tests/test_mcp_documented_idioms.py b/tests/test_mcp_documented_idioms.py index 7b66a98d..bf2f940b 100644 --- a/tests/test_mcp_documented_idioms.py +++ b/tests/test_mcp_documented_idioms.py @@ -293,6 +293,14 @@ async def test_cross_model_ratio(child_engine: SlayerQueryEngine) -> None: assert [fx.value(r, ".per_customer") for r in resp.data] == [pytest.approx(168 / 4)] +async def test_unrelated_model_ratio(child_engine: SlayerQueryEngine) -> None: + resp = await _run(child_engine, { + "source_model": "customers", "measures": [{"formula": fx.UNRELATED_RATIO, "name": "per_customer"}], + }) + assert [fx.value(r, ".per_customer") for r in resp.data] == [pytest.approx(6 / 4)] + assert "unrelated_dataset" in _kinds(resp) + + async def test_outer_stage_reads_flattened_inner_dimension(engine: SlayerQueryEngine) -> None: resp = await _run(engine, [ { diff --git a/tests/test_mcp_surface_budget.py b/tests/test_mcp_surface_budget.py index 078756cb..249b9af9 100644 --- a/tests/test_mcp_surface_budget.py +++ b/tests/test_mcp_surface_budget.py @@ -29,6 +29,7 @@ SECOND_CHILD, STAGE_NEEDED, STAGE_NOT_NEEDED, + UNRELATED_MODEL, ) DESCRIPTION_BUDGET = 2048 @@ -53,6 +54,7 @@ "an order with no customer": ("SlayerQuery", "measures"), "only the columns the question asks for": ("SlayerQuery", "order"), "where the facts are": ("SlayerQuery", "source_model"), + UNRELATED_MODEL: ("SlayerQuery", "measures"), **EXAMPLE_OWNERS, } @@ -71,6 +73,7 @@ def _field_path(model: str, field: str) -> tuple[str, ...]: for marker in ( "time_spine.timestamp", "an order with no customer", "only the columns the question asks for", "where the facts are", SECOND_CHILD, CROSS_MODEL_RATIO, STAGE_NOT_NEEDED, STAGE_NEEDED, + UNRELATED_MODEL, ) }, ONE_QUERY: frozenset({_INSTRUCTIONS, _TOOL_DESCRIPTION}), @@ -415,6 +418,11 @@ def test_measure_formula_points_to_the_measures_field() -> None: assert len(text) <= 200, text +def test_unrelated_aggregate_varies_per_spine_bucket() -> None: + text = _tools()["query"].inputSchema["$defs"]["SlayerQuery"]["properties"]["measures"].get("description") or "" + assert "repeated on every row (per bucket of a time_spine time dimension)" in text + + def test_date_range_is_described() -> None: text = _tools()["query"].inputSchema["$defs"]["TimeDimension"]["properties"]["date_range"].get("description") or "" for needle in ("change,", "change_pct", "time_shift", "window=", "cumsum"): diff --git a/tests/test_nested_dag_cross_stage_refs.py b/tests/test_nested_dag_cross_stage_refs.py index 18c7b164..5736bf4f 100644 --- a/tests/test_nested_dag_cross_stage_refs.py +++ b/tests/test_nested_dag_cross_stage_refs.py @@ -14,7 +14,6 @@ from sqlglot import exp from slayer.core.enums import DataType, TimeGranularity -from slayer.core.errors import SlayerError from slayer.core.models import ( Column, DatasourceConfig, @@ -162,6 +161,23 @@ async def _engine_with_real_sqlite( # quoting / formatting drift. # --------------------------------------------------------------------------- +def _assert_reads_unrelated_customers(resp) -> None: + """``customers``, which no join path reaches from ``s1``, is aggregated over its own rows — never + by re-aggregating an ``s1`` flat column — and announced as an unrelated dataset.""" + assert any( + w.kind == "unrelated_dataset" and w.dataset == "customers" for w in resp.warnings or [] + ), resp.warnings + assert resp.sql is not None + tree = sqlglot.parse_one(resp.sql, dialect="sqlite") + assert not [c for c in tree.find_all(exp.Column) if c.name.startswith("customers__revenue")], resp.sql + own_rows = [ + s for s in tree.find_all(exp.Select) + if not s.args.get("group") and any(t.name == "customers" for t in s.find_all(exp.Table)) + and any(c.name == "revenue" for agg in s.find_all(exp.AggFunc) for c in agg.find_all(exp.Column)) + ] + assert own_rows, resp.sql + + def _outermost_select(sql: str, dialect: str = "sqlite") -> exp.Select: tree = sqlglot.parse_one(sql, dialect=dialect) assert isinstance(tree, exp.Select), f"expected outermost Select, got {type(tree).__name__}" @@ -226,7 +242,7 @@ async def test_outer_references_inner_flat_alias_not_broken_hybrid(self) -> None ) outer = SlayerQuery( source_model="s1", - # DEV-1450 typed contract: downstream stages see a FLAT + # Typed contract: downstream stages see a FLAT # schema — the inner stage's `customers.regions.name` # dim is projected as `customers__regions__name` on s1. dimensions=["customers__regions__name"], @@ -272,7 +288,7 @@ async def test_end_to_end_against_real_sqlite(self, tmp_path) -> None: ) outer = SlayerQuery( source_model="s1", - # DEV-1450 typed contract: downstream uses the flat alias. + # Typed contract: downstream uses the flat alias. dimensions=["customers__regions__name"], measures=[{"formula": "*:count"}], ) @@ -300,7 +316,7 @@ async def test_three_hop_cross_stage(self) -> None: ) outer = SlayerQuery( source_model="s1", - # DEV-1450 typed contract: flat downstream alias. + # Typed contract: flat downstream alias. dimensions=["customers__regions__countries__name"], measures=[{"formula": "*:count"}], ) @@ -347,7 +363,7 @@ async def test_multi_hop_dotted_time_dim_cross_stage(self) -> None: outer = SlayerQuery( source_model="s1", time_dimensions=[TimeDimension( - # DEV-1450 typed contract: flat downstream alias. + # Typed contract: flat downstream alias. dimension=ColumnRef(name="customers__regions__last_activity_at"), granularity=TimeGranularity.MONTH, )], @@ -390,7 +406,7 @@ async def test_cross_model_measure_reaggregation_sql_shape(self) -> None: ) outer = SlayerQuery( source_model="s1", - # DEV-1450 typed re-aggregation: outer references the flat + # Typed re-aggregation: outer references the flat # inner alias `customers__revenue_sum` directly and sums it. measures=[{"formula": "customers__revenue_sum:sum"}], ) @@ -425,7 +441,7 @@ async def test_cross_model_measure_reaggregation_row_count(self, tmp_path) -> No ) outer = SlayerQuery( source_model="s1", - # DEV-1450 typed re-aggregation: outer references the flat + # Typed re-aggregation: outer references the flat # inner alias directly. measures=[{"formula": "customers__revenue_sum:sum"}], ) @@ -436,7 +452,7 @@ async def test_cross_model_measure_reaggregation_row_count(self, tmp_path) -> No # SUM per region matches per-customer revenue; outer re-SUM # totals 1500. row = resp.data[0] - # DEV-1450 typed contract: re-aggregating the flat inner alias + # Typed contract: re-aggregating the flat inner alias # surfaces under the canonical `_sum` shape. assert "s1.customers__revenue_sum_sum" in row, ( f"Re-aggregated flat alias must surface as " @@ -462,7 +478,7 @@ async def test_filter_dotted_ref_rewritten_to_flat(self) -> None: ) outer = SlayerQuery( source_model="s1", - # DEV-1450 typed contract: downstream uses flat alias in + # Typed contract: downstream uses flat alias in # dimensions AND filters. dimensions=["customers__regions__name"], measures=[{"formula": "*:count"}], @@ -502,7 +518,7 @@ async def test_filter_cross_stage_filters_rows(self, tmp_path) -> None: ) outer = SlayerQuery( source_model="s1", - # DEV-1450 typed contract: downstream flat-only refs. + # Typed contract: downstream flat-only refs. dimensions=["customers__regions__name"], measures=[{"formula": "*:count"}], filters=["customers__regions__name = 'West'"], @@ -529,7 +545,7 @@ async def test_order_by_dotted_ref_sql_shape(self) -> None: ) outer = SlayerQuery( source_model="s1", - # DEV-1450 typed contract: downstream flat-only refs. + # Typed contract: downstream flat-only refs. dimensions=["customers__regions__name"], measures=[{"formula": "*:count"}], order=[{"column": "customers__regions__name"}], @@ -572,7 +588,7 @@ async def test_order_by_actually_sorts_rows(self, tmp_path) -> None: ) outer = SlayerQuery( source_model="s1", - # DEV-1450 typed contract: downstream flat-only refs. + # Typed contract: downstream flat-only refs. dimensions=["customers__regions__name"], measures=[{"formula": "*:count"}], order=[{"column": "customers__regions__name"}], @@ -647,23 +663,18 @@ async def test_existing_single_stage_multi_hop_query_unchanged(self) -> None: # =========================================================================== -# Test #13 — DEV-1443 rename interaction: colon syntax does NOT auto-resolve. +# Test #13 — rename interaction: colon syntax does NOT auto-resolve. # =========================================================================== class TestRenamedInnerMeasureCrossStage: async def test_renamed_cmm_colon_syntax_no_longer_resolves_after_rename( self, ) -> None: - """Post-DEV-1448 (main): `_alias_to_short`/cm.name now - propagates the user-supplied rename to the wrapped virtual - model's column. So `{formula: customers.revenue:sum, name: rev}` - on s1 leaves s1.columns with `rev` (not the canonical flat - `customers__revenue_sum`). The outer's colon-syntax reference - `customers.revenue:sum` no longer matches the intercept's - candidate flat name → falls through to the cross-model CTE - path → raises on the virtual stage (no joins). - - DEV-1445 territory: users renamed cross-model measures must - reference them by the rename on downstream stages.""" + """The user-supplied rename propagates to the wrapped virtual model's + column: `{formula: customers.revenue:sum, name: rev}` on s1 leaves + s1.columns with `rev` (not the canonical flat `customers__revenue_sum`). + The outer's `customers.revenue:sum` no longer matches the intercept's + candidate flat name, so it never re-aggregates s1: `customers`, which no + join path reaches from s1, is aggregated over its own rows.""" engine, tmp = await _engine_with_join_chain() try: inner = SlayerQuery( @@ -676,13 +687,13 @@ async def test_renamed_cmm_colon_syntax_no_longer_resolves_after_rename( source_model="s1", measures=[{"formula": "customers.revenue:sum"}], ) - with pytest.raises((SlayerError, ValueError)): - await engine.execute(query=[inner, outer], dry_run=True) + resp = await engine.execute(query=[inner, outer], dry_run=True) + _assert_reads_unrelated_customers(resp) finally: tmp.cleanup() async def test_renamed_cmm_via_rename_resolves(self) -> None: - """Post-DEV-1448 (main): the rename propagates to s1.columns, + """The rename propagates to s1.columns, so `rev:sum` on the outer DOES resolve (s1.get_column('rev') finds it as a local column, the standard local-aggregate path emits SUM(s1.rev)).""" @@ -709,7 +720,7 @@ async def test_renamed_cmm_via_rename_resolves(self) -> None: (c.table, c.name) for c in s.find_all(exp.Column) ) assert ("s1", "rev") in outer_sum_targets, ( - f"Outer SUM(s1.rev) expected after DEV-1448 rename " + f"Outer SUM(s1.rev) expected after rename " f"propagation.\ngot: {outer_sum_targets}\nSQL:\n{sql}" ) finally: @@ -739,7 +750,7 @@ async def test_time_shift_over_multi_hop_dotted_time_dim(self) -> None: outer = SlayerQuery( source_model="s1", time_dimensions=[TimeDimension( - # DEV-1450 typed contract: downstream flat alias. + # Typed contract: downstream flat alias. dimension=ColumnRef(name="customers__regions__last_activity_at"), granularity=TimeGranularity.MONTH, )], @@ -863,7 +874,7 @@ async def test_star_count_cross_stage_alias_resolution(self) -> None: ) outer = SlayerQuery( source_model="s1", - # DEV-1450 typed re-aggregation: outer references the flat + # Typed re-aggregation: outer references the flat # inner alias `customers___count` directly and sums it to # roll up total rows. COUNT on the stage rows would # silently return the number of groups instead. @@ -910,9 +921,8 @@ class TestCrossModelInterceptSemanticsGate: async def test_avg_falls_through_to_cte_path(self) -> None: """Cross-stage `customers.revenue:avg` must NOT be intercepted — averaging an inner-aggregated average is not equal to the overall - average. The intercept returns None; the existing cross-model - path takes over (which on a virtual stage with no joins raises - ValueError — that's still better than silently lying).""" + average. `customers`, which no join path reaches from s1, is + averaged over its own rows instead.""" engine, tmp = await _engine_with_join_chain() try: inner = SlayerQuery( @@ -925,18 +935,14 @@ async def test_avg_falls_through_to_cte_path(self) -> None: source_model="s1", measures=[{"formula": "customers.revenue:avg"}], ) - # Falls through to existing CTE path → raises because s1 has - # no joins. Pin the existing error rather than asserting the - # outer SQL has any specific shape (the fix is: don't - # silently re-aggregate). - with pytest.raises((SlayerError, ValueError)): - await engine.execute(query=[inner, outer], dry_run=True) + resp = await engine.execute(query=[inner, outer], dry_run=True) + _assert_reads_unrelated_customers(resp) finally: tmp.cleanup() async def test_count_distinct_falls_through(self) -> None: """Cross-stage `customers.revenue:count_distinct` is also - non-distributive — falls through to the CTE path.""" + non-distributive — `customers` is aggregated over its own rows.""" engine, tmp = await _engine_with_join_chain() try: inner = SlayerQuery( @@ -949,8 +955,8 @@ async def test_count_distinct_falls_through(self) -> None: source_model="s1", measures=[{"formula": "customers.revenue:count_distinct"}], ) - with pytest.raises((SlayerError, ValueError)): - await engine.execute(query=[inner, outer], dry_run=True) + resp = await engine.execute(query=[inner, outer], dry_run=True) + _assert_reads_unrelated_customers(resp) finally: tmp.cleanup() @@ -968,7 +974,7 @@ async def test_sum_passes_through_intercept(self) -> None: ) outer = SlayerQuery( source_model="s1", - # DEV-1450 typed re-aggregation via flat inner alias. + # Typed re-aggregation via flat inner alias. measures=[{"formula": "customers__revenue_sum:sum"}], ) resp = await engine.execute(query=[inner, outer], dry_run=True) @@ -1007,7 +1013,7 @@ async def test_renamed_intercept_surfaces_user_alias(self) -> None: ) outer = SlayerQuery( source_model="s1", - # DEV-1450 typed re-aggregation with rename. + # Typed re-aggregation with rename. measures=[{"formula": "customers__revenue_sum:sum", "name": "rev"}], ) resp = await engine.execute(query=[inner, outer], dry_run=True) @@ -1023,7 +1029,7 @@ async def test_renamed_intercept_surfaces_user_alias(self) -> None: async def test_renamed_intercept_filter_via_colon_form(self) -> None: """Outer renames the re-aggregated flat measure to `rev` AND - filters via the colon form. Per DEV-1443, the filter may use + filters via the colon form. The filter may use either the colon form or the user alias; both resolve to the rename.""" engine, tmp = await _engine_with_join_chain() @@ -1036,7 +1042,7 @@ async def test_renamed_intercept_filter_via_colon_form(self) -> None: ) outer = SlayerQuery( source_model="s1", - # DEV-1450 typed re-aggregation with rename. + # Typed re-aggregation with rename. measures=[{"formula": "customers__revenue_sum:sum", "name": "rev"}], filters=["customers__revenue_sum:sum > 100"], ) @@ -1089,7 +1095,7 @@ class TestCrossModelInterceptDuplicateQfieldGuard: async def test_intercepted_unrenamed_works_as_middle_stage_in_three_stage_dag( self, ) -> None: - """DEV-1450 typed contract end-to-end across a 3-stage DAG: + """Typed contract end-to-end across a 3-stage DAG: stage 1 projects a cross-model measure (legal — has joins), stage 2 re-aggregates the flat inner alias, stage 3 re-aggregates the stage-2 flat alias. The contract requires @@ -1161,15 +1167,14 @@ async def test_intercept_skips_user_named_local_measure_that_looks_like_cmm_cano # candidate computes `customers__revenue_sum` and the # column exists on s1, BUT it isn't an auto-derived cross- # model canonical-flat (it's the user-renamed local - # measure). The intercept must skip it and fall through - # to the cross-model CTE path, which raises because s1 - # has no joins. + # measure). The intercept must skip it: `customers`, which no + # join path reaches from s1, is aggregated over its own rows. outer = SlayerQuery( source_model="s1", measures=[{"formula": "customers.revenue:sum"}], ) - with pytest.raises((SlayerError, ValueError)): - await engine.execute(query=[inner, outer], dry_run=True) + resp = await engine.execute(query=[inner, outer], dry_run=True) + _assert_reads_unrelated_customers(resp) finally: tmp.cleanup() @@ -1183,11 +1188,9 @@ async def test_unrenamed_intercepted_cmm_colon_filter_does_not_get_rewritten_as_ HAVING on the re-aggregated measure. The fallback gating recognises the aggregation-canonical leaf - and skips the dim-style rewrite. The standard strict path - then raises (DEV-1445 territory: cross-model measure filters - are not yet auto-resolved). The unrenamed case is the same - — users must reference via the renamed alias, restructure - with multi-stage, or wait for DEV-1445.""" + and skips the dim-style rewrite: `customers`, which no join path + reaches from s1, is aggregated over its own rows and the filter + applies to that value.""" engine, tmp = await _engine_with_join_chain() try: inner = SlayerQuery( @@ -1201,18 +1204,15 @@ async def test_unrenamed_intercepted_cmm_colon_filter_does_not_get_rewritten_as_ measures=[{"formula": "customers.revenue:sum"}], filters=["customers.revenue:sum > 100"], ) - # The strict path raises rather than silently emitting a - # WHERE that would clip rows before the outer aggregation. - # (The rename path test pins the WORKING case.) - with pytest.raises((SlayerError, ValueError)): - await engine.execute(query=[inner, outer], dry_run=True) + resp = await engine.execute(query=[inner, outer], dry_run=True) + _assert_reads_unrelated_customers(resp) finally: tmp.cleanup() async def test_intercepted_cmm_order_only_reaggregated_resolves( self, ) -> None: - """DEV-1712 (D-D variant 1): an AGGREGATED outer stage may order by + """D-D variant 1: an AGGREGATED outer stage may order by an EXPLICIT re-aggregation of an inner-stage column (``customers__revenue_sum:max``) that is not re-projected. It materialises as a hidden aggregate on s1 and orders at the outer @@ -1261,7 +1261,7 @@ async def test_intercepted_cmm_order_only_reaggregated_resolves( async def test_intercepted_cmm_order_only_bare_grouped_max_wraps( self, ) -> None: - """DEV-1712 (D-D variant 2), superseded by DEV-1703 Phase 1: an + """D-D variant 2, as the typed pipeline resolves it: an AGGREGATED outer stage ordering by a BARE inner-stage row column (``customers__revenue_sum``, not re-aggregated) is not in the outer GROUP BY. Stage 8 rejected it; the sort key now materialises as a @@ -1269,7 +1269,7 @@ async def test_intercepted_cmm_order_only_bare_grouped_max_wraps( The stage boundary is the point of this test: the wrap must resolve against the ``s1`` rowset (``MIN(s1.customers__revenue_sum)`` — the - order defaults to ASC and DEV-1747 D10 made the wrap direction-aware), + order defaults to ASC and the wrap is direction-aware), never reach back into s1's own source tables, and must not widen the outer grain or leak into the public projection.""" @@ -1304,7 +1304,7 @@ async def test_intercepted_cmm_order_only_bare_grouped_max_wraps( async def test_intercepted_cmm_order_only_bare_ungrouped_splits( self, ) -> None: - """DEV-1712 (D-D variant 3): a NON-aggregating outer stage (dedup off) + """D-D variant 3: a NON-aggregating outer stage (dedup off) ordering by a bare inner-stage column emits a valid SPLIT reference against the s1 rowset — resolving on s1, never a bare `customers` table.""" @@ -1345,7 +1345,7 @@ async def test_intercepted_cmm_order_only_bare_ungrouped_splits( async def test_intercepted_cmm_order_only_self_qualified_resolves( self, ) -> None: - """DEV-1712 (Codex): a downstream stage may SELF-qualify an order ref + """A downstream stage may SELF-qualify an order ref with its own stage name (``s1.customers__revenue_sum``). The qualifier-aware host-local check must recognise the stage relation as the host, so it resolves identically to the bare form — not @@ -1388,7 +1388,7 @@ async def test_intercepted_cmm_order_only_self_qualified_resolves( # =========================================================================== -# DEV-1779 — the cross-model-INTERCEPT rename site. +# The cross-model-INTERCEPT rename site. # # A downstream-stage formula that references an intercepted cross-model # aggregate BEFORE that same aggregate is selected+renamed must not orphan @@ -1406,16 +1406,16 @@ def _dev1779_undeclared(sql: str) -> set[str]: return referenced - declared -class TestDev1779InterceptRename: +class TestInterceptRename: async def test_formula_before_renamed_intercept_ref(self, tmp_path) -> None: - """DEV-1779 across a stage boundary: the outer stage lists a FORMULA + """Across a stage boundary: the outer stage lists a FORMULA over the re-aggregated intercept measure FIRST (which, on the old enrichment pipeline, froze the intercept's flat alias), then selects the same aggregate under an explicit rename. The branch's structural re-aggregation must keep both references pointing at one column regardless of declaration order. - Downstream stages see a FLAT schema (DEV-1450), so the outer stage + Downstream stages see a FLAT schema, so the outer stage references the inner cross-model aggregate by its flat path-mangled name ``customers__revenue_sum`` — the dotted ``customers.revenue`` form is intentionally illegal past a stage boundary.""" diff --git a/tests/test_query_backed_typed_expansion.py b/tests/test_query_backed_typed_expansion.py index a9b50ceb..e0054cb1 100644 --- a/tests/test_query_backed_typed_expansion.py +++ b/tests/test_query_backed_typed_expansion.py @@ -17,6 +17,8 @@ from unittest.mock import patch import pytest +import sqlglot +from sqlglot import exp import slayer.engine.query_engine as query_engine_module from slayer.core.enums import DataType @@ -1195,15 +1197,11 @@ async def test_outer_dotted_ref_canonical_alias_no_longer_resolves( self, ) -> None: """A query-backed model that already aggregated ``customers.revenue:sum`` - exposes the canonical flat name ``customers__revenue_sum``. Outer - dotted refs (``customers.revenue:sum``) against the virtual model - DO NOT silently re-aggregate via the legacy ``SourceModelOrigin`` - lineage walk — this is the P4 closure (decision D). - - The exact error surface (``ValueError`` from binder, or empty SQL - with no matching ref) depends on the typed pipeline's resolution - order; the assertion is that the dotted form does not silently - succeed with a duplicate aggregation. + exposes the canonical flat name ``customers__revenue_sum``. An outer + dotted ref (``customers.revenue:sum``) against the virtual model never + re-aggregates that column through the legacy ``SourceModelOrigin`` + lineage walk (the P4 closure): ``customers``, which no join path + reaches from the virtual model, is aggregated over its own rows. """ orders_with_join = _orders_model().model_copy(update={ "joins": [ModelJoin( @@ -1241,19 +1239,22 @@ async def test_outer_dotted_ref_canonical_alias_no_longer_resolves( ) resp_flat = await engine.execute(flat_q, dry_run=True) assert resp_flat.sql is not None - # The dotted form must surface a clear binder error — not a - # silent re-aggregation through the legacy SourceModelOrigin - # lineage walk. The error message must reference the failed - # ref so callers can correct their query. dotted_q = SlayerQuery( source_model="qb_already_aggregated", measures=[{"formula": "customers.revenue:sum"}], dimensions=["status"], ) - with pytest.raises( - (ValueError, KeyError), - match=r"(customers|revenue|not found|cannot resolve|unknown|join)", - ): - await engine.execute(dotted_q, dry_run=True) + resp = await engine.execute(dotted_q, dry_run=True) + assert any( + w.kind == "unrelated_dataset" and w.dataset == "customers" for w in resp.warnings or [] + ), resp.warnings + assert resp.sql is not None + tree = sqlglot.parse_one(resp.sql, dialect="sqlite") + assert not [c for c in tree.find_all(exp.Column) if c.name.startswith("customers__revenue")], resp.sql + assert any( + not sel.args.get("group") and any(t.alias_or_name == "customers" for t in sel.find_all(exp.Table)) + and any(c.name == "revenue" for agg in sel.find_all(exp.AggFunc) for c in agg.find_all(exp.Column)) + for sel in tree.find_all(exp.Select) + ), resp.sql finally: tmp.cleanup() diff --git a/tests/test_recommend_root_model.py b/tests/test_recommend_root_model.py index 008a94a4..14ea0490 100644 --- a/tests/test_recommend_root_model.py +++ b/tests/test_recommend_root_model.py @@ -457,6 +457,56 @@ async def test_dominated_candidates_dropped(self, engine) -> None: assert "customers" not in names +# -------------------------------------------------------------------------- +# Attachments on unrelated datasets (no join path from the root) +# -------------------------------------------------------------------------- +class TestUnrelatedAttachments: + async def test_unrelated_attachment_is_reported_through_the_product_hop(self, engine) -> None: + rec = await engine.recommend_root_model(["customers.name", "logs.id:count"]) + assert rec.root_model == "customers" + assert rec.reachable is True + flags = {ip.input_item: (ip.path, ip.unrelated) for ip in rec.item_paths} + assert flags == {"customers.name": ("name", False), "logs.id:count": ("count(logs.id)", True)} + resp = await engine.execute( + SlayerQuery.model_validate({"source_model": "customers", "measures": [flags["logs.id:count"][0]]}), + dry_run=True, + ) + assert resp.sql + + async def test_unrelated_attachment_never_steers_the_choice(self, engine) -> None: + items = ["customers.name", "regions.name"] + without = await engine.recommend_root_model(items) + with_unrelated = await engine.recommend_root_model([*items, "logs.id:count", "agents.id:count"]) + assert with_unrelated.root_model == without.root_model == "customers" + assert {ip.input_item for ip in with_unrelated.item_paths if ip.unrelated} == { + "logs.id:count", "agents.id:count", + } + + async def test_feasible_root_hint_reaches_an_unrelated_attachment(self, engine) -> None: + rec = await engine.recommend_root_model(["customers.name", "logs.id:count"], root_hint="orders") + assert rec.root_model == "orders" + assert rec.warnings == [] + assert {ip.input_item: ip.unrelated for ip in rec.item_paths} == { + "customers.name": False, "logs.id:count": True, + } + + async def test_unrelated_column_stays_unreachable(self, engine) -> None: + rec = await engine.recommend_root_model(["customers.name", "logs.line"]) + assert rec.root_model is None + assert rec.reachable is False + assert rec.item_paths == [] + + async def test_attachments_alone_keep_join_path_selection(self, engine) -> None: + rec = await engine.recommend_root_model(["customers.id:count", "logs.id:count"]) + assert rec.root_model is None + assert rec.reachable is False + assert rec.item_paths == [] + + async def test_connected_items_are_never_flagged(self, engine) -> None: + rec = await engine.recommend_root_model(["orders.status", "products.price:sum", "orders.aov"]) + assert [ip.unrelated for ip in rec.item_paths] == [False, False, False] + + # -------------------------------------------------------------------------- # data_source scoping & dedup # -------------------------------------------------------------------------- @@ -787,6 +837,10 @@ def test_item_path_fields(self) -> None: assert ip.input_item == "orders.revenue:sum" assert ip.path == "customers.revenue:sum" + def test_item_path_unrelated_defaults_false(self) -> None: + assert ItemPath(input_item="orders.status", path="status").unrelated is False + assert ItemPath(input_item="logs.id:count", path="count(logs.id)", unrelated=True).unrelated is True + def test_candidate_coverage_fields(self) -> None: cc = CandidateCoverage( model_name="orders", diff --git a/tests/test_recommend_root_model_surfaces.py b/tests/test_recommend_root_model_surfaces.py index 42b0ce03..54d4213f 100644 --- a/tests/test_recommend_root_model_surfaces.py +++ b/tests/test_recommend_root_model_surfaces.py @@ -9,10 +9,12 @@ import sys import tempfile from collections.abc import AsyncIterator +from typing import Any import pytest import pytest_asyncio from fastapi.testclient import TestClient +from mcp.types import TextContent from slayer.api.server import create_app from slayer.cli import _run_recommend_root_model, main @@ -72,7 +74,7 @@ async def test_markdown_names_root(self, storage) -> None: name="recommend_root_model", arguments={"items": ["customers.name", "products.category"]}, ) - text = blocks[0].text + text = _text(blocks) assert "orders" in text assert "customers.name" in text @@ -82,7 +84,7 @@ async def test_json_format(self, storage) -> None: name="recommend_root_model", arguments={"items": ["orders.status"], "data_source": "mydb", "format": "json"}, ) - payload = json.loads(blocks[0].text) + payload = json.loads(_text(blocks)) assert payload["root_model"] == "orders" assert payload["reachable"] is True @@ -92,7 +94,7 @@ async def test_no_root_renders_coverage(self, storage) -> None: name="recommend_root_model", arguments={"items": ["customers.name", "tickets.subject"], "format": "json"}, ) - payload = json.loads(blocks[0].text) + payload = json.loads(_text(blocks)) assert payload["root_model"] is None assert payload["reachable"] is False assert payload["coverage"] @@ -103,7 +105,7 @@ async def test_invalid_format_returns_friendly_error(self, storage) -> None: name="recommend_root_model", arguments={"items": ["orders.status"], "data_source": "mydb", "format": "xml"}, ) - assert "failed" in blocks[0].text.lower() + assert "failed" in _text(blocks).lower() async def test_ambiguous_model_returns_friendly_error(self) -> None: # 'orders' in two datasources → AmbiguousModelError (a SlayerError, @@ -125,7 +127,7 @@ async def test_ambiguous_model_returns_friendly_error(self) -> None: ) # Routed through the shared MCP ambiguity hint (mentions data_source / # multiple datasources), not a bare "failed" string. - text = blocks[0].text.lower() + text = _text(blocks).lower() assert "multiple datasources" in text assert "data_source" in text @@ -230,6 +232,86 @@ async def test_local_engine_async(self, storage) -> None: assert rec.root_model == "orders" # to-one determiner of both +UNRELATED_ITEMS = ["customers.name", "tickets.id:count"] +UNRELATED_FLAGS = {"customers.name": False, "tickets.id:count": True} + + +def _flags(payload: dict) -> dict[str, bool]: + return {ip["input_item"]: ip.get("unrelated") for ip in payload["item_paths"]} + + +def _text(blocks: Any) -> str: + """The text of an MCP call's first content block.""" + block = blocks[0] + assert isinstance(block, TextContent) + return block.text + + +def _flagged_in_text(text: str) -> bool: + """The text's line for the unrelated item says so, and the connected item's line does not.""" + def lines(item: str) -> list[str]: + return [ln.lower() for ln in text.splitlines() if item in ln] + + return bool(lines("tickets.id:count")) and all("unrelated" in ln for ln in lines("tickets.id:count")) \ + and not any("unrelated" in ln for ln in lines("customers.name")) + + +class TestUnrelatedFlagSurfaces: + """``ItemPath.unrelated`` is serialised on every surface.""" + + async def test_mcp_json(self, storage) -> None: + mcp = create_mcp_server(storage=storage) + blocks, _ = await mcp.call_tool( + name="recommend_root_model", arguments={"items": UNRELATED_ITEMS, "format": "json"}, + ) + payload = json.loads(_text(blocks)) + assert payload["root_model"] == "customers" + assert _flags(payload) == UNRELATED_FLAGS + + async def test_mcp_markdown(self, storage) -> None: + mcp = create_mcp_server(storage=storage) + blocks, _ = await mcp.call_tool(name="recommend_root_model", arguments={"items": UNRELATED_ITEMS}) + assert _flagged_in_text(_text(blocks)) + + def test_rest(self, storage) -> None: + resp = TestClient(create_app(storage=storage)).post("/recommend-root-model", json={"items": UNRELATED_ITEMS}) + assert resp.status_code == 200 + assert _flags(resp.json()) == UNRELATED_FLAGS + + @pytest.mark.parametrize("fmt", ["json", "text"]) + def test_cli(self, storage, capsys, fmt: str) -> None: + args = argparse.Namespace( + storage=storage.base_dir, models_dir=None, items=UNRELATED_ITEMS, data_source=None, format=fmt, + ) + _run_recommend_root_model(args) + out = capsys.readouterr().out + if fmt == "json": + assert _flags(json.loads(out)) == UNRELATED_FLAGS + else: + assert _flagged_in_text(out) + + async def test_client_local(self, storage) -> None: + rec = await SlayerClient(storage=storage).recommend_root_model(UNRELATED_ITEMS) + assert {ip.input_item: ip.unrelated for ip in rec.item_paths} == UNRELATED_FLAGS + + async def test_client_remote_parses_the_flag(self) -> None: + client = SlayerClient(url="https://testserver") + + async def fake_request(method, path, json=None, params=None): # NOSONAR(S7503) — async required: stub is awaited via client._request + return { + "data_source": "mydb", "root_model": "customers", "reachable": True, + "item_paths": [ + {"input_item": "customers.name", "path": "name", "unrelated": False}, + {"input_item": "tickets.id:count", "path": "count(tickets.id)", "unrelated": True}, + ], + "coverage": [], "message": "", "warnings": [], + } + + client._request = fake_request # type: ignore[assignment] + rec = await client.recommend_root_model(UNRELATED_ITEMS) + assert {ip.input_item: ip.unrelated for ip in rec.item_paths} == UNRELATED_FLAGS + + class TestRootHintSurfaces: """``root_hint`` plumbed through every surface: a feasible bridge hint is honored; a bad hint surfaces per-surface (MCP failed-text / REST 400 / @@ -242,7 +324,7 @@ async def test_mcp_feasible_hint_honored(self, storage) -> None: name="recommend_root_model", arguments={"items": ["customers.name"], "root_hint": "orders", "format": "json"}, ) - payload = json.loads(blocks[0].text) + payload = json.loads(_text(blocks)) assert payload["root_model"] == "orders" async def test_mcp_bad_hint_friendly_error(self, storage) -> None: @@ -251,7 +333,7 @@ async def test_mcp_bad_hint_friendly_error(self, storage) -> None: name="recommend_root_model", arguments={"items": ["orders.status"], "data_source": "mydb", "root_hint": "nope"}, ) - assert "failed" in blocks[0].text.lower() + assert "failed" in _text(blocks).lower() # -- REST ----------------------------------------------------------- def test_rest_feasible_hint_honored(self, storage) -> None: diff --git a/tests/test_sql_generator.py b/tests/test_sql_generator.py index 09ba1a87..0d4c3b1d 100644 --- a/tests/test_sql_generator.py +++ b/tests/test_sql_generator.py @@ -606,7 +606,7 @@ async def test_arithmetic_field(self, generator: SQLGenerator, orders_model: Sla assert "aov" in sql.lower() assert "COUNT(*)" in sql assert "SUM(" in sql - assert "/ COUNT(*)" in sql + assert "/ NULLIF(COUNT(*), 0)" in sql async def test_no_fields_no_cte(self, generator: SQLGenerator, orders_model: SlayerModel) -> None: """Without fields, no CTE is generated.""" diff --git a/tests/test_unrelated_datasets.py b/tests/test_unrelated_datasets.py new file mode 100644 index 00000000..de4cf558 --- /dev/null +++ b/tests/test_unrelated_datasets.py @@ -0,0 +1,612 @@ +"""Datasets with no join path from the population: the product hop ``P × D``, read only through aggregates and one-sided filters.""" + +from __future__ import annotations + +from typing import Any + +import pydantic +import pytest + +from slayer.core.errors import ( + PartitionKeyError, + SlayerError, + TimeSpineError, + UnknownReferenceError, + UnreachableDefinitionError, + UnrelatedDatasetError, + UnresolvableDimensionJoinError, + UnsafeJoinInputError, +) +from slayer.core.models import Column, DatasourceConfig, ModelJoin, ModelMeasure, SlayerModel +from slayer.core.enums import DataType +from slayer.core.policy import ColumnFilterRuleset, SessionPolicy +from slayer.core.query import SlayerQuery +from slayer.engine.query_engine import SlayerQueryEngine +from slayer.storage.access_filtered import AccessFilteredStorage + +from tests._unrelated_datasets_fixtures import ( + BACKENDS, + GROUPED, + RATIO, + WIDE_CITIES, + WIDE_DATASETS, + customers_model, + events_model, + execute_capturing, + grouped_query, + m, + main_engine, + only_row, + orgs_model, + product_hop_violations, + query, + ratio_query, + rows, + stages, + unrelated_warnings, + users_model, + value, + warnings_of, + wide_engine, + wide_measures, +) + +JAN_MAR = ["2024-01-01", "2024-03-31"] + + +@pytest.fixture(params=BACKENDS) +async def engine(request): + async with main_engine(request.param) as eng: + yield eng + + +def _spine_query(**extra: Any) -> SlayerQuery: + return grouped_query(**{ + "measures": [m("count(events.id)", "n_events")], + "time_dimensions": [{"dimension": "time_spine.timestamp", "granularity": "month", "date_range": JAN_MAR}], + **extra, + }) + + +def _assert_row_level_refusal(exc: pytest.ExceptionInfo, *, reference: str, dataset: str = "events") -> None: + msg = str(exc.value) + assert dataset in msg + assert reference in msg + assert "customers" in msg + assert "aggregat" in msg.lower() + + +# --------------------------------------------------------------------------- +# Resolution: an unrelated dataset is reached by naming it +# --------------------------------------------------------------------------- + +class TestResolution: + async def test_grand_total_ratio(self, engine) -> None: + resp = await engine.execute(ratio_query()) + customers = await engine.execute(query(measures=[m("count(*)", "n")])) + events = await engine.execute(SlayerQuery.model_validate({"source_model": "events", "measures": [m("count(*)", "n")]})) + expected = only_row(events, "n")[0] / only_row(customers, "n")[0] + assert only_row(resp, "events_per_customer") == (pytest.approx(5 / 3),) + assert only_row(resp, "events_per_customer")[0] == pytest.approx(expected) + + async def test_path_continues_past_the_product_hop(self, engine) -> None: + resp = await engine.execute(query(measures=[m("count(events.users.id)", "n")])) + direct = await engine.execute(SlayerQuery.model_validate({ + "source_model": "events", "measures": [m("count(users.id)", "n")], + })) + assert only_row(resp, "n") == only_row(direct, "n") + + async def test_query_local_stage_is_an_unrelated_dataset(self, engine) -> None: + resp = await engine.execute(stages( + {"name": "c", "source_model": "customers", "measures": [m("count(*)", "nc")]}, + {"name": "e", "source_model": "events", "measures": [m("count(*)", "ne")]}, + {"source_model": "c", "dimensions": ["nc"], "measures": [m("max(e.ne)", "ne")]}, + )) + assert only_row(resp, "nc", "ne") == (3.0, 5.0) + + async def test_stage_spelling_takes_precedence_over_the_model(self, engine) -> None: + resp = await engine.execute(stages( + {"name": "events", "source_model": "users", "measures": [m("count(*)", "ne")]}, + {"source_model": "customers", "measures": [m("max(events.ne)", "ne")]}, + )) + assert only_row(resp, "ne") == (3.0,) + + async def test_stored_stage_of_a_query_backed_model(self, engine) -> None: + await engine.save_model(SlayerModel(name="per_city", data_source="test", source_queries=[query( + dimensions=["city"], measures=[m("count(*)", "n"), m("count(events.id)", "ne")], + )])) + resp = await engine.execute(SlayerQuery.model_validate({ + "source_model": "per_city", "dimensions": ["city"], "measures": [m("max(ne)", "ne_max")], + })) + assert rows(resp, "ne_max") == {"A": (5.0,), "B": (5.0,)} + + async def test_field_filter_is_the_only_reference(self, engine) -> None: + kept = await engine.execute(grouped_query(measures=[m("count(*)", "n")], filters=["events.amount > 25"])) + assert rows(kept, "n") == {"A": (2.0,), "B": (1.0,)} + emptied = await engine.execute(grouped_query(measures=[m("count(*)", "n")], filters=["events.amount > 1000"])) + assert emptied.data == [] + + async def test_measure_filter_is_the_only_reference(self, engine) -> None: + resp = await engine.execute(grouped_query(measures=[m("count(*)", "n")], filters=["count(events.id) > 4"])) + assert rows(resp, "n") == {"A": (2.0,), "B": (1.0,)} + + async def test_order_entry_is_the_only_reference(self, engine) -> None: + resp = await engine.execute(grouped_query( + measures=[m("count(*)", "n")], order=[{"column": "count(events.id)", "direction": "desc"}], + )) + assert rows(resp, "n") == {"A": (2.0,), "B": (1.0,)} + + async def test_partition_by_empty_measure_is_the_only_reference(self, engine) -> None: + resp = await engine.execute(grouped_query(measures=[m("count(events.id, partition_by=[])", "total")])) + assert rows(resp, "total") == {"A": (5.0,), "B": (5.0,)} + + +class TestExistingResolutionUnchanged: + async def test_join_path_reference(self, engine) -> None: + resp = await engine.execute(SlayerQuery.model_validate({ + "source_model": "users", "dimensions": ["name"], "measures": [m("count(events.id)", "n")], + })) + assert rows(resp, "n", by="name") == {"u1": (2.0,), "u2": (2.0,), "u3": (1.0,)} + assert unrelated_warnings(resp) == [] + + async def test_short_form_route(self, engine) -> None: + short = await engine.execute(SlayerQuery.model_validate({ + "source_model": "events", "dimensions": ["orgs.name"], "measures": [m("count(*)", "n")], + })) + full = await engine.execute(SlayerQuery.model_validate({ + "source_model": "events", "dimensions": ["users.orgs.name"], "measures": [m("count(*)", "n")], + })) + assert rows(short, "n", by="name") == rows(full, "n", by="name") == {"o1": (4.0,), "o2": (1.0,)} + assert unrelated_warnings(short) == [] + + async def test_population_spelled_by_its_own_name(self, engine) -> None: + resp = await engine.execute(query(measures=[m("count(customers.id)", "n")])) + assert only_row(resp, "n") == (3.0,) + assert unrelated_warnings(resp) == [] + + +class TestNamesThatAreNotReachableDatasets: + async def test_unknown_name(self, engine) -> None: + q = query(measures=[m("count(evnts.id)", "n")]) + with pytest.raises(UnresolvableDimensionJoinError) as exc: + await engine.execute(q) + assert "evnts.id" in str(exc.value) + assert "no route to target" in str(exc.value) + + async def test_time_spine_is_never_an_unrelated_dataset(self, engine) -> None: + q = query(measures=[m("count(time_spine.timestamp)", "n")]) + with pytest.raises(TimeSpineError) as exc: + await engine.execute(q) + assert "no countable rows" in str(exc.value) + + async def test_model_of_another_datasource(self, engine) -> None: + await engine.storage.save_datasource(DatasourceConfig(name="other", type="sqlite", database=":memory:")) + await engine.storage.save_model(SlayerModel( + name="widgets", sql_table="widgets", data_source="other", + columns=[Column(name="id", type=DataType.INT, primary_key=True)], + )) + q = query(measures=[m("count(widgets.id)", "n")]) + with pytest.raises(UnresolvableDimensionJoinError) as exc: + await engine.execute(q) + assert "no route to target" in str(exc.value) + + @pytest.mark.parametrize("backend", BACKENDS) + async def test_hidden_model_is_reported_as_unknown(self, backend) -> None: + hidden = events_model().model_copy(update={"access_tags": ["secret"]}) + async with main_engine(backend, models=[customers_model(), hidden, users_model(), orgs_model()]) as eng: + scoped = SlayerQueryEngine(storage=AccessFilteredStorage(eng.storage, tags=set(), bypass=False)) + hidden_q = query(measures=[m("count(events.id)", "n")]) + unknown_q = query(measures=[m("count(evnts.id)", "n")]) + try: + with pytest.raises(UnresolvableDimensionJoinError) as hidden_exc: + await scoped.execute(hidden_q) + with pytest.raises(UnresolvableDimensionJoinError) as unknown_exc: + await scoped.execute(unknown_q) + finally: + scoped.close() + assert str(hidden_exc.value) == str(unknown_exc.value).replace("evnts", "events") + + +@pytest.mark.parametrize("backend", BACKENDS) +async def test_row_level_security_scopes_the_unrelated_dataset(backend) -> None: + async with main_engine(backend) as eng: + scoped = SlayerQueryEngine( + storage=eng.storage, policy=SessionPolicy(ruleset=ColumnFilterRuleset(column="tenant", value="t1")), + ) + try: + resp = await scoped.execute(ratio_query()) + finally: + scoped.close() + assert only_row(resp, "events_per_customer") == (pytest.approx(3 / 2),) + + +class TestStoredDefinitionsRefuse: + async def test_saved_measure(self, engine) -> None: + await engine.save_model(customers_model(measures=[ModelMeasure(name="ev", formula="count(events.id)")])) + q = query(measures=["ev"]) + with pytest.raises(UnresolvableDimensionJoinError) as exc: + await engine.execute(q) + assert "no route to target" in str(exc.value) + + @pytest.mark.parametrize("definition", ["column", "filter"]) + async def test_column_sql_and_model_filter(self, engine, definition: str) -> None: + if definition == "column": + model = customers_model(columns=[Column(name="ev_amount", type=DataType.DOUBLE, sql="events.amount")]) + use, named = query(measures=[m("sum(ev_amount)", "x")]), "ev_amount" + else: + model = customers_model(filters=["events.amount > 1"]) + use, named = query(measures=[m("count(*)", "x")]), "events.amount > 1" + with pytest.raises(SlayerError) as saved: + await engine.save_model(model) + await engine.storage.save_model(model, _validate=False) + with pytest.raises(SlayerError) as used: + await engine.execute(use) + assert type(used.value) is type(saved.value) + for exc in (saved, used): + assert "events" in str(exc.value) + assert named in str(exc.value) + + @pytest.mark.parametrize("sql", ['"events".amount', '"events"."amount"']) + async def test_quoted_qualifier(self, engine, sql: str) -> None: + model = customers_model(columns=[Column(name="ev_amount", type=DataType.DOUBLE, sql=sql)]) + await engine.storage.save_model(model, _validate=False) + q = query(measures=[m("sum(ev_amount)", "x")]) + with pytest.raises(SlayerError, match="no join path reaches 'events'"): + await engine.execute(q) + + @pytest.mark.parametrize(("source", "formula"), [("per_city", "max(n)"), ("orgs", "max(per_city.n)")]) + async def test_stage_base_definition(self, engine, source: str, formula: str) -> None: + await engine.storage.save_model(SlayerModel( + name="logs", sql_table="orgs", data_source="test", + columns=[Column(name="id", type=DataType.INT, primary_key=True), Column(name="name", type=DataType.TEXT)], + )) + stale = customers_model(columns=[Column(name="lx", type=DataType.TEXT, sql="logs.name")]) + await engine.storage.save_model(stale, _validate=False) + await engine.storage.save_model(SlayerModel(name="per_city", data_source="test", source_queries=[ + query(dimensions=["city"], measures=[m("count(lx)", "n")]), + ]), _validate=False) + q = SlayerQuery.model_validate({"source_model": source, "measures": [m(formula, "x")]}) + with pytest.raises(UnreachableDefinitionError, match="no join path reaches 'logs' from 'customers'"): + await engine.execute(q) + + async def test_unspliceable_unrelated_query_backed_model(self, engine) -> None: + await engine.storage.save_model(SlayerModel(name="per_city", data_source="test", source_queries=[ + query(dimensions=["city"], measures=[m("count(nope)", "n")]), + ]), _validate=False) + q = SlayerQuery.model_validate({"source_model": "orgs", "measures": [m("max(per_city.n)", "x")]}) + with pytest.raises(UnknownReferenceError, match="'nope'"): + await engine.execute(q) + + async def test_edge_named_like_an_unspliceable_model(self, engine) -> None: + await engine.storage.save_model(SlayerModel(name="per_city", data_source="test", source_queries=[ + query(dimensions=["city"], measures=[m("count(nope)", "n")]), + ]), _validate=False) + edge = ModelJoin(target_model="orgs", join_pairs=[["id", "id"]], name="per_city") + await engine.storage.save_model(customers_model(joins=[edge]), _validate=False) + resp = await engine.execute(query(measures=[m("count(per_city.id)", "n")])) + assert only_row(resp, "n") == (2.0,) + assert unrelated_warnings(resp) == [] + + +# --------------------------------------------------------------------------- +# Aggregates across a product hop +# --------------------------------------------------------------------------- + +class TestAggregates: + async def test_grouped_query_broadcasts_the_total(self, engine) -> None: + resp = await engine.execute(grouped_query()) + assert rows(resp, "n_customers", "n_events") == {"A": (2.0, 5.0), "B": (1.0, 5.0)} + (w,) = warnings_of(resp, "broadcast") + assert "n_events" in w.measure + assert "city" in " ".join(d.dimension for d in w.dimensions) + + async def test_associate_mode_gives_the_same_total(self, engine) -> None: + resp = await engine.execute(grouped_query(to_many_handling="associate")) + assert rows(resp, "n_customers", "n_events") == {"A": (2.0, 5.0), "B": (1.0, 5.0)} + assert warnings_of(resp, "associated") + assert warnings_of(resp, "broadcast") == [] + + async def test_error_mode_refuses_a_population_dimension(self, engine) -> None: + q = grouped_query(to_many_handling="error") + with pytest.raises(SlayerError) as exc: + await engine.execute(q) + msg = str(exc.value) + assert "would broadcast" in msg + assert "n_events" in msg + assert "city" in msg + + async def test_error_mode_accepts_a_dimensionless_query(self, engine) -> None: + resp = await engine.execute(ratio_query(to_many_handling="error")) + assert only_row(resp, "events_per_customer") == (pytest.approx(5 / 3),) + + async def test_spine_attributes_through_the_unrelated_axis(self, engine) -> None: + resp = await engine.execute(_spine_query()) + got = {(value(r, "city"), str(value(r, "timestamp"))[:7]): value(r, "n_events") for r in resp.data} + per_month = {"2024-01": 2.0, "2024-02": 2.0, "2024-03": 1.0} + assert got == {(city, month): n for city in "AB" for month, n in per_month.items()} + + @pytest.mark.parametrize("mode", ["broadcast", "error"]) + async def test_partition_by_a_population_dimension(self, engine, mode: str) -> None: + q = grouped_query(measures=[m("count(events.id, partition_by=[city])", "n")], to_many_handling=mode) + with pytest.raises(PartitionKeyError): + await engine.execute(q) + + async def test_partition_by_a_population_dimension_under_associate(self, engine) -> None: + resp = await engine.execute(grouped_query( + measures=[m("count(events.id, partition_by=[city])", "n")], to_many_handling="associate", + )) + assert rows(resp, "n") == {"A": (5.0,), "B": (5.0,)} + + async def test_transform_over_the_unrelated_aggregate(self, engine) -> None: + resp = await engine.execute(_spine_query(measures=[m("cumsum(count(events.id))", "running")])) + got = {(value(r, "city"), str(value(r, "timestamp"))[:7]): value(r, "running") for r in resp.data} + per_month = {"2024-01": 2.0, "2024-02": 4.0, "2024-03": 5.0} + assert got == {(city, month): n for city in "AB" for month, n in per_month.items()} + + async def test_nested_aggregation_over_the_unrelated_aggregate(self, engine) -> None: + resp = await engine.execute(grouped_query(measures=[m("max(count(events.id), partition_by=[])", "top")])) + assert rows(resp, "top") == {"A": (5.0,), "B": (5.0,)} + + async def test_explicitly_grained_computed_dimension(self, engine) -> None: + resp = await engine.execute(grouped_query( + dimensions=["city", {"expression": "count(events.id, partition_by=[])", "name": "total_events"}], + measures=[m("count(*)", "n")], + )) + assert rows(resp, "n", "total_events") == {"A": (2.0, 5.0), "B": (1.0, 5.0)} + + async def test_composed_aggregates(self, engine) -> None: + resp = await engine.execute(grouped_query( + measures=[m("count(events.id) * 2", "twice"), m("count(*) / count(events.id)", "share")], + filters=["count(events.id) > 4"], + order=[{"column": "count(events.id)", "direction": "desc"}], + )) + got = rows(resp, "twice", "share") + assert got == {"A": (10.0, pytest.approx(0.4)), "B": (10.0, pytest.approx(0.2))} + + async def test_unrelated_derived_column_in_an_aggregation(self, engine) -> None: + resp = await engine.execute(query(measures=[m("sum(events.amount_x2)", "x")])) + assert only_row(resp, "x") == (300.0,) + + +# --------------------------------------------------------------------------- +# Other row-level reads fail closed +# --------------------------------------------------------------------------- + +class TestRowLevelRefusal: + async def test_unrelated_dimension(self, engine) -> None: + q = grouped_query(dimensions=["city", "events.kind"]) + with pytest.raises(UnrelatedDatasetError) as exc: + await engine.execute(q) + _assert_row_level_refusal(exc, reference="events.kind") + + async def test_unrelated_derived_dimension(self, engine) -> None: + q = grouped_query(dimensions=["city", "events.amount_x2"]) + with pytest.raises(UnrelatedDatasetError) as exc: + await engine.execute(q) + _assert_row_level_refusal(exc, reference="events.amount_x2") + + @pytest.mark.parametrize("fields, reference", [ + ({"time_dimensions": [{"dimension": "events.created_at", "granularity": "month"}]}, "events.created_at"), + ({"dimensions": ["city", {"expression": "events.amount * 2", "name": "a2"}]}, "events.amount"), + ({"order": [{"column": "events.amount", "direction": "asc"}]}, "events.amount"), + ({"dimensions": ["city", "events.kind"], "measures": [], "distinct_dimension_values": False}, "events.kind"), + ], ids=["time_dimension", "computed_dimension", "order_key", "raw_rows"]) + async def test_other_row_level_positions(self, engine, fields: dict[str, Any], reference: str) -> None: + q = query(**{"measures": [m("count(*)", "n")], **fields}) + with pytest.raises(UnrelatedDatasetError) as exc: + await engine.execute(q) + _assert_row_level_refusal(exc, reference=reference) + + async def test_one_row_stage_field_names_the_max_remedy(self, engine) -> None: + q = stages( + {"name": "e", "source_model": "events", "measures": [m("count(*)", "ne")]}, + {"source_model": "customers", "dimensions": ["city", "e.ne"], "measures": [m("count(*)", "n")]}, + ) + with pytest.raises(UnrelatedDatasetError) as exc: + await engine.execute(q) + assert "max(e.ne)" in str(exc.value) + + async def test_mixed_operands_inside_one_aggregation(self, engine) -> None: + q = query(measures=[m("sum(events.amount * customers.id)", "x")]) + with pytest.raises(UnsafeJoinInputError): + await engine.execute(q) + + def test_empty_join_pairs_name_the_aggregate_remedy(self) -> None: + with pytest.raises(pydantic.ValidationError) as exc: + SlayerQuery.model_validate({ + "source_model": {"source_name": "customers", "joins": [{"target_model": "events", "join_pairs": []}]}, + "measures": ["count(*)"], + }) + msg = str(exc.value) + assert "join_pairs" in msg + assert "aggregat" in msg.lower() + + +# --------------------------------------------------------------------------- +# Filters are one-sided associations +# --------------------------------------------------------------------------- + +class TestFilters: + async def test_filter_on_the_unrelated_dataset(self, engine) -> None: + resp = await engine.execute(grouped_query(filters=["events.amount > 25"])) + assert rows(resp, "n_customers", "n_events") == {"A": (2.0, 3.0), "B": (1.0, 3.0)} + + async def test_filter_on_the_population(self, engine) -> None: + resp = await engine.execute(grouped_query(filters=["city = 'A'"])) + assert rows(resp, "n_customers", "n_events") == {"A": (2.0, 5.0)} + + async def test_filter_no_population_row_passes(self, engine) -> None: + resp = await engine.execute(query(measures=[*GROUPED, RATIO], filters=["city = 'Z'"])) + assert only_row(resp, "n_customers", "n_events", "events_per_customer") == (0.0, 0.0, None) + + async def test_filters_on_both_sides(self, engine) -> None: + resp = await engine.execute(grouped_query(filters=["events.amount > 25", "city = 'A'"])) + assert rows(resp, "n_customers", "n_events") == {"A": (2.0, 3.0)} + + @pytest.mark.parametrize("conjunct", ["events.amount > customers.id", "city = 'A' or events.amount > 100"]) + async def test_mixed_conjuncts_are_refused(self, engine, conjunct: str) -> None: + q = query(measures=[m("count(events.id)", "n")], filters=[conjunct]) + with pytest.raises(UnrelatedDatasetError) as exc: + await engine.execute(q) + msg = str(exc.value) + assert "events.amount" in msg + assert "split" in msg.lower() + + async def test_filter_no_unrelated_row_passes(self, engine) -> None: + grouped = await engine.execute(grouped_query(filters=["events.amount > 1000"])) + assert grouped.data == [] + total = await engine.execute(query(measures=[*GROUPED, RATIO], filters=["events.amount > 1000"])) + assert only_row(total, "n_customers", "n_events", "events_per_customer") == (0.0, 0.0, None) + + @pytest.mark.parametrize("backend", BACKENDS) + async def test_empty_unrelated_dataset(self, backend) -> None: + async with main_engine(backend, event_rows=[]) as eng: + resp = await eng.execute(grouped_query()) + assert rows(resp, "n_customers", "n_events") == {"A": (2.0, 0.0), "B": (1.0, 0.0)} + + +# --------------------------------------------------------------------------- +# Warnings +# --------------------------------------------------------------------------- + +class TestWarnings: + async def test_dimensionless_query(self, engine) -> None: + resp, caught = await execute_capturing(engine, ratio_query()) + (w,) = unrelated_warnings(resp) + assert w.dataset == "events" + assert w.population == "customers" + assert any("events_per_customer" in name for name in w.measures) + assert warnings_of(resp, "broadcast") == [] + assert any("unrelated" in str(c.message).lower() and "events" in str(c.message) for c in caught) + + async def test_grouped_query(self, engine) -> None: + resp = await engine.execute(grouped_query()) + assert len(unrelated_warnings(resp)) == 1 + assert len(warnings_of(resp, "broadcast")) == 1 + + @pytest.mark.parametrize("build", [grouped_query, query]) + async def test_nested_producer(self, engine, build) -> None: + resp = await engine.execute(build(measures=[m("max(count(events.id), partition_by=[])", "top")])) + (w,) = unrelated_warnings(resp) + assert w.dataset == "events" + + async def test_one_entry_per_dataset_and_stage(self, engine) -> None: + resp, caught = await execute_capturing(engine, stages( + {"name": "s1", "source_model": "customers", + "measures": [m("count(events.id)", "n_events"), m("sum(events.amount)", "amount")]}, + {"source_model": "s1", "measures": [m("max(n_events)", "inner"), m("count(events.id)", "outer")]}, + )) + assert len([c for c in caught if "unrelated" in str(c.message).lower()]) == 2 + entries = unrelated_warnings(resp) + assert len(entries) == 2 + assert {w.dataset for w in entries} == {"events"} + assert len({w.location for w in entries}) == 2 + measure_sets = sorted(sorted(w.measures) for w in entries) + assert any(len(names) == 2 for names in measure_sets) + assert any(len(names) == 1 and "outer" in names[0] for names in measure_sets) + + +# --------------------------------------------------------------------------- +# No row explosion, no quadratic evaluation +# --------------------------------------------------------------------------- + +def _wide_row(n_customers: float) -> dict[str, Any]: + """Expected values of ``wide_measures()`` for a cell of ``n_customers`` customers, from the seed.""" + sizes = {"big": 1000, "small": 3, "empty": 0} + sums = {name: sum(float(i * i % 997 + 1) for i in range(1, n + 1)) for name, n in sizes.items()} + row: dict[str, Any] = {"n_customers": n_customers} + for name in WIDE_DATASETS: + row[f"{name}_sum"] = sums[name] if sizes[name] else None + row[f"{name}_n"] = float(sizes[name]) + row["big_plus_small"] = sums["big"] + sums["small"] + row["all_rows"] = 1003.0 + row["small_per_customer"] = pytest.approx(3 / n_customers) + return row + + +WIDE_PER_CITY = {c: float(sum(1 for i in range(1, 201) if WIDE_CITIES[i % 7] == c)) for c in WIDE_CITIES} + + +class TestNoExplosion: + @pytest.mark.parametrize("backend", BACKENDS) + @pytest.mark.parametrize("mode", ["broadcast", "associate"]) + async def test_three_unrelated_datasets_grouped(self, backend, mode: str) -> None: + measures = wide_measures() + names = [x["name"] for x in measures] + async with wide_engine(backend) as eng: + resp = await eng.execute(query(dimensions=["city"], measures=measures, to_many_handling=mode)) + alone = { + x["name"]: rows(await eng.execute(query(dimensions=["city"], measures=[x], to_many_handling=mode)), x["name"]) + for x in measures + } + assert len(resp.data) == len(WIDE_CITIES) + got = rows(resp, *names) + assert got == {city: tuple(_wide_row(n)[name] for name in names) for city, n in WIDE_PER_CITY.items()} + for i, name in enumerate(names): + assert {city: (vals[i],) for city, vals in got.items()} == alone[name], name + + @pytest.mark.parametrize("backend", BACKENDS) + @pytest.mark.parametrize("mode", ["broadcast", "associate", "error"]) + async def test_three_unrelated_datasets_dimensionless(self, backend, mode: str) -> None: + measures = wide_measures() + names = [x["name"] for x in measures] + async with wide_engine(backend) as eng: + resp = await eng.execute(query(measures=measures, to_many_handling=mode)) + alone = [only_row(await eng.execute(query(measures=[x], to_many_handling=mode)), x["name"])[0] + for x in measures] + got = only_row(resp, *names) + assert got == tuple(_wide_row(200.0)[name] for name in names) + assert list(got) == alone + + +class TestEmittedSql: + @pytest.mark.parametrize("backend", BACKENDS) + @pytest.mark.parametrize("mode", ["broadcast", "associate", "error"]) + async def test_three_dataset_query(self, backend, mode: str) -> None: + shapes = [query(measures=wide_measures(), to_many_handling=mode)] + if mode != "error": + shapes.append(query(dimensions=["city"], measures=wide_measures(), to_many_handling=mode)) + async with wide_engine(backend) as eng: + for q in shapes: + resp = await eng.execute(q, dry_run=True) + assert product_hop_violations( + resp.sql, dialect=backend, unrelated=WIDE_DATASETS, physical=["customers"], + ) == [] + + @pytest.mark.parametrize("backend", BACKENDS) + @pytest.mark.parametrize("q", [ + grouped_query(to_many_handling="associate"), + _spine_query(), + grouped_query(filters=["events.amount > 25", "city = 'A'"]), + ratio_query(filters=["city = 'Z'"]), + ], ids=["associate", "spine", "filters_on_both_sides", "population_filter"]) + async def test_main_seed_queries(self, backend, q: SlayerQuery) -> None: + async with main_engine(backend) as eng: + resp = await eng.execute(q, dry_run=True) + assert product_hop_violations(resp.sql, dialect=backend, unrelated=["events"], physical=["customers"]) == [] + + +class TestProductHopChecker: + """The emitted-SQL checker trips on every forbidden shape and passes the designed one.""" + + CHECK = {"dialect": "sqlite", "unrelated": ["events"], "physical": ["customers"]} + + def test_designed_emission_passes(self) -> None: + sql = ( + "SELECT c.city, p.n FROM customers c " + "CROSS JOIN (SELECT COUNT(*) AS n FROM events WHERE amount > 25 " + "AND EXISTS (SELECT 1 FROM customers WHERE city = 'A')) p " + "WHERE EXISTS (SELECT 1 FROM events e WHERE e.amount > 25)" + ) + assert product_hop_violations(sql, **self.CHECK) == [] + + @pytest.mark.parametrize("sql", [ + "SELECT c.city, COUNT(e.id) FROM customers c CROSS JOIN events e GROUP BY c.city", + "SELECT c.city, p.id FROM customers c CROSS JOIN (SELECT id FROM events) p", + "WITH r AS (SELECT id FROM events) SELECT c.city, COUNT(r.id) FROM customers c CROSS JOIN r GROUP BY c.city", + "SELECT c.city FROM customers c WHERE EXISTS (SELECT 1 FROM events e WHERE e.amount > c.id)", + "SELECT p.n FROM (SELECT COUNT(*) AS n FROM events e " + "WHERE EXISTS (SELECT 1 FROM customers c WHERE c.id = e.user_id)) p", + ], ids=["direct_product", "raw_derived_rows", "raw_cte_rows", "correlated_exists", "correlated_inside_producer"]) + def test_forbidden_shapes_trip(self, sql: str) -> None: + assert product_hop_violations(sql, **self.CHECK) != []