diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index aba3dc209..ce534778b 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -251,7 +251,9 @@ jobs: # `secrets.SNOWFLAKE_CONNECTIONS_TOML`. env: SLAYER_SNOWFLAKE_CONNECTION: slayer_test - run: poetry run pytest tests/integration/test_integration_snowflake.py -v -m integration --timeout=300 + # The secret is present (gate above), so an unreachable Snowflake fails rather than skips. + SLAYER_SNOWFLAKE_REQUIRED: "1" + run: poetry run pytest tests/integration/test_integration_snowflake.py -v -rs -m integration --timeout=300 - name: Wipe Snowflake credentials if: always() diff --git a/architecture/system.arc42.md b/architecture/system.arc42.md index eb83b460d..412658891 100644 --- a/architecture/system.arc42.md +++ b/architecture/system.arc42.md @@ -126,7 +126,7 @@ All code, old and new, MUST obey these. 10. **Two expression layers**: Mode A free SQL (`Column.sql`, model `filters`) vs Mode B, a SQL-compatible grammar (formulas, query fields) — one canonical function library, extended never forked. [review] Every Mode B - construct means the same on every dialect. [target: DEV-2120] + construct means the same on every dialect. [enforced: test:tests/test_dev2120_library_matrix.py] 11. **Versioned persistence**: models/queries/datasource configs carry `version`; migrations run automatically on load. [review] 12. **Pydantic v2 for all models; never dataclasses.** [review] diff --git a/docs/concepts/formulas.md b/docs/concepts/formulas.md index 523bee8c7..dfed1c9c9 100644 --- a/docs/concepts/formulas.md +++ b/docs/concepts/formulas.md @@ -496,6 +496,8 @@ Inside `Column.sql`, `ModelMeasure.formula`, or any `Aggregation.formula`, you c | `round(x[, ndigits])` | 1–2 | Round to `ndigits` decimal places (default 0). `ndigits` must be an integer literal. | | `abs(x)` | 1 | Absolute value. | +Query and measure formulas also take `div`, `pi`, `sin` … `atan2` and `cbrt` from the [portable function library](references.md#the-portable-function-library). + Unlike the other scalar functions above — which pass through only when embedded in a larger `Column.sql` or arithmetic expression — `round` and `abs` are also valid as the **top-level** form of a query measure or `ModelMeasure.formula`: ```python diff --git a/docs/concepts/models.md b/docs/concepts/models.md index cf12f0cc8..bb2244277 100644 --- a/docs/concepts/models.md +++ b/docs/concepts/models.md @@ -453,6 +453,8 @@ Or use the saved result as a model in another query: A consumed query-backed model is spliced into the consuming query as stages whose names stay private to it, and one that references itself, directly or through other query-backed models, is rejected. +Joins declared on a saved query-backed model, keyed on its output columns, stay usable wherever the model is consumed; the backing source model's joins are not inherited. + ### Variables in model SQL `{variable}` substitution is not limited to query-level filters — the same mechanism injects caller-supplied values into a model's **raw-SQL (Mode A) surfaces**. This is the primitive for parameterizing hand-written model SQL (for example, representing a Cube `FILTER_PARAMS` cube as an `sql`-mode model whose filter bounds arrive as variables). diff --git a/docs/concepts/queries.md b/docs/concepts/queries.md index f24c575f7..7602fe3cc 100644 --- a/docs/concepts/queries.md +++ b/docs/concepts/queries.md @@ -357,16 +357,13 @@ by. ### Scalar Functions in Filters -Filters in `SlayerQuery.filters` accept the closed Mode-B scalar -allowlist: string hygiene (`lower`, `upper`, `trim`, `ltrim`, -`rtrim`, `replace`, `substr`, `substring`, `instr`, `length`, `concat`), -null handling (`coalesce`, `nullif`, `ifnull`), math (`round`, `abs`, -`ceil`, `floor`, `sign`, `trunc`, `mod`, `log10`, …), scalar min/max -(`greatest`, `least`), and [date functions](references.md#date-and-time-functions) -(`date_part`, `date_diff`, `date_add`, `current_date`, `now`). The SQL `||` concat operator is -rewritten to `concat(...)` automatically. See -[references](references.md#scalar-functions-and-dialect-semantics) for the -full list and per-dialect semantics. +Filters in `SlayerQuery.filters` accept the +[portable function library](references.md#the-portable-function-library) — strings +(`lower`, `left`, `split_part`, `concat_ws`, …), math (`round`, `div`, `atan2`, …), null +handling, `greatest` / `least`, regex (`regexp_like`, `x ~ 'p'`), JSON (`json_value`, +`payload ->> 'key'`) and [date functions](references.md#date-and-time-functions) — each with +one meaning on every database. The SQL `||` concat operator is rewritten to `concat(...)` +automatically. ```json "filters": [ @@ -375,16 +372,15 @@ full list and per-dialect semantics. "replace(category, ',', '') = 'books'", "substr(s, 1, instr(s, ',') - 1) = 'first_token'", "coalesce(nickname, name) = 'Ada'", - "first || ' ' || last = 'jane doe'" + "first || ' ' || last = 'jane doe'", + "regexp_like(sku, '^[A-Z]{3}-[0-9]+$')", + "json_value(payload, '$.plan') = 'pro'" ] ``` -Names are matched case-insensitively — `LOWER(...)` and `lower(...)` both bind. -sqlglot translates each call to the target dialect's preferred spelling at SQL-generation -time (`instr` → `POSITION` / `LOCATE` / `STRPOS`, `substr` → -`SUBSTRING`, `concat` → `||` on SQLite). Raw SQL functions outside the -allowlist (`json_extract`, `date_trunc`, `CASE WHEN`, …) belong in -`Column.sql` / `Column.filter` / `SlayerModel.filters` (Mode A SQL). +Names are matched case-insensitively — `LOWER(...)` and `lower(...)` both bind — and raw SQL +functions outside the library (`initcap`, `to_date`, …) belong in `Column.sql` / +`Column.filter` / `SlayerModel.filters` (Mode A SQL). ### Filtering on Computed Columns diff --git a/docs/concepts/references.md b/docs/concepts/references.md index 321798f4b..98f2e76ab 100644 --- a/docs/concepts/references.md +++ b/docs/concepts/references.md @@ -7,7 +7,7 @@ SLayer has two distinct expression layers and the rules for what each one accept | Mode | Fields | Parser | Accepts | Rejects | |---|---|---|---|---| | **A — SQL** | `Column.sql`, `Column.filter`, each entry of `SlayerModel.filters` | sqlglot | Any valid SQL expression for the underlying dialect — function calls (`json_extract`, `coalesce`, `nullif`, `lower`, `length`, …), arithmetic, `CASE WHEN`, string literals, comparison and boolean operators in SQL spelling (`=`, `<>`, `IS NULL`, `AND`, `OR`, `NOT`, `IN`, `LIKE`). Bare names and dotted join paths (`customers.regions.name`). | Aggregations (`sum(revenue)`); SLayer transform calls (`cumsum`, `change`, `rank`, …); references to `ModelMeasure` formulas; raw `OVER (...)` window functions inside `Column.filter` / `SlayerModel.filters` (allowed only in `Column.sql`); the legacy `__`-delimited split-alias qualifier (`customers__regions.name`) — now a hard error (`LegacyDunderAliasError`). | -| **B — DSL** | `ModelMeasure.formula`, `SlayerQuery.measures`, `SlayerQuery.filters`, `SlayerQuery.dimensions`, `SlayerQuery.time_dimensions`, `SlayerQuery.order`, `SlayerQuery.main_time_dimension` | SQL-compatible grammar | Bare names that resolve to a `Column` or `ModelMeasure` on the model; single-dot dotted paths through joins (`customers.regions.name`, `sum(customers.revenue)`); aggregations (`sum(revenue)`, `count(*)`, `percentile(price, p=0.9)`, parametric forms), including same-model expression sources (`sum(amount - cost)`); transform calls (`cumsum(sum(revenue))`, `rank(sum(revenue), partition_by=region, direction='desc')`); arithmetic / boolean / comparison operators; the SQL `\|\|` concat operator (folded into `concat(...)`); SQL forms — `CASE`, `CAST` / `TRY_CAST` / `::`, `BETWEEN`, `IS [NOT] DISTINCT FROM`, `[NOT] LIKE` / `ILIKE`, `EXTRACT`, `POSITION`, `SUBSTRING … FROM … FOR`, `INTERVAL` / `DATE` / `TIMESTAMP` literals, `CURRENT_DATE`, `FILTER (WHERE …)`, plus the `like(value, pattern)` scalar; a closed allowlist of scalar functions (matched case-insensitively) — null handling (`nullif`, `coalesce`, `ifnull`), math (`ln`, `log10`, `log2`, `log`, `exp`, `sqrt`, `pow`, `power`, `abs`, `floor`, `ceil`, `ceiling`, `round`, `sign`, `trunc`, `mod`), scalar min/max (`greatest`, `least`), string hygiene (`lower`, `upper`, `trim`, `ltrim`, `rtrim`, `replace`, `substr`, `substring`, `instr`, `length`, `concat`), `like`, and [date functions](#date-and-time-functions) (`date_part`, `date_diff`, `date_add`, `current_date`, `now`), each with a declared argument count that is validated (`coalesce`, `concat`, `greatest` and `least` are variadic; `trunc` takes exactly one argument); `{variable}` placeholders supplying literal values. | identifiers using the reserved `__slayer_` prefix; raw SQL function calls outside that allowlist (`json_extract`, `date_trunc`, …), and any allowlisted call with the wrong number of arguments; raw `OVER (...)`; bare names that don't resolve to a Column / ModelMeasure / custom aggregation / query alias; `NULL` inside an `in` / `not in` list (use `is null` / `is not null` instead — see below); `\|` (use `\|\|`), `//`, `SIMILAR TO`, `REGEXP` / `RLIKE`, `TIME '…'` literals. | +| **B — DSL** | `ModelMeasure.formula`, `SlayerQuery.measures`, `SlayerQuery.filters`, `SlayerQuery.dimensions`, `SlayerQuery.time_dimensions`, `SlayerQuery.order`, `SlayerQuery.main_time_dimension` | SQL-compatible grammar | Bare names that resolve to a `Column` or `ModelMeasure` on the model; single-dot dotted paths through joins (`customers.regions.name`, `sum(customers.revenue)`); aggregations (`sum(revenue)`, `count(*)`, `percentile(price, p=0.9)`, parametric forms), including same-model expression sources (`sum(amount - cost)`); transform calls (`cumsum(sum(revenue))`, `rank(sum(revenue), partition_by=region, direction='desc')`); arithmetic / boolean / comparison operators; the SQL `\|\|` concat operator (folded into `concat(...)`); SQL forms — `CASE`, `CAST` / `TRY_CAST` / `::`, `BETWEEN`, `IS [NOT] DISTINCT FROM`, `[NOT] LIKE` / `ILIKE`, the regex operators `~` / `~*` / `!~` / `!~*`, the JSON arrows `->` / `->>`, `EXTRACT`, `POSITION`, `SUBSTRING … FROM … FOR`, `INTERVAL` / `DATE` / `TIMESTAMP` literals, `CURRENT_DATE`, `FILTER (WHERE …)`, plus the `like(value, pattern)` scalar; the [portable function library](#the-portable-function-library) (matched case-insensitively) — null handling (`nullif`, `coalesce`, `ifnull`), math (`ln`, `log10`, `log2`, `log`, `exp`, `sqrt`, `pow`, `power`, `abs`, `floor`, `ceil`, `ceiling`, `round`, `sign`, `trunc`, `mod`, `div`, `pi`, `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `cbrt`), scalar min/max (`greatest`, `least`), strings (`lower`, `upper`, `trim`, `ltrim`, `rtrim`, `replace`, `substr`, `substring`, `instr` / `strpos`, `length`, `concat`, `left`, `right`, `starts_with`, `ends_with`, `contains`, `lpad`, `rpad`, `reverse`, `repeat`, `split_part`, `concat_ws`, `chr`, `ascii`), regex (`regexp_like`, `regexp_extract`, `regexp_replace`), JSON (`json_value` and its aliases `json_extract`, `json_extract_scalar`, `json_extract_path_text`, `jsonb_extract_path_text`), `like`, and [date functions](#date-and-time-functions) (`date_part`, `date_diff`, `date_add`, `date_trunc`, `current_date`, `now`), each with a declared argument count that is validated (`coalesce`, `concat`, `concat_ws`, `greatest` and `least` are variadic; `trunc` takes exactly one argument); `{variable}` placeholders supplying literal values. | identifiers using the reserved `__slayer_` prefix; raw SQL function calls outside that library (`initcap`, `to_date`, `strftime`, JSON builders, …), and any library call with the wrong number of arguments; raw `OVER (...)`; bare names that don't resolve to a Column / ModelMeasure / custom aggregation / query alias; `NULL` inside an `in` / `not in` list (use `is null` / `is not null` instead — see below); `\|` (use `\|\|`), `//` (use `div(a, b)`), `SIMILAR TO`, `REGEXP` / `RLIKE` (use `~`), a bare `->` (end the chain with `->>`), `TIME '…'` literals. | ## Identifier resolution @@ -135,8 +135,8 @@ Rejected at `SlayerQuery` construction: Rejected at enrichment: ```json -{"source_model": "orders", "dimensions": ["id"], "filters": ["json_extract(data, '$.x') > 5"]} -// ↑ ReferenceError: raw SQL function calls in DSL mode +{"source_model": "orders", "dimensions": ["id"], "filters": ["initcap(name) = 'Ada'"]} +// ↑ UnknownFunctionError: raw SQL function calls outside the library in DSL mode {"source_model": "orders", "dimensions": ["id"], "filters": ["unknown_col > 0"]} // ↑ ReferenceError: 'unknown_col' is not a Column / ModelMeasure on 'orders' @@ -160,7 +160,7 @@ Accepted at construction: Rejected at enrichment (when the formula is evaluated against a model): ```json -{"name": "bad", "formula": "json_extract(data, '$.x')"} // raw SQL fn +{"name": "bad", "formula": "initcap(name)"} // raw SQL fn ``` A bare `aov` or dotted `customers.aov` reuses a saved measure by expanding its formula inline, but only inside a measure formula or computed-dimension expression — see [Reusing another model's saved measure](models.md#reusing-another-models-saved-measure-customersaov). @@ -186,17 +186,7 @@ Five consequences worth knowing: {"filters": ["concat(ifnull(first_name, ''), ifnull(last_name, '')) = 'AdaLovelace'"]} ``` -* **`greatest` / `least` NULL handling is backend-specific.** They pass through - to each backend's native form, and those forms disagree on `NULL`: Postgres, - DuckDB, SQL Server, ClickHouse 24.12+ and Snowflake (where the generated SQL - uses `GREATEST_IGNORE_NULLS`/`LEAST_IGNORE_NULLS`) *ignore* `NULL` arguments - (returning `NULL` only when every argument is `NULL`), while SQLite (scalar - `MAX`/`MIN`), MySQL, BigQuery and pre-24.12 ClickHouse (or 24.12+ with the - `least_greatest_legacy_null_behavior` setting) *propagate* `NULL` - (any `NULL` argument makes the result `NULL`). SLayer does not normalise this — wrap arguments in - `ifnull(...)` / `coalesce(...)` if you need one behaviour on every backend. - On SQL Server, `GREATEST` / `LEAST` require SQL Server 2022 or newer; earlier - versions reject the generated SQL. +* **`greatest` / `least` ignore `NULL` arguments on every backend** (NULL only when every argument is NULL); on SQL Server they need 2022 or later. * **`log10` / `log2` keep their single-argument form** on the backends that provide one, rather than becoming the generic two-argument `LOG(base, x)`. @@ -222,6 +212,31 @@ Five consequences worth knowing: written against either SQL convention binds, and both emit the target's own form. +## The portable function library + +Every library function, operator and pattern language means the same on SQLite, Postgres, DuckDB, MySQL, ClickHouse, SQL Server, Trino, Snowflake and BigQuery — Postgres's value where databases disagree — and is verified on each of them. + +* **Out-of-domain arguments yield `NULL`** (`asin(2)` over a column, `div(a, 0)`, a surrogate `chr`), and a literal one is a plan-time error. +* **Strings count characters, not bytes**; `left` / `right` with a negative count drop characters from the other end, `lpad` / `rpad` truncate, `split_part`'s index is a non-zero integer literal (negative from the end, `''` past it), `concat_ws` skips `NULL`s, `chr` / `ascii` speak Unicode code points; `div` truncates toward zero. +* **A version-gated function fails at plan time** when the server reports an older version: regex needs SQL Server 2025, `greatest` / `least` SQL Server 2022; JSON reads and `TRY_CAST` return `NULL` on malformed input only on Postgres 16+. +* **`date_trunc('month', x)` is the granularity call `month(x)`** in every position. + +### Regular expressions + +`regexp_like(x, p[, 'i'])` (also `x ~ p`, `~*`, `!~`, `!~*`), `regexp_extract(x, p[, group])` and `regexp_replace(x, p, replacement[, 'i'])` take a pattern literal or `{variable}` in one portable subset — literals, `.`, `[…]` / `[^…]`, `* + ? {m,n}`, `^ $`, `|`, `( )`, `\d \w \s` and their negations, `\n \t \r`, a backslash before a metacharacter — where `.` matches newlines, `^` / `$` are the whole string's ends, `\d \w \s` are ASCII, matching is case-sensitive without `'i'`, and a replacement's `\1`–`\9` insert a group and `\\` a backslash (`$` and `&` are literal); anything else (lookaround, backreferences, lazy quantifiers, `(?…)`, `\b`, `\p{…}`, POSIX classes) is a plan-time error naming the construct, and a repetition such as `'[0-9]{3}'` needs no brace escaping. + +### JSON + +`json_value(x, '$.a[0]."b c"' [RETURNING INT | DOUBLE | BOOLEAN | DATE | TIMESTAMP | TEXT])` reads one scalar from JSON text or a native JSON column (`NULL` when missing, JSON null, an object or an array; `NULL` when the value cannot convert), the arrows `x -> 'a' ->> 'b'` and `x ->> '$.a.b'` spell the same read as TEXT, and a path is `$` followed by `.key`, `."quoted key"` and `[n]` steps only. + +### Text beside a number + +A TEXT operand meeting a number in a comparison, `IN`, `BETWEEN`, `IS [NOT] DISTINCT FROM`, arithmetic or `greatest` / `least` reads as `TRY_CAST(text AS DOUBLE)` (a non-number is `NULL`; a TEXT literal converts at plan time or is an error), so `amount_txt > 100` compares numerically everywhere — integers beyond 2^53 lose precision, so compare those with `TRY_CAST(x AS BIGINT)`, and a number function or aggregation over TEXT (`sum(amount_txt)`) still needs an explicit `TRY_CAST`. + +### String matching + +`=`, `<`, `IN` and `LIKE` follow the column's collation (except SQLite's `LIKE`, which is case-sensitive), `ILIKE` and the regex `'i'` flag are the case-insensitive forms, and every `LIKE` / `ILIKE` pattern reads `%` / `_` as wildcards, `\` as escaping `%`, `_` and itself (literal before anything else) and every other character, `[` included, as itself. + ## Date and time functions Five portable functions cover extraction, differences, arithmetic and the clock. Each renders diff --git a/docs/database-support.md b/docs/database-support.md index d44d819c6..b73a2694b 100644 --- a/docs/database-support.md +++ b/docs/database-support.md @@ -283,6 +283,7 @@ plus `$GCP_PROJECT_ID` for billing). The `bigquery://` driver requires the `PERCENTILE_CONT(p) WITHIN GROUP (ORDER BY x)` to BigQuery's analytic form). Use a custom `Aggregation` with `APPROX_QUANTILES(x, 100)[OFFSET(N)]` when you need it. +- **SLayer timestamps are `DATETIME`.** `now()`, timestamp literals, `TRY_CAST(… AS TIMESTAMP)`, `json_value(… RETURNING TIMESTAMP)` and the date functions produce naive `DATETIME` values (UTC wall clock), and a zoned `TIMESTAMP` column, which ingestion marks with `db_type: TIMESTAMP` (re-ingest older models), reads as its UTC wall clock everywhere except as a direct comparison operand, where it stays bare (keeping partition pruning) and the other side is cast to `TIMESTAMP`. - **No native EXPLAIN.** BigQuery has no SQL-level `EXPLAIN`. The `BigqueryDialect.explain_prefix` is `None`, so `engine.execute(..., explain=True)` returns the dry-run SQL unchanged rather than an execution diff --git a/examples/comparisons/matrix.json b/examples/comparisons/matrix.json index 2844e7928..7a35eed0d 100644 --- a/examples/comparisons/matrix.json +++ b/examples/comparisons/matrix.json @@ -171,7 +171,7 @@ { "engine": "MetricFlow", "id": "Q1-mf-metric-filter-region", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3756" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3807" } ] }, @@ -636,22 +636,22 @@ { "engine": "MetricFlow", "id": "Q4-mf-offset-no-row", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3767" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3818" }, { "engine": "MetricFlow", "id": "Q4-mf-change", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3786" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3837" }, { "engine": "MetricFlow", "id": "Q4-mf-cum-day", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3806" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3857" }, { "engine": "MetricFlow", "id": "Q4-mf-ytd-first", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3823" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3874" } ] }, @@ -780,7 +780,7 @@ { "engine": "MetricFlow", "id": "Q5-mf-band-high", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3845" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3896" } ] }, @@ -963,7 +963,7 @@ { "engine": "MetricFlow", "id": "Q6-mf-two-hop-city", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3860" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3911" } ] }, @@ -1255,17 +1255,17 @@ { "engine": "MetricFlow", "id": "Q8-mf-root-orders", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3872" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3923" }, { "engine": "MetricFlow", "id": "Q8-mf-union-null", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3887" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3938" }, { "engine": "MetricFlow", "id": "Q8-mf-fill-nulls", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3905" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3956" } ] }, @@ -1475,7 +1475,7 @@ { "engine": "MetricFlow", "id": "Q9-mf-raw-where-alias", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3921" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3972" } ] }, @@ -1661,27 +1661,27 @@ { "engine": "MetricFlow", "id": "Q10-mf-any-order", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3942" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3993" }, { "engine": "MetricFlow", "id": "Q10-mf-gold-or-any-order", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3953" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4004" }, { "engine": "MetricFlow", "id": "Q10-mf-rowlevel-or", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3966" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4017" }, { "engine": "MetricFlow", "id": "Q10-mf-antijoin-eq0", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3977" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4028" }, { "engine": "MetricFlow", "id": "X2-mf-any", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3991" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4042" } ] }, @@ -1821,17 +1821,17 @@ { "engine": "MetricFlow", "id": "Q11-mf-90d-day", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4007" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4058" }, { "engine": "MetricFlow", "id": "Q11-mf-90d-cd-day", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4024" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4075" }, { "engine": "MetricFlow", "id": "Q11-mf-90d-last", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4041" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4092" } ] }, @@ -1991,7 +1991,7 @@ { "engine": "MetricFlow", "id": "Q13-mf-order-unselected-dim", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4064" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4115" } ] }, @@ -2248,12 +2248,12 @@ { "engine": "MetricFlow", "id": "Q16-mf-filter-expression", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4074" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4125" }, { "engine": "MetricFlow", "id": "Q16-mf-groupby-expression", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4085" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4136" } ] }, @@ -2464,7 +2464,7 @@ { "engine": "MetricFlow", "id": "Q18-mf-filter-day-grain", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4094" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4145" } ] }, @@ -2570,42 +2570,42 @@ { "engine": "MetricFlow", "id": "Q20-mf-sql-date-math", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4104" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4155" }, { "engine": "MetricFlow", "id": "Q20-mf-start-snaps", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4115" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4166" }, { "engine": "SLayer", "id": "Q20-slayer-last-n", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4219" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4270" }, { "engine": "SLayer", "id": "Q20-slayer-ago", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4231" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4282" }, { "engine": "SLayer", "id": "Q20-slayer-this-year", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4240" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4291" }, { "engine": "SLayer", "id": "Q20-slayer-quarter-literal", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4249" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4300" }, { "engine": "SLayer", "id": "Q20-slayer-period-upper", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4258" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4309" }, { "engine": "SLayer", "id": "Q20-slayer-open-ended", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4267" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4318" } ] }, @@ -2654,32 +2654,32 @@ { "engine": "MetricFlow", "id": "Q21-mf-dow", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4134" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4185" }, { "engine": "MetricFlow", "id": "Q21-mf-dow-dunder", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4146" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4197" }, { "engine": "SLayer", "id": "Q21-slayer-day-of-week", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4694" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4745" }, { "engine": "SLayer", "id": "Q21-slayer-date-diff", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4703" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4754" }, { "engine": "SLayer", "id": "Q21-slayer-date-add", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4712" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4763" }, { "engine": "SLayer", "id": "Q21-slayer-interval", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4723" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4774" } ] }, @@ -2750,47 +2750,47 @@ { "engine": "MetricFlow", "id": "Q23-mf-saved-where", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4155" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4206" }, { "engine": "MetricFlow", "id": "Q23-mf-saved-groupby", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4169" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4220" }, { "engine": "SLayer", "id": "Q23-slayer-refine-groupby", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4279" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4330" }, { "engine": "SLayer", "id": "Q23-slayer-refine-where", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4290" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4341" }, { "engine": "SLayer", "id": "Q23-slayer-refine-measure", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4299" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4350" }, { "engine": "SLayer", "id": "Q23-slayer-refine-top", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4308" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4359" }, { "engine": "SLayer", "id": "Q23-slayer-refine-final-stage", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4317" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4368" }, { "engine": "SLayer", "id": "Q23-slayer-refine-aggregated-away", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4326" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4377" }, { "engine": "SLayer", "id": "Q23-slayer-refine-conflict", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4334" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4385" } ] }, @@ -3354,8 +3354,9 @@ "origin": "Malloy", "cells": { "slayer": { - "verdict": "partial", - "text": "Functions SLayer translates per engine (date parts, differences, math, conditionals); others, e.g. regex, are written in the warehouse's own SQL." + "verdict": "yes", + "text": "One library (strings, math, regex, JSON, dates, TEXT-vs-number coercion) with one meaning on every engine, verified per engine.", + "caveat": "Postgres 16+ for NULL-on-error JSON reads and TRY_CAST; SQL Server 2025+ for regex." }, "malloy": { "verdict": "yes", @@ -3372,10 +3373,37 @@ } }, "leaders": [ + "slayer", "malloy" ], "comment": "Overlaps with Q21.", - "probes": [] + "probes": [ + { + "engine": "SLayer", + "id": "C9-slayer-regex", + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3719" + }, + { + "engine": "SLayer", + "id": "C9-slayer-strings", + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3729" + }, + { + "engine": "SLayer", + "id": "C9-slayer-json", + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3740" + }, + { + "engine": "SLayer", + "id": "C9-slayer-text-number", + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3751" + }, + { + "engine": "SLayer", + "id": "C9-slayer-greatest", + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3760" + } + ] }, { "id": "C10", @@ -3444,12 +3472,12 @@ { "engine": "SLayer", "id": "C11-facade-listing", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3719" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3770" }, { "engine": "SLayer", "id": "C11-facade-query", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3741" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L3792" } ] }, @@ -3550,32 +3578,32 @@ { "engine": "MetricFlow", "id": "C14-mf-fiscal-year", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4178" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4229" }, { "engine": "SLayer", "id": "C14-slayer-fiscal-year", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4543" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4594" }, { "engine": "SLayer", "id": "C14-slayer-fiscal-year-shift", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4554" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4605" }, { "engine": "SLayer", "id": "C14-slayer-fiscal-year-spine", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4566" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4617" }, { "engine": "SLayer", "id": "C14-slayer-quarter-hour", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4581" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4632" }, { "engine": "SLayer", "id": "C14-slayer-quarter-hour-spine", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4590" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4641" } ] }, @@ -3615,7 +3643,7 @@ { "engine": "MetricFlow", "id": "C15-mf-drill-across-tier", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4192" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4243" } ] }, @@ -3689,7 +3717,7 @@ { "engine": "MetricFlow", "id": "C17-mf-dimension-only", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4207" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4258" } ] }, @@ -3761,37 +3789,37 @@ { "engine": "SLayer", "id": "C19-axis-two-facts", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4482" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4533" }, { "engine": "SLayer", "id": "C19-axis-two-facts-region", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4499" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4550" }, { "engine": "SLayer", "id": "C19-axis-ambiguous-route", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4518" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4569" }, { "engine": "SLayer", "id": "C19-calendar-model-parity", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4527" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4578" }, { "engine": "MetricFlow", "id": "C19-mf-two-facts", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4604" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4655" }, { "engine": "Cube", "id": "C19-cube-two-facts", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4654" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4705" }, { "engine": "Malloy", "id": "C19-malloy-calendar", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4673" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4724" } ] }, @@ -3830,67 +3858,67 @@ { "engine": "SLayer", "id": "C20-spine-fill-month", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4343" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4394" }, { "engine": "SLayer", "id": "C20-spine-fill-coalesce", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4355" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4406" }, { "engine": "SLayer", "id": "C20-spine-no-lower-bound", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4367" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4418" }, { "engine": "SLayer", "id": "C20-spine-per-group", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4375" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4426" }, { "engine": "SLayer", "id": "C20-spine-fact-filter", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4391" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4442" }, { "engine": "SLayer", "id": "C20-spine-change", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4403" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4454" }, { "engine": "SLayer", "id": "C20-spine-cumsum", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4416" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4467" }, { "engine": "SLayer", "id": "C20-spine-consecutive", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4429" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4480" }, { "engine": "SLayer", "id": "C20-spine-window", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4443" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4494" }, { "engine": "SLayer", "id": "C20-spine-lag", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4456" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4507" }, { "engine": "SLayer", "id": "C20-spine-stage", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4469" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4520" }, { "engine": "MetricFlow", "id": "C20-mf-no-fill", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4619" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4670" }, { "engine": "MetricFlow", "id": "C20-mf-join-to-timespine", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4635" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4686" } ] }, @@ -4023,12 +4051,12 @@ { "engine": "SLayer", "id": "C24-mcp-connect-and-ask", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4734" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4785" }, { "engine": "SLayer", "id": "C24-mcp-help", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4746" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4797" } ] }, @@ -4066,17 +4094,17 @@ { "engine": "SLayer", "id": "C25-memory-recalled-by-draft-query", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4754" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4805" }, { "engine": "SLayer", "id": "C25-memory-in-inspect", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4765" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4816" }, { "engine": "SLayer", "id": "C25-example-query", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4775" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4826" } ] }, @@ -4117,12 +4145,12 @@ { "engine": "SLayer", "id": "C26-search-finds-column", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4787" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4838" }, { "engine": "SLayer", "id": "C26-search-memories-and-columns", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4795" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4846" } ] }, @@ -4160,12 +4188,12 @@ { "engine": "SLayer", "id": "C27-ingest-fk-joins", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4805" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4856" }, { "engine": "SLayer", "id": "C27-ingest-comments", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4820" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4871" } ] }, @@ -4205,12 +4233,12 @@ { "engine": "SLayer", "id": "C28-edit-column-then-query", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4831" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4882" }, { "engine": "SLayer", "id": "C28-saved-measure-then-query", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4842" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4893" } ] }, @@ -4250,17 +4278,17 @@ { "engine": "SLayer", "id": "C29-drift-query-error", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4857" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4908" }, { "engine": "SLayer", "id": "C29-validate-models", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4867" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4918" }, { "engine": "SLayer", "id": "C29-reingest-keeps-edits", - "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4876" + "url": "https://github.com/MotleyAI/slayer/blob/main/examples/comparisons/probes.yaml#L4927" } ] } diff --git a/examples/comparisons/matrix.yaml b/examples/comparisons/matrix.yaml index 8ef640994..bb4d46025 100644 --- a/examples/comparisons/matrix.yaml +++ b/examples/comparisons/matrix.yaml @@ -702,8 +702,9 @@ rows: intent: The same function means the same thing on every engine. origin: Malloy slayer: - verdict: partial - text: "Functions SLayer translates per engine (date parts, differences, math, conditionals); others, e.g. regex, are written in the warehouse's own SQL." + verdict: 'yes' + text: "One library (strings, math, regex, JSON, dates, TEXT-vs-number coercion) with one meaning on every engine, verified per engine." + caveat: "Postgres 16+ for NULL-on-error JSON reads and TRY_CAST; SQL Server 2025+ for regex." malloy: verdict: 'yes' text: Broad standard library plus a native escape. diff --git a/examples/comparisons/probes.yaml b/examples/comparisons/probes.yaml index 815403dee..a55634761 100644 --- a/examples/comparisons/probes.yaml +++ b/examples/comparisons/probes.yaml @@ -3715,6 +3715,57 @@ probes: query: {source_model: monthly_rev, measures: [{formula: "sum(rev)", name: v}]} options: {policy: north} + # ------------------------------------------------------------------ C9 portable expression library (SLayer) + - id: C9-slayer-regex + row: C9 + title: regex filter and group extraction, one meaning on every engine + truth_sql: | + select name, regexp_extract(name, '^([A-Z])[a-z]+$', 1) from customers where regexp_matches(name, '^[A-E]') + compare: {keys: [name], values: [initial]} + slayer: + query: {source_model: customers, distinct_dimension_values: false, filters: ["name ~ '^[A-E]'"], + dimensions: [name, {expression: "regexp_extract(name, '^([A-Z])[a-z]+$', 1)", name: initial}]} + + - id: C9-slayer-strings + row: C9 + title: Postgres string semantics (negative left, truncating lpad, negative split_part) + truth_sql: | + select name, lpad(left(name, -1), 4, '.'), split_part(city, 'o', -1) from customers + compare: {keys: [name], values: [short, tail]} + slayer: + query: {source_model: customers, distinct_dimension_values: false, + dimensions: [name, {expression: "lpad(left(name, -1), 4, '.')", name: short}, + {expression: "split_part(city, 'o', -1)", name: tail}]} + + - id: C9-slayer-json + row: C9 + title: json_value and the ->> arrow read a scalar out of JSON text + truth_sql: select name, city, length(city) from customers + compare: {keys: [name], values: [city_json, city_len]} + slayer: + query: {source_model: customers, distinct_dimension_values: false, + dimensions: [name, {expression: "'{\"c\": \"' || city || '\"}' ->> 'c'", name: city_json}, + {expression: "json_value('{\"n\": ' || length(city) || '}', '$.n' RETURNING INT)", + name: city_len}]} + + - id: C9-slayer-text-number + row: C9 + title: text compared with a number compares numerically (TRY_CAST) + truth_sql: select id from customers where id * 10 > 50 + compare: {keys: [id], values: []} + slayer: + query: {source_model: customers, distinct_dimension_values: false, dimensions: [id], + filters: ["id || '0' > 50"]} + + - id: C9-slayer-greatest + row: C9 + title: greatest ignores NULL arguments + truth_sql: select name, greatest(nullif(discount, 0) * 100, 250) from customers + compare: {keys: [name], values: [g]} + slayer: + query: {source_model: customers, distinct_dimension_values: false, + dimensions: [name, {expression: "greatest(nullif(discount, 0) * 100, 250)", name: g}]} + # ------------------------------------------------------------------ C11 curated semantic surfaces (SLayer) - id: C11-facade-listing row: C11 diff --git a/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/.openspec.yaml b/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/.openspec.yaml new file mode 100644 index 000000000..dc36fb1bf --- /dev/null +++ b/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/.openspec.yaml @@ -0,0 +1,2 @@ +schema: spec-driven +created: 2026-10-21 diff --git a/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/design.md b/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/design.md new file mode 100644 index 000000000..45cf62bbc --- /dev/null +++ b/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/design.md @@ -0,0 +1,19 @@ +## Context + +The public save path validates and persists joins after populating a query-backed model's output columns. Execution strips those joins from its placeholder, then creates a flat synthetic model from the final StageSchema. Product-hop support can turn the missing edge into a successful uncorrelated filter rather than a refusal. + +## Decisions + +1. Repair the saved-relation boundary. Preserve only the query-backed model's own declared joins; never inherit its backing source's join graph. +2. Reuse `model_from_stage_schema` to carry optional declared joins for saved final relation names in source, extension and sibling/target paths. Keep StageSchema unchanged. Validate joins against the saved relation's real identity so a legal target named `_stage` is not mistaken for a self-join. +3. Select ModelScope for a materialized saved relation by its identity in the query-backed model map, including relations with incoming reverse edges and no outgoing joins. Ordinary/private query stages retain flat StageSchema binding. +4. Keep demand-based splicing. Merely declaring or reaching an unread query-backed model must not plan it or manufacture a cycle. +5. Reuse the existing logical join-key and extension semantics. Test distinct/named extension joins. An extension join equal to one of its base model's stored joins in all but metadata and pair order is that stored edge, applied once, for every model kind; the runtime overlay and the schema-drift stage graph share this one rule. A join differing in target, name, join type, cardinality or pairs stays a separate edge. + +## Validation + +Record failing segmented-total tests before the implementation. Execute the repaired paths on SQLite and DuckDB using renamed physical/logical keys. Check root and target consumption, aggregate attribution, extension parity, private-stage scopes and cycles. Run the required unit, lint, type and architecture gates and the documented CI integration selection, then inspect current-head CI and review results. + +## Risks + +An incomplete root-only fix leaves target/sibling reads broken. Passing saved relationships to ordinary stages breaks stage isolation. Eager traversal of retained edges can introduce false cycles. Preserve those distinctions and use existing fixtures and regression suites. diff --git a/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/proposal.md b/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/proposal.md new file mode 100644 index 000000000..1fb6cec52 --- /dev/null +++ b/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/proposal.md @@ -0,0 +1,22 @@ +## Why + +A saved query-backed model's declared joins disappear when its final stage becomes a consuming relation. A customer-segment filter consequently returns all-customer revenue (150 instead of 120), because the missing relationship is treated as a product hop. The older outbound traversal gap is tracked as DEV-1918; this change fixes its wrong-result consequence reported in GitHub issue #507. + +## What Changes + +- Retain the saved relation's own joins through query-backed placeholder and relation materialization. +- Bind saved relations as model scopes, keeping ordinary query-stage outputs flat. +- Add executable SQLite/DuckDB tests for filtered totals, traversal and aggregate attribution. +- Preserve existing demand splicing, private stage scopes, cycle errors and extension behavior. +- Treat an extension join repeating a stored join of its base as that edge, for every model kind. + +## Capabilities + +### Modified Capabilities + +- `queries/query-backed-inline`: consuming a saved relation retains its own declared relationships. +- `models/join-traversal`: an extension join repeating a stored edge is that edge. + +## Impact + +A focused engine/IR fix with regression tests and a clarification in the models guide. No new dependency, persisted schema, public request field or normative architecture change. diff --git a/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/specs/models/join-traversal/spec.md b/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/specs/models/join-traversal/spec.md new file mode 100644 index 000000000..4bf830856 --- /dev/null +++ b/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/specs/models/join-traversal/spec.md @@ -0,0 +1,13 @@ +## ADDED Requirements + +### Requirement: An extension join repeating a stored edge is that edge + +A query-level model extension's join that equals one of its base model's stored joins in every field except `description`, `meta` and pair order SHALL be that stored edge, applied once, for every model kind; an extension join differing in target, name, join type, cardinality or join pairs SHALL remain a separate edge. + +#### Scenario: Repeating a stored join in an extension +- **WHEN** an extension over a table-backed model repeats a stored join and a query reads through it +- **THEN** the query resolves over that single edge instead of failing as an ambiguous hop + +#### Scenario: A differing extension join stays parallel +- **WHEN** an extension adds an unnamed join to the same target with different join pairs +- **THEN** a bare hop to that target fails closed as ambiguous diff --git a/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/specs/queries/query-backed-inline/spec.md b/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/specs/queries/query-backed-inline/spec.md new file mode 100644 index 000000000..2096afe94 --- /dev/null +++ b/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/specs/queries/query-backed-inline/spec.md @@ -0,0 +1,33 @@ +## ADDED Requirements + +### Requirement: Saved relation relationships survive splicing + +A stored query-backed model consumed as a relation SHALL retain that model's own declared joins, with keys resolved against its final-stage output columns. Those relationships SHALL remain available when the relation is a source, a join target or an extended source. Ordinary query-stage outputs SHALL remain flat and SHALL NOT inherit joins from their backing source. + +#### Scenario: Joined segment filter on a saved relation +- **WHEN** a saved customer-total relation declares a customer-key join and a query filters to gold customers +- **THEN** only the related gold customers contribute, with the same values as an equivalent relationship declared solely on a query extension, on SQLite and DuckDB + +#### Scenario: Joined dimensions and aggregate attribution +- **WHEN** a query reads a dimension or aggregate through a saved relation's declared join +- **THEN** the relationship determines the rows and attribution instead of being treated as an unrelated dataset + +#### Scenario: A saved relation consumed through another model +- **WHEN** another model joins a saved query-backed relation and a query traverses onward through that relation's own join +- **THEN** the declared relationships remain available with logical key spelling and correct values + +#### Scenario: Extending a saved relation +- **WHEN** a query extension adds a distinct named join to a saved relation +- **THEN** both its stored joins and the extension's joins remain available + +#### Scenario: Repeating an existing saved relationship +- **WHEN** an extension over a saved query-backed relation repeats an exactly identical declared join +- **THEN** that edge is applied once, without introducing an ambiguous parallel path + +#### Scenario: Legal join targets do not collide with temporary identities +- **WHEN** a saved relation declares a join to a legal model named `_stage` +- **THEN** both unjoined and joined consumers execute without a false self-join error + +#### Scenario: Ordinary stage isolation +- **WHEN** an ordinary query stage is consumed by a later stage +- **THEN** only its projected output schema is visible and its backing source's joins are not inherited diff --git a/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/tasks.md b/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/tasks.md new file mode 100644 index 000000000..38b37d05c --- /dev/null +++ b/openspec/changes/archive/2026-10-22-fix-query-backed-declared-joins/tasks.md @@ -0,0 +1,20 @@ +## 1. Plan and reproduce + +- [x] 1.1 Refresh current upstream and public issue/PR history; report the wrong-result behavior in #507, distinguishing the known DEV-1918 traversal gap. +- [x] 1.2 Review the relation-boundary design independently, preserving flat ordinary stages and demand splicing without a normative architecture edit. +- [x] 1.3 Record failing SQLite/DuckDB segmented-total regressions before production changes. + +## 2. Implement and document + +- [x] 2.1 Preserve declared joins through saved-relation placeholder, root/extension and sibling/target materialization. +- [x] 2.2 Verify logical-key traversal, aggregate attribution, extension compatibility, ordinary-stage isolation and cycle behavior. +- [x] 2.3 Clarify saved-relation joins in the user models guide. +- [x] 2.4 Treat an extension join repeating a stored join as that edge for every model kind, in the runtime overlay and the schema-drift stage graph. + +## 3. Validate and review + +- [x] 3.1 Pass the focused regressions and related query-backed scope/cycle tests. +- [x] 3.2 Run the full documented unit selection, retest environment/timing failures, and pass lint, type and architecture gates. +- [x] 3.3 Independently review the implementation and verify the final tree. + +Validation note: the local Python 3.14 unit run reported 31,377 passed, 99 skipped, 7 xfailed and three failures. All three passed isolated retries; the Poetry PATH was corrected for the affected subprocess test, and the timing-sensitive failure also reproduced on unchanged upstream. The documented integration selection passed with 656 passed, 36 skipped and 1 xfailed. CI validates the full suites on Python 3.11 and 3.14. diff --git a/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/.openspec.yaml b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/.openspec.yaml new file mode 100644 index 000000000..7cc41bb51 --- /dev/null +++ b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/.openspec.yaml @@ -0,0 +1,2 @@ +schema: spec-driven +created: 2026-10-22 diff --git a/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/design.md b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/design.md new file mode 100644 index 000000000..2a93f2941 --- /dev/null +++ b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/design.md @@ -0,0 +1,87 @@ +## Context + +See proposal.md for motivation. After DEV-2101 (merged into this branch): Mode B is parsed by `slayer/core/syntax.py`; casts are `CastKey(source, type_text, data_type, try_)` rendered through `SqlDialect.build_try_cast` (input read as text first); the engine fetches a cached `ServerProfile` only when the dialect sets `try_cast_reads_profile` and `plans_try_cast(planned)` finds a `TRY_CAST` key. Scalars are `ScalarCallKey`s over the `SCALAR_SPECS` allowlist in `slayer/core/keys.py`, rendered by `render_scalar_call` as `exp.func(name)` plus sqlglot transpilation (`rewrite_target_ast`); date functions already use typed dialect hooks (`build_date_part`, …). SQLite functions are registered in `register_sqlite_udfs`. Ingestion keeps `Column.db_type` only where `DataType` is lossy (opaque types, exact NUMERIC). Booleans in a numeric context are read as 1 / 0 at render (`numeric_parts`). + +## Goals / Non-Goals + +**Goals:** one portable meaning per function, operator and pattern language, held by construction (explicit lowerings, re-emitted patterns) and enforced by a registry-driven test matrix. + +**Non-Goals:** a DECIMAL or JSON member of `DataType`; capturing column collations; Postgres versions before 16 getting NULL-on-error semantics; JSON builders / table functions; `initcap`. + +## Decisions + +### D1. Every function has an explicit portable lowering + +The symptom (`greatest` / `least` NULLs, `LIKE` case and metacharacters, regex flavours) is one structural cause: semantics delegated to sqlglot's per-dialect translation, so "same meaning everywhere" was never a property of the code. Each library function now has an explicit lowering: `ScalarSpec` gains the function's result-type rule; `render_scalar_call` dispatches each new function to a typed `SqlDialect` hook per function family (sql P1: operands are rendered `Expression`s and typed values, never a function-name `str`), with the base class holding the default form and each Tier-1 dialect file overriding only its quirks (sql P2). Existing passthrough scalars keep their path. The matrix test (`tests/test_dev2120_library_matrix.py`) iterates `SCALAR_SPECS` and the Mode-B operators, fails for any entry without cases, executes the cases on SQLite and DuckDB, and emits them for every Tier-1 dialect; the integration suites execute the same case table live. This flips system P10's "every Mode B construct means the same on every dialect" from `[target: DEV-2120]` to `[enforced: test:tests/test_dev2120_library_matrix.py]` (approved). + +Alternative: keep sqlglot passthrough and fix instances — rejected: every new function would re-open the bug class. + +### D2. Patterns and paths are parsed in core, emitted per dialect + +Three pure-syntax parsers in `slayer/core/` (no SLayer imports beyond core): regex patterns, LIKE patterns and JSON paths, each producing a small frozen Pydantic AST, `lru_cache`d. The binder validates every literal and variable-supplied pattern / path at plan time (typed errors naming the construct and, for variables, the variable). Keys keep the literal text (identity unchanged, core P1); the renderer re-parses through the cache and the dialect emits from the AST: + +- **Regex** — one emitter in `slayer/sql/dialects/` parameterised by a per-dialect flavour record: Postgres ARE, Snowflake POSIX, RE2 (DuckDB, ClickHouse, BigQuery, SQL Server 2025), Java / Joni (Trino), ICU (MySQL), Python `re` (SQLite). The record says how to spell dot-matches-newline (`(?s)`, match parameter `'n'` / `'s'`, or native), the string-end anchors (`$`, `\z`, `\Z`, `\A`), case-insensitivity, and the replacement-reference syntax. `\d \w \s` always emit as explicit ASCII classes (inside brackets as ranges); `\n \t \r` as the engine's escape or a literal character. Replacement strings are re-emitted the same way (`\1` → `$1` on MySQL / Trino, literal `$` / `&` / `\` escaped per engine). +- **LIKE** — a literal pattern is re-emitted; a column-valued pattern is translated at run time (SQL Server `REPLACE(p, '[', '[[]')`, SQLite inside `slayer_like_glob`). +- **JSON paths** — emitted as the dialect's path or key-list form. + +Alternative: pass pattern text through with `(?s)` prefixes — rejected: `\d` inside brackets, `$` before a trailing newline and Unicode classes differ under identical text. + +### D3. Spellings collapse in the parser (engine P2) + +`~` / `~*` / `!~` / `!~*` parse to `regexp_like` (negated by `NOT`); `->` / `->>` chains to `json_value(x, path)` (the path assembled from the operands; a chain ending in `->` is a parse error with the `->>` hint); `json_extract` / `json_extract_scalar` / `json_extract_path_text` / `jsonb_extract_path_text` to `json_value`; `date_trunc(unit, x)` to the granularity call `(x)`; `strpos` to `instr`. The arrows sit at the `||` level of the precedence ladder, left-associative, so every Postgres-accepted expression parses with Postgres's meaning. `json_value(x, p RETURNING t)` parses to `TRY_CAST(json_value(x, p) AS t)` — a `CastKey` over the TEXT `json_value` (system P13: no new key kind; its meaning is exactly `TRY_CAST` of the text). Dialects may lower that pair natively where equivalent (ClickHouse `JSONExtract(x, …, 'Nullable(T)')` guarded by `JSONType`, SQLite `json_extract` + `json_type` so booleans and numbers never go through text, Snowflake `GET_PATH` then `build_try_cast`). + +### D4. Coercion is a TRY_CAST key inserted by the checker + +Where the checker types a comparison / `IN` / `BETWEEN` / `IS DISTINCT FROM` / arithmetic / `greatest` / `least` operand as TEXT against INT / DOUBLE, it wraps the TEXT operand in `CastKey(type_text="DOUBLE", data_type=DOUBLE, try_=True)`; a TEXT literal is converted to a number literal at plan time or raises a `QueryTypeError` (engine P9). Because the coercion is an ordinary `TRY_CAST` key, `plans_try_cast` sees it (the Postgres profile is fetched), the existing cast renderer emits it, and arithmetic types DOUBLE through the cast's type. An author's `CastKey` is never touched. + +Alternative: wrap at render like `numeric_parts` — rejected: invisible to the profile predicate and to the checker's typing. + +### D5. Version gating through the server profile + +`try_cast_reads_profile` and `plans_try_cast` generalise to one dialect predicate over the planned keys, "does rendering this plan read the profile". Postgres answers for `TRY_CAST` keys; SQL Server for regex and `greatest` / `least`. SQL Server gains `server_profile_sql` (`SERVERPROPERTY('ProductMajorVersion')`) and `parse_server_profile`. The version check raises a typed plan-time error naming the function and the version; an unknown profile emits. `regexp_like` on SQL Server lowers to `REGEXP_INSTR(…) > 0`, which runs at every compatibility level (`REGEXP_LIKE` needs level 170), so the profile carries no compatibility level. + +### D6. Out-of-domain → NULL + +Dialects guard the domain where the database raises or returns a non-NULL substitute: `asin` / `acos` by `CASE WHEN x BETWEEN -1 AND 1`, `div` by `NULLIF(b, 0)`, `chr` by the code-point range minus surrogates, `split_part` index by the plan-time literal check. A literal argument is checked in the binder and raises. + +### D7. greatest / least + +On NULL-propagating engines (SQLite scalar `MAX` / `MIN`, MySQL, BigQuery, ClickHouse before 24.12 or with the legacy setting) the form is `GREATEST(COALESCE(a, b, c), COALESCE(b, a, c), COALESCE(c, a, b))`: every term is non-NULL unless all arguments are, and each non-NULL argument appears as its own term. Snowflake keeps `GREATEST_IGNORE_NULLS`. SQL Server before 2022 is the D5 version error. Coercion (D4) applies to mixed TEXT / number arguments. + +### D8. SQLite + +Registered deterministic functions on the existing connect hook: `slayer_regexp_like`, `slayer_regexp_extract`, `slayer_regexp_replace` (Python `re`, the pattern already re-emitted for the Python flavour), `slayer_like_glob` (LIKE pattern → GLOB pattern: `%`→`*`, `_`→`?`, `*`, `?`, `[` bracketed, backslash escapes resolved), plus any string function SQLite lacks (`concat_ws` on old SQLite builds, code-point `chr` / `ascii` where the built-ins differ). Mode-B `LIKE` renders `x GLOB slayer_like_glob(p)` (deterministic, so a constant pattern is evaluated once per statement); `ILIKE` renders native `LIKE`. Mode-A `LIKE` is untouched because nothing connection-wide changes. + +### D9. LIKE on the other dialects + +A typed `build_like(value, pattern, case_insensitive)` hook. Base: `LIKE … ESCAPE '\'` (Postgres, MySQL, DuckDB, Snowflake, Trino); `ILIKE` native where it exists, else `LOWER(x) LIKE LOWER(p)`. ClickHouse and BigQuery: native backslash escaping, no `ESCAPE` clause. SQL Server: `ESCAPE '\'` and `[` bracketed (literal patterns re-emitted, column patterns through `REPLACE`). + +### D10. JSON inputs and ingestion + +Ingestion keeps `db_type` for JSON-family types (Postgres `json` / `jsonb`, MySQL / DuckDB / BigQuery `JSON`, Snowflake `VARIANT` / `OBJECT` / `ARRAY`, ClickHouse `JSON`); `json_value` accepts an opaque (UNKNOWN) column whose `db_type` is JSON-family. Lowering reads the operand's `db_type`: Postgres `CAST(x AS JSONB)` for every input (a no-op on `jsonb`) with `jsonb_typeof` excluding objects / arrays / null and, on 16+, `pg_input_is_valid(x, 'jsonb')` guarding malformed text; Snowflake `VARIANT` direct, else `TRY_PARSE_JSON(TO_VARCHAR(x))`; ClickHouse `JSON` column vs `String`; others take TEXT and native JSON alike. A missing `db_type` reads as TEXT. + +### D11. Verification + +Unit: matrix on SQLite and DuckDB plus emission on every dialect. Integration (live, same case table): Postgres (local pytest-postgresql, 16+; emission for 15 and unknown), MySQL 8.0, ClickHouse, Trino via testcontainers; SQL Server parameterised over 2022 (version error) and 2025 (regex); Snowflake and BigQuery in their secret-gated CI suites. C9 flips only after a PR run in which the Snowflake and BigQuery suites executed (not skipped). + +### D12. Digit-and-comma braces in string literals + +A brace pair inside a Mode-B string literal whose contents are only digits, commas and spaces (`{3}`, `{2,}`, `{1,2}`, `{1, 2, 3}`, `{}`) is literal text, so regex quantifiers work as written; it is an invalid-variable-name error today, so nothing that runs changes meaning. Name-shaped pairs stay placeholders, other pairs keep the invalid-name error, `{{` / `}}` keep escaping, and bare braces outside a string literal are unchanged. An undefined-variable error from a regex pattern argument adds the `{{` / `}}` hint. + +Alternatives: doubling quantifier braces (`'[0-9]{{3}}'`) — rejected: standard regex fails as written; every non-name pair literal — rejected: a mistyped placeholder (`'{start-date}'`) would silently become text; exempting pattern positions from substitution — rejected: substitution precedes parsing and would forbid placeholders in patterns. + +### D13. BigQuery TIMESTAMP is DATETIME + +SLayer's TIMESTAMP is naive, so on BigQuery every SLayer-produced timestamp is `DATETIME`: `CURRENT_DATETIME()`, `DATETIME_ADD` / `DATETIME_DIFF` / `DATETIME_TRUNC`, and `SAFE_CAST(… AS DATETIME)` for `TRY_CAST` / `RETURNING` (a plain `CAST` stays the database's own). Ingestion keeps `db_type` for the dialect's zoned type (`SqlDialect.zoned_timestamp_db_types`, BigQuery `TIMESTAMP`), and the binder casts the other side of a comparison with such a column to `TIMESTAMP`, so the column stays bare and partition pruning holds. Query time zones are DEV-2000. Elsewhere a zoned column reads as `CAST(col AS DATETIME)`, so buckets, windows, the time spine and returned values see one type; only a direct comparison operand stays bare. + +## Risks / Trade-offs + +- [Golden SQL churn: every Mode-B `LIKE` gains `ESCAPE '\'`; SQLite `LIKE` becomes `GLOB`] → regenerate baselines; release note. +- [Behaviour changes for live queries: `greatest` / `least` NULLs, SQLite `LIKE` case, LIKE `\` / `[`, TEXT vs number] → release notes; no stored-text migration (stored text keeps parsing; its meaning moves to the portable one by design). +- [Trino's default regex library (Joni) and Java-style anchors] → the flavour record emits `\A` / `\z`; trailing-newline probes in the Trino suite. +- [SQLite registered Python functions are slower than native] → only for regex and LIKE; constant patterns are evaluated once. +- [DOUBLE coercion loses precision beyond 2^53] → documented, `TRY_CAST(x AS BIGINT)` remedy. +- [JSON number to TEXT differs by database (`1.0` vs `1`)] → documented; `RETURNING DOUBLE` is the exact form. +- [`db_type` absent on models ingested before this change] → TEXT form; Snowflake's TEXT form also reads `VARIANT`; ClickHouse `JSON` columns need a re-ingest (documented). +- [MCP schema budget] → Field-description additions stay within `tests/test_mcp_surface_budget.py`. +- [DEV-2101's `//` hint names `div` before this change lands] → accepted; scenario asserts the hint works here. diff --git a/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/proposal.md b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/proposal.md new file mode 100644 index 000000000..d69cda6c3 --- /dev/null +++ b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/proposal.md @@ -0,0 +1,39 @@ +## Why + +Mode B passes most scalars to sqlglot and documents where the databases disagree (`greatest` / `least` NULLs, SQLite `LIKE` case, LIKE metacharacters), and it has no regex, JSON, TEXT-vs-number coercion or common string / math functions — so agents fall back to query-time Mode-A SQL (which DEV-2021 removes) and comparison-matrix row C9 "Portable expression library" is only `partial`. This change gives every Mode-B function, operator and pattern language one documented meaning on every Tier-1 dialect, verified per dialect. + +## What Changes + +- Global rules for the library: Postgres is the reference meaning when databases disagree; an out-of-domain argument yields NULL on every dialect (a literal one is a plan-time error); a version-gated feature fails closed at plan time when the server version is known. +- Strings: `left`, `right`, `starts_with`, `ends_with`, `contains`, `strpos`, `lpad`, `rpad`, `reverse`, `repeat`, `split_part` (non-zero integer-literal index), `concat_ws`, `chr`, `ascii` (Unicode code points). +- Math: `div` (truncates toward zero), `pi`, `sin`, `cos`, `tan`, `asin`, `acos`, `atan`, `atan2`, `cbrt`. +- `date_trunc(unit, x)` as a spelling of the granularity call `(x)`. +- **BREAKING** `greatest` / `least` ignore NULL arguments on every dialect (SQLite, MySQL, BigQuery and ClickHouse before 24.12 propagated NULL); SQL Server before 2022 is a plan-time error. +- Regex: `regexp_like`, `regexp_extract`, `regexp_replace`, the `~` / `~*` / `!~` / `!~*` operators, one portable pattern subset re-emitted per dialect; SQL Server needs 2025+. +- JSON: `json_value(x, path [RETURNING type])`, `->` / `->>` chains, the `json_extract` / `json_extract_scalar` / `json_extract_path_text` / `jsonb_extract_path_text` aliases; ingestion keeps `db_type` for JSON-family columns. +- **BREAKING** TEXT against a number compares and computes numerically (`TRY_CAST(text AS DOUBLE)`), on every dialect. +- **BREAKING** One LIKE pattern language: `%` and `_` the only wildcards, `\` escapes `%`, `_` and `\`, `[` always literal (DuckDB, Trino, SQLite and SQL Server read these differently today). SQLite Mode-B `LIKE` becomes case-sensitive; Mode-A SQL is untouched. +- Braces inside a Mode-B string literal holding only digits, commas and spaces (`'[0-9]{3}'`, `'{1, 2, 3}'`) are literal text, so regex quantifiers need no escaping. +- Comparison matrix: C9 SLayer verdict → yes, with `C9-slayer-*` probes. +- Not added: `initcap` (no single-expression form on MySQL, SQL Server, DuckDB), `random()`, format-string parsers, JSON builders and table functions. + +## Capabilities + +### New Capabilities +- `queries/scalar-functions`: the library's global rules (reference meaning, out-of-domain NULL, version gating) and its string, math and `greatest` / `least` functions. +- `queries/regex`: regex functions and operators, the portable pattern subset, its one meaning, replacement strings. +- `queries/json`: `json_value`, path subset, `RETURNING`, `->` / `->>` chains, aliases, input forms. +- `queries/mixed-type-coercion`: TEXT against a number in comparisons and arithmetic. +- `queries/string-matching`: collation rule, the LIKE / ILIKE pattern language, SQLite case. + +### Modified Capabilities +- `queries/date-functions`: `date_trunc(unit, x)` is the granularity call. +- `queries/variables`: digit-and-comma braces inside a string literal are literal text. + +## Impact + +- Code: `slayer/core/keys.py` (scalar registry), new pure-syntax modules in `slayer/core/` (regex pattern, JSON path, LIKE pattern), `slayer/core/syntax.py` (regex and JSON operators, `date_trunc`), `slayer/engine/binding.py` / `elaborate_env.py` (pattern and path validation, coercion typing), `slayer/sql/render/row_expr.py`, `slayer/sql/dialects/*` (per-function lowerings, SQLite registered functions, SQL Server version gate), `slayer/engine/ingestion.py` (JSON `db_type`). +- Docs: `docs/concepts/references.md`, `formulas.md`, `queries.md`, MCP Field descriptions, `slayer/memories/help_content/*`. +- Comparison: `examples/comparisons/probes.yaml`, `matrix.yaml`, `matrix.json`. +- Architecture: `system.arc42.md` principle 10 status tag. +- Behaviour changes for live queries: `greatest` / `least` with NULLs, SQLite `LIKE` case, LIKE backslash / `[`, TEXT vs number, SQL Server version errors. diff --git a/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/date-functions/spec.md b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/date-functions/spec.md new file mode 100644 index 000000000..438e66590 --- /dev/null +++ b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/date-functions/spec.md @@ -0,0 +1,20 @@ +## ADDED Requirements + +### Requirement: date_trunc is the granularity call + +`date_trunc(unit, x)` SHALL mean the granularity call `(x)` — the same bucket, type and behaviour in every position: a row value in filters, aggregation sources, computed dimensions and arithmetic, and a time dimension in a `dimensions` / `time_dimensions` entry or an `order` key. `unit` SHALL be a string literal naming a built-in granularity (`second`, `minute`, `hour`, `day`, `week`, `week_sunday`, `month`, `quarter`, `year`), matched case-insensitively; anything else SHALL be rejected with the granularity call's error. `date_trunc` SHALL be reserved like the other date function names. + +#### Scenario: Row value + +- **WHEN** a filter is `date_trunc('month', created_at) = '2025-03'` +- **THEN** it keeps the same rows as `month(created_at) = '2025-03'` + +#### Scenario: Time dimension + +- **WHEN** a query's `dimensions` entry is `"date_trunc('month', created_at)"` +- **THEN** it is the time dimension `month(created_at)`, with the same result key and SQL + +#### Scenario: Unknown unit + +- **WHEN** a dimension is `date_trunc('fortnight', created_at)` +- **THEN** the query fails with the granularity call's unknown-granularity error diff --git a/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/json/spec.md b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/json/spec.md new file mode 100644 index 000000000..43268a240 --- /dev/null +++ b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/json/spec.md @@ -0,0 +1,99 @@ +## Purpose + +Defines how Mode-B expressions read scalar values out of JSON: `json_value` with an optional typed result, the Postgres and MySQL arrow chains, the accepted aliases, and the JSON inputs each dialect reads. + +## ADDED Requirements + +### Requirement: json_value reads one scalar + +`json_value(x, path [RETURNING type])` SHALL return the scalar at `path` in the JSON document `x`. It SHALL yield NULL when `x` is NULL or not valid JSON, the path does not exist, or the value there is JSON `null`, an object or an array. A JSON string SHALL be returned unquoted; a JSON boolean as `'true'` / `'false'`; a JSON number in the database's own number-to-text rendering. On Postgres older than 16, or of unknown version, invalid JSON input SHALL follow the `TRY_CAST` contract of `queries/casts` and fail the query. + +#### Scenario: Scalars, missing and non-scalars + +- **WHEN** a dimension is `json_value(payload, '$.a.b')` over rows holding `{"a": {"b": "x"}}`, `{"a": {}}`, `{"a": {"b": null}}`, `{"a": {"b": [1]}}` and `'not json'` +- **THEN** they yield `'x'`, NULL, NULL, NULL and NULL on every Tier-1 dialect (Postgres 16+) + +#### Scenario: Boolean as text + +- **WHEN** a dimension is `json_value(payload, '$.ok')` over a row holding `{"ok": true}` +- **THEN** it yields `'true'` + +### Requirement: The path subset + +A path SHALL be a string literal or `{var}` placeholder made of `$` followed by any sequence of `.key`, `."quoted key"` and `[n]` with `n` a non-negative integer. Wildcards, filters, recursive descent, negative indices and anything else SHALL be rejected at plan time with a typed error naming the construct. + +#### Scenario: Array index and quoted key + +- **WHEN** a dimension is `json_value(payload, '$.items[1]."unit price"')` over a row holding `{"items": [{}, {"unit price": "9.5"}]}` +- **THEN** it yields `'9.5'` + +#### Scenario: Wildcard + +- **WHEN** a dimension is `json_value(payload, '$.items[*].sku')` +- **THEN** the query fails at plan time naming the wildcard + +### Requirement: RETURNING converts or yields NULL + +`RETURNING INT | DOUBLE | BOOLEAN | DATE | TIMESTAMP | TEXT` SHALL type the result (default TEXT). A value that cannot convert SHALL yield NULL, with the `TRY_CAST` meaning of `queries/casts`; a JSON boolean SHALL convert to BOOLEAN directly, never through its text; a JSON number SHALL convert to INT / DOUBLE directly. + +#### Scenario: Typed result + +- **WHEN** a measure is `sum(json_value(payload, '$.qty' RETURNING INT))` over rows holding `{"qty": 2}`, `{"qty": "3"}`, `{"qty": "x"}` and `{}` +- **THEN** it yields 5 on every Tier-1 dialect (Postgres 16+) + +#### Scenario: Genuine zero and false are kept + +- **WHEN** dimensions are `json_value(payload, '$.n' RETURNING INT)` and `json_value(payload, '$.f' RETURNING BOOLEAN)` over a row holding `{"n": 0, "f": false}`, and over a row holding `{}` +- **THEN** the first row yields `0` and `false`, the second NULL and NULL, on every Tier-1 dialect + +### Requirement: JSON inputs + +`x` SHALL be a TEXT expression or a column of the database's native JSON type (Postgres `json` / `jsonb`, MySQL / DuckDB / BigQuery `JSON`, Snowflake `VARIANT` / `OBJECT` / `ARRAY`, ClickHouse `JSON`); ingestion SHALL record such a column's database type so its native form is read. A column whose database type is not recorded SHALL be read as TEXT. + +#### Scenario: Native JSON column + +- **WHEN** a Postgres table has a `jsonb` column `payload`, its model is ingested, and a dimension is `json_value(payload, '$.a')` +- **THEN** the query runs and yields the value at `$.a` + +#### Scenario: Snowflake VARIANT + +- **WHEN** a Snowflake table has a `VARIANT` column `payload`, its model is ingested, and a dimension is `json_value(payload, '$.a' RETURNING INT)` +- **THEN** the query runs and an unconvertible value yields NULL + +### Requirement: Arrow chains + +`x -> k1 -> … ->> kn` (Postgres form) and `x ->> '$.path'` (MySQL form) SHALL mean `json_value(x, path)` with TEXT result: a string operand starting with `$` is a path, any other string a key, an integer an array index. Every operand SHALL be a literal. The arrows SHALL bind as Postgres binds them: at the precedence of `||`, left-associative. A chain ending in `->` (a JSON-valued result) SHALL be rejected with a hint to end it with `->>`. + +#### Scenario: Postgres chain + +- **WHEN** a dimension is `payload -> 'a' -> 0 ->> 'b'` over a row holding `{"a": [{"b": "x"}]}` +- **THEN** it yields `'x'`, the same as `json_value(payload, '$.a[0].b')` + +#### Scenario: MySQL path form + +- **WHEN** a dimension is `payload ->> '$.a.b'` +- **THEN** it means `json_value(payload, '$.a.b')` + +#### Scenario: Bare arrow + +- **WHEN** a dimension is `payload -> 'a'` +- **THEN** the query fails with a hint to use `->>` + +#### Scenario: Postgres precedence + +- **WHEN** a dimension is `payload ->> 'n' || 'x'` +- **THEN** it means `(payload ->> 'n') || 'x'` + +### Requirement: JSON aliases + +`json_extract(x, path)` and `json_extract_scalar(x, path)` SHALL mean `json_value(x, path)` (exactly two arguments, no `RETURNING`); `json_extract_path_text(x, k1, …)` and `jsonb_extract_path_text(x, k1, …)` SHALL mean `json_value` over the path of those keys. + +#### Scenario: Key-list alias + +- **WHEN** a dimension is `json_extract_path_text(payload, 'a', 'b')` +- **THEN** it means `json_value(payload, '$.a.b')` + +#### Scenario: json_extract of an object + +- **WHEN** a dimension is `json_extract(payload, '$.a')` over a row holding `{"a": {"b": 1}}` +- **THEN** it yields NULL diff --git a/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/mixed-type-coercion/spec.md b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/mixed-type-coercion/spec.md new file mode 100644 index 000000000..f415bcd7f --- /dev/null +++ b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/mixed-type-coercion/spec.md @@ -0,0 +1,100 @@ +## Purpose + +Defines what a Mode-B expression means when a TEXT value meets a number, so comparisons and arithmetic over numbers stored as text behave the same on every Tier-1 dialect. + +## ADDED Requirements + +### Requirement: TEXT against a number is numeric + +When a TEXT operand meets an INT or DOUBLE operand in a comparison (`=`, `<>`, `<`, `<=`, `>`, `>=`), `IN`, `BETWEEN`, `IS [NOT] DISTINCT FROM`, arithmetic (`+`, `-`, `*`, `/`, `%`) or `greatest` / `least`, the TEXT side SHALL be read as `TRY_CAST(text AS DOUBLE)` with the meaning of `queries/casts` — invalid text yields NULL — and the operation SHALL be numeric on every dialect. Arithmetic with a TEXT operand SHALL type as DOUBLE. On Postgres older than 16, or of unknown version, the conversion SHALL follow `TRY_CAST`'s contract there (a plain cast). + +#### Scenario: Comparison against an integer literal + +- **WHEN** a query's filter is `amount_txt > 100` over rows holding `'120.5'`, `'99'`, `'abc'` and NULL +- **THEN** it keeps `'120.5'` only, on every Tier-1 dialect (Postgres 16+) + +#### Scenario: Comparison against a numeric column + +- **WHEN** a filter is `amount_txt = qty` over a row where `amount_txt` is `'3.0'` and `qty` is 3 +- **THEN** it keeps the row + +#### Scenario: Numeric, not lexicographic, on SQLite + +- **WHEN** a filter is `amount_txt < 9` over a row holding `'10'` on SQLite +- **THEN** it drops the row + +#### Scenario: Arithmetic + +- **WHEN** a dimension is `amount_txt * 2` over a row holding `'1.5'` +- **THEN** it yields `3.0` with type DOUBLE + +#### Scenario: IN list + +- **WHEN** a filter is `code_txt IN (1, 2)` over rows holding `'1'`, `'02'` and `'x'` +- **THEN** it keeps `'1'` and `'02'` + +### Requirement: TEXT literals convert at plan time + +A TEXT literal meeting a number SHALL be converted to a number at plan time; a literal that is not a number SHALL be rejected at plan time with a typed error naming the literal. + +#### Scenario: Numeric string literal + +- **WHEN** a filter is `amount > '100'` over an INT column `amount` +- **THEN** it keeps the rows with `amount > 100` + +#### Scenario: Non-numeric literal + +- **WHEN** a filter is `amount > 'abc'` +- **THEN** the query fails at plan time naming `'abc'` + +### Requirement: Coercion is limited to mixed operands + +Coercion SHALL apply only where TEXT meets a number in the positions above. A numeric function or numeric aggregation over a TEXT argument (`abs(amount_txt)`, `sum(amount_txt)`) SHALL keep its type error, whose remedy SHALL name `TRY_CAST`. An author-written `CAST` / `::` SHALL never be rewritten. `||` with a number SHALL convert the number to TEXT with the database's own number-to-text cast. A BOOLEAN operand of `||`, `concat` or `concat_ws` SHALL be rejected at plan time with a typed error whose remedy names `CASE`. Existing rules for TEXT against a DATE / TIMESTAMP (a time point) and booleans in a numeric context (1 / 0) SHALL be unchanged. + +#### Scenario: Boolean in text concatenation + +- **WHEN** a dimension is `name || (amount > 100)` +- **THEN** the query fails at plan time with a type error whose remedy names `CASE` + +#### Scenario: Numeric aggregation over TEXT + +- **WHEN** a measure is `sum(amount_txt)` +- **THEN** it fails with a type error whose remedy names `TRY_CAST` + +#### Scenario: Author cast kept + +- **WHEN** a filter is `CAST(amount_txt AS INT) > 100` on Postgres over a row holding `'abc'` +- **THEN** the query fails with Postgres's own cast error, as the author's `CAST` does + +### Requirement: Large integers stored as text + +The documentation SHALL state that the DOUBLE reading loses precision for integers beyond 2^53 and that `TRY_CAST(x AS BIGINT)` is the exact form. + +#### Scenario: Exact form + +- **WHEN** a filter is `TRY_CAST(id_txt AS BIGINT) = 12345678901234567` +- **THEN** it compares exactly + +### Requirement: A naive timestamp meets a zoned column in the column's type + +SLayer's TIMESTAMP SHALL be a naive wall-clock value on every dialect (BigQuery `DATETIME`) — the result of `now()`, timestamp literals, `TRY_CAST(… AS TIMESTAMP)`, `json_value(… RETURNING TIMESTAMP)` and the date functions. A timestamp literal against such a column SHALL compare as ISO text in the column's type, read as UTC. Where a column's `db_type` is the dialect's zoned instant type (BigQuery `TIMESTAMP`), a comparison (`=`, `<>`, `<`, `<=`, `>`, `>=`, `IS [NOT] DISTINCT FROM`) between that column and a non-literal TIMESTAMP value SHALL convert the value to the column's type, reading it as UTC, and SHALL leave the column unconverted. Everywhere else — buckets, date functions, windows, the time spine, scalar functions and returned values — such a column SHALL read as its UTC wall clock, a naive TIMESTAMP. + +#### Scenario: now() against a BigQuery TIMESTAMP column + +- **WHEN** a filter is `created_at < now()` over a BigQuery `TIMESTAMP` column ingested with `db_type` `TIMESTAMP` +- **THEN** it keeps the rows before the current UTC instant, comparing the column itself + +#### Scenario: now() against a BigQuery DATETIME column + +- **WHEN** a filter is `created_at < now()` over a BigQuery `DATETIME` column +- **THEN** it keeps the rows before the current UTC wall clock + +#### Scenario: Timestamp literal against a BigQuery TIMESTAMP column + +- **WHEN** a filter is `created_at < TIMESTAMP '2025-01-01 00:00:00'` over a BigQuery `TIMESTAMP` column ingested with `db_type` `TIMESTAMP` +- **THEN** it keeps the rows before the UTC instant 2025-01-01 00:00:00, comparing the column itself + +#### Scenario: Monthly bucket of a BigQuery TIMESTAMP column + +- **WHEN** a query has the time dimension `month(created_at)` over a BigQuery `TIMESTAMP` column ingested with `db_type` `TIMESTAMP`, on the time spine +- **THEN** each bucket is the naive month start of the UTC wall clock and joins the spine diff --git a/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/regex/spec.md b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/regex/spec.md new file mode 100644 index 000000000..c61e3c3db --- /dev/null +++ b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/regex/spec.md @@ -0,0 +1,144 @@ +## Purpose + +Defines Mode-B regular expressions: the matching, extraction and replacement functions, their operator spellings, and one portable pattern language that means the same on every Tier-1 dialect. + +## ADDED Requirements + +### Requirement: Regex functions + +Mode B SHALL provide: + +- `regexp_like(x, p[, 'i'])` — BOOLEAN, true when `p` matches anywhere in `x`. +- `regexp_extract(x, p[, group])` — TEXT: the first match, or that capture group of the first match; NULL when nothing matches; `''` when the pattern matches but the group did not take part (as in a replacement), on every dialect. `group` SHALL be an integer literal from 0 (the whole match) to the pattern's group count. +- `regexp_replace(x, p, replacement[, 'i'])` — TEXT with every non-overlapping match replaced. + +The only flag SHALL be the literal `'i'` (case-insensitive); without it matching SHALL be case-sensitive on every dialect, whatever the column's collation. A NULL `x` SHALL yield NULL. + +#### Scenario: Partial match + +- **WHEN** a filter is `regexp_like(code, '[0-9]{3}')` over rows holding `'ab123'` and `'ab12'` +- **THEN** it keeps `'ab123'` only, on every Tier-1 dialect + +#### Scenario: Case-sensitive by default + +- **WHEN** a filter is `regexp_like(status, '^paid$')` over rows holding `'paid'` and `'PAID'` on MySQL with a case-insensitive collation +- **THEN** it keeps `'paid'` only; with the `'i'` flag it keeps both + +#### Scenario: Extract a group, NULL on no match + +- **WHEN** a dimension is `regexp_extract(email, '@(.+)$', 1)` over rows holding `'a@x.org'` and `'nobody'` +- **THEN** they yield `'x.org'` and NULL on every Tier-1 dialect + +#### Scenario: Group that did not take part + +- **WHEN** a dimension is `regexp_extract(code, '(x)?b', 1)` over rows holding `'ab'` and `'zz'` +- **THEN** they yield `''` and NULL on every Tier-1 dialect + +#### Scenario: Group beyond the pattern + +- **WHEN** a dimension is `regexp_extract(email, '@(.+)$', 2)` +- **THEN** the query fails at plan time with a typed error + +#### Scenario: Replace every match + +- **WHEN** a dimension is `regexp_replace(phone, '[^0-9]', '')` over a row holding `'+1 (555) 01'` +- **THEN** it yields `'155501'` + +### Requirement: Regex operators + +`x ~ p`, `x ~* p`, `x !~ p` and `x !~* p` SHALL mean `regexp_like(x, p)`, `regexp_like(x, p, 'i')`, `NOT regexp_like(x, p)` and `NOT regexp_like(x, p, 'i')`, binding like the comparison operators. + +#### Scenario: Operator spelling + +- **WHEN** a filter is `name ~* '^ad'` +- **THEN** it keeps the same rows as `regexp_like(name, '^ad', 'i')` + +### Requirement: Patterns are literals or variables + +A pattern SHALL be a string literal or a `{var}` placeholder whose value is the pattern text. Any other pattern expression (a column, a concatenation) SHALL be rejected at plan time. A repetition count in a pattern literal is written as is (`queries/variables`). An undefined-variable error raised from a pattern argument SHALL also point at `{{` / `}}` for literal braces. + +#### Scenario: Column-valued pattern + +- **WHEN** a filter is `regexp_like(name, pattern_col)` +- **THEN** the query fails at plan time with a typed error + +#### Scenario: Variable pattern + +- **WHEN** a filter is `regexp_like(name, {p})` with variable `p` = `'^a.c$'` +- **THEN** it keeps the rows matching `^a.c$` + +#### Scenario: Name-shaped braces in a pattern + +- **WHEN** a filter is `regexp_like(word, '\p{L}')` and no variable `L` is supplied +- **THEN** it fails with the undefined-variable error naming `L` and pointing at `{{` / `}}` + +### Requirement: The portable pattern subset + +A pattern SHALL be validated at plan time against the portable subset: literal characters; `.`; bracket expressions `[…]` and `[^…]` with ranges; the quantifiers `*`, `+`, `?`, `{m}`, `{m,}`, `{m,n}`; the anchors `^` and `$`; alternation `|`; groups `( … )`; the classes `\d`, `\w`, `\s` and their negations `\D`, `\W`, `\S`; the escapes `\n`, `\t`, `\r`; and a backslash before any metacharacter. Anything else — backreferences, lookaround, lazy quantifiers, `(?…)` groups, `\b`, `\p{…}`, POSIX classes such as `[[:alpha:]]` — SHALL be rejected with a typed error naming the construct; for a variable pattern the error SHALL also name the variable. + +#### Scenario: Unsupported construct + +- **WHEN** a filter is `regexp_like(name, '(?=a)b')` +- **THEN** the query fails at plan time naming the lookahead construct + +#### Scenario: Unsupported construct in a variable + +- **WHEN** a filter is `regexp_like(name, {p})` with `p` = `'\bword'` +- **THEN** the query fails at plan time naming `\b` and the variable `p` + +### Requirement: One pattern meaning on every dialect + +On every Tier-1 dialect: `.` SHALL match any character, newline included; `^` and `$` SHALL match only at the start and end of the whole string (never before a trailing newline); `\d`, `\w` and `\s` SHALL be the ASCII classes `[0-9]`, `[A-Za-z0-9_]` and `[ \t\n\r\f\v]`, inside bracket expressions too; `\n`, `\t` and `\r` SHALL be newline, tab and carriage return; the `'i'` flag SHALL fold at least ASCII letters, non-ASCII folding being the database's own. + +#### Scenario: Dot matches newline + +- **WHEN** a filter is `regexp_like(notes, 'paid.*late')` over a row holding `'paid` newline `late'` +- **THEN** it keeps the row on every Tier-1 dialect + +#### Scenario: Dollar is the true end + +- **WHEN** a filter is `regexp_like(code, '^ab$')` over a row holding `'ab'` followed by a newline +- **THEN** it drops the row on every Tier-1 dialect + +#### Scenario: ASCII digit class + +- **WHEN** a filter is `regexp_like(code, '^\d+$')` over rows holding `'123'` and `'١٢٣'` (Arabic-Indic digits) +- **THEN** it keeps `'123'` only, on every Tier-1 dialect + +#### Scenario: Class inside brackets + +- **WHEN** a filter is `regexp_like(code, '^[\d_]+$')` over a row holding `'1_2'` +- **THEN** it keeps the row on every Tier-1 dialect + +#### Scenario: Newline escape + +- **WHEN** a dimension is `regexp_extract(notes, '^[^\n]*')` over a row holding `'line1` newline `line2'` +- **THEN** it yields `'line1'` + +### Requirement: Replacement strings + +In a `regexp_replace` replacement, `\1` to `\9` SHALL insert that capture group (empty when it did not participate) and `\\` SHALL insert one backslash; every other character, `$` and `&` included, SHALL be literal on every dialect. Any other backslash sequence, or a group number beyond the pattern's groups, SHALL be rejected at plan time. The replacement SHALL be a string literal or a `{var}` placeholder. + +#### Scenario: Group reference + +- **WHEN** a dimension is `regexp_replace(name, '(\w+) (\w+)', '\2, \1')` over a row holding `'Ada Lovelace'` +- **THEN** it yields `'Lovelace, Ada'` on every Tier-1 dialect + +#### Scenario: Literal dollar and ampersand + +- **WHEN** a dimension is `regexp_replace(price, 'USD', '$ & co')` over a row holding `'5 USD'` +- **THEN** it yields `'5 $ & co'` on every Tier-1 dialect + +#### Scenario: Unknown escape + +- **WHEN** a dimension is `regexp_replace(name, 'a', '\q')` +- **THEN** the query fails at plan time with a typed error + +### Requirement: SQL Server needs 2025 + +Regex functions and operators SHALL follow the version-gating rule of `queries/scalar-functions` with SQL Server 2025 as the minimum, at every database compatibility level. + +#### Scenario: SQL Server 2022 + +- **WHEN** a filter is `regexp_like(code, '^a')` against a SQL Server reporting version 2022 +- **THEN** the query fails at plan time naming SQL Server 2025 diff --git a/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/scalar-functions/spec.md b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/scalar-functions/spec.md new file mode 100644 index 000000000..09e0f1b0d --- /dev/null +++ b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/scalar-functions/spec.md @@ -0,0 +1,146 @@ +## Purpose + +Defines the Mode-B scalar function library: the rules that give every function one meaning on every Tier-1 dialect, and the string, math and `greatest` / `least` functions. + +## ADDED Requirements + +### Requirement: One meaning on every Tier-1 dialect + +Every Mode-B scalar function SHALL return the same value for the same inputs on SQLite, Postgres, DuckDB, MySQL, ClickHouse, SQL Server, Trino, Snowflake and BigQuery. Where the databases disagree on an edge case — NULL arguments, out-of-range positions, empty strings, negative counts — the meaning SHALL be the value Postgres returns. Every function in the library SHALL be verified by execution on every Tier-1 dialect. + +#### Scenario: Every library function is covered on every dialect + +- **WHEN** a scalar function is in the Mode-B library +- **THEN** the per-dialect test matrix holds executed cases for it on every Tier-1 dialect, and a function without cases fails the test suite + +#### Scenario: Postgres edge case is the meaning + +- **WHEN** a dimension is `left(code, -2)` over a row holding `'ABCDE'` +- **THEN** it yields `'ABC'` on every Tier-1 dialect + +### Requirement: Out-of-domain arguments yield NULL + +A function argument outside the function's domain — `asin` / `acos` beyond ±1, `div` by zero, a `chr` code point that is a surrogate or above `0x10FFFF` — SHALL yield NULL on every dialect, as `/` by zero does. When the out-of-domain argument is a literal, the query SHALL be rejected at plan time with a typed error naming the function and the argument. + +#### Scenario: Column argument out of domain + +- **WHEN** a dimension is `asin(ratio)` over rows holding `0.5` and `2` +- **THEN** they yield `asin(0.5)` and NULL on every Tier-1 dialect + +#### Scenario: Literal argument out of domain + +- **WHEN** a dimension is `asin(2)` +- **THEN** the query fails at plan time with a typed error naming `asin` and its argument + +#### Scenario: Division by zero + +- **WHEN** a dimension is `div(amount, qty)` over a row where `qty` is 0 +- **THEN** it yields NULL on every Tier-1 dialect + +### Requirement: Version-gated functions fail closed + +A function that needs a newer server than the connected one SHALL be rejected at plan time with a typed error naming the function and the required version, when the server version is known. When the version is unknown, the SQL SHALL be emitted and the database decides. `greatest` / `least` require SQL Server 2022 or later; regex functions require SQL Server 2025 or later. + +#### Scenario: Old SQL Server + +- **WHEN** a dimension is `greatest(a, b)` against a SQL Server reporting version 2019 +- **THEN** the query fails at plan time naming `greatest` and SQL Server 2022 + +#### Scenario: Unknown version + +- **WHEN** the same query is rendered without a server profile +- **THEN** the SQL is emitted + +### Requirement: String functions + +The library SHALL provide, with Postgres meanings: + +- `left(s, n)` / `right(s, n)` — the first / last `n` characters; a negative `n` drops the last / first `|n|` characters. +- `starts_with(s, p)` / `ends_with(s, p)` / `contains(s, p)` — BOOLEAN; `p` is plain text, never a pattern, matched case- and accent-sensitively whatever the column's collation. +- `strpos(s, p)` — the 1-based position of the first `p` in `s`, 0 when absent, matched like `contains`; the same function as `instr` and `POSITION(p IN s)`. +- `lpad(s, n[, fill])` / `rpad(s, n[, fill])` — pad to `n` characters with `fill` (default one space), truncating `s` when it is longer than `n`. +- `reverse(s)` — the characters of `s` in reverse order. +- `repeat(s, n)` — `s` repeated `n` times; empty for `n ≤ 0`. +- `split_part(s, delimiter, n)` — the `n`-th field, the delimiter matched case- and accent-sensitively whatever the column's collation; `n` SHALL be a non-zero integer literal, negative counting from the end; a field beyond the last yields `''`. +- `replace(s, from, to)` — every `from` in `s` replaced by `to`, matched case- and accent-sensitively whatever the column's collation. +- `concat_ws(separator, a, …)` — the non-NULL arguments joined by the separator. +- `chr(n)` — the character with a Unicode code point from `1` through `0x10FFFF`, excluding surrogates; `ascii(s)` — the code point of the first character of `s`. + +Lengths, positions and counts SHALL be in characters, not bytes. + +#### Scenario: Plain-text containment + +- **WHEN** a filter is `contains(code, '5%')` over rows holding `'15%'` and `'150'` +- **THEN** it keeps `'15%'` only + +#### Scenario: Case-sensitive whatever the collation + +- **WHEN** a filter is `starts_with(name, 'ad')` over a row holding `'Ada'` on MySQL with a case-insensitive collation +- **THEN** it drops the row + +#### Scenario: Non-ASCII characters + +- **WHEN** dimensions are `reverse(name)`, `ascii(name)` and `left(name, 1)` over a row holding `'€é'` +- **THEN** they yield `'é€'`, `8364` and `'€'` on every Tier-1 dialect + +#### Scenario: Astral code point + +- **WHEN** a dimension is `chr(128512)` +- **THEN** it yields the one character U+1F600 on every Tier-1 dialect + +#### Scenario: split_part index + +- **WHEN** dimensions are `split_part(path, '/', 2)`, `split_part(path, '/', -1)` and `split_part(path, '/', 9)` over a row holding `'a/b/c'` +- **THEN** they yield `'b'`, `'c'` and `''` + +#### Scenario: split_part non-literal or zero index + +- **WHEN** a dimension is `split_part(path, '/', depth)` or `split_part(path, '/', 0)` +- **THEN** the query fails at plan time with a typed error + +#### Scenario: lpad truncates + +- **WHEN** a dimension is `lpad(code, 3, '0')` over rows holding `'7'` and `'12345'` +- **THEN** they yield `'007'` and `'123'` + +#### Scenario: concat_ws skips NULLs + +- **WHEN** a dimension is `concat_ws('-', a, b, c)` over a row where `b` is NULL, `a` is `'x'` and `c` is `'z'` +- **THEN** it yields `'x-z'` + +### Requirement: Math functions + +The library SHALL provide `div(a, b)` — the quotient truncated toward zero, INT when both operands are INT, else DOUBLE; `pi()`; `sin`, `cos`, `tan`, `asin`, `acos`, `atan` (radians); `atan2(y, x)`; and `cbrt(x)`, the real cube root keeping the sign of `x`. + +#### Scenario: div truncates toward zero + +- **WHEN** dimensions are `div(7, 2)`, `div(-7, 2)`, `div(7, -2)` and `div(-7, -2)` +- **THEN** they yield `3`, `-3`, `-3` and `3` on every Tier-1 dialect + +#### Scenario: cbrt of a negative number + +- **WHEN** a dimension is `cbrt(x)` over a row holding `-8` +- **THEN** it yields `-2` + +#### Scenario: The floor-division hint names a working function + +- **WHEN** a query uses `a // b` and then follows the error's hint with `div(a, b)` +- **THEN** the second query runs + +### Requirement: greatest and least ignore NULLs + +`greatest(a, b, …)` and `least(a, b, …)` SHALL return the greatest / least non-NULL argument, and NULL only when every argument is NULL, on every dialect. + +#### Scenario: NULL in any position + +- **WHEN** a dimension is `greatest(a, b, c)` over rows `(NULL, 2, 1)`, `(3, NULL, 1)`, `(1, 2, NULL)` and `(NULL, NULL, NULL)` +- **THEN** they yield `2`, `3`, `2` and NULL on every Tier-1 dialect + +### Requirement: Functions outside the library are rejected + +`initcap`, `random`, format-string parsers (`to_date(x, fmt)`, `strftime`), JSON builders and JSON table functions SHALL NOT be Mode-B functions; a call SHALL fail with the existing unknown-function error. + +#### Scenario: initcap + +- **WHEN** a dimension is `initcap(name)` +- **THEN** the query fails as an unknown function diff --git a/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/string-matching/spec.md b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/string-matching/spec.md new file mode 100644 index 000000000..afc5d5944 --- /dev/null +++ b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/string-matching/spec.md @@ -0,0 +1,53 @@ +## Purpose + +Defines how Mode-B compares and pattern-matches strings: which comparisons follow the column's collation, which are guaranteed case-insensitive, and one LIKE pattern language on every Tier-1 dialect. + +## ADDED Requirements + +### Requirement: Comparisons follow the column's collation + +`=`, `<>`, `<`, `<=`, `>`, `>=`, `IN` and `LIKE` over TEXT SHALL follow the database's collation for the operands, except on SQLite, where Mode-B `LIKE` SHALL be case-sensitive whatever the column's declared collation. `ILIKE` and the regex `'i'` flag SHALL be the case-insensitive forms on every dialect. Mode-A SQL (`Column.sql`, model `filters`) SHALL keep the database's own meaning. + +#### Scenario: SQLite LIKE is case-sensitive + +- **WHEN** a filter is `name LIKE 'ada%'` on SQLite over rows holding `'ada'` and `'Ada'` +- **THEN** it keeps `'ada'` only + +#### Scenario: ILIKE is case-insensitive everywhere + +- **WHEN** a filter is `name ILIKE 'ADA%'` over rows holding `'ada'` and `'Ada'` +- **THEN** it keeps both, on every Tier-1 dialect + +#### Scenario: Mode-A LIKE on SQLite unchanged + +- **WHEN** a model column has `sql` `name LIKE 'ada%'` on SQLite and a row holds `'Ada'` +- **THEN** the column is true for that row, as SQLite's own `LIKE` is + +### Requirement: One LIKE pattern language + +In Mode-B `LIKE` and `ILIKE` patterns, `%` SHALL match any sequence of characters (newlines included) and `_` exactly one character; a backslash SHALL make the following `%`, `_` or `\` literal and SHALL be literal before any other character; every other character, `[` included, SHALL be literal — on every Tier-1 dialect, for literal, variable and column-valued patterns. + +#### Scenario: Escaped wildcard + +- **WHEN** a filter is `code LIKE 'a\_%'` over rows holding `'a_1'` and `'ab1'` +- **THEN** it keeps `'a_1'` only, on every Tier-1 dialect + +#### Scenario: Bracket is literal + +- **WHEN** a filter is `code LIKE '[ab]%'` over rows holding `'[ab]1'` and `'a1'` +- **THEN** it keeps `'[ab]1'` only, on SQL Server as everywhere + +#### Scenario: Lone backslash is literal + +- **WHEN** a filter is `path LIKE 'c:\x%'` over a row holding `'c:\x1'` +- **THEN** it keeps the row on every Tier-1 dialect + +#### Scenario: Column-valued pattern + +- **WHEN** a filter is `name LIKE prefix || '%'` over a row where `prefix` is `'a_'` and `name` is `'a_b'`, and over a row where `name` is `'axb'` +- **THEN** both rows match, `_` in the column value being a wildcard + +#### Scenario: GLOB metacharacters on SQLite + +- **WHEN** a filter is `code LIKE 'a*?%'` on SQLite over rows holding `'a*?1'` and `'abc1'` +- **THEN** it keeps `'a*?1'` only diff --git a/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/variables/spec.md b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/variables/spec.md new file mode 100644 index 000000000..883d11b01 --- /dev/null +++ b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/specs/queries/variables/spec.md @@ -0,0 +1,35 @@ +## MODIFIED Requirements + +### Requirement: Every Mode-B formula surface substitutes variables + +`{var}` placeholders in a query's filters, measure formulas, computed-dimension expressions (string and object form) and order expressions SHALL be bound from the query's effective variables as literal values, never as text spliced into the expression. A placeholder inside a string literal, wholly or partly (`'{status}'`, `'%{q}%'`), SHALL contribute its value's text to that literal; a placeholder in a bare literal position SHALL take a number or boolean value, a numeric string reading as its number; a placeholder forming the whole parenthesised list of `IN` SHALL take a list value. `{{` and `}}` inside a string literal SHALL render literal braces, and a brace pair inside a string literal whose contents are only digits, commas and spaces (`'[0-9]{3}'`, `'{1, 2, 3}'`, `'{}'`) SHALL be literal text, not a placeholder. A query carrying placeholders on these surfaces SHALL construct successfully and SHALL execute with the bound values. + +#### Scenario: Measure formula + +- **WHEN** a query on `orders` has measure `sum(amount) * {k} / 100` and `variables={"k": 10}` +- **THEN** it executes and returns the total amount multiplied by 10 and divided by 100, by executed values on SQLite and DuckDB + +#### Scenario: Computed dimension in string and object form + +- **WHEN** a query has dimension `"amount * {k}"`, or dimension `{"expression": "amount * {k}"}`, with `variables={"k": 10}` +- **THEN** both construct and group by `amount * 10` + +#### Scenario: Order expression in colon and call form + +- **WHEN** a query orders by `sum(amount) * {k}` descending, with `variables={"k": -1}` +- **THEN** both construct and the rows come back in ascending total-amount order + +#### Scenario: Placeholder in operand positions + +- **WHEN** a placeholder appears as an aggregation argument (`sum({k})`), a transform argument, a scalar-function argument, a CASE branch, or the whole right-hand side of `in` (`region in ({regions})` with a list value) +- **THEN** the query constructs and executes with the substituted value + +#### Scenario: Quoted string value is escaped + +- **WHEN** a measure contains `'{name}'` inside a quoted literal and `variables={"name": "O'Brien"}` +- **THEN** the literal's value is `O'Brien` and the query executes without a parse error + +#### Scenario: Digit-and-comma braces in a string literal + +- **WHEN** a filter is `regexp_like(code, '^[a-z]{1,2}[0-9]{2,}$')`, `status = '{1, 2, 3}'` or `status = '{}'`, with or without variables +- **THEN** the braces stay in the literal and no variable is looked up diff --git a/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/tasks.md b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/tasks.md new file mode 100644 index 000000000..5fbba116a --- /dev/null +++ b/openspec/changes/dev-2120-portable-expression-library-strings-math-regex-json-coercion/tasks.md @@ -0,0 +1,62 @@ +## 1. Tracker records (pr-plan) + +- [x] 1.1 DEV-2120 body: point to this change and list the scope settled in planning (initcap dropped; TEXT side always DOUBLE; LIKE pattern language; regex `\n \t \r` and replacement `\\`; SQLite LIKE via GLOB, case-sensitive whatever the collation; `split_part` literal index; Postgres reference / out-of-domain NULL / version gating rules; JSON `db_type` at ingestion); verify by reading the issue + +## 2. Failing tests (pr-tests) + +- [x] 2.1 Registry-driven matrix `tests/test_dev2120_library_matrix.py`: one case table per library function and Mode-B operator; fails for any `SCALAR_SPECS` entry or operator without cases; executes on SQLite and DuckDB, emits on every Tier-1 dialect; verify it fails on the current code +- [x] 2.2 `queries/scalar-functions` scenarios, plus R2 boundaries: `asin` / `acos` at and beyond ±1, `div` by zero and every sign combination, `split_part` index 0 / negative / beyond range / non-literal, `chr` surrogates and > 0x10FFFF, all-NULL and every-NULL-position `greatest` / `least` (3+ args); each with a literal (plan-time error) and a column (NULL) argument; non-ASCII `é`, `€`, U+1F600; `initcap` unknown; `//` hint → `div` runs; verify failing +- [x] 2.3 `queries/regex` scenarios, plus trailing-newline probes for `^`, `$`, alternation and `'i'`; bracketed classes; variable patterns with bad constructs; replacement `$`, `&`, `\\`, `\1`–`\9`, group beyond the pattern; SQL Server 2022 / unknown-profile emission; verify failing +- [x] 2.4 `queries/json` scenarios, plus missing / JSON null / object / array / wrong type / unconvertible / genuine `0` and `false` for every `RETURNING` type; arrow-chain precedence and the bare `->` hint; aliases; ingestion → render for each native JSON form (Postgres json / jsonb, MySQL, DuckDB, BigQuery JSON, Snowflake VARIANT, ClickHouse JSON) and for a missing `db_type`; verify failing +- [x] 2.5 `queries/mixed-type-coercion` scenarios, plus `BETWEEN`, `IS DISTINCT FROM`, `greatest` with mixed args, `sum(text)` remedy names `TRY_CAST`, author `CAST` untouched, Postgres 15 / 16 / unknown emissions; verify failing +- [x] 2.6 `queries/string-matching` scenarios on every Tier-1 dialect (escaped `%` / `_`, literal `[`, lone backslash, column-valued pattern, GLOB metacharacters on SQLite, Mode-A LIKE unchanged on SQLite); verify failing +- [x] 2.7 `queries/date-functions` `date_trunc` scenarios (row value, dimension, order key, unknown unit, reserved name); verify failing +- [x] 2.8 Integration: the matrix case table runs live in each integration suite (Postgres, MySQL, ClickHouse, Trino, SQL Server parameterised 2022 / 2025, Snowflake, BigQuery); verify they run (skipping where the DB is absent) +- [x] 2.9 `queries/variables` digit-and-comma brace scenario and the regex name-shaped-brace hint scenario; verify failing +- [x] 2.10 Codex review of the tests against this change + +## 3. Parser and core syntax + +- [x] 3.1 Regex-pattern, LIKE-pattern and JSON-path parsers in `slayer/core/` (frozen Pydantic ASTs, cached, typed errors naming the construct); verify the parser-level tests in 2.3 / 2.4 / 2.6 +- [x] 3.2 Grammar (`slayer/core/syntax.py`): `~` / `~*` / `!~` / `!~*` → `regexp_like`; `->` / `->>` at the `||` level → `json_value` (bare `->` hint); `RETURNING` → `TRY_CAST` over `json_value`; JSON aliases; `date_trunc` → granularity call; `strpos` → `instr`; verify the parse tests +- [x] 3.3 `SCALAR_SPECS` entries for every new function with arity and result-type rules; `initcap` absent; verify `tests/test_dev1737_scalar_specs.py` and 2.1's registry check +- [x] 3.4 Variable substitution: a brace pair inside a string literal holding only digits, commas and spaces stays text; the undefined-variable error from a regex pattern argument adds the `{{` / `}}` hint; verify 2.9 + +## 4. Binding and checker + +- [x] 4.1 Plan-time validation: patterns, replacements, paths, `regexp_extract` group, `split_part` index, literal out-of-domain arguments; variable-supplied patterns named in errors; verify 2.2–2.4 error scenarios +- [x] 4.2 Coercion (design D4): checker wraps TEXT operands in `TRY_CAST(… AS DOUBLE)`, converts TEXT literals or raises; `sum` / `abs` over TEXT remedies name `TRY_CAST`; verify 2.5 +- [x] 4.3 `json_value` accepts opaque JSON-family columns; verify 2.4 typing scenarios + +## 5. Dialect lowerings + +- [x] 5.1 Typed function-family hooks in `SqlDialect` and `render_scalar_call` dispatch (design D1); string and math lowerings with domain guards (D6) per dialect; verify 2.2 on SQLite / DuckDB and emissions +- [x] 5.2 `greatest` / `least` coalesce form on NULL-propagating engines (D7); verify 2.2 +- [x] 5.3 Regex flavour records and the shared emitter (D2); per-dialect function lowerings incl. SQL Server `REGEXP_INSTR(…) > 0`, Snowflake `REGEXP_INSTR`, DuckDB extract `''` → NULL, Postgres `'g'`; verify 2.3 +- [x] 5.4 JSON lowerings per dialect and input form (D3, D10), typed `RETURNING` native pairs; verify 2.4 +- [x] 5.5 `build_like` hook (D9): `ESCAPE '\'`, ClickHouse / BigQuery native escapes, SQL Server `[` bracketing incl. column patterns, `ILIKE` fallback; verify 2.6 +- [x] 5.6 SQLite registered functions (D8): regex trio, `slayer_like_glob`, any missing string functions; `LIKE` → `GLOB`, `ILIKE` → native `LIKE`; verify 2.3 / 2.6 on SQLite +- [x] 5.7 Server-profile predicate generalised (D5); SQL Server `server_profile_sql` / `parse_server_profile`; version errors for regex and `greatest` / `least`; verify 2.2 / 2.3 version scenarios +- [x] 5.8 BigQuery TIMESTAMP is DATETIME; zoned `TIMESTAMP` columns keep `db_type` and compare through a cast of the other side (D13) +- [x] 5.9 `starts_with` / `ends_with` / `contains` / `strpos` / `split_part` / `replace` compare binary on MySQL (`BINARY`) and SQL Server (`COLLATE Latin1_General_100_BIN2`); verify emissions +- [x] 5.10 A zoned BigQuery column reads as DATETIME outside direct comparison operands (D13); BOOLEAN in `||` / `concat` / `concat_ws` rejected at plan time; `concat_ws` converts numbers to TEXT + +## 6. Ingestion + +- [x] 6.1 Keep `db_type` for JSON-family types across inspectors (Postgres, MySQL, DuckDB, BigQuery, Snowflake, ClickHouse); verify 2.4 ingestion scenarios and the ingestion suites + +## 7. Architecture + +- [x] 7.1 Apply the approved edit: `architecture/system.arc42.md` principle 10, tag after "Every Mode B construct means the same on every dialect." `[target: DEV-2120]` → `[enforced: test:tests/test_dev2120_library_matrix.py]`; verify `la-arch-check` + +## 8. Docs, agent surfaces, comparison + +- [x] 8.1 `docs/concepts/references.md` (scalar library table, regex / JSON / coercion / collation / LIKE sections, remove the `greatest` / `least` caveat, SQLite LIKE exception, 2^53 note, Postgres 16 / SQL Server 2022 / 2025 requirements), `formulas.md`, `queries.md` (filters); verify `grep` finds no remaining "backend-specific" caveat left unaddressed +- [x] 8.2 MCP `Field` descriptions and `slayer/memories/help_content/*`; verify `tests/test_mcp_surface_budget.py` and the documented-idioms tests +- [x] 8.3 `examples/comparisons/probes.yaml` `C9-slayer-*` probes (regex, strings, JSON, TRY_CAST, greatest / least); C9 SLayer verdict → yes with the Postgres 16+ / SQL Server 2025+ caveat in `matrix.yaml`; regenerate `matrix.json`; verify the comparison tooling's checks +- [x] 8.4 Release-notes draft (untracked, never staged): `greatest` / `least` NULLs; SQLite LIKE case; LIKE `\` / `[`; TEXT vs number; SQL Server version errors; no `initcap`; ClickHouse JSON columns need re-ingest + +## 9. Gates + +- [ ] 9.1 `poetry run pytest -m "not integration"`, the CI integration invocation, `poetry run ruff check slayer/ tests/`, `poetry run basedpyright` (no new errors vs baseline), `la-arch-check`; verify all green +- [ ] 9.2 pr-review gate: the PR's Snowflake and BigQuery suites executed (not skipped) before C9 = yes is accepted; verify in the PR's check logs diff --git a/openspec/specs/models/join-traversal/spec.md b/openspec/specs/models/join-traversal/spec.md index e38ba9081..316c0ba0c 100644 --- a/openspec/specs/models/join-traversal/spec.md +++ b/openspec/specs/models/join-traversal/spec.md @@ -323,3 +323,15 @@ directed cycle SHALL fail closed when every candidate root is blocked by a fanni #### Scenario: Rootless query across a directed 3-cycle fails closed - **WHEN** a query without `source_model` selects `x.v`, `y.v` and `z.v` over `x → y → z → x` - **THEN** it fails with the no-viable-candidate error, and succeeds once `source_model` is given + +### Requirement: An extension join repeating a stored edge is that edge + +A query-level model extension's join that equals one of its base model's stored joins in every field except `description`, `meta` and pair order SHALL be that stored edge, applied once, for every model kind; an extension join differing in target, name, join type, cardinality or join pairs SHALL remain a separate edge. + +#### Scenario: Repeating a stored join in an extension +- **WHEN** an extension over a table-backed model repeats a stored join and a query reads through it +- **THEN** the query resolves over that single edge instead of failing as an ambiguous hop + +#### Scenario: A differing extension join stays parallel +- **WHEN** an extension adds an unnamed join to the same target with different join pairs +- **THEN** a bare hop to that target fails closed as ambiguous diff --git a/openspec/specs/queries/query-backed-inline/spec.md b/openspec/specs/queries/query-backed-inline/spec.md index c6ef3fadc..ee0a946ff 100644 --- a/openspec/specs/queries/query-backed-inline/spec.md +++ b/openspec/specs/queries/query-backed-inline/spec.md @@ -123,3 +123,35 @@ cycle. A planning failure unrelated to a cycle SHALL keep its own error. #### Scenario: Direct and transitive cycles - **WHEN** `A` consumes `A`, or `A` consumes `B` which consumes `A`, and a consumer of `A` executes, `A` runs by name, `A` is saved, or `A`'s column types are requested - **THEN** each raises the same cycle error naming the path + +### Requirement: Saved relation relationships survive splicing + +A stored query-backed model consumed as a relation SHALL retain that model's own declared joins, with keys resolved against its final-stage output columns. Those relationships SHALL remain available when the relation is a source, a join target or an extended source. Ordinary query-stage outputs SHALL remain flat and SHALL NOT inherit joins from their backing source. + +#### Scenario: Joined segment filter on a saved relation +- **WHEN** a saved customer-total relation declares a customer-key join and a query filters to gold customers +- **THEN** only the related gold customers contribute, with the same values as an equivalent relationship declared solely on a query extension, on SQLite and DuckDB + +#### Scenario: Joined dimensions and aggregate attribution +- **WHEN** a query reads a dimension or aggregate through a saved relation's declared join +- **THEN** the relationship determines the rows and attribution instead of being treated as an unrelated dataset + +#### Scenario: A saved relation consumed through another model +- **WHEN** another model joins a saved query-backed relation and a query traverses onward through that relation's own join +- **THEN** the declared relationships remain available with logical key spelling and correct values + +#### Scenario: Extending a saved relation +- **WHEN** a query extension adds a distinct named join to a saved relation +- **THEN** both its stored joins and the extension's joins remain available + +#### Scenario: Repeating an existing saved relationship +- **WHEN** an extension over a saved query-backed relation repeats an exactly identical declared join +- **THEN** that edge is applied once, without introducing an ambiguous parallel path + +#### Scenario: Legal join targets do not collide with temporary identities +- **WHEN** a saved relation declares a join to a legal model named `_stage` +- **THEN** both unjoined and joined consumers execute without a false self-join error + +#### Scenario: Ordinary stage isolation +- **WHEN** an ordinary query stage is consumed by a later stage +- **THEN** only its projected output schema is visible and its backing source's joins are not inherited diff --git a/pyproject.toml b/pyproject.toml index 6547e3a00..99d7dd027 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "motley-slayer" -version = "1.4.0" +version = "1.4.1" description = "A lightweight, agent-first semantic layer for AI agents" requires-python = ">=3.11" license = "MIT" diff --git a/slayer/core/errors.py b/slayer/core/errors.py index b5c9f1fb4..c76c4d480 100644 --- a/slayer/core/errors.py +++ b/slayer/core/errors.py @@ -415,6 +415,20 @@ class AggregationFilterError(QueryTypeError): """A ``FILTER (WHERE …)`` condition that is not a row-level predicate of its aggregation.""" +class ScalarArgumentError(QueryTypeError): + """A scalar function argument outside its contract: a pattern, path, flag or index the library does not + take, or a literal outside the function's domain.""" + + +class ScalarOperandTypeError(QueryTypeError): + """A scalar function or operator over an operand of a type it does not read (a number function over TEXT, + a JSON read of a non-JSON value, a TEXT literal that is not a number beside a number).""" + + +class ServerVersionError(QueryTypeError): + """A function the connected server's version does not provide.""" + + class UnreachableDefinitionError(SlayerError, ValueError): """A stored ``Column.sql`` / ``Column.filter`` / model filter naming a dataset no join path reaches from its model.""" @@ -710,6 +724,10 @@ def __init__(self, chain: List[str]) -> None: )) +class VariableError(SlayerError): + """A ``{name}`` placeholder whose name is invalid or whose variable is undefined.""" + + class UnresolvedPlaceholderError(SlayerError): """A ``{name}`` placeholder reached binding unsubstituted.""" diff --git a/slayer/core/join_edges.py b/slayer/core/join_edges.py index 7567408da..69ee07eb5 100644 --- a/slayer/core/join_edges.py +++ b/slayer/core/join_edges.py @@ -18,6 +18,7 @@ "relationship_signature", "resolve_join_ref", "resolve_join_refs", + "same_edge", "without_joins", ] @@ -58,6 +59,15 @@ def _pair_set(pairs: list[list[str]]) -> frozenset[tuple[str, str]]: return frozenset((p[0], p[1]) for p in pairs) +def same_edge(a: ModelJoin, b: ModelJoin) -> bool: + """Whether two declarations on one model are one edge: equal in all but metadata and pair order.""" + return ( + (a.target_model, a.name, a.join_type, a.cardinality) + == (b.target_model, b.name, b.join_type, b.cardinality) + and _pair_set(a.join_pairs) == _pair_set(b.join_pairs) + ) + + def _joins_to(model: SlayerModel, target: str) -> list[ModelJoin]: return [j for j in model.joins if j.target_model == target] diff --git a/slayer/core/join_walker.py b/slayer/core/join_walker.py index c486acc0f..fbc97aad0 100644 --- a/slayer/core/join_walker.py +++ b/slayer/core/join_walker.py @@ -23,14 +23,14 @@ from contextlib import contextmanager from contextvars import ContextVar -from typing import Dict, Iterable, Iterator, Literal, Optional, Sequence +from typing import Callable, Dict, Iterable, Iterator, Literal, Optional, Sequence from pydantic import BaseModel, ConfigDict from slayer.core.enums import DataType, JoinCardinality, JoinType, invert_cardinality from slayer.core.errors import AmbiguousJoinPathError, CircularJoinPathError from slayer.core.keys import ColumnKey, ColumnSqlKey, ColumnTypeFn, ValueKey, source_anchor_path -from slayer.core.models import ModelJoin, SlayerModel, is_key_set_unique, join_key_error +from slayer.core.models import Column, ModelJoin, SlayerModel, is_key_set_unique, join_key_error from slayer.core.time_spine import PRODUCT_JOIN_TYPE, TIME_SPINE_MODEL, axis_column, is_spine, spine_joins __all__ = [ @@ -640,9 +640,11 @@ def resolved_terminal( return _terminal(root=root, path=path, models_by_name=models_by_name, revisits=True) -def model_column_type(*, model: SlayerModel, models_by_name: dict[str, SlayerModel]) -> ColumnTypeFn: - """Declared types of column leaves rooted at ``model``; ``None`` for anything unresolvable.""" - def column_type(key: ValueKey) -> Optional[DataType]: +def model_column_lookup( + *, model: SlayerModel, models_by_name: dict[str, SlayerModel], +) -> Callable[[object], Optional[Column]]: + """The declared ``Column`` of a column leaf rooted at ``model``; ``None`` for anything unresolvable.""" + def lookup(key: object) -> Optional[Column]: if isinstance(key, ColumnSqlKey): owner = model if key.model == model.name else models_by_name.get(key.model) leaf = key.column_name @@ -651,7 +653,16 @@ def column_type(key: ValueKey) -> Optional[DataType]: leaf = key.leaf else: return None - col = owner.get_column(leaf) if owner is not None else None + return owner.get_column(leaf) if owner is not None else None + return lookup + + +def model_column_type(*, model: SlayerModel, models_by_name: dict[str, SlayerModel]) -> ColumnTypeFn: + """Declared types of column leaves rooted at ``model``; ``None`` for anything unresolvable.""" + lookup = model_column_lookup(model=model, models_by_name=models_by_name) + + def column_type(key: ValueKey) -> Optional[DataType]: + col = lookup(key) return col.type if col is not None else None return column_type diff --git a/slayer/core/json_path.py b/slayer/core/json_path.py new file mode 100644 index 000000000..70ff9490f --- /dev/null +++ b/slayer/core/json_path.py @@ -0,0 +1,127 @@ +"""The portable JSON path subset: ``$`` then ``.key``, ``."quoted key"`` and ``[n]`` steps.""" + +from __future__ import annotations + +import re +from functools import lru_cache + +from pydantic import BaseModel, ConfigDict + +_KEY_RE = re.compile(r"[A-Za-z_]\w*", re.ASCII) +_CONTROL_RE = re.compile(r"[\x00-\x1f\x7f]") +_MODE_WORDS = ("lax", "strict") + + +class JsonPathError(ValueError): + """A path outside the portable subset; ``construct`` names the offending part.""" + + def __init__(self, construct: str) -> None: + self.construct = construct + super().__init__(f"{construct} is not in the portable JSON path subset") + + +class JsonPath(BaseModel): + """Object keys (``str``) and array indices (``int``), outermost first.""" + + model_config = ConfigDict(frozen=True) + + steps: tuple[str | int, ...] + + @property + def text(self) -> str: + """The canonical path text.""" + return json_path_text(self.steps) + + +def json_path_text(steps: tuple[str | int, ...]) -> str: + """``$`` plus each step: ``.key`` for a plain key, ``."key"`` for any other, ``[n]`` for an index.""" + out = ["$"] + for step in steps: + if isinstance(step, int): + out.append(f"[{step}]") + elif _KEY_RE.fullmatch(step): + out.append(f".{step}") + else: + out.append(f'."{step}"') + return "".join(out) + + +def check_key(key: str) -> str: + """``key`` when the subset can spell it (no double quote, backslash or control character).""" + if '"' in key or "\\" in key: + raise JsonPathError(f"the key {key!r} with a double quote or backslash") + if _CONTROL_RE.search(key): + raise JsonPathError(f"the key {key!r} with a control character") + return key + + +class _Reader: + def __init__(self, text: str) -> None: + self.text = text + self.pos = 0 + + def peek(self) -> str: + return self.text[self.pos] if self.pos < len(self.text) else "" + + def steps(self) -> tuple[str | int, ...]: + out: list = [] + while self.pos < len(self.text): + ch = self.peek() + if ch == ".": + out.append(self.member()) + elif ch == "[": + out.append(self.index()) + else: + raise JsonPathError(f"the text {self.text[self.pos:]!r} after a step") + return tuple(out) + + def member(self) -> str: + self.pos += 1 + ch = self.peek() + if ch == ".": + raise JsonPathError("the recursive descent '..'") + if ch == "*": + raise JsonPathError("the wildcard '*'") + if ch == '"': + end = self.text.find('"', self.pos + 1) + if end < 0: + raise JsonPathError('the unterminated quote \'"\' of a quoted key') + key = self.text[self.pos + 1:end] + self.pos = end + 1 + return check_key(key) + match = _KEY_RE.match(self.text, self.pos) + if match is None: + raise JsonPathError(f"the member step '.{self.text[self.pos:self.pos + 8]}' (quote the key: .\"…\")") + self.pos = match.end() + return match.group(0) + + def index(self) -> int: + end = self.text.find("]", self.pos) + body = self.text[self.pos + 1:end] if end > 0 else self.text[self.pos + 1:] + stripped = body.strip() + if stripped == "*": + raise JsonPathError("the wildcard '[*]'") + if stripped.startswith("?"): + raise JsonPathError("the filter expression '[?…]'") + if stripped.startswith(("'", '"')): + raise JsonPathError("the bracket key '[...]' (write .key or .\"key\")") + if stripped.startswith("-") and stripped[1:].isdigit(): + raise JsonPathError(f"the negative index '[{stripped}]'") + if end < 0 or not stripped.isdigit(): + raise JsonPathError(f"the array index '[{body}]' (an index is a non-negative integer)") + self.pos = end + 1 + return int(stripped) + + +@lru_cache(maxsize=4096) +def parse_json_path(text: str) -> JsonPath: + """``text`` as a portable path; ``JsonPathError`` names the first construct outside the subset.""" + head = text.strip().split(" ", 1)[0].lower() if text.strip() else "" + if head in _MODE_WORDS: + raise JsonPathError(f"the path mode word '{head}'") + if not text.startswith("$"): + raise JsonPathError("a path not starting with '$'") + return JsonPath(steps=_Reader(text[1:]).steps()) + + +__all__ = ["JsonPath", "JsonPathError", "check_key", "json_path_text", "parse_json_path"] diff --git a/slayer/core/keys.py b/slayer/core/keys.py index dd0ebeea3..339b03dce 100644 --- a/slayer/core/keys.py +++ b/slayer/core/keys.py @@ -59,39 +59,68 @@ class ScalarSpec(BaseModel, frozen=True): """One allowlisted Mode-B scalar: accepted argument counts (``max_args=None`` - is variadic) and whether its call is literally the same SQL function.""" + is variadic), whether its call is literally the same SQL function, its fixed + result type (``None``: one of its value arguments' types) and whether it reads + every argument as a number.""" min_args: int max_args: Optional[int] = None sql_passthrough: bool = True + result: Optional[DataType] = None + numeric: bool = False -def _spec(low: int, high: Optional[int], *, sql: bool = True) -> ScalarSpec: - return ScalarSpec(min_args=low, max_args=high, sql_passthrough=sql) +def _spec( + low: int, high: Optional[int], *, sql: bool = True, result: Optional[DataType] = None, numeric: bool = False, +) -> ScalarSpec: + return ScalarSpec(min_args=low, max_args=high, sql_passthrough=sql, result=result, numeric=numeric) + + +_TEXT, _BOOL, _INT, _DOUBLE = DataType.TEXT, DataType.BOOLEAN, DataType.INT, DataType.DOUBLE + + +def _library(low: int, high: Optional[int], *, result: Optional[DataType] = None, numeric: bool = False) -> ScalarSpec: + """A library function: the same-named SQL function, lowered per dialect to its one meaning.""" + return _spec(low, high, result=result, numeric=numeric) # The one canonical Mode-B scalar allowlist (C12); every other scalar set derives # from it. Arity is enforced because sqlglot silently mis-handles wrong-arity calls. SCALAR_SPECS: Mapping[str, ScalarSpec] = MappingProxyType({ "nullif": _spec(2, 2), "coalesce": _spec(1, None), "ifnull": _spec(2, 2), - "ln": _spec(1, 1), "log10": _spec(1, 1), "log2": _spec(1, 1), "log": _spec(1, 2), - "exp": _spec(1, 1), "sqrt": _spec(1, 1), "pow": _spec(2, 2), "power": _spec(2, 2), - "abs": _spec(1, 1), "floor": _spec(1, 1), "ceil": _spec(1, 1), "round": _spec(1, 2), - "ceiling": _spec(1, 1), "sign": _spec(1, 1), - "trunc": _spec(1, 1), # 2-arg form silently drops digits on SQLite - "mod": _spec(2, 2), - # Scalar min/max; min two args because 1-arg MAX/MIN parse as the aggregate on SQLite. - "greatest": _spec(2, None), "least": _spec(2, None), - "lower": _spec(1, 1), "upper": _spec(1, 1), "trim": _spec(1, 1), "length": _spec(1, 1), + "ln": _spec(1, 1, numeric=True), "log10": _spec(1, 1, numeric=True), "log2": _spec(1, 1, numeric=True), + "log": _spec(1, 2, numeric=True), "exp": _spec(1, 1, numeric=True), "sqrt": _spec(1, 1, numeric=True), + "pow": _spec(2, 2, numeric=True), "power": _spec(2, 2, numeric=True), + "abs": _spec(1, 1, numeric=True), "floor": _spec(1, 1, numeric=True), "ceil": _spec(1, 1, numeric=True), + "round": _spec(1, 2, numeric=True), "ceiling": _spec(1, 1, numeric=True), "sign": _spec(1, 1, numeric=True), + "trunc": _spec(1, 1, numeric=True), # 2-arg form silently drops digits on SQLite + "mod": _spec(2, 2, numeric=True), + # Scalar min/max, NULLs ignored; min two args because 1-arg MAX/MIN parse as the aggregate on SQLite. + "greatest": _library(2, None), "least": _library(2, None), + "lower": _spec(1, 1, result=_TEXT), "upper": _spec(1, 1, result=_TEXT), "trim": _spec(1, 1, result=_TEXT), + "length": _spec(1, 1, result=_INT), # Trims take the string only; 2-arg strip-set form deferred (DEV-1793). - "ltrim": _spec(1, 1), "rtrim": _spec(1, 1), - "replace": _spec(3, 3), "substr": _spec(2, 3), "substring": _spec(2, 3), "instr": _spec(2, 2), - "concat": _spec(1, None), - "like": _spec(2, 2, sql=False), # emits the LIKE operator - "ilike": _spec(2, 2, sql=False), # case-insensitive LIKE on every dialect + "ltrim": _spec(1, 1, result=_TEXT), "rtrim": _spec(1, 1, result=_TEXT), + "replace": _spec(3, 3, result=_TEXT), "substr": _spec(2, 3, result=_TEXT), + "substring": _spec(2, 3, result=_TEXT), "instr": _spec(2, 2, result=_INT), + "concat": _spec(1, None, result=_TEXT), + "left": _library(2, 2, result=_TEXT), "right": _library(2, 2, result=_TEXT), + "starts_with": _library(2, 2, result=_BOOL), "ends_with": _library(2, 2, result=_BOOL), + "contains": _library(2, 2, result=_BOOL), + "lpad": _library(2, 3, result=_TEXT), "rpad": _library(2, 3, result=_TEXT), + "reverse": _library(1, 1, result=_TEXT), "repeat": _library(2, 2, result=_TEXT), + "split_part": _library(3, 3, result=_TEXT), "concat_ws": _library(2, None, result=_TEXT), + "chr": _library(1, 1, result=_TEXT), "ascii": _library(1, 1, result=_INT), + "div": _library(2, 2, numeric=True), "pi": _library(0, 0, result=_DOUBLE), + **{name: _library(1, 1, result=_DOUBLE, numeric=True) for name in ("sin", "cos", "tan", "asin", "acos", "atan")}, + "atan2": _library(2, 2, result=_DOUBLE, numeric=True), "cbrt": _library(1, 1, result=_DOUBLE, numeric=True), + "regexp_like": _library(2, 3, result=_BOOL), "regexp_extract": _library(2, 3, result=_TEXT), + "regexp_replace": _library(3, 4, result=_TEXT), "json_value": _library(2, 2, result=_TEXT), + "like": _spec(2, 2, sql=False, result=_BOOL), # emits the LIKE operator + "ilike": _spec(2, 2, sql=False, result=_BOOL), # case-insensitive LIKE on every dialect "iif": _spec(3, 3, sql=False), # emits CASE WHEN - "date_part": _spec(2, 2, sql=False), - "date_diff": _spec(3, 3, sql=False), + "date_part": _spec(2, 2, sql=False, result=_INT), + "date_diff": _spec(3, 3, sql=False, result=_INT), "date_add": _spec(3, 3, sql=False), "interval": _spec(2, 2, sql=False), # parse-time spelling of date_add "current_date": _spec(0, 0, sql=False), @@ -99,6 +128,16 @@ def _spec(low: int, high: Optional[int], *, sql: bool = True) -> ScalarSpec: }) SCALAR_FUNCTIONS: frozenset[str] = frozenset(SCALAR_SPECS) +# Names the parser rewrites into a library call or the granularity call; reserved like the functions. +SCALAR_SPELLINGS: frozenset[str] = frozenset({ + "strpos", "date_trunc", "json_extract", "json_extract_scalar", "json_extract_path_text", + "jsonb_extract_path_text", +}) +RESERVED_SCALAR_NAMES: frozenset[str] = SCALAR_FUNCTIONS | SCALAR_SPELLINGS +TEXT_RESULT_SCALARS: frozenset[str] = frozenset(n for n, s in SCALAR_SPECS.items() if s.result is DataType.TEXT) +BOOLEAN_RESULT_SCALARS: frozenset[str] = frozenset(n for n, s in SCALAR_SPECS.items() if s.result is DataType.BOOLEAN) +# Scalars that read every argument as a number. +NUMERIC_ARG_SCALARS: frozenset[str] = frozenset(n for n, s in SCALAR_SPECS.items() if s.numeric) SCALAR_FUNCTION_ARITY: dict[str, tuple[int, Optional[int]]] = { name: (spec.min_args, spec.max_args) for name, spec in SCALAR_SPECS.items() } @@ -1351,7 +1390,7 @@ def boolean_valued(key: object, *, column_type: ColumnTypeFn) -> bool: def _scalar_boolean_valued(key: ScalarCallKey, *, column_type: ColumnTypeFn) -> bool: - if key.name in ("like", "ilike"): + if key.name in BOOLEAN_RESULT_SCALARS: return True if key.name not in _BOOLEAN_BRANCH_SCALARS: return False @@ -1361,11 +1400,6 @@ def _scalar_boolean_valued(key: ScalarCallKey, *, column_type: ColumnTypeFn) -> return bool(branches) and all(boolean_valued(a, column_type=column_type) for a in branches) -# Scalars that read every argument as a number. -_NUMERIC_SCALARS = frozenset({ - "ln", "log10", "log2", "log", "exp", "sqrt", "pow", "power", "abs", "floor", "ceil", "ceiling", - "round", "sign", "trunc", "mod", -}) # Integer-preserving operators and scalars, for typing an expression built from booleans. _INT_OPS = frozenset({"+", "-", "*", "%"}) _INT_SCALARS = frozenset({"abs", "sign", "round", "floor", "ceil", "ceiling", "trunc", "mod"}) @@ -1387,7 +1421,9 @@ def _is_int_literal(arg: object) -> bool: # Scalars whose result is always a number. -_NUMBER_RESULT_SCALARS = _NUMERIC_SCALARS | {"length", "instr", "date_part", "date_diff"} +_NUMBER_RESULT_SCALARS = NUMERIC_ARG_SCALARS | frozenset( + n for n, s in SCALAR_SPECS.items() if s.result in _NUMERIC_TYPES +) # Transforms whose result is always a number. _NUMBER_RESULT_TRANSFORMS = frozenset({*RANK_FAMILY_TRANSFORMS, "consecutive_periods"}) @@ -1422,6 +1458,45 @@ def _scalar_numeric_valued(key: ScalarCallKey, *, column_type: ColumnTypeFn) -> return any(numbers) and all(n or boolean_valued(a, column_type=column_type) for a, n in zip(branches, numbers)) +_INTEGER_RESULT_AGGS = frozenset({"count", "count_distinct", "count_distinct_approx"}) + + +def integer_valued(key: object, *, column_type: ColumnTypeFn) -> bool: + """Whether ``key``'s value is certainly an integer (booleans read as 0 / 1 count).""" + if _is_int_literal(key) or boolean_valued(key, column_type=column_type): + return True + if isinstance(key, (ColumnKey, ColumnSqlKey)): + return column_type(key) is DataType.INT + if isinstance(key, CastKey): + return key.data_type is DataType.INT + if isinstance(key, ArithmeticKey): + return key.op in _INT_OPS and all(integer_valued(o, column_type=column_type) for o in key.operands) + if isinstance(key, AggregateKey): + return _aggregate_integer_valued(key, column_type=column_type) + if isinstance(key, ScalarCallKey): + return _scalar_integer_valued(key, column_type=column_type) + return False + + +def _aggregate_integer_valued(key: AggregateKey, *, column_type: ColumnTypeFn) -> bool: + agg = key.agg.lower() + return agg in _INTEGER_RESULT_AGGS or ( + agg in ("sum", "min", "max", "first", "last") and integer_valued(key.source, column_type=column_type) + ) + + +def _scalar_integer_valued(key: ScalarCallKey, *, column_type: ColumnTypeFn) -> bool: + spec = SCALAR_SPECS.get(key.name) + if spec is not None and spec.result is DataType.INT: + return True + if key.name not in _INT_SCALARS and key.name not in _VALUE_ARG_SCALARS: + return False + if key.name == "round" and len(key.args) > 1: + return False + values = [a for a in key.args if not _is_null_arg(a)] + return bool(values) and all(integer_valued(a, column_type=column_type) for a in values) + + def _boolean_positions( children: Sequence[object], positions: Iterable[int], *, column_type: ColumnTypeFn, ) -> FrozenSet[int]: @@ -1440,7 +1515,7 @@ def _arithmetic_numeric_booleans(key: ArithmeticKey, *, column_type: ColumnTypeF def _scalar_numeric_booleans(key: ScalarCallKey, *, column_type: ColumnTypeFn) -> FrozenSet[int]: - if key.name in _NUMERIC_SCALARS: + if key.name in NUMERIC_ARG_SCALARS: return _boolean_positions(key.args, range(len(key.args)), column_type=column_type) if key.name in _BOOLEAN_BRANCH_SCALARS and not boolean_valued(key, column_type=column_type): positions = _BOOLEAN_BRANCH_SCALARS[key.name] diff --git a/slayer/core/like_pattern.py b/slayer/core/like_pattern.py new file mode 100644 index 000000000..287b12a84 --- /dev/null +++ b/slayer/core/like_pattern.py @@ -0,0 +1,53 @@ +"""The one LIKE pattern language: ``%`` / ``_`` wildcards, ``\\`` escaping ``%``, ``_`` and itself, all else literal.""" + +from __future__ import annotations + +from functools import lru_cache +from typing import Literal + +from pydantic import BaseModel, ConfigDict + +LIKE_SPECIALS = frozenset("%_\\") + + +class LikeWildcard(BaseModel): + model_config = ConfigDict(frozen=True) + + #: ``any``: ``%`` (any run of characters); ``one``: ``_`` (exactly one). + kind: Literal["any", "one"] + + +class LikePattern(BaseModel): + """Literal text runs and wildcards, in order.""" + + model_config = ConfigDict(frozen=True) + + parts: tuple[str | LikeWildcard, ...] + + +@lru_cache(maxsize=4096) +def parse_like(text: str) -> LikePattern: + """``text`` read in the LIKE pattern language (every string is a valid pattern).""" + parts: list = [] + literal: list = [] + i = 0 + while i < len(text): + ch = text[i] + if ch == "\\" and i + 1 < len(text) and text[i + 1] in LIKE_SPECIALS: + literal.append(text[i + 1]) + i += 2 + continue + if ch in "%_": + if literal: + parts.append("".join(literal)) + literal = [] + parts.append(LikeWildcard(kind="any" if ch == "%" else "one")) + else: + literal.append(ch) + i += 1 + if literal: + parts.append("".join(literal)) + return LikePattern(parts=tuple(parts)) + + +__all__ = ["LIKE_SPECIALS", "LikePattern", "LikeWildcard", "parse_like"] diff --git a/slayer/core/models.py b/slayer/core/models.py index 48cb8119b..3c5d3bfdd 100644 --- a/slayer/core/models.py +++ b/slayer/core/models.py @@ -19,7 +19,7 @@ from slayer.core.errors import GranularityDefinitionError, JoinKeyError from slayer.core.format import NumberFormat from slayer.core.granularity import CustomGranularity, GranularitySpec, definition_error, granularity_key -from slayer.core.keys import SCALAR_FUNCTIONS +from slayer.core.keys import RESERVED_SCALAR_NAMES from slayer.core.refs import IDENTIFIER_RE from slayer.sql.dialects import dialect_for_ds_type from slayer.sql.sql_predicate import parse_sql_predicate @@ -452,11 +452,11 @@ def _reject_transform_names(self) -> "Aggregation": # form (``round(x)`` must stay the scalar call), so every legal # aggregation stays reachable as ``agg(col)``. Case-insensitive to # match the parser's scalar dispatch. - if self.name.lower() in SCALAR_FUNCTIONS: + if self.name.lower() in RESERVED_SCALAR_NAMES: raise ValueError( f"Aggregation name '{self.name}' conflicts with a scalar " f"function. Scalar-allowlist names are reserved: " - f"{', '.join(sorted(SCALAR_FUNCTIONS))}" + f"{', '.join(sorted(RESERVED_SCALAR_NAMES))}" ) if self.name.lower() in RESERVED_DATE_SYNTAX_NAMES: raise ValueError( @@ -1087,7 +1087,7 @@ def resolve_env_vars(self) -> "DatasourceConfig": def _reserved_granularity_names() -> dict[str, str]: """Names a custom granularity may not take, lowercased, with the kind they belong to.""" - out: dict[str, str] = dict.fromkeys(SCALAR_FUNCTIONS, "Mode-B function") + out: dict[str, str] = dict.fromkeys(RESERVED_SCALAR_NAMES, "Mode-B function") out.update(dict.fromkeys(RESERVED_DATE_SYNTAX_NAMES, "Mode-B date function")) out.update(dict.fromkeys(ALL_TRANSFORMS, "transform")) out.update(dict.fromkeys(BUILTIN_AGGREGATIONS, "aggregation")) diff --git a/slayer/core/query.py b/slayer/core/query.py index a165ebe68..f5caf7042 100644 --- a/slayer/core/query.py +++ b/slayer/core/query.py @@ -24,7 +24,7 @@ from slayer.core.direction import normalize_direction from slayer.core.enums import BUILTIN_AGGREGATIONS, GRANULARITY_NAMES, TimeGranularity, normalize_aggregation_name, ALL_TRANSFORMS -from slayer.core.keys import SCALAR_FUNCTIONS +from slayer.core.keys import RESERVED_SCALAR_NAMES from slayer.core.errors import DistinctDimensionValuesError, GranularityCallError, RefinementConflictError from slayer.core.granularity import GranularitySpec, granularity_key from slayer.core.models import ( @@ -904,7 +904,7 @@ def _may_name_datasource_granularity(entry: str) -> bool: return False name = callee.lower() return not ( - name in GRANULARITY_NAMES or name in SCALAR_FUNCTIONS or name in ALL_TRANSFORMS + name in GRANULARITY_NAMES or name in RESERVED_SCALAR_NAMES or name in ALL_TRANSFORMS or normalize_aggregation_name(callee) in BUILTIN_AGGREGATIONS ) @@ -1254,8 +1254,9 @@ def _validate_query_name(cls, v: str | None) -> str | None: description=( "Conditions, AND-ed; each routes automatically to row filtering (WHERE), aggregate " "filtering (HAVING) or filtering after transforms. SQL operators: = <> < <= > >=, in, " - "between, like / ilike, is null / is not null, and / or / not; strings are " - "single-quoted ('paid'); build them from the column's sampled values.\n" + "between, like / ilike, is null / is not null, and / or / not, regex x ~ '^A[0-9]{3}', " + "JSON payload ->> 'key'; strings are single-quoted ('paid'); build them from the " + "column's sampled values.\n" "- Aggregates and transforms filter too, by formula or by a measure's name: " "sum(amount) > 100; top N per group: " "rank(sum(amount), partition_by=customers.regions.name, direction='desc') <= 1.\n" diff --git a/slayer/core/regex_pattern.py b/slayer/core/regex_pattern.py new file mode 100644 index 000000000..81bef2650 --- /dev/null +++ b/slayer/core/regex_pattern.py @@ -0,0 +1,332 @@ +"""The portable regex subset: pattern and replacement syntax, parsed once and re-emitted per dialect.""" + +from __future__ import annotations + +from functools import lru_cache +from typing import Literal + +from pydantic import BaseModel, ConfigDict + +#: The largest repetition count every dialect accepts (Postgres's ``RE_DUP_MAX``). +MAX_REPEAT = 255 +#: Characters a backslash makes literal. +_PUNCTUATION = frozenset("\\.[](){}*+?^$|/-!\"#%&',:;<=>@_`~") +_CONTROL_ESCAPES = {"n": "\n", "t": "\t", "r": "\r"} +_CLASS_ESCAPES = frozenset("dws") +_LETTER_ESCAPES = { + "b": "the word boundary '\\b'", "B": "the non-word-boundary '\\B'", + "p": "the Unicode property '\\p'", "P": "the Unicode property '\\P'", + "A": "the anchor '\\A'", "z": "the anchor '\\z'", "Z": "the anchor '\\Z'", "G": "the anchor '\\G'", + "x": "the hex escape '\\x'", "u": "the Unicode escape '\\u'", "U": "the Unicode escape '\\U'", + "c": "the control escape '\\c'", "e": "the escape '\\e'", "f": "the escape '\\f'", "v": "the escape '\\v'", + "a": "the escape '\\a'", "k": "the named backreference '\\k'", "Q": "the quoting escape '\\Q'", + "E": "the quoting escape '\\E'", "R": "the escape '\\R'", "X": "the escape '\\X'", "h": "the escape '\\h'", + "H": "the escape '\\H'", "N": "the escape '\\N'", "K": "the escape '\\K'", "m": "the escape '\\m'", + "M": "the escape '\\M'", "y": "the escape '\\y'", "Y": "the escape '\\Y'", +} +_GROUP_FORMS = ( + ("(?<=", "the lookbehind '(?<='"), ("(? None: + self.construct = construct + super().__init__(f"{construct} is not in the portable regex subset") + + +class _Node(BaseModel): + model_config = ConfigDict(frozen=True) + + +class RegexChar(_Node): + """One literal character.""" + + char: str + + +class RegexAny(_Node): + """``.`` — any character, newline included.""" + + +class RegexAnchor(_Node): + """``^`` / ``$`` — the start / end of the whole string.""" + + at: Literal["start", "end"] + + +class RegexClass(_Node): + """``\\d`` / ``\\w`` / ``\\s`` (ASCII), or a negation.""" + + kind: Literal["d", "w", "s"] + negated: bool = False + + +class RegexRange(_Node): + low: str + high: str + + +BracketItem = RegexChar | RegexRange | RegexClass + + +class RegexBracket(_Node): + """``[…]`` / ``[^…]``.""" + + negated: bool + items: tuple[BracketItem, ...] + + +class RegexGroup(_Node): + """A capturing group ``( … )``; ``index`` counts opening parentheses from 1.""" + + index: int + body: "RegexAlt" + + +class RegexRepeat(_Node): + node: "RegexAtom" + low: int + high: int | None = None + + +RegexAtom = RegexChar | RegexAny | RegexAnchor | RegexClass | RegexBracket | RegexGroup +RegexItem = RegexAtom | RegexRepeat + + +class RegexAlt(_Node): + """Alternatives, each a sequence of items.""" + + branches: tuple[tuple[RegexItem, ...], ...] + + +class RegexPattern(_Node): + """A parsed portable pattern; ``groups`` is its capturing-group count.""" + + root: RegexAlt + groups: int + + +class RegexGroupRef(_Node): + index: int + + +class RegexReplacement(_Node): + """A parsed replacement: literal text and ``\\1``-``\\9`` group references.""" + + parts: tuple[str | RegexGroupRef, ...] + + +RegexGroup.model_rebuild() +RegexRepeat.model_rebuild() + + +class _Parser: + def __init__(self, text: str) -> None: + self.text = text + self.pos = 0 + self.groups = 0 + self.quant_start = 0 + + def peek(self, offset: int = 0) -> str: + i = self.pos + offset + return self.text[i] if i < len(self.text) else "" + + def at_end(self) -> bool: + return self.pos >= len(self.text) + + def alt(self, *, nested: bool) -> RegexAlt: + branches = [self.seq()] + while self.peek() == "|": + self.pos += 1 + branches.append(self.seq()) + if self.peek() == ")" and not nested: + raise RegexPatternError("the unbalanced parenthesis ')'") + return RegexAlt(branches=tuple(branches)) + + def seq(self) -> tuple[RegexItem, ...]: + items: list = [] + while not self.at_end() and self.peek() not in "|)": + atom = self.atom() + items.append(self.quantified(atom)) + return tuple(items) + + def atom(self) -> RegexAtom: + ch = self.peek() + if ch in "*+?": + raise RegexPatternError(f"the quantifier '{ch}' with nothing to repeat") + if ch == "{": + raise RegexPatternError("the brace '{' outside a repetition {m}, {m,} or {m,n} (write \\{ for a brace)") + self.pos += 1 + if ch == "(": + return self.group() + if ch == "[": + return self.bracket() + if ch == ".": + return RegexAny() + if ch == "^": + return RegexAnchor(at="start") + if ch == "$": + return RegexAnchor(at="end") + if ch == "\\": + return self.escape(in_bracket=False) + return RegexChar(char=ch) + + def group(self) -> RegexGroup: + if self.peek() == "?": + rest = self.text[self.pos - 1:] + for prefix, construct in _GROUP_FORMS: + if rest.startswith(prefix): + raise RegexPatternError(construct) + raise RegexPatternError(f"the inline group '{rest[:3]}…'") + self.groups += 1 + index = self.groups + body = self.alt(nested=True) + if self.peek() != ")": + raise RegexPatternError("the unbalanced parenthesis '(' (an unclosed group)") + self.pos += 1 + return RegexGroup(index=index, body=body) + + def escape(self, *, in_bracket: bool) -> RegexChar | RegexClass: + if self.at_end(): + raise RegexPatternError("the trailing backslash '\\'") + ch = self.peek() + self.pos += 1 + if ch.lower() in _CLASS_ESCAPES: + negated = ch.isupper() + if negated and in_bracket: + raise RegexPatternError(f"the negated class '\\{ch}' inside a bracket expression") + return RegexClass(kind=ch.lower(), negated=negated) # pyright: ignore[reportArgumentType] + if ch in _CONTROL_ESCAPES: + return RegexChar(char=_CONTROL_ESCAPES[ch]) + if ch.isdigit(): + raise RegexPatternError(f"the backreference '\\{ch}'") + if ch in _LETTER_ESCAPES: + raise RegexPatternError(_LETTER_ESCAPES[ch]) + if ch in _PUNCTUATION or not ch.isascii(): + return RegexChar(char=ch) + raise RegexPatternError(f"the escape '\\{ch}'") + + def bracket(self) -> RegexBracket: + negated = self.peek() == "^" + if negated: + self.pos += 1 + items: list = [] + while True: + if self.at_end(): + raise RegexPatternError("the unterminated bracket expression '['") + # A leading ``]`` is literal. + if self.peek() == "]" and items: + self.pos += 1 + return RegexBracket(negated=negated, items=tuple(items)) + items.append(self.bracket_item()) + + def bracket_item(self) -> BracketItem: + ch = self.peek() + if ch == "[" and self.peek(1) in (":", ".", "="): + end = self.text.find("]", self.pos) + construct = self.text[self.pos + 1:end] if end > 0 else self.text[self.pos + 1:] + raise RegexPatternError(f"the POSIX class '[{construct}]'") + self.pos += 1 + item = self.escape(in_bracket=True) if ch == "\\" else RegexChar(char=ch) + if isinstance(item, RegexChar) and self.peek() == "-" and self.peek(1) not in ("]", ""): + return self.bracket_range(item) + return item + + def bracket_range(self, low: RegexChar) -> RegexRange: + self.pos += 1 + high_ch = self.peek() + self.pos += 1 + high = self.escape(in_bracket=True) if high_ch == "\\" else RegexChar(char=high_ch) + if not isinstance(high, RegexChar) or ord(high.char) < ord(low.char): + raise RegexPatternError(f"the range '{low.char}-{high_ch}'") + return RegexRange(low=low.char, high=high.char) + + def quantified(self, atom: RegexAtom) -> RegexItem: + bounds = self.quantifier() + if bounds is None: + return atom + if isinstance(atom, RegexAnchor): + raise RegexPatternError("a quantifier on an anchor") + nxt = self.peek() + if nxt == "?": + raise RegexPatternError(f"the lazy quantifier '{self.text[self.quant_start:self.pos + 1]}'") + if nxt == "+": + raise RegexPatternError(f"the possessive quantifier '{self.text[self.quant_start:self.pos + 1]}'") + if nxt and nxt in "*{": + raise RegexPatternError(f"the stacked quantifier '{self.text[self.quant_start:self.pos + 1]}'") + low, high = bounds + return RegexRepeat(node=atom, low=low, high=high) + + def quantifier(self) -> tuple[int, int | None] | None: + self.quant_start = self.pos + ch = self.peek() + if ch in ("*", "+", "?"): + self.pos += 1 + return {"*": (0, None), "+": (1, None), "?": (0, 1)}[ch] + if ch != "{": + return None + end = self.text.find("}", self.pos) + body = self.text[self.pos + 1:end] if end > 0 else "" + low_text, comma, high_text = body.partition(",") + if end < 0 or not low_text.isdigit() or not (high_text.isdigit() or not high_text): + raise RegexPatternError("the brace '{' outside a repetition {m}, {m,} or {m,n} (write \\{ for a brace)") + self.pos = end + 1 + low = int(low_text) + if high_text: + high = int(high_text) + else: + high = None if comma else low + if low > MAX_REPEAT or (high is not None and high > MAX_REPEAT): + raise RegexPatternError(f"the repetition count above {MAX_REPEAT} in '{{{body}}}'") + if high is not None and high < low: + raise RegexPatternError(f"the repetition '{{{body}}}' (its maximum is below its minimum)") + return low, high + + +@lru_cache(maxsize=4096) +def parse_regex(text: str) -> RegexPattern: + """``text`` as a portable pattern; ``RegexPatternError`` names the first construct outside the subset.""" + parser = _Parser(text) + root = parser.alt(nested=False) + return RegexPattern(root=root, groups=parser.groups) + + +@lru_cache(maxsize=4096) +def parse_replacement(text: str, *, groups: int) -> RegexReplacement: + """A replacement over a pattern with ``groups`` groups: ``\\1``-``\\9`` insert a group, ``\\\\`` a backslash.""" + parts: list = [] + literal: list = [] + i = 0 + while i < len(text): + ch = text[i] + if ch != "\\": + literal.append(ch) + i += 1 + continue + nxt = text[i + 1] if i + 1 < len(text) else "" + if nxt == "\\": + literal.append("\\") + elif nxt.isdigit() and nxt != "0" and int(nxt) <= groups: + if literal: + parts.append("".join(literal)) + literal = [] + parts.append(RegexGroupRef(index=int(nxt))) + elif nxt.isdigit(): + raise RegexPatternError(f"the replacement group reference '\\{nxt}' (the pattern has {groups} groups)") + else: + raise RegexPatternError(f"the replacement escape '\\{nxt}' (only \\1-\\9 and \\\\ are)") + i += 2 + if literal: + parts.append("".join(literal)) + return RegexReplacement(parts=tuple(parts)) + + +__all__ = [ + "MAX_REPEAT", "RegexAlt", "RegexAnchor", "RegexAny", "RegexAtom", "RegexBracket", "RegexChar", "RegexClass", + "RegexGroup", "RegexGroupRef", "RegexItem", "RegexPattern", "RegexPatternError", "RegexRange", + "RegexRepeat", "RegexReplacement", "parse_regex", "parse_replacement", +] diff --git a/slayer/core/scalar_args.py b/slayer/core/scalar_args.py new file mode 100644 index 000000000..92615bf1b --- /dev/null +++ b/slayer/core/scalar_args.py @@ -0,0 +1,128 @@ +"""Library-function argument contracts on literal values: patterns, paths, flags, groups, indices, domains.""" + +from __future__ import annotations + +from decimal import Decimal +from types import MappingProxyType +from typing import Mapping, Optional, Tuple + +from slayer.core.errors import ScalarArgumentError +from slayer.core.json_path import JsonPath, JsonPathError, parse_json_path +from slayer.core.regex_pattern import ( + RegexPattern, + RegexPatternError, + RegexReplacement, + parse_regex, + parse_replacement, +) + +REGEX_FUNCTIONS = frozenset({"regexp_like", "regexp_extract", "regexp_replace"}) +#: Argument positions that take only a string literal or a ``{variable}`` holding the text. +STRING_SLOTS: Mapping[str, Tuple[int, ...]] = MappingProxyType({ + "regexp_like": (1,), "regexp_extract": (1,), "regexp_replace": (1, 2), "json_value": (1,), +}) +_SLOT_NAMES = {(1, "json_value"): "path", (2, "regexp_replace"): "replacement"} +#: The real domain of the inverse sines and cosines. +_UNIT_INTERVAL = (Decimal(-1), Decimal(1)) +MAX_CODE_POINT = 0x10FFFF +SURROGATES = (0xD800, 0xDFFF) + + +def slot_name(fn: str, pos: int) -> str: + return _SLOT_NAMES.get((pos, fn), "pattern") + + +def _where(variable: Optional[str]) -> str: + return f" (from the variable {{{variable}}})" if variable else "" + + +def _error(summary: str, *, suggestion: str) -> ScalarArgumentError: + return ScalarArgumentError(summary=summary, suggestion=suggestion) + + +def check_pattern(fn: str, text: str, *, variable: Optional[str] = None) -> RegexPattern: + try: + return parse_regex(text) + except RegexPatternError as e: + raise _error( + f"{fn}() pattern {text!r}{_where(variable)}: {e}.", + suggestion="Use the portable subset: literals, ., [...], [^...], * + ? {m,n}, ^ $, |, ( ), " + "\\d \\w \\s and their negations, \\n \\t \\r, and a backslash before a metacharacter.", + ) from None + + +def check_replacement(fn: str, text: str, *, pattern: RegexPattern, variable: Optional[str] = None) -> RegexReplacement: + try: + return parse_replacement(text, groups=pattern.groups) + except RegexPatternError as e: + raise _error( + f"{fn}() replacement {text!r}{_where(variable)}: {e}.", + suggestion="In a replacement, \\1-\\9 insert a group of the pattern and \\\\ a backslash; " + "everything else is literal.", + ) from None + + +def check_path(fn: str, text: str, *, variable: Optional[str] = None) -> JsonPath: + try: + return parse_json_path(text) + except JsonPathError as e: + raise _error( + f"{fn}() path {text!r}{_where(variable)}: {e}.", + suggestion="Write $ followed by .key, .\"quoted key\" and [n] steps.", + ) from None + + +def check_flags(fn: str, value: object) -> bool: + """Whether the flags literal asks for case-insensitive matching (only ``'i'`` exists).""" + if value != "i": + raise _error( + f"{fn}() flag {value!r} is not supported.", + suggestion="The only flag is the literal 'i' (case-insensitive); matching is case-sensitive without it.", + ) + return True + + +def check_group(fn: str, value: object, *, pattern: RegexPattern) -> int: + if not isinstance(value, Decimal) or value != value.to_integral_value() or not 0 <= value <= pattern.groups: + raise _error( + f"{fn}() group {value!r} is not a group of the pattern.", + suggestion=f"Pass an integer literal from 0 (the whole match) to {pattern.groups} (its group count).", + ) + return int(value) + + +def check_split_index(value: object) -> int: + if not isinstance(value, Decimal) or value != value.to_integral_value() or value == 0: + raise _error( + f"split_part() field index {value!r} is not a non-zero integer literal.", + suggestion="Pass 1, 2, … to count fields from the start, or -1, -2, … to count from the end.", + ) + return int(value) + + +def check_domain(fn: str, position: int, value: object, *, text: str) -> None: + """A literal argument outside ``fn``'s domain (whose column form yields NULL) is a plan-time error.""" + if not isinstance(value, Decimal): + return + low, high = _UNIT_INTERVAL + if fn in ("asin", "acos") and not low <= value <= high: + reason = "outside [-1, 1]" + elif fn == "div" and position == 1 and value == 0: + reason = "a zero divisor" + elif fn == "chr" and ( + value != value.to_integral_value() or value < 1 or value > MAX_CODE_POINT + or SURROGATES[0] <= value <= SURROGATES[1] + ): + reason = "not a character code point (1 to 0x10FFFF, surrogates excluded)" + else: + return + raise _error( + f"{fn}() argument {text} is {reason}.", + suggestion=f"Use an argument inside the domain of {fn}(); over a column, out-of-domain values yield NULL.", + ) + + +__all__ = [ + "MAX_CODE_POINT", "REGEX_FUNCTIONS", "STRING_SLOTS", "SURROGATES", "check_domain", "check_flags", "check_group", + "check_path", "check_pattern", "check_replacement", "check_split_index", "slot_name", +] diff --git a/slayer/core/syntax.py b/slayer/core/syntax.py index f44b3f4ec..21cd91874 100644 --- a/slayer/core/syntax.py +++ b/slayer/core/syntax.py @@ -5,7 +5,8 @@ pure syntax, no scope resolution or named-measure expansion (binder's job). Every spelling of a construct collapses to one node: CASE → ``iif``, ``EXTRACT`` → ``date_part``, ``count(distinct x)`` → ``count_distinct``, ``BETWEEN`` → its conjunction, ``x::t`` → -``Cast``, interval literals → ``date_add``. +``Cast``, interval literals → ``date_add``, regex operators → ``regexp_like``, JSON arrows and +aliases → ``json_value``, ``date_trunc(unit, x)`` → ``unit(x)``. """ from __future__ import annotations @@ -17,6 +18,7 @@ import unicodedata from decimal import Decimal from functools import lru_cache, partial +from itertools import count from typing import Any, Callable, Dict, Iterator, List, Mapping, Optional, Tuple, Union, cast import pyparsing as pp @@ -33,9 +35,12 @@ ambiguous_weekday_message, normalize_aggregation_name, ) -from slayer.core.errors import GranularityCallError, IllegalWindowInFilterError, UnknownFunctionError -from slayer.core.keys import DATE_UNIT_ARGS, SCALAR_FUNCTIONS, check_scalar_arity +from slayer.core.errors import GranularityCallError, IllegalWindowInFilterError, UnknownFunctionError, VariableError +from slayer.core.json_path import JsonPathError, check_key, json_path_text, parse_json_path +from slayer.core.keys import DATE_UNIT_ARGS, RESERVED_SCALAR_NAMES, SCALAR_FUNCTIONS, check_scalar_arity from slayer.core.refs import split_agg_suffix +from slayer.core.regex_pattern import RegexPattern +from slayer.core.scalar_args import STRING_SLOTS, check_path, check_pattern, check_replacement, slot_name # --------------------------------------------------------------------------- @@ -90,6 +95,14 @@ class Placeholder(_BaseNode): """An unsubstituted ``{name}`` variable in a literal slot.""" name: str + # Offset in the parsed text; not part of identity. + start: int = -1 + + def __eq__(self, other: object) -> bool: + return isinstance(other, Placeholder) and self.name == other.name + + def __hash__(self) -> int: + return hash(("Placeholder", self.name)) class TupleLit(_BaseNode): @@ -411,7 +424,7 @@ def _placeholder_node(s: str, loc: int, toks: pp.ParseResults) -> Placeholder: rest = s[end:].lstrip() if rest.startswith(("(", ".")) or (rest.startswith(":") and not rest.startswith("::")): raise _Problem(f"{_LITERAL_VALUES}; a variable cannot name a function, column or path.") - return Placeholder(name=raw[1:-1]) + return Placeholder(name=raw[1:-1], start=loc) def _reject_placeholder(_s: str, _loc: int, _toks: pp.ParseResults) -> None: @@ -638,6 +651,21 @@ def _extract_node(toks: List[Any]) -> ScalarCall: _on(_EXTRACT, _extract_node) + +_RETURNING_TYPES = frozenset({"INT", "DOUBLE", "BOOLEAN", "DATE", "TIMESTAMP", "TEXT"}) +_JSON_VALUE_RETURNING = (pp.Suppress(_kw("json_value")) + LPAR + expr + COMMA + expr + pp.Suppress(_kw("returning")) + + _need(_TYPE_SPEC, "RETURNING needs a type: INT, DOUBLE, BOOLEAN, DATE, TIMESTAMP or TEXT.") + + _need(RPAR, "json_value(x, path RETURNING ) is missing its ')'.")) + + +def _json_value_returning(toks: List[Any]) -> Cast: + value, path, type_text = toks + if type_text not in _RETURNING_TYPES: + raise _Problem(f"json_value() RETURNING {type_text} is not supported; use one of {', '.join(sorted(_RETURNING_TYPES))}.") + return Cast(source=ScalarCall(name="json_value", args=(value, path)), type_text=type_text, try_=True) + + +_on(_JSON_VALUE_RETURNING, _json_value_returning) _POSITION = _on((pp.Suppress(_kw("position")) + LPAR + _concat_level + pp.Suppress(_kw("in")) + expr + RPAR), lambda toks: ScalarCall(name="instr", args=(toks[1], toks[0]))) _SUBSTRING = _on((pp.Suppress(_kw("substring")) + LPAR + expr + pp.Suppress(_kw("from")) + expr + pp.Optional(pp.Suppress(_kw("for")) + expr) + RPAR), lambda toks: ScalarCall(name="substr", args=tuple(toks))) @@ -710,9 +738,10 @@ def _interval_node(toks: List[Any]) -> ScalarCall: _PAREN = LPAR + expr + RPAR _PLACEHOLDER_ATOM = _PLACEHOLDER.copy().set_parse_action(_placeholder_node) _KEYWORD_LED = pp.FollowedBy(pp.Regex( - r"(?i:case|cast|try_cast|extract|position|substring|trim|date|timestamp|time|interval|current_date|current_timestamp)" - r"(?![A-Za-z0-9_])" -)) + (_CASE | _CAST | _EXTRACT | _POSITION | _SUBSTRING | _TRIM_FORM | _TEMPORAL | _TIME_LITERAL | _INTERVAL | _CLOCK) + r"(?i:case|cast|try_cast|extract|position|substring|trim|date|timestamp|time|interval|current_date|current_timestamp" + r"|json_value)(?![A-Za-z0-9_])" +)) + (_CASE | _CAST | _EXTRACT | _POSITION | _SUBSTRING | _TRIM_FORM | _TEMPORAL | _TIME_LITERAL | _INTERVAL | _CLOCK + | _JSON_VALUE_RETURNING) _ATOM = (_KEYWORD_LED | _CONSTANT | _PLACEHOLDER_ATOM | _NUMBER | _STRING | _PAREN | _CALL | _COLON_AGG | _REF) @@ -774,11 +803,47 @@ def _fold_arith(toks: pp.ParseResults) -> Any: return node +_BARE_ARROW = ( + "'->' yields a JSON value, which Mode B does not read; end the chain with ->> to read the value as text, " + "e.g. payload -> 'a' ->> 'b'." +) + + +def _arrow_steps(operand: Any) -> Tuple[Any, ...]: + """The path steps one ``->`` / ``->>`` operand adds: a ``'$…'`` path, a key, or an array index.""" + value = operand.value if isinstance(operand, Literal) else None + try: + if isinstance(value, str): + return parse_json_path(value).steps if value.startswith("$") else (check_key(value),) + except JsonPathError as e: + raise _Problem(f"{e}.") from None + if isinstance(value, Decimal) and value == value.to_integral_value() and value >= 0: + return (int(value),) + raise _Problem( + "the right operand of -> / ->> must be a literal key ('a'), a non-negative array index (0) or a " + "'$…' path." + ) + + def _fold_concat(toks: pp.ParseResults) -> Any: + """``||`` concatenation and ``->`` / ``->>`` JSON reads share one left-associative level, as in Postgres.""" items = list(toks[0]) node = items[0] - for right in items[1:]: - node = ScalarCall(name="concat", args=(node, right)) + chain: Optional[Tuple[Any, Tuple[Any, ...]]] = None + for op, right in zip(items[1::2], items[2::2]): + if op == "||": + if chain is not None: + raise _Problem(_BARE_ARROW) + node = ScalarCall(name="concat", args=(node, right)) + continue + base, steps = chain if chain is not None else (node, ()) + steps = (*steps, *_arrow_steps(right)) + if op == "->": + chain = (base, steps) + else: + node, chain = ScalarCall(name="json_value", args=(base, Literal(value=json_path_text(steps)))), None + if chain is not None: + raise _Problem(_BARE_ARROW) return node @@ -788,10 +853,10 @@ def _fold_concat(toks: pp.ParseResults) -> Any: _concat_level <<= pp.infix_notation(_PRIMARY, [ (DCOLON + _need(_TYPE_SPEC, "'::' needs a type."), 1, pp.OpAssoc.LEFT, _fold_casts), (pp.Suppress(_sym(r"\*\*", "'**'")), 2, pp.OpAssoc.RIGHT, _pow), - (_sym("[+-]", "'-' or '+'"), 1, pp.OpAssoc.RIGHT, _signed), + (_sym(r"\+|-(?!>)", "'-' or '+'"), 1, pp.OpAssoc.RIGHT, _signed), (_FLOORDIV | _sym(r"\*(?!\*)|/(?!/)|%", "'*', '/' or '%'"), 2, pp.OpAssoc.LEFT, _fold_arith), - (_sym("[+-]", "'+' or '-'"), 2, pp.OpAssoc.LEFT, _fold_arith), - (pp.Suppress(_PIPE | _sym(r"\|\|", "'||'")), 2, pp.OpAssoc.LEFT, _fold_concat), + (_sym(r"\+|-(?!>)", "'+' or '-'"), 2, pp.OpAssoc.LEFT, _fold_arith), + (_PIPE | _sym(r"\|\||->>|->", "'||', '->' or '->>'"), 2, pp.OpAssoc.LEFT, _fold_concat), ], lpar=pp.NoMatch(), rpar=pp.NoMatch()) # pyright: ignore[reportArgumentType] — unannotated; documented to accept a ParserElement # -- comparison level ---------------------------------------------------------- @@ -829,6 +894,13 @@ def _truth_test(left: Any, toks: List[Any]) -> Any: return _negated(test, negate) +def _regex_operator(left: Any, toks: List[Any]) -> Any: + """``~`` / ``~*`` / ``!~`` / ``!~*`` as ``[NOT] regexp_like(left, p[, 'i'])``.""" + op, pattern = toks + flags = (Literal(value="i"),) if op.endswith("*") else () + return _negated(ScalarCall(name="regexp_like", args=(left, pattern, *flags)), op.startswith("!")) + + def _in_rhs_elements(items: List[Any]) -> TupleLit: if not items: raise _Problem( @@ -874,8 +946,11 @@ def _in_rhs_elements(items: List[Any]) -> TupleLit: )), t[0])) | _suffix(_NOT_FLAG + _kw("like", "ilike") + _concat_level, lambda left, t: _negated(ScalarCall(name=t[1].lower(), args=(left, t[2])), t[0])) - | (_NOT_FLAG + _kw("similar") + _kw("to")) + _fail("SIMILAR TO is not supported; use LIKE or ILIKE.") - | (_kw("regexp", "rlike") + _fail("the REGEXP / RLIKE operators are not supported; use LIKE or ILIKE.")) + | _suffix(_sym(r"!~\*|!~|~\*|~", "regex operator") + _concat_level, _regex_operator) + | (_NOT_FLAG + _kw("similar") + _kw("to")) + _fail( + "SIMILAR TO is not supported; use LIKE, ILIKE or a regex (x ~ 'p', regexp_like(x, 'p')).") + | (_kw("regexp", "rlike") + _fail( + "the REGEXP / RLIKE operators are not supported; use x ~ 'p' or regexp_like(x, 'p').")) ) @@ -962,6 +1037,7 @@ def placeholder_names(parsed: Any) -> List[str]: _ANY_BRACE_RE = re.compile(r"\{\{|\}\}|\{([^}]*)\}") +_DIGIT_BRACES_RE = re.compile(r"[0-9, ]*") _NUMBER_TEXT_RE = re.compile(r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][+-]?\d+)?") @@ -977,24 +1053,89 @@ def bind_variables(text: str, variables: Mapping[str, Any]) -> str: if region.kind == "code" and ("{?" in chunk or "?}" in chunk): raise ValueError(f"{_OPTIONAL_BLOCKS} Got: {text!r}.") for m in _ANY_BRACE_RE.finditer(chunk): - _check_variable(m, text=text, variables=variables) + _check_variable(m, text=text, variables=variables, in_string=region.kind == "string") # Strings bound and ``{{`` / ``}}`` outside strings read as braces: the grammar judges the variable slots. - parse_expr(_spliced(text, variables=variables, regions=regions, kinds=("string",), code_braces=True)) - return _spliced(text, variables=variables, regions=regions, kinds=("string", "code"), code_braces=False) + template = parse_expr(_spliced(text, variables=variables, regions=regions, kinds=("string",), code_braces=True)) + text_slots = _text_slot_ordinals(template, variables=variables) + return _spliced( + text, variables=variables, regions=regions, kinds=("string", "code"), code_braces=False, text_slots=text_slots, + ) + + +def _text_slot_ordinals(template: Any, *, variables: Mapping[str, Any]) -> frozenset[int]: + """Textual ordinals of the placeholders filling a pattern / path / replacement slot, checked here so an + error names the variable.""" + starts = sorted({n.start for n in _walk_parsed(template) if isinstance(n, Placeholder)}) + return frozenset( + starts.index(placeholder.start) + for node in _walk_parsed(template) + if isinstance(node, ScalarCall) and node.name in STRING_SLOTS + for placeholder in _checked_slot_placeholders(node, variables=variables) + ) + + +def _checked_slot_placeholders(call: ScalarCall, *, variables: Mapping[str, Any]) -> List[Placeholder]: + """``call``'s text-slot placeholders, each value checked against its slot.""" + found: List[Placeholder] = [] + pattern: Optional[RegexPattern] = None + for pos in STRING_SLOTS[call.name]: + arg = call.args[pos] if pos < len(call.args) else None + value = _slot_text(call, pos=pos, arg=arg, variables=variables) + if value is None: + continue + variable = arg.name if isinstance(arg, Placeholder) else None + pattern = _check_slot(call.name, pos=pos, value=value, variable=variable, pattern=pattern) + if isinstance(arg, Placeholder): + found.append(arg) + return found + + +def _slot_text(call: ScalarCall, *, pos: int, arg: Any, variables: Mapping[str, Any]) -> Optional[str]: + """The text filling a slot: a variable's value (which must be text) or a string literal's.""" + if not isinstance(arg, Placeholder): + value = getattr(arg, "value", None) + return value if isinstance(value, str) else None + value = variables.get(arg.name) + if not isinstance(value, str): + raise VariableError( + f"Variable '{arg.name}' fills the {slot_name(call.name, pos)} of {call.name}() and must hold text; " + f"got {type(value).__name__}." + ) + return value + + +def _check_slot( + fn: str, *, pos: int, value: str, variable: Optional[str], pattern: Optional[RegexPattern], +) -> Optional[RegexPattern]: + """Checks one slot's text; returns the call's pattern so far.""" + if fn == "json_value": + if variable: + check_path(fn, value, variable=variable) + return pattern + if pos == 1: + return check_pattern(fn, value, variable=variable) + if variable and pattern is not None: + check_replacement(fn, value, pattern=pattern, variable=variable) + return pattern def _spliced( text: str, *, variables: Mapping[str, Any], regions: List[_Region], kinds: Tuple[str, ...], code_braces: bool, + text_slots: frozenset[int] = frozenset(), ) -> str: out: List[str] = [] cursor = 0 + ordinal = count() for region in regions: out.append(text[cursor:region.start]) chunk = text[region.start:region.end] if region.kind in kinds: in_string = region.kind == "string" chunk = _ANY_BRACE_RE.sub( - partial(_bound_text, text=text, region_start=region.start, in_string=in_string, variables=variables), + partial( + _bound_text, text=text, region_start=region.start, in_string=in_string, variables=variables, + text_slots=text_slots, ordinal=ordinal, + ), chunk, ) elif code_braces: @@ -1005,31 +1146,42 @@ def _spliced( return "".join(out) -def _check_variable(match: "re.Match[str]", *, text: str, variables: Mapping[str, Any]) -> None: - if match.group(0) in ("{{", "}}"): +def _literal_braces(match: "re.Match[str]", *, in_string: bool) -> bool: + """A string-literal brace pair holding only digits, commas and spaces (``{3}``, ``{1, 2}``) is text.""" + return in_string and match.group(1) is not None and _DIGIT_BRACES_RE.fullmatch(match.group(1)) is not None + + +def _check_variable(match: "re.Match[str]", *, text: str, variables: Mapping[str, Any], in_string: bool) -> None: + if match.group(0) in ("{{", "}}") or _literal_braces(match, in_string=in_string): return name = match.group(1) if not re.fullmatch(_VAR_NAME, name): - raise ValueError( + raise VariableError( f"Invalid variable name '{name}' in filter: {text!r}. " f"Variable names must contain only letters, digits, and underscores." ) if name not in variables: - raise ValueError( - f"Undefined variable '{name}' in filter: {text!r}. Available variables: {sorted(variables)}" + hint = " For literal braces in a string (e.g. a regex), write {{ and }}." if in_string else "" + raise VariableError( + f"Undefined variable '{name}' in filter: {text!r}. Available variables: {sorted(variables)}.{hint}" ) def _bound_text( match: "re.Match[str]", *, text: str, region_start: int, in_string: bool, variables: Mapping[str, Any], + text_slots: frozenset[int], ordinal: Iterator[int], ) -> str: whole = match.group(0) if whole in ("{{", "}}"): return whole[0] + if _literal_braces(match, in_string=in_string): + return whole name = match.group(1) value = variables[name] if in_string: return _value_text(name, value).replace("'", "''") + if next(ordinal) in text_slots: + return _literal_text(name, value) start = region_start + match.start() if _opens_in_list(text, start=start, end=region_start + match.end()): values = value if isinstance(value, (list, tuple)) else [value] @@ -1373,6 +1525,16 @@ def _dispatch_call( # NOSONAR(S3776) — the one call-dispatch ladder (builtin _reject_bare_star_args(args, kwargs, func_name=func_name, original=original) return TransformCall(op=func_name, input=args[0], args=args[1:], kwargs=kwargs) + spelling = _SPELLINGS.get(func_name.lower()) + if spelling is not None: + if kwargs: + raise ValueError(f"Invalid Mode-B expression {original!r}: {func_name}() takes positional arguments only.") + _reject_bare_star_args(args, kwargs, func_name=func_name, original=original) + try: + return spelling(args) + except _Problem as problem: + raise ValueError(f"Invalid Mode-B expression {original!r}: {problem.detail}") from None + # Normalised to lower case so ``COALESCE`` / ``coalesce`` intern to one key. if func_name.lower() in SCALAR_FUNCTIONS: if kwargs: @@ -1417,6 +1579,51 @@ def _dispatch_call( # NOSONAR(S3776) — the one call-dispatch ladder (builtin ) +def _date_trunc(args: Tuple[Any, ...]) -> ParsedExpr: + """``date_trunc(unit, x)`` → the granularity call ``unit(x)``.""" + if len(args) != 2 or not (isinstance(args[0], Literal) and isinstance(args[0].value, str)): + raise _Problem("date_trunc() takes a unit string literal and a value: date_trunc('month', x).") + unit = args[0].value.lower() + if not unit.isidentifier() or unit in RESERVED_SCALAR_NAMES or unit in ALL_TRANSFORMS or ( + normalize_aggregation_name(unit) in BUILTIN_AGGREGATIONS + ) or unit in DATE_PART_ALIASES or unit in AMBIGUOUS_WEEKDAY_NAMES: + raise _Problem(f"unknown date_trunc() unit {args[0].value!r}; use a granularity such as 'month'.") + return _dispatch_call(unit, args=(args[1],), kwargs=(), original=_STATE.text) + + +def _json_alias(name: str): + def build(args: Tuple[Any, ...]) -> ParsedExpr: + if len(args) != 2: + raise _Problem(f"{name}(x, path) takes exactly two arguments; for a typed result use " + f"json_value(x, path RETURNING ).") + return ScalarCall(name="json_value", args=args) + return build + + +def _json_key_list(name: str): + def build(args: Tuple[Any, ...]) -> ParsedExpr: + keys = args[1:] + if not keys or not all(isinstance(k, Literal) and isinstance(k.value, str) for k in keys): + raise _Problem(f"{name}(x, 'key', …) takes string-literal keys after the value.") + try: + path = json_path_text(tuple(check_key(k.value) for k in keys)) + except JsonPathError as e: + raise _Problem(f"{e}.") from None + return ScalarCall(name="json_value", args=(args[0], Literal(value=path))) + return build + + +# Spellings collapsed into one library node (engine P2); each name is reserved (``SCALAR_SPELLINGS``). +_SPELLINGS: Dict[str, Callable[[Tuple[Any, ...]], ParsedExpr]] = { + "strpos": lambda args: ScalarCall(name="instr", args=args), + "date_trunc": _date_trunc, + "json_extract": _json_alias("json_extract"), + "json_extract_scalar": _json_alias("json_extract_scalar"), + "json_extract_path_text": _json_key_list("json_extract_path_text"), + "jsonb_extract_path_text": _json_key_list("jsonb_extract_path_text"), +} + + def keyword_spelling(node: Any) -> Optional[str]: """The name of a ``name = value`` argument, which a scalar call reads as a comparison.""" if isinstance(node, Cmp) and node.single_eq and isinstance(node.left, Ref) and not node.left.quoted: diff --git a/slayer/engine/bind_inputs.py b/slayer/engine/bind_inputs.py index 59a1b5ee9..8db4e4eba 100644 --- a/slayer/engine/bind_inputs.py +++ b/slayer/engine/bind_inputs.py @@ -88,6 +88,8 @@ check_transform_inputs, check_transform_partition_keys_in_operand_grain, check_time_transforms_resolved, + coerce_text_numbers, + coerce_zoned_comparisons, resolve_time_points, ) from slayer.engine.join_safety import assert_partition_key_attributable @@ -96,6 +98,7 @@ measure_key_preserves_native_type, measure_key_type, scope_column_type, + scope_zoned_timestamp, stage_measure_type, ) from slayer.core.syntax import ( @@ -157,6 +160,8 @@ def _expr_has_measure_ref( ) -> bool: if node is None: return False + if isinstance(node, AggCall) and resolve_granularity(node.agg, defined=bundle.granularities) is not None: + return _expr_has_measure_ref(node.source, measure_names=measure_names, scope=scope, bundle=bundle) if isinstance(node, (AggCall, TransformCall)): return True if isinstance(node, Ref) and node.name in measure_names: @@ -502,6 +507,7 @@ def bind_query_inputs( # NOSONAR(S3776) — one cohesive bind pass. The stages order_specs.append(OrderSpec(bound=bo, direction=o.direction, nulls=o.nulls or "default")) column_type = scope_column_type(scope=scope, bundle=bundle) + zoned = scope_zoned_timestamp(scope=scope, bundle=bundle) check_date_operands( roots=[ *(dm.bound.value_key for dm in declared_measures), @@ -512,7 +518,13 @@ def bind_query_inputs( # NOSONAR(S3776) — one cohesive bind pass. The stages ) # Every time point resolves against the execution's one clock reading. declared_measures, bound_filters, order_specs = _map_bound_keys( - lambda vk: resolve_time_points(vk, column_type=column_type, now=bundle.now, units=bundle.granularities), + lambda vk: coerce_zoned_comparisons( + coerce_text_numbers( + resolve_time_points(vk, column_type=column_type, now=bundle.now, units=bundle.granularities), + column_type=column_type, + ), + zoned=zoned, column_type=column_type, + ), declared_measures=declared_measures, bound_filters=bound_filters, order_specs=order_specs, diff --git a/slayer/engine/binding.py b/slayer/engine/binding.py index d12063122..d87ab6af2 100644 --- a/slayer/engine/binding.py +++ b/slayer/engine/binding.py @@ -13,6 +13,8 @@ from pydantic import BaseModel, ConfigDict from slayer.core.errors import ( + ScalarArgumentError, + ScalarOperandTypeError, AggregationArgumentError, AggregationFilterError, AggregationNotAllowedError, @@ -36,8 +38,9 @@ from slayer.core.enums import RANK_FAMILY_TRANSFORMS from slayer.core.granularity import CustomGranularity, Granularity, resolve_granularity from slayer.core.refs import EXPRESSION_SOURCE_KINDS, key_display -from slayer.core.keys import source_anchor_path, window_kwarg_of, DATE_ADD_COUNT_ARG, DATE_OPERAND_ARGS, MIRRORED_TIME_POINT_OP, SCALAR_FUNCTIONS, cast_data_type, check_scalar_arity, type_date_values, AggregateKey, AggregateSource, ArithmeticKey, CastKey, ColumnKey, ColumnSqlKey, Grain, InKey, LiteralKey, ScalarCallKey, SqlFragmentKey, StarKey, TimePointCmpKey, TimePointOp, TimeTruncKey, TransformKey, ValueKey, boolean_valued, column_leaf, column_path, is_attached_source, normalize_scalar, prepend_value_key, temporal_type, walk_value_keys +from slayer.core.keys import source_anchor_path, window_kwarg_of, DATE_ADD_COUNT_ARG, DATE_OPERAND_ARGS, MIRRORED_TIME_POINT_OP, SCALAR_FUNCTIONS, TEXT_RESULT_SCALARS, cast_data_type, check_scalar_arity, type_date_values, AggregateKey, AggregateSource, ArithmeticKey, CastKey, ColumnKey, ColumnSqlKey, Grain, InKey, LiteralKey, ScalarCallKey, SqlFragmentKey, StarKey, TimePointCmpKey, TimePointOp, TimeTruncKey, TransformKey, ValueKey, boolean_valued, column_leaf, column_path, is_attached_source, normalize_scalar, numeric_valued, prepend_value_key, temporal_type, walk_value_keys from slayer.core.join_walker import ( + resolved_terminal, aggregation_owner, canonical_path, terminal_model, @@ -82,7 +85,18 @@ placeholder_names, positional_hint, ) -from slayer.sql.sql_expr import build_cast_type, has_window_function +from slayer.core.scalar_args import ( + REGEX_FUNCTIONS, + check_domain, + check_flags, + check_group, + check_path, + check_pattern, + check_replacement, + check_split_index, + slot_name, +) +from slayer.sql.sql_expr import build_cast_type, has_window_function, native_json_type from slayer.sql.sql_template import SqlTemplateError, aggregation_reads from slayer.ir.bound import BoundExpr, BoundFilter, BoundTimeDimension @@ -1049,12 +1063,6 @@ def _not_an_aggregation_source(bound: ValueKey, *, agg: str) -> AggregationNotAl ) -# Scalar functions whose result is certainly text, for the best-effort -# expression type inference. -_TEXT_RESULT_SCALARS = frozenset({ - "lower", "upper", "trim", "ltrim", "rtrim", "replace", "substr", - "substring", "concat", -}) # Null-handling / min-max scalars whose result class follows their arguments. _ARG_CLASS_SCALARS = frozenset({ "coalesce", "ifnull", "nullif", "greatest", "least", @@ -1064,7 +1072,7 @@ def _expression_is_confidently_text(key, *, model: Optional[SlayerModel]) -> boo if isinstance(key, str): return True if isinstance(key, ScalarCallKey): - if key.name in _TEXT_RESULT_SCALARS: + if key.name in TEXT_RESULT_SCALARS: return True if key.name in _ARG_CLASS_SCALARS: return any( @@ -1102,10 +1110,11 @@ def _reject_non_numeric_expression_agg( kind = "text" else: return + remedy = " (numbers stored as text: TRY_CAST(x AS DOUBLE))" if kind == "text" else "" raise AggregationNotAllowedError( column=key_display(source), agg=agg, reason=f"{agg!r} requires a numeric value, but the aggregated expression is non-numeric ({kind}). Use a " - f"counting or min/max aggregation, or make the expression numeric.", + f"counting or min/max aggregation, or make the expression numeric{remedy}.", ) @@ -1537,8 +1546,12 @@ def _column_agg_refusal(*, col, columns, agg: str, custom: bool) -> Optional[str allowed = DEFAULT_AGGREGATIONS_BY_TYPE.get(col.type, frozenset()) if custom or agg in allowed: return None + remedy = ( + f" For numbers stored as text, convert them: {agg}(TRY_CAST({leaf} AS DOUBLE))." + if col.type is DataType.TEXT and agg in NUMERIC_ONLY_AGGREGATIONS else "" + ) return (f"aggregation {agg!r} is not applicable to {col.type} column {leaf!r}; " - f"default aggregations are {sorted(allowed)}.") + f"default aggregations are {sorted(allowed)}.{remedy}") def _bind_agg_arg( @@ -1826,6 +1839,8 @@ def _bind_scalar( f"{canonical_measure_text(parsed.args[1])!r}." ) + _check_library_literals(parsed) + def bind(a: ParsedExpr, *, in_temporal_slot: bool) -> ValueKey: key = _bind( a, scope=scope, bundle=bundle, in_filter=in_filter, alias_map=alias_map, @@ -1843,9 +1858,76 @@ def bind(a: ParsedExpr, *, in_temporal_slot: bool) -> ValueKey: raise _with_hint(e, hint=positional_hint(e.name)) from e if parsed.name == "date_add": _check_literal_count(args[DATE_ADD_COUNT_ARG]) + if parsed.name == "json_value": + args = (_json_input(args[0], scope=scope, bundle=bundle), *args[1:]) return ScalarCallKey(name=parsed.name, args=args) +def _text_literal(parsed: ScalarCall, pos: int) -> str: + """The string literal at ``pos`` of a library call's text slot (pattern, replacement, path).""" + value = _fold_to_scalar(parsed.args[pos]) + if not isinstance(value, str): + slot = slot_name(parsed.name, pos) + raise ScalarArgumentError( + summary=f"the {slot} of {parsed.name}() must be a string literal or a {{variable}}; got " + f"`{canonical_measure_text(parsed.args[pos])}`.", + suggestion=f"Write the {slot} as a literal, e.g. '…', or pass it through `variables`.", + ) + return value + + +def _check_library_literals(parsed: ScalarCall) -> None: + """The literal-only arguments of a library call: patterns, replacements, paths, flags, groups, indices, domains.""" + name, args = parsed.name, parsed.args + if name in REGEX_FUNCTIONS: + pattern = check_pattern(name, _text_literal(parsed, 1)) + if name == "regexp_replace": + check_replacement(name, _text_literal(parsed, 2), pattern=pattern) + extra = 3 if name == "regexp_replace" else 2 + if len(args) > extra and name == "regexp_extract": + check_group(name, _fold_to_scalar(args[extra]), pattern=pattern) + elif len(args) > extra: + check_flags(name, _fold_to_scalar(args[extra])) + elif name == "json_value": + check_path(name, _text_literal(parsed, 1)) + elif name == "split_part": + check_split_index(_fold_to_scalar(args[2])) + for pos, arg in enumerate(args): + value = _fold_to_scalar(arg) + if value is not _NOT_SCALAR: + check_domain(name, pos, value, text=canonical_measure_text(arg)) + + +def _json_input(arg: ValueKey, *, scope: ModelScope | StageSchema, bundle: ResolvedSourceBundle) -> ValueKey: + """``json_value``'s input: TEXT as is, a native JSON column read as its own type (``CAST(col AS JSONB)``).""" + column_type = scope_column_type(scope=scope, bundle=bundle) + db_type = _json_db_type(arg, scope=scope, bundle=bundle) + if db_type is not None: + return CastKey(source=arg, type_text=db_type, data_type=DataType.UNKNOWN) + declared = column_type(arg) if isinstance(arg, (ColumnKey, ColumnSqlKey)) else None + if declared in (None, DataType.TEXT) and not ( + numeric_valued(arg, column_type=column_type) or boolean_valued(arg, column_type=column_type) + or temporal_type(arg, column_type=column_type) is not None + ): + return arg + raise ScalarOperandTypeError( + summary=f"json_value() reads JSON text or a JSON column; `{key_display(arg)}` is " + f"{(declared or DataType.UNKNOWN).value if declared not in (None, DataType.TEXT) else 'not text'}.", + suggestion="Pass a TEXT column holding JSON, or a column of the database's JSON type.", + ) + + +def _json_db_type(arg: ValueKey, *, scope: ModelScope | StageSchema, bundle: ResolvedSourceBundle) -> Optional[str]: + """The database JSON type of a column ``arg`` (``JSONB``, ``VARIANT``, …), when it has one.""" + if not isinstance(arg, ColumnKey) or not isinstance(scope, ModelScope) or scope.source_model is None: + return None + owner = resolved_terminal(root=scope.source_model, path=arg.path, models_by_name=bundle.models_by_name) + col = owner.get_column(arg.leaf) if owner is not None else None + if col is None or not col.db_type: + return None + return native_json_type(col.db_type, dialect=bundle.dialect) + + def _is_integer_literal(parsed: ParsedExpr) -> bool: """An integer literal, signed or not (``2``, ``-2``).""" if isinstance(parsed, UnaryOp) and parsed.op == "-": diff --git a/slayer/engine/bundle_builder.py b/slayer/engine/bundle_builder.py index c4442f6f6..1ad41d04b 100644 --- a/slayer/engine/bundle_builder.py +++ b/slayer/engine/bundle_builder.py @@ -262,7 +262,7 @@ async def _split_query_backed( ) -> "Tuple[List[SlayerModel], Dict[str, SlayerModel]]": """Split ``models`` into referenced models and query-backed placeholders, closing 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 + their components). Placeholders keep their stored form, including declared joins; on-chain names are never loaded.""" referenced: Dict[str, SlayerModel] = {} query_backed: Dict[str, SlayerModel] = {} @@ -279,7 +279,7 @@ async def _split_query_backed( storage=storage, data_source=data_source, failures=failures, ) if not is_spine(m)) continue - query_backed[model.name] = model.model_copy(update={"joins": []}) + query_backed[model.name] = model pending.extend(await _stage_base_components( model=model, skip=[*chain, *query_backed], known={*referenced, *query_backed}, storage=storage, data_source=data_source, failures=failures, diff --git a/slayer/engine/elaborate_env.py b/slayer/engine/elaborate_env.py index 58353744c..56d72bdb4 100644 --- a/slayer/engine/elaborate_env.py +++ b/slayer/engine/elaborate_env.py @@ -6,7 +6,8 @@ from __future__ import annotations -from datetime import datetime +from datetime import date, datetime +from decimal import Decimal, InvalidOperation from types import MappingProxyType from typing import ( Callable, Dict, Iterator, List, Literal, Mapping, NamedTuple, NoReturn, Optional, @@ -32,6 +33,7 @@ PartitionKeyError, PositionTypingError, ReaggregationError, + ScalarOperandTypeError, TimeAxisError, TimeDimensionColumnError, TimeLiteralError, @@ -47,6 +49,7 @@ from slayer.core.keys import ( DATE_ADD_COUNT_ARG, DATE_OPERAND_ARGS, + NUMERIC_ARG_SCALARS, AggregateKey, ColumnTypeFn, ConsumerNode, @@ -57,6 +60,8 @@ is_local_combined_regroup_ref, is_local_partitioned_agg, is_reaggregation_key, + boolean_valued, + numeric_valued, split_top_level_and, ArithmeticKey, ColumnKey, @@ -65,6 +70,7 @@ InKey, LiteralKey, CastKey, + SCALAR_SPECS, ScalarCallKey, TimePointCmpKey, TimeTruncKey, @@ -1008,10 +1014,6 @@ def check_time_dimension_column( ) -# Allowlisted scalars whose result is never numeric. -_TEXT_SCALARS = frozenset({ - "lower", "upper", "trim", "ltrim", "rtrim", "replace", "substr", "substring", "concat", -}) _NON_NUMERIC_TYPES = frozenset({ DataType.TEXT, DataType.BOOLEAN, DataType.DATE, DataType.TIMESTAMP, DataType.UNKNOWN, }) @@ -1038,9 +1040,6 @@ def _operand_display(k: object) -> str: _LITERAL_TYPES: Mapping[type, DataType] = MappingProxyType({ bool: DataType.BOOLEAN, str: DataType.TEXT, }) -_SCALAR_RESULT_TYPES: Mapping[str, DataType] = MappingProxyType({ - **{name: DataType.TEXT for name in _TEXT_SCALARS}, "like": DataType.BOOLEAN, "ilike": DataType.BOOLEAN, -}) def _leaf_count_type(key: object, *, column_type: ColumnTypeFn) -> Optional[DataType]: @@ -1051,7 +1050,8 @@ def _leaf_count_type(key: object, *, column_type: ColumnTypeFn) -> Optional[Data if isinstance(key, (ArithmeticKey, TimePointCmpKey, InKey)) and is_boolean_shaped(key): return DataType.BOOLEAN if isinstance(key, ScalarCallKey): - return _SCALAR_RESULT_TYPES.get(key.name) + spec = SCALAR_SPECS.get(key.name) + return None if spec is None else spec.result if isinstance(key, CastKey) and key.data_type is not DataType.UNKNOWN: return key.data_type return None @@ -1243,6 +1243,173 @@ def _non_temporal_comparison(key: TimePointCmpKey, *, units: Mapping[str, Custom return ArithmeticKey(op=op, operands=(key.operand, literal)) +# Positions where TEXT beside a number reads as a number (spec: queries/mixed-type-coercion). +_COERCED_OPS = frozenset({ + "==", "!=", "<", "<=", ">", ">=", "is distinct from", "is not distinct from", "+", "-", "*", "/", "%", +}) +_TEXT_PRESERVING_AGGS = frozenset({"min", "max", "first", "last"}) + + +def _text_valued(key: object, *, column_type: ColumnTypeFn) -> bool: + """Whether ``key``'s value is certainly TEXT.""" + if isinstance(key, LiteralKey): + return isinstance(key.value, str) + if isinstance(key, (ColumnKey, ColumnSqlKey)): + return column_type(key) is DataType.TEXT + if isinstance(key, CastKey): + return key.data_type is DataType.TEXT + if isinstance(key, AggregateKey): + return key.agg.lower() in _TEXT_PRESERVING_AGGS and _text_valued(key.source, column_type=column_type) + if isinstance(key, ScalarCallKey): + spec = SCALAR_SPECS.get(key.name) + if spec is not None and spec.result is not None: + return spec.result is DataType.TEXT + values = [key.args[i] for i in value_arg_positions(key.name, len(key.args))] + known = [a for a in values if not (isinstance(a, LiteralKey) and a.value is None)] + return bool(known) and all(_text_valued(a, column_type=column_type) for a in known) + return False + + +def _as_number(key: ValueKey, *, beside: ValueKey) -> ValueKey: + """A TEXT operand read as a number: a literal converted now, anything else ``TRY_CAST(… AS DOUBLE)``.""" + if isinstance(key, LiteralKey) and isinstance(key.value, str): + return LiteralKey(value=_number_literal(key.value, beside=beside)) + return CastKey(source=key, type_text="DOUBLE", data_type=DataType.DOUBLE, try_=True) + + +def _number_literal(text: str, *, beside: ValueKey) -> Decimal: + try: + value = Decimal(text.strip()) + except InvalidOperation: + value = None + if value is None or not value.is_finite(): + raise ScalarOperandTypeError( + summary=f"'{text}' is not a number, so it cannot meet the number `{_operand_display(beside)}`.", + suggestion="Compare with a number (e.g. 100), or compare text with text.", + ) + return value + + +def coerce_text_numbers(key: ValueKey, *, column_type: ColumnTypeFn) -> ValueKey: + """TEXT beside a number in a comparison, ``IN``, arithmetic or ``greatest`` / ``least`` reads as a number; + a number function over TEXT fails (literals convert); ``||`` reads a number as its text and refuses a BOOLEAN.""" + rebuilt = cast(ValueKey, key.map_children(lambda c: coerce_text_numbers(c, column_type=column_type))) + + def text(k: object) -> bool: + return _text_valued(k, column_type=column_type) + + def number(k: object) -> bool: + return numeric_valued(k, column_type=column_type) + + def boolean(k: object) -> bool: + return boolean_valued(k, column_type=column_type) + + if isinstance(rebuilt, ArithmeticKey) and rebuilt.op in _COERCED_OPS and len(rebuilt.operands) == 2: + return _coerce_binary(rebuilt, text=text, number=number) + if isinstance(rebuilt, InKey): + return _coerce_in(rebuilt, text=text, number=number) + if isinstance(rebuilt, ScalarCallKey): + return _coerce_scalar_args(rebuilt, text=text, number=number, boolean=boolean) + return rebuilt + + +_ZONED_COMPARED_OPS = frozenset({ + "==", "=", "!=", "<>", "<", "<=", ">", ">=", "is distinct from", "is not distinct from", +}) + + +def coerce_zoned_comparisons( + key: ValueKey, *, zoned: Callable[[object], bool], column_type: ColumnTypeFn, +) -> ValueKey: + """A naive timestamp compared with a zoned-instant column converts to the column's type; the column stays bare.""" + rebuilt = cast(ValueKey, key.map_children( + lambda c: coerce_zoned_comparisons(c, zoned=zoned, column_type=column_type))) + if not (isinstance(rebuilt, ArithmeticKey) and rebuilt.op in _ZONED_COMPARED_OPS and len(rebuilt.operands) == 2): + return rebuilt + left, right = rebuilt.operands + + def naive(k: ValueKey) -> bool: + # A temporal literal renders as ISO text, which already reads as the column's type. + literal = isinstance(k, LiteralKey) and isinstance(k.value, date) + return not literal and not zoned(k) and temporal_type(k, column_type=column_type) is DataType.TIMESTAMP + + if zoned(left) and naive(right): + return rebuilt.model_copy(update={"operands": (left, _as_zoned(right))}) + if zoned(right) and naive(left): + return rebuilt.model_copy(update={"operands": (_as_zoned(left), right)}) + return rebuilt + + +def _as_zoned(key: ValueKey) -> ValueKey: + return CastKey(source=key, type_text="TIMESTAMP", data_type=DataType.TIMESTAMP) + + +def _coerce_binary(key: ArithmeticKey, *, text: Callable[[object], bool], number: Callable[[object], bool]) -> ValueKey: + left, right = key.operands + if text(left) and number(right): + return key.model_copy(update={"operands": (_as_number(left, beside=right), right)}) + if number(left) and text(right): + return key.model_copy(update={"operands": (left, _as_number(right, beside=left))}) + return key + + +def _coerce_in(key: InKey, *, text: Callable[[object], bool], number: Callable[[object], bool]) -> ValueKey: + if text(key.column) and all(number(v) for v in key.values): + return key.model_copy(update={"column": _as_number(key.column, beside=key.values[0])}) + if number(key.column) and any(text(v) for v in key.values): + values = tuple(cast(LiteralKey, _as_number(v, beside=key.column)) if text(v) else v for v in key.values) + return key.model_copy(update={"values": values}) + return key + + +def _numeric_scalar_args(key: ScalarCallKey, *, text: Callable[[object], bool]) -> list: + """A number function's arguments: TEXT literals converted, any other TEXT refused.""" + args = list(key.args) + for i, arg in enumerate(args): + if isinstance(arg, LiteralKey) and isinstance(arg.value, str): + args[i] = LiteralKey(value=_number_literal(arg.value, beside=key)) + elif text(arg): + display = _operand_display(arg) + raise ScalarOperandTypeError( + summary=f"{key.name}() reads numbers, but `{display}` is TEXT.", + suggestion=f"Convert numbers stored as text: {key.name}(TRY_CAST({display} AS DOUBLE)).", + ) + return args + + +def _text_concat_args( + key: ScalarCallKey, *, number: Callable[[object], bool], boolean: Callable[[object], bool], +) -> list: + """Concatenation arguments: a number reads as its text; a BOOLEAN has no portable text.""" + for arg in key.args: + if boolean(arg): + display = _operand_display(arg) + raise ScalarOperandTypeError( + summary=f"Text concatenation has no portable spelling for the BOOLEAN `{display}`.", + suggestion=f"Spell it explicitly: CASE WHEN {display} THEN 'true' ELSE 'false' END.", + ) + return [CastKey(source=cast(ValueKey, a), type_text="TEXT", data_type=DataType.TEXT) if number(a) else a + for a in key.args] + + +def _coerce_scalar_args( + key: ScalarCallKey, *, text: Callable[[object], bool], number: Callable[[object], bool], + boolean: Callable[[object], bool], +) -> ValueKey: + args = list(key.args) + if key.name in ("greatest", "least"): + numbers = [a for a in args if number(a)] + if numbers: + args = [_as_number(cast(ValueKey, a), beside=cast(ValueKey, numbers[0])) if text(a) else a for a in args] + elif key.name in NUMERIC_ARG_SCALARS: + args = _numeric_scalar_args(key, text=text) + elif key.name in ("concat", "concat_ws"): + args = _text_concat_args(key, number=number, boolean=boolean) + if args == list(key.args): + return key + return key.model_copy(update={"args": tuple(args)}) + + def _time_search_children(key: ValueKey) -> List[ValueKey]: if isinstance(key, AggregateKey): # A transform constituent lives in the source (or a composite parameter); diff --git a/slayer/engine/ingestion.py b/slayer/engine/ingestion.py index f9d90be54..768cd12f1 100644 --- a/slayer/engine/ingestion.py +++ b/slayer/engine/ingestion.py @@ -36,8 +36,10 @@ _resolve_fallback_ref, _safe_get_columns, is_exact_numeric_db_type, + is_json_db_type, ) from slayer.sql import engine_factory, sqlite_introspect +from slayer.sql.dialects import dialect_for_ds_type from slayer.engine.schema_scope import ( SchemaRef, SkippedSchema, @@ -630,8 +632,19 @@ def _safe_get_table_comment( return None -def _introspected_column(col: dict[str, Any], *, name: str, primary_key: bool) -> IntrospectedColumn: - """One inspector column; ``db_type`` only where ``DataType`` is lossy (opaque, exact NUMERIC/DECIMAL).""" +def _sa_type_is_json(sa_type: sa.types.TypeEngine) -> bool: + """A JSON-family type (``json_value`` reads it natively): JSON / JSONB, Snowflake VARIANT / OBJECT / ARRAY.""" + sa_type = _unwrap_clickhouse_wrappers(sa_type) + names = (type(sa_type).__name__, str(sa_type)) + snowflake_array = type(sa_type).__name__.upper() == "ARRAY" and type(sa_type).__module__.startswith("snowflake") + return any(is_json_db_type(n) for n in names) or snowflake_array + + +def _introspected_column( + col: dict[str, Any], *, name: str, primary_key: bool, zoned_types: frozenset[str] = frozenset(), +) -> IntrospectedColumn: + """One inspector column; ``db_type`` only where ``DataType`` is lossy (opaque, exact NUMERIC/DECIMAL, JSON, + a zoned timestamp in ``zoned_types``).""" col_type = col["type"] db_type: str | None = None if isinstance(col_type, DataType): @@ -641,7 +654,9 @@ def _introspected_column(col: dict[str, Any], *, name: str, primary_key: bool) - else: data_type = _sa_type_to_data_type(col_type) is_float = _sa_type_is_float(col_type) - if data_type.is_opaque or _sa_type_is_exact_numeric(col_type): + if data_type.is_opaque or _sa_type_is_exact_numeric(col_type) or _sa_type_is_json(col_type) or ( + type(col_type).__name__.upper() in zoned_types + ): db_type = _raw_db_type_str(_unwrap_clickhouse_wrappers(col_type)) return IntrospectedColumn( name=name, type=data_type, primary_key=primary_key, is_float=is_float, @@ -658,9 +673,10 @@ def _introspect_query_columns_via_inspector( """Introspect the table's own columns.""" pk_constraint = _safe_get_pk_constraint(inspector, sa_engine, table_name, ref) pk_columns = set(pk_constraint.get("constrained_columns", [])) + zoned_types = dialect_for_ds_type(sa_engine.dialect.name).zoned_timestamp_db_types # Dotted names (BigQuery STRUCT subfields, quoted dotted identifiers) cannot be model columns. return [ - _introspected_column(col, name=col["name"], primary_key=col["name"] in pk_columns) + _introspected_column(col, name=col["name"], primary_key=col["name"] in pk_columns, zoned_types=zoned_types) for col in _safe_get_columns(inspector, sa_engine, table_name, ref) if "." not in col["name"] ] diff --git a/slayer/engine/introspect_utils.py b/slayer/engine/introspect_utils.py index 4805118f3..439e93dfe 100644 --- a/slayer/engine/introspect_utils.py +++ b/slayer/engine/introspect_utils.py @@ -1,6 +1,6 @@ """Dependency-free column-introspection helpers. -Extracted from ``slayer/engine/ingestion.py`` (DEV-1578) so the +Extracted from ``slayer/engine/ingestion.py`` so the forced-filter column-presence probe in ``slayer/engine/query_engine.py`` can reuse ``_safe_get_columns`` without importing ``ingestion`` (which imports ``query_engine`` — a cycle). ``ingestion`` and ``schema_drift`` @@ -24,6 +24,7 @@ _dialect_qualifies_tokens, default_schema_ref_for_engine, ) +from slayer.sql.dialects import dialect_for_ds_type # Float-like INFORMATION_SCHEMA type names _FLOAT_LIKE_INFO_SCHEMA_TYPES = frozenset( @@ -35,7 +36,7 @@ ) # Map INFORMATION_SCHEMA type names to SLayer DataTypes (for DuckDB fallback). -# DEV-1361: integer family → INT, floating family → DOUBLE. +# Integer family → INT, floating family → DOUBLE. _INFO_SCHEMA_TYPE_MAP = { # Integer family "INTEGER": DataType.INT, @@ -70,8 +71,8 @@ def _clean_comment(value: Optional[str]) -> Optional[str]: # Per-dialect column-comment queries for the fallback path. INFORMATION_SCHEMA # has no standard comment column, so each dialect needs its own source -# (DEV-1809). Each entry is ``(template, schema_clause, default_clause, -# catalog_clause)``; ``catalog_clause`` is appended (DEV-1758) only when the +# Each entry is ``(template, schema_clause, default_clause, +# catalog_clause)``; ``catalog_clause`` is appended only when the # ref carries a catalog, so a same-named table in an attached DuckDB catalog # can't cross-assign its comments. SQL Server / BigQuery are omitted: their # Inspector paths already surface comments, and their fallback equivalents are @@ -210,7 +211,7 @@ def _info_schema_columns_query( ) -> tuple[str, Dict]: """Build the parameterized INFORMATION_SCHEMA.columns query for one table. - The ``table_catalog`` predicate is added (DEV-1758) only when ``catalog`` + The ``table_catalog`` predicate is added only when ``catalog`` is supplied — a same-named table in an attached DuckDB catalog must not union its columns into this one. """ @@ -273,10 +274,18 @@ def is_exact_numeric_db_type(db_type: Optional[str]) -> bool: return "DECIMAL" in token or "NUMERIC" in token +_JSON_DB_TYPES = frozenset({"JSON", "JSONB", "VARIANT", "OBJECT"}) + + +def is_json_db_type(db_type: Optional[str]) -> bool: + """Whether ``db_type`` names a JSON-family type (JSON / JSONB, Snowflake VARIANT / OBJECT).""" + return bool(db_type) and db_type.split("(")[0].upper().strip() in _JSON_DB_TYPES + + def _info_schema_type(data_type_str: str) -> tuple[DataType, bool]: """Map an INFORMATION_SCHEMA type string to ``(DataType, is_float)``. - NUMERIC/DECIMAL resolve float-vs-integer by scale (DEV-1361). Substring + NUMERIC/DECIMAL resolve float-vs-integer by scale. Substring branches are ordered widest-match-last: ``FLOATING POINT`` and ``INTERVAL`` both contain ``INT`` but must not read as INT. """ @@ -314,6 +323,7 @@ def _get_columns_fallback( bare listing never sweeps another catalog. """ ref = _resolve_fallback_ref(sa_engine, ref) + zoned_types = dialect_for_ds_type(getattr(getattr(sa_engine, "dialect", None), "name", None)).zoned_timestamp_db_types schema = ref.name if ref else None catalog = ref.catalog if ref else None sql, params = _info_schema_columns_query( @@ -327,7 +337,10 @@ def _get_columns_fallback( # type mapping and db_type capture see the inner type. unwrapped = unwrap_clickhouse_wrapper_str(data_type_str) if data_type_str else data_type_str sa_type, is_float = _info_schema_type(unwrapped) - db_type = unwrapped if is_exact_numeric_db_type(unwrapped) else None + lossy = is_exact_numeric_db_type(unwrapped) or is_json_db_type(unwrapped) or ( + bool(unwrapped) and unwrapped.upper() in zoned_types + ) + db_type = unwrapped if lossy else None result.append({"name": col_name, "type": sa_type, "is_float": is_float, "db_type": db_type}) comments = _get_column_comments_fallback( sa_engine=sa_engine, table_name=table_name, ref=ref, diff --git a/slayer/engine/key_metadata.py b/slayer/engine/key_metadata.py index fa31e9d1d..8512cdfb3 100644 --- a/slayer/engine/key_metadata.py +++ b/slayer/engine/key_metadata.py @@ -7,7 +7,7 @@ from __future__ import annotations from decimal import Decimal -from typing import Optional, Tuple, TypeGuard +from typing import Callable, Optional, Tuple, TypeGuard from slayer.core.enums import ( AggregationValueClass, @@ -30,13 +30,14 @@ join_conditional_branch_types, temporal_type, ) -from slayer.core.join_walker import model_column_type +from slayer.core.join_walker import model_column_lookup, model_column_type from slayer.core.models import SlayerModel from slayer.core.scope import ModelScope, StageSchema from slayer.core.refs import EXPRESSION_SOURCE_KINDS from slayer.engine.introspect_utils import is_exact_numeric_db_type from slayer.engine.response_meta import _infer_aggregated_format from slayer.ir.prebound import walk_key_path +from slayer.sql.dialects import get_dialect from slayer.sql.naming import expression_source_leaf __all__ = [ @@ -157,6 +158,16 @@ def scope_column_type(*, scope: ModelScope | StageSchema, bundle) -> ColumnTypeF return model_column_type(model=scope.source_model, models_by_name=bundle.models_by_name) +def scope_zoned_timestamp(*, scope: ModelScope | StageSchema, bundle) -> Callable[[object], bool]: + """Whether a model column leaf holds a zoned instant on the bundle's dialect (a stage column already + reads naive).""" + dialect = get_dialect(bundle.dialect) + if not dialect.zoned_timestamp_db_types or isinstance(scope, StageSchema) or scope.source_model is None: + return lambda _key: False + lookup = model_column_lookup(model=scope.source_model, models_by_name=bundle.models_by_name) + return lambda key: dialect.is_zoned_db_type(getattr(lookup(key), "db_type", None)) + + def date_scalar_type(key: ValueKey, *, column_type: ColumnTypeFn) -> Optional[DataType]: """INT for ``date_part``/``date_diff``, else the key's DATE/TIMESTAMP type (date functions, temporal conditionals, min/max/first/last of a temporal value); ``None`` otherwise.""" diff --git a/slayer/engine/plan.py b/slayer/engine/plan.py index 16dbc7f00..d205357af 100644 --- a/slayer/engine/plan.py +++ b/slayer/engine/plan.py @@ -131,6 +131,7 @@ def _stage_scope_and_bundle_unframed( if sib is not None and isinstance(src, ModelExtension): base = model_from_stage_schema( name=sib, schema=stage_schemas[sib], data_source=data_source, + joins=bundle.saved_joins(sib), ) overlaid = apply_extension_overlay(base, src) others = {n: s for n, s in stage_schemas.items() if n != sib} @@ -144,12 +145,15 @@ def _stage_scope_and_bundle_unframed( if isinstance(src, str) and src in stage_schemas: synth = model_from_stage_schema( name=src, schema=stage_schemas[src], data_source=data_source, + joins=bundle.saved_joins(src), ) others = {n: s for n, s in stage_schemas.items() if n != src} sb = stage_bundle_with_siblings( bundle=bundle, source_model=synth, sibling_schemas=others, data_source=data_source, ) + if src in bundle.query_backed: + return ModelScope(source_model=synth), sb return stage_schemas[src], sb # 3. Model-scoped: the stage's own resolved source model. diff --git a/slayer/engine/query_engine.py b/slayer/engine/query_engine.py index c4c162c2d..7deeba6e2 100644 --- a/slayer/engine/query_engine.py +++ b/slayer/engine/query_engine.py @@ -116,7 +116,7 @@ is_spliced, plan_has_semi_join_filters, plans_read_clock, - plans_try_cast, + planned_keys, ) from slayer.engine.schema_drift import ( AppliedEntry, @@ -753,10 +753,10 @@ def _apply_policy( async def _render_dialect( self, *, dialect: str, datasource: DatasourceConfig, planned_list, ) -> "str | SqlDialect": - """``dialect``, carrying the server profile when rendering a ``TRY_CAST`` reads it; an unreadable + """``dialect``, carrying the server profile when rendering the plan reads it; an unreadable profile renders as an unknown server.""" sql_dialect = get_dialect(dialect) - if not sql_dialect.try_cast_reads_profile or not plans_try_cast(planned_list): + if not sql_dialect.profile_needed(planned_keys(planned_list)): return dialect try: profile = await self._client_for(datasource).server_profile() diff --git a/slayer/engine/schema_drift.py b/slayer/engine/schema_drift.py index d23680277..633399a71 100644 --- a/slayer/engine/schema_drift.py +++ b/slayer/engine/schema_drift.py @@ -68,6 +68,7 @@ from slayer.sql.client import SlayerSQLClient, build_sql_model_trial_query from slayer.sql.dialects import dialect_for_ds_type from slayer.sql.engine_factory import EngineCacheKey, _sql_client_cache_key +from slayer.ir.source_bundle import added_joins logger = logging.getLogger(__name__) @@ -769,6 +770,8 @@ def _build_stage_graph( extension_joins = _stage_source_joins(stage) extension_targets = {j.target_model for j in extension_joins} base = models_by_name.get(stage_source_name) if stage_source_name else None + if base is not None: + extension_joins = added_joins(base=base, joins=extension_joins) source = base.model_copy(update={"joins": [*base.joins, *extension_joins]}) if base is not None else None models = {**models_by_name, source.name: source} if source is not None else models_by_name roots = [source] if source is not None else [models[t] for t in sorted(extension_targets) if t in models] diff --git a/slayer/ir/planned.py b/slayer/ir/planned.py index e9b3d88ec..fb351f966 100644 --- a/slayer/ir/planned.py +++ b/slayer/ir/planned.py @@ -20,7 +20,6 @@ AggregateKey, LiteralKey, Phase, - CastKey, ScalarCallKey, TransformKey, ValueKey, @@ -776,14 +775,9 @@ def plan_value_keys(planned) -> Iterator[ValueKey]: yield from _walk_plan_keys(planned, set()) -def plans_try_cast(planned_list) -> bool: - """Whether any plan renders a ``TRY_CAST``.""" - return any( - isinstance(k, CastKey) and k.try_ - for planned in planned_list - for root in plan_value_keys(planned) - for k in walk_value_keys(root) - ) +def planned_keys(planned_list) -> Iterator[ValueKey]: + """Every key, nested ones included, that rendering ``planned_list`` reads.""" + return (k for planned in planned_list for root in plan_value_keys(planned) for k in walk_value_keys(root)) def plans_read_clock(planned_list) -> bool: diff --git a/slayer/ir/source_bundle.py b/slayer/ir/source_bundle.py index 98e8bb172..935492569 100644 --- a/slayer/ir/source_bundle.py +++ b/slayer/ir/source_bundle.py @@ -11,8 +11,10 @@ from slayer.core.enums import DataType from slayer.core.granularity import CustomGranularity +from slayer.core.join_edges import same_edge from slayer.core.models import ( Column, + ModelJoin, SlayerModel, _check_column_measure_namespace, _check_join_keys, @@ -24,6 +26,7 @@ __all__ = [ "resolve_scope", "ResolvedSourceBundle", + "added_joins", "apply_extension_overlay", "as_extension_over_nonsibling", "follow_sibling_chain", @@ -50,7 +53,7 @@ class ResolvedSourceBundle(BaseModel): dialect: str # sqlglot dialect the query renders in # Minted stage identity → its user-facing spelling. stage_displays: Dict[str, StageDisplay] = Field(default_factory=dict) - # Stored query-backed models the statement may splice (stored form, joins dropped). + # Stored query-backed models the statement may splice, including result joins. query_backed: Dict[str, SlayerModel] = Field(default_factory=dict) # Query-backed models whose stages are being planned, outermost first. splice_chain: Tuple[str, ...] = () @@ -71,6 +74,11 @@ def get_referenced_model(self, name: str) -> Optional[SlayerModel]: return m return None + def saved_joins(self, name: str) -> List[ModelJoin]: + """The declared joins of stored query-backed model ``name``; none for any other stage.""" + saved = self.query_backed.get(name) + return list(saved.joins) if saved is not None else [] + def factor_free(self, model: SlayerModel) -> SlayerModel: """``model`` as stored: a population without its product hops.""" if model.unrelated_datasets: @@ -105,6 +113,11 @@ def models_by_name(self) -> Dict[str, SlayerModel]: return out +def added_joins(*, base: SlayerModel, joins: Optional[List[ModelJoin]]) -> List[ModelJoin]: + """Extension ``joins`` new to ``base``: one repeating a stored join is that edge.""" + return [j for j in joins or [] if not any(same_edge(j, s) for s in base.joins)] + + def apply_extension_overlay( base: SlayerModel, ext: ModelExtension ) -> SlayerModel: @@ -118,7 +131,7 @@ def apply_extension_overlay( update={ "columns": list(base.columns) + list(ext.columns or []), "measures": overlay_measures, - "joins": list(base.joins) + list(ext.joins or []), + "joins": list(base.joins) + added_joins(base=base, joins=ext.joins), } ) # model_copy runs no validators; re-run the namespace and join-key checks @@ -185,6 +198,7 @@ def model_from_stage_schema( sql: Optional[str] = None, column_sql: Optional[Dict[str, str]] = None, default_time_dimension: Optional[str] = None, + joins: Optional[List[ModelJoin]] = None, ) -> SlayerModel: """The model a stage's output is read as: over its CTE (``sql=None``) or over ``sql``. @@ -213,10 +227,14 @@ def model_from_stage_schema( for c in schema.columns ], ) + joins = joins or [] + # Joins attach after the rename (validators skip model_copy), so check their keys here. + _check_join_keys(model_name=name, columns=model.columns, joins=joins) # A minted stage identity carries the reserved prefix the name validator rejects. return model.model_copy(update={ "name": name, "sql_table": name if sql is None else None, "default_time_dimension": default_time_dimension or schema.default_time_dimension, + "joins": joins, }).with_spelling(schema.display_name if schema.display_name != name else None) @@ -237,7 +255,7 @@ def stage_bundle_with_siblings( """ synths = [ model_from_stage_schema( - name=n, schema=s, data_source=data_source + name=n, schema=s, data_source=data_source, joins=bundle.saved_joins(n), ) for n, s in sibling_schemas.items() ] diff --git a/slayer/memories/help_content/07_queries.md b/slayer/memories/help_content/07_queries.md index e14408356..08e30dafd 100644 --- a/slayer/memories/help_content/07_queries.md +++ b/slayer/memories/help_content/07_queries.md @@ -30,6 +30,14 @@ A query with dimensions only returns distinct combinations; set `limit`, the MCP response stops at 20 rows with a notice; for a longer list set a `limit` that covers it. Use `limit` for top N, never to cut a list asked for in full. +## Functions + +Conditions and formulas take one portable library with the same meaning on every +database: strings (`left`, `split_part`, `concat_ws`, ...), math (`div`, `atan2`, ...), +regex (`regexp_like(x, 'p')`, `x ~ 'p'`, `regexp_extract`, `regexp_replace`), JSON +(`json_value(x, '$.a' RETURNING INT)`, `x ->> 'a'`); text compared with a number reads as +a number (`amount_txt > 100`). + ## Variables `{name}` placeholders in conditions, formulas and `date_range` bounds take values from diff --git a/slayer/sql/dialects/base.py b/slayer/sql/dialects/base.py index e91175641..df45c1228 100644 --- a/slayer/sql/dialects/base.py +++ b/slayer/sql/dialects/base.py @@ -7,7 +7,7 @@ from datetime import date, datetime from functools import lru_cache from typing import TYPE_CHECKING, Any, ClassVar, Literal, Optional, TypeGuard, get_args -from collections.abc import Callable, Sequence +from collections.abc import Callable, Iterable, Sequence from pydantic import BaseModel, ConfigDict from sqlalchemy.engine.url import make_url @@ -19,8 +19,12 @@ from sqlglot.errors import SqlglotError from slayer.core.enums import SUB_DAY_GRANULARITIES, DataType, DatePart, TimeGranularity -from slayer.core.errors import IdentifierCollisionError, IdentifierLengthError +from slayer.core.errors import IdentifierCollisionError, IdentifierLengthError, ServerVersionError from slayer.core.granularity import CustomGranularity, Granularity, granularity_parts, nests_into +from slayer.core.json_path import JsonPath +from slayer.core.like_pattern import LikePattern +from slayer.core.regex_pattern import RegexPattern, RegexReplacement +from slayer.sql.dialects.patterns import POSTGRES, RegexFlavour, emit_regex, emit_replacement, like_expression, like_text from slayer.sql._identifier_fit import ( SqlLexis, fit_identifier, @@ -82,6 +86,77 @@ def is_stat_agg2(name: str) -> TypeGuard[StatAgg2Name]: return name in get_args(StatAgg2Name) +TextFn = Literal[ + "left", "right", "starts_with", "ends_with", "contains", "lpad", "rpad", "reverse", "repeat", "concat_ws", + "chr", "ascii", "trim", "ltrim", "rtrim", "strpos", "instr", "replace", +] +TrimFn = Literal["trim", "ltrim", "rtrim"] +MathFn = Literal["div", "pi", "sin", "cos", "tan", "asin", "acos", "atan", "atan2", "cbrt"] +ExtremumFn = Literal["greatest", "least"] + + +def is_text_fn(name: str) -> TypeGuard[TextFn]: + return name in get_args(TextFn) + + +def is_math_fn(name: str) -> TypeGuard[MathFn]: + return name in get_args(MathFn) + + +def is_extremum_fn(name: str) -> TypeGuard[ExtremumFn]: + return name in get_args(ExtremumFn) + + +def anon(name: str, *args: Expression) -> exp.Anonymous: + """``NAME(args)`` emitted as written on every dialect (no transpilation).""" + return exp.Anonymous(this=name, expressions=[a.copy() for a in args]) + + +def case(*branches: tuple[Expression, Expression], default: Optional[Expression] = None) -> exp.Case: + return exp.Case(ifs=[exp.If(this=c, true=v) for c, v in branches], default=default) + + +def lit(value: int | str) -> Expression: + return exp.Literal.number(value) if isinstance(value, int) else exp.Literal.string(value) + + +def is_null(value: Expression) -> Expression: + return exp.Is(this=operand_copy(value), expression=exp.Null()) + + +def either(*conditions: Expression) -> Expression: + """``c1 OR c2 OR …``.""" + out = conditions[0] + for condition in conditions[1:]: + out = exp.Or(this=out, expression=condition) + return out + + +def any_null(*values: Expression) -> Expression: + return either(*(is_null(v) for v in values)) + + +def func(name: str, *args: Expression) -> Expression: + """``exp.func``: the named sqlglot function, transpiled per dialect.""" + node = exp.func(name, *(a.copy() for a in args)) + assert isinstance(node, Expression) # concrete Func classes and Anonymous all are + return node + + +def pad_fill(args: Sequence[Expression]) -> Expression: + """``lpad`` / ``rpad``'s fill: the third argument, else one space.""" + return args[2] if len(args) > 2 else lit(" ") + + +def literal_value(node: Expression) -> Optional[int]: + """An integer literal's value (``-2`` included), else ``None``.""" + return literal_int(node) + + +#: Code points ``chr`` takes: 1 to 0x10FFFF without the surrogates. +CHR_RANGES = ((1, 0xD7FF), (0xE000, 0x10FFFF)) + + _OPERATOR_SHAPED = (exp.Binary, exp.Unary, exp.Between, exp.In) @@ -113,6 +188,25 @@ def iso_text(value: date) -> str: FALSE_WORDS = ("false", "f", "no", "0") +#: ``meta`` tag on the cast ``read_column`` wraps around a zoned column. +ZONED_READ = "slayer_zoned_read" + + +def bare_comparands(left: Expression, right: Expression) -> tuple[Expression, Expression]: + """A zoned column read stays bare where the other side is already in the zoned type (a ``TIMESTAMP`` + cast, ISO text, another zoned column), so the comparison keeps partition pruning.""" + def zoned(node: Expression) -> bool: + return isinstance(node, exp.Cast) and bool(node.meta.get(ZONED_READ)) + + def in_zoned_type(node: Expression) -> bool: + return zoned(node) or (isinstance(node, exp.Literal) and node.is_string) or ( + isinstance(node, exp.Cast) and node.to.this is exp.DataType.Type.TIMESTAMPTZ) + + new_left = left.this if zoned(left) and in_zoned_type(right) else left + new_right = right.this if zoned(right) and in_zoned_type(left) else right + return new_left, new_right + + def as_text(value: Expression) -> Expression: """``CAST(value AS TEXT)`` — the input a validity check reads.""" return exp.Cast(this=value.copy(), to=exp.DataType.build("TEXT")) @@ -325,10 +419,8 @@ class SqlDialect(BaseModel): # Whether setting the statement timeout depends on the server profile (probed only then). timeout_reads_profile: bool = False - # The server's profile, when SQL generation needs it (Postgres TRY_CAST); unknown otherwise. + # The server's profile, when SQL generation reads it (``profile_needed``); unknown otherwise. server_profile: ServerProfile = ServerProfile() - # Whether rendering a TRY_CAST reads ``server_profile``. - try_cast_reads_profile: bool = False # An ``IN`` subquery and its joins run once on the initiator (``GLOBAL``): exact over shards. global_in_subqueries: bool = False @@ -379,6 +471,21 @@ def cast_type_supported(self, data_type: exp.DataType) -> bool: """Whether this dialect can express a CAST to ``data_type``.""" return data_type.this not in VENDOR_ONLY_CAST_TYPES or data_type.this in self.vendor_cast_types + #: Column ``db_type``s holding a zoned instant where SLayer's TIMESTAMP is naive (BigQuery ``TIMESTAMP``). + zoned_timestamp_db_types: ClassVar[frozenset[str]] = frozenset() + + def is_zoned_db_type(self, db_type: Optional[str]) -> bool: + """Whether a column of ``db_type`` holds a zoned instant on this dialect.""" + return bool(db_type) and db_type.split("(")[0].strip().upper() in self.zoned_timestamp_db_types + + def read_column(self, column: Expression, *, zoned: bool) -> Expression: # NOSONAR(S1172) — hook parameter read by dialect overrides + """A column as SLayer reads it; default: as stored.""" + return column + + def try_cast_type(self, to: exp.DataType, *, data_type: DataType) -> exp.DataType: # NOSONAR(S1172) — hook parameter read by dialect overrides + """The portable ``TRY_CAST`` target of a cast to ``data_type``; default: the database's own type.""" + return to + def build_try_cast(self, value: Expression, to: exp.DataType) -> Expression: """``TRY_CAST``: NULL for an input the cast cannot convert; the input is read as text first.""" return exp.TryCast(this=as_text(value), to=to) @@ -391,6 +498,289 @@ def build_ilike(self, value: Expression, pattern: Expression) -> Expression: return exp.ILike(this=value, expression=pattern) return exp.Like(this=exp.Lower(this=value), expression=exp.Lower(this=pattern)) + # -- The portable library (spec: queries/scalar-functions, regex, json, string-matching) ------- + + #: How this engine spells the portable regex. + regex_flavour: ClassVar[RegexFlavour] = POSTGRES + #: This engine's JSON column types (a column of one is read natively by ``json_value``). + json_db_types: ClassVar[frozenset[str]] = frozenset({"JSON"}) + #: Whether LIKE takes ``ESCAPE '\'`` (else backslash already escapes). + like_escape_clause: ClassVar[bool] = True + #: Whether ``[`` is a LIKE metacharacter (SQL Server). + like_brackets: ClassVar[bool] = False + + def profile_needed(self, keys: Iterable[object]) -> bool: # NOSONAR(S1172) — no-op hook default + """Whether rendering ``keys`` reads ``server_profile``.""" + return False + + def require_version(self, *, minimum: tuple[int, int], what: str, release: str) -> None: + """Fail closed when the known server version is below ``minimum``; an unknown version emits.""" + version = self.server_profile.version + if version is not None and version < minimum: + raise ServerVersionError( + summary=f"{what} needs {release} or later; the server reports version {version[0]}.{version[1]}.", + suggestion=f"Upgrade to {release}, or express the computation without {what}.", + ) + + def char_length(self, value: Expression) -> Expression: + """The length of ``value`` in characters.""" + return self.rewrite_target_ast(exp.Length(this=value.copy())) + + def char_substring(self, value: Expression, start: Expression, length: Expression) -> Expression: + """``length`` characters of ``value`` from the 1-based ``start``.""" + return self.rewrite_target_ast(exp.Substring(this=value.copy(), start=start.copy(), length=length.copy())) + + def text_repeat(self, value: Expression, count: Expression) -> Expression: + """``value`` repeated ``count`` (≥ 1) times.""" + return anon("REPEAT", value, count) + + def truncate(self, value: Expression) -> Expression: + """``value`` truncated toward zero.""" + return self.rewrite_target_ast(func("TRUNC", value)) + + def build_text_call(self, fn: TextFn, args: tuple[Expression, ...]) -> Expression: + """A library string function with its Postgres meaning (characters, never bytes).""" + s = args[0] + if fn in ("trim", "ltrim", "rtrim"): + return self.trim_spaces(fn, s) + if fn in ("left", "right"): + return self._left_right(fn=fn, s=s, n=args[1]) + if fn == "starts_with": + head = self.char_substring(s, lit(1), self.char_length(args[1])) + return exp.EQ(this=self.binary_text(head), expression=self.binary_text(args[1])) + if fn == "ends_with": + p = args[1] + start = case((exp.GTE(this=self.char_length(s), expression=self.char_length(p)), + exp.Add(this=exp.Sub(this=self.char_length(s), expression=self.char_length(p)), + expression=lit(1))), default=lit(1)) + tail = self.char_substring(s, start, self.char_length(p)) + return exp.EQ(this=self.binary_text(tail), expression=self.binary_text(p)) + if fn == "contains": + return exp.GT(this=self.text_position(s, args[1]), expression=lit(0)) + if fn in ("strpos", "instr"): + return self.text_position(s, args[1]) + if fn == "replace": + return self.rewrite_target_ast(func("REPLACE", *args)) + if fn in ("lpad", "rpad"): + return self._pad(fn=fn, s=s, n=args[1], fill=pad_fill(args)) + if fn == "reverse": + return anon("REVERSE", s) + if fn == "repeat": + return self._non_positive_empty(args[1], self.text_repeat(s, args[1]), source=s) + if fn == "concat_ws": + return anon("CONCAT_WS", *args) + if fn == "chr": + return self._code_point_guard(s, self.code_point_char(s)) + return self.first_code_point(s) + + def binary_text(self, value: Expression) -> Expression: + """``value`` compared case- and accent-sensitively whatever its collation; default: as is.""" + return value.copy() + + def text_position(self, s: Expression, p: Expression) -> Expression: + """The 1-based character position of the first ``p`` in ``s``, 0 when absent, compared binary.""" + return self.rewrite_target_ast(exp.StrPosition(this=self.binary_text(s), substr=self.binary_text(p))) + + def trim_spaces(self, fn: TrimFn, s: Expression) -> Expression: + """Postgres ``trim`` / ``ltrim`` / ``rtrim``: spaces only, never other whitespace.""" + return self.rewrite_target_ast(func(fn.upper(), s)) + + def _left_right(self, *, fn: TextFn, s: Expression, n: Expression) -> Expression: + """Postgres ``left`` / ``right``: a negative count drops that many characters from the other end.""" + length = self.char_length(s) + kept = exp.Add(this=length, expression=n.copy()) + if fn == "left": + positive = self.char_substring(s, lit(1), n) + negative = self.char_substring(s, lit(1), kept) + else: + positive = self.char_substring(s, exp.Add(this=exp.Sub(this=length.copy(), expression=n.copy()), + expression=lit(1)), n) + negative = self.char_substring(s, exp.Sub(this=lit(1), expression=n.copy()), kept.copy()) + branches: list[tuple[Expression, Expression]] = [(any_null(s, n), exp.Null())] + if fn == "right": + branches.append((exp.GTE(this=n.copy(), expression=length.copy()), s.copy())) + branches += [(exp.GTE(this=n.copy(), expression=lit(0)), positive), + (exp.GT(this=kept.copy(), expression=lit(0)), negative)] + return case(*branches, default=lit("")) + + def _non_positive_empty(self, n: Expression, value: Expression, *, source: Expression) -> Expression: + """``value``, or ``''`` for a count ≤ 0 (a NULL ``source`` stays NULL).""" + count = literal_value(n) + if count is not None: + return value if count > 0 else case((exp.Not(this=any_null(source)), lit(""))) + return case((exp.LTE(this=n.copy(), expression=lit(0)), case((exp.Not(this=any_null(source)), lit("")))), + default=value) + + def _pad(self, *, fn: TextFn, s: Expression, n: Expression, fill: Expression) -> Expression: + node = anon("LPAD" if fn == "lpad" else "RPAD", s, n, fill) + return self._non_positive_empty(n, node, source=s) + + def portable_pad(self, *, fn: TextFn, s: Expression, n: Expression, fill: Expression) -> Expression: + """``lpad`` / ``rpad`` built from substring and repeat, for an engine without them.""" + length = self.char_length(s) + padding = self.char_substring(self.text_repeat(fill, n), lit(1), exp.Sub(this=n.copy(), expression=length)) + padded = self.concat_text(padding, s) if fn == "lpad" else self.concat_text(s, padding) + return case( + (any_null(s, n, fill), exp.Null()), + (exp.LTE(this=n.copy(), expression=lit(0)), lit("")), + (exp.GTE(this=length.copy(), expression=n.copy()), self.char_substring(s, lit(1), n)), + (exp.EQ(this=self.char_length(fill), expression=lit(0)), s.copy()), + default=padded, + ) + + def concat_text(self, left: Expression, right: Expression) -> Expression: + return exp.DPipe(this=left.copy(), expression=right.copy()) + + def field_count(self, value: Expression, delimiter: Expression) -> Expression: + """How many ``delimiter``-separated fields ``value`` has.""" + removed = self.char_length(anon("REPLACE", value, delimiter, lit(""))) + gap = exp.Paren(this=exp.Sub(this=self.char_length(value), expression=removed)) + per_field = exp.Nullif(this=self.char_length(delimiter), expression=lit(0)) + return exp.Add(this=exp.IntDiv(this=gap, expression=per_field), expression=lit(1)) + + def code_point_char(self, n: Expression) -> Expression: + """The character of Unicode code point ``n`` (in range).""" + return anon("CHR", n) + + def _code_point_guard(self, n: Expression, value: Expression) -> Expression: + """``value`` where ``n`` is a Unicode scalar value, else NULL.""" + inside = either(*(exp.Between(this=n.copy(), low=lit(lo), high=lit(hi)) for lo, hi in CHR_RANGES)) + return case((inside, value)) + + def first_code_point(self, s: Expression) -> Expression: + """The code point of ``s``'s first character; 0 for ``''``.""" + return anon("ASCII", s) + + def build_split_part(self, value: Expression, delimiter: Expression, index: int) -> Expression: + """The ``index``-th field (negative: from the end); ``''`` beyond the last.""" + return anon("SPLIT_PART", value, delimiter, lit(index)) + + def build_math_call(self, fn: MathFn, args: tuple[Expression, ...]) -> Expression: + """A library math function; an out-of-domain argument yields NULL.""" + if fn == "div": + divisor = exp.Nullif(this=operand_copy(args[1]), expression=lit(0)) + return self.truncate(exp.Div(this=operand_copy(args[0]), expression=divisor)) + if fn == "pi": + return anon("PI") + if fn in ("asin", "acos"): + inside = exp.Between(this=args[0].copy(), low=lit(-1), high=lit(1)) + return case((inside, self.rewrite_target_ast(func(fn.upper(), args[0])))) + if fn == "cbrt": + return self.cube_root(args[0]) + return self.rewrite_target_ast(func(fn.upper(), *args)) + + def cube_root(self, value: Expression) -> Expression: + return anon("CBRT", value) + + def build_extremum(self, fn: ExtremumFn, args: tuple[Expression, ...]) -> Expression: + """``greatest`` / ``least`` of the non-NULL arguments; NULL only when all are NULL.""" + return anon(fn.upper(), *args) + + def coalesced_extremum( + self, fn: ExtremumFn, args: tuple[Expression, ...], *, spelling: Literal["upper", "lower", "min_max"], + ) -> Expression: + """``GREATEST(COALESCE(a, b, c), COALESCE(b, a, c), …)`` for an engine whose function propagates NULL + (``min_max``: the scalar ``MAX`` / ``MIN``).""" + terms = [exp.Coalesce(this=a.copy(), expressions=[o.copy() for j, o in enumerate(args) if j != i]) + for i, a in enumerate(args)] + name = {"upper": fn.upper(), "lower": fn, "min_max": "MAX" if fn == "greatest" else "MIN"}[spelling] + return anon(name, *terms) + + def build_modulo(self, left: Expression, right: Expression, integer: bool) -> Expression: # NOSONAR(S1172) — hook parameter read by dialect overrides + """``left % right`` truncated (the result takes the dividend's sign); ``integer``: both are integers.""" + return exp.Mod(this=operand_copy(left), expression=operand_copy(right)) + + # Regex + + def regex_text( + self, pattern: RegexPattern, *, case_insensitive: bool = False, capture: Optional[int] = None, + wrap: bool = False, anchored: bool = False, + ) -> Expression: + return lit(emit_regex(pattern, self.regex_flavour, case_insensitive=case_insensitive, capture=capture, + wrap=wrap, anchored=anchored)) + + def replacement_text(self, replacement: RegexReplacement) -> Expression: + return lit(emit_replacement(replacement, self.regex_flavour)) + + def build_regexp_like(self, value: Expression, pattern: RegexPattern, case_insensitive: bool) -> Expression: + """Whether ``pattern`` matches anywhere in ``value``.""" + node = exp.RegexpILike if case_insensitive else exp.RegexpLike + return node(this=value.copy(), expression=self.regex_text(pattern)) + + def build_regexp_extract( + self, value: Expression, pattern: RegexPattern, group: int, case_insensitive: bool, + ) -> Expression: + """The first match (``group`` 0) or its ``group``; NULL on no match, ``''`` for a group that did not + take part.""" + match = anon("REGEXP_MATCH", value, self.regex_text(pattern, wrap=True), + *([lit("i")] if case_insensitive else [])) + picked = exp.Bracket(this=exp.Paren(this=match), expressions=[lit(group)]) + return self.skipped_group_empty(value, pattern, group, picked) + + def skipped_group_empty( + self, value: Expression, pattern: RegexPattern, group: int, extracted: Expression, + ) -> Expression: + """``extracted`` with a skipped group's NULL read as ``''`` (NULL stays for no match).""" + if group == 0: + return extracted + matched = self.build_regexp_like(value, pattern, False) + return case((matched, exp.Coalesce(this=extracted, expressions=[lit("")]))) + + def build_regexp_replace( + self, value: Expression, pattern: RegexPattern, replacement: RegexReplacement, case_insensitive: bool, + ) -> Expression: + """``value`` with every match replaced.""" + return anon("REGEXP_REPLACE", value, self.regex_text(pattern), self.replacement_text(replacement), + lit("gi" if case_insensitive else "g")) + + # LIKE + + def like_pattern(self, pattern: LikePattern | Expression) -> Expression: + """The pattern as this engine's backslash-escaped LIKE text.""" + if isinstance(pattern, LikePattern): + return lit(like_text(pattern, brackets=self.like_brackets)) + return like_expression(pattern.copy(), brackets=self.like_brackets) + + def build_like( + self, value: Expression, pattern: LikePattern | Expression, case_insensitive: bool, + ) -> Expression: + """``LIKE`` / ``ILIKE`` in the one LIKE pattern language.""" + text = self.like_pattern(pattern) + if not case_insensitive: + node: Expression = exp.Like(this=value.copy(), expression=text) + elif self.ilike_native: + node = exp.ILike(this=value.copy(), expression=text) + else: + node = exp.Like(this=exp.Lower(this=value.copy()), expression=exp.Lower(this=text)) + return exp.Escape(this=node, expression=lit("\\")) if self.like_escape_clause else node + + # JSON + + def build_json_value(self, value: Expression, path: JsonPath, native: bool) -> Expression: + """The scalar at ``path`` as TEXT; NULL when missing, JSON null, an object or an array.""" + jsonb = exp.DataType.build("JSONB") + already = isinstance(value, exp.Cast) and value.to.is_type(exp.DataType.Type.JSONB) + doc = value.copy() if already else exp.Cast(this=value.copy(), to=jsonb) + keys = [lit(str(step)) for step in path.steps] + found = anon("JSONB_EXTRACT_PATH", doc, *keys) + scalar = exp.In(this=anon("JSONB_TYPEOF", found), expressions=[lit("string"), lit("number"), lit("boolean")]) + read = case((scalar, anon("JSONB_EXTRACT_PATH_TEXT", doc, *keys))) + if native or not self.validates_json_input(): + return read + valid = anon("PG_INPUT_IS_VALID", as_text(value), lit("jsonb")) + return case((valid, read)) + + def validates_json_input(self) -> bool: + """Whether malformed JSON text can be detected (Postgres 16+).""" + version = self.server_profile.version + return version is not None and version >= (16, 0) + + def build_json_value_as( + self, value: Expression, path: JsonPath, native: bool, to: exp.DataType, target: DataType, # NOSONAR(S1172) — hook parameter read by dialect overrides + ) -> Expression: + """``json_value(… RETURNING target)``: the scalar converted, NULL where it cannot convert.""" + return self.build_try_cast(self.build_json_value(value, path, native), to) + def build_null_safe_eq( self, left: Expression, right: Expression, ) -> Expression: diff --git a/slayer/sql/dialects/bigquery.py b/slayer/sql/dialects/bigquery.py index 70b73ded4..f6fa262a1 100644 --- a/slayer/sql/dialects/bigquery.py +++ b/slayer/sql/dialects/bigquery.py @@ -16,14 +16,27 @@ from sqlglot.expressions.core import Expression from slayer.core.enums import SUB_DAY_GRANULARITIES, DataType, DatePart, TimeGranularity +from slayer.core.json_path import JsonPath +from slayer.core.regex_pattern import RegexPattern, RegexReplacement from slayer.sql.dialects.base import ( COMPARISON_NODES, DottedAliasManglingMixin, + ExtremumFn, + MathFn, SqlDialect, TemporalComparisonOp, + TextFn, + ZONED_READ, + TrimFn, _digest, + anon, + any_null, + case, iso_text, + lit, + operand_copy, ) +from slayer.sql.dialects.patterns import RE2, RegexFlavour from slayer.sql.dialects.drivers import import_driver if TYPE_CHECKING: @@ -33,6 +46,7 @@ # Caveat: a single-backticked word-only path like `ds.tbl` false-positive mangles; quote segments singly. _DOTTED_ALIAS_RE = re.compile(r"`(\w+(?:\.\w+)+)`", re.ASCII) _WEEK_ANCHORS = {TimeGranularity.WEEK: "MONDAY", TimeGranularity.WEEK_SUNDAY: "SUNDAY"} +_DATETIME = exp.DataType.build("DATETIME") def _date_part_unit(unit: TimeGranularity) -> Expression: @@ -98,7 +112,7 @@ class BigqueryDialect(DottedAliasManglingMixin, SqlDialect): explain_prefix: str | None = None explain_postfix: str = "" log10_native: bool = True - log2_native: bool = True + log2_native: bool = False max_identifier_bytes: int | None = 300 # column-name limit approx_count_distinct_native: bool = True url_scheme: str | None = "bigquery" @@ -106,6 +120,65 @@ class BigqueryDialect(DottedAliasManglingMixin, SqlDialect): dotted_alias_re: ClassVar[re.Pattern[str]] = _DOTTED_ALIAS_RE alias_quote_open: ClassVar[str] = "`" alias_quote_close: ClassVar[str] = "`" + regex_flavour: ClassVar[RegexFlavour] = RE2 + like_escape_clause: ClassVar[bool] = False + zoned_timestamp_db_types: ClassVar[frozenset[str]] = frozenset({"TIMESTAMP"}) + + def build_text_call(self, fn: TextFn, args: tuple[Expression, ...]) -> Expression: + if fn == "concat_ws": + return anon("ARRAY_TO_STRING", exp.Array(expressions=[a.copy() for a in args[1:]]), args[0]) + if fn == "ascii": + return anon("UNICODE", args[0]) + return super().build_text_call(fn, args) + + def trim_spaces(self, fn: TrimFn, s: Expression) -> Expression: + """The bare form strips every whitespace character.""" + return anon(fn.upper(), s, lit(" ")) + + def build_split_part(self, value: Expression, delimiter: Expression, index: int) -> Expression: + """``SPLIT`` indexed by ``SAFE_ORDINAL`` (reversed for a negative index); ``''`` past the end.""" + fields = anon("SPLIT", value, delimiter) + if index < 0: + fields = anon("ARRAY_REVERSE", fields) + picked = exp.Bracket(this=fields, expressions=[lit(abs(index))], safe=True, offset=1) + return case((any_null(value, delimiter), exp.Null()), default=exp.Coalesce(this=picked, expressions=[lit("")])) + + def build_math_call(self, fn: MathFn, args: tuple[Expression, ...]) -> Expression: + if fn == "pi": + return anon("ACOS", lit(-1)) + return super().build_math_call(fn, args) + + def build_modulo(self, left: Expression, right: Expression, integer: bool) -> Expression: + """``MOD`` takes no FLOAT64: ``a - b * TRUNC(a / b)``.""" + if integer: + return super().build_modulo(left, right, integer) + quotient = self.truncate(exp.Div(this=operand_copy(left), expression=exp.Nullif(this=operand_copy(right), + expression=lit(0)))) + return exp.Paren(this=exp.Sub(this=operand_copy(left), expression=exp.Mul(this=operand_copy(right), + expression=quotient))) + + def build_extremum(self, fn: ExtremumFn, args: tuple[Expression, ...]) -> Expression: + """``GREATEST`` / ``LEAST`` return NULL when any argument is NULL.""" + return self.coalesced_extremum(fn, args, spelling="upper") + + def build_regexp_like(self, value: Expression, pattern: RegexPattern, case_insensitive: bool) -> Expression: + return anon("REGEXP_CONTAINS", value, self.regex_text(pattern, case_insensitive=case_insensitive)) + + def build_regexp_extract( + self, value: Expression, pattern: RegexPattern, group: int, case_insensitive: bool, + ) -> Expression: + """``REGEXP_EXTRACT`` takes at most one capturing group: every other one becomes non-capturing.""" + extracted = anon("REGEXP_EXTRACT", value, self.regex_text(pattern, capture=group)) + return self.skipped_group_empty(value, pattern, group, extracted) + + def build_regexp_replace( + self, value: Expression, pattern: RegexPattern, replacement: RegexReplacement, case_insensitive: bool, + ) -> Expression: + return anon("REGEXP_REPLACE", value, self.regex_text(pattern, case_insensitive=case_insensitive), + self.replacement_text(replacement)) + + def build_json_value(self, value: Expression, path: JsonPath, native: bool) -> Expression: + return anon("JSON_VALUE", value, lit(path.text)) def build_date_trunc( self, @@ -122,7 +195,7 @@ def build_date_trunc( col_expr=col_expr, granularity=granularity, ) if not isinstance(col_expr, (exp.Column, exp.Cast)): - col_expr = exp.Cast(this=col_expr, to=exp.DataType.build("TIMESTAMP")) + col_expr = self.promote_to_timestamp(col_expr) week = exp.Anonymous(this="WEEK", expressions=[exp.var(weekday)]) return exp.Anonymous(this="DATE_TRUNC", expressions=[col_expr, week]) @@ -135,7 +208,22 @@ def build_integer_sequence(self, *, size: int) -> exp.Select: )) def promote_to_timestamp(self, expr: Expression) -> Expression: - return exp.Cast(this=expr.copy(), to=exp.DataType.build("TIMESTAMPTZ")) + """SLayer's TIMESTAMP is naive: ``DATETIME`` (a zoned ``TIMESTAMP`` reads as its UTC wall clock).""" + already = (isinstance(expr, exp.Cast) and expr.to.this is exp.DataType.Type.DATETIME) or ( + isinstance(expr, exp.Anonymous) and expr.name.upper() == "CURRENT_DATETIME") + return expr.copy() if already else exp.Cast(this=expr.copy(), to=_DATETIME.copy()) + + def read_column(self, column: Expression, *, zoned: bool) -> Expression: + """A zoned ``TIMESTAMP`` reads as its UTC wall clock; a comparison unwraps it (``bare_comparands``).""" + if not zoned: + return column + read = exp.Cast(this=column, to=_DATETIME.copy()) + read.meta[ZONED_READ] = True + return read + + def try_cast_type(self, to: exp.DataType, *, data_type: DataType) -> exp.DataType: + zoned = to.this is exp.DataType.Type.TIMESTAMPTZ + return _DATETIME.copy() if data_type is DataType.TIMESTAMP and zoned else to def build_temporal_literal(self, *, value: date, dt: DataType) -> Expression: if dt is DataType.DATE: @@ -143,7 +231,7 @@ def build_temporal_literal(self, *, value: date, dt: DataType) -> Expression: return self.promote_to_timestamp(exp.Literal.string(iso_text(value))) def build_current_timestamp(self) -> Expression: - return exp.CurrentTimestamp() + return anon("CURRENT_DATETIME") def build_temporal_comparison( self, *, op: TemporalComparisonOp, operand: Expression, value: date, @@ -172,15 +260,14 @@ def _date_part(self, part: DatePart, expr: Expression) -> Expression: def build_date_diff( self, *, unit: TimeGranularity, start: Expression, end: Expression, operand: DataType, ) -> Expression: - """``DATE_DIFF`` counts date-part boundaries; ``TIMESTAMP_DIFF`` counts elapsed units, so its + """``DATE_DIFF`` counts date-part boundaries; ``DATETIME_DIFF`` counts elapsed units, so its operands are truncated first (and it has no week/month/quarter/year).""" if unit in SUB_DAY_GRANULARITIES: - if operand is DataType.DATE: - start, end = self.promote_to_timestamp(start), self.promote_to_timestamp(end) + start, end = self.promote_to_timestamp(start), self.promote_to_timestamp(end) def trunc(e: Expression) -> Expression: - return exp.Anonymous(this="TIMESTAMP_TRUNC", expressions=[e.copy(), exp.var(unit.value.upper())]) - return exp.Anonymous(this="TIMESTAMP_DIFF", expressions=[ + return exp.Anonymous(this="DATETIME_TRUNC", expressions=[e.copy(), exp.var(unit.value.upper())]) + return exp.Anonymous(this="DATETIME_DIFF", expressions=[ trunc(end), trunc(start), exp.var(unit.value.upper()), ]) if operand is DataType.TIMESTAMP: @@ -195,20 +282,14 @@ def bucket_comparand(self, bucket: Expression) -> Expression: def build_date_add( self, *, expr: Expression, count: Expression, unit: TimeGranularity, operand: DataType, ) -> Expression: - """``DATE_ADD`` keeps a DATE a DATE; timestamps use ``TIMESTAMP_ADD`` up to a day and - ``DATETIME_ADD`` (which clamps at month-end) for months.""" + """``DATE_ADD`` keeps a DATE a DATE; timestamps use ``DATETIME_ADD`` (which clamps at month-end).""" if operand is DataType.DATE and unit not in SUB_DAY_GRANULARITIES: return exp.Anonymous(this="DATE_ADD", expressions=[expr.copy(), _interval(count.copy(), unit)]) - base = self.promote_to_timestamp(expr) if operand is DataType.DATE else expr.copy() + base = self.promote_to_timestamp(expr) if unit in (TimeGranularity.WEEK, TimeGranularity.WEEK_SUNDAY): - days = exp.Mul(this=exp.Paren(this=count.copy()), expression=exp.Literal.number(7)) - return exp.Anonymous(this="TIMESTAMP_ADD", expressions=[base, _interval(days, TimeGranularity.DAY)]) - if unit in SUB_DAY_GRANULARITIES or unit is TimeGranularity.DAY: - return exp.Anonymous(this="TIMESTAMP_ADD", expressions=[base, _interval(count.copy(), unit)]) - moved = exp.Anonymous(this="DATETIME_ADD", expressions=[ - exp.Cast(this=base, to=exp.DataType.build("DATETIME")), _interval(count.copy(), unit), - ]) - return self.promote_to_timestamp(moved) + count = exp.Mul(this=exp.Paren(this=count.copy()), expression=exp.Literal.number(7)) + unit = TimeGranularity.DAY + return exp.Anonymous(this="DATETIME_ADD", expressions=[base, _interval(count.copy(), unit)]) def build_engine( self, diff --git a/slayer/sql/dialects/clickhouse.py b/slayer/sql/dialects/clickhouse.py index fccfa8b16..53ee89c45 100644 --- a/slayer/sql/dialects/clickhouse.py +++ b/slayer/sql/dialects/clickhouse.py @@ -16,7 +16,41 @@ from sqlglot.expressions.core import Expression from slayer.core.enums import SUB_DAY_GRANULARITIES, DataType, DatePart, TimeGranularity -from slayer.sql.dialects.base import ServerProfile, SqlDialect, as_text, iso_text +from slayer.core.json_path import JsonPath +from slayer.core.regex_pattern import RegexPattern, RegexReplacement +from slayer.sql.dialects.base import ( + ExtremumFn, + ServerProfile, + SqlDialect, + TextFn, + anon, + as_text, + case, + iso_text, + lit, + pad_fill, +) +from slayer.sql.dialects.patterns import RE2, RegexFlavour + +#: Byte-based string functions and their character (UTF-8) counterparts. +_UTF8_FUNCTIONS = {exp.Substring: "substringUTF8", exp.Lower: "lowerUTF8", exp.Upper: "upperUTF8"} +_JSON_SCALAR_TYPES = ("Int64", "UInt64", "Double", "Bool") + + +def _utf8(node: Expression) -> Expression: + """Character semantics for the byte-based string functions.""" + for cls, name in _UTF8_FUNCTIONS.items(): + if type(node) is cls: + args = [node.this, *(node.args[k] for k in ("start", "length") if node.args.get(k) is not None)] + return exp.Anonymous(this=name, expressions=args) + if isinstance(node, exp.StrPosition): + return exp.Anonymous(this="positionUTF8", expressions=[node.this, node.args["substr"]]) + return node + + +def _byte(value: Expression, position: int) -> Expression: + return exp.Anonymous(this="ascii", expressions=[exp.Anonymous(this="substring", expressions=[ + value.copy(), exp.Literal.number(position), exp.Literal.number(1)])]) _CH_CORRELATED_SETTING = "allow_experimental_correlated_subqueries" _CORRELATED_MIN_VERSION = (25, 4) @@ -107,6 +141,98 @@ def _settings_holder(ast: Expression) -> Expression: class ClickhouseDialect(SqlDialect): sqlglot_name: str = "clickhouse" ilike_native: ClassVar[bool] = True + regex_flavour: ClassVar[RegexFlavour] = RE2 + json_db_types: ClassVar[frozenset[str]] = frozenset({"JSON", "OBJECT"}) + like_escape_clause: ClassVar[bool] = False + + def rewrite_target_ast(self, tree: Expression) -> Expression: + """Character, not byte, semantics for substring / lower / upper / position.""" + return tree.transform(_utf8) + + def build_text_call(self, fn: TextFn, args: tuple[Expression, ...]) -> Expression: + if fn in ("left", "right"): + return anon(f"{fn}UTF8", *args) + if fn in ("lpad", "rpad"): + node = anon("leftPadUTF8" if fn == "lpad" else "rightPadUTF8", args[0], args[1], pad_fill(args)) + return self._non_positive_empty(args[1], node, source=args[0]) + if fn == "reverse": + return anon("reverseUTF8", args[0]) + if fn == "concat_ws": + item = exp.to_identifier("_v") + present = exp.Lambda(this=anon("isNotNull", exp.column(item.copy())), expressions=[item]) + values = exp.Array(expressions=[a.copy() for a in args[1:]]) + return case((anon("isNull", args[0]), exp.Null()), + default=anon("arrayStringConcat", anon("arrayFilter", present, values), args[0])) + return super().build_text_call(fn, args) + + def code_point_char(self, n: Expression) -> Expression: + """The UTF-8 bytes of code point ``n``.""" + def part(shift: int, mask_base: int) -> Expression: + shifted = n.copy() if shift == 0 else anon("intDiv", n, lit(1 << shift)) + return exp.Add(this=lit(mask_base), expression=anon("modulo", shifted, lit(64)) if mask_base == 128 + else shifted) + two = anon("char", part(6, 192), part(0, 128)) + three = anon("char", part(12, 224), part(6, 128), part(0, 128)) + four = anon("char", part(18, 240), part(12, 128), part(6, 128), part(0, 128)) + return case((exp.LT(this=n.copy(), expression=lit(128)), anon("char", n)), + (exp.LT(this=n.copy(), expression=lit(2048)), two), + (exp.LT(this=n.copy(), expression=lit(65536)), three), default=four) + + def first_code_point(self, s: Expression) -> Expression: + """Decoded from the first character's UTF-8 bytes; ``''`` is 0.""" + b1 = _byte(s, 1) + + def tail(position: int) -> Expression: + return exp.Paren(this=exp.Sub(this=_byte(s, position), expression=lit(128))) + + def scaled(value: Expression, factor: int) -> Expression: + return exp.Mul(this=value, expression=lit(factor)) + two = exp.Add(this=scaled(exp.Paren(this=exp.Sub(this=b1.copy(), expression=lit(192))), 64), expression=tail(2)) + three = exp.Add(this=exp.Add(this=scaled(exp.Paren(this=exp.Sub(this=b1.copy(), expression=lit(224))), 4096), + expression=scaled(tail(2), 64)), expression=tail(3)) + four = exp.Add(this=exp.Add(this=exp.Add( + this=scaled(exp.Paren(this=exp.Sub(this=b1.copy(), expression=lit(240))), 262144), + expression=scaled(tail(2), 4096)), expression=scaled(tail(3), 64)), expression=tail(4)) + return case((exp.LT(this=b1.copy(), expression=lit(128)), b1.copy()), + (exp.LT(this=b1.copy(), expression=lit(224)), two), + (exp.LT(this=b1.copy(), expression=lit(240)), three), default=four) + + def build_split_part(self, value: Expression, delimiter: Expression, index: int) -> Expression: + """``splitByString`` indexes from either end; past the end is the empty default.""" + return anon("arrayElement", anon("splitByString", delimiter, value), lit(index)) + + def text_repeat(self, value: Expression, count: Expression) -> Expression: + return anon("repeat", value, count) + + def build_extremum(self, fn: ExtremumFn, args: tuple[Expression, ...]) -> Expression: + """``greatest`` / ``least`` propagate NULL before 24.12.""" + return self.coalesced_extremum(fn, args, spelling="lower") + + def build_regexp_like(self, value: Expression, pattern: RegexPattern, case_insensitive: bool) -> Expression: + return anon("match", value, self.regex_text(pattern, case_insensitive=case_insensitive)) + + def build_regexp_extract( + self, value: Expression, pattern: RegexPattern, group: int, case_insensitive: bool, + ) -> Expression: + """``regexpExtract`` returns ``''`` without a match: a match is tested first.""" + text = self.regex_text(pattern) + return case((anon("match", value, text), anon("regexpExtract", value, text.copy(), lit(group)))) + + def build_regexp_replace( + self, value: Expression, pattern: RegexPattern, replacement: RegexReplacement, case_insensitive: bool, + ) -> Expression: + return anon("replaceRegexpAll", value, self.regex_text(pattern, case_insensitive=case_insensitive), + self.replacement_text(replacement)) + + def build_json_value(self, value: Expression, path: JsonPath, native: bool) -> Expression: + document = anon("toJSONString", value) if native else value.copy() + keys = [lit(step + 1) if isinstance(step, int) else lit(step) for step in path.steps] + kind = anon("JSONType", document, *keys) + return case( + (exp.EQ(this=kind, expression=lit("String")), anon("JSONExtractString", document, *keys)), + (exp.In(this=kind.copy(), expressions=[lit(t) for t in _JSON_SCALAR_TYPES]), + anon("JSONExtractRaw", document, *keys)), + ) ds_type_aliases: frozenset[str] = frozenset({"clickhouse"}) explain_prefix: str | None = "EXPLAIN" explain_postfix: str = "" diff --git a/slayer/sql/dialects/duckdb.py b/slayer/sql/dialects/duckdb.py index 5c310f2c4..477860f0b 100644 --- a/slayer/sql/dialects/duckdb.py +++ b/slayer/sql/dialects/duckdb.py @@ -10,8 +10,15 @@ from typing import ClassVar from sqlglot import exp +from sqlglot.expressions.core import Expression -from slayer.sql.dialects.base import SqlDialect +from slayer.core.json_path import JsonPath +from slayer.core.regex_pattern import RegexPattern, RegexReplacement +from slayer.sql.dialects.base import SqlDialect, TextFn, anon, case, lit, pad_fill +from slayer.sql.dialects.patterns import RE2, RegexFlavour, emit_replacement + +#: ``json_type`` values that are not a scalar. +_NON_SCALAR_JSON = ("OBJECT", "ARRAY", "NULL") class DuckdbDialect(SqlDialect): @@ -25,6 +32,38 @@ class DuckdbDialect(SqlDialect): max_identifier_bytes: int | None = 256 # safe documented ceiling approx_count_distinct_native: bool = True url_scheme: str | None = "duckdb" + regex_flavour: ClassVar[RegexFlavour] = RE2 + + def build_text_call(self, fn: TextFn, args: tuple[Expression, ...]) -> Expression: + """``left`` / ``right`` / ``lpad`` / ``rpad`` / ``repeat`` are native with the reference meaning.""" + if fn in ("left", "right", "lpad", "rpad", "repeat"): + fill = [pad_fill(args)] if fn in ("lpad", "rpad") and len(args) == 2 else [] + return anon(fn.upper(), *args, *fill) + return super().build_text_call(fn, args) + + def build_regexp_like(self, value: Expression, pattern: RegexPattern, case_insensitive: bool) -> Expression: + return anon("REGEXP_MATCHES", value, self.regex_text(pattern, case_insensitive=case_insensitive)) + + def build_regexp_extract( + self, value: Expression, pattern: RegexPattern, group: int, case_insensitive: bool, + ) -> Expression: + """The first of ``regexp_extract_all`` (NULL on no match, unlike ``regexp_extract``'s ``''``).""" + matches = anon("REGEXP_EXTRACT_ALL", value, self.regex_text(pattern, case_insensitive=case_insensitive), + lit(group)) + return self.skipped_group_empty(value, pattern, group, anon("LIST_EXTRACT", matches, lit(1))) + + def build_regexp_replace( + self, value: Expression, pattern: RegexPattern, replacement: RegexReplacement, case_insensitive: bool, + ) -> Expression: + return anon("REGEXP_REPLACE", value, self.regex_text(pattern, case_insensitive=case_insensitive), + lit(emit_replacement(replacement, self.regex_flavour)), lit("g")) + + def build_json_value(self, value: Expression, path: JsonPath, native: bool) -> Expression: + text = lit(path.text) + scalar = exp.Not(this=exp.In(this=anon("JSON_TYPE", value, text), + expressions=[lit(t) for t in _NON_SCALAR_JSON])) + read = case((scalar, anon("JSON_EXTRACT_STRING", value, text))) + return case((anon("JSON_VALID", value), read)) def build_integer_sequence(self, *, size: int) -> exp.Select: return exp.select(exp.column("i")).from_(exp.Table( diff --git a/slayer/sql/dialects/mysql.py b/slayer/sql/dialects/mysql.py index ebc9eee38..b9dcb757e 100644 --- a/slayer/sql/dialects/mysql.py +++ b/slayer/sql/dialects/mysql.py @@ -11,20 +11,36 @@ from __future__ import annotations +from typing import ClassVar + from sqlglot import exp from sqlglot.expressions.core import Expression from slayer.core.enums import DataType, DatePart, TimeGranularity +from slayer.core.json_path import JsonPath +from slayer.core.regex_pattern import RegexPattern, RegexReplacement from slayer.sql.dialects.base import ( FALSE_WORDS, NUMBER_TEXT_PATTERN, TRUE_WORDS, + ExtremumFn, SqlDialect, + TextFn, + anon, + any_null, as_text, + case, + lit, StatAgg1Name, StatAgg2Name, _build_covar_decomposition, ) +from slayer.sql.dialects.patterns import ICU, RegexFlavour + + +def _match_type(case_insensitive: bool) -> Expression: + """ICU match type: always explicit, so a case-insensitive collation never decides.""" + return lit("i" if case_insensitive else "c") _SUB_DAY_TRUNC_FORMATS = { @@ -42,6 +58,58 @@ class MysqlDialect(SqlDialect): sqlglot_name: str = "mysql" ds_type_aliases: frozenset[str] = frozenset({"mysql"}) + regex_flavour: ClassVar[RegexFlavour] = ICU + + def build_text_call(self, fn: TextFn, args: tuple[Expression, ...]) -> Expression: + if fn == "chr": + utf32 = exp.Chr(expressions=[args[0].copy()], charset=exp.var("utf32")) + text = exp.Cast(this=utf32, to=exp.DataType(this=exp.DataType.Type.CHARACTER_SET, kind=exp.var("utf8mb4"))) + return self._code_point_guard(args[0], text) + if fn == "ascii": + return exp.Unicode(this=args[0].copy()) + return super().build_text_call(fn, args) + + def binary_text(self, value: Expression) -> Expression: + """Read as ``utf8mb4`` (any column charset) under its binary collation.""" + utf8 = exp.Cast(this=value.copy(), to=exp.DataType(this=exp.DataType.Type.CHARACTER_SET, kind=exp.var("utf8mb4"))) + return exp.Collate(this=utf8, expression=exp.var("utf8mb4_bin")) + + def build_split_part(self, value: Expression, delimiter: Expression, index: int) -> Expression: + """``SUBSTRING_INDEX`` twice; ``''`` past the last field.""" + inner = anon("SUBSTRING_INDEX", value, delimiter, lit(index)) + field = anon("SUBSTRING_INDEX", inner, delimiter, lit(-1 if index > 0 else 1)) + beyond = exp.GT(this=lit(abs(index)), expression=self.field_count(value, delimiter)) + return case((any_null(value, delimiter), exp.Null()), (beyond, lit("")), default=field) + + def cube_root(self, value: Expression) -> Expression: + root = exp.Pow(this=exp.Abs(this=value.copy()), expression=exp.Div(this=lit(1), expression=exp.Literal.number("3.0"))) + return exp.Mul(this=exp.Sign(this=value.copy()), expression=root) + + def build_extremum(self, fn: ExtremumFn, args: tuple[Expression, ...]) -> Expression: + """``GREATEST`` / ``LEAST`` propagate NULL here.""" + return self.coalesced_extremum(fn, args, spelling="upper") + + def build_regexp_like(self, value: Expression, pattern: RegexPattern, case_insensitive: bool) -> Expression: + return anon("REGEXP_LIKE", value, self.regex_text(pattern), _match_type(case_insensitive)) + + def build_regexp_extract( + self, value: Expression, pattern: RegexPattern, group: int, case_insensitive: bool, + ) -> Expression: + """The first match, then (for a group) that match re-read whole by the pattern.""" + match = anon("REGEXP_SUBSTR", value, self.regex_text(pattern), lit(1), lit(1), _match_type(False)) + if group == 0: + return match + return anon("REGEXP_REPLACE", match, self.regex_text(pattern, anchored=True), lit(f"${group}"), lit(1), + lit(0), _match_type(False)) + + def build_regexp_replace( + self, value: Expression, pattern: RegexPattern, replacement: RegexReplacement, case_insensitive: bool, + ) -> Expression: + return anon("REGEXP_REPLACE", value, self.regex_text(pattern), self.replacement_text(replacement), lit(1), + lit(0), _match_type(case_insensitive)) + + def build_json_value(self, value: Expression, path: JsonPath, native: bool) -> Expression: + return case((anon("JSON_VALID", value), anon("JSON_VALUE", value, lit(path.text)))) def build_try_cast(self, value: Expression, to: exp.DataType) -> Expression: """Numeric and boolean targets are guarded by the validity grammar; MySQL's date casts already yield NULL.""" diff --git a/slayer/sql/dialects/patterns.py b/slayer/sql/dialects/patterns.py new file mode 100644 index 000000000..b4e14ab1c --- /dev/null +++ b/slayer/sql/dialects/patterns.py @@ -0,0 +1,202 @@ +"""Pattern re-emission: one portable regex / LIKE pattern spelled in each engine's own syntax.""" + +from __future__ import annotations + +from typing import List, Literal, Optional, Tuple + +from pydantic import BaseModel, ConfigDict +from sqlglot import exp +from sqlglot.expressions.core import Expression + +from slayer.core.like_pattern import LikePattern, LikeWildcard +from slayer.core.regex_pattern import ( + RegexAlt, + RegexAny, + RegexAnchor, + RegexBracket, + RegexChar, + RegexClass, + RegexGroup, + RegexGroupRef, + RegexItem, + RegexPattern, + RegexRange, + RegexRepeat, + RegexReplacement, +) + +_META = frozenset("\\.^$|?*+()[]{}") +_SPACE = (" ", "\t", "\n", "\r", "\f", "\v") +#: ``\d`` / ``\w`` / ``\s`` as ASCII code-point ranges. +_CLASS_RANGES: dict = { + "d": [("0", "9")], + "w": [("A", "Z"), ("a", "z"), ("0", "9"), ("_", "_")], + "s": [(c, c) for c in _SPACE], +} + + +class RegexFlavour(BaseModel): + """How one engine spells the portable meaning.""" + + model_config = ConfigDict(frozen=True) + + #: Inline ``(?s)`` (and ``(?i)``) flags; otherwise the caller passes them as a match parameter. + inline_flags: bool = True + #: The end-of-string anchor (``$`` where it never matches before a trailing newline). + end_anchor: str = "$" + #: Replacement group references: ``\1`` or ``$1``. + group_ref: Literal["backslash", "dollar"] = "backslash" + #: Whether ``&`` in a replacement inserts the whole match (so a literal one is escaped). + replacement_ampersand: bool = False + + +POSTGRES = RegexFlavour(inline_flags=False) +RE2 = RegexFlavour() +JAVA = RegexFlavour(end_anchor="\\z", group_ref="dollar") +ICU = RegexFlavour(end_anchor="\\z", group_ref="dollar") +POSIX = RegexFlavour(inline_flags=False) +PYTHON = RegexFlavour(inline_flags=False, end_anchor="\\Z") + + +class _Emitter: + def __init__(self, flavour: RegexFlavour, *, capture: Optional[int]) -> None: + self.flavour = flavour + self.capture = capture + + def alt(self, alt: RegexAlt) -> str: + return "|".join("".join(self.item(i) for i in seq) for seq in alt.branches) + + def item(self, item: RegexItem) -> str: + if not isinstance(item, RegexRepeat): + return self.atom(item) + low, high = item.low, item.high + quant = {(0, None): "*", (1, None): "+", (0, 1): "?"}.get((low, high)) + if quant is None: + quant = _braced_repeat(low, high) + return self.atom(item.node) + quant + + def atom(self, atom: object) -> str: + if isinstance(atom, RegexChar): + return "\\" + atom.char if atom.char in _META else atom.char + if isinstance(atom, RegexAny): + return "." + if isinstance(atom, RegexAnchor): + return "^" if atom.at == "start" else self.flavour.end_anchor + if isinstance(atom, RegexClass): + return self.bracket(atom.negated, [_class_ranges(atom)]) + if isinstance(atom, RegexBracket): + return self.bracket(atom.negated, [_item_ranges(i) for i in atom.items]) + if isinstance(atom, RegexGroup): + captured = self.capture is None or atom.index == self.capture + return ("(" if captured else "(?:") + self.alt(atom.body) + ")" + raise TypeError(f"unknown regex node {type(atom).__name__}") + + def bracket(self, negated: bool, ranges: List[List[Tuple[str, str]]]) -> str: + flat = [r for group in ranges for r in group] + return ("[^" if negated else "[") + _escaped_bracket(flat) + "]" + + +def _braced_repeat(low: int, high: int | None) -> str: + if high == low: + return f"{{{low}}}" + if high is None: + return f"{{{low},}}" + return f"{{{low},{high}}}" + + +def _class_ranges(cls: RegexClass) -> List[Tuple[str, str]]: + return list(_CLASS_RANGES[cls.kind]) + + +def _item_ranges(item: object) -> List[Tuple[str, str]]: + if isinstance(item, RegexChar): + return [(item.char, item.char)] + if isinstance(item, RegexRange): + return [(item.low, item.high)] + if isinstance(item, RegexClass): + return _class_ranges(item) + raise TypeError(f"unknown bracket item {type(item).__name__}") + + +_BRACKET_SPECIALS = frozenset("\\]^-[&~") + + +def _escaped_bracket(ranges: List[Tuple[str, str]]) -> str: + def one(ch: str) -> str: + return "\\" + ch if ch in _BRACKET_SPECIALS else ch + return "".join(one(lo) if lo == hi else f"{one(lo)}-{one(hi)}" for lo, hi in ranges) + + +def emit_regex( + pattern: RegexPattern, flavour: RegexFlavour, *, case_insensitive: bool = False, + capture: Optional[int] = None, wrap: bool = False, anchored: bool = False, +) -> str: + """``pattern`` in ``flavour``'s syntax. ``capture`` keeps only that group capturing (0: none); ``wrap`` + captures the whole match as group 1; ``anchored`` makes it match the whole string.""" + body = _Emitter(flavour, capture=capture).alt(pattern.root) + if wrap: + body = f"({body})" + if anchored: + body = f"^(?:{body}){flavour.end_anchor}" + if flavour.inline_flags: + body = ("(?si)" if case_insensitive else "(?s)") + body + return body + + +def emit_replacement(replacement: RegexReplacement, flavour: RegexFlavour) -> str: + """``replacement`` with group references and literal ``\\`` / ``$`` spelled for ``flavour``.""" + out: List[str] = [] + for part in replacement.parts: + if isinstance(part, RegexGroupRef): + out.append(f"${part.index}" if flavour.group_ref == "dollar" else f"\\{part.index}") + else: + text = part.replace("\\", "\\\\") + if flavour.group_ref == "dollar": + text = text.replace("$", "\\$") + if flavour.replacement_ampersand: + text = text.replace("&", "\\&") + out.append(text) + return "".join(out) + + +def like_text(pattern: LikePattern, *, brackets: bool = False) -> str: + """``pattern`` as LIKE text escaped by ``\\`` (``brackets``: ``[`` as ``[[]``, SQL Server).""" + out: List[str] = [] + for part in pattern.parts: + if isinstance(part, LikeWildcard): + out.append("%" if part.kind == "any" else "_") + continue + for ch in part: + if ch in "%_\\": + out.append("\\" + ch) + elif ch == "[" and brackets: + out.append("[[]") + else: + out.append(ch) + return "".join(out) + + +_SENTINELS = ("\x01", "\x02", "\x03") + + +def _replace(value: Expression, old: str, new: str) -> Expression: + return exp.Anonymous(this="REPLACE", expressions=[value, exp.Literal.string(old), exp.Literal.string(new)]) + + +def like_expression(pattern: Expression, *, brackets: bool = False) -> Expression: + """A run-time pattern in the LIKE language as ``\\``-escaped LIKE text: a lone backslash made literal + (``brackets``: ``[`` as ``[[]``).""" + escaped = (("\\\\", _SENTINELS[0]), ("\\%", _SENTINELS[1]), ("\\_", _SENTINELS[2])) + value = pattern + for old, mark in escaped: + value = _replace(value, old, mark) + value = _replace(value, "\\", "\\\\") + for old, mark in escaped: + value = _replace(value, mark, old) + return _replace(value, "[", "[[]") if brackets else value + + +__all__ = [ + "ICU", "JAVA", "POSIX", "POSTGRES", "PYTHON", "RE2", "RegexFlavour", "emit_regex", "emit_replacement", + "like_expression", "like_text", +] diff --git a/slayer/sql/dialects/postgres.py b/slayer/sql/dialects/postgres.py index 9d71ee490..6debf7fba 100644 --- a/slayer/sql/dialects/postgres.py +++ b/slayer/sql/dialects/postgres.py @@ -2,19 +2,30 @@ from __future__ import annotations -from collections.abc import Sequence +from collections.abc import Iterable, Sequence from typing import Any, ClassVar from sqlglot import exp from sqlglot.expressions.datatypes import DType from sqlglot.expressions.core import Expression -from slayer.sql.dialects.base import ServerProfile, SqlDialect, as_text +from slayer.core.keys import CastKey, ScalarCallKey +from slayer.sql.dialects.base import ServerProfile, SqlDialect, TextFn, anon, as_text, pad_fill #: The first Postgres major version with ``pg_input_is_valid``. _PG_INPUT_IS_VALID_SINCE = (16, 0) +def _cast_log_arg_to_numeric(node: Expression) -> Expression: + """A based ``LOG(b, x)`` has only the ``numeric`` overload: cast ``x`` (Postgres has no ``log2``).""" + if not isinstance(node, exp.Log) or node.args.get("expression") is None: + return node + value = node.expression + if not (isinstance(value, exp.Cast) and value.to.is_type(exp.DataType.Type.DECIMAL)): + node.set("expression", exp.cast(value.copy(), "DECIMAL")) + return node + + def _cast_round_arg_to_numeric(node: exp.Expression) -> exp.Expression: """Wrap the first arg of a 2-arg ``ROUND`` in ``CAST(... AS DECIMAL)``. @@ -49,18 +60,39 @@ class PostgresDialect(SqlDialect): explain_prefix: str | None = "EXPLAIN ANALYZE" explain_postfix: str = "" log10_native: bool = True - log2_native: bool = True + log2_native: bool = False # NAMEDATALEN: 63 usable bytes; over-length names are SILENTLY truncated. max_identifier_bytes: int | None = 63 statement_timeout_best_effort: bool = True - try_cast_reads_profile: bool = True + json_db_types: ClassVar[frozenset[str]] = frozenset({"JSON", "JSONB"}) url_scheme: str | None = "postgresql+psycopg2" async_driver: str | None = "asyncpg" install_extra: str | None = "postgres" + def profile_needed(self, keys: Iterable[object]) -> bool: + """``TRY_CAST`` and ``json_value`` check their input with ``pg_input_is_valid`` on 16+.""" + return any( + (isinstance(k, CastKey) and k.try_) or (isinstance(k, ScalarCallKey) and k.name == "json_value") + for k in keys + ) + def server_profile_sql(self) -> str | None: return "SELECT current_setting('server_version_num')" + def build_text_call(self, fn: TextFn, args: tuple[Expression, ...]) -> Expression: + """``left`` / ``right`` / ``lpad`` / ``rpad`` / ``repeat`` are native with the reference meaning.""" + if fn in ("left", "right", "lpad", "rpad", "repeat"): + fill = [pad_fill(args)] if fn in ("lpad", "rpad") and len(args) == 2 else [] + return anon(fn.upper(), *args, *fill) + return super().build_text_call(fn, args) + + def build_modulo(self, left: Expression, right: Expression, integer: bool) -> Expression: + """``%`` has no DOUBLE overload: non-integers go through NUMERIC.""" + if integer: + return super().build_modulo(left, right, integer) + numeric = exp.DataType.build("NUMERIC") + return anon("MOD", exp.Cast(this=left.copy(), to=numeric), exp.Cast(this=right.copy(), to=numeric)) + def parse_server_profile( self, *, base_row: Sequence[Any] | None, correlated_row: Sequence[Any] | None = None, ) -> ServerProfile: @@ -94,5 +126,5 @@ def statement_timeout_sql(self, timeout_seconds: int) -> str | None: return f"SET LOCAL statement_timeout = {timeout_seconds * 1000}" def rewrite_target_ast(self, tree: exp.Expression) -> exp.Expression: - """Numeric-cast every 2-arg ROUND's first arg: Postgres has no ``round(double, int)``.""" - return tree.transform(_cast_round_arg_to_numeric) + """Numeric-cast every 2-arg ROUND's and based LOG's value: their only overloads take ``numeric``.""" + return tree.transform(_cast_round_arg_to_numeric).transform(_cast_log_arg_to_numeric) diff --git a/slayer/sql/dialects/snowflake.py b/slayer/sql/dialects/snowflake.py index 6cb0fa820..59dd914e0 100644 --- a/slayer/sql/dialects/snowflake.py +++ b/slayer/sql/dialects/snowflake.py @@ -13,7 +13,10 @@ from sqlglot.expressions.core import Expression from slayer.core.enums import DataType, DatePart, TimeGranularity -from slayer.sql.dialects.base import SqlDialect +from slayer.core.json_path import JsonPath +from slayer.core.regex_pattern import RegexPattern, RegexReplacement +from slayer.sql.dialects.base import ExtremumFn, SqlDialect, TextFn, anon, case, either, lit +from slayer.sql.dialects.patterns import POSIX, RegexFlavour from slayer.sql.dialects.drivers import import_driver if TYPE_CHECKING: @@ -96,6 +99,24 @@ def _extract_connection_name(connection_string: str) -> str: return name +def _parameters(case_insensitive: bool) -> Expression: + """Match parameters: case as asked, ``.`` across newlines.""" + return lit("is" if case_insensitive else "cs") + + +def _snowflake_path(path: JsonPath) -> str: + """``GET_PATH`` syntax: no ``$``; a key that is not a plain identifier in double quotes.""" + out = [] + for i, step in enumerate(path.steps): + if isinstance(step, int): + out.append(f"[{step}]") + else: + plain = _SAFE_SNOWFLAKE_IDENT.match(step) is not None and "$" not in step + key = step if plain else f'"{step}"' + out.append(key if i == 0 else f".{key}") + return "".join(out) + + class SnowflakeDialect(SqlDialect): """Snowflake dialect.""" @@ -116,6 +137,46 @@ class SnowflakeDialect(SqlDialect): DatePart.ISO_YEAR: "YEAROFWEEKISO", DatePart.WEEK: "WEEKISO", DatePart.DAY_OF_WEEK: "DAYOFWEEKISO", DatePart.DAY_OF_YEAR: "DAYOFYEAR", } + regex_flavour: ClassVar[RegexFlavour] = POSIX + json_db_types: ClassVar[frozenset[str]] = frozenset({"VARIANT", "OBJECT", "ARRAY"}) + + def build_text_call(self, fn: TextFn, args: tuple[Expression, ...]) -> Expression: + if fn == "concat_ws": + return anon("ARRAY_TO_STRING", anon("ARRAY_CONSTRUCT_COMPACT", *args[1:]), args[0]) + return super().build_text_call(fn, args) + + def first_code_point(self, s: Expression) -> Expression: + return case((exp.EQ(this=s.copy(), expression=lit("")), lit(0)), default=anon("UNICODE", s)) + + def build_extremum(self, fn: ExtremumFn, args: tuple[Expression, ...]) -> Expression: + return anon(f"{fn.upper()}_IGNORE_NULLS", *args) + + def build_regexp_like(self, value: Expression, pattern: RegexPattern, case_insensitive: bool) -> Expression: + """``REGEXP_LIKE`` matches the whole string here; ``REGEXP_INSTR`` finds a partial match.""" + position = anon("REGEXP_INSTR", value, self.regex_text(pattern), lit(1), lit(1), lit(0), + _parameters(case_insensitive)) + return exp.GT(this=position, expression=lit(0)) + + def build_regexp_extract( + self, value: Expression, pattern: RegexPattern, group: int, case_insensitive: bool, + ) -> Expression: + if group == 0: + return anon("REGEXP_SUBSTR", value, self.regex_text(pattern), lit(1), lit(1), _parameters(False)) + extracted = anon("REGEXP_SUBSTR", value, self.regex_text(pattern), lit(1), lit(1), lit("cse"), lit(group)) + return self.skipped_group_empty(value, pattern, group, extracted) + + def build_regexp_replace( + self, value: Expression, pattern: RegexPattern, replacement: RegexReplacement, case_insensitive: bool, + ) -> Expression: + return anon("REGEXP_REPLACE", value, self.regex_text(pattern), self.replacement_text(replacement), lit(1), + lit(0), _parameters(case_insensitive)) + + def build_json_value(self, value: Expression, path: JsonPath, native: bool) -> Expression: + """``GET_PATH`` on the VARIANT (text parsed with ``TRY_PARSE_JSON``); objects, arrays and null are NULL.""" + document = value.copy() if native else anon("TRY_PARSE_JSON", anon("TO_VARCHAR", value)) + found = anon("GET_PATH", document, lit(_snowflake_path(path))) + not_scalar = either(anon("IS_OBJECT", found), anon("IS_ARRAY", found.copy()), anon("IS_NULL_VALUE", found.copy())) + return case((not_scalar, exp.Null()), default=anon("TO_VARCHAR", found.copy())) def _second_gap(self, *, start: Expression, end: Expression) -> Expression: """No interval type: ``DATEDIFF`` of second-aligned timestamps is exact.""" diff --git a/slayer/sql/dialects/sqlite.py b/slayer/sql/dialects/sqlite.py index c63872cff..e13adf479 100644 --- a/slayer/sql/dialects/sqlite.py +++ b/slayer/sql/dialects/sqlite.py @@ -7,26 +7,37 @@ from calendar import monthrange from datetime import date, datetime, timedelta from decimal import Decimal +from functools import lru_cache from sqlglot import exp from sqlglot.expressions.datatypes import DType from sqlglot.expressions.core import Expression -from typing import ClassVar, Optional +from typing import Callable, ClassVar, Optional from slayer.core.enums import DataType, DatePart, TimeGranularity +from slayer.core.json_path import JsonPath from slayer.core.keys import cast_data_type +from slayer.core.like_pattern import LikePattern, LikeWildcard, parse_like +from slayer.core.regex_pattern import RegexGroupRef, RegexPattern, RegexReplacement, parse_replacement from slayer.core.time_points import parse_temporal_value from slayer.sql.dialects.base import ( COMPARISON_NODES, FALSE_WORDS, TRUE_WORDS, VENDOR_ONLY_CAST_TYPES, + ExtremumFn, + MathFn, SqlDialect, TemporalComparisonOp, + TextFn, + anon, as_text, + case, iso_text, + lit, ) +from slayer.sql.dialects.patterns import PYTHON, RegexFlavour, like_text def rewrite_sqlite_json_extract(node: Expression) -> Expression: @@ -408,8 +419,119 @@ def _slayer_try_cast(text, target): return text +def _nulls(fn: Callable) -> Callable: + def wrapped(*args): + return None if any(a is None for a in args) else fn(*args) + return wrapped + + +@lru_cache(maxsize=1024) +def _compiled(pattern: str, flags: str) -> "re.Pattern[str]": + return re.compile(pattern, re.DOTALL | (re.IGNORECASE if "i" in flags else 0)) + + +def _regexp_like(value, pattern, flags): + if value is None or pattern is None: + return None + return int(_compiled(pattern, flags or "").search(str(value)) is not None) + + +def _regexp_extract(value, pattern, group): + if value is None or pattern is None or group is None: + return None + match = _compiled(pattern, "").search(str(value)) + return None if match is None else match.group(int(group)) or "" + + +def _regexp_replace(value, pattern, replacement, flags): + """``replacement`` is portable text: ``\\1``-``\\9`` insert a group, ``\\\\`` a backslash.""" + if value is None or pattern is None or replacement is None: + return None + compiled = _compiled(pattern, flags or "") + parts = parse_replacement(replacement, groups=compiled.groups).parts + + def substitute(match: "re.Match[str]") -> str: + return "".join(p if isinstance(p, str) else (match.group(p.index) or "") for p in parts) + return compiled.sub(substitute, str(value)) + + +_GLOB_SPECIALS = {"*": "[*]", "?": "[?]", "[": "[[]"} + + +def like_to_glob(pattern: Optional[str]) -> Optional[str]: + """A LIKE pattern as the GLOB pattern with its meaning (case-sensitive, collation-free).""" + if pattern is None: + return None + out = [] + for part in parse_like(pattern).parts: + if isinstance(part, LikeWildcard): + out.append("*" if part.kind == "any" else "?") + else: + out.append("".join(_GLOB_SPECIALS.get(ch, ch) for ch in part)) + return "".join(out) + + +def _pad(s: str, n, fill: str, *, left: bool) -> str: + n = int(n) + if n <= 0: + return "" + if len(s) >= n or not fill: + return s[:n] + padding = (fill * n)[:n - len(s)] + return padding + s if left else s + padding + + +def _split_part(s: str, delimiter: str, index) -> str: + fields = s.split(delimiter) if delimiter else [s] + index = int(index) + if index > 0: + return fields[index - 1] if index <= len(fields) else "" + return fields[index] if -index <= len(fields) else "" + + +def _fmod(a, b): + if a is None or b is None or b == 0: + return None + return math.fmod(a, b) if isinstance(a, float) or isinstance(b, float) else int(math.fmod(a, b)) + + +def _trunc(x): + if x is None: + return None + return math.trunc(x) if isinstance(x, int) else float(math.trunc(x)) + + +def _cbrt(x: float) -> float: + return math.copysign(abs(x) ** (1 / 3), x) + + +_TEXT_UDFS: dict = { + "slayer_lpad": (3, _nulls(lambda s, n, f: _pad(str(s), n, str(f), left=True))), + "slayer_rpad": (3, _nulls(lambda s, n, f: _pad(str(s), n, str(f), left=False))), + "slayer_reverse": (1, _nulls(lambda s: str(s)[::-1])), + "slayer_repeat": (2, _nulls(lambda s, n: str(s) * max(int(n), 0))), + "slayer_split_part": (3, _nulls(lambda s, d, k: _split_part(str(s), str(d), k))), + "slayer_concat_ws": (-1, lambda sep, *args: None if sep is None else str(sep).join( + str(a) for a in args if a is not None)), + "slayer_like_glob": (1, like_to_glob), + "slayer_regexp_like": (3, _regexp_like), + "slayer_regexp_extract": (3, _regexp_extract), + "slayer_regexp_replace": (4, _regexp_replace), + # SQLAlchemy's pysqlite registers ``floor`` as ``math.floor``, which fails on NULL. + "floor": (1, _nulls(lambda x: float(math.floor(x)) if isinstance(x, float) else math.floor(x))), + "slayer_fmod": (2, _fmod), + "slayer_trunc": (1, _trunc), + "slayer_pi": (0, lambda: math.pi), + "slayer_cbrt": (1, _nulls(_cbrt)), + "slayer_atan2": (2, _nulls(math.atan2)), + **{f"slayer_{name}": (1, _nulls(getattr(math, name))) for name in ("sin", "cos", "tan", "asin", "acos", "atan")}, +} + + def register_sqlite_udfs(dbapi_connection) -> None: """Register all SLayer SQLite UDFs on a fresh DBAPI connection (idempotent).""" + for name, (narg, fn) in _TEXT_UDFS.items(): + dbapi_connection.create_function(name, narg, fn, deterministic=True) dbapi_connection.create_function("ln", 1, _ln) dbapi_connection.create_function("log10", 1, _log10) dbapi_connection.create_function("log2", 1, _log2) @@ -438,6 +560,11 @@ def register_sqlite_udfs(dbapi_connection) -> None: dbapi_connection.create_aggregate("covar_pop", 2, _CovarPopAgg) +def _like_source(pattern: LikePattern) -> str: + """``pattern`` back as LIKE text (the GLOB conversion runs in ``slayer_like_glob``).""" + return like_text(pattern) + + class SqliteDialect(SqlDialect): sqlglot_name: str = "sqlite" # Any type name is a column affinity on SQLite. @@ -452,6 +579,107 @@ class SqliteDialect(SqlDialect): max_identifier_bytes: int | None = None # unbounded url_scheme: str | None = "sqlite" + regex_flavour: ClassVar[RegexFlavour] = PYTHON + json_db_types: ClassVar[frozenset[str]] = frozenset() + + def build_text_call(self, fn: TextFn, args: tuple[Expression, ...]) -> Expression: + """SQLite lacks the padding, reversing, repeating and separator functions: registered ones stand in.""" + if fn in ("lpad", "rpad"): + return anon(f"slayer_{fn}", *args, *([] if len(args) > 2 else [lit(" ")])) + if fn in ("reverse", "repeat", "concat_ws"): + return anon(f"slayer_{fn}", *args) + return super().build_text_call(fn, args) + + def code_point_char(self, n: Expression) -> Expression: + return anon("CHAR", n) + + def first_code_point(self, s: Expression) -> Expression: + return case((exp.EQ(this=s.copy(), expression=lit("")), lit(0)), default=anon("UNICODE", s)) + + def build_split_part(self, value: Expression, delimiter: Expression, index: int) -> Expression: + return anon("slayer_split_part", value, delimiter, lit(index)) + + def build_math_call(self, fn: MathFn, args: tuple[Expression, ...]) -> Expression: + """Math functions are registered (SQLite builds may lack them); the domain guards stay.""" + if fn in ("asin", "acos"): + inside = exp.Between(this=args[0].copy(), low=lit(-1), high=lit(1)) + return case((inside, anon(f"slayer_{fn}", args[0]))) + if fn == "div": + return super().build_math_call(fn, args) + return anon(f"slayer_{fn}", *args) + + def truncate(self, value: Expression) -> Expression: + return anon("slayer_trunc", value) + + def build_extremum(self, fn: ExtremumFn, args: tuple[Expression, ...]) -> Expression: + """Scalar ``MAX`` / ``MIN`` propagate NULL: each term coalesces to a present argument.""" + return self.coalesced_extremum(fn, args, spelling="min_max") + + def build_modulo(self, left: Expression, right: Expression, integer: bool) -> Expression: + """``%`` truncates real operands to integers first; non-integers use ``fmod``.""" + if integer: + return super().build_modulo(left, right, integer) + return anon("slayer_fmod", left, right) + + def build_regexp_like(self, value: Expression, pattern: RegexPattern, case_insensitive: bool) -> Expression: + return anon("slayer_regexp_like", value, self.regex_text(pattern), lit("i" if case_insensitive else "")) + + def build_regexp_extract( + self, value: Expression, pattern: RegexPattern, group: int, case_insensitive: bool, + ) -> Expression: + return anon("slayer_regexp_extract", value, self.regex_text(pattern), lit(group)) + + def build_regexp_replace( + self, value: Expression, pattern: RegexPattern, replacement: RegexReplacement, case_insensitive: bool, + ) -> Expression: + portable = "".join( + f"\\{p.index}" if isinstance(p, RegexGroupRef) else p.replace("\\", "\\\\") for p in replacement.parts + ) + return anon("slayer_regexp_replace", value, self.regex_text(pattern), lit(portable), + lit("i" if case_insensitive else "")) + + def build_like( + self, value: Expression, pattern: LikePattern | Expression, case_insensitive: bool, + ) -> Expression: + """``LIKE`` is ``GLOB`` over the converted pattern (case-sensitive whatever the collation); + ``ILIKE`` is SQLite's own case-insensitive ``LIKE``.""" + if case_insensitive: + return super().build_like(value, pattern, case_insensitive) + text = lit(_like_source(pattern)) if isinstance(pattern, LikePattern) else pattern.copy() + return exp.Glob(this=value.copy(), expression=anon("slayer_like_glob", text)) + + def build_json_value(self, value: Expression, path: JsonPath, native: bool) -> Expression: + kind, read = self._json_parts(value, path) + text = case( + (exp.In(this=kind, expressions=[lit("true"), lit("false")]), kind.copy()), + (exp.In(this=kind.copy(), expressions=[lit("text"), lit("integer"), lit("real")]), + exp.Cast(this=read, to=exp.DataType.build("TEXT"))), + ) + return case((anon("JSON_VALID", value), text)) + + def build_json_value_as( + self, value: Expression, path: JsonPath, native: bool, to: exp.DataType, target: DataType, + ) -> Expression: + """A JSON number or boolean converts directly (never through its text); a JSON string by ``TRY_CAST``.""" + kind, read = self._json_parts(value, path) + from_text = (exp.EQ(this=kind.copy(), expression=lit("text")), self.build_try_cast(read.copy(), to)) + direct: list = [] + if target is DataType.INT: + direct = [(exp.EQ(this=kind.copy(), expression=lit("integer")), read.copy())] + elif target is DataType.DOUBLE: + direct = [(exp.In(this=kind.copy(), expressions=[lit("integer"), lit("real")]), + exp.Cast(this=read.copy(), to=exp.DataType.build("REAL")))] + elif target is DataType.BOOLEAN: + direct = [(exp.EQ(this=kind.copy(), expression=lit("true")), lit(1)), + (exp.EQ(this=kind.copy(), expression=lit("false")), lit(0))] + elif target is DataType.TEXT: + return self.build_json_value(value, path, native) + return case((anon("JSON_VALID", value), case(*direct, from_text))) + + def _json_parts(self, value: Expression, path: JsonPath) -> tuple[Expression, Expression]: + text = lit(path.text) + return anon("JSON_TYPE", value, text), anon("JSON_EXTRACT", value, text) + def declared_cast_type(self, dt: Optional[DataType]) -> Optional[DataType]: """No DATE / TIMESTAMP cast: under numeric affinity it collapses a text date to its year.""" if dt in (DataType.DATE, DataType.TIMESTAMP): diff --git a/slayer/sql/dialects/trino.py b/slayer/sql/dialects/trino.py index 6322f7ef2..235121ef7 100644 --- a/slayer/sql/dialects/trino.py +++ b/slayer/sql/dialects/trino.py @@ -11,7 +11,10 @@ from slayer.core.enums import SUB_DAY_GRANULARITIES, DataType, DatePart, TimeGranularity from slayer.core.errors import SlayerError -from slayer.sql.dialects.base import SqlDialect +from slayer.core.json_path import JsonPath, json_path_text +from slayer.core.regex_pattern import RegexPattern, RegexReplacement +from slayer.sql.dialects.base import ExtremumFn, SqlDialect, TrimFn, anon, any_null, case, lit +from slayer.sql.dialects.patterns import JAVA, RegexFlavour if TYPE_CHECKING: from slayer.core.models import DatasourceConfig @@ -116,11 +119,65 @@ def value() -> Expression: return select.where(exp.LT(this=value(), expression=exp.Literal.number(size))) +def _trino_path(path: JsonPath) -> str: + """The path in Trino's JSONPath: a key that is not a plain identifier goes in ``["…"]``.""" + out = ["$"] + for step in path.steps: + if isinstance(step, int): + out.append(f"[{step}]") + elif json_path_text((step,)) == f"$.{step}": + out.append(f".{step}") + else: + out.append(f'["{step}"]') + return "".join(out) + + class TrinoDialect(PrestoFamilyDialect): sqlglot_name: str = "trino" ds_type_aliases: frozenset[str] = frozenset({"trino"}) url_scheme: str | None = "trino" install_extra: str | None = "trino" + regex_flavour: ClassVar[RegexFlavour] = JAVA + + def text_repeat(self, value: Expression, count: Expression) -> Expression: + """``repeat`` builds an array here.""" + return anon("ARRAY_JOIN", anon("REPEAT", value, count), lit("")) + + def first_code_point(self, s: Expression) -> Expression: + first = exp.Cast(this=anon("SUBSTR", s, lit(1), lit(1)), to=exp.DataType.build("VARCHAR(1)")) + return case((exp.EQ(this=s.copy(), expression=lit("")), lit(0)), default=anon("CODEPOINT", first)) + + def trim_spaces(self, fn: TrimFn, s: Expression) -> Expression: + """The bare form strips every whitespace character.""" + return anon(fn.upper(), s, lit(" ")) + + def build_split_part(self, value: Expression, delimiter: Expression, index: int) -> Expression: + """``element_at`` indexes from either end and is NULL past it.""" + field = exp.Coalesce(this=anon("ELEMENT_AT", anon("SPLIT", value, delimiter), lit(index)), + expressions=[lit("")]) + return case((any_null(value, delimiter), exp.Null()), default=field) + + def build_extremum(self, fn: ExtremumFn, args: tuple[Expression, ...]) -> Expression: + """``greatest`` / ``least`` return NULL when any argument is NULL.""" + return self.coalesced_extremum(fn, args, spelling="upper") + + def build_regexp_like(self, value: Expression, pattern: RegexPattern, case_insensitive: bool) -> Expression: + return anon("REGEXP_LIKE", value, self.regex_text(pattern, case_insensitive=case_insensitive)) + + def build_regexp_extract( + self, value: Expression, pattern: RegexPattern, group: int, case_insensitive: bool, + ) -> Expression: + extracted = anon("REGEXP_EXTRACT", value, self.regex_text(pattern), lit(group)) + return self.skipped_group_empty(value, pattern, group, extracted) + + def build_regexp_replace( + self, value: Expression, pattern: RegexPattern, replacement: RegexReplacement, case_insensitive: bool, + ) -> Expression: + return anon("REGEXP_REPLACE", value, self.regex_text(pattern, case_insensitive=case_insensitive), + self.replacement_text(replacement)) + + def build_json_value(self, value: Expression, path: JsonPath, native: bool) -> Expression: + return anon("JSON_EXTRACT_SCALAR", value, lit(_trino_path(path))) def set_connection_timeout(self, dbapi_connection: Any, timeout_seconds: int) -> object: """``query_max_run_time`` as a client-session property: sent with the next statement only.""" diff --git a/slayer/sql/dialects/tsql.py b/slayer/sql/dialects/tsql.py index c7e5a7928..456f92607 100644 --- a/slayer/sql/dialects/tsql.py +++ b/slayer/sql/dialects/tsql.py @@ -7,21 +7,42 @@ from __future__ import annotations import re -from typing import ClassVar, Literal, Optional +from collections.abc import Iterable, Sequence +from typing import Any, ClassVar, Literal, Optional from sqlglot import exp from sqlglot.expressions.datatypes import DType from sqlglot.expressions.core import Expr, Expression from slayer.core.enums import SUB_DAY_GRANULARITIES, DataType, DatePart, TimeGranularity +from slayer.core.json_path import JsonPath +from slayer.core.keys import ScalarCallKey +from slayer.core.regex_pattern import RegexPattern, RegexReplacement from slayer.sql.dialects.base import ( DottedAliasManglingMixin, + ExtremumFn, + ServerProfile, SqlDialect, + TextFn, + anon, + any_null, + case, + either, + lit, operand_copy, + pad_fill, StatAgg1Name, StatAgg2Name, _build_covar_decomposition, ) +from slayer.sql.dialects.patterns import RE2, RegexFlavour + +#: SQL Server major versions: 16 = 2022 (``GREATEST`` / ``LEAST``), 17 = 2025 (regex functions). +_SQL_SERVER_2022 = (16, 0) +_SQL_SERVER_2025 = (17, 0) +_REGEX_FUNCTIONS = frozenset({"regexp_like", "regexp_extract", "regexp_replace"}) +_GATED_FUNCTIONS = _REGEX_FUNCTIONS | {"greatest", "least"} +_HIGH_SURROGATES = (55296, 56319) # sqlglot's tsql transpiler emits names (VAR_SAMP, VARIANCE_POP) T-SQL lacks. @@ -71,7 +92,10 @@ def _days_since_monday(expr: Expression) -> Expression: def _is_predicate(node: Expr) -> bool: - return isinstance(node, (exp.Predicate, exp.Connector, exp.Not)) + """A predicate node; ``LIKE`` under its ``ESCAPE`` clause is part of that predicate.""" + if isinstance(node.parent, exp.Escape) and node.arg_key == "this": + return False + return isinstance(node, (exp.Predicate, exp.Connector, exp.Not, exp.Escape)) def _in_condition_position(node: Expr) -> bool: @@ -115,6 +139,135 @@ class TsqlDialect(DottedAliasManglingMixin, SqlDialect): alias_quote_open: ClassVar[str] = "[" alias_quote_close: ClassVar[str] = "]" + regex_flavour: ClassVar[RegexFlavour] = RE2.model_copy(update={"replacement_ampersand": True}) + json_db_types: ClassVar[frozenset[str]] = frozenset() + like_brackets: ClassVar[bool] = True + + def profile_needed(self, keys: Iterable[object]) -> bool: + """Regex needs SQL Server 2025 and ``greatest`` / ``least`` 2022: the version decides.""" + return any(isinstance(k, ScalarCallKey) and k.name in _GATED_FUNCTIONS for k in keys) + + def server_profile_sql(self) -> str | None: + return "SELECT SERVERPROPERTY('ProductMajorVersion')" + + def parse_server_profile( + self, *, base_row: Sequence[Any] | None, correlated_row: Sequence[Any] | None = None, + ) -> ServerProfile: + major = base_row[0] if base_row else None + try: + version = None if major is None else (int(str(major).strip()), 0) + except ValueError: + version = None + return ServerProfile(version=version) + + def _require_regex(self, fn: str) -> None: + self.require_version(minimum=_SQL_SERVER_2025, what=f"{fn}()", release="SQL Server 2025") + + def text_repeat(self, value: Expression, count: Expression) -> Expression: + return anon("REPLICATE", value, count) + + def concat_text(self, left: Expression, right: Expression) -> Expression: + return anon("CONCAT", left, right) + + def build_text_call(self, fn: TextFn, args: tuple[Expression, ...]) -> Expression: + if fn in ("lpad", "rpad"): + return self.portable_pad(fn=fn, s=args[0], n=args[1], fill=pad_fill(args)) + if fn == "replace": + return anon("REPLACE", self.binary_text(args[0]), self.binary_text(args[1]), args[2]) + if fn == "contains": + found = exp.GT(this=self.text_position(args[0], args[1]), expression=lit(0)) + empty = exp.And(this=exp.EQ(this=anon("DATALENGTH", args[1]), expression=lit(0)), + expression=exp.Not(this=any_null(args[0]))) + return either(found, empty) + return super().build_text_call(fn, args) + + def field_count(self, value: Expression, delimiter: Expression) -> Expression: + removed = self.char_length(anon("REPLACE", self.binary_text(value), self.binary_text(delimiter), lit(""))) + gap = exp.Paren(this=exp.Sub(this=self.char_length(value), expression=removed)) + per_field = exp.Nullif(this=self.char_length(delimiter), expression=lit(0)) + return exp.Add(this=exp.IntDiv(this=gap, expression=per_field), expression=lit(1)) + + def binary_text(self, value: Expression) -> Expression: + # COLLATE binds tighter than any operator. + atomic = isinstance(value, (exp.Column, exp.Literal, exp.Paren)) + operand = value.copy() if atomic else exp.Paren(this=value.copy()) + return exp.Collate(this=operand, expression=exp.var("Latin1_General_100_BIN2")) + + def code_point_char(self, n: Expression) -> Expression: + """``NCHAR``, astral code points as their UTF-16 surrogate pair (no supplementary collation needed).""" + offset = exp.Paren(this=exp.Sub(this=n.copy(), expression=lit(65536))) + high = anon("NCHAR", exp.Add(this=lit(55296), expression=exp.IntDiv(this=offset, expression=lit(1024)))) + low = anon("NCHAR", exp.Add(this=lit(56320), expression=exp.Mod(this=offset.copy(), expression=lit(1024)))) + return case((exp.LT(this=n.copy(), expression=lit(65536)), anon("NCHAR", n)), default=anon("CONCAT", high, low)) + + def first_code_point(self, s: Expression) -> Expression: + """``UNICODE`` reads one UTF-16 unit: a surrogate pair is combined; ``''`` is 0.""" + first = anon("UNICODE", s) + second = anon("UNICODE", self.char_substring(s, lit(2), lit(1))) + astral = exp.Add(this=exp.Add(this=exp.Mul(this=exp.Paren(this=exp.Sub(this=first.copy(), expression=lit(55296))), + expression=lit(1024)), + expression=exp.Sub(this=second, expression=lit(56320))), expression=lit(65536)) + return case( + (exp.EQ(this=anon("DATALENGTH", s), expression=lit(0)), lit(0)), + (exp.Between(this=first.copy(), low=lit(_HIGH_SURROGATES[0]), high=lit(_HIGH_SURROGATES[1])), astral), + default=first, + ) + + def build_split_part(self, value: Expression, delimiter: Expression, index: int) -> Expression: + """The fields as a JSON array (``STRING_ESCAPE``d), indexed by ``JSON_VALUE``; ``''`` past the end.""" + escaped = anon("REPLACE", self.binary_text(anon("STRING_ESCAPE", value, lit("json"))), + self.binary_text(anon("STRING_ESCAPE", delimiter, lit("json"))), lit('","')) + array = anon("CONCAT", lit('["'), escaped, lit('"]')) + if index > 0: + path: Expression = lit(f"$[{index - 1}]") + else: + position = exp.Add(this=self.field_count(value, delimiter), expression=lit(index)) + path = anon("CONCAT", lit("$["), position, lit("]")) + field = exp.Coalesce(this=anon("JSON_VALUE", array, path), expressions=[lit("")]) + return case((any_null(value, delimiter), exp.Null()), default=field) + + def cube_root(self, value: Expression) -> Expression: + magnitude = exp.Cast(this=exp.Abs(this=value.copy()), to=exp.DataType.build("FLOAT")) + root = anon("POWER", magnitude, exp.Div(this=lit(1), expression=exp.Literal.number("3.0"))) + return exp.Mul(this=exp.Sign(this=value.copy()), expression=root) + + def build_modulo(self, left: Expression, right: Expression, integer: bool) -> Expression: + """``%`` rejects FLOAT operands: ``a - b * trunc(a / b)``.""" + if integer: + return super().build_modulo(left, right, integer) + quotient = self.truncate(exp.Div(this=operand_copy(left), expression=exp.Nullif(this=operand_copy(right), + expression=lit(0)))) + return exp.Paren(this=exp.Sub(this=operand_copy(left), expression=exp.Mul(this=operand_copy(right), + expression=quotient))) + + def build_extremum(self, fn: ExtremumFn, args: tuple[Expression, ...]) -> Expression: + self.require_version(minimum=_SQL_SERVER_2022, what=f"{fn}()", release="SQL Server 2022") + return super().build_extremum(fn, args) + + def build_regexp_like(self, value: Expression, pattern: RegexPattern, case_insensitive: bool) -> Expression: + """``REGEXP_INSTR(…) > 0``: ``REGEXP_LIKE`` needs compatibility level 170, this does not.""" + self._require_regex("regexp_like") + position = anon("REGEXP_INSTR", value, self.regex_text(pattern, case_insensitive=case_insensitive)) + return exp.GT(this=position, expression=lit(0)) + + def build_regexp_extract( + self, value: Expression, pattern: RegexPattern, group: int, case_insensitive: bool, + ) -> Expression: + self._require_regex("regexp_extract") + extracted = anon("REGEXP_SUBSTR", value, self.regex_text(pattern), lit(1), lit(1), lit("c"), lit(group)) + return self.skipped_group_empty(value, pattern, group, extracted) + + def build_regexp_replace( + self, value: Expression, pattern: RegexPattern, replacement: RegexReplacement, case_insensitive: bool, + ) -> Expression: + self._require_regex("regexp_replace") + return anon("REGEXP_REPLACE", value, self.regex_text(pattern, case_insensitive=case_insensitive), + self.replacement_text(replacement), lit(1), lit(0), lit("c")) + + def build_json_value(self, value: Expression, path: JsonPath, native: bool) -> Expression: + valid = exp.EQ(this=anon("ISJSON", value), expression=lit(1)) + return case((valid, anon("JSON_VALUE", value, lit(path.text)))) + def build_null_safe_eq( self, left: Expression, right: Expression, ) -> Expression: diff --git a/slayer/sql/generator.py b/slayer/sql/generator.py index 589315316..b957dec40 100644 --- a/slayer/sql/generator.py +++ b/slayer/sql/generator.py @@ -40,7 +40,7 @@ from slayer.core.enums import RANK_FAMILY_TRANSFORMS 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, CastKey, 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.keys import BOOL_CONNECTIVE_OPS, KIND_POLICY, REGROUP_LEAF_PREFIX, SLOT_COMPOSITE_KINDS, TEMPORAL_TYPES, TEXT_RESULT_SCALARS, VALUE_KEY_TYPES, AggregateKey, ArithmeticKey, CastKey, 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, @@ -74,7 +74,7 @@ from slayer.sql._identifier_fit import fit_identifier, overlimit_tokens from slayer.sql import staged_plan from slayer.sql.dialects import SqlDialect, get_dialect -from slayer.sql.dialects.base import is_stat_agg1, is_stat_agg2 +from slayer.sql.dialects.base import bare_comparands, is_stat_agg1, is_stat_agg2 from slayer.sql.naming import ( OUTER_WRAP_ALIAS, AliasAllocator, @@ -190,6 +190,11 @@ class AggRenderSpec(BaseModel): value: Optional[Expression] = None +def _key_equality(left: Expression, right: Expression) -> exp.EQ: + left, right = bare_comparands(left, right) + return exp.EQ(this=left, expression=right) + + def _strip_declared_cast(expr: Expression) -> Expression: """Unwrap one declared-type ``CAST`` a derived-column expansion added.""" return expr.this if isinstance(expr, exp.Cast) else expr @@ -656,13 +661,6 @@ def _is_host_grain(key) -> bool: # --- Transform-input shape classification, shared by the series-regime # time_shift selector and the consecutive_periods emitter. --- -# SCALAR_PASSTHROUGH members whose result is a string (no defined truthiness); -# length / instr return numbers and are intentionally excluded. -_STRING_VALUED_SCALARS = frozenset({ - "lower", "upper", "trim", "ltrim", "rtrim", - "replace", "substr", "substring", "concat", -}) - #: Argument-less rank-family window functions (``ntile`` carries its bucket count). _RANK_WINDOW_FNS = {"rank": exp.Rank, "dense_rank": exp.DenseRank, "percent_rank": exp.PercentRank} @@ -679,7 +677,7 @@ def _validate_consecutive_periods_input(*, op: str, inner) -> None: (a boolean anywhere a number is needed is its integer).""" if ( isinstance(inner, ScalarCallKey) - and inner.name.lower() in _STRING_VALUED_SCALARS + and inner.name.lower() in TEXT_RESULT_SCALARS ): raise ValueError( f"{op!r} cannot use a string-valued predicate ({inner.name}(...)): a " @@ -2790,10 +2788,10 @@ def _ranked_value_expr( column_name=col.name, bundle=bundle, )) else: - expr = self._resolve_sql( + expr = self._dialect.read_column(self._resolve_sql( sql=col.sql if col.sql else col.name, name=col.name, model_name=root_relation, type=col.type, - ) + ), zoned=self._dialect.is_zoned_db_type(col.db_type)) for p in self._joined_paths_in_sql( sql_expr=expr, source_relation=root_relation, source_model=root_model, bundle=bundle, @@ -4417,6 +4415,13 @@ def _build_from_and_joins( prev_model = next_model return base_from, joins + def _join_key(self, *, model, column: str, alias: str) -> Expression: + # _to_ident quotes mixed-case keys; table qualifiers are internal aliases. + key = exp.Column(this=self._to_ident(column), table=exp.to_identifier(alias)) + # Join pairs name physical columns. + declared = next((c for c in getattr(model, "columns", ()) if c.is_base and c.physical_name == column), None) + return self._dialect.read_column(key, zoned=self._dialect.is_zoned_db_type(getattr(declared, "db_type", None))) + def _hop_join( self, *, edge, prev_model, next_model, current_alias: str, next_alias: str, ) -> Tuple[Expression, Optional[exp.Condition], str]: @@ -4424,16 +4429,9 @@ def _hop_join( 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( - this=exp.Column( - this=self._to_ident(src_col), - table=exp.to_identifier(current_alias), - ), - expression=exp.Column( - this=self._to_ident(tgt_col), - table=exp.to_identifier(next_alias), - ), + _key_equality( + self._join_key(model=prev_model, column=src_col, alias=current_alias), + self._join_key(model=next_model, column=tgt_col, alias=next_alias), ) for src_col, tgt_col in physical_join_pairs( edge=edge, source=prev_model, target=next_model, @@ -4481,10 +4479,8 @@ def _joined_or_local_dim_expr( f"Column {leaf!r} not found on joined model " f"{current_model.name!r}.", ) - return exp.Column( - this=exp.to_identifier(leaf), - table=exp.to_identifier(current_alias), - ) + column = exp.Column(this=exp.to_identifier(leaf), table=exp.to_identifier(current_alias)) + return self._dialect.read_column(column, zoned=self._dialect.is_zoned_db_type(col_def.db_type)) def _rank_family_window( self, *, fn: Expression, measure: Expression, partition_by: Iterable[Expression], descending: bool, @@ -5365,10 +5361,8 @@ def _dim_column_expr_from_planned( f"Column {leaf!r} not found on model " f"{source_model.name!r}", ) - return self._resolve_sql( - sql=col.sql, name=col.name, model_name=source_relation, - type=col.type, - ) + resolved = self._resolve_sql(sql=col.sql, name=col.name, model_name=source_relation, type=col.type) + return self._dialect.read_column(resolved, zoned=self._dialect.is_zoned_db_type(col.db_type)) def _raw_time_col_expr_for_planned( self, *, time_column, source_model, source_relation: str, bundle, @@ -5406,6 +5400,7 @@ def _raw_time_col_expr_for_planned( owner_path=tuple(time_column.path), cast=False, ) + owner = joined_model else: expanded_sql = self._expand_derived_column_sql( source_model=source_model, @@ -5414,7 +5409,11 @@ def _raw_time_col_expr_for_planned( bundle=bundle, cast=False, ) - return self._parse(expanded_sql) + owner = source_model + declared = owner.get_column(time_column.column_name) + return self._dialect.read_column( + self._parse(expanded_sql), zoned=self._dialect.is_zoned_db_type(getattr(declared, "db_type", None)), + ) raise NotImplementedError( f"Unsupported TimeTruncKey column type: {type(time_column).__name__}", ) @@ -5773,9 +5772,15 @@ def _build_agg_render_spec_from_planned( # NOSONAR(S3776) — sequential isinst # The declared-type CAST is baked into sql_text (on the value), so # the aggregate must not re-cast the whole expression. column_type = None + zoned_value = None else: sql_text = col.sql if col.sql else col.name column_type = col.type + # A zoned physical column reads as the dialect's naive type inside the aggregate too. + zoned_value = self._dialect.read_column( + self._resolve_sql(sql=sql_text, name=col.name, model_name=source_relation, type=column_type), + zoned=True, + ) if self._dialect.is_zoned_db_type(col.db_type) else None formula = rendered_formula(agg=key.agg, definition=agg_def) return AggRenderSpec( name=col.name, @@ -5786,6 +5791,7 @@ def _build_agg_render_spec_from_planned( # NOSONAR(S3776) — sequential isinst type=slot_type, column_type=column_type, input_type=input_type, + value=zoned_value, agg_kwargs=self._agg_param_exprs( key=key, formula=formula, resolved=resolved_agg_kwargs, scope=param_scope, ), diff --git a/slayer/sql/render/library.py b/slayer/sql/render/library.py new file mode 100644 index 000000000..763ad59c9 --- /dev/null +++ b/slayer/sql/render/library.py @@ -0,0 +1,103 @@ +"""The portable library's render path: each library call through its typed dialect hook.""" + +from __future__ import annotations + +from typing import Any, Callable, List, Optional, Tuple, get_args + +from sqlglot import exp +from sqlglot.expressions.core import Expression + +from slayer.core.json_path import JsonPath, parse_json_path +from slayer.core.keys import ScalarCallKey +from slayer.core.like_pattern import parse_like +from slayer.core.regex_pattern import parse_regex, parse_replacement +from slayer.sql.dialects.base import ( + ExtremumFn, + MathFn, + SqlDialect, + TextFn, + any_null, + case, + is_extremum_fn, + is_math_fn, + is_text_fn, + lit, + literal_int, +) + +#: Scalars rendered through a dialect hook. +LIBRARY_FUNCTIONS = frozenset({ + *get_args(TextFn), *get_args(MathFn), *get_args(ExtremumFn), "split_part", "like", "ilike", "json_value", + "regexp_like", "regexp_extract", "regexp_replace", +}) +_REGEX = frozenset({"regexp_like", "regexp_extract", "regexp_replace"}) + + +def _text(node: Expression) -> str: + if not (isinstance(node, exp.Literal) and node.is_string): + raise RuntimeError(f"a library text argument reached render as {node.sql()!r}; the binder checks it.") + return node.this + + +def _int(node: Expression) -> int: + value = literal_int(node) + if value is None: + raise RuntimeError(f"a library integer argument reached render as {node.sql()!r}; the binder checks it.") + return value + + +def json_input(value: Expression, *, dialect: SqlDialect) -> bool: + """Whether ``json_value``'s rendered input is the engine's native JSON type (a cast to it).""" + if not isinstance(value, exp.Cast): + return False + return value.to.sql(dialect=dialect.sqlglot_name).split("(")[0].upper() in dialect.json_db_types + + +def json_operands( + key: ScalarCallKey, *, part: Callable[[Any], Expression], dialect: SqlDialect, +) -> Tuple[Expression, JsonPath, bool]: + """``json_value``'s rendered input, its path, and whether the input is the engine's native JSON type.""" + value = part(key.args[0]) + return value, parse_json_path(_text(part(key.args[1]))), json_input(value, dialect=dialect) + + +def render_library_call(*, name: str, args: List[Expression], dialect: SqlDialect) -> Optional[Expression]: + """``name(args)`` lowered through its dialect hook; ``None`` for a non-library scalar.""" + if is_text_fn(name): + return dialect.build_text_call(name, tuple(args)) + if is_math_fn(name): + return dialect.build_math_call(name, tuple(args)) + if is_extremum_fn(name): + return dialect.build_extremum(name, tuple(args)) + if name == "split_part": + return _split_part(args, dialect=dialect) + if name in ("like", "ilike"): + pattern = args[1] + written = parse_like(pattern.this) if isinstance(pattern, exp.Literal) and pattern.is_string else pattern + return dialect.build_like(args[0], written, name == "ilike") + if name == "json_value": + return dialect.build_json_value(args[0], parse_json_path(_text(args[1])), json_input(args[0], dialect=dialect)) + if name in _REGEX: + return _render_regex(name=name, args=args, dialect=dialect) + return None + + +def _split_part(args: List[Expression], *, dialect: SqlDialect) -> Expression: + """An empty delimiter leaves the whole value as the one field (Postgres), whatever the engine's own split.""" + value, delimiter, index = args[0], args[1], _int(args[2]) + whole = value.copy() if abs(index) == 1 else case((exp.Not(this=any_null(value)), lit(""))) + empty = exp.EQ(this=dialect.char_length(delimiter), expression=lit(0)) + return case((empty, whole), default=dialect.build_split_part(value, delimiter, index)) + + +def _render_regex(*, name: str, args: List[Expression], dialect: SqlDialect) -> Expression: + pattern = parse_regex(_text(args[1])) + if name == "regexp_extract": + return dialect.build_regexp_extract(args[0], pattern, _int(args[2]) if len(args) > 2 else 0, False) + if name == "regexp_like": + return dialect.build_regexp_like(args[0], pattern, len(args) > 2) + replacement = parse_replacement(_text(args[2]), groups=pattern.groups) + return dialect.build_regexp_replace(args[0], pattern, replacement, len(args) > 3) + + +__all__ = ["LIBRARY_FUNCTIONS", "json_input", "json_operands", "render_library_call"] diff --git a/slayer/sql/render/row_expr.py b/slayer/sql/render/row_expr.py index 6026a6cd1..4fdac9a05 100644 --- a/slayer/sql/render/row_expr.py +++ b/slayer/sql/render/row_expr.py @@ -39,11 +39,20 @@ _FrozenKey, boolean_valued, check_scalar_arity, + integer_valued, numeric_boolean_positions, temporal_type, unit_word, ) -from slayer.sql.dialects.base import SqlDialect, TemporalComparisonOp, cast_target, operand_copy, temporal_type_of +from slayer.sql.dialects.base import ( + SqlDialect, + TemporalComparisonOp, + bare_comparands, + cast_target, + operand_copy, + temporal_type_of, +) +from slayer.sql.render.library import json_operands, render_library_call from slayer.sql.render.parse import rewrite_log_aliases as rewrite_log_alias _BINARY_OPS: Dict[str, Any] = { @@ -214,6 +223,8 @@ def render_arithmetic( node_cls = _BINARY_OPS.get(op) if node_cls is None: raise NotImplementedError(f"Unsupported arithmetic operator {op!r}.") + if op in _TEMPORAL_COMPARISON_OPS: + operands = list(bare_comparands(operands[0], operands[1])) return _fold_binary(node_cls=node_cls, operands=operands) @@ -245,21 +256,32 @@ def temporal_comparison(key: ArithmeticKey) -> Optional[Tuple[TemporalComparison def render_null_safe(*, op: str, operands: List[Expression], dialect: SqlDialect) -> Expression: """``a IS [NOT] DISTINCT FROM b`` through the dialect's null-safe equality.""" - left, right = (operand_copy(o) for o in operands) + left, right = bare_comparands(*(operand_copy(o) for o in operands)) same = dialect.build_null_safe_eq(left, right) return same if op == "is not distinct from" else exp.Not(this=exp.Paren(this=same)) -def render_cast(*, key: CastKey, value: Expression, dialect: SqlDialect) -> Expression: - """The database's own cast of the author's type; ``TRY_CAST`` through the dialect's lowering.""" +def render_cast( + *, key: CastKey, part: Callable[[Any], Expression], dialect: SqlDialect, direct: bool = True, +) -> Expression: + """The database's own cast of the author's type; ``TRY_CAST`` through the dialect's lowering, and a + ``TRY_CAST`` of ``json_value`` (``RETURNING``) as the dialect's typed read when ``direct`` (its inputs readable).""" to = cast_target(key.type_text, dialect=dialect) + if key.try_: + to = dialect.try_cast_type(to, data_type=key.data_type) + source = key.source + if key.try_ and direct and isinstance(source, ScalarCallKey) and source.name == "json_value": + value, path, native = json_operands(source, part=part, dialect=dialect) + return dialect.build_json_value_as(value, path, native, to, key.data_type) + value = part(source) return dialect.build_try_cast(value, to) if key.try_ else exp.Cast(this=value, to=to) def render_temporal_comparison( *, op: TemporalComparisonOp, operand: Expression, value: date, dialect: SqlDialect, ) -> Expression: - """A comparison against a temporal literal, through the dialect's one hook.""" + """A comparison against a temporal literal, through the dialect's one hook (ISO text, so a zoned column stays bare).""" + operand, _ = bare_comparands(operand, exp.Literal.string("")) grouped = _paren_if_lower_prec(operand, parent_prec=_COMPARISON_PREC, is_right=False) return dialect.build_temporal_comparison(op=op, operand=grouped, value=value) @@ -267,20 +289,37 @@ def render_temporal_comparison( def render_scalar_call( *, name: str, args: List[Expression], dialect: SqlDialect, ) -> Expression: - """The one ScalarCall policy. The log fix-up is load-bearing: ``exp.func("LOG10", x)`` normalises to ``LOG(10, x)``, wrong where ``LOG10`` is native single-arg.""" + """The one ScalarCall policy: a library function through its dialect hook, else the same-named SQL call. + The log fix-up is load-bearing (``passthrough_call``).""" arity_error = check_scalar_arity(name=name, argc=len(args)) if arity_error is not None: # Checked before building: sqlglot is inconsistent (3-arg ROUND drops the third, etc.). raise NotImplementedError(f"Scalar arity check failed: {arity_error}") if name in DATE_FUNCTIONS: raise RuntimeError(f"Date function {name!r} renders only from its key (render_date_call).") - if name == "like": - return exp.Like(this=args[0], expression=args[1]) - if name == "ilike": - return dialect.build_ilike(args[0], args[1]) + library = render_library_call(name=name, args=args, dialect=dialect) + if library is not None: + return dialect.rewrite_target_ast(library) if name == "mod": - # ``%`` is an operator, not a Func; the ``%`` composer parenthesises both sides correctly. - return render_arithmetic(op="%", operands=args) + return dialect.build_modulo(args[0], args[1], True) + if name == "log" and len(args) == 1: + # Postgres's one-argument log is base 10; elsewhere bare LOG is often ln. + return passthrough_call(name="log10", args=args, dialect=dialect) + return passthrough_call(name=name, args=args, dialect=dialect) + + +def render_scalar_key( + *, key: ScalarCallKey, args: List[Expression], dialect: SqlDialect, column_type: ColumnTypeFn, +) -> Expression: + """A non-date scalar key: ``mod`` by its operand types, else ``render_scalar_call``.""" + if key.name == "mod": + return render_modulo(key=key, operands=args, dialect=dialect, column_type=column_type) + return render_scalar_call(name=key.name, args=args, dialect=dialect) + + +def passthrough_call(*, name: str, args: List[Expression], dialect: SqlDialect) -> Expression: + """``name(args)`` as sqlglot spells it on ``dialect``. The log fix-up is load-bearing: + ``exp.func("LOG10", x)`` normalises to ``LOG(10, x)``, wrong where ``LOG10`` is native single-arg.""" node = dialect.rewrite_target_ast(exp.func(name.upper(), *args)) return rewrite_log_alias(node, dialect=dialect) @@ -313,7 +352,7 @@ def render_date_call( if not isinstance(key.args[DATE_ADD_COUNT_ARG], LiteralKey): # One truncation toward zero, identical on every dialect. count = exp.Cast( - this=render_scalar_call(name="trunc", args=[count], dialect=dialect), + this=passthrough_call(name="trunc", args=[count], dialect=dialect), to=exp.DataType.build("INT"), ) return dialect.build_date_add( @@ -416,7 +455,7 @@ def _part(a: Any) -> Expression: (column,) = numeric_parts(key=key, parts=[_part(key.column)], column_type=column_type) return render_in_predicate(key=key, column=column, dialect=dialect) if isinstance(key, CastKey): - return render_cast(key=key, value=_part(key.source), dialect=dialect) + return render_cast(key=key, part=_part, dialect=dialect) raise NotImplementedError( f"Row-level expression cannot contain {type(key).__name__}.", ) @@ -431,10 +470,19 @@ def _row_arithmetic( return render_temporal_comparison(op=op, operand=part(operand), value=value, dialect=dialect) if key.op in NULL_SAFE_COMPARISON_OPS: return render_null_safe(op=key.op, operands=[part(o) for o in key.operands], dialect=dialect) - return render_arithmetic( - op=key.op.lower(), - operands=numeric_parts(key=key, parts=[part(o) for o in key.operands], column_type=column_type), - ) + operands = numeric_parts(key=key, parts=[part(o) for o in key.operands], column_type=column_type) + if key.op == "%": + return render_modulo(key=key, operands=operands, dialect=dialect, column_type=column_type) + return render_arithmetic(op=key.op.lower(), operands=operands) + + +def render_modulo( + *, key: ArithmeticKey | ScalarCallKey, operands: List[Expression], dialect: SqlDialect, column_type: ColumnTypeFn, +) -> Expression: + """``%`` / ``mod`` through the dialect, which knows whether its native ``%`` takes non-integers.""" + children = key.operands if isinstance(key, ArithmeticKey) else key.args + integer = all(integer_valued(c, column_type=column_type) for c in children) + return dialect.build_modulo(operands[0], operands[1], integer) def _row_scalar_call( @@ -445,4 +493,4 @@ def _row_scalar_call( args = numeric_parts(key=key, parts=[part(a) for a in key.args], column_type=column_type) if key.name in DATE_FUNCTIONS: return render_date_call(key=key, args=args, dialect=dialect, column_type=column_type) - return render_scalar_call(name=key.name, args=args, dialect=dialect) + return render_scalar_key(key=key, args=args, dialect=dialect, column_type=column_type) diff --git a/slayer/sql/render/value_expr.py b/slayer/sql/render/value_expr.py index 955e8bac2..77b2fe9c8 100644 --- a/slayer/sql/render/value_expr.py +++ b/slayer/sql/render/value_expr.py @@ -57,10 +57,12 @@ render_arithmetic, render_cast, render_in_predicate, + render_modulo, render_null_safe, render_date_call, render_temporal_comparison, render_scalar_call, + render_scalar_key, temporal_comparison, ) from slayer.sql.scope import ScopeFrame @@ -404,6 +406,8 @@ def render_value_key( # NOSONAR(S3776) — sequential dispatch over the closed and op in _COMPARISON_OPS ): operands = [_paren_if_binary(o) for o in operands] + if op == "%": + return render_modulo(key=key, operands=operands, dialect=ctx.dialect, column_type=_known_column_types(ctx)) return render_arithmetic(op=op, operands=operands) if isinstance(key, ScalarCallKey): @@ -421,9 +425,7 @@ def render_value_key( # NOSONAR(S3776) — sequential dispatch over the closed return render_date_call( key=key, args=args, dialect=ctx.dialect, column_type=_column_types(ctx, key), ) - return render_scalar_call( - name=key.name, args=args, dialect=ctx.dialect, - ) + return render_scalar_key(key=key, args=args, dialect=ctx.dialect, column_type=_known_column_types(ctx)) if isinstance(key, InKey): (column,) = numeric_parts( @@ -432,7 +434,10 @@ def render_value_key( # NOSONAR(S3776) — sequential dispatch over the closed return render_in_predicate(key=key, column=column, dialect=ctx.dialect) if isinstance(key, CastKey): - return render_cast(key=key, value=render_value_key(key=key.source, ctx=ctx), dialect=ctx.dialect) + return render_cast( + key=key, part=lambda k: render_value_key(key=k, ctx=ctx), dialect=ctx.dialect, + direct=ctx.aliases is None or not _slot_available(key.source, ctx.aliases), + ) if isinstance(key, AggregateKey): return _render_aggregate(key, ctx) diff --git a/slayer/sql/scope.py b/slayer/sql/scope.py index f1c1fd7af..fce6f45b1 100644 --- a/slayer/sql/scope.py +++ b/slayer/sql/scope.py @@ -29,7 +29,7 @@ from slayer.core.enums import DataType from slayer.core.errors import ModeASqlParseError, UnknownReferenceError, UnreachableDefinitionError -from slayer.core.join_walker import model_column_type, resolved_terminal +from slayer.core.join_walker import model_column_lookup, model_column_type, resolved_terminal from slayer.core.keys import ( REGROUP_LEAF_PREFIX, ArithmeticKey, @@ -406,10 +406,14 @@ def _anchor(self, ref: Ref) -> exp.Expression: # NOSONAR(S3776) — flat dispat limit=self.dialect.max_identifier_bytes, ) self._register_path_prefixes(ref.path) - return quote_mixed_case_identifiers(exp.Column( + column = quote_mixed_case_identifiers(exp.Column( this=exp.to_identifier(ref.leaf), table=exp.to_identifier(alias), )) + declared = model_column_lookup(model=self.root_model, models_by_name=self._models_by_name())(ref) + return self.dialect.read_column( + column, zoned=self.dialect.is_zoned_db_type(getattr(declared, "db_type", None)), + ) if isinstance(ref, ColumnSqlKey): model = self._model_for(ref.model) col = next( @@ -452,7 +456,7 @@ def _anchor(self, ref: Ref) -> exp.Expression: # NOSONAR(S3776) — flat dispat alias_resolver=self._alias_resolver(), crossed_paths=self.join_paths, ) - return self._parse(expanded) + return self.dialect.read_column(self._parse(expanded), zoned=self.dialect.is_zoned_db_type(col.db_type)) if isinstance(ref, SqlFragmentKey): # A bound parameter expression: each typed ref anchors (and registers # its joins) here, substituted into the parsed template. diff --git a/slayer/sql/sql_expr.py b/slayer/sql/sql_expr.py index d31445fe8..abc461a9e 100644 --- a/slayer/sql/sql_expr.py +++ b/slayer/sql/sql_expr.py @@ -1,4 +1,4 @@ -"""Stage 7a.4 (DEV-1450) — Mode-A sqlglot wrapper. +"""Stage 7a.4 — Mode-A sqlglot wrapper. Canonicalises Mode-A SQL to a sqlglot-normalised string and detects window functions uniformly. @@ -93,7 +93,7 @@ def canonicalize_sql(text: str, *, dialect: Optional[str] = None) -> str: if dialect == "sqlite": parsed = rewrite_sqlite_json_extract(parsed) - # DEV-1784: single log-alias policy — the same rewrite the parser and + # Single log-alias policy — the same rewrite the parser and # generator apply, keyed on ``SqlDialect.should_use_native_log`` rather than # a local allowlist. ``dialect=None``, or a name sqlglot parses but SLayer's # registry does not carry, skips the rewrite (matching the old allowlist's @@ -146,3 +146,9 @@ def assert_no_window_in_filter(text: str, *, source: str) -> None: def build_cast_type(type_text: str, *, dialect: str) -> exp.DataType: """The author's cast type as ``dialect``'s ``DataType``; ``ValueError`` when it cannot express it.""" return cast_target(type_text, dialect=get_dialect(dialect)) + + +def native_json_type(db_type: str, *, dialect: str) -> Optional[str]: + """``db_type``'s leading word when it is one of ``dialect``'s JSON types (``JSONB``, ``VARIANT``, …).""" + word = db_type.split("(")[0].strip().upper() + return word if word in get_dialect(dialect).json_db_types else None diff --git a/slayer/usage_reporting/features/__init__.py b/slayer/usage_reporting/features/__init__.py index 06fc8fc22..31085cd04 100644 --- a/slayer/usage_reporting/features/__init__.py +++ b/slayer/usage_reporting/features/__init__.py @@ -8,7 +8,7 @@ from pydantic import BaseModel, Field from slayer.core.enums import BUILTIN_AGGREGATIONS, normalize_aggregation_name, ALL_TRANSFORMS -from slayer.core.keys import SCALAR_FUNCTIONS +from slayer.core.keys import RESERVED_SCALAR_NAMES from slayer.core.models import DatasourceConfig from slayer.core.query import ComputedDimension, SlayerQuery from slayer.sql.dialects import dialect_for_ds_type @@ -65,7 +65,7 @@ def _is_call(tokens: list[tokenize.TokenInfo], i: int) -> bool: def _count_call(tokens: list[tokenize.TokenInfo], i: int, out: QueryFeatures) -> None: """Count the call at ``tokens[i]`` as a transform or an aggregation; scalar functions are skipped.""" name = tokens[i].string.lower() - if name in SCALAR_FUNCTIONS: + if name in RESERVED_SCALAR_NAMES: return wraps = _wraps_aggregate(tokens[i + 2:_close_paren(tokens, i + 1)]) aggregation = _aggregation_token(tokens[i].string) diff --git a/tests/_dev1871_raise_ledger.py b/tests/_dev1871_raise_ledger.py index 827f607bb..22c732828 100644 --- a/tests/_dev1871_raise_ledger.py +++ b/tests/_dev1871_raise_ledger.py @@ -135,6 +135,18 @@ def _row(module, function, exc, message, category, family, user, owner, message="date_add() count `…` is not numeric." + SUGGEST + "Pass an integer, or a numeric column or expression (it is truncated toward zero).", category="checker", family="date-operand", user=True, owner="checker"), + _row(module=_EE, function="_number_literal", exc="ScalarOperandTypeError", + message="'…' is not a number, so it cannot meet the number `…`." + + SUGGEST + "Compare with a number (e.g. 100), or compare text with text.", + category="checker", family="mixed-type-coercion", user=True, owner="checker"), + _row(module=_EE, function="_numeric_scalar_args", exc="ScalarOperandTypeError", + message="…() reads numbers, but `…` is TEXT." + + SUGGEST + "Convert numbers stored as text: …(TRY_CAST(… AS DOUBLE)).", + category="checker", family="mixed-type-coercion", user=True, owner="checker"), + _row(module=_EE, function="_text_concat_args", exc="ScalarOperandTypeError", + message="Text concatenation has no portable spelling for the BOOLEAN `…`." + + SUGGEST + "Spell it explicitly: CASE WHEN … THEN 'true' ELSE 'false' END.", + category="checker", family="mixed-type-coercion", user=True, owner="checker"), _row(module=_EE, function="_raise_not_a_time_point", exc="TimeLiteralError", message="'…' is not a time point." + AT + "comparison with `…`" diff --git a/tests/_dev2101_fixtures.py b/tests/_dev2101_fixtures.py index a3da84b97..6e8b41e1a 100644 --- a/tests/_dev2101_fixtures.py +++ b/tests/_dev2101_fixtures.py @@ -255,6 +255,7 @@ async def make_exec_engine(request) -> AsyncIterator[SlayerQueryEngine]: ('"order total" >= 300', frozenset({3, 4})), ("-amount < -25", frozenset({3, 4})), ("quantity % 2 = 1", frozenset({1, 3})), + ("amount % 20 = 10", frozenset({1, 3})), ("amount ** 2 > 500", frozenset({3, 4})), ("CASE WHEN status = 'paid' THEN amount ELSE 0 END > 15", frozenset({2, 4})), ("CASE status WHEN 'void' THEN 1 ELSE 0 END = 1", frozenset({5})), @@ -270,6 +271,7 @@ async def make_exec_engine(request) -> AsyncIterator[SlayerQueryEngine]: ("SUBSTRING(status FROM 2 FOR 3)", {1: "aid", 2: "aid", 3: "end", 4: "aid", 5: "oid"}), ("POSITION('a' IN status)", {1: 2, 2: 2, 3: 0, 4: 2, 5: 0}), ("quantity % 3", {1: 1, 2: 2, 3: 0, 4: 2, 5: 1}), + ("amount % 7", {1: 3, 2: 6, 3: 2, 4: 5, 5: None}), ("amount ** 2", {1: 100, 2: 400, 3: 900, 4: 1600, 5: None}), ("CASE WHEN amount > 15 THEN 'big' ELSE 'small' END", {1: "small", 2: "big", 3: "big", 4: "big", 5: "small"}), ("date_diff('day', DATE '2024-01-01', order_date)", {1: 4, 2: 19, 3: 40, 4: 55, 5: 74}), diff --git a/tests/_dev2120_fixtures.py b/tests/_dev2120_fixtures.py new file mode 100644 index 000000000..011201948 --- /dev/null +++ b/tests/_dev2120_fixtures.py @@ -0,0 +1,762 @@ +"""Shared fixtures for the portable Mode-B library: the ``lib`` table, the case table every dialect runs, seeding. + +Expected values are the Postgres meaning (spec: queries/scalar-functions and siblings). +""" + +from __future__ import annotations + +import contextlib +import math +from collections.abc import AsyncGenerator, Callable, Iterable, Mapping +from datetime import date, datetime, timedelta +from decimal import Decimal +from typing import Any, Optional + +from pydantic import BaseModel, ConfigDict + +from slayer.core.enums import DataType +from slayer.core.errors import SlayerError +from slayer.core.keys import SCALAR_SPECS +from slayer.core.models import Column, SlayerModel +from slayer.core.query import SlayerQuery +from slayer.engine.query_engine import SlayerQueryEngine, SlayerResponse +from slayer.sql.client import SlayerSQLClient +from slayer.sql.dialects.base import ServerProfile +from tests._dev1737_fixtures import SERVER_TYPES, TableSpec, as_temporal, seed_backend +from tests._dev2101_fixtures import emit +from tests._engine_helpers import seeded_exec_engine + +TIER1 = ("sqlite", "postgres", "duckdb", "mysql", "clickhouse", "tsql", "trino", "snowflake", "bigquery") +EXEC_BACKENDS = ("sqlite", "duckdb") +IDS = tuple(range(1, 11)) + +#: Functions this change adds to ``SCALAR_SPECS``. +NEW_FUNCTIONS = frozenset({ + "left", "right", "starts_with", "ends_with", "contains", "lpad", "rpad", "reverse", "repeat", + "split_part", "concat_ws", "chr", "ascii", + "div", "pi", "sin", "cos", "tan", "asin", "acos", "atan", "atan2", "cbrt", + "regexp_like", "regexp_extract", "regexp_replace", "json_value", +}) +#: Spellings the parser collapses into a library function or the granularity call. +SPELLINGS = frozenset({ + "strpos", "POSITION", "date_trunc", "json_extract", "json_extract_scalar", + "json_extract_path_text", "jsonb_extract_path_text", +}) +#: Mode-B operators whose meaning the library fixes. +OPERATORS = frozenset({ + "=", "<>", "<", "<=", ">", ">=", "IN", "BETWEEN", "IS DISTINCT FROM", + "+", "-", "*", "/", "%", "||", "LIKE", "ILIKE", "~", "~*", "!~", "!~*", "->", "->>", "RETURNING", +}) + +# --------------------------------------------------------------------------- # +# The ``lib`` table +# --------------------------------------------------------------------------- # +P1 = '{"a": {"b": "x"}, "qty": 2, "n": 0, "f": false, "ok": true}' +P7 = '{"items": [{}, {"unit price": "9.5"}], "a": [{"b": "x"}]}' +P9 = '{"a": {"b": 1}, "n": 12, "f": true, "ok": false}' +P10 = '{"a": {"b": 2.5}, "d": "2024-02-29", "t": "2024-02-29 10:00:00", "n": "7"}' + +LIB = TableSpec( + name="lib", + columns=[ + ("id", "INT"), ("s", "TEXT"), ("p", "TEXT"), ("n", "INT"), ("i", "INT"), ("m", "INT"), + ("x", "DOUBLE"), ("y", "DOUBLE"), ("a", "INT"), ("b", "INT"), ("c", "INT"), ("cp", "INT"), + ("code", "TEXT"), ("word", "TEXT"), ("tag", "TEXT"), ("notes", "TEXT"), ("prefix", "TEXT"), + ("payload", "TEXT"), ("num_txt", "TEXT"), ("qty", "INT"), ("ts", "TIMESTAMP"), ("doc", "TEXT"), + ("big", "TEXT"), + ], + rows=[ + (1, "ABCDE", "CD", 2, 7, 2, 0.5, 1.0, None, 2, 1, 65, "ab123", "paid", "+1 (555) 01", + "paid\nlate", "ab1", P1, "120.5", 3, "2025-03-05 10:00:00", '{"v": null}', "12345678901234567"), + (2, "€é", "é", -2, -7, -2, 2.0, -1.0, 3, None, 1, 8364, "ab12", "PAID", "5 USD", + "line1\nline2", "zz", '{"a": {}, "qty": "3"}', "99", 0, "2025-03-31 23:59:59", '{}', None), + (3, "a/b/c", "/", 0, 7, 0, -1.0, 0.5, 1, 2, None, 128512, "a_1", "ada", "a@x.org", + "nothing", "a_", '{"a": {"b": null}, "qty": "x"}', "abc", 1, "2025-04-01 00:00:00", '{"v": {"k": 1}}', None), + (4, "", "x", 9, -7, 3, 1.0, 1.0, None, None, None, 55296, "abc1", "Ada", "nobody", + "paid late", "a_", '{"a": {"b": [1]}}', None, 2, "2024-12-31 12:00:00", '{"v": [1]}', None), + (5, None, "a", None, 7, None, None, 1.0, 5, 5, 5, None, None, None, None, + None, None, "not json", "3.0", 3, None, '{"v": "x"}', None), + (6, "Ada Lovelace", "Love", 3, 7, -3, -8.0, None, -1, 0, 1, 1114112, "[ab]1", "123", "15%", + "Paid Later", "[a", None, "10", 1, "2025-02-10 08:00:00", '{"v": 0}', None), + (7, "x\U0001F600y", "\U0001F600", -9, -7, 7, -1.5, 2.0, 2, None, None, 57343, "a1", "١٢٣", "150", + "x", "%", P7, "1.5", 2, "2025-03-15 00:00:00", '{"v": false}', None), + (8, "ab", "", 1, 0, 1, 0.0, 1.0, None, None, 4, 1114111, "a*?1", "admin", "x", + "late paid", "a*", "{}", "1", 1, "2025-01-01 00:00:00", '{"v": "2024-02-29"}', None), + (9, "abc", "z", -1, None, -1, 27.0, -3.0, 0, -3, None, 233, "ab\n", "Adele", "USD USD", + "a\nb", None, P9, "02", 2, "2025-06-30 18:30:00", '{"v": "2024-02-29 10:00:00"}', None), + (10, "Ünïcode", None, 5, 8, 4, 0.25, 0.5, 7, 1, 3, 97, "1_2", "c:\\x1", "", + "", "1\\_", P10, "x", None, "2025-03-01 00:00:00", '{"v": 12}', None), + ], +) +_NAMES = [c for c, _ in LIB.columns] +ROWS: dict[int, dict[str, Any]] = {r[0]: dict(zip(_NAMES, r)) for r in LIB.rows} + + +def lib_model(*, data_source: str = "test") -> SlayerModel: + types = {"INT": DataType.INT, "DOUBLE": DataType.DOUBLE, "TEXT": DataType.TEXT, "TIMESTAMP": DataType.TIMESTAMP} + return SlayerModel( + name="lib", sql_table="lib", data_source=data_source, default_time_dimension="ts", + columns=[Column(name=c, type=types[k], primary_key=c == "id") for c, k in LIB.columns], + ) + + +# --------------------------------------------------------------------------- # +# Postgres-meaning oracle +# --------------------------------------------------------------------------- # +def _nulls(fn: Callable[..., Any]) -> Callable[..., Any]: + def wrapped(*args: Any) -> Any: + return None if any(a is None for a in args) else fn(*args) + return wrapped + + +@_nulls +def pg_left(s: str, n: int) -> str: + return s[:n] + + +@_nulls +def pg_right(s: str, n: int) -> str: + return s[max(len(s) - n, 0):] if n >= 0 else s[-n:] + + +@_nulls +def pg_lpad(s: str, n: int, fill: str = " ") -> str: + if n <= 0: + return "" + return s[:n] if len(s) >= n else (fill * n)[:n - len(s)] + s + + +@_nulls +def pg_rpad(s: str, n: int, fill: str = " ") -> str: + if n <= 0: + return "" + return s[:n] if len(s) >= n else s + (fill * n)[:n - len(s)] + + +@_nulls +def pg_split_part(s: str, delimiter: str, k: int) -> str: + parts = s.split(delimiter) + if k > 0: + return parts[k - 1] if k <= len(parts) else "" + return parts[k] if -k <= len(parts) else "" + + +@_nulls +def pg_strpos(s: str, p: str) -> int: + return s.find(p) + 1 + + +@_nulls +def pg_div(a: float, b: float) -> Optional[float]: + return None if b == 0 else math.trunc(a / b) + + +def pg_greatest(*args: Any) -> Any: + present = [a for a in args if a is not None] + return max(present) if present else None + + +def pg_least(*args: Any) -> Any: + present = [a for a in args if a is not None] + return min(present) if present else None + + +@_nulls +def pg_chr(cp: int) -> Optional[str]: + return None if 0xD800 <= cp <= 0xDFFF or cp > 0x10FFFF else chr(cp) + + +@_nulls +def pg_ascii(s: str) -> int: + return ord(s[0]) if s else 0 + + +@_nulls +def in_unit(fn: Callable[[float], float], x: float) -> Optional[float]: + return fn(x) if -1 <= x <= 1 else None + + +@_nulls +def cbrt(x: float) -> float: + return math.copysign(abs(x) ** (1 / 3), x) + + +def num_text(value: Any) -> Optional[float]: + """``TRY_CAST(text AS DOUBLE)``.""" + if value is None: + return None + try: + return float(value) + except ValueError: + return None + + +# --------------------------------------------------------------------------- # +# The case table +# --------------------------------------------------------------------------- # +class NumText(BaseModel): + """A JSON number read as TEXT: the database's own rendering of ``value``.""" + + model_config = ConfigDict(frozen=True) + value: float + + +class Unspecified(BaseModel): + """A cell the plan leaves to the database (e.g. a JSON number read as BOOLEAN).""" + + model_config = ConfigDict(frozen=True) + + +ANY = Unspecified() + + +class Case(BaseModel): + """One executed case: a row value per id, or the ids a filter keeps.""" + + model_config = ConfigDict(frozen=True, arbitrary_types_allowed=True) + case_id: str + covers: tuple[str, ...] + expr: str + values: Optional[dict[int, Any]] = None + keeps: Optional[frozenset[int]] = None + variables: Optional[dict[str, Any]] = None + + def query(self) -> SlayerQuery: + body: dict[str, Any] = {"source_model": "lib", "distinct_dimension_values": False} + if self.keeps is not None: + body |= {"dimensions": ["id"], "filters": [self.expr]} + else: + body |= {"dimensions": ["id", {"expression": self.expr, "name": "v"}]} + if self.variables: + body["variables"] = self.variables + return SlayerQuery.model_validate(body) + + +def every(fn: Callable[[dict[str, Any]], Any]) -> dict[int, Any]: + return {rid: fn(row) for rid, row in ROWS.items()} + + +def only(mapping: Mapping[int, Any], *, default: Any = None) -> dict[int, Any]: + return {rid: mapping.get(rid, default) for rid in IDS} + + +def keeps(pred: Callable[[dict[str, Any]], Optional[bool]]) -> frozenset[int]: + return frozenset(rid for rid, row in ROWS.items() if pred(row)) + + +def _v(case_id: str, covers: Iterable[str], expr: str, values: dict[int, Any], **kw: Any) -> Case: + return Case(case_id=case_id, covers=tuple(covers), expr=expr, values=values, **kw) + + +def _f(case_id: str, covers: Iterable[str], expr: str, kept: Iterable[int], **kw: Any) -> Case: + return Case(case_id=case_id, covers=tuple(covers), expr=expr, keeps=frozenset(kept), **kw) + + +def _ts(row: dict[str, Any]) -> Optional[datetime]: + return None if row["ts"] is None else datetime.fromisoformat(row["ts"]) + + +def _month(row: dict[str, Any]) -> Optional[date]: + t = _ts(row) + return None if t is None else date(t.year, t.month, 1) + + +def _string_cases() -> list[Case]: + s = lambda r: r["s"] # noqa: E731 + return [ + _v("left|column-count", ["left"], "left(s, n)", every(lambda r: pg_left(r["s"], r["n"]))), + _v("left|negative-literal", ["left"], "left(s, -2)", every(lambda r: pg_left(r["s"], -2))), + _v("right|column-count", ["right"], "right(s, n)", every(lambda r: pg_right(r["s"], r["n"]))), + _v("right|negative-literal", ["right"], "right(s, -1)", every(lambda r: pg_right(r["s"], -1))), + _v("starts_with", ["starts_with"], "starts_with(s, 'a/')", + every(lambda r: None if r["s"] is None else r["s"].startswith("a/"))), + _v("ends_with", ["ends_with"], "ends_with(s, 'c')", + every(lambda r: None if r["s"] is None else r["s"].endswith("c"))), + _f("contains|plain-text", ["contains"], "contains(tag, '5%')", [6]), + _v("strpos", ["strpos"], "strpos(s, p)", every(lambda r: pg_strpos(r["s"], r["p"]))), + _v("instr", ["instr"], "instr(s, p)", every(lambda r: pg_strpos(r["s"], r["p"]))), + _v("position", ["POSITION"], "POSITION(p IN s)", every(lambda r: pg_strpos(r["s"], r["p"]))), + _v("lpad|fill", ["lpad"], "lpad(s, 4, '*')", every(lambda r: pg_lpad(r["s"], 4, "*"))), + _v("lpad|default-fill", ["lpad"], "lpad(s, 6)", every(lambda r: pg_lpad(r["s"], 6))), + _v("lpad|multi-char-fill", ["lpad"], "lpad(s, 7, 'xy')", every(lambda r: pg_lpad(r["s"], 7, "xy"))), + _v("lpad|column-count", ["lpad"], "lpad(s, n, '0')", every(lambda r: pg_lpad(r["s"], r["n"], "0"))), + _v("rpad|fill", ["rpad"], "rpad(s, 4, '*')", every(lambda r: pg_rpad(r["s"], 4, "*"))), + _v("rpad|column-count", ["rpad"], "rpad(s, n, '-')", every(lambda r: pg_rpad(r["s"], r["n"], "-"))), + _v("reverse", ["reverse"], "reverse(s)", every(lambda r: None if r["s"] is None else r["s"][::-1])), + _v("repeat", ["repeat"], "repeat(s, n)", + every(lambda r: None if r["s"] is None or r["n"] is None else r["s"] * max(r["n"], 0))), + _v("split_part|second", ["split_part"], "split_part(s, '/', 2)", + every(lambda r: pg_split_part(r["s"], "/", 2))), + _v("split_part|last", ["split_part"], "split_part(s, '/', -1)", + every(lambda r: pg_split_part(r["s"], "/", -1))), + _v("split_part|beyond", ["split_part"], "split_part(s, '/', 9)", + every(lambda r: pg_split_part(r["s"], "/", 9))), + _v("split_part|beyond-negative", ["split_part"], "split_part(s, '/', -4)", + every(lambda r: pg_split_part(r["s"], "/", -4))), + _v("concat_ws|skips-nulls", ["concat_ws"], "concat_ws('-', word, p, code)", + every(lambda r: "-".join(v for v in (r["word"], r["p"], r["code"]) if v is not None))), + _v("chr", ["chr"], "chr(cp)", every(lambda r: pg_chr(r["cp"]))), + _v("ascii", ["ascii"], "ascii(s)", every(lambda r: pg_ascii(r["s"]))), + _v("length|characters", ["length"], "length(s)", every(lambda r: None if s(r) is None else len(s(r)))), + _v("substr", ["substr"], "substr(s, 2, 2)", every(lambda r: None if s(r) is None else s(r)[1:3])), + _v("substring", ["substring"], "substring(s, 2)", every(lambda r: None if s(r) is None else s(r)[1:])), + _v("replace", ["replace"], "replace(code, '_', '-')", + every(lambda r: None if r["code"] is None else r["code"].replace("_", "-"))), + _v("lower", ["lower"], "lower(word)", every(lambda r: None if r["word"] is None else r["word"].lower())), + _v("upper", ["upper"], "upper(word)", every(lambda r: None if r["word"] is None else r["word"].upper())), + _v("trim", ["trim", "||"], "trim(' ' || code || ' ')", + every(lambda r: None if r["code"] is None else r["code"].strip(" "))), + _v("ltrim", ["ltrim"], "ltrim(' ' || code)", every(lambda r: r["code"])), + _v("rtrim", ["rtrim"], "rtrim(code || ' ')", every(lambda r: r["code"])), + _v("concat", ["concat"], "concat(coalesce(word, '?'), '|')", every(lambda r: f"{r['word'] or '?'}|")), + _v("concat|number-to-text", ["||"], "qty || '#'", every(lambda r: None if r["qty"] is None else f"{r['qty']}#")), + ] + + +def _math_cases() -> list[Case]: + x = lambda r: r["x"] # noqa: E731 + + def on_x(fn: Callable[[float], float]) -> dict[int, Any]: + return every(lambda r: None if x(r) is None else fn(x(r))) + + return [ + _v("div|int", ["div"], "div(i, m)", every(lambda r: pg_div(r["i"], r["m"]))), + _v("div|double", ["div"], "div(i + 0.5, m)", + every(lambda r: None if r["i"] is None else pg_div(r["i"] + 0.5, r["m"]))), + _v("pi", ["pi"], "pi() + 0 * id", every(lambda r: math.pi)), + _v("sin", ["sin"], "sin(x)", on_x(math.sin)), + _v("cos", ["cos"], "cos(x)", on_x(math.cos)), + _v("tan", ["tan"], "tan(x)", on_x(math.tan)), + _v("asin|domain", ["asin"], "asin(x)", every(lambda r: in_unit(math.asin, r["x"]))), + _v("acos|domain", ["acos"], "acos(x)", every(lambda r: in_unit(math.acos, r["x"]))), + _v("atan", ["atan"], "atan(x)", on_x(math.atan)), + _v("atan2", ["atan2"], "atan2(y, x)", + every(lambda r: None if r["x"] is None or r["y"] is None else math.atan2(r["y"], r["x"]))), + _v("cbrt", ["cbrt"], "cbrt(x)", every(lambda r: cbrt(r["x"]))), + _v("greatest|nulls", ["greatest"], "greatest(a, b, c)", every(lambda r: pg_greatest(r["a"], r["b"], r["c"]))), + _v("least|nulls", ["least"], "least(a, b, c)", every(lambda r: pg_least(r["a"], r["b"], r["c"]))), + _v("greatest|two", ["greatest"], "greatest(a, b)", every(lambda r: pg_greatest(r["a"], r["b"]))), + _v("nullif", ["nullif"], "nullif(qty, 0)", every(lambda r: None if r["qty"] == 0 else r["qty"])), + _v("coalesce", ["coalesce"], "coalesce(p, 'zz')", every(lambda r: "zz" if r["p"] is None else r["p"])), + _v("ifnull", ["ifnull"], "ifnull(a, -100)", every(lambda r: -100 if r["a"] is None else r["a"])), + _v("ln", ["ln", "abs", "+"], "ln(abs(x) + 1)", on_x(lambda v: math.log(abs(v) + 1))), + _v("log10", ["log10"], "log10(abs(x) + 1)", on_x(lambda v: math.log10(abs(v) + 1))), + _v("log2", ["log2"], "log2(abs(x) + 1)", on_x(lambda v: math.log2(abs(v) + 1))), + _v("log|one-arg", ["log"], "log(abs(x) + 1)", on_x(lambda v: math.log10(abs(v) + 1))), + _v("log|base", ["log"], "log(2, abs(x) + 1)", on_x(lambda v: math.log2(abs(v) + 1))), + _v("exp", ["exp"], "exp(x)", on_x(math.exp)), + _v("sqrt", ["sqrt"], "sqrt(abs(x))", on_x(lambda v: math.sqrt(abs(v)))), + _v("pow", ["pow"], "pow(x, 2)", on_x(lambda v: v ** 2)), + _v("power", ["power"], "power(2, a)", every(lambda r: None if r["a"] is None else 2.0 ** r["a"])), + _v("floor", ["floor"], "floor(x)", on_x(math.floor)), + _v("ceil", ["ceil"], "ceil(x)", on_x(math.ceil)), + _v("ceiling", ["ceiling"], "ceiling(x)", on_x(math.ceil)), + _v("round", ["round"], "round(x + 0.1)", on_x(lambda v: float(round(Decimal(str(v + 0.1)))))), + _v("round|digits", ["round", "/"], "round(x / 3, 2)", + on_x(lambda v: float(Decimal(str(v / 3)).quantize(Decimal("0.01"))))), + _v("sign", ["sign"], "sign(x)", on_x(lambda v: (v > 0) - (v < 0))), + _v("trunc", ["trunc"], "trunc(x)", on_x(lambda v: float(math.trunc(v)))), + _v("mod|int", ["mod"], "mod(i, 3)", every(lambda r: None if r["i"] is None else int(math.fmod(r["i"], 3)))), + _v("mod|double", ["mod"], "mod(x, 0.75)", on_x(lambda v: math.fmod(v, 0.75))), + _v("percent|int", ["%"], "i % 3", every(lambda r: None if r["i"] is None else int(math.fmod(r["i"], 3)))), + _v("percent|double", ["%"], "x % 2", on_x(lambda v: math.fmod(v, 2))), + _v("arith|minus-times", ["-", "*"], "qty * 2 - 1", every(lambda r: None if r["qty"] is None else r["qty"] * 2 - 1)), + ] + + +def _on_ts(fn: Callable[[datetime], Any]) -> dict[int, Any]: + def at(row: dict[str, Any]) -> Any: + t = _ts(row) + return None if t is None else fn(t) + return every(at) + + +def _date_cases() -> list[Case]: + return [ + _v("date_trunc|month", ["date_trunc"], "date_trunc('month', ts)", every(_month)), + _v("date_part", ["date_part"], "date_part('month', ts)", _on_ts(lambda t: t.month)), + _v("date_diff", ["date_diff"], "date_diff('day', TIMESTAMP '2025-01-01 00:00:00', ts)", + _on_ts(lambda t: (t.date() - date(2025, 1, 1)).days)), + _v("date_add", ["date_add"], "date_add(ts, 2, 'day')", _on_ts(lambda t: t + timedelta(days=2))), + _v("interval", ["interval"], "ts + interval(1, 'hour')", _on_ts(lambda t: t + timedelta(hours=1))), + _f("current_date", ["current_date"], "date_diff('day', ts, current_date()) > 0", + [rid for rid, r in ROWS.items() if r["ts"] is not None]), + _f("now", ["now"], "ts < now()", [rid for rid, r in ROWS.items() if r["ts"] is not None]), + _v("iif", ["iif"], "iif(qty > 1, 'many', 'few')", + every(lambda r: "many" if r["qty"] is not None and r["qty"] > 1 else "few")), + ] + + +def _like_cases() -> list[Case]: + return [ + _f("like|escaped-underscore", ["LIKE", "like"], r"code LIKE 'a\_%'", [3]), + _f("like|underscore-wildcard", ["LIKE"], "code LIKE 'a__1'", [4, 8]), + _f("like|bracket-literal", ["LIKE"], "code LIKE '[ab]%'", [6]), + _f("like|lone-backslash", ["LIKE"], r"word LIKE 'c:\x%'", [10]), + _f("like|escaped-percent", ["LIKE"], r"tag LIKE '%5\%'", [6]), + _f("like|escaped-backslash", ["LIKE"], r"word LIKE 'c:\\x%'", [10]), + _f("like|column-pattern", ["LIKE", "||"], "code LIKE prefix || '%'", [1, 3, 4, 6, 7, 8, 10]), + _f("like|glob-metacharacters", ["LIKE"], "code LIKE 'a*?%'", [8]), + _f("like|percent-spans-newline", ["LIKE"], "notes LIKE 'paid%late'", [1, 4]), + _f("not-like", ["LIKE"], "code NOT LIKE 'a%'", [6, 10]), + _f("ilike|case-insensitive", ["ILIKE", "ilike"], "word ILIKE 'ADA%'", [3, 4]), + _f("ilike|escaped-underscore", ["ILIKE"], r"code ILIKE 'A\_%'", [3]), + ] + + +def _regex_cases() -> list[Case]: + return [ + _f("regexp_like|partial", ["regexp_like"], "regexp_like(code, '[0-9]{3}')", [1]), + _f("regexp_like|case-sensitive", ["regexp_like"], "regexp_like(word, '^paid$')", [1]), + _f("regexp_like|flag-i", ["regexp_like"], "regexp_like(word, '^paid$', 'i')", [1, 2]), + _f("op|tilde", ["~"], "word ~ '^ad'", [3, 8]), + _f("op|tilde-star", ["~*"], "word ~* '^ad'", [3, 4, 8, 9]), + _f("op|not-tilde", ["!~"], "word !~ '^ad'", [1, 2, 4, 6, 7, 9, 10]), + _f("op|not-tilde-star", ["!~*"], "word !~* '^ad'", [1, 2, 6, 7, 10]), + _f("regex|dot-newline", ["regexp_like"], "regexp_like(notes, 'paid.*late')", [1, 4]), + _f("regex|dollar-true-end", ["regexp_like"], "regexp_like(code, '^ab$|^a1$')", [7]), + _f("regex|dollar-isolated", ["regexp_like"], "regexp_like(code, '^ab$')", []), + _f("regex|dollar-before-newline-escape", ["regexp_like"], r"regexp_like(code, '^ab\n?$')", [9]), + _f("regex|caret-string-start", ["regexp_like"], "regexp_like(notes, '^late|^line')", [2, 8]), + _f("regex|flag-i-trailing-newline", ["regexp_like"], "regexp_like(code, '^AB$|^A1$', 'i')", [7]), + _f("regex|newline-escape", ["regexp_like"], r"regexp_like(code, '^ab\n$')", [9]), + _f("regex|ascii-digit", ["regexp_like"], r"regexp_like(word, '^\d+$')", [6]), + _f("regex|digit-in-brackets", ["regexp_like"], r"regexp_like(code, '^[\d_]+$')", [10]), + _f("regex|ascii-word", ["regexp_like"], r"regexp_like(s, '^\w+$')", [1, 8, 9]), + _f("regex|space-class", ["regexp_like"], r"regexp_like(notes, 'paid\slate')", [1, 4]), + _f("regex|escaped-metachar", ["regexp_like"], r"regexp_like(tag, '\(555\)')", [1]), + _f("regex|escaped-star", ["regexp_like"], r"regexp_like(code, 'a\*\?')", [8]), + _f("regex|escaped-bracket", ["regexp_like"], r"regexp_like(code, '\[ab\]')", [6]), + _f("regex|bounded-repeat", ["regexp_like"], "regexp_like(code, '^[a-z]{1,2}[0-9]{2,}$')", [1, 2]), + _f("regex|variable-pattern", ["regexp_like"], "regexp_like(s, {p})", [9], variables={"p": "^a.c$"}), + _v("regexp_extract|group", ["regexp_extract"], "regexp_extract(tag, '@(.+)$', 1)", only({3: "x.org"})), + _v("regexp_extract|whole", ["regexp_extract"], "regexp_extract(code, '[a-z]+')", + only({1: "ab", 2: "ab", 3: "a", 4: "abc", 6: "ab", 7: "a", 8: "a", 9: "ab"})), + _v("regexp_extract|non-participating-group", ["regexp_extract"], "regexp_extract(code, '(x)?b', 1)", + only({1: "", 2: "", 4: "", 6: "", 9: ""})), + _v("regexp_extract|negated-digit", ["regexp_extract"], r"regexp_extract(word, '\D+')", + only({1: "paid", 2: "PAID", 3: "ada", 4: "Ada", 7: "١٢٣", 8: "admin", 9: "Adele", 10: "c:\\x"})), + _v("regexp_extract|first-line", ["regexp_extract"], r"regexp_extract(notes, '^[^\n]*')", + only({1: "paid", 2: "line1", 3: "nothing", 4: "paid late", 6: "Paid Later", 7: "x", 8: "late paid", + 9: "a", 10: ""})), + _v("regexp_replace|every-match", ["regexp_replace"], "regexp_replace(tag, '[^0-9]', '')", + every(lambda r: None if r["tag"] is None else "".join(ch for ch in r["tag"] if ch in "0123456789"))), + _v("regexp_replace|groups", ["regexp_replace"], r"regexp_replace(s, '(\w+) (\w+)', '\2, \1')", + every(lambda r: "Lovelace, Ada" if r["s"] == "Ada Lovelace" else r["s"])), + _v("regexp_replace|literal-dollar-amp", ["regexp_replace"], "regexp_replace(tag, 'USD', '$ & co')", + every(lambda r: None if r["tag"] is None else r["tag"].replace("USD", "$ & co"))), + _v("regexp_replace|flag-i", ["regexp_replace"], "regexp_replace(word, 'a', 'X', 'i')", + every(lambda r: None if r["word"] is None else r["word"].replace("a", "X").replace("A", "X"))), + _v("regexp_replace|backslash", ["regexp_replace"], r"regexp_replace(word, ':', '\\')", + every(lambda r: None if r["word"] is None else r["word"].replace(":", "\\"))), + _v("regexp_replace|nine-groups", ["regexp_replace"], + r"regexp_replace(s, '^(A)(B)(C)(D)(E)(x)?(x)?(x)?(x)?$', '\9\8\7\6\5\4\3\2\1')", + every(lambda r: "EDCBA" if r["s"] == "ABCDE" else r["s"])), + _v("regexp_replace|empty-group", ["regexp_replace"], r"regexp_replace(code, '(x)?b', '[\1]')", + every(lambda r: None if r["code"] is None else r["code"].replace("b", "[]"))), + ] + + +def _json_cases() -> list[Case]: + ab = {1: "x", 9: NumText(value=1), 10: NumText(value=2.5)} + flags = {1: "true", 9: "false"} + return [ + _v("json_value|scalars-missing-nonscalars", ["json_value"], "json_value(payload, '$.a.b')", only(ab)), + _v("json_value|boolean-text", ["json_value"], "json_value(payload, '$.ok')", only(flags)), + _v("json_value|index-and-quoted-key", ["json_value"], "json_value(payload, '$.items[1].\"unit price\"')", + only({7: "9.5"})), + _v("json_value|returning-int", ["json_value", "RETURNING"], "json_value(payload, '$.qty' RETURNING INT)", + only({1: 2, 2: 3})), + _v("json_value|returning-int-zero", ["RETURNING"], "json_value(payload, '$.n' RETURNING INT)", + only({1: 0, 9: 12, 10: 7})), + _v("json_value|returning-boolean", ["RETURNING"], "json_value(payload, '$.f' RETURNING BOOLEAN)", + only({1: False, 9: True})), + _v("json_value|returning-double", ["RETURNING"], "json_value(payload, '$.a.b' RETURNING DOUBLE)", + only({9: 1.0, 10: 2.5})), + _v("json_value|returning-date", ["RETURNING"], "json_value(payload, '$.d' RETURNING DATE)", + only({10: date(2024, 2, 29)})), + _v("json_value|returning-timestamp", ["RETURNING"], "json_value(payload, '$.t' RETURNING TIMESTAMP)", + only({10: datetime(2024, 2, 29, 10, 0)})), + _v("json_value|returning-text", ["RETURNING"], "json_value(payload, '$.ok' RETURNING TEXT)", only(flags)), + _v("json_value|boolean-to-int-is-null", ["RETURNING"], "json_value(payload, '$.ok' RETURNING INT)", only({})), + _v("json_value|object-to-int-is-null", ["RETURNING"], "json_value(payload, '$.a' RETURNING INT)", only({})), + _v("arrow|postgres-chain", ["->", "->>"], "payload -> 'a' -> 0 ->> 'b'", only({7: "x"})), + _v("arrow|mysql-path", ["->>"], "payload ->> '$.a.b'", only(ab)), + _v("arrow|key", ["->>"], "payload ->> 'ok'", only(flags)), + _v("arrow|precedence", ["->>", "||"], "payload ->> 'ok' || '!'", only({1: "true!", 9: "false!"})), + _v("json_extract|object-is-null", ["json_extract"], "json_extract(payload, '$.a')", only({})), + _v("json_extract|scalar", ["json_extract"], "json_extract(payload, '$.ok')", only(flags)), + _v("json_extract_scalar", ["json_extract_scalar"], "json_extract_scalar(payload, '$.a.b')", only(ab)), + _v("json_extract_path_text", ["json_extract_path_text"], "json_extract_path_text(payload, 'a', 'b')", only(ab)), + _v("jsonb_extract_path_text", ["jsonb_extract_path_text"], "jsonb_extract_path_text(payload, 'a', 'b')", + only(ab)), + ] + + +def _txt_keeps(pred: Callable[[float, dict[str, Any]], bool]) -> frozenset[int]: + """Ids whose ``num_txt`` reads as a number satisfying ``pred``.""" + def at(row: dict[str, Any]) -> bool: + v = num_text(row["num_txt"]) + return v is not None and pred(v, row) + return keeps(at) + + +def _on_txt(fn: Callable[[float, dict[str, Any]], Any]) -> dict[int, Any]: + def at(row: dict[str, Any]) -> Any: + v = num_text(row["num_txt"]) + return None if v is None else fn(v, row) + return every(at) + + +#: ``json_value(doc, '$.v' RETURNING )`` per row: null, missing, object, array, "x", 0, false, +#: a date string, a timestamp string, 12. +RETURNING_GRID: dict[str, dict[int, Any]] = { + "INT": {6: 0, 10: 12}, + "DOUBLE": {6: 0.0, 10: 12.0}, + "BOOLEAN": {6: ANY, 7: False, 10: ANY}, + "TEXT": {5: "x", 6: NumText(value=0), 7: "false", 8: "2024-02-29", 9: "2024-02-29 10:00:00", + 10: NumText(value=12)}, + "DATE": {8: date(2024, 2, 29), 9: ANY}, + "TIMESTAMP": {8: ANY, 9: datetime(2024, 2, 29, 10, 0)}, +} + + +def _returning_cases() -> list[Case]: + return [_v(f"json_value|returning-grid-{target.lower()}", ["RETURNING"], + f"json_value(doc, '$.v' RETURNING {target})", only(expected)) + for target, expected in RETURNING_GRID.items()] + + +def _coercion_cases() -> list[Case]: + return [ + _f("coerce|gt-literal", [">"], "num_txt > 100", _txt_keeps(lambda v, r: v > 100)), + _f("coerce|eq-column", ["="], "num_txt = qty", _txt_keeps(lambda v, r: r["qty"] is not None and v == r["qty"])), + _f("coerce|lt-numeric-not-lexicographic", ["<"], "num_txt < 9", _txt_keeps(lambda v, r: v < 9)), + _f("coerce|le", ["<="], "num_txt <= 10", _txt_keeps(lambda v, r: v <= 10)), + _f("coerce|ge", [">="], "num_txt >= 99", _txt_keeps(lambda v, r: v >= 99)), + _f("coerce|ne", ["<>"], "num_txt <> 1", _txt_keeps(lambda v, r: v != 1)), + _f("coerce|in", ["IN"], "num_txt IN (1, 2)", _txt_keeps(lambda v, r: v in (1.0, 2.0))), + _f("coerce|between", ["BETWEEN"], "num_txt BETWEEN 1 AND 10", _txt_keeps(lambda v, r: 1 <= v <= 10)), + _f("coerce|is-distinct-from", ["IS DISTINCT FROM"], "num_txt IS DISTINCT FROM 99", + keeps(lambda r: num_text(r["num_txt"]) != 99)), + _f("coerce|literal-text", [">"], "qty > '1'", keeps(lambda r: r["qty"] is not None and r["qty"] > 1)), + _v("coerce|times", ["*"], "num_txt * 2", _on_txt(lambda v, r: v * 2)), + _v("coerce|plus-column", ["+"], "num_txt + qty", _on_txt(lambda v, r: None if r["qty"] is None else v + r["qty"])), + _v("coerce|minus", ["-"], "num_txt - 1", _on_txt(lambda v, r: v - 1)), + _v("coerce|divide", ["/"], "num_txt / 2", _on_txt(lambda v, r: v / 2)), + _v("coerce|modulo", ["%"], "num_txt % 7", _on_txt(lambda v, r: math.fmod(v, 7))), + _f("coerce|exact-bigint", ["="], "TRY_CAST(big AS BIGINT) = 12345678901234567", [1]), + _f("coerce|exact-bigint-off-by-one", ["="], "TRY_CAST(big AS BIGINT) = 12345678901234568", []), + _v("coerce|boolean-stays-numeric", ["*"], "(qty > 1) * 2", + every(lambda r: None if r["qty"] is None else 2 * int(r["qty"] > 1))), + _v("coerce|greatest", ["greatest"], "greatest(num_txt, 5)", + every(lambda r: pg_greatest(num_text(r["num_txt"]), 5))), + _v("coerce|least", ["least"], "least(num_txt, 5)", every(lambda r: pg_least(num_text(r["num_txt"]), 5))), + ] + + +def library_cases() -> list[Case]: + return [*_string_cases(), *_math_cases(), *_date_cases(), *_like_cases(), *_regex_cases(), + *_json_cases(), *_returning_cases(), *_coercion_cases()] + + +def required_names() -> frozenset[str]: + return frozenset(SCALAR_SPECS) | NEW_FUNCTIONS | SPELLINGS | OPERATORS + + +# --------------------------------------------------------------------------- # +# Assertions +# --------------------------------------------------------------------------- # +def assert_cell(actual: Any, expected: Any, *, where: str) -> None: + if isinstance(expected, Unspecified): + return + if expected is None: + assert actual is None, f"{where}: expected NULL, got {actual!r}" + return + assert actual is not None, f"{where}: expected {expected!r}, got NULL" + if isinstance(expected, NumText): + assert isinstance(actual, str), f"{where}: expected TEXT, got {actual!r}" + assert float(actual) == expected.value, f"{where}: expected {expected.value}, got {actual!r}" + elif isinstance(expected, bool): + assert actual in (True, False, 0, 1), f"{where}: expected a boolean, got {actual!r}" + assert bool(actual) is expected, f"{where}: expected {expected}, got {actual!r}" + elif isinstance(expected, (date, datetime)): + got = as_temporal(actual) + got_day = got.date() if isinstance(got, datetime) and not isinstance(expected, datetime) else got + assert got_day == expected, f"{where}: expected {expected}, got {actual!r}" + elif isinstance(expected, str): + assert actual == expected, f"{where}: expected {expected!r}, got {actual!r}" + elif isinstance(expected, int): + assert not isinstance(actual, (str, bool)), f"{where}: expected a number, got {actual!r}" + assert Decimal(str(actual)) == Decimal(expected), f"{where}: expected {expected}, got {actual!r}" + else: + assert not isinstance(actual, (str, bool)), f"{where}: expected a number, got {actual!r}" + assert math.isclose(float(actual), float(expected), rel_tol=1e-9, abs_tol=1e-12), ( + f"{where}: expected {expected}, got {actual!r}") + + +def assert_case(data: list[dict[str, Any]], case: Case) -> None: + if case.keeps is not None: + got = {int(r["lib.id"]) for r in data} + assert got == set(case.keeps), f"{case.case_id}: kept {sorted(got)}, expected {sorted(case.keeps)}" + return + assert case.values is not None + got = {int(r["lib.id"]): r["lib.v"] for r in data} + assert set(got) == set(IDS), f"{case.case_id}: row ids {sorted(got)}" + for rid in IDS: + assert_cell(got[rid], case.values[rid], where=f"{case.case_id} id={rid}") + + +def lib_query(*dims: Any, **kw: Any) -> SlayerQuery: + """A row-level ``lib`` query: ``id`` plus ``dims`` (an expression string becomes the ``v`` dimension).""" + dimensions: list[Any] = ["id"] + [{"expression": d, "name": "v"} if isinstance(d, str) else d for d in dims] + return SlayerQuery.model_validate({"source_model": "lib", "distinct_dimension_values": False, + "dimensions": dimensions, **kw}) + + +async def emit_lib(query: SlayerQuery, *, dialect: str, models: Optional[list[SlayerModel]] = None) -> str: + """Dry-run SQL for a ``lib`` query on ``dialect`` (asserts it parses there).""" + return await emit(query, dialect=dialect, models=models or [lib_model()]) + + +def lib_values(resp: SlayerResponse, name: str = "v") -> dict[int, Any]: + return {int(r["lib.id"]): r[f"lib.{name}"] for r in resp.data} + + +def lib_ids(resp: SlayerResponse) -> set[int]: + return {int(r["lib.id"]) for r in resp.data} + + +def patch_profile(monkeypatch: Any, *, version: Optional[tuple[int, int]] = None, fail: bool = False) -> list[int]: + """Stub the server-profile probe; the returned list records each probe.""" + calls: list[int] = [] + + async def fake(_self: Any) -> ServerProfile: + calls.append(1) + if fail: + raise ConnectionError("probe failed") + return ServerProfile(version=version) + + monkeypatch.setattr(SlayerSQLClient, "server_profile", fake) + return calls + + +async def run_case(engine: SlayerQueryEngine, case: Case) -> None: + resp = await engine.execute(case.query()) + try: + assert_case(resp.data, case) + except AssertionError as exc: + raise AssertionError(f"{exc}\nSQL:\n{resp.sql}") from None + + +# --------------------------------------------------------------------------- # +# Seeding +# --------------------------------------------------------------------------- # +@contextlib.asynccontextmanager +async def lib_engine(backend: str, *, models: Optional[list[SlayerModel]] = None) -> AsyncGenerator[SlayerQueryEngine]: + async with seeded_exec_engine( + dialect=backend, seed=lambda p: seed_backend(backend, p, [LIB]), models=models or [lib_model()], + ) as (engine, _db): + yield engine + + +SERVER_LIB_TYPES: dict[str, dict[str, str]] = { + **SERVER_TYPES, + "postgres": {**SERVER_TYPES["postgres"], "TIMESTAMP": "TIMESTAMP"}, + "mysql": {**SERVER_TYPES["mysql"], "TIMESTAMP": "DATETIME"}, + "snowflake": {"INT": "NUMBER(38,0)", "DOUBLE": "FLOAT", "TEXT": "TEXT", "TIMESTAMP": "TIMESTAMP_NTZ"}, + "bigquery": {"INT": "INT64", "DOUBLE": "FLOAT64", "TEXT": "STRING", "TIMESTAMP": "DATETIME"}, +} +_TEMPORAL_PREFIX = {"trino": "TIMESTAMP", "bigquery": "DATETIME"} +_SUFFIX = {"clickhouse": " ENGINE = MergeTree ORDER BY tuple()"} + + +def server_literal(value: Any, *, kind: str, dialect: str) -> str: + """``value`` as a SQL literal on ``dialect`` (backslash-escaping engines and N'' strings handled).""" + if value is None: + return "NULL" + if isinstance(value, (int, float)): + return repr(value) + text = str(value) + if dialect in ("mysql", "clickhouse", "snowflake", "bigquery"): + text = text.replace("\\", "\\\\") + if dialect == "bigquery": + text = text.replace("'", "\\'").replace("\n", "\\n") + else: + text = text.replace("'", "''") + if kind == "TIMESTAMP" and dialect in _TEMPORAL_PREFIX: + return f"{_TEMPORAL_PREFIX[dialect]} '{text}'" + return f"N'{text}'" if dialect == "tsql" else f"'{text}'" + + +def server_table_statements(table: TableSpec, *, dialect: str, prefix: str = "") -> list[str]: + """CREATE + one multi-row INSERT for ``table`` on a server ``dialect`` (``prefix`` qualifies the name).""" + types = SERVER_LIB_TYPES[dialect] + cols = ", ".join(f"{c} {types[k]}" for c, k in table.columns) + kinds = [k for _, k in table.columns] + rows = ", ".join( + "(" + ", ".join(server_literal(v, kind=k, dialect=dialect) for v, k in zip(row, kinds)) + ")" + for row in table.rows + ) + name = f"{prefix}{table.name}" + return [f"CREATE TABLE {name} ({cols}){_SUFFIX.get(dialect, '')}", f"INSERT INTO {name} VALUES {rows}"] + + +# --------------------------------------------------------------------------- # +# Native JSON columns (ingested, then read with json_value) +# --------------------------------------------------------------------------- # +DOCS_ROWS: list[tuple[int, Optional[str]]] = [ + (1, '{"a": 1, "s": "x"}'), (2, '{"a": "2", "s": null}'), (3, '{"a": "x", "s": {"t": 1}}'), + (4, "{}"), (5, None), +] +DOCS_S = {1: "x", 2: None, 3: None, 4: None, 5: None} +DOCS_A_INT = {1: 1, 2: 2, 3: None, 4: None, 5: None} + + +async def check_native_json(engine: SlayerQueryEngine, *, model: str = "docs", column: str = "payload") -> None: + """``json_value`` over an ingested native-JSON column: TEXT and ``RETURNING INT`` reads.""" + for expr, expected in ( + (f"json_value({column}, '$.s')", DOCS_S), + (f"json_value({column}, '$.a' RETURNING INT)", DOCS_A_INT), + (f"{column} ->> 's'", DOCS_S), + ): + resp = await engine.execute(SlayerQuery.model_validate({ + "source_model": model, "distinct_dimension_values": False, + "dimensions": ["id", {"expression": expr, "name": "v"}], + })) + got = {int(r[f"{model}.id"]): r[f"{model}.v"] for r in resp.data} + assert set(got) == set(expected), (expr, resp.sql) + for rid, value in expected.items(): + assert_cell(got[rid], value, where=f"{expr} id={rid}") + + +REGEX_NAMES = frozenset({"regexp_like", "regexp_extract", "regexp_replace", "~", "~*", "!~", "!~*"}) + + +async def check_library(engine: SlayerQueryEngine, *, gated: frozenset[str] = frozenset(), + refusal: str = "") -> None: + """Every case on a live engine; a case covering a ``gated`` name must be refused naming ``refusal``. + + Failures are collected so one run reports them all. + """ + failures: list[str] = [] + for case in library_cases(): + try: + if gated & set(case.covers): + problem = await _refusal_problem(engine, case, refusal=refusal) + else: + await run_case(engine, case) + problem = None + except Exception as exc: # noqa: BLE001 — report every failing case, not the first + problem = f"{type(exc).__name__}: {exc}" + if problem: + failures.append(f"{case.case_id}: {problem}") + assert not failures, "\n\n".join(failures) + + +async def _refusal_problem(engine: SlayerQueryEngine, case: Case, *, refusal: str) -> str | None: + try: + await engine.execute(case.query()) + except SlayerError as exc: + return None if refusal in str(exc) else f"refusal without {refusal!r}: {exc}" + return f"expected a plan-time refusal naming {refusal}" diff --git a/tests/dialects/test_bigquery.py b/tests/dialects/test_bigquery.py index 1772dc35b..5130c1a15 100644 --- a/tests/dialects/test_bigquery.py +++ b/tests/dialects/test_bigquery.py @@ -73,7 +73,7 @@ def test_explain_prefix_is_none() -> None: def test_log_native_flags() -> None: d = BigqueryDialect() assert d.should_use_native_log(10) is True - assert d.should_use_native_log(2) is True + assert d.should_use_native_log(2) is False def test_build_explain_sql_raises() -> None: diff --git a/tests/dialects/test_date_functions.py b/tests/dialects/test_date_functions.py index 370641959..57239e623 100644 --- a/tests/dialects/test_date_functions.py +++ b/tests/dialects/test_date_functions.py @@ -148,10 +148,10 @@ def test_bigquery_date_add_on_date_stays_date(self, unit: TimeGranularity) -> No @pytest.mark.parametrize("unit", SUB_DAY) @pytest.mark.parametrize("operand", OPERANDS) - def test_bigquery_sub_day_add_is_timestamp(self, unit: TimeGranularity, operand: DataType) -> None: + def test_bigquery_sub_day_add_is_datetime(self, unit: TimeGranularity, operand: DataType) -> None: sql = _sql(get_dialect("bigquery").build_date_add( expr=_col(), count=exp.Literal.number(1), unit=unit, operand=operand), "bigquery") - assert "TIMESTAMP" in sql, sql + assert "DATETIME_ADD(" in sql, sql assert not re.search(r"\bDATE_(ADD|SUB)\(", sql), sql @pytest.mark.parametrize("unit", list(TimeGranularity)) @@ -172,10 +172,10 @@ def test_bigquery_date_diff_on_date_uses_date_functions(self, unit: TimeGranular assert "TIMESTAMP" not in sql, sql @pytest.mark.parametrize("unit", SUB_DAY) - def test_bigquery_sub_day_diff_uses_timestamp_functions(self, unit: TimeGranularity) -> None: + def test_bigquery_sub_day_diff_uses_datetime_functions(self, unit: TimeGranularity) -> None: sql = _sql(get_dialect("bigquery").build_date_diff( unit=unit, start=_col("s"), end=_col("e"), operand=DataType.TIMESTAMP), "bigquery") - assert "TIMESTAMP_" in sql, sql + assert "DATETIME_DIFF(" in sql, sql assert "DATE_DIFF(" not in sql, sql @pytest.mark.parametrize("dialect", ["postgres", "duckdb"]) diff --git a/tests/dialects/test_dev1753_scalar_emission.py b/tests/dialects/test_dev1753_scalar_emission.py index bd50926c2..b2d7c7e42 100644 --- a/tests/dialects/test_dev1753_scalar_emission.py +++ b/tests/dialects/test_dev1753_scalar_emission.py @@ -20,11 +20,13 @@ def _same(sql: str) -> dict[str, str]: EXPECTED: dict[tuple[str, int], dict[str, str]] = { ("ceiling", 1): {**_same("CEIL(a)"), "tsql": "CEILING(a)"}, ("sign", 1): _same("SIGN(a)"), - ("ltrim", 1): _same("LTRIM(a)"), - ("rtrim", 1): _same("RTRIM(a)"), + ("ltrim", 1): {**_same("LTRIM(a)"), "bigquery": "LTRIM(a, ' ')"}, + ("rtrim", 1): {**_same("RTRIM(a)"), "bigquery": "RTRIM(a, ' ')"}, # T-SQL SUBSTRING requires a length; DATALENGTH(a) reaches the end, trailing spaces included. - ("substring", 2): {**_same("SUBSTRING(a, b)"), "postgres": "SUBSTRING(a FROM b)", "tsql": "SUBSTRING(a, b, DATALENGTH(a))"}, - ("substring", 3): {**_same("SUBSTRING(a, b, c)"), "postgres": "SUBSTRING(a FROM b FOR c)"}, + ("substring", 2): {**_same("SUBSTRING(a, b)"), "postgres": "SUBSTRING(a FROM b)", "tsql": "SUBSTRING(a, b, DATALENGTH(a))", + "clickhouse": "substringUTF8(a, b)"}, + ("substring", 3): {**_same("SUBSTRING(a, b, c)"), "postgres": "SUBSTRING(a FROM b FOR c)", + "clickhouse": "substringUTF8(a, b, c)"}, } CASES = [(name, argc, d) for (name, argc) in EXPECTED for d in TIER1] diff --git a/tests/dialects/test_multi_dialect_generation.py b/tests/dialects/test_multi_dialect_generation.py index 341f067b0..7057635ee 100644 --- a/tests/dialects/test_multi_dialect_generation.py +++ b/tests/dialects/test_multi_dialect_generation.py @@ -1,6 +1,6 @@ """Multi-dialect SQL generation end-to-end tests. -DEV-1542 cleanup: lifted from ``tests/test_sql_generator.py``. Each test +Lifted from ``tests/test_sql_generator.py``. Each test class drives ``SQLGenerator`` across multiple dialects and asserts on the final emitted SQL — orthogonal to the per-dialect strategy-class tests in ``tests/dialects/test_.py`` which pin emission from the @@ -22,7 +22,7 @@ class drives ``SQLGenerator`` across multiple dialects and asserts on the from tests.dialects.conftest import _generate, _norm -# DEV-1337: per-alias allowlists for "natively supports single-arg log10/log2" +# Per-alias allowlists for "natively supports single-arg log10/log2" # rendering. Outside these sets the current 2-arg LOG(base, x) form is kept. # Explicit hand-written sets — these are the spec; deriving from the dialect # flags would make the log-alias tests self-fulfilling. @@ -32,8 +32,8 @@ class drives ``SQLGenerator`` across multiple dialects and asserts on the "trino", "presto", "databricks", "spark", "tsql", }) _LOG2_NATIVE_DIALECTS = frozenset({ - "sqlite", "postgres", "duckdb", "mysql", "clickhouse", - "bigquery", "trino", "presto", "databricks", "spark", + "sqlite", "duckdb", "mysql", "clickhouse", + "trino", "presto", "databricks", "spark", }) @@ -107,7 +107,7 @@ async def test_date_trunc(self, dialect: str, orders_model: SlayerModel) -> None # Oracle is excluded: its native TRUNC(x,'WEEK') is Jan-1-anchored, so # neither WEEK nor WEEK_SUNDAY is truly Monday/Sunday there — Oracle - # Sunday-week correctness is explicitly out of scope (DEV-1572). The exact + # Sunday-week correctness is explicitly out of scope. The exact # per-dialect Sunday shape is pinned in tests/dialects/test_.py; # SQLite runtime bucketing is pinned by execution there. This is an # emission-only smoke test guarding against a silent fallback to Monday @@ -118,7 +118,7 @@ async def test_date_trunc(self, dialect: str, orders_model: SlayerModel) -> None async def test_date_trunc_week_sunday_differs_from_week( self, dialect: str, orders_model: SlayerModel ) -> None: - """DEV-1572 emission smoke test: a WEEK_SUNDAY breakout must emit + """Emission smoke test: a WEEK_SUNDAY breakout must emit different SQL from a plain (Monday) WEEK breakout — a dialect-agnostic guard that WEEK_SUNDAY is genuinely shifted/overridden and never silently falls back to Monday-week bucketing. Exact Sunday-shape and @@ -356,7 +356,7 @@ async def test_window_measure_tsql_multi_unit_uses_chained_dateadd( assert "INTERVAL" not in norm, f"INTERVAL is invalid T-SQL syntax:\n{sql}" assert "DATEADD" in norm, f"Expected DATEADD in multi-unit T-SQL window:\n{sql}" - # DEV-1317: cross-dialect stat-agg generation. The exact SQL shape per + # Cross-dialect stat-agg generation. The exact SQL shape per # Tier-1 dialect is pinned in TestStatAggsPerDialect; here we just confirm # the generator produces parseable SQL on every supported dialect. # Assertions check the function-call SHAPE (qualified column refs in the @@ -481,7 +481,7 @@ async def test_two_arg_stat_agg_mysql_emits_formula_valid_sql( class TestLogAliasPreservation: - """DEV-1337 — user-written ``log10(x)`` / ``log2(x)`` must round-trip + """User-written ``log10(x)`` / ``log2(x)`` must round-trip verbatim in emitted SQL on dialects that natively support those single-arg aliases. sqlglot's default behaviour normalises both into a generic ``Log(this=Literal(base), expression=arg)`` AST node and re-emits as @@ -572,8 +572,10 @@ async def test_log2_in_column_sql_is_preserved( f"{dialect}: should not canonicalise to LOG(amount, 2):\n{sql}" ) else: - # Fallback for tsql / oracle / redshift / snowflake (no native LOG2). - assert "LOG(2,ORDERS.AMOUNT)" in upper_no_ws or "LOG(ORDERS.AMOUNT,2)" in upper_no_ws, ( + # Fallback for postgres / tsql / oracle / redshift / snowflake (no native LOG2); Postgres's + # LOG(b, x) takes NUMERIC only. + assert ("LOG(2,ORDERS.AMOUNT)" in upper_no_ws or "LOG(ORDERS.AMOUNT,2)" in upper_no_ws + or "LOG(2,CAST(ORDERS.AMOUNTASDECIMAL))" in upper_no_ws), ( f"{dialect}: expected fallback LOG(base,x) form, got:\n{sql}" ) @@ -657,7 +659,8 @@ async def test_log_with_non_alias_base_unchanged( f"{dialect}: must not invent LOG3() — only base 10 and 2 are aliased:\n{sql}" ) # The 2-arg form must remain in some arg order. - assert "LOG(3,ORDERS.AMOUNT)" in upper_no_ws or "LOG(ORDERS.AMOUNT,3)" in upper_no_ws, ( + assert ("LOG(3,ORDERS.AMOUNT)" in upper_no_ws or "LOG(ORDERS.AMOUNT,3)" in upper_no_ws + or "LOG(3,CAST(ORDERS.AMOUNTASDECIMAL))" in upper_no_ws), ( f"{dialect}: expected 2-arg LOG(3, amount) preserved, got:\n{sql}" ) @@ -681,7 +684,7 @@ async def test_ln_unchanged( class TestStringHygieneDialectTranslation: - """DEV-1378: lowercase string-hygiene operators are pass-through to + """Lowercase string-hygiene operators are pass-through to the emitted SQL string, then re-parsed by sqlglot under the target dialect at WHERE-assembly. sqlglot's per-dialect emitter chooses each dialect's preferred spelling. These tests pin the actual @@ -696,7 +699,7 @@ class TestStringHygieneDialectTranslation: ("postgres", "LOWER(orders.status) = 'active'"), ("mysql", "LOWER(orders.status) = 'active'"), ("duckdb", "LOWER(orders.status) = 'active'"), - ("clickhouse", "LOWER(orders.status) = 'active'"), + ("clickhouse", "lowerUTF8(orders.status) = 'active'"), ], ) async def test_lower(self, orders_model: SlayerModel, dialect: str, expected: str) -> None: @@ -717,9 +720,10 @@ async def test_lower(self, orders_model: SlayerModel, dialect: str, expected: st [ ("sqlite", "INSTR(orders.status, ',')"), ("postgres", "POSITION(',' IN orders.status)"), - ("mysql", "LOCATE(',', orders.status)"), + ("mysql", "LOCATE(\n CAST(',' AS CHAR CHARACTER SET utf8mb4) COLLATE utf8mb4_bin,\n" + " CAST(orders.status AS CHAR CHARACTER SET utf8mb4) COLLATE utf8mb4_bin\n )"), ("duckdb", "STRPOS(orders.status, ',')"), - ("clickhouse", "POSITION(orders.status, ',')"), + ("clickhouse", "positionUTF8(orders.status, ',')"), ], ) async def test_instr_translates_per_dialect( @@ -744,7 +748,7 @@ async def test_instr_translates_per_dialect( ("postgres", "SUBSTRING(orders.status FROM 1 FOR 5)"), ("mysql", "SUBSTRING(orders.status, 1, 5)"), ("duckdb", "SUBSTRING(orders.status, 1, 5)"), - ("clickhouse", "SUBSTRING(orders.status, 1, 5)"), + ("clickhouse", "substringUTF8(orders.status, 1, 5)"), ], ) async def test_substr_translates_per_dialect( diff --git a/tests/dialects/test_postgres.py b/tests/dialects/test_postgres.py index 393bdaf5a..5badec051 100644 --- a/tests/dialects/test_postgres.py +++ b/tests/dialects/test_postgres.py @@ -21,7 +21,7 @@ def test_postgres_explain_prefix() -> None: def test_postgres_log_native_flags() -> None: d = PostgresDialect() assert d.should_use_native_log(10) is True - assert d.should_use_native_log(2) is True + assert d.should_use_native_log(2) is False # Postgres has no log2 # build_date_trunc — native DATE_TRUNC diff --git a/tests/dialects/test_sqlite_udfs.py b/tests/dialects/test_sqlite_udfs.py index f01f580f9..09a1eee7e 100644 --- a/tests/dialects/test_sqlite_udfs.py +++ b/tests/dialects/test_sqlite_udfs.py @@ -420,7 +420,7 @@ def test_log_udf_registered_unconditionally(): registered: list[tuple[str, int]] = [] class _SpyConn: - def create_function(self, name, narg, fn): # noqa: ARG002 + def create_function(self, name, narg, fn, **_kw): # noqa: ARG002 registered.append((name, narg)) def create_aggregate(self, name, narg, cls): # noqa: ARG002 diff --git a/tests/golden/consecutive_periods_calendar_sql_baseline.json b/tests/golden/consecutive_periods_calendar_sql_baseline.json index 44ead38b6..0012e7315 100644 --- a/tests/golden/consecutive_periods_calendar_sql_baseline.json +++ b/tests/golden/consecutive_periods_calendar_sql_baseline.json @@ -1,50 +1,50 @@ { - "cp/date_range::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n (\n orders.order_date >= '2025-02-01 00:00:00'\n AND orders.order_date < '2025-07-01 00:00:00'\n )\n AND orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, MONTH)\n), cp_prev_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n LAG(`orders___order_date`) OVER (ORDER BY `orders___order_date`) AS `_cp_prev_orders___v`\n FROM base\n), cp_reset_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n SUM(\n CASE\n WHEN `orders___amount_sum` > 100\n AND CAST(`_cp_prev_orders___v` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`orders___order_date` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___order_date` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___v`\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n CASE\n WHEN `orders___amount_sum` > 100\n THEN SUM(CASE WHEN `orders___amount_sum` > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___v`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___v`\n FROM cp_reset_v\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders___v`\n FROM cp_value_v\n) AS _outer", + "cp/date_range::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n (\n orders.order_date >= '2025-02-01 00:00:00'\n AND orders.order_date < '2025-07-01 00:00:00'\n )\n AND orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, MONTH)\n), cp_prev_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n LAG(`orders___order_date`) OVER (ORDER BY `orders___order_date`) AS `_cp_prev_orders___v`\n FROM base\n), cp_reset_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n SUM(\n CASE\n WHEN `orders___amount_sum` > 100\n AND CAST(`_cp_prev_orders___v` AS DATETIME) = DATETIME_ADD(CAST(`orders___order_date` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___order_date` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___v`\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n CASE\n WHEN `orders___amount_sum` > 100\n THEN SUM(CASE WHEN `orders___amount_sum` > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___v`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___v`\n FROM cp_reset_v\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders___v`\n FROM cp_value_v\n) AS _outer", "cp/date_range::duckdb": "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 WHERE\n (\n orders.order_date >= CAST('2025-02-01 00:00:00' AS TIMESTAMP)\n AND orders.order_date < CAST('2025-07-01 00:00:00' AS TIMESTAMP)\n )\n AND orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = \"orders.order_date\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/date_range::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 WHERE\n (\n orders.order_date >= CAST('2025-02-01 00:00:00' AS TIMESTAMP)\n AND orders.order_date < CAST('2025-07-01 00:00:00' AS TIMESTAMP)\n )\n AND orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = \"orders.order_date\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/date_range::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n (\n orders.order_date >= '2025-02-01' AND orders.order_date < '2025-07-01'\n )\n AND orders.customer_id = 1\n GROUP BY\n STRFTIME('%Y-%m-01', orders.order_date)\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = SLAYER_DATE_ADD(\"orders.order_date\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/date_range::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 WHERE\n (\n orders.order_date >= CAST('2025-02-01 00:00:00' AS DATETIME2)\n AND orders.order_date < CAST('2025-07-01 00:00:00' AS DATETIME2)\n )\n AND orders.customer_id = 1\n GROUP BY\n DATETRUNC(month, orders.order_date)\n), cp_prev_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n LAG([orders___order_date]) OVER (ORDER BY [orders___order_date]) AS [_cp_prev_orders___v]\n FROM base\n), cp_reset_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n SUM(\n CASE\n WHEN [orders___amount_sum] > 100\n AND [_cp_prev_orders___v] = DATEADD(MONTH, -1, [orders___order_date])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [orders___order_date] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_orders___v]\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n CASE\n WHEN [orders___amount_sum] > 100\n THEN SUM(CASE WHEN [orders___amount_sum] > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY [_cp_reset_orders___v]\n ORDER BY [orders___order_date]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [orders___v]\n FROM cp_reset_v\n)\nSELECT\n [orders___order_date],\n [orders___v]\nFROM (\n SELECT\n [orders___order_date],\n [orders___amount_sum],\n [orders___v]\n FROM cp_value_v\n) AS _outer", - "cp/grouped::bigquery": "WITH base AS (\n SELECT\n orders.customer_id AS `orders___customer_id`,\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n GROUP BY\n orders.customer_id,\n DATE_TRUNC(orders.order_date, MONTH)\n), cp_prev_v AS (\n SELECT\n `orders___customer_id`,\n `orders___order_date`,\n `orders___amount_sum`,\n LAG(`orders___order_date`) OVER (PARTITION BY `orders___customer_id` ORDER BY `orders___order_date`) AS `_cp_prev_orders___v`\n FROM base\n), cp_reset_v AS (\n SELECT\n `orders___customer_id`,\n `orders___order_date`,\n `orders___amount_sum`,\n SUM(\n CASE\n WHEN `orders___amount_sum` > 100\n AND CAST(`_cp_prev_orders___v` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`orders___order_date` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY `orders___customer_id`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS `_cp_reset_orders___v`\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n `orders___customer_id`,\n `orders___order_date`,\n `orders___amount_sum`,\n CASE\n WHEN `orders___amount_sum` > 100\n THEN SUM(CASE WHEN `orders___amount_sum` > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `orders___customer_id`, `_cp_reset_orders___v`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___v`\n FROM cp_reset_v\n)\nSELECT\n `orders___customer_id`,\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___customer_id`,\n `orders___order_date`,\n `orders___amount_sum`,\n `orders___v`\n FROM cp_value_v\n) AS _outer", + "cp/grouped::bigquery": "WITH base AS (\n SELECT\n orders.customer_id AS `orders___customer_id`,\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n GROUP BY\n orders.customer_id,\n DATE_TRUNC(orders.order_date, MONTH)\n), cp_prev_v AS (\n SELECT\n `orders___customer_id`,\n `orders___order_date`,\n `orders___amount_sum`,\n LAG(`orders___order_date`) OVER (PARTITION BY `orders___customer_id` ORDER BY `orders___order_date`) AS `_cp_prev_orders___v`\n FROM base\n), cp_reset_v AS (\n SELECT\n `orders___customer_id`,\n `orders___order_date`,\n `orders___amount_sum`,\n SUM(\n CASE\n WHEN `orders___amount_sum` > 100\n AND CAST(`_cp_prev_orders___v` AS DATETIME) = DATETIME_ADD(CAST(`orders___order_date` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY `orders___customer_id`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS `_cp_reset_orders___v`\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n `orders___customer_id`,\n `orders___order_date`,\n `orders___amount_sum`,\n CASE\n WHEN `orders___amount_sum` > 100\n THEN SUM(CASE WHEN `orders___amount_sum` > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `orders___customer_id`, `_cp_reset_orders___v`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___v`\n FROM cp_reset_v\n)\nSELECT\n `orders___customer_id`,\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___customer_id`,\n `orders___order_date`,\n `orders___amount_sum`,\n `orders___v`\n FROM cp_value_v\n) AS _outer", "cp/grouped::duckdb": "WITH base AS (\n SELECT\n orders.customer_id AS \"orders.customer_id\",\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 orders.customer_id,\n DATE_TRUNC('MONTH', orders.order_date)\n), cp_prev_v AS (\n SELECT\n \"orders.customer_id\",\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (PARTITION BY \"orders.customer_id\" ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.customer_id\",\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = \"orders.order_date\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY \"orders.customer_id\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.customer_id\",\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"orders.customer_id\", \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.customer_id\",\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.customer_id\",\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/grouped::postgres": "WITH base AS (\n SELECT\n orders.customer_id AS \"orders.customer_id\",\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 orders.customer_id,\n DATE_TRUNC('MONTH', orders.order_date)\n), cp_prev_v AS (\n SELECT\n \"orders.customer_id\",\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (PARTITION BY \"orders.customer_id\" ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.customer_id\",\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = \"orders.order_date\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY \"orders.customer_id\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.customer_id\",\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"orders.customer_id\", \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.customer_id\",\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.customer_id\",\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/grouped::sqlite": "WITH base AS (\n SELECT\n orders.customer_id AS \"orders.customer_id\",\n STRFTIME('%Y-%m-01', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n orders.customer_id,\n STRFTIME('%Y-%m-01', orders.order_date)\n), cp_prev_v AS (\n SELECT\n \"orders.customer_id\",\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (PARTITION BY \"orders.customer_id\" ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.customer_id\",\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = SLAYER_DATE_ADD(\"orders.order_date\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY \"orders.customer_id\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.customer_id\",\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"orders.customer_id\", \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.customer_id\",\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.customer_id\",\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/grouped::tsql": "WITH base AS (\n SELECT\n orders.customer_id AS [orders___customer_id],\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 orders.customer_id,\n DATETRUNC(month, orders.order_date)\n), cp_prev_v AS (\n SELECT\n [orders___customer_id] AS [orders___customer_id],\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n LAG([orders___order_date]) OVER (PARTITION BY [orders___customer_id] ORDER BY [orders___order_date]) AS [_cp_prev_orders___v]\n FROM base\n), cp_reset_v AS (\n SELECT\n [orders___customer_id] AS [orders___customer_id],\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n SUM(\n CASE\n WHEN [orders___amount_sum] > 100\n AND [_cp_prev_orders___v] = DATEADD(MONTH, -1, [orders___order_date])\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY [orders___customer_id]\n ORDER BY [orders___order_date]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS [_cp_reset_orders___v]\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n [orders___customer_id] AS [orders___customer_id],\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n CASE\n WHEN [orders___amount_sum] > 100\n THEN SUM(CASE WHEN [orders___amount_sum] > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY [orders___customer_id], [_cp_reset_orders___v]\n ORDER BY [orders___order_date]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [orders___v]\n FROM cp_reset_v\n)\nSELECT\n [orders___customer_id],\n [orders___order_date],\n [orders___v]\nFROM (\n SELECT\n [orders___customer_id],\n [orders___order_date],\n [orders___amount_sum],\n [orders___v]\n FROM cp_value_v\n) AS _outer", - "cp/hour::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, HOUR) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, HOUR)\n), cp_prev_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n LAG(`orders___order_date`) OVER (ORDER BY `orders___order_date`) AS `_cp_prev_orders___v`\n FROM base\n), cp_reset_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n SUM(\n CASE\n WHEN `orders___amount_sum` > 100\n AND CAST(`_cp_prev_orders___v` AS TIMESTAMP) = TIMESTAMP_ADD(CAST(`orders___order_date` AS TIMESTAMP), INTERVAL -1 HOUR)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___order_date` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___v`\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n CASE\n WHEN `orders___amount_sum` > 100\n THEN SUM(CASE WHEN `orders___amount_sum` > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___v`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___v`\n FROM cp_reset_v\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders___v`\n FROM cp_value_v\n) AS _outer", + "cp/hour::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, HOUR) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, HOUR)\n), cp_prev_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n LAG(`orders___order_date`) OVER (ORDER BY `orders___order_date`) AS `_cp_prev_orders___v`\n FROM base\n), cp_reset_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n SUM(\n CASE\n WHEN `orders___amount_sum` > 100\n AND CAST(`_cp_prev_orders___v` AS DATETIME) = DATETIME_ADD(CAST(`orders___order_date` AS DATETIME), INTERVAL -1 HOUR)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___order_date` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___v`\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n CASE\n WHEN `orders___amount_sum` > 100\n THEN SUM(CASE WHEN `orders___amount_sum` > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___v`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___v`\n FROM cp_reset_v\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders___v`\n FROM cp_value_v\n) AS _outer", "cp/hour::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('HOUR', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('HOUR', orders.order_date)\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = \"orders.order_date\" - INTERVAL 1 HOUR\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/hour::postgres": "WITH base AS (\n SELECT\n DATE_TRUNC('HOUR', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('HOUR', orders.order_date)\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = \"orders.order_date\" - INTERVAL '1 HOUR'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/hour::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-%d %H:00:00', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n STRFTIME('%Y-%m-%d %H:00:00', orders.order_date)\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = SLAYER_DATE_ADD(\"orders.order_date\", -1, 'hour')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/hour::tsql": "WITH base AS (\n SELECT\n DATETRUNC(hour, orders.order_date) AS [orders___order_date],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATETRUNC(hour, orders.order_date)\n), cp_prev_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n LAG([orders___order_date]) OVER (ORDER BY [orders___order_date]) AS [_cp_prev_orders___v]\n FROM base\n), cp_reset_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n SUM(\n CASE\n WHEN [orders___amount_sum] > 100\n AND [_cp_prev_orders___v] = DATEADD(HOUR, -1, [orders___order_date])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [orders___order_date] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_orders___v]\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n CASE\n WHEN [orders___amount_sum] > 100\n THEN SUM(CASE WHEN [orders___amount_sum] > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY [_cp_reset_orders___v]\n ORDER BY [orders___order_date]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [orders___v]\n FROM cp_reset_v\n)\nSELECT\n [orders___order_date],\n [orders___v]\nFROM (\n SELECT\n [orders___order_date],\n [orders___amount_sum],\n [orders___v]\n FROM cp_value_v\n) AS _outer", - "cp/month::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, MONTH)\n), cp_prev_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n LAG(`orders___order_date`) OVER (ORDER BY `orders___order_date`) AS `_cp_prev_orders___v`\n FROM base\n), cp_reset_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n SUM(\n CASE\n WHEN `orders___amount_sum` > 100\n AND CAST(`_cp_prev_orders___v` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`orders___order_date` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___order_date` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___v`\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n CASE\n WHEN `orders___amount_sum` > 100\n THEN SUM(CASE WHEN `orders___amount_sum` > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___v`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___v`\n FROM cp_reset_v\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders___v`\n FROM cp_value_v\n) AS _outer", + "cp/month::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, MONTH)\n), cp_prev_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n LAG(`orders___order_date`) OVER (ORDER BY `orders___order_date`) AS `_cp_prev_orders___v`\n FROM base\n), cp_reset_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n SUM(\n CASE\n WHEN `orders___amount_sum` > 100\n AND CAST(`_cp_prev_orders___v` AS DATETIME) = DATETIME_ADD(CAST(`orders___order_date` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___order_date` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___v`\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n CASE\n WHEN `orders___amount_sum` > 100\n THEN SUM(CASE WHEN `orders___amount_sum` > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___v`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___v`\n FROM cp_reset_v\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders___v`\n FROM cp_value_v\n) AS _outer", "cp/month::duckdb": "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 WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = \"orders.order_date\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/month::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 WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = \"orders.order_date\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/month::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n STRFTIME('%Y-%m-01', orders.order_date)\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = SLAYER_DATE_ADD(\"orders.order_date\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/month::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 WHERE\n orders.customer_id = 1\n GROUP BY\n DATETRUNC(month, orders.order_date)\n), cp_prev_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n LAG([orders___order_date]) OVER (ORDER BY [orders___order_date]) AS [_cp_prev_orders___v]\n FROM base\n), cp_reset_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n SUM(\n CASE\n WHEN [orders___amount_sum] > 100\n AND [_cp_prev_orders___v] = DATEADD(MONTH, -1, [orders___order_date])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [orders___order_date] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_orders___v]\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n CASE\n WHEN [orders___amount_sum] > 100\n THEN SUM(CASE WHEN [orders___amount_sum] > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY [_cp_reset_orders___v]\n ORDER BY [orders___order_date]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [orders___v]\n FROM cp_reset_v\n)\nSELECT\n [orders___order_date],\n [orders___v]\nFROM (\n SELECT\n [orders___order_date],\n [orders___amount_sum],\n [orders___v]\n FROM cp_value_v\n) AS _outer", - "cp/over_change::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, MONTH)\n), sjoin__time_shift_inner AS (\n SELECT\n base.`orders___order_date`,\n base.`orders___amount_sum`,\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___order_date` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___order_date` AS TIMESTAMP)\n), cp_prev_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n LAG(`orders___order_date`) OVER (ORDER BY `orders___order_date`) AS `_cp_prev_orders___v`\n FROM sjoin__time_shift_inner\n), cp_reset_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n SUM(\n CASE\n WHEN `orders___amount_sum` - `orders____time_shift_inner` > 0\n AND CAST(`_cp_prev_orders___v` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`orders___order_date` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___order_date` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___v`\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n CASE\n WHEN `orders___amount_sum` - `orders____time_shift_inner` > 0\n THEN SUM(CASE WHEN `orders___amount_sum` - `orders____time_shift_inner` > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___v`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___v`\n FROM cp_reset_v\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n `orders___v`\n FROM cp_value_v\n) AS _outer", + "cp/over_change::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, MONTH)\n), sjoin__time_shift_inner AS (\n SELECT\n base.`orders___order_date`,\n base.`orders___amount_sum`,\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 DATETIME_ADD(CAST(base.`orders___order_date` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___order_date` AS DATETIME)\n), cp_prev_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n LAG(`orders___order_date`) OVER (ORDER BY `orders___order_date`) AS `_cp_prev_orders___v`\n FROM sjoin__time_shift_inner\n), cp_reset_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n SUM(\n CASE\n WHEN `orders___amount_sum` - `orders____time_shift_inner` > 0\n AND CAST(`_cp_prev_orders___v` AS DATETIME) = DATETIME_ADD(CAST(`orders___order_date` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___order_date` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___v`\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n CASE\n WHEN `orders___amount_sum` - `orders____time_shift_inner` > 0\n THEN SUM(CASE WHEN `orders___amount_sum` - `orders____time_shift_inner` > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___v`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___v`\n FROM cp_reset_v\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n `orders___v`\n FROM cp_value_v\n) AS _outer", "cp/over_change::duckdb": "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 WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), shifted__time_shift_inner AS (\n SELECT\n DATE_TRUNC('MONTH', orders.order_date) AS \"orders.order_date\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.order_date\",\n base.\"orders.amount_sum\",\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.order_date\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.order_date\"\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM sjoin__time_shift_inner\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" - \"orders._time_shift_inner\" > 0\n AND \"_cp_prev_orders.v\" = \"orders.order_date\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n CASE\n WHEN \"orders.amount_sum\" - \"orders._time_shift_inner\" > 0\n THEN SUM(CASE WHEN \"orders.amount_sum\" - \"orders._time_shift_inner\" > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/over_change::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 WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), shifted__time_shift_inner AS (\n SELECT\n DATE_TRUNC('MONTH', orders.order_date) AS \"orders.order_date\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.order_date\",\n base.\"orders.amount_sum\",\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.order_date\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.order_date\"\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM sjoin__time_shift_inner\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" - \"orders._time_shift_inner\" > 0\n AND \"_cp_prev_orders.v\" = \"orders.order_date\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n CASE\n WHEN \"orders.amount_sum\" - \"orders._time_shift_inner\" > 0\n THEN SUM(CASE WHEN \"orders.amount_sum\" - \"orders._time_shift_inner\" > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/over_change::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n STRFTIME('%Y-%m-01', orders.order_date)\n), shifted__time_shift_inner AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.order_date) AS \"orders.order_date\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n STRFTIME('%Y-%m-01', orders.order_date)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.order_date\",\n base.\"orders.amount_sum\",\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.order_date\", -1, 'month') IS shifted__time_shift_inner.\"orders.order_date\"\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM sjoin__time_shift_inner\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" - \"orders._time_shift_inner\" > 0\n AND \"_cp_prev_orders.v\" = SLAYER_DATE_ADD(\"orders.order_date\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n CASE\n WHEN \"orders.amount_sum\" - \"orders._time_shift_inner\" > 0\n THEN SUM(CASE WHEN \"orders.amount_sum\" - \"orders._time_shift_inner\" > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/over_change::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 WHERE\n orders.customer_id = 1\n GROUP BY\n DATETRUNC(month, orders.order_date)\n), shifted__time_shift_inner AS (\n SELECT\n DATETRUNC(month, orders.order_date) AS [orders___order_date],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___amount_sum]\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATETRUNC(month, orders.order_date)\n), sjoin__time_shift_inner AS (\n SELECT\n base.[orders___order_date] AS [orders___order_date],\n base.[orders___amount_sum] AS [orders___amount_sum],\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 (\n DATEADD(MONTH, -1, base.[orders___order_date]) = shifted__time_shift_inner.[orders___order_date]\n AND NOT DATEADD(MONTH, -1, base.[orders___order_date]) IS NULL\n AND NOT shifted__time_shift_inner.[orders___order_date] IS NULL\n )\n OR (\n DATEADD(MONTH, -1, base.[orders___order_date]) IS NULL\n AND shifted__time_shift_inner.[orders___order_date] IS NULL\n )\n )\n), cp_prev_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n LAG([orders___order_date]) OVER (ORDER BY [orders___order_date]) AS [_cp_prev_orders___v]\n FROM sjoin__time_shift_inner\n), cp_reset_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n SUM(\n CASE\n WHEN [orders___amount_sum] - [orders____time_shift_inner] > 0\n AND [_cp_prev_orders___v] = DATEADD(MONTH, -1, [orders___order_date])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [orders___order_date] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_orders___v]\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n CASE\n WHEN [orders___amount_sum] - [orders____time_shift_inner] > 0\n THEN SUM(CASE WHEN [orders___amount_sum] - [orders____time_shift_inner] > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY [_cp_reset_orders___v]\n ORDER BY [orders___order_date]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [orders___v]\n FROM cp_reset_v\n)\nSELECT\n [orders___order_date],\n [orders___v]\nFROM (\n SELECT\n [orders___order_date],\n [orders___amount_sum],\n [orders____time_shift_inner],\n [orders___v]\n FROM cp_value_v\n) AS _outer", - "cp/over_lag::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, MONTH)\n), step1 AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n LAG(`orders___amount_sum`, 1) OVER (ORDER BY `orders___order_date`) AS `orders____lag_inner`\n FROM base\n), cp_prev_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____lag_inner`,\n LAG(`orders___order_date`) OVER (ORDER BY `orders___order_date`) AS `_cp_prev_orders___v`\n FROM step1\n), cp_reset_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____lag_inner`,\n SUM(\n CASE\n WHEN `orders____lag_inner` > 100\n AND CAST(`_cp_prev_orders___v` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`orders___order_date` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___order_date` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___v`\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____lag_inner`,\n CASE\n WHEN `orders____lag_inner` > 100\n THEN SUM(CASE WHEN `orders____lag_inner` > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___v`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___v`\n FROM cp_reset_v\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____lag_inner`,\n `orders___v`\n FROM cp_value_v\n) AS _outer", + "cp/over_lag::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, MONTH)\n), step1 AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n LAG(`orders___amount_sum`, 1) OVER (ORDER BY `orders___order_date`) AS `orders____lag_inner`\n FROM base\n), cp_prev_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____lag_inner`,\n LAG(`orders___order_date`) OVER (ORDER BY `orders___order_date`) AS `_cp_prev_orders___v`\n FROM step1\n), cp_reset_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____lag_inner`,\n SUM(\n CASE\n WHEN `orders____lag_inner` > 100\n AND CAST(`_cp_prev_orders___v` AS DATETIME) = DATETIME_ADD(CAST(`orders___order_date` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___order_date` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___v`\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____lag_inner`,\n CASE\n WHEN `orders____lag_inner` > 100\n THEN SUM(CASE WHEN `orders____lag_inner` > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___v`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___v`\n FROM cp_reset_v\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____lag_inner`,\n `orders___v`\n FROM cp_value_v\n) AS _outer", "cp/over_lag::duckdb": "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 WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), step1 AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.amount_sum\", 1) OVER (ORDER BY \"orders.order_date\") AS \"orders._lag_inner\"\n FROM base\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._lag_inner\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM step1\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._lag_inner\",\n SUM(\n CASE\n WHEN \"orders._lag_inner\" > 100\n AND \"_cp_prev_orders.v\" = \"orders.order_date\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._lag_inner\",\n CASE\n WHEN \"orders._lag_inner\" > 100\n THEN SUM(CASE WHEN \"orders._lag_inner\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._lag_inner\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/over_lag::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 WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), step1 AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.amount_sum\", 1) OVER (ORDER BY \"orders.order_date\") AS \"orders._lag_inner\"\n FROM base\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._lag_inner\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM step1\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._lag_inner\",\n SUM(\n CASE\n WHEN \"orders._lag_inner\" > 100\n AND \"_cp_prev_orders.v\" = \"orders.order_date\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._lag_inner\",\n CASE\n WHEN \"orders._lag_inner\" > 100\n THEN SUM(CASE WHEN \"orders._lag_inner\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._lag_inner\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/over_lag::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n STRFTIME('%Y-%m-01', orders.order_date)\n), step1 AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.amount_sum\", 1) OVER (ORDER BY \"orders.order_date\") AS \"orders._lag_inner\"\n FROM base\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._lag_inner\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM step1\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._lag_inner\",\n SUM(\n CASE\n WHEN \"orders._lag_inner\" > 100\n AND \"_cp_prev_orders.v\" = SLAYER_DATE_ADD(\"orders.order_date\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._lag_inner\",\n CASE\n WHEN \"orders._lag_inner\" > 100\n THEN SUM(CASE WHEN \"orders._lag_inner\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._lag_inner\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/over_lag::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 WHERE\n orders.customer_id = 1\n GROUP BY\n DATETRUNC(month, orders.order_date)\n), step1 AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n LAG([orders___amount_sum], 1) OVER (ORDER BY [orders___order_date]) AS [orders____lag_inner]\n FROM base\n), cp_prev_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders____lag_inner] AS [orders____lag_inner],\n LAG([orders___order_date]) OVER (ORDER BY [orders___order_date]) AS [_cp_prev_orders___v]\n FROM step1\n), cp_reset_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders____lag_inner] AS [orders____lag_inner],\n SUM(\n CASE\n WHEN [orders____lag_inner] > 100\n AND [_cp_prev_orders___v] = DATEADD(MONTH, -1, [orders___order_date])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [orders___order_date] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_orders___v]\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders____lag_inner] AS [orders____lag_inner],\n CASE\n WHEN [orders____lag_inner] > 100\n THEN SUM(CASE WHEN [orders____lag_inner] > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY [_cp_reset_orders___v]\n ORDER BY [orders___order_date]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [orders___v]\n FROM cp_reset_v\n)\nSELECT\n [orders___order_date],\n [orders___v]\nFROM (\n SELECT\n [orders___order_date],\n [orders___amount_sum],\n [orders____lag_inner],\n [orders___v]\n FROM cp_value_v\n) AS _outer", - "cp/quarter::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, QUARTER) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, QUARTER)\n), cp_prev_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n LAG(`orders___order_date`) OVER (ORDER BY `orders___order_date`) AS `_cp_prev_orders___v`\n FROM base\n), cp_reset_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n SUM(\n CASE\n WHEN `orders___amount_sum` > 100\n AND CAST(`_cp_prev_orders___v` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`orders___order_date` AS TIMESTAMP) AS DATETIME), INTERVAL -1 QUARTER) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___order_date` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___v`\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n CASE\n WHEN `orders___amount_sum` > 100\n THEN SUM(CASE WHEN `orders___amount_sum` > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___v`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___v`\n FROM cp_reset_v\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders___v`\n FROM cp_value_v\n) AS _outer", + "cp/quarter::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, QUARTER) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, QUARTER)\n), cp_prev_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n LAG(`orders___order_date`) OVER (ORDER BY `orders___order_date`) AS `_cp_prev_orders___v`\n FROM base\n), cp_reset_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n SUM(\n CASE\n WHEN `orders___amount_sum` > 100\n AND CAST(`_cp_prev_orders___v` AS DATETIME) = DATETIME_ADD(CAST(`orders___order_date` AS DATETIME), INTERVAL -1 QUARTER)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___order_date` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___v`\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n CASE\n WHEN `orders___amount_sum` > 100\n THEN SUM(CASE WHEN `orders___amount_sum` > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___v`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___v`\n FROM cp_reset_v\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders___v`\n FROM cp_value_v\n) AS _outer", "cp/quarter::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('QUARTER', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('QUARTER', orders.order_date)\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = \"orders.order_date\" - INTERVAL 3 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/quarter::postgres": "WITH base AS (\n SELECT\n DATE_TRUNC('QUARTER', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('QUARTER', orders.order_date)\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = \"orders.order_date\" - INTERVAL '3 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/quarter::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-', orders.order_date) || CASE\n WHEN CAST(STRFTIME('%m', orders.order_date) AS INTEGER) <= 3\n THEN '01-01'\n WHEN CAST(STRFTIME('%m', orders.order_date) AS INTEGER) <= 6\n THEN '04-01'\n WHEN CAST(STRFTIME('%m', orders.order_date) AS INTEGER) <= 9\n THEN '07-01'\n ELSE '10-01'\n END AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n STRFTIME('%Y-', orders.order_date) || CASE\n WHEN CAST(STRFTIME('%m', orders.order_date) AS INTEGER) <= 3\n THEN '01-01'\n WHEN CAST(STRFTIME('%m', orders.order_date) AS INTEGER) <= 6\n THEN '04-01'\n WHEN CAST(STRFTIME('%m', orders.order_date) AS INTEGER) <= 9\n THEN '07-01'\n ELSE '10-01'\n END\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = SLAYER_DATE_ADD(\"orders.order_date\", -1, 'quarter')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/quarter::tsql": "WITH base AS (\n SELECT\n DATETRUNC(quarter, orders.order_date) AS [orders___order_date],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATETRUNC(quarter, orders.order_date)\n), cp_prev_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n LAG([orders___order_date]) OVER (ORDER BY [orders___order_date]) AS [_cp_prev_orders___v]\n FROM base\n), cp_reset_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n SUM(\n CASE\n WHEN [orders___amount_sum] > 100\n AND [_cp_prev_orders___v] = DATEADD(QUARTER, -1, [orders___order_date])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [orders___order_date] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_orders___v]\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n CASE\n WHEN [orders___amount_sum] > 100\n THEN SUM(CASE WHEN [orders___amount_sum] > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY [_cp_reset_orders___v]\n ORDER BY [orders___order_date]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [orders___v]\n FROM cp_reset_v\n)\nSELECT\n [orders___order_date],\n [orders___v]\nFROM (\n SELECT\n [orders___order_date],\n [orders___amount_sum],\n [orders___v]\n FROM cp_value_v\n) AS _outer", - "cp/under_lag::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, MONTH)\n), cp_prev__consecutive_periods_inner AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n LAG(`orders___order_date`) OVER (ORDER BY `orders___order_date`) AS `_cp_prev_orders____consecutive_periods_inner`\n FROM base\n), cp_reset__consecutive_periods_inner AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n SUM(\n CASE\n WHEN `orders___amount_sum` > 100\n AND CAST(`_cp_prev_orders____consecutive_periods_inner` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`orders___order_date` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___order_date` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders____consecutive_periods_inner`\n FROM cp_prev__consecutive_periods_inner\n), cp_value__consecutive_periods_inner AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n CASE\n WHEN `orders___amount_sum` > 100\n THEN SUM(CASE WHEN `orders___amount_sum` > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders____consecutive_periods_inner`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders____consecutive_periods_inner`\n FROM cp_reset__consecutive_periods_inner\n), step1 AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____consecutive_periods_inner`,\n LAG(`orders____consecutive_periods_inner`, 1) OVER (ORDER BY `orders___order_date`) AS `orders___v`\n FROM cp_value__consecutive_periods_inner\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____consecutive_periods_inner`,\n `orders___v`\n FROM step1\n) AS _outer", + "cp/under_lag::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, MONTH)\n), cp_prev__consecutive_periods_inner AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n LAG(`orders___order_date`) OVER (ORDER BY `orders___order_date`) AS `_cp_prev_orders____consecutive_periods_inner`\n FROM base\n), cp_reset__consecutive_periods_inner AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n SUM(\n CASE\n WHEN `orders___amount_sum` > 100\n AND CAST(`_cp_prev_orders____consecutive_periods_inner` AS DATETIME) = DATETIME_ADD(CAST(`orders___order_date` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___order_date` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders____consecutive_periods_inner`\n FROM cp_prev__consecutive_periods_inner\n), cp_value__consecutive_periods_inner AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n CASE\n WHEN `orders___amount_sum` > 100\n THEN SUM(CASE WHEN `orders___amount_sum` > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders____consecutive_periods_inner`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders____consecutive_periods_inner`\n FROM cp_reset__consecutive_periods_inner\n), step1 AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____consecutive_periods_inner`,\n LAG(`orders____consecutive_periods_inner`, 1) OVER (ORDER BY `orders___order_date`) AS `orders___v`\n FROM cp_value__consecutive_periods_inner\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders____consecutive_periods_inner`,\n `orders___v`\n FROM step1\n) AS _outer", "cp/under_lag::duckdb": "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 WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), cp_prev__consecutive_periods_inner AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders._consecutive_periods_inner\"\n FROM base\n), cp_reset__consecutive_periods_inner AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders._consecutive_periods_inner\" = \"orders.order_date\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders._consecutive_periods_inner\"\n FROM cp_prev__consecutive_periods_inner\n), cp_value__consecutive_periods_inner AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders._consecutive_periods_inner\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders._consecutive_periods_inner\"\n FROM cp_reset__consecutive_periods_inner\n), step1 AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._consecutive_periods_inner\",\n LAG(\"orders._consecutive_periods_inner\", 1) OVER (ORDER BY \"orders.order_date\") AS \"orders.v\"\n FROM cp_value__consecutive_periods_inner\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._consecutive_periods_inner\",\n \"orders.v\"\n FROM step1\n) AS _outer", "cp/under_lag::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 WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), cp_prev__consecutive_periods_inner AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders._consecutive_periods_inner\"\n FROM base\n), cp_reset__consecutive_periods_inner AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders._consecutive_periods_inner\" = \"orders.order_date\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders._consecutive_periods_inner\"\n FROM cp_prev__consecutive_periods_inner\n), cp_value__consecutive_periods_inner AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders._consecutive_periods_inner\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders._consecutive_periods_inner\"\n FROM cp_reset__consecutive_periods_inner\n), step1 AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._consecutive_periods_inner\",\n LAG(\"orders._consecutive_periods_inner\", 1) OVER (ORDER BY \"orders.order_date\") AS \"orders.v\"\n FROM cp_value__consecutive_periods_inner\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._consecutive_periods_inner\",\n \"orders.v\"\n FROM step1\n) AS _outer", "cp/under_lag::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n STRFTIME('%Y-%m-01', orders.order_date)\n), cp_prev__consecutive_periods_inner AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders._consecutive_periods_inner\"\n FROM base\n), cp_reset__consecutive_periods_inner AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders._consecutive_periods_inner\" = SLAYER_DATE_ADD(\"orders.order_date\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders._consecutive_periods_inner\"\n FROM cp_prev__consecutive_periods_inner\n), cp_value__consecutive_periods_inner AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders._consecutive_periods_inner\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders._consecutive_periods_inner\"\n FROM cp_reset__consecutive_periods_inner\n), step1 AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._consecutive_periods_inner\",\n LAG(\"orders._consecutive_periods_inner\", 1) OVER (ORDER BY \"orders.order_date\") AS \"orders.v\"\n FROM cp_value__consecutive_periods_inner\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders._consecutive_periods_inner\",\n \"orders.v\"\n FROM step1\n) AS _outer", "cp/under_lag::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 WHERE\n orders.customer_id = 1\n GROUP BY\n DATETRUNC(month, orders.order_date)\n), cp_prev__consecutive_periods_inner AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n LAG([orders___order_date]) OVER (ORDER BY [orders___order_date]) AS [_cp_prev_orders____consecutive_periods_inner]\n FROM base\n), cp_reset__consecutive_periods_inner AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n SUM(\n CASE\n WHEN [orders___amount_sum] > 100\n AND [_cp_prev_orders____consecutive_periods_inner] = DATEADD(MONTH, -1, [orders___order_date])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [orders___order_date] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_orders____consecutive_periods_inner]\n FROM cp_prev__consecutive_periods_inner\n), cp_value__consecutive_periods_inner AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n CASE\n WHEN [orders___amount_sum] > 100\n THEN SUM(CASE WHEN [orders___amount_sum] > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY [_cp_reset_orders____consecutive_periods_inner]\n ORDER BY [orders___order_date]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [orders____consecutive_periods_inner]\n FROM cp_reset__consecutive_periods_inner\n), step1 AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders____consecutive_periods_inner] AS [orders____consecutive_periods_inner],\n LAG([orders____consecutive_periods_inner], 1) OVER (ORDER BY [orders___order_date]) AS [orders___v]\n FROM cp_value__consecutive_periods_inner\n)\nSELECT\n [orders___order_date],\n [orders___v]\nFROM (\n SELECT\n [orders___order_date],\n [orders___amount_sum],\n [orders____consecutive_periods_inner],\n [orders___v]\n FROM step1\n) AS _outer", - "cp/week_sunday::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, WEEK(SUNDAY)) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, WEEK(SUNDAY))\n), cp_prev_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n LAG(`orders___order_date`) OVER (ORDER BY `orders___order_date`) AS `_cp_prev_orders___v`\n FROM base\n), cp_reset_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n SUM(\n CASE\n WHEN `orders___amount_sum` > 100\n AND CAST(`_cp_prev_orders___v` AS TIMESTAMP) = TIMESTAMP_ADD(CAST(`orders___order_date` AS TIMESTAMP), INTERVAL ((\n -1\n ) * 7) DAY)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___order_date` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___v`\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n CASE\n WHEN `orders___amount_sum` > 100\n THEN SUM(CASE WHEN `orders___amount_sum` > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___v`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___v`\n FROM cp_reset_v\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders___v`\n FROM cp_value_v\n) AS _outer", + "cp/week_sunday::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, WEEK(SUNDAY)) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, WEEK(SUNDAY))\n), cp_prev_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n LAG(`orders___order_date`) OVER (ORDER BY `orders___order_date`) AS `_cp_prev_orders___v`\n FROM base\n), cp_reset_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n SUM(\n CASE\n WHEN `orders___amount_sum` > 100\n AND CAST(`_cp_prev_orders___v` AS DATETIME) = DATETIME_ADD(CAST(`orders___order_date` AS DATETIME), INTERVAL ((\n -1\n ) * 7) DAY)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___order_date` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___v`\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n CASE\n WHEN `orders___amount_sum` > 100\n THEN SUM(CASE WHEN `orders___amount_sum` > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___v`\n ORDER BY `orders___order_date`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___v`\n FROM cp_reset_v\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders___v`\n FROM cp_value_v\n) AS _outer", "cp/week_sunday::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('WEEK', CAST(orders.order_date + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('WEEK', CAST(orders.order_date + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = \"orders.order_date\" - INTERVAL 1 WEEK\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/week_sunday::postgres": "WITH base AS (\n SELECT\n DATE_TRUNC('WEEK', CAST(orders.order_date + INTERVAL '1 DAY' AS TIMESTAMP)) - INTERVAL '1 DAY' AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('WEEK', CAST(orders.order_date + INTERVAL '1 DAY' AS TIMESTAMP)) - INTERVAL '1 DAY'\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = \"orders.order_date\" - INTERVAL '1 WEEK'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/week_sunday::sqlite": "WITH base AS (\n SELECT\n SLAYER_DATE_ADD(\n DATE(SLAYER_DATE_ADD(orders.order_date, 1, 'day'), 'weekday 0', '-6 days'),\n -1,\n 'day'\n ) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n SLAYER_DATE_ADD(\n DATE(SLAYER_DATE_ADD(orders.order_date, 1, 'day'), 'weekday 0', '-6 days'),\n -1,\n 'day'\n )\n), cp_prev_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n LAG(\"orders.order_date\") OVER (ORDER BY \"orders.order_date\") AS \"_cp_prev_orders.v\"\n FROM base\n), cp_reset_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 100\n AND \"_cp_prev_orders.v\" = SLAYER_DATE_ADD(\"orders.order_date\", -1, 'week_sunday')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.order_date\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.v\"\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n CASE\n WHEN \"orders.amount_sum\" > 100\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.v\"\n ORDER BY \"orders.order_date\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.v\"\n FROM cp_reset_v\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM cp_value_v\n) AS _outer", "cp/week_sunday::tsql": "WITH base AS (\n SELECT\n DATEADD(DAY, -1, DATETRUNC(iso_week, CAST(DATEADD(DAY, 1, orders.order_date) AS DATETIME2))) AS [orders___order_date],\n SUM(orders.amount) AS [orders___amount_sum]\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATEADD(DAY, -1, DATETRUNC(iso_week, CAST(DATEADD(DAY, 1, orders.order_date) AS DATETIME2)))\n), cp_prev_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n LAG([orders___order_date]) OVER (ORDER BY [orders___order_date]) AS [_cp_prev_orders___v]\n FROM base\n), cp_reset_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n SUM(\n CASE\n WHEN [orders___amount_sum] > 100\n AND [_cp_prev_orders___v] = DATEADD(WEEK, -1, [orders___order_date])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [orders___order_date] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_orders___v]\n FROM cp_prev_v\n), cp_value_v AS (\n SELECT\n [orders___order_date] AS [orders___order_date],\n [orders___amount_sum] AS [orders___amount_sum],\n CASE\n WHEN [orders___amount_sum] > 100\n THEN SUM(CASE WHEN [orders___amount_sum] > 100 THEN 1 ELSE 0 END) OVER (\n PARTITION BY [_cp_reset_orders___v]\n ORDER BY [orders___order_date]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [orders___v]\n FROM cp_reset_v\n)\nSELECT\n [orders___order_date],\n [orders___v]\nFROM (\n SELECT\n [orders___order_date],\n [orders___amount_sum],\n [orders___v]\n FROM cp_value_v\n) AS _outer", - "ts/hour::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, HOUR) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, HOUR)\n), shifted_v AS (\n SELECT\n DATE_TRUNC(orders.order_date, HOUR) AS `orders___order_date`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, HOUR)\n), sjoin_v AS (\n SELECT\n base.`orders___order_date`,\n base.`orders___amount_sum`,\n shifted_v.`orders___amount_sum` AS `orders___v`\n FROM base\n LEFT JOIN shifted_v\n ON TIMESTAMP_ADD(CAST(base.`orders___order_date` AS TIMESTAMP), INTERVAL -1 HOUR) IS NOT DISTINCT FROM CAST(shifted_v.`orders___order_date` AS TIMESTAMP)\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders___v`\n FROM sjoin_v\n) AS _outer", + "ts/hour::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.order_date, HOUR) AS `orders___order_date`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, HOUR)\n), shifted_v AS (\n SELECT\n DATE_TRUNC(orders.order_date, HOUR) AS `orders___order_date`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC(orders.order_date, HOUR)\n), sjoin_v AS (\n SELECT\n base.`orders___order_date`,\n base.`orders___amount_sum`,\n shifted_v.`orders___amount_sum` AS `orders___v`\n FROM base\n LEFT JOIN shifted_v\n ON DATETIME_ADD(CAST(base.`orders___order_date` AS DATETIME), INTERVAL -1 HOUR) IS NOT DISTINCT FROM CAST(shifted_v.`orders___order_date` AS DATETIME)\n)\nSELECT\n `orders___order_date`,\n `orders___v`\nFROM (\n SELECT\n `orders___order_date`,\n `orders___amount_sum`,\n `orders___v`\n FROM sjoin_v\n) AS _outer", "ts/hour::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('HOUR', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('HOUR', orders.order_date)\n), shifted_v AS (\n SELECT\n DATE_TRUNC('HOUR', orders.order_date) AS \"orders.order_date\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('HOUR', orders.order_date)\n), sjoin_v AS (\n SELECT\n base.\"orders.order_date\",\n base.\"orders.amount_sum\",\n shifted_v.\"orders.amount_sum\" AS \"orders.v\"\n FROM base\n LEFT JOIN shifted_v\n ON base.\"orders.order_date\" - INTERVAL 1 HOUR IS NOT DISTINCT FROM shifted_v.\"orders.order_date\"\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM sjoin_v\n) AS _outer", "ts/hour::postgres": "WITH base AS (\n SELECT\n DATE_TRUNC('HOUR', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('HOUR', orders.order_date)\n), shifted_v AS (\n SELECT\n DATE_TRUNC('HOUR', orders.order_date) AS \"orders.order_date\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n DATE_TRUNC('HOUR', orders.order_date)\n), sjoin_v AS (\n SELECT\n base.\"orders.order_date\",\n base.\"orders.amount_sum\",\n shifted_v.\"orders.amount_sum\" AS \"orders.v\"\n FROM base\n LEFT JOIN shifted_v\n ON base.\"orders.order_date\" - INTERVAL '1 HOUR' IS NOT DISTINCT FROM shifted_v.\"orders.order_date\"\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM sjoin_v\n) AS _outer", "ts/hour::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-%d %H:00:00', orders.order_date) AS \"orders.order_date\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n STRFTIME('%Y-%m-%d %H:00:00', orders.order_date)\n), shifted_v AS (\n SELECT\n STRFTIME('%Y-%m-%d %H:00:00', orders.order_date) AS \"orders.order_date\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.customer_id = 1\n GROUP BY\n STRFTIME('%Y-%m-%d %H:00:00', orders.order_date)\n), sjoin_v AS (\n SELECT\n base.\"orders.order_date\",\n base.\"orders.amount_sum\",\n shifted_v.\"orders.amount_sum\" AS \"orders.v\"\n FROM base\n LEFT JOIN shifted_v\n ON SLAYER_DATE_ADD(base.\"orders.order_date\", -1, 'hour') IS shifted_v.\"orders.order_date\"\n)\nSELECT\n \"orders.order_date\",\n \"orders.v\"\nFROM (\n SELECT\n \"orders.order_date\",\n \"orders.amount_sum\",\n \"orders.v\"\n FROM sjoin_v\n) AS _outer", diff --git a/tests/golden/dev1737_date_add_parity.json b/tests/golden/dev1737_date_add_parity.json index c07afbf67..a48cb71ef 100644 --- a/tests/golden/dev1737_date_add_parity.json +++ b/tests/golden/dev1737_date_add_parity.json @@ -1,5 +1,5 @@ { - "shift|day_on_month|-1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, MONTH) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, MONTH)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, MONTH) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, MONTH)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON CAST(DATE_TRUNC(\n CAST(TIMESTAMP_ADD(CAST(base.`ev___ts` AS TIMESTAMP), INTERVAL -1 DAY) AS DATETIME),\n MONTH\n ) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS TIMESTAMP)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", + "shift|day_on_month|-1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, MONTH) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, MONTH)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, MONTH) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, MONTH)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON CAST(DATE_TRUNC(\n CAST(DATETIME_ADD(CAST(base.`ev___ts` AS DATETIME), INTERVAL -1 DAY) AS DATETIME),\n MONTH\n ) AS DATETIME) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS DATETIME)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", "shift|day_on_month|-1::clickhouse": "WITH base AS (\n SELECT\n dateTrunc('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('MONTH', ev.ts)\n), shifted_x AS (\n SELECT\n dateTrunc('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('MONTH', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON dateTrunc('MONTH', CAST(addDays(base.\"ev.ts\", -1) AS Nullable(DateTime))) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|day_on_month|-1::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('MONTH', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('MONTH', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON DATE_TRUNC('MONTH', CAST(base.\"ev.ts\" - INTERVAL 1 DAY AS TIMESTAMP)) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|day_on_month|-1::mysql": "WITH base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', MONTH(ev.ts), ' 1'), '%Y %c %e') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', MONTH(ev.ts), ' 1'), '%Y %c %e')\n), shifted_x AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', MONTH(ev.ts), ' 1'), '%Y %c %e') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', MONTH(ev.ts), ' 1'), '%Y %c %e')\n), sjoin_x AS (\n SELECT\n base.`ev.ts`,\n base.`ev.v_sum`,\n shifted_x.`ev.v_sum` AS `ev.x`\n FROM base\n LEFT JOIN shifted_x\n ON STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(base.`ev.ts`, INTERVAL -1 DAY) AS DATETIME)), ' ', MONTH(CAST(DATE_ADD(base.`ev.ts`, INTERVAL -1 DAY) AS DATETIME)), ' 1'),\n '%Y %c %e'\n ) <=> shifted_x.`ev.ts`\n)\nSELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\nFROM (\n SELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\n FROM sjoin_x\n) AS _outer", @@ -7,7 +7,7 @@ "shift|day_on_month|-1::snowflake": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('MONTH', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('MONTH', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON DATE_TRUNC('MONTH', CAST(DATEADD(DAY, -1, base.\"ev.ts\") AS TIMESTAMP)) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|day_on_month|-1::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-01', ev.ts)\n), shifted_x AS (\n SELECT\n STRFTIME('%Y-%m-01', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-01', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON STRFTIME('%Y-%m-01', SLAYER_DATE_ADD(base.\"ev.ts\", -1, 'day')) IS shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|day_on_month|-1::tsql": "WITH base AS (\n SELECT\n DATETRUNC(month, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(month, ev.ts)\n), shifted_x AS (\n SELECT\n DATETRUNC(month, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(month, ev.ts)\n), sjoin_x AS (\n SELECT\n base.[ev___ts] AS [ev___ts],\n base.[ev___v_sum] AS [ev___v_sum],\n shifted_x.[ev___v_sum] AS [ev___x]\n FROM base\n LEFT JOIN shifted_x\n ON (\n (\n DATETRUNC(month, CAST(DATEADD(DAY, -1, base.[ev___ts]) AS DATETIME2)) = shifted_x.[ev___ts]\n AND NOT DATETRUNC(month, CAST(DATEADD(DAY, -1, base.[ev___ts]) AS DATETIME2)) IS NULL\n AND NOT shifted_x.[ev___ts] IS NULL\n )\n OR (\n DATETRUNC(month, CAST(DATEADD(DAY, -1, base.[ev___ts]) AS DATETIME2)) IS NULL\n AND shifted_x.[ev___ts] IS NULL\n )\n )\n)\nSELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\nFROM (\n SELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\n FROM sjoin_x\n) AS _outer", - "shift|day|-1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, DAY) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, DAY)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, DAY) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, DAY)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON TIMESTAMP_ADD(CAST(base.`ev___ts` AS TIMESTAMP), INTERVAL -1 DAY) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS TIMESTAMP)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", + "shift|day|-1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, DAY) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, DAY)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, DAY) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, DAY)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON DATETIME_ADD(CAST(base.`ev___ts` AS DATETIME), INTERVAL -1 DAY) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS DATETIME)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", "shift|day|-1::clickhouse": "WITH base AS (\n SELECT\n dateTrunc('DAY', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('DAY', ev.ts)\n), shifted_x AS (\n SELECT\n dateTrunc('DAY', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('DAY', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON addDays(base.\"ev.ts\", -1) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|day|-1::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('DAY', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('DAY', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('DAY', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('DAY', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON base.\"ev.ts\" - INTERVAL 1 DAY IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|day|-1::mysql": "WITH base AS (\n SELECT\n DATE(ev.ts) AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n DATE(ev.ts)\n), shifted_x AS (\n SELECT\n DATE(ev.ts) AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n DATE(ev.ts)\n), sjoin_x AS (\n SELECT\n base.`ev.ts`,\n base.`ev.v_sum`,\n shifted_x.`ev.v_sum` AS `ev.x`\n FROM base\n LEFT JOIN shifted_x\n ON DATE_ADD(base.`ev.ts`, INTERVAL -1 DAY) <=> shifted_x.`ev.ts`\n)\nSELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\nFROM (\n SELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\n FROM sjoin_x\n) AS _outer", @@ -15,7 +15,7 @@ "shift|day|-1::snowflake": "WITH base AS (\n SELECT\n DATE_TRUNC('DAY', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('DAY', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('DAY', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('DAY', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON DATEADD(DAY, -1, base.\"ev.ts\") IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|day|-1::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-%d', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-%d', ev.ts)\n), shifted_x AS (\n SELECT\n STRFTIME('%Y-%m-%d', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-%d', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON SLAYER_DATE_ADD(base.\"ev.ts\", -1, 'day') IS shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|day|-1::tsql": "WITH base AS (\n SELECT\n DATETRUNC(day, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(day, ev.ts)\n), shifted_x AS (\n SELECT\n DATETRUNC(day, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(day, ev.ts)\n), sjoin_x AS (\n SELECT\n base.[ev___ts] AS [ev___ts],\n base.[ev___v_sum] AS [ev___v_sum],\n shifted_x.[ev___v_sum] AS [ev___x]\n FROM base\n LEFT JOIN shifted_x\n ON (\n (\n DATEADD(DAY, -1, base.[ev___ts]) = shifted_x.[ev___ts]\n AND NOT DATEADD(DAY, -1, base.[ev___ts]) IS NULL\n AND NOT shifted_x.[ev___ts] IS NULL\n )\n OR (\n DATEADD(DAY, -1, base.[ev___ts]) IS NULL AND shifted_x.[ev___ts] IS NULL\n )\n )\n)\nSELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\nFROM (\n SELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\n FROM sjoin_x\n) AS _outer", - "shift|day|1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, DAY) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, DAY)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, DAY) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, DAY)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON TIMESTAMP_ADD(CAST(base.`ev___ts` AS TIMESTAMP), INTERVAL 1 DAY) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS TIMESTAMP)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", + "shift|day|1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, DAY) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, DAY)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, DAY) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, DAY)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON DATETIME_ADD(CAST(base.`ev___ts` AS DATETIME), INTERVAL 1 DAY) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS DATETIME)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", "shift|day|1::clickhouse": "WITH base AS (\n SELECT\n dateTrunc('DAY', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('DAY', ev.ts)\n), shifted_x AS (\n SELECT\n dateTrunc('DAY', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('DAY', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON addDays(base.\"ev.ts\", 1) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|day|1::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('DAY', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('DAY', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('DAY', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('DAY', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON base.\"ev.ts\" + INTERVAL 1 DAY IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|day|1::mysql": "WITH base AS (\n SELECT\n DATE(ev.ts) AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n DATE(ev.ts)\n), shifted_x AS (\n SELECT\n DATE(ev.ts) AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n DATE(ev.ts)\n), sjoin_x AS (\n SELECT\n base.`ev.ts`,\n base.`ev.v_sum`,\n shifted_x.`ev.v_sum` AS `ev.x`\n FROM base\n LEFT JOIN shifted_x\n ON DATE_ADD(base.`ev.ts`, INTERVAL 1 DAY) <=> shifted_x.`ev.ts`\n)\nSELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\nFROM (\n SELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\n FROM sjoin_x\n) AS _outer", @@ -23,7 +23,7 @@ "shift|day|1::snowflake": "WITH base AS (\n SELECT\n DATE_TRUNC('DAY', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('DAY', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('DAY', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('DAY', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON DATEADD(DAY, 1, base.\"ev.ts\") IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|day|1::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-%d', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-%d', ev.ts)\n), shifted_x AS (\n SELECT\n STRFTIME('%Y-%m-%d', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-%d', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON SLAYER_DATE_ADD(base.\"ev.ts\", 1, 'day') IS shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|day|1::tsql": "WITH base AS (\n SELECT\n DATETRUNC(day, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(day, ev.ts)\n), shifted_x AS (\n SELECT\n DATETRUNC(day, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(day, ev.ts)\n), sjoin_x AS (\n SELECT\n base.[ev___ts] AS [ev___ts],\n base.[ev___v_sum] AS [ev___v_sum],\n shifted_x.[ev___v_sum] AS [ev___x]\n FROM base\n LEFT JOIN shifted_x\n ON (\n (\n DATEADD(DAY, 1, base.[ev___ts]) = shifted_x.[ev___ts]\n AND NOT DATEADD(DAY, 1, base.[ev___ts]) IS NULL\n AND NOT shifted_x.[ev___ts] IS NULL\n )\n OR (\n DATEADD(DAY, 1, base.[ev___ts]) IS NULL AND shifted_x.[ev___ts] IS NULL\n )\n )\n)\nSELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\nFROM (\n SELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\n FROM sjoin_x\n) AS _outer", - "shift|hour|-1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, HOUR) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, HOUR)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, HOUR) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, HOUR)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON TIMESTAMP_ADD(CAST(base.`ev___ts` AS TIMESTAMP), INTERVAL -1 HOUR) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS TIMESTAMP)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", + "shift|hour|-1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, HOUR) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, HOUR)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, HOUR) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, HOUR)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON DATETIME_ADD(CAST(base.`ev___ts` AS DATETIME), INTERVAL -1 HOUR) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS DATETIME)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", "shift|hour|-1::clickhouse": "WITH base AS (\n SELECT\n dateTrunc('HOUR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('HOUR', ev.ts)\n), shifted_x AS (\n SELECT\n dateTrunc('HOUR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('HOUR', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON addHours(base.\"ev.ts\", -1) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|hour|-1::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('HOUR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('HOUR', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('HOUR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('HOUR', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON base.\"ev.ts\" - INTERVAL 1 HOUR IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|hour|-1::mysql": "WITH base AS (\n SELECT\n CAST(DATE_FORMAT(ev.ts, '%Y-%m-%d %H:00:00') AS DATETIME) AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n CAST(DATE_FORMAT(ev.ts, '%Y-%m-%d %H:00:00') AS DATETIME)\n), shifted_x AS (\n SELECT\n CAST(DATE_FORMAT(ev.ts, '%Y-%m-%d %H:00:00') AS DATETIME) AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n CAST(DATE_FORMAT(ev.ts, '%Y-%m-%d %H:00:00') AS DATETIME)\n), sjoin_x AS (\n SELECT\n base.`ev.ts`,\n base.`ev.v_sum`,\n shifted_x.`ev.v_sum` AS `ev.x`\n FROM base\n LEFT JOIN shifted_x\n ON DATE_ADD(base.`ev.ts`, INTERVAL -1 HOUR) <=> shifted_x.`ev.ts`\n)\nSELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\nFROM (\n SELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\n FROM sjoin_x\n) AS _outer", @@ -31,7 +31,7 @@ "shift|hour|-1::snowflake": "WITH base AS (\n SELECT\n DATE_TRUNC('HOUR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('HOUR', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('HOUR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('HOUR', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON DATEADD(HOUR, -1, base.\"ev.ts\") IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|hour|-1::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-%d %H:00:00', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-%d %H:00:00', ev.ts)\n), shifted_x AS (\n SELECT\n STRFTIME('%Y-%m-%d %H:00:00', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-%d %H:00:00', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON SLAYER_DATE_ADD(base.\"ev.ts\", -1, 'hour') IS shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|hour|-1::tsql": "WITH base AS (\n SELECT\n DATETRUNC(hour, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(hour, ev.ts)\n), shifted_x AS (\n SELECT\n DATETRUNC(hour, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(hour, ev.ts)\n), sjoin_x AS (\n SELECT\n base.[ev___ts] AS [ev___ts],\n base.[ev___v_sum] AS [ev___v_sum],\n shifted_x.[ev___v_sum] AS [ev___x]\n FROM base\n LEFT JOIN shifted_x\n ON (\n (\n DATEADD(HOUR, -1, base.[ev___ts]) = shifted_x.[ev___ts]\n AND NOT DATEADD(HOUR, -1, base.[ev___ts]) IS NULL\n AND NOT shifted_x.[ev___ts] IS NULL\n )\n OR (\n DATEADD(HOUR, -1, base.[ev___ts]) IS NULL AND shifted_x.[ev___ts] IS NULL\n )\n )\n)\nSELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\nFROM (\n SELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\n FROM sjoin_x\n) AS _outer", - "shift|hour|1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, HOUR) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, HOUR)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, HOUR) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, HOUR)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON TIMESTAMP_ADD(CAST(base.`ev___ts` AS TIMESTAMP), INTERVAL 1 HOUR) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS TIMESTAMP)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", + "shift|hour|1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, HOUR) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, HOUR)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, HOUR) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, HOUR)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON DATETIME_ADD(CAST(base.`ev___ts` AS DATETIME), INTERVAL 1 HOUR) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS DATETIME)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", "shift|hour|1::clickhouse": "WITH base AS (\n SELECT\n dateTrunc('HOUR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('HOUR', ev.ts)\n), shifted_x AS (\n SELECT\n dateTrunc('HOUR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('HOUR', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON addHours(base.\"ev.ts\", 1) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|hour|1::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('HOUR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('HOUR', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('HOUR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('HOUR', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON base.\"ev.ts\" + INTERVAL 1 HOUR IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|hour|1::mysql": "WITH base AS (\n SELECT\n CAST(DATE_FORMAT(ev.ts, '%Y-%m-%d %H:00:00') AS DATETIME) AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n CAST(DATE_FORMAT(ev.ts, '%Y-%m-%d %H:00:00') AS DATETIME)\n), shifted_x AS (\n SELECT\n CAST(DATE_FORMAT(ev.ts, '%Y-%m-%d %H:00:00') AS DATETIME) AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n CAST(DATE_FORMAT(ev.ts, '%Y-%m-%d %H:00:00') AS DATETIME)\n), sjoin_x AS (\n SELECT\n base.`ev.ts`,\n base.`ev.v_sum`,\n shifted_x.`ev.v_sum` AS `ev.x`\n FROM base\n LEFT JOIN shifted_x\n ON DATE_ADD(base.`ev.ts`, INTERVAL 1 HOUR) <=> shifted_x.`ev.ts`\n)\nSELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\nFROM (\n SELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\n FROM sjoin_x\n) AS _outer", @@ -39,7 +39,7 @@ "shift|hour|1::snowflake": "WITH base AS (\n SELECT\n DATE_TRUNC('HOUR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('HOUR', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('HOUR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('HOUR', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON DATEADD(HOUR, 1, base.\"ev.ts\") IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|hour|1::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-%d %H:00:00', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-%d %H:00:00', ev.ts)\n), shifted_x AS (\n SELECT\n STRFTIME('%Y-%m-%d %H:00:00', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-%d %H:00:00', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON SLAYER_DATE_ADD(base.\"ev.ts\", 1, 'hour') IS shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|hour|1::tsql": "WITH base AS (\n SELECT\n DATETRUNC(hour, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(hour, ev.ts)\n), shifted_x AS (\n SELECT\n DATETRUNC(hour, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(hour, ev.ts)\n), sjoin_x AS (\n SELECT\n base.[ev___ts] AS [ev___ts],\n base.[ev___v_sum] AS [ev___v_sum],\n shifted_x.[ev___v_sum] AS [ev___x]\n FROM base\n LEFT JOIN shifted_x\n ON (\n (\n DATEADD(HOUR, 1, base.[ev___ts]) = shifted_x.[ev___ts]\n AND NOT DATEADD(HOUR, 1, base.[ev___ts]) IS NULL\n AND NOT shifted_x.[ev___ts] IS NULL\n )\n OR (\n DATEADD(HOUR, 1, base.[ev___ts]) IS NULL AND shifted_x.[ev___ts] IS NULL\n )\n )\n)\nSELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\nFROM (\n SELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\n FROM sjoin_x\n) AS _outer", - "shift|month|-1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, MONTH) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, MONTH)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, MONTH) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, MONTH)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON CAST(DATETIME_ADD(CAST(CAST(base.`ev___ts` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS TIMESTAMP)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", + "shift|month|-1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, MONTH) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, MONTH)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, MONTH) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, MONTH)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON DATETIME_ADD(CAST(base.`ev___ts` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS DATETIME)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", "shift|month|-1::clickhouse": "WITH base AS (\n SELECT\n dateTrunc('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('MONTH', ev.ts)\n), shifted_x AS (\n SELECT\n dateTrunc('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('MONTH', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON addMonths(base.\"ev.ts\", -1) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|month|-1::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('MONTH', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('MONTH', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON base.\"ev.ts\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|month|-1::mysql": "WITH base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', MONTH(ev.ts), ' 1'), '%Y %c %e') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', MONTH(ev.ts), ' 1'), '%Y %c %e')\n), shifted_x AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', MONTH(ev.ts), ' 1'), '%Y %c %e') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', MONTH(ev.ts), ' 1'), '%Y %c %e')\n), sjoin_x AS (\n SELECT\n base.`ev.ts`,\n base.`ev.v_sum`,\n shifted_x.`ev.v_sum` AS `ev.x`\n FROM base\n LEFT JOIN shifted_x\n ON DATE_ADD(base.`ev.ts`, INTERVAL -1 MONTH) <=> shifted_x.`ev.ts`\n)\nSELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\nFROM (\n SELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\n FROM sjoin_x\n) AS _outer", @@ -47,7 +47,7 @@ "shift|month|-1::snowflake": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('MONTH', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('MONTH', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON DATEADD(MONTH, -1, base.\"ev.ts\") IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|month|-1::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-01', ev.ts)\n), shifted_x AS (\n SELECT\n STRFTIME('%Y-%m-01', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-01', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON SLAYER_DATE_ADD(base.\"ev.ts\", -1, 'month') IS shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|month|-1::tsql": "WITH base AS (\n SELECT\n DATETRUNC(month, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(month, ev.ts)\n), shifted_x AS (\n SELECT\n DATETRUNC(month, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(month, ev.ts)\n), sjoin_x AS (\n SELECT\n base.[ev___ts] AS [ev___ts],\n base.[ev___v_sum] AS [ev___v_sum],\n shifted_x.[ev___v_sum] AS [ev___x]\n FROM base\n LEFT JOIN shifted_x\n ON (\n (\n DATEADD(MONTH, -1, base.[ev___ts]) = shifted_x.[ev___ts]\n AND NOT DATEADD(MONTH, -1, base.[ev___ts]) IS NULL\n AND NOT shifted_x.[ev___ts] IS NULL\n )\n OR (\n DATEADD(MONTH, -1, base.[ev___ts]) IS NULL AND shifted_x.[ev___ts] IS NULL\n )\n )\n)\nSELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\nFROM (\n SELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\n FROM sjoin_x\n) AS _outer", - "shift|month|1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, MONTH) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, MONTH)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, MONTH) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, MONTH)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON CAST(DATETIME_ADD(CAST(CAST(base.`ev___ts` AS TIMESTAMP) AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS TIMESTAMP)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", + "shift|month|1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, MONTH) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, MONTH)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, MONTH) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, MONTH)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON DATETIME_ADD(CAST(base.`ev___ts` AS DATETIME), INTERVAL 1 MONTH) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS DATETIME)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", "shift|month|1::clickhouse": "WITH base AS (\n SELECT\n dateTrunc('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('MONTH', ev.ts)\n), shifted_x AS (\n SELECT\n dateTrunc('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('MONTH', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON addMonths(base.\"ev.ts\", 1) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|month|1::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('MONTH', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('MONTH', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON base.\"ev.ts\" + INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|month|1::mysql": "WITH base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', MONTH(ev.ts), ' 1'), '%Y %c %e') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', MONTH(ev.ts), ' 1'), '%Y %c %e')\n), shifted_x AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', MONTH(ev.ts), ' 1'), '%Y %c %e') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', MONTH(ev.ts), ' 1'), '%Y %c %e')\n), sjoin_x AS (\n SELECT\n base.`ev.ts`,\n base.`ev.v_sum`,\n shifted_x.`ev.v_sum` AS `ev.x`\n FROM base\n LEFT JOIN shifted_x\n ON DATE_ADD(base.`ev.ts`, INTERVAL 1 MONTH) <=> shifted_x.`ev.ts`\n)\nSELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\nFROM (\n SELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\n FROM sjoin_x\n) AS _outer", @@ -55,7 +55,7 @@ "shift|month|1::snowflake": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('MONTH', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('MONTH', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('MONTH', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON DATEADD(MONTH, 1, base.\"ev.ts\") IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|month|1::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-01', ev.ts)\n), shifted_x AS (\n SELECT\n STRFTIME('%Y-%m-01', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-01', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON SLAYER_DATE_ADD(base.\"ev.ts\", 1, 'month') IS shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|month|1::tsql": "WITH base AS (\n SELECT\n DATETRUNC(month, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(month, ev.ts)\n), shifted_x AS (\n SELECT\n DATETRUNC(month, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(month, ev.ts)\n), sjoin_x AS (\n SELECT\n base.[ev___ts] AS [ev___ts],\n base.[ev___v_sum] AS [ev___v_sum],\n shifted_x.[ev___v_sum] AS [ev___x]\n FROM base\n LEFT JOIN shifted_x\n ON (\n (\n DATEADD(MONTH, 1, base.[ev___ts]) = shifted_x.[ev___ts]\n AND NOT DATEADD(MONTH, 1, base.[ev___ts]) IS NULL\n AND NOT shifted_x.[ev___ts] IS NULL\n )\n OR (\n DATEADD(MONTH, 1, base.[ev___ts]) IS NULL AND shifted_x.[ev___ts] IS NULL\n )\n )\n)\nSELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\nFROM (\n SELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\n FROM sjoin_x\n) AS _outer", - "shift|quarter|-1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, QUARTER) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, QUARTER)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, QUARTER) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, QUARTER)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON CAST(DATETIME_ADD(CAST(CAST(base.`ev___ts` AS TIMESTAMP) AS DATETIME), INTERVAL -1 QUARTER) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS TIMESTAMP)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", + "shift|quarter|-1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, QUARTER) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, QUARTER)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, QUARTER) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, QUARTER)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON DATETIME_ADD(CAST(base.`ev___ts` AS DATETIME), INTERVAL -1 QUARTER) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS DATETIME)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", "shift|quarter|-1::clickhouse": "WITH base AS (\n SELECT\n dateTrunc('QUARTER', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('QUARTER', ev.ts)\n), shifted_x AS (\n SELECT\n dateTrunc('QUARTER', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('QUARTER', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON addQuarters(base.\"ev.ts\", -1) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|quarter|-1::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('QUARTER', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('QUARTER', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('QUARTER', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('QUARTER', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON base.\"ev.ts\" - INTERVAL 3 MONTH IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|quarter|-1::mysql": "WITH base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', QUARTER(ev.ts) * 3 - 2, ' 1'), '%Y %c %e') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', QUARTER(ev.ts) * 3 - 2, ' 1'), '%Y %c %e')\n), shifted_x AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', QUARTER(ev.ts) * 3 - 2, ' 1'), '%Y %c %e') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', QUARTER(ev.ts) * 3 - 2, ' 1'), '%Y %c %e')\n), sjoin_x AS (\n SELECT\n base.`ev.ts`,\n base.`ev.v_sum`,\n shifted_x.`ev.v_sum` AS `ev.x`\n FROM base\n LEFT JOIN shifted_x\n ON DATE_ADD(base.`ev.ts`, INTERVAL -1 QUARTER) <=> shifted_x.`ev.ts`\n)\nSELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\nFROM (\n SELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\n FROM sjoin_x\n) AS _outer", @@ -63,7 +63,7 @@ "shift|quarter|-1::snowflake": "WITH base AS (\n SELECT\n DATE_TRUNC('QUARTER', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('QUARTER', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('QUARTER', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('QUARTER', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON DATEADD(QUARTER, -1, base.\"ev.ts\") IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|quarter|-1::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-', ev.ts) || CASE\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 3\n THEN '01-01'\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 6\n THEN '04-01'\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 9\n THEN '07-01'\n ELSE '10-01'\n END AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-', ev.ts) || CASE\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 3\n THEN '01-01'\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 6\n THEN '04-01'\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 9\n THEN '07-01'\n ELSE '10-01'\n END\n), shifted_x AS (\n SELECT\n STRFTIME('%Y-', ev.ts) || CASE\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 3\n THEN '01-01'\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 6\n THEN '04-01'\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 9\n THEN '07-01'\n ELSE '10-01'\n END AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-', ev.ts) || CASE\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 3\n THEN '01-01'\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 6\n THEN '04-01'\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 9\n THEN '07-01'\n ELSE '10-01'\n END\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON SLAYER_DATE_ADD(base.\"ev.ts\", -1, 'quarter') IS shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|quarter|-1::tsql": "WITH base AS (\n SELECT\n DATETRUNC(quarter, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(quarter, ev.ts)\n), shifted_x AS (\n SELECT\n DATETRUNC(quarter, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(quarter, ev.ts)\n), sjoin_x AS (\n SELECT\n base.[ev___ts] AS [ev___ts],\n base.[ev___v_sum] AS [ev___v_sum],\n shifted_x.[ev___v_sum] AS [ev___x]\n FROM base\n LEFT JOIN shifted_x\n ON (\n (\n DATEADD(QUARTER, -1, base.[ev___ts]) = shifted_x.[ev___ts]\n AND NOT DATEADD(QUARTER, -1, base.[ev___ts]) IS NULL\n AND NOT shifted_x.[ev___ts] IS NULL\n )\n OR (\n DATEADD(QUARTER, -1, base.[ev___ts]) IS NULL AND shifted_x.[ev___ts] IS NULL\n )\n )\n)\nSELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\nFROM (\n SELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\n FROM sjoin_x\n) AS _outer", - "shift|quarter|1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, QUARTER) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, QUARTER)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, QUARTER) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, QUARTER)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON CAST(DATETIME_ADD(CAST(CAST(base.`ev___ts` AS TIMESTAMP) AS DATETIME), INTERVAL 1 QUARTER) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS TIMESTAMP)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", + "shift|quarter|1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, QUARTER) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, QUARTER)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, QUARTER) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, QUARTER)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON DATETIME_ADD(CAST(base.`ev___ts` AS DATETIME), INTERVAL 1 QUARTER) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS DATETIME)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", "shift|quarter|1::clickhouse": "WITH base AS (\n SELECT\n dateTrunc('QUARTER', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('QUARTER', ev.ts)\n), shifted_x AS (\n SELECT\n dateTrunc('QUARTER', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('QUARTER', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON addQuarters(base.\"ev.ts\", 1) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|quarter|1::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('QUARTER', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('QUARTER', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('QUARTER', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('QUARTER', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON base.\"ev.ts\" + INTERVAL 3 MONTH IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|quarter|1::mysql": "WITH base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', QUARTER(ev.ts) * 3 - 2, ' 1'), '%Y %c %e') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', QUARTER(ev.ts) * 3 - 2, ' 1'), '%Y %c %e')\n), shifted_x AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', QUARTER(ev.ts) * 3 - 2, ' 1'), '%Y %c %e') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', QUARTER(ev.ts) * 3 - 2, ' 1'), '%Y %c %e')\n), sjoin_x AS (\n SELECT\n base.`ev.ts`,\n base.`ev.v_sum`,\n shifted_x.`ev.v_sum` AS `ev.x`\n FROM base\n LEFT JOIN shifted_x\n ON DATE_ADD(base.`ev.ts`, INTERVAL 1 QUARTER) <=> shifted_x.`ev.ts`\n)\nSELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\nFROM (\n SELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\n FROM sjoin_x\n) AS _outer", @@ -71,7 +71,7 @@ "shift|quarter|1::snowflake": "WITH base AS (\n SELECT\n DATE_TRUNC('QUARTER', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('QUARTER', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('QUARTER', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('QUARTER', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON DATEADD(QUARTER, 1, base.\"ev.ts\") IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|quarter|1::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-', ev.ts) || CASE\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 3\n THEN '01-01'\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 6\n THEN '04-01'\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 9\n THEN '07-01'\n ELSE '10-01'\n END AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-', ev.ts) || CASE\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 3\n THEN '01-01'\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 6\n THEN '04-01'\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 9\n THEN '07-01'\n ELSE '10-01'\n END\n), shifted_x AS (\n SELECT\n STRFTIME('%Y-', ev.ts) || CASE\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 3\n THEN '01-01'\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 6\n THEN '04-01'\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 9\n THEN '07-01'\n ELSE '10-01'\n END AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-', ev.ts) || CASE\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 3\n THEN '01-01'\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 6\n THEN '04-01'\n WHEN CAST(STRFTIME('%m', ev.ts) AS INTEGER) <= 9\n THEN '07-01'\n ELSE '10-01'\n END\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON SLAYER_DATE_ADD(base.\"ev.ts\", 1, 'quarter') IS shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|quarter|1::tsql": "WITH base AS (\n SELECT\n DATETRUNC(quarter, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(quarter, ev.ts)\n), shifted_x AS (\n SELECT\n DATETRUNC(quarter, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(quarter, ev.ts)\n), sjoin_x AS (\n SELECT\n base.[ev___ts] AS [ev___ts],\n base.[ev___v_sum] AS [ev___v_sum],\n shifted_x.[ev___v_sum] AS [ev___x]\n FROM base\n LEFT JOIN shifted_x\n ON (\n (\n DATEADD(QUARTER, 1, base.[ev___ts]) = shifted_x.[ev___ts]\n AND NOT DATEADD(QUARTER, 1, base.[ev___ts]) IS NULL\n AND NOT shifted_x.[ev___ts] IS NULL\n )\n OR (\n DATEADD(QUARTER, 1, base.[ev___ts]) IS NULL AND shifted_x.[ev___ts] IS NULL\n )\n )\n)\nSELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\nFROM (\n SELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\n FROM sjoin_x\n) AS _outer", - "shift|week_sunday|-1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(SUNDAY)) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(SUNDAY))\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(SUNDAY)) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(SUNDAY))\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON TIMESTAMP_ADD(CAST(base.`ev___ts` AS TIMESTAMP), INTERVAL ((\n -1\n ) * 7) DAY) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS TIMESTAMP)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", + "shift|week_sunday|-1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(SUNDAY)) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(SUNDAY))\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(SUNDAY)) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(SUNDAY))\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON DATETIME_ADD(CAST(base.`ev___ts` AS DATETIME), INTERVAL ((\n -1\n ) * 7) DAY) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS DATETIME)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", "shift|week_sunday|-1::clickhouse": "WITH base AS (\n SELECT\n addDays(dateTrunc('WEEK', CAST(addDays(ev.ts, 1) AS Nullable(DateTime))), -1) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n addDays(dateTrunc('WEEK', CAST(addDays(ev.ts, 1) AS Nullable(DateTime))), -1)\n), shifted_x AS (\n SELECT\n addDays(dateTrunc('WEEK', CAST(addDays(ev.ts, 1) AS Nullable(DateTime))), -1) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n addDays(dateTrunc('WEEK', CAST(addDays(ev.ts, 1) AS Nullable(DateTime))), -1)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON addWeeks(base.\"ev.ts\", -1) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|week_sunday|-1::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('WEEK', CAST(ev.ts + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('WEEK', CAST(ev.ts + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY\n), shifted_x AS (\n SELECT\n DATE_TRUNC('WEEK', CAST(ev.ts + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('WEEK', CAST(ev.ts + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON base.\"ev.ts\" - INTERVAL 1 WEEK IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|week_sunday|-1::mysql": "WITH base AS (\n SELECT\n DATE_ADD(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(ev.ts, INTERVAL 1 DAY) AS DATETIME)), ' ', WEEK(CAST(DATE_ADD(ev.ts, INTERVAL 1 DAY) AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n INTERVAL -1 DAY\n ) AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_ADD(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(ev.ts, INTERVAL 1 DAY) AS DATETIME)), ' ', WEEK(CAST(DATE_ADD(ev.ts, INTERVAL 1 DAY) AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n INTERVAL -1 DAY\n )\n), shifted_x AS (\n SELECT\n DATE_ADD(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(ev.ts, INTERVAL 1 DAY) AS DATETIME)), ' ', WEEK(CAST(DATE_ADD(ev.ts, INTERVAL 1 DAY) AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n INTERVAL -1 DAY\n ) AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_ADD(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(ev.ts, INTERVAL 1 DAY) AS DATETIME)), ' ', WEEK(CAST(DATE_ADD(ev.ts, INTERVAL 1 DAY) AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n INTERVAL -1 DAY\n )\n), sjoin_x AS (\n SELECT\n base.`ev.ts`,\n base.`ev.v_sum`,\n shifted_x.`ev.v_sum` AS `ev.x`\n FROM base\n LEFT JOIN shifted_x\n ON DATE_ADD(base.`ev.ts`, INTERVAL -1 WEEK) <=> shifted_x.`ev.ts`\n)\nSELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\nFROM (\n SELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\n FROM sjoin_x\n) AS _outer", @@ -79,7 +79,7 @@ "shift|week_sunday|-1::snowflake": "WITH base AS (\n SELECT\n DATEADD(DAY, -1, DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, ev.ts) AS TIMESTAMP))) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATEADD(DAY, -1, DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, ev.ts) AS TIMESTAMP)))\n), shifted_x AS (\n SELECT\n DATEADD(DAY, -1, DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, ev.ts) AS TIMESTAMP))) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATEADD(DAY, -1, DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, ev.ts) AS TIMESTAMP)))\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON DATEADD(WEEK, -1, base.\"ev.ts\") IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|week_sunday|-1::sqlite": "WITH base AS (\n SELECT\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(ev.ts, 1, 'day'), 'weekday 0', '-6 days'), -1, 'day') AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(ev.ts, 1, 'day'), 'weekday 0', '-6 days'), -1, 'day')\n), shifted_x AS (\n SELECT\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(ev.ts, 1, 'day'), 'weekday 0', '-6 days'), -1, 'day') AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(ev.ts, 1, 'day'), 'weekday 0', '-6 days'), -1, 'day')\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON SLAYER_DATE_ADD(base.\"ev.ts\", -1, 'week_sunday') IS shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|week_sunday|-1::tsql": "WITH base AS (\n SELECT\n DATEADD(DAY, -1, DATETRUNC(iso_week, CAST(DATEADD(DAY, 1, ev.ts) AS DATETIME2))) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATEADD(DAY, -1, DATETRUNC(iso_week, CAST(DATEADD(DAY, 1, ev.ts) AS DATETIME2)))\n), shifted_x AS (\n SELECT\n DATEADD(DAY, -1, DATETRUNC(iso_week, CAST(DATEADD(DAY, 1, ev.ts) AS DATETIME2))) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATEADD(DAY, -1, DATETRUNC(iso_week, CAST(DATEADD(DAY, 1, ev.ts) AS DATETIME2)))\n), sjoin_x AS (\n SELECT\n base.[ev___ts] AS [ev___ts],\n base.[ev___v_sum] AS [ev___v_sum],\n shifted_x.[ev___v_sum] AS [ev___x]\n FROM base\n LEFT JOIN shifted_x\n ON (\n (\n DATEADD(WEEK, -1, base.[ev___ts]) = shifted_x.[ev___ts]\n AND NOT DATEADD(WEEK, -1, base.[ev___ts]) IS NULL\n AND NOT shifted_x.[ev___ts] IS NULL\n )\n OR (\n DATEADD(WEEK, -1, base.[ev___ts]) IS NULL AND shifted_x.[ev___ts] IS NULL\n )\n )\n)\nSELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\nFROM (\n SELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\n FROM sjoin_x\n) AS _outer", - "shift|week_sunday|1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(SUNDAY)) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(SUNDAY))\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(SUNDAY)) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(SUNDAY))\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON TIMESTAMP_ADD(CAST(base.`ev___ts` AS TIMESTAMP), INTERVAL ((\n 1\n ) * 7) DAY) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS TIMESTAMP)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", + "shift|week_sunday|1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(SUNDAY)) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(SUNDAY))\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(SUNDAY)) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(SUNDAY))\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON DATETIME_ADD(CAST(base.`ev___ts` AS DATETIME), INTERVAL ((\n 1\n ) * 7) DAY) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS DATETIME)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", "shift|week_sunday|1::clickhouse": "WITH base AS (\n SELECT\n addDays(dateTrunc('WEEK', CAST(addDays(ev.ts, 1) AS Nullable(DateTime))), -1) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n addDays(dateTrunc('WEEK', CAST(addDays(ev.ts, 1) AS Nullable(DateTime))), -1)\n), shifted_x AS (\n SELECT\n addDays(dateTrunc('WEEK', CAST(addDays(ev.ts, 1) AS Nullable(DateTime))), -1) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n addDays(dateTrunc('WEEK', CAST(addDays(ev.ts, 1) AS Nullable(DateTime))), -1)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON addWeeks(base.\"ev.ts\", 1) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|week_sunday|1::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('WEEK', CAST(ev.ts + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('WEEK', CAST(ev.ts + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY\n), shifted_x AS (\n SELECT\n DATE_TRUNC('WEEK', CAST(ev.ts + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('WEEK', CAST(ev.ts + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON base.\"ev.ts\" + INTERVAL 1 WEEK IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|week_sunday|1::mysql": "WITH base AS (\n SELECT\n DATE_ADD(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(ev.ts, INTERVAL 1 DAY) AS DATETIME)), ' ', WEEK(CAST(DATE_ADD(ev.ts, INTERVAL 1 DAY) AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n INTERVAL -1 DAY\n ) AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_ADD(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(ev.ts, INTERVAL 1 DAY) AS DATETIME)), ' ', WEEK(CAST(DATE_ADD(ev.ts, INTERVAL 1 DAY) AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n INTERVAL -1 DAY\n )\n), shifted_x AS (\n SELECT\n DATE_ADD(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(ev.ts, INTERVAL 1 DAY) AS DATETIME)), ' ', WEEK(CAST(DATE_ADD(ev.ts, INTERVAL 1 DAY) AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n INTERVAL -1 DAY\n ) AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_ADD(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(ev.ts, INTERVAL 1 DAY) AS DATETIME)), ' ', WEEK(CAST(DATE_ADD(ev.ts, INTERVAL 1 DAY) AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n INTERVAL -1 DAY\n )\n), sjoin_x AS (\n SELECT\n base.`ev.ts`,\n base.`ev.v_sum`,\n shifted_x.`ev.v_sum` AS `ev.x`\n FROM base\n LEFT JOIN shifted_x\n ON DATE_ADD(base.`ev.ts`, INTERVAL 1 WEEK) <=> shifted_x.`ev.ts`\n)\nSELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\nFROM (\n SELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\n FROM sjoin_x\n) AS _outer", @@ -87,7 +87,7 @@ "shift|week_sunday|1::snowflake": "WITH base AS (\n SELECT\n DATEADD(DAY, -1, DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, ev.ts) AS TIMESTAMP))) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATEADD(DAY, -1, DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, ev.ts) AS TIMESTAMP)))\n), shifted_x AS (\n SELECT\n DATEADD(DAY, -1, DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, ev.ts) AS TIMESTAMP))) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATEADD(DAY, -1, DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, ev.ts) AS TIMESTAMP)))\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON DATEADD(WEEK, 1, base.\"ev.ts\") IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|week_sunday|1::sqlite": "WITH base AS (\n SELECT\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(ev.ts, 1, 'day'), 'weekday 0', '-6 days'), -1, 'day') AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(ev.ts, 1, 'day'), 'weekday 0', '-6 days'), -1, 'day')\n), shifted_x AS (\n SELECT\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(ev.ts, 1, 'day'), 'weekday 0', '-6 days'), -1, 'day') AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(ev.ts, 1, 'day'), 'weekday 0', '-6 days'), -1, 'day')\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON SLAYER_DATE_ADD(base.\"ev.ts\", 1, 'week_sunday') IS shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|week_sunday|1::tsql": "WITH base AS (\n SELECT\n DATEADD(DAY, -1, DATETRUNC(iso_week, CAST(DATEADD(DAY, 1, ev.ts) AS DATETIME2))) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATEADD(DAY, -1, DATETRUNC(iso_week, CAST(DATEADD(DAY, 1, ev.ts) AS DATETIME2)))\n), shifted_x AS (\n SELECT\n DATEADD(DAY, -1, DATETRUNC(iso_week, CAST(DATEADD(DAY, 1, ev.ts) AS DATETIME2))) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATEADD(DAY, -1, DATETRUNC(iso_week, CAST(DATEADD(DAY, 1, ev.ts) AS DATETIME2)))\n), sjoin_x AS (\n SELECT\n base.[ev___ts] AS [ev___ts],\n base.[ev___v_sum] AS [ev___v_sum],\n shifted_x.[ev___v_sum] AS [ev___x]\n FROM base\n LEFT JOIN shifted_x\n ON (\n (\n DATEADD(WEEK, 1, base.[ev___ts]) = shifted_x.[ev___ts]\n AND NOT DATEADD(WEEK, 1, base.[ev___ts]) IS NULL\n AND NOT shifted_x.[ev___ts] IS NULL\n )\n OR (\n DATEADD(WEEK, 1, base.[ev___ts]) IS NULL AND shifted_x.[ev___ts] IS NULL\n )\n )\n)\nSELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\nFROM (\n SELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\n FROM sjoin_x\n) AS _outer", - "shift|week|-1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(MONDAY)) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(MONDAY))\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(MONDAY)) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(MONDAY))\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON TIMESTAMP_ADD(CAST(base.`ev___ts` AS TIMESTAMP), INTERVAL ((\n -1\n ) * 7) DAY) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS TIMESTAMP)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", + "shift|week|-1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(MONDAY)) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(MONDAY))\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(MONDAY)) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(MONDAY))\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON DATETIME_ADD(CAST(base.`ev___ts` AS DATETIME), INTERVAL ((\n -1\n ) * 7) DAY) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS DATETIME)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", "shift|week|-1::clickhouse": "WITH base AS (\n SELECT\n dateTrunc('WEEK', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('WEEK', ev.ts)\n), shifted_x AS (\n SELECT\n dateTrunc('WEEK', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('WEEK', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON addWeeks(base.\"ev.ts\", -1) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|week|-1::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('WEEK', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('WEEK', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('WEEK', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('WEEK', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON base.\"ev.ts\" - INTERVAL 1 WEEK IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|week|-1::mysql": "WITH base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', WEEK(ev.ts, 1), ' 1'), '%Y %u %w') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', WEEK(ev.ts, 1), ' 1'), '%Y %u %w')\n), shifted_x AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', WEEK(ev.ts, 1), ' 1'), '%Y %u %w') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', WEEK(ev.ts, 1), ' 1'), '%Y %u %w')\n), sjoin_x AS (\n SELECT\n base.`ev.ts`,\n base.`ev.v_sum`,\n shifted_x.`ev.v_sum` AS `ev.x`\n FROM base\n LEFT JOIN shifted_x\n ON DATE_ADD(base.`ev.ts`, INTERVAL -1 WEEK) <=> shifted_x.`ev.ts`\n)\nSELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\nFROM (\n SELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\n FROM sjoin_x\n) AS _outer", @@ -95,7 +95,7 @@ "shift|week|-1::snowflake": "WITH base AS (\n SELECT\n DATE_TRUNC('WEEK', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('WEEK', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('WEEK', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('WEEK', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON DATEADD(WEEK, -1, base.\"ev.ts\") IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|week|-1::sqlite": "WITH base AS (\n SELECT\n DATE(ev.ts, 'weekday 0', '-6 days') AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE(ev.ts, 'weekday 0', '-6 days')\n), shifted_x AS (\n SELECT\n DATE(ev.ts, 'weekday 0', '-6 days') AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE(ev.ts, 'weekday 0', '-6 days')\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON SLAYER_DATE_ADD(base.\"ev.ts\", -1, 'week') IS shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|week|-1::tsql": "WITH base AS (\n SELECT\n DATETRUNC(iso_week, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(iso_week, ev.ts)\n), shifted_x AS (\n SELECT\n DATETRUNC(iso_week, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(iso_week, ev.ts)\n), sjoin_x AS (\n SELECT\n base.[ev___ts] AS [ev___ts],\n base.[ev___v_sum] AS [ev___v_sum],\n shifted_x.[ev___v_sum] AS [ev___x]\n FROM base\n LEFT JOIN shifted_x\n ON (\n (\n DATEADD(WEEK, -1, base.[ev___ts]) = shifted_x.[ev___ts]\n AND NOT DATEADD(WEEK, -1, base.[ev___ts]) IS NULL\n AND NOT shifted_x.[ev___ts] IS NULL\n )\n OR (\n DATEADD(WEEK, -1, base.[ev___ts]) IS NULL AND shifted_x.[ev___ts] IS NULL\n )\n )\n)\nSELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\nFROM (\n SELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\n FROM sjoin_x\n) AS _outer", - "shift|week|1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(MONDAY)) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(MONDAY))\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(MONDAY)) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(MONDAY))\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON TIMESTAMP_ADD(CAST(base.`ev___ts` AS TIMESTAMP), INTERVAL ((\n 1\n ) * 7) DAY) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS TIMESTAMP)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", + "shift|week|1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(MONDAY)) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(MONDAY))\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(MONDAY)) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(MONDAY))\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON DATETIME_ADD(CAST(base.`ev___ts` AS DATETIME), INTERVAL ((\n 1\n ) * 7) DAY) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS DATETIME)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", "shift|week|1::clickhouse": "WITH base AS (\n SELECT\n dateTrunc('WEEK', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('WEEK', ev.ts)\n), shifted_x AS (\n SELECT\n dateTrunc('WEEK', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('WEEK', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON addWeeks(base.\"ev.ts\", 1) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|week|1::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('WEEK', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('WEEK', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('WEEK', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('WEEK', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON base.\"ev.ts\" + INTERVAL 1 WEEK IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|week|1::mysql": "WITH base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', WEEK(ev.ts, 1), ' 1'), '%Y %u %w') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', WEEK(ev.ts, 1), ' 1'), '%Y %u %w')\n), shifted_x AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', WEEK(ev.ts, 1), ' 1'), '%Y %u %w') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', WEEK(ev.ts, 1), ' 1'), '%Y %u %w')\n), sjoin_x AS (\n SELECT\n base.`ev.ts`,\n base.`ev.v_sum`,\n shifted_x.`ev.v_sum` AS `ev.x`\n FROM base\n LEFT JOIN shifted_x\n ON DATE_ADD(base.`ev.ts`, INTERVAL 1 WEEK) <=> shifted_x.`ev.ts`\n)\nSELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\nFROM (\n SELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\n FROM sjoin_x\n) AS _outer", @@ -103,7 +103,7 @@ "shift|week|1::snowflake": "WITH base AS (\n SELECT\n DATE_TRUNC('WEEK', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('WEEK', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('WEEK', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('WEEK', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON DATEADD(WEEK, 1, base.\"ev.ts\") IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|week|1::sqlite": "WITH base AS (\n SELECT\n DATE(ev.ts, 'weekday 0', '-6 days') AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE(ev.ts, 'weekday 0', '-6 days')\n), shifted_x AS (\n SELECT\n DATE(ev.ts, 'weekday 0', '-6 days') AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE(ev.ts, 'weekday 0', '-6 days')\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON SLAYER_DATE_ADD(base.\"ev.ts\", 1, 'week') IS shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|week|1::tsql": "WITH base AS (\n SELECT\n DATETRUNC(iso_week, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(iso_week, ev.ts)\n), shifted_x AS (\n SELECT\n DATETRUNC(iso_week, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(iso_week, ev.ts)\n), sjoin_x AS (\n SELECT\n base.[ev___ts] AS [ev___ts],\n base.[ev___v_sum] AS [ev___v_sum],\n shifted_x.[ev___v_sum] AS [ev___x]\n FROM base\n LEFT JOIN shifted_x\n ON (\n (\n DATEADD(WEEK, 1, base.[ev___ts]) = shifted_x.[ev___ts]\n AND NOT DATEADD(WEEK, 1, base.[ev___ts]) IS NULL\n AND NOT shifted_x.[ev___ts] IS NULL\n )\n OR (\n DATEADD(WEEK, 1, base.[ev___ts]) IS NULL AND shifted_x.[ev___ts] IS NULL\n )\n )\n)\nSELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\nFROM (\n SELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\n FROM sjoin_x\n) AS _outer", - "shift|year|-1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, YEAR) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, YEAR)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, YEAR) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, YEAR)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON CAST(DATETIME_ADD(CAST(CAST(base.`ev___ts` AS TIMESTAMP) AS DATETIME), INTERVAL -1 YEAR) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS TIMESTAMP)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", + "shift|year|-1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, YEAR) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, YEAR)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, YEAR) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, YEAR)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON DATETIME_ADD(CAST(base.`ev___ts` AS DATETIME), INTERVAL -1 YEAR) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS DATETIME)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", "shift|year|-1::clickhouse": "WITH base AS (\n SELECT\n dateTrunc('YEAR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('YEAR', ev.ts)\n), shifted_x AS (\n SELECT\n dateTrunc('YEAR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('YEAR', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON addYears(base.\"ev.ts\", -1) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|year|-1::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('YEAR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('YEAR', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('YEAR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('YEAR', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON base.\"ev.ts\" - INTERVAL 1 YEAR IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|year|-1::mysql": "WITH base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' 1 1'), '%Y %c %e') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' 1 1'), '%Y %c %e')\n), shifted_x AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' 1 1'), '%Y %c %e') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' 1 1'), '%Y %c %e')\n), sjoin_x AS (\n SELECT\n base.`ev.ts`,\n base.`ev.v_sum`,\n shifted_x.`ev.v_sum` AS `ev.x`\n FROM base\n LEFT JOIN shifted_x\n ON DATE_ADD(base.`ev.ts`, INTERVAL -1 YEAR) <=> shifted_x.`ev.ts`\n)\nSELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\nFROM (\n SELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\n FROM sjoin_x\n) AS _outer", @@ -111,7 +111,7 @@ "shift|year|-1::snowflake": "WITH base AS (\n SELECT\n DATE_TRUNC('YEAR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('YEAR', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('YEAR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('YEAR', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON DATEADD(YEAR, -1, base.\"ev.ts\") IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|year|-1::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-01-01', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-01-01', ev.ts)\n), shifted_x AS (\n SELECT\n STRFTIME('%Y-01-01', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-01-01', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON SLAYER_DATE_ADD(base.\"ev.ts\", -1, 'year') IS shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|year|-1::tsql": "WITH base AS (\n SELECT\n DATETRUNC(year, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(year, ev.ts)\n), shifted_x AS (\n SELECT\n DATETRUNC(year, ev.ts) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(year, ev.ts)\n), sjoin_x AS (\n SELECT\n base.[ev___ts] AS [ev___ts],\n base.[ev___v_sum] AS [ev___v_sum],\n shifted_x.[ev___v_sum] AS [ev___x]\n FROM base\n LEFT JOIN shifted_x\n ON (\n (\n DATEADD(YEAR, -1, base.[ev___ts]) = shifted_x.[ev___ts]\n AND NOT DATEADD(YEAR, -1, base.[ev___ts]) IS NULL\n AND NOT shifted_x.[ev___ts] IS NULL\n )\n OR (\n DATEADD(YEAR, -1, base.[ev___ts]) IS NULL AND shifted_x.[ev___ts] IS NULL\n )\n )\n)\nSELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\nFROM (\n SELECT\n [ev___ts],\n [ev___v_sum],\n [ev___x]\n FROM sjoin_x\n) AS _outer", - "shift|year|1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, YEAR) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, YEAR)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, YEAR) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, YEAR)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON CAST(DATETIME_ADD(CAST(CAST(base.`ev___ts` AS TIMESTAMP) AS DATETIME), INTERVAL 1 YEAR) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS TIMESTAMP)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", + "shift|year|1::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(ev.ts, YEAR) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, YEAR)\n), shifted_x AS (\n SELECT\n DATE_TRUNC(ev.ts, YEAR) AS `ev___ts`,\n CAST(SUM(ev.v) AS FLOAT64) AS `ev___v_sum`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, YEAR)\n), sjoin_x AS (\n SELECT\n base.`ev___ts`,\n base.`ev___v_sum`,\n shifted_x.`ev___v_sum` AS `ev___x`\n FROM base\n LEFT JOIN shifted_x\n ON DATETIME_ADD(CAST(base.`ev___ts` AS DATETIME), INTERVAL 1 YEAR) IS NOT DISTINCT FROM CAST(shifted_x.`ev___ts` AS DATETIME)\n)\nSELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\nFROM (\n SELECT\n `ev___ts`,\n `ev___v_sum`,\n `ev___x`\n FROM sjoin_x\n) AS _outer", "shift|year|1::clickhouse": "WITH base AS (\n SELECT\n dateTrunc('YEAR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('YEAR', ev.ts)\n), shifted_x AS (\n SELECT\n dateTrunc('YEAR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS Nullable(Float64)) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('YEAR', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON addYears(base.\"ev.ts\", 1) IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|year|1::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('YEAR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('YEAR', ev.ts)\n), shifted_x AS (\n SELECT\n DATE_TRUNC('YEAR', ev.ts) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('YEAR', ev.ts)\n), sjoin_x AS (\n SELECT\n base.\"ev.ts\",\n base.\"ev.v_sum\",\n shifted_x.\"ev.v_sum\" AS \"ev.x\"\n FROM base\n LEFT JOIN shifted_x\n ON base.\"ev.ts\" + INTERVAL 1 YEAR IS NOT DISTINCT FROM shifted_x.\"ev.ts\"\n)\nSELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\nFROM (\n SELECT\n \"ev.ts\",\n \"ev.v_sum\",\n \"ev.x\"\n FROM sjoin_x\n) AS _outer", "shift|year|1::mysql": "WITH base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' 1 1'), '%Y %c %e') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' 1 1'), '%Y %c %e')\n), shifted_x AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' 1 1'), '%Y %c %e') AS `ev.ts`,\n CAST(SUM(ev.v) AS DOUBLE) AS `ev.v_sum`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' 1 1'), '%Y %c %e')\n), sjoin_x AS (\n SELECT\n base.`ev.ts`,\n base.`ev.v_sum`,\n shifted_x.`ev.v_sum` AS `ev.x`\n FROM base\n LEFT JOIN shifted_x\n ON DATE_ADD(base.`ev.ts`, INTERVAL 1 YEAR) <=> shifted_x.`ev.ts`\n)\nSELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\nFROM (\n SELECT\n `ev.ts`,\n `ev.v_sum`,\n `ev.x`\n FROM sjoin_x\n) AS _outer", @@ -127,7 +127,7 @@ "trunc|week_sunday::snowflake": "SELECT\n DATEADD(DAY, -1, DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, ev.ts) AS TIMESTAMP))) AS \"ev.ts\",\n CAST(SUM(ev.v) AS DOUBLE) AS \"ev.v_sum\"\nFROM ev AS ev\nGROUP BY\n DATEADD(DAY, -1, DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, ev.ts) AS TIMESTAMP)))", "trunc|week_sunday::sqlite": "SELECT\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(ev.ts, 1, 'day'), 'weekday 0', '-6 days'), -1, 'day') AS \"ev.ts\",\n CAST(SUM(ev.v) AS REAL) AS \"ev.v_sum\"\nFROM ev AS ev\nGROUP BY\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(ev.ts, 1, 'day'), 'weekday 0', '-6 days'), -1, 'day')", "trunc|week_sunday::tsql": "SELECT\n DATEADD(DAY, -1, DATETRUNC(iso_week, CAST(DATEADD(DAY, 1, ev.ts) AS DATETIME2))) AS [ev___ts],\n CAST(SUM(ev.v) AS FLOAT) AS [ev___v_sum]\nFROM ev AS ev\nGROUP BY\n DATEADD(DAY, -1, DATETRUNC(iso_week, CAST(DATEADD(DAY, 1, ev.ts) AS DATETIME2)))", - "window|1m|day::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(ev.ts, DAY) AS `ev___ts`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, DAY)\n), _cm_ev__v_sum_window_1m AS (\n SELECT\n _base.`ev___ts`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `ev___x`\n FROM (\n SELECT\n DATE_TRUNC(ev.ts, DAY) AS `ev___ts`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, DAY)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= CAST(DATETIME_ADD(CAST(TIMESTAMP_ADD(_base.`ev___ts`, INTERVAL 1 DAY) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n AND _src._w_time < TIMESTAMP_ADD(_base.`ev___ts`, INTERVAL 1 DAY)\n GROUP BY\n _base.`ev___ts`\n)\nSELECT\n _base.`ev___ts`,\n _cm_ev__v_sum_window_1m.`ev___x`\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_1m\n ON _base.`ev___ts` IS NOT DISTINCT FROM _cm_ev__v_sum_window_1m.`ev___ts`", + "window|1m|day::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(ev.ts, DAY) AS `ev___ts`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, DAY)\n), _cm_ev__v_sum_window_1m AS (\n SELECT\n _base.`ev___ts`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `ev___x`\n FROM (\n SELECT\n DATE_TRUNC(ev.ts, DAY) AS `ev___ts`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, DAY)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`ev___ts` AS DATETIME), INTERVAL 1 DAY) AS DATETIME),\n INTERVAL -1 MONTH\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`ev___ts` AS DATETIME), INTERVAL 1 DAY)\n GROUP BY\n _base.`ev___ts`\n)\nSELECT\n _base.`ev___ts`,\n _cm_ev__v_sum_window_1m.`ev___x`\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_1m\n ON _base.`ev___ts` IS NOT DISTINCT FROM _cm_ev__v_sum_window_1m.`ev___ts`", "window|1m|day::clickhouse": "WITH _base AS (\n SELECT\n dateTrunc('DAY', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('DAY', ev.ts)\n), _cm_ev__v_sum_window_1m AS (\n SELECT\n _base.\"ev.ts\",\n CAST(SUM(_src._w_value) AS Nullable(Float64)) AS \"ev.x\"\n FROM (\n SELECT\n dateTrunc('DAY', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('DAY', ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= addMonths(addDays(_base.\"ev.ts\", 1), -1)\n AND _src._w_time < addDays(_base.\"ev.ts\", 1)\n GROUP BY\n _base.\"ev.ts\"\n)\nSELECT\n _base.\"ev.ts\",\n _cm_ev__v_sum_window_1m.\"ev.x\"\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_1m\n ON _base.\"ev.ts\" IS NOT DISTINCT FROM _cm_ev__v_sum_window_1m.\"ev.ts\"", "window|1m|day::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('DAY', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('DAY', ev.ts)\n), _cm_ev__v_sum_window_1m AS (\n SELECT\n _base.\"ev.ts\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"ev.x\"\n FROM (\n SELECT\n DATE_TRUNC('DAY', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('DAY', ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= _base.\"ev.ts\" + INTERVAL 1 DAY - INTERVAL 1 MONTH\n AND _src._w_time < _base.\"ev.ts\" + INTERVAL 1 DAY\n GROUP BY\n _base.\"ev.ts\"\n)\nSELECT\n _base.\"ev.ts\",\n _cm_ev__v_sum_window_1m.\"ev.x\"\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_1m\n ON _base.\"ev.ts\" IS NOT DISTINCT FROM _cm_ev__v_sum_window_1m.\"ev.ts\"", "window|1m|day::mysql": "WITH _base AS (\n SELECT\n DATE(ev.ts) AS `ev.ts`\n FROM ev AS ev\n GROUP BY\n DATE(ev.ts)\n), _cm_ev__v_sum_window_1m AS (\n SELECT\n _base.`ev.ts`,\n CAST(SUM(_src._w_value) AS DOUBLE) AS `ev.x`\n FROM (\n SELECT\n DATE(ev.ts) AS `ev.ts`\n FROM ev AS ev\n GROUP BY\n DATE(ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`ev.ts`, INTERVAL 1 DAY), INTERVAL -1 MONTH)\n AND _src._w_time < DATE_ADD(_base.`ev.ts`, INTERVAL 1 DAY)\n GROUP BY\n _base.`ev.ts`\n)\nSELECT\n _base.`ev.ts`,\n _cm_ev__v_sum_window_1m.`ev.x`\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_1m\n ON _base.`ev.ts` <=> _cm_ev__v_sum_window_1m.`ev.ts`", @@ -135,7 +135,7 @@ "window|1m|day::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('DAY', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('DAY', ev.ts)\n), _cm_ev__v_sum_window_1m AS (\n SELECT\n _base.\"ev.ts\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"ev.x\"\n FROM (\n SELECT\n DATE_TRUNC('DAY', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('DAY', ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= DATEADD(MONTH, -1, DATEADD(DAY, 1, _base.\"ev.ts\"))\n AND _src._w_time < DATEADD(DAY, 1, _base.\"ev.ts\")\n GROUP BY\n _base.\"ev.ts\"\n)\nSELECT\n _base.\"ev.ts\",\n _cm_ev__v_sum_window_1m.\"ev.x\"\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_1m\n ON _base.\"ev.ts\" IS NOT DISTINCT FROM _cm_ev__v_sum_window_1m.\"ev.ts\"", "window|1m|day::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-%d', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-%d', ev.ts)\n), _cm_ev__v_sum_window_1m AS (\n SELECT\n _base.\"ev.ts\",\n CAST(SUM(_src._w_value) AS REAL) AS \"ev.x\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-%d', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-%d', ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"ev.ts\", 1, 'day'), -1, 'month')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"ev.ts\", 1, 'day')\n GROUP BY\n _base.\"ev.ts\"\n)\nSELECT\n _base.\"ev.ts\",\n _cm_ev__v_sum_window_1m.\"ev.x\"\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_1m\n ON _base.\"ev.ts\" IS _cm_ev__v_sum_window_1m.\"ev.ts\"", "window|1m|day::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(day, ev.ts) AS [ev___ts]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(day, ev.ts)\n), _cm_ev__v_sum_window_1m AS (\n SELECT\n _base.[ev___ts] AS [ev___ts],\n CAST(SUM(_src._w_value) AS FLOAT) AS [ev___x]\n FROM (\n SELECT\n DATETRUNC(day, ev.ts) AS [ev___ts]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(day, ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= DATEADD(MONTH, -1, DATEADD(DAY, 1, _base.[ev___ts]))\n AND _src._w_time < DATEADD(DAY, 1, _base.[ev___ts])\n GROUP BY\n _base.[ev___ts]\n)\nSELECT\n _base.[ev___ts],\n _cm_ev__v_sum_window_1m.[ev___x]\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_1m\n ON (\n (\n _base.[ev___ts] = _cm_ev__v_sum_window_1m.[ev___ts]\n AND NOT _base.[ev___ts] IS NULL\n AND NOT _cm_ev__v_sum_window_1m.[ev___ts] IS NULL\n )\n OR (\n _base.[ev___ts] IS NULL AND _cm_ev__v_sum_window_1m.[ev___ts] IS NULL\n )\n )", - "window|1y2m3w5d6h7min8s|day::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(ev.ts, DAY) AS `ev___ts`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, DAY)\n), _cm_ev__v_sum_window_1y2m3w5d6h7min8s AS (\n SELECT\n _base.`ev___ts`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `ev___x`\n FROM (\n SELECT\n DATE_TRUNC(ev.ts, DAY) AS `ev___ts`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, DAY)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n TIMESTAMP_ADD(\n TIMESTAMP_ADD(\n TIMESTAMP_ADD(\n TIMESTAMP_ADD(\n CAST(DATETIME_ADD(\n CAST(CAST(DATETIME_ADD(CAST(TIMESTAMP_ADD(_base.`ev___ts`, INTERVAL 1 DAY) AS DATETIME), INTERVAL -1 YEAR) AS TIMESTAMP) AS DATETIME),\n INTERVAL -2 MONTH\n ) AS TIMESTAMP),\n INTERVAL ((\n -3\n ) * 7) DAY\n ),\n INTERVAL -5 DAY\n ),\n INTERVAL -6 HOUR\n ),\n INTERVAL -7 MINUTE\n ),\n INTERVAL -8 SECOND\n )\n AND _src._w_time < TIMESTAMP_ADD(_base.`ev___ts`, INTERVAL 1 DAY)\n GROUP BY\n _base.`ev___ts`\n)\nSELECT\n _base.`ev___ts`,\n _cm_ev__v_sum_window_1y2m3w5d6h7min8s.`ev___x`\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_1y2m3w5d6h7min8s\n ON _base.`ev___ts` IS NOT DISTINCT FROM _cm_ev__v_sum_window_1y2m3w5d6h7min8s.`ev___ts`", + "window|1y2m3w5d6h7min8s|day::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(ev.ts, DAY) AS `ev___ts`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, DAY)\n), _cm_ev__v_sum_window_1y2m3w5d6h7min8s AS (\n SELECT\n _base.`ev___ts`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `ev___x`\n FROM (\n SELECT\n DATE_TRUNC(ev.ts, DAY) AS `ev___ts`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, DAY)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(\n CAST(DATETIME_ADD(\n CAST(DATETIME_ADD(\n CAST(DATETIME_ADD(\n CAST(DATETIME_ADD(\n CAST(DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`ev___ts` AS DATETIME), INTERVAL 1 DAY) AS DATETIME),\n INTERVAL -1 YEAR\n ) AS DATETIME),\n INTERVAL -2 MONTH\n ) AS DATETIME),\n INTERVAL ((\n -3\n ) * 7) DAY\n ) AS DATETIME),\n INTERVAL -5 DAY\n ) AS DATETIME),\n INTERVAL -6 HOUR\n ) AS DATETIME),\n INTERVAL -7 MINUTE\n ) AS DATETIME),\n INTERVAL -8 SECOND\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`ev___ts` AS DATETIME), INTERVAL 1 DAY)\n GROUP BY\n _base.`ev___ts`\n)\nSELECT\n _base.`ev___ts`,\n _cm_ev__v_sum_window_1y2m3w5d6h7min8s.`ev___x`\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_1y2m3w5d6h7min8s\n ON _base.`ev___ts` IS NOT DISTINCT FROM _cm_ev__v_sum_window_1y2m3w5d6h7min8s.`ev___ts`", "window|1y2m3w5d6h7min8s|day::clickhouse": "WITH _base AS (\n SELECT\n dateTrunc('DAY', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('DAY', ev.ts)\n), _cm_ev__v_sum_window_1y2m3w5d6h7min8s AS (\n SELECT\n _base.\"ev.ts\",\n CAST(SUM(_src._w_value) AS Nullable(Float64)) AS \"ev.x\"\n FROM (\n SELECT\n dateTrunc('DAY', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('DAY', ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= addSeconds(\n addMinutes(\n addHours(\n addDays(addWeeks(addMonths(addYears(addDays(_base.\"ev.ts\", 1), -1), -2), -3), -5),\n -6\n ),\n -7\n ),\n -8\n )\n AND _src._w_time < addDays(_base.\"ev.ts\", 1)\n GROUP BY\n _base.\"ev.ts\"\n)\nSELECT\n _base.\"ev.ts\",\n _cm_ev__v_sum_window_1y2m3w5d6h7min8s.\"ev.x\"\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_1y2m3w5d6h7min8s\n ON _base.\"ev.ts\" IS NOT DISTINCT FROM _cm_ev__v_sum_window_1y2m3w5d6h7min8s.\"ev.ts\"", "window|1y2m3w5d6h7min8s|day::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('DAY', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('DAY', ev.ts)\n), _cm_ev__v_sum_window_1y2m3w5d6h7min8s AS (\n SELECT\n _base.\"ev.ts\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"ev.x\"\n FROM (\n SELECT\n DATE_TRUNC('DAY', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('DAY', ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= _base.\"ev.ts\" + INTERVAL 1 DAY - INTERVAL 1 YEAR - INTERVAL 2 MONTH - INTERVAL 3 WEEK - INTERVAL 5 DAY - INTERVAL 6 HOUR - INTERVAL 7 MINUTE - INTERVAL 8 SECOND\n AND _src._w_time < _base.\"ev.ts\" + INTERVAL 1 DAY\n GROUP BY\n _base.\"ev.ts\"\n)\nSELECT\n _base.\"ev.ts\",\n _cm_ev__v_sum_window_1y2m3w5d6h7min8s.\"ev.x\"\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_1y2m3w5d6h7min8s\n ON _base.\"ev.ts\" IS NOT DISTINCT FROM _cm_ev__v_sum_window_1y2m3w5d6h7min8s.\"ev.ts\"", "window|1y2m3w5d6h7min8s|day::mysql": "WITH _base AS (\n SELECT\n DATE(ev.ts) AS `ev.ts`\n FROM ev AS ev\n GROUP BY\n DATE(ev.ts)\n), _cm_ev__v_sum_window_1y2m3w5d6h7min8s AS (\n SELECT\n _base.`ev.ts`,\n CAST(SUM(_src._w_value) AS DOUBLE) AS `ev.x`\n FROM (\n SELECT\n DATE(ev.ts) AS `ev.ts`\n FROM ev AS ev\n GROUP BY\n DATE(ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= DATE_ADD(\n DATE_ADD(\n DATE_ADD(\n DATE_ADD(\n DATE_ADD(\n DATE_ADD(\n DATE_ADD(DATE_ADD(_base.`ev.ts`, INTERVAL 1 DAY), INTERVAL -1 YEAR),\n INTERVAL -2 MONTH\n ),\n INTERVAL -3 WEEK\n ),\n INTERVAL -5 DAY\n ),\n INTERVAL -6 HOUR\n ),\n INTERVAL -7 MINUTE\n ),\n INTERVAL -8 SECOND\n )\n AND _src._w_time < DATE_ADD(_base.`ev.ts`, INTERVAL 1 DAY)\n GROUP BY\n _base.`ev.ts`\n)\nSELECT\n _base.`ev.ts`,\n _cm_ev__v_sum_window_1y2m3w5d6h7min8s.`ev.x`\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_1y2m3w5d6h7min8s\n ON _base.`ev.ts` <=> _cm_ev__v_sum_window_1y2m3w5d6h7min8s.`ev.ts`", @@ -143,7 +143,7 @@ "window|1y2m3w5d6h7min8s|day::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('DAY', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('DAY', ev.ts)\n), _cm_ev__v_sum_window_1y2m3w5d6h7min8s AS (\n SELECT\n _base.\"ev.ts\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"ev.x\"\n FROM (\n SELECT\n DATE_TRUNC('DAY', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('DAY', ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= DATEADD(\n SECOND,\n -8,\n DATEADD(\n MINUTE,\n -7,\n DATEADD(\n HOUR,\n -6,\n DATEADD(\n DAY,\n -5,\n DATEADD(WEEK, -3, DATEADD(MONTH, -2, DATEADD(YEAR, -1, DATEADD(DAY, 1, _base.\"ev.ts\"))))\n )\n )\n )\n )\n AND _src._w_time < DATEADD(DAY, 1, _base.\"ev.ts\")\n GROUP BY\n _base.\"ev.ts\"\n)\nSELECT\n _base.\"ev.ts\",\n _cm_ev__v_sum_window_1y2m3w5d6h7min8s.\"ev.x\"\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_1y2m3w5d6h7min8s\n ON _base.\"ev.ts\" IS NOT DISTINCT FROM _cm_ev__v_sum_window_1y2m3w5d6h7min8s.\"ev.ts\"", "window|1y2m3w5d6h7min8s|day::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-%d', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-%d', ev.ts)\n), _cm_ev__v_sum_window_1y2m3w5d6h7min8s AS (\n SELECT\n _base.\"ev.ts\",\n CAST(SUM(_src._w_value) AS REAL) AS \"ev.x\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-%d', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n STRFTIME('%Y-%m-%d', ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(\n SLAYER_DATE_ADD(\n SLAYER_DATE_ADD(\n SLAYER_DATE_ADD(\n SLAYER_DATE_ADD(\n SLAYER_DATE_ADD(SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"ev.ts\", 1, 'day'), -1, 'year'), -2, 'month'),\n -3,\n 'week'\n ),\n -5,\n 'day'\n ),\n -6,\n 'hour'\n ),\n -7,\n 'minute'\n ),\n -8,\n 'second'\n )\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"ev.ts\", 1, 'day')\n GROUP BY\n _base.\"ev.ts\"\n)\nSELECT\n _base.\"ev.ts\",\n _cm_ev__v_sum_window_1y2m3w5d6h7min8s.\"ev.x\"\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_1y2m3w5d6h7min8s\n ON _base.\"ev.ts\" IS _cm_ev__v_sum_window_1y2m3w5d6h7min8s.\"ev.ts\"", "window|1y2m3w5d6h7min8s|day::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(day, ev.ts) AS [ev___ts]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(day, ev.ts)\n), _cm_ev__v_sum_window_1y2m3w5d6h7min8s AS (\n SELECT\n _base.[ev___ts] AS [ev___ts],\n CAST(SUM(_src._w_value) AS FLOAT) AS [ev___x]\n FROM (\n SELECT\n DATETRUNC(day, ev.ts) AS [ev___ts]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(day, ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= DATEADD(\n SECOND,\n -8,\n DATEADD(\n MINUTE,\n -7,\n DATEADD(\n HOUR,\n -6,\n DATEADD(\n DAY,\n -5,\n DATEADD(WEEK, -3, DATEADD(MONTH, -2, DATEADD(YEAR, -1, DATEADD(DAY, 1, _base.[ev___ts]))))\n )\n )\n )\n )\n AND _src._w_time < DATEADD(DAY, 1, _base.[ev___ts])\n GROUP BY\n _base.[ev___ts]\n)\nSELECT\n _base.[ev___ts],\n _cm_ev__v_sum_window_1y2m3w5d6h7min8s.[ev___x]\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_1y2m3w5d6h7min8s\n ON (\n (\n _base.[ev___ts] = _cm_ev__v_sum_window_1y2m3w5d6h7min8s.[ev___ts]\n AND NOT _base.[ev___ts] IS NULL\n AND NOT _cm_ev__v_sum_window_1y2m3w5d6h7min8s.[ev___ts] IS NULL\n )\n OR (\n _base.[ev___ts] IS NULL AND _cm_ev__v_sum_window_1y2m3w5d6h7min8s.[ev___ts] IS NULL\n )\n )", - "window|2w|week::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(MONDAY)) AS `ev___ts`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(MONDAY))\n), _cm_ev__v_sum_window_2w AS (\n SELECT\n _base.`ev___ts`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `ev___x`\n FROM (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(MONDAY)) AS `ev___ts`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(MONDAY))\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n TIMESTAMP_ADD(_base.`ev___ts`, INTERVAL ((\n 1\n ) * 7) DAY),\n INTERVAL ((\n -2\n ) * 7) DAY\n )\n AND _src._w_time < TIMESTAMP_ADD(_base.`ev___ts`, INTERVAL ((\n 1\n ) * 7) DAY)\n GROUP BY\n _base.`ev___ts`\n)\nSELECT\n _base.`ev___ts`,\n _cm_ev__v_sum_window_2w.`ev___x`\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_2w\n ON _base.`ev___ts` IS NOT DISTINCT FROM _cm_ev__v_sum_window_2w.`ev___ts`", + "window|2w|week::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(MONDAY)) AS `ev___ts`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(MONDAY))\n), _cm_ev__v_sum_window_2w AS (\n SELECT\n _base.`ev___ts`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `ev___x`\n FROM (\n SELECT\n DATE_TRUNC(ev.ts, WEEK(MONDAY)) AS `ev___ts`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, WEEK(MONDAY))\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`ev___ts` AS DATETIME), INTERVAL ((\n 1\n ) * 7) DAY) AS DATETIME),\n INTERVAL ((\n -2\n ) * 7) DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`ev___ts` AS DATETIME), INTERVAL ((\n 1\n ) * 7) DAY)\n GROUP BY\n _base.`ev___ts`\n)\nSELECT\n _base.`ev___ts`,\n _cm_ev__v_sum_window_2w.`ev___x`\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_2w\n ON _base.`ev___ts` IS NOT DISTINCT FROM _cm_ev__v_sum_window_2w.`ev___ts`", "window|2w|week::clickhouse": "WITH _base AS (\n SELECT\n dateTrunc('WEEK', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('WEEK', ev.ts)\n), _cm_ev__v_sum_window_2w AS (\n SELECT\n _base.\"ev.ts\",\n CAST(SUM(_src._w_value) AS Nullable(Float64)) AS \"ev.x\"\n FROM (\n SELECT\n dateTrunc('WEEK', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('WEEK', ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= addWeeks(addWeeks(_base.\"ev.ts\", 1), -2)\n AND _src._w_time < addWeeks(_base.\"ev.ts\", 1)\n GROUP BY\n _base.\"ev.ts\"\n)\nSELECT\n _base.\"ev.ts\",\n _cm_ev__v_sum_window_2w.\"ev.x\"\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_2w\n ON _base.\"ev.ts\" IS NOT DISTINCT FROM _cm_ev__v_sum_window_2w.\"ev.ts\"", "window|2w|week::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('WEEK', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('WEEK', ev.ts)\n), _cm_ev__v_sum_window_2w AS (\n SELECT\n _base.\"ev.ts\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"ev.x\"\n FROM (\n SELECT\n DATE_TRUNC('WEEK', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('WEEK', ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= _base.\"ev.ts\" + INTERVAL 1 WEEK - INTERVAL 2 WEEK\n AND _src._w_time < _base.\"ev.ts\" + INTERVAL 1 WEEK\n GROUP BY\n _base.\"ev.ts\"\n)\nSELECT\n _base.\"ev.ts\",\n _cm_ev__v_sum_window_2w.\"ev.x\"\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_2w\n ON _base.\"ev.ts\" IS NOT DISTINCT FROM _cm_ev__v_sum_window_2w.\"ev.ts\"", "window|2w|week::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', WEEK(ev.ts, 1), ' 1'), '%Y %u %w') AS `ev.ts`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', WEEK(ev.ts, 1), ' 1'), '%Y %u %w')\n), _cm_ev__v_sum_window_2w AS (\n SELECT\n _base.`ev.ts`,\n CAST(SUM(_src._w_value) AS DOUBLE) AS `ev.x`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', WEEK(ev.ts, 1), ' 1'), '%Y %u %w') AS `ev.ts`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', WEEK(ev.ts, 1), ' 1'), '%Y %u %w')\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`ev.ts`, INTERVAL 1 WEEK), INTERVAL -2 WEEK)\n AND _src._w_time < DATE_ADD(_base.`ev.ts`, INTERVAL 1 WEEK)\n GROUP BY\n _base.`ev.ts`\n)\nSELECT\n _base.`ev.ts`,\n _cm_ev__v_sum_window_2w.`ev.x`\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_2w\n ON _base.`ev.ts` <=> _cm_ev__v_sum_window_2w.`ev.ts`", @@ -151,7 +151,7 @@ "window|2w|week::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('WEEK', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('WEEK', ev.ts)\n), _cm_ev__v_sum_window_2w AS (\n SELECT\n _base.\"ev.ts\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"ev.x\"\n FROM (\n SELECT\n DATE_TRUNC('WEEK', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('WEEK', ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= DATEADD(WEEK, -2, DATEADD(WEEK, 1, _base.\"ev.ts\"))\n AND _src._w_time < DATEADD(WEEK, 1, _base.\"ev.ts\")\n GROUP BY\n _base.\"ev.ts\"\n)\nSELECT\n _base.\"ev.ts\",\n _cm_ev__v_sum_window_2w.\"ev.x\"\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_2w\n ON _base.\"ev.ts\" IS NOT DISTINCT FROM _cm_ev__v_sum_window_2w.\"ev.ts\"", "window|2w|week::sqlite": "WITH _base AS (\n SELECT\n DATE(ev.ts, 'weekday 0', '-6 days') AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n DATE(ev.ts, 'weekday 0', '-6 days')\n), _cm_ev__v_sum_window_2w AS (\n SELECT\n _base.\"ev.ts\",\n CAST(SUM(_src._w_value) AS REAL) AS \"ev.x\"\n FROM (\n SELECT\n DATE(ev.ts, 'weekday 0', '-6 days') AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n DATE(ev.ts, 'weekday 0', '-6 days')\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"ev.ts\", 1, 'week'), -2, 'week')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"ev.ts\", 1, 'week')\n GROUP BY\n _base.\"ev.ts\"\n)\nSELECT\n _base.\"ev.ts\",\n _cm_ev__v_sum_window_2w.\"ev.x\"\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_2w\n ON _base.\"ev.ts\" IS _cm_ev__v_sum_window_2w.\"ev.ts\"", "window|2w|week::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(iso_week, ev.ts) AS [ev___ts]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(iso_week, ev.ts)\n), _cm_ev__v_sum_window_2w AS (\n SELECT\n _base.[ev___ts] AS [ev___ts],\n CAST(SUM(_src._w_value) AS FLOAT) AS [ev___x]\n FROM (\n SELECT\n DATETRUNC(iso_week, ev.ts) AS [ev___ts]\n FROM ev AS ev\n GROUP BY\n DATETRUNC(iso_week, ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= DATEADD(WEEK, -2, DATEADD(WEEK, 1, _base.[ev___ts]))\n AND _src._w_time < DATEADD(WEEK, 1, _base.[ev___ts])\n GROUP BY\n _base.[ev___ts]\n)\nSELECT\n _base.[ev___ts],\n _cm_ev__v_sum_window_2w.[ev___x]\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_2w\n ON (\n (\n _base.[ev___ts] = _cm_ev__v_sum_window_2w.[ev___ts]\n AND NOT _base.[ev___ts] IS NULL\n AND NOT _cm_ev__v_sum_window_2w.[ev___ts] IS NULL\n )\n OR (\n _base.[ev___ts] IS NULL AND _cm_ev__v_sum_window_2w.[ev___ts] IS NULL\n )\n )", - "window|90d|month::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(ev.ts, MONTH) AS `ev___ts`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, MONTH)\n), _cm_ev__v_sum_window_90d AS (\n SELECT\n _base.`ev___ts`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `ev___x`\n FROM (\n SELECT\n DATE_TRUNC(ev.ts, MONTH) AS `ev___ts`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`ev___ts` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`ev___ts` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`ev___ts`\n)\nSELECT\n _base.`ev___ts`,\n _cm_ev__v_sum_window_90d.`ev___x`\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_90d\n ON _base.`ev___ts` IS NOT DISTINCT FROM _cm_ev__v_sum_window_90d.`ev___ts`", + "window|90d|month::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(ev.ts, MONTH) AS `ev___ts`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, MONTH)\n), _cm_ev__v_sum_window_90d AS (\n SELECT\n _base.`ev___ts`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `ev___x`\n FROM (\n SELECT\n DATE_TRUNC(ev.ts, MONTH) AS `ev___ts`\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC(ev.ts, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`ev___ts` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`ev___ts` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`ev___ts`\n)\nSELECT\n _base.`ev___ts`,\n _cm_ev__v_sum_window_90d.`ev___x`\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_90d\n ON _base.`ev___ts` IS NOT DISTINCT FROM _cm_ev__v_sum_window_90d.`ev___ts`", "window|90d|month::clickhouse": "WITH _base AS (\n SELECT\n dateTrunc('MONTH', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('MONTH', ev.ts)\n), _cm_ev__v_sum_window_90d AS (\n SELECT\n _base.\"ev.ts\",\n CAST(SUM(_src._w_value) AS Nullable(Float64)) AS \"ev.x\"\n FROM (\n SELECT\n dateTrunc('MONTH', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n dateTrunc('MONTH', ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= addDays(addMonths(_base.\"ev.ts\", 1), -90)\n AND _src._w_time < addMonths(_base.\"ev.ts\", 1)\n GROUP BY\n _base.\"ev.ts\"\n)\nSELECT\n _base.\"ev.ts\",\n _cm_ev__v_sum_window_90d.\"ev.x\"\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_90d\n ON _base.\"ev.ts\" IS NOT DISTINCT FROM _cm_ev__v_sum_window_90d.\"ev.ts\"", "window|90d|month::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('MONTH', ev.ts)\n), _cm_ev__v_sum_window_90d AS (\n SELECT\n _base.\"ev.ts\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"ev.x\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', ev.ts) AS \"ev.ts\"\n FROM ev AS ev\n GROUP BY\n DATE_TRUNC('MONTH', ev.ts)\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= _base.\"ev.ts\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"ev.ts\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"ev.ts\"\n)\nSELECT\n _base.\"ev.ts\",\n _cm_ev__v_sum_window_90d.\"ev.x\"\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_90d\n ON _base.\"ev.ts\" IS NOT DISTINCT FROM _cm_ev__v_sum_window_90d.\"ev.ts\"", "window|90d|month::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', MONTH(ev.ts), ' 1'), '%Y %c %e') AS `ev.ts`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', MONTH(ev.ts), ' 1'), '%Y %c %e')\n), _cm_ev__v_sum_window_90d AS (\n SELECT\n _base.`ev.ts`,\n CAST(SUM(_src._w_value) AS DOUBLE) AS `ev.x`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', MONTH(ev.ts), ' 1'), '%Y %c %e') AS `ev.ts`\n FROM ev AS ev\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(ev.ts), ' ', MONTH(ev.ts), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n ev.ts AS _w_time,\n ev.v AS _w_value\n FROM ev AS ev\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`ev.ts`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`ev.ts`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`ev.ts`\n)\nSELECT\n _base.`ev.ts`,\n _cm_ev__v_sum_window_90d.`ev.x`\nFROM _base\nLEFT JOIN _cm_ev__v_sum_window_90d\n ON _base.`ev.ts` <=> _cm_ev__v_sum_window_90d.`ev.ts`", diff --git a/tests/golden/dev1737_date_functions.json b/tests/golden/dev1737_date_functions.json index d1423324c..06a7e5408 100644 --- a/tests/golden/dev1737_date_functions.json +++ b/tests/golden/dev1737_date_functions.json @@ -23,7 +23,7 @@ "add|day|d1|plus1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(DAY, 1, dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(DAY, 1, dt.d1)", "add|day|d1|plus1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, 1, 'day') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, 1, 'day')", "add|day|d1|plus1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(DAY, 1, dt.d1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(DAY, 1, dt.d1)", - "add|day|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL (CAST(TRUNC(dt.n) AS INT64)) DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL (CAST(TRUNC(dt.n) AS INT64)) DAY)", + "add|day|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) DAY)", "add|day|t1|computed::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addDays(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32))) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addDays(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32)))", "add|day|t1|computed::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 DAY AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 DAY", "add|day|t1|computed::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) DAY) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) DAY)", @@ -31,7 +31,7 @@ "add|day|t1|computed::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(DAY, CAST(TRUNC(dt.n) AS INT), dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(DAY, CAST(TRUNC(dt.n) AS INT), dt.t1)", "add|day|t1|computed::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'day') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'day')", "add|day|t1|computed::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(DAY, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(DAY, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1)", - "add|day|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL -13 DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL -13 DAY)", + "add|day|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 DAY)", "add|day|t1|minus13::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addDays(dt.t1, -13) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addDays(dt.t1, -13)", "add|day|t1|minus13::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 - INTERVAL 13 DAY AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 - INTERVAL 13 DAY", "add|day|t1|minus13::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL -13 DAY) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL -13 DAY)", @@ -39,7 +39,7 @@ "add|day|t1|minus13::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(DAY, -13, dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(DAY, -13, dt.t1)", "add|day|t1|minus13::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, -13, 'day') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, -13, 'day')", "add|day|t1|minus13::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(DAY, -13, dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(DAY, -13, dt.t1)", - "add|day|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL 1 DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL 1 DAY)", + "add|day|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 DAY)", "add|day|t1|plus1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addDays(dt.t1, 1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addDays(dt.t1, 1)", "add|day|t1|plus1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + INTERVAL 1 DAY AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + INTERVAL 1 DAY", "add|day|t1|plus1::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL 1 DAY) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL 1 DAY)", @@ -47,7 +47,7 @@ "add|day|t1|plus1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(DAY, 1, dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(DAY, 1, dt.t1)", "add|day|t1|plus1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, 1, 'day') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, 1, 'day')", "add|day|t1|plus1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(DAY, 1, dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(DAY, 1, dt.t1)", - "add|hour|d1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) HOUR)", + "add|hour|d1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) HOUR)", "add|hour|d1|computed::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addHours(toDateTime64(dt.d1, 6), CAST(trunc(dt.n) AS Nullable(Int32))) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addHours(toDateTime64(dt.d1, 6), CAST(trunc(dt.n) AS Nullable(Int32)))", "add|hour|d1|computed::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.d1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 HOUR AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.d1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 HOUR", "add|hour|d1|computed::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.d1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) HOUR) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.d1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) HOUR)", @@ -55,7 +55,7 @@ "add|hour|d1|computed::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(HOUR, CAST(TRUNC(dt.n) AS INT), dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(HOUR, CAST(TRUNC(dt.n) AS INT), dt.d1)", "add|hour|d1|computed::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, CAST(TRUNC(dt.n) AS INTEGER), 'hour') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, CAST(TRUNC(dt.n) AS INTEGER), 'hour')", "add|hour|d1|computed::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(HOUR, CAST(ROUND(dt.n, 0, 1) AS INTEGER), CAST(dt.d1 AS DATETIME2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(HOUR, CAST(ROUND(dt.n, 0, 1) AS INTEGER), CAST(dt.d1 AS DATETIME2))", - "add|hour|d1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL -13 HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL -13 HOUR)", + "add|hour|d1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL -13 HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL -13 HOUR)", "add|hour|d1|minus13::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addHours(toDateTime64(dt.d1, 6), -13) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addHours(toDateTime64(dt.d1, 6), -13)", "add|hour|d1|minus13::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.d1 - INTERVAL 13 HOUR AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.d1 - INTERVAL 13 HOUR", "add|hour|d1|minus13::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.d1, INTERVAL -13 HOUR) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.d1, INTERVAL -13 HOUR)", @@ -63,7 +63,7 @@ "add|hour|d1|minus13::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(HOUR, -13, dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(HOUR, -13, dt.d1)", "add|hour|d1|minus13::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, -13, 'hour') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, -13, 'hour')", "add|hour|d1|minus13::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(HOUR, -13, CAST(dt.d1 AS DATETIME2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(HOUR, -13, CAST(dt.d1 AS DATETIME2))", - "add|hour|d1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL 1 HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL 1 HOUR)", + "add|hour|d1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL 1 HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL 1 HOUR)", "add|hour|d1|plus1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addHours(toDateTime64(dt.d1, 6), 1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addHours(toDateTime64(dt.d1, 6), 1)", "add|hour|d1|plus1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.d1 + INTERVAL 1 HOUR AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.d1 + INTERVAL 1 HOUR", "add|hour|d1|plus1::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.d1, INTERVAL 1 HOUR) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.d1, INTERVAL 1 HOUR)", @@ -71,7 +71,7 @@ "add|hour|d1|plus1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(HOUR, 1, dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(HOUR, 1, dt.d1)", "add|hour|d1|plus1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, 1, 'hour') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, 1, 'hour')", "add|hour|d1|plus1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(HOUR, 1, CAST(dt.d1 AS DATETIME2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(HOUR, 1, CAST(dt.d1 AS DATETIME2))", - "add|hour|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL (CAST(TRUNC(dt.n) AS INT64)) HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL (CAST(TRUNC(dt.n) AS INT64)) HOUR)", + "add|hour|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) HOUR)", "add|hour|t1|computed::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addHours(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32))) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addHours(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32)))", "add|hour|t1|computed::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 HOUR AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 HOUR", "add|hour|t1|computed::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) HOUR) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) HOUR)", @@ -79,7 +79,7 @@ "add|hour|t1|computed::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(HOUR, CAST(TRUNC(dt.n) AS INT), dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(HOUR, CAST(TRUNC(dt.n) AS INT), dt.t1)", "add|hour|t1|computed::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'hour') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'hour')", "add|hour|t1|computed::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(HOUR, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(HOUR, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1)", - "add|hour|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL -13 HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL -13 HOUR)", + "add|hour|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 HOUR)", "add|hour|t1|minus13::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addHours(dt.t1, -13) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addHours(dt.t1, -13)", "add|hour|t1|minus13::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 - INTERVAL 13 HOUR AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 - INTERVAL 13 HOUR", "add|hour|t1|minus13::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL -13 HOUR) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL -13 HOUR)", @@ -87,7 +87,7 @@ "add|hour|t1|minus13::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(HOUR, -13, dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(HOUR, -13, dt.t1)", "add|hour|t1|minus13::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, -13, 'hour') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, -13, 'hour')", "add|hour|t1|minus13::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(HOUR, -13, dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(HOUR, -13, dt.t1)", - "add|hour|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL 1 HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL 1 HOUR)", + "add|hour|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 HOUR)", "add|hour|t1|plus1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addHours(dt.t1, 1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addHours(dt.t1, 1)", "add|hour|t1|plus1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + INTERVAL 1 HOUR AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + INTERVAL 1 HOUR", "add|hour|t1|plus1::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL 1 HOUR) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL 1 HOUR)", @@ -95,7 +95,7 @@ "add|hour|t1|plus1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(HOUR, 1, dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(HOUR, 1, dt.t1)", "add|hour|t1|plus1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, 1, 'hour') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, 1, 'hour')", "add|hour|t1|plus1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(HOUR, 1, dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(HOUR, 1, dt.t1)", - "add|minute|d1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) MINUTE) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) MINUTE)", + "add|minute|d1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) MINUTE) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) MINUTE)", "add|minute|d1|computed::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addMinutes(toDateTime64(dt.d1, 6), CAST(trunc(dt.n) AS Nullable(Int32))) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addMinutes(toDateTime64(dt.d1, 6), CAST(trunc(dt.n) AS Nullable(Int32)))", "add|minute|d1|computed::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.d1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 MINUTE AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.d1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 MINUTE", "add|minute|d1|computed::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.d1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) MINUTE) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.d1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) MINUTE)", @@ -103,7 +103,7 @@ "add|minute|d1|computed::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(MINUTE, CAST(TRUNC(dt.n) AS INT), dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MINUTE, CAST(TRUNC(dt.n) AS INT), dt.d1)", "add|minute|d1|computed::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, CAST(TRUNC(dt.n) AS INTEGER), 'minute') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, CAST(TRUNC(dt.n) AS INTEGER), 'minute')", "add|minute|d1|computed::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(MINUTE, CAST(ROUND(dt.n, 0, 1) AS INTEGER), CAST(dt.d1 AS DATETIME2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MINUTE, CAST(ROUND(dt.n, 0, 1) AS INTEGER), CAST(dt.d1 AS DATETIME2))", - "add|minute|d1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL -13 MINUTE) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL -13 MINUTE)", + "add|minute|d1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL -13 MINUTE) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL -13 MINUTE)", "add|minute|d1|minus13::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addMinutes(toDateTime64(dt.d1, 6), -13) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addMinutes(toDateTime64(dt.d1, 6), -13)", "add|minute|d1|minus13::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.d1 - INTERVAL 13 MINUTE AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.d1 - INTERVAL 13 MINUTE", "add|minute|d1|minus13::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.d1, INTERVAL -13 MINUTE) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.d1, INTERVAL -13 MINUTE)", @@ -111,7 +111,7 @@ "add|minute|d1|minus13::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(MINUTE, -13, dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MINUTE, -13, dt.d1)", "add|minute|d1|minus13::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, -13, 'minute') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, -13, 'minute')", "add|minute|d1|minus13::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(MINUTE, -13, CAST(dt.d1 AS DATETIME2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MINUTE, -13, CAST(dt.d1 AS DATETIME2))", - "add|minute|d1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL 1 MINUTE) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL 1 MINUTE)", + "add|minute|d1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL 1 MINUTE) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL 1 MINUTE)", "add|minute|d1|plus1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addMinutes(toDateTime64(dt.d1, 6), 1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addMinutes(toDateTime64(dt.d1, 6), 1)", "add|minute|d1|plus1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.d1 + INTERVAL 1 MINUTE AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.d1 + INTERVAL 1 MINUTE", "add|minute|d1|plus1::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.d1, INTERVAL 1 MINUTE) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.d1, INTERVAL 1 MINUTE)", @@ -119,7 +119,7 @@ "add|minute|d1|plus1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(MINUTE, 1, dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MINUTE, 1, dt.d1)", "add|minute|d1|plus1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, 1, 'minute') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, 1, 'minute')", "add|minute|d1|plus1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(MINUTE, 1, CAST(dt.d1 AS DATETIME2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MINUTE, 1, CAST(dt.d1 AS DATETIME2))", - "add|minute|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL (CAST(TRUNC(dt.n) AS INT64)) MINUTE) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL (CAST(TRUNC(dt.n) AS INT64)) MINUTE)", + "add|minute|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) MINUTE) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) MINUTE)", "add|minute|t1|computed::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addMinutes(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32))) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addMinutes(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32)))", "add|minute|t1|computed::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 MINUTE AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 MINUTE", "add|minute|t1|computed::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) MINUTE) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) MINUTE)", @@ -127,7 +127,7 @@ "add|minute|t1|computed::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(MINUTE, CAST(TRUNC(dt.n) AS INT), dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MINUTE, CAST(TRUNC(dt.n) AS INT), dt.t1)", "add|minute|t1|computed::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'minute') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'minute')", "add|minute|t1|computed::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(MINUTE, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MINUTE, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1)", - "add|minute|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL -13 MINUTE) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL -13 MINUTE)", + "add|minute|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 MINUTE) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 MINUTE)", "add|minute|t1|minus13::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addMinutes(dt.t1, -13) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addMinutes(dt.t1, -13)", "add|minute|t1|minus13::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 - INTERVAL 13 MINUTE AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 - INTERVAL 13 MINUTE", "add|minute|t1|minus13::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL -13 MINUTE) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL -13 MINUTE)", @@ -135,7 +135,7 @@ "add|minute|t1|minus13::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(MINUTE, -13, dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MINUTE, -13, dt.t1)", "add|minute|t1|minus13::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, -13, 'minute') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, -13, 'minute')", "add|minute|t1|minus13::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(MINUTE, -13, dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MINUTE, -13, dt.t1)", - "add|minute|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL 1 MINUTE) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL 1 MINUTE)", + "add|minute|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 MINUTE) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 MINUTE)", "add|minute|t1|plus1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addMinutes(dt.t1, 1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addMinutes(dt.t1, 1)", "add|minute|t1|plus1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + INTERVAL 1 MINUTE AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + INTERVAL 1 MINUTE", "add|minute|t1|plus1::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL 1 MINUTE) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL 1 MINUTE)", @@ -167,7 +167,7 @@ "add|month|d1|plus1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(MONTH, 1, dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MONTH, 1, dt.d1)", "add|month|d1|plus1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, 1, 'month') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, 1, 'month')", "add|month|d1|plus1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(MONTH, 1, dt.d1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MONTH, 1, dt.d1)", - "add|month|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) MONTH) AS TIMESTAMP) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) MONTH) AS TIMESTAMP)", + "add|month|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) MONTH) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) MONTH)", "add|month|t1|computed::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addMonths(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32))) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addMonths(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32)))", "add|month|t1|computed::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 MONTH AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 MONTH", "add|month|t1|computed::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) MONTH) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) MONTH)", @@ -175,7 +175,7 @@ "add|month|t1|computed::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(MONTH, CAST(TRUNC(dt.n) AS INT), dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MONTH, CAST(TRUNC(dt.n) AS INT), dt.t1)", "add|month|t1|computed::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'month') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'month')", "add|month|t1|computed::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(MONTH, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MONTH, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1)", - "add|month|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 MONTH) AS TIMESTAMP) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 MONTH) AS TIMESTAMP)", + "add|month|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 MONTH) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 MONTH)", "add|month|t1|minus13::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addMonths(dt.t1, -13) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addMonths(dt.t1, -13)", "add|month|t1|minus13::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 - INTERVAL 13 MONTH AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 - INTERVAL 13 MONTH", "add|month|t1|minus13::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL -13 MONTH) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL -13 MONTH)", @@ -183,7 +183,7 @@ "add|month|t1|minus13::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(MONTH, -13, dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MONTH, -13, dt.t1)", "add|month|t1|minus13::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, -13, 'month') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, -13, 'month')", "add|month|t1|minus13::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(MONTH, -13, dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MONTH, -13, dt.t1)", - "add|month|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)", + "add|month|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 MONTH) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 MONTH)", "add|month|t1|plus1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addMonths(dt.t1, 1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addMonths(dt.t1, 1)", "add|month|t1|plus1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + INTERVAL 1 MONTH AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + INTERVAL 1 MONTH", "add|month|t1|plus1::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL 1 MONTH) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL 1 MONTH)", @@ -215,7 +215,7 @@ "add|quarter|d1|plus1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(QUARTER, 1, dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(QUARTER, 1, dt.d1)", "add|quarter|d1|plus1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, 1, 'quarter') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, 1, 'quarter')", "add|quarter|d1|plus1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(QUARTER, 1, dt.d1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(QUARTER, 1, dt.d1)", - "add|quarter|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) QUARTER) AS TIMESTAMP) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) QUARTER) AS TIMESTAMP)", + "add|quarter|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) QUARTER) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) QUARTER)", "add|quarter|t1|computed::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addQuarters(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32))) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addQuarters(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32)))", "add|quarter|t1|computed::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 3 MONTH AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 3 MONTH", "add|quarter|t1|computed::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) QUARTER) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) QUARTER)", @@ -223,7 +223,7 @@ "add|quarter|t1|computed::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(QUARTER, CAST(TRUNC(dt.n) AS INT), dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(QUARTER, CAST(TRUNC(dt.n) AS INT), dt.t1)", "add|quarter|t1|computed::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'quarter') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'quarter')", "add|quarter|t1|computed::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(QUARTER, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(QUARTER, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1)", - "add|quarter|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 QUARTER) AS TIMESTAMP) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 QUARTER) AS TIMESTAMP)", + "add|quarter|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 QUARTER) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 QUARTER)", "add|quarter|t1|minus13::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addQuarters(dt.t1, -13) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addQuarters(dt.t1, -13)", "add|quarter|t1|minus13::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 - INTERVAL 39 MONTH AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 - INTERVAL 39 MONTH", "add|quarter|t1|minus13::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL -13 QUARTER) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL -13 QUARTER)", @@ -231,7 +231,7 @@ "add|quarter|t1|minus13::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(QUARTER, -13, dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(QUARTER, -13, dt.t1)", "add|quarter|t1|minus13::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, -13, 'quarter') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, -13, 'quarter')", "add|quarter|t1|minus13::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(QUARTER, -13, dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(QUARTER, -13, dt.t1)", - "add|quarter|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 QUARTER) AS TIMESTAMP) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 QUARTER) AS TIMESTAMP)", + "add|quarter|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 QUARTER) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 QUARTER)", "add|quarter|t1|plus1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addQuarters(dt.t1, 1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addQuarters(dt.t1, 1)", "add|quarter|t1|plus1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + INTERVAL 3 MONTH AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + INTERVAL 3 MONTH", "add|quarter|t1|plus1::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL 1 QUARTER) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL 1 QUARTER)", @@ -239,7 +239,7 @@ "add|quarter|t1|plus1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(QUARTER, 1, dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(QUARTER, 1, dt.t1)", "add|quarter|t1|plus1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, 1, 'quarter') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, 1, 'quarter')", "add|quarter|t1|plus1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(QUARTER, 1, dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(QUARTER, 1, dt.t1)", - "add|second|d1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) SECOND) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) SECOND)", + "add|second|d1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) SECOND) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) SECOND)", "add|second|d1|computed::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addSeconds(toDateTime64(dt.d1, 6), CAST(trunc(dt.n) AS Nullable(Int32))) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addSeconds(toDateTime64(dt.d1, 6), CAST(trunc(dt.n) AS Nullable(Int32)))", "add|second|d1|computed::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.d1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 SECOND AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.d1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 SECOND", "add|second|d1|computed::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.d1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) SECOND) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.d1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) SECOND)", @@ -247,7 +247,7 @@ "add|second|d1|computed::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(SECOND, CAST(TRUNC(dt.n) AS INT), dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(SECOND, CAST(TRUNC(dt.n) AS INT), dt.d1)", "add|second|d1|computed::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, CAST(TRUNC(dt.n) AS INTEGER), 'second') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, CAST(TRUNC(dt.n) AS INTEGER), 'second')", "add|second|d1|computed::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(SECOND, CAST(ROUND(dt.n, 0, 1) AS INTEGER), CAST(dt.d1 AS DATETIME2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(SECOND, CAST(ROUND(dt.n, 0, 1) AS INTEGER), CAST(dt.d1 AS DATETIME2))", - "add|second|d1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL -13 SECOND) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL -13 SECOND)", + "add|second|d1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL -13 SECOND) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL -13 SECOND)", "add|second|d1|minus13::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addSeconds(toDateTime64(dt.d1, 6), -13) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addSeconds(toDateTime64(dt.d1, 6), -13)", "add|second|d1|minus13::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.d1 - INTERVAL 13 SECOND AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.d1 - INTERVAL 13 SECOND", "add|second|d1|minus13::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.d1, INTERVAL -13 SECOND) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.d1, INTERVAL -13 SECOND)", @@ -255,7 +255,7 @@ "add|second|d1|minus13::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(SECOND, -13, dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(SECOND, -13, dt.d1)", "add|second|d1|minus13::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, -13, 'second') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, -13, 'second')", "add|second|d1|minus13::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(SECOND, -13, CAST(dt.d1 AS DATETIME2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(SECOND, -13, CAST(dt.d1 AS DATETIME2))", - "add|second|d1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL 1 SECOND) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(CAST(dt.d1 AS TIMESTAMP), INTERVAL 1 SECOND)", + "add|second|d1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL 1 SECOND) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.d1 AS DATETIME), INTERVAL 1 SECOND)", "add|second|d1|plus1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addSeconds(toDateTime64(dt.d1, 6), 1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addSeconds(toDateTime64(dt.d1, 6), 1)", "add|second|d1|plus1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.d1 + INTERVAL 1 SECOND AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.d1 + INTERVAL 1 SECOND", "add|second|d1|plus1::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.d1, INTERVAL 1 SECOND) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.d1, INTERVAL 1 SECOND)", @@ -263,7 +263,7 @@ "add|second|d1|plus1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(SECOND, 1, dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(SECOND, 1, dt.d1)", "add|second|d1|plus1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, 1, 'second') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, 1, 'second')", "add|second|d1|plus1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(SECOND, 1, CAST(dt.d1 AS DATETIME2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(SECOND, 1, CAST(dt.d1 AS DATETIME2))", - "add|second|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL (CAST(TRUNC(dt.n) AS INT64)) SECOND) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL (CAST(TRUNC(dt.n) AS INT64)) SECOND)", + "add|second|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) SECOND) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) SECOND)", "add|second|t1|computed::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addSeconds(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32))) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addSeconds(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32)))", "add|second|t1|computed::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 SECOND AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 SECOND", "add|second|t1|computed::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) SECOND) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) SECOND)", @@ -271,7 +271,7 @@ "add|second|t1|computed::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(SECOND, CAST(TRUNC(dt.n) AS INT), dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(SECOND, CAST(TRUNC(dt.n) AS INT), dt.t1)", "add|second|t1|computed::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'second') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'second')", "add|second|t1|computed::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(SECOND, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(SECOND, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1)", - "add|second|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL -13 SECOND) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL -13 SECOND)", + "add|second|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 SECOND) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 SECOND)", "add|second|t1|minus13::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addSeconds(dt.t1, -13) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addSeconds(dt.t1, -13)", "add|second|t1|minus13::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 - INTERVAL 13 SECOND AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 - INTERVAL 13 SECOND", "add|second|t1|minus13::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL -13 SECOND) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL -13 SECOND)", @@ -279,7 +279,7 @@ "add|second|t1|minus13::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(SECOND, -13, dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(SECOND, -13, dt.t1)", "add|second|t1|minus13::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, -13, 'second') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, -13, 'second')", "add|second|t1|minus13::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(SECOND, -13, dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(SECOND, -13, dt.t1)", - "add|second|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL 1 SECOND) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL 1 SECOND)", + "add|second|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 SECOND) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 SECOND)", "add|second|t1|plus1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addSeconds(dt.t1, 1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addSeconds(dt.t1, 1)", "add|second|t1|plus1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + INTERVAL 1 SECOND AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + INTERVAL 1 SECOND", "add|second|t1|plus1::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL 1 SECOND) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL 1 SECOND)", @@ -311,7 +311,7 @@ "add|week_sunday|d1|plus1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(WEEK, 1, dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(WEEK, 1, dt.d1)", "add|week_sunday|d1|plus1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, 1, 'week_sunday') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, 1, 'week_sunday')", "add|week_sunday|d1|plus1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(WEEK, 1, dt.d1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(WEEK, 1, dt.d1)", - "add|week_sunday|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL ((\n CAST(TRUNC(dt.n) AS INT64)\n ) * 7) DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL ((\n CAST(TRUNC(dt.n) AS INT64)\n ) * 7) DAY)", + "add|week_sunday|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL ((\n CAST(TRUNC(dt.n) AS INT64)\n ) * 7) DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL ((\n CAST(TRUNC(dt.n) AS INT64)\n ) * 7) DAY)", "add|week_sunday|t1|computed::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addWeeks(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32))) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addWeeks(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32)))", "add|week_sunday|t1|computed::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 WEEK AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 WEEK", "add|week_sunday|t1|computed::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) WEEK) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) WEEK)", @@ -319,7 +319,7 @@ "add|week_sunday|t1|computed::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(WEEK, CAST(TRUNC(dt.n) AS INT), dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(WEEK, CAST(TRUNC(dt.n) AS INT), dt.t1)", "add|week_sunday|t1|computed::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'week_sunday') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'week_sunday')", "add|week_sunday|t1|computed::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(WEEK, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(WEEK, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1)", - "add|week_sunday|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL ((\n -13\n ) * 7) DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL ((\n -13\n ) * 7) DAY)", + "add|week_sunday|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL ((\n -13\n ) * 7) DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL ((\n -13\n ) * 7) DAY)", "add|week_sunday|t1|minus13::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addWeeks(dt.t1, -13) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addWeeks(dt.t1, -13)", "add|week_sunday|t1|minus13::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 - INTERVAL 13 WEEK AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 - INTERVAL 13 WEEK", "add|week_sunday|t1|minus13::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL -13 WEEK) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL -13 WEEK)", @@ -327,7 +327,7 @@ "add|week_sunday|t1|minus13::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(WEEK, -13, dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(WEEK, -13, dt.t1)", "add|week_sunday|t1|minus13::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, -13, 'week_sunday') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, -13, 'week_sunday')", "add|week_sunday|t1|minus13::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(WEEK, -13, dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(WEEK, -13, dt.t1)", - "add|week_sunday|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL ((\n 1\n ) * 7) DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL ((\n 1\n ) * 7) DAY)", + "add|week_sunday|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL ((\n 1\n ) * 7) DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL ((\n 1\n ) * 7) DAY)", "add|week_sunday|t1|plus1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addWeeks(dt.t1, 1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addWeeks(dt.t1, 1)", "add|week_sunday|t1|plus1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + INTERVAL 1 WEEK AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + INTERVAL 1 WEEK", "add|week_sunday|t1|plus1::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL 1 WEEK) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL 1 WEEK)", @@ -359,7 +359,7 @@ "add|week|d1|plus1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(WEEK, 1, dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(WEEK, 1, dt.d1)", "add|week|d1|plus1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, 1, 'week') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, 1, 'week')", "add|week|d1|plus1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(WEEK, 1, dt.d1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(WEEK, 1, dt.d1)", - "add|week|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL ((\n CAST(TRUNC(dt.n) AS INT64)\n ) * 7) DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL ((\n CAST(TRUNC(dt.n) AS INT64)\n ) * 7) DAY)", + "add|week|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL ((\n CAST(TRUNC(dt.n) AS INT64)\n ) * 7) DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL ((\n CAST(TRUNC(dt.n) AS INT64)\n ) * 7) DAY)", "add|week|t1|computed::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addWeeks(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32))) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addWeeks(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32)))", "add|week|t1|computed::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 WEEK AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 WEEK", "add|week|t1|computed::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) WEEK) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) WEEK)", @@ -367,7 +367,7 @@ "add|week|t1|computed::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(WEEK, CAST(TRUNC(dt.n) AS INT), dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(WEEK, CAST(TRUNC(dt.n) AS INT), dt.t1)", "add|week|t1|computed::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'week') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'week')", "add|week|t1|computed::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(WEEK, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(WEEK, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1)", - "add|week|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL ((\n -13\n ) * 7) DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL ((\n -13\n ) * 7) DAY)", + "add|week|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL ((\n -13\n ) * 7) DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL ((\n -13\n ) * 7) DAY)", "add|week|t1|minus13::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addWeeks(dt.t1, -13) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addWeeks(dt.t1, -13)", "add|week|t1|minus13::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 - INTERVAL 13 WEEK AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 - INTERVAL 13 WEEK", "add|week|t1|minus13::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL -13 WEEK) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL -13 WEEK)", @@ -375,7 +375,7 @@ "add|week|t1|minus13::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(WEEK, -13, dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(WEEK, -13, dt.t1)", "add|week|t1|minus13::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, -13, 'week') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, -13, 'week')", "add|week|t1|minus13::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(WEEK, -13, dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(WEEK, -13, dt.t1)", - "add|week|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL ((\n 1\n ) * 7) DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL ((\n 1\n ) * 7) DAY)", + "add|week|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL ((\n 1\n ) * 7) DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL ((\n 1\n ) * 7) DAY)", "add|week|t1|plus1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addWeeks(dt.t1, 1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addWeeks(dt.t1, 1)", "add|week|t1|plus1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + INTERVAL 1 WEEK AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + INTERVAL 1 WEEK", "add|week|t1|plus1::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL 1 WEEK) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL 1 WEEK)", @@ -407,7 +407,7 @@ "add|year|d1|plus1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(YEAR, 1, dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(YEAR, 1, dt.d1)", "add|year|d1|plus1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, 1, 'year') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, 1, 'year')", "add|year|d1|plus1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(YEAR, 1, dt.d1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(YEAR, 1, dt.d1)", - "add|year|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) YEAR) AS TIMESTAMP) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) YEAR) AS TIMESTAMP)", + "add|year|t1|computed::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) YEAR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(dt.n) AS INT64)) YEAR)", "add|year|t1|computed::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addYears(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32))) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addYears(dt.t1, CAST(trunc(dt.n) AS Nullable(Int32)))", "add|year|t1|computed::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 YEAR AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + (\n CAST(TRUNC(dt.n) AS INT)\n ) * INTERVAL 1 YEAR", "add|year|t1|computed::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) YEAR) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(dt.n, 0) AS SIGNED)) YEAR)", @@ -415,7 +415,7 @@ "add|year|t1|computed::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(YEAR, CAST(TRUNC(dt.n) AS INT), dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(YEAR, CAST(TRUNC(dt.n) AS INT), dt.t1)", "add|year|t1|computed::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'year') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, CAST(TRUNC(dt.n) AS INTEGER), 'year')", "add|year|t1|computed::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(YEAR, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(YEAR, CAST(ROUND(dt.n, 0, 1) AS INTEGER), dt.t1)", - "add|year|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 YEAR) AS TIMESTAMP) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 YEAR) AS TIMESTAMP)", + "add|year|t1|minus13::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 YEAR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL -13 YEAR)", "add|year|t1|minus13::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addYears(dt.t1, -13) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addYears(dt.t1, -13)", "add|year|t1|minus13::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 - INTERVAL 13 YEAR AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 - INTERVAL 13 YEAR", "add|year|t1|minus13::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL -13 YEAR) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL -13 YEAR)", @@ -423,7 +423,7 @@ "add|year|t1|minus13::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(YEAR, -13, dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(YEAR, -13, dt.t1)", "add|year|t1|minus13::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.t1, -13, 'year') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.t1, -13, 'year')", "add|year|t1|minus13::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(YEAR, -13, dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(YEAR, -13, dt.t1)", - "add|year|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 YEAR) AS TIMESTAMP) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 YEAR) AS TIMESTAMP)", + "add|year|t1|plus1::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 YEAR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 YEAR)", "add|year|t1|plus1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addYears(dt.t1, 1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addYears(dt.t1, 1)", "add|year|t1|plus1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + INTERVAL 1 YEAR AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + INTERVAL 1 YEAR", "add|year|t1|plus1::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL 1 YEAR) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL 1 YEAR)", @@ -439,7 +439,7 @@ "clock|current_date::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CURRENT_DATE AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CURRENT_DATE", "clock|current_date::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CURRENT_DATE AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CURRENT_DATE", "clock|current_date::tsql": "SELECT\n dt.id AS [dt___id],\n CAST(GETDATE() AS DATE) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(GETDATE() AS DATE)", - "clock|now::bigquery": "SELECT\n dt.id AS `dt___id`,\n CURRENT_TIMESTAMP() AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CURRENT_TIMESTAMP()", + "clock|now::bigquery": "SELECT\n dt.id AS `dt___id`,\n CURRENT_DATETIME() AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CURRENT_DATETIME()", "clock|now::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n now() AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n now()", "clock|now::duckdb": "SELECT\n dt.id AS \"dt.id\",\n CAST(CURRENT_TIMESTAMP AS TIMESTAMP) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(CURRENT_TIMESTAMP AS TIMESTAMP)", "clock|now::mysql": "SELECT\n dt.id AS `dt.id`,\n CAST(CURRENT_TIMESTAMP() AS DATETIME) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(CURRENT_TIMESTAMP() AS DATETIME)", @@ -455,7 +455,7 @@ "diff|day|d1-d2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST(dt.d2 AS DATE) - CAST(dt.d1 AS DATE) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(dt.d2 AS DATE) - CAST(dt.d1 AS DATE)", "diff|day|d1-d2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(JULIANDAY(DATE(dt.d2)) - JULIANDAY(DATE(dt.d1)) AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(JULIANDAY(DATE(dt.d2)) - JULIANDAY(DATE(dt.d1)) AS INTEGER)", "diff|day|d1-d2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(DAY, dt.d1, dt.d2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(DAY, dt.d1, dt.d2)", - "diff|day|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS TIMESTAMP) AS DATE), DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS TIMESTAMP) AS DATE), DAY)", + "diff|day|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS DATETIME) AS DATE), DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS DATETIME) AS DATE), DAY)", "diff|day|d1-t2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('day', toDateTime64(dt.d1, 6), dt.t2) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('day', toDateTime64(dt.d1, 6), dt.t2)", "diff|day|d1-t2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n CAST(dt.t2 AS DATE) - CAST(CAST(dt.d1 AS TIMESTAMP) AS DATE) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(dt.t2 AS DATE) - CAST(CAST(dt.d1 AS TIMESTAMP) AS DATE)", "diff|day|d1-t2::mysql": "SELECT\n dt.id AS `dt.id`,\n DATEDIFF(dt.t2, CAST(dt.d1 AS DATETIME)) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF(dt.t2, CAST(dt.d1 AS DATETIME))", @@ -463,7 +463,7 @@ "diff|day|d1-t2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST(dt.t2 AS DATE) - CAST(CAST(dt.d1 AS TIMESTAMP) AS DATE) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(dt.t2 AS DATE) - CAST(CAST(dt.d1 AS TIMESTAMP) AS DATE)", "diff|day|d1-t2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(JULIANDAY(DATE(dt.t2)) - JULIANDAY(DATE(DATETIME(dt.d1))) AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(JULIANDAY(DATE(dt.t2)) - JULIANDAY(DATE(DATETIME(dt.d1))) AS INTEGER)", "diff|day|d1-t2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(DAY, CAST(dt.d1 AS DATETIME2), dt.t2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(DAY, CAST(dt.d1 AS DATETIME2), dt.t2)", - "diff|day|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(CAST(dt.d2 AS TIMESTAMP) AS DATE), CAST(dt.t1 AS DATE), DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(CAST(dt.d2 AS TIMESTAMP) AS DATE), CAST(dt.t1 AS DATE), DAY)", + "diff|day|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(CAST(dt.d2 AS DATETIME) AS DATE), CAST(dt.t1 AS DATE), DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(CAST(dt.d2 AS DATETIME) AS DATE), CAST(dt.t1 AS DATE), DAY)", "diff|day|t1-d2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('day', dt.t1, toDateTime64(dt.d2, 6)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('day', dt.t1, toDateTime64(dt.d2, 6))", "diff|day|t1-d2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n CAST(CAST(dt.d2 AS TIMESTAMP) AS DATE) - CAST(dt.t1 AS DATE) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(CAST(dt.d2 AS TIMESTAMP) AS DATE) - CAST(dt.t1 AS DATE)", "diff|day|t1-d2::mysql": "SELECT\n dt.id AS `dt.id`,\n DATEDIFF(CAST(dt.d2 AS DATETIME), dt.t1) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF(CAST(dt.d2 AS DATETIME), dt.t1)", @@ -479,7 +479,7 @@ "diff|day|t1-t2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST(dt.t2 AS DATE) - CAST(dt.t1 AS DATE) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(dt.t2 AS DATE) - CAST(dt.t1 AS DATE)", "diff|day|t1-t2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(JULIANDAY(DATE(dt.t2)) - JULIANDAY(DATE(dt.t1)) AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(JULIANDAY(DATE(dt.t2)) - JULIANDAY(DATE(dt.t1)) AS INTEGER)", "diff|day|t1-t2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(DAY, dt.t1, dt.t2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(DAY, dt.t1, dt.t2)", - "diff|hour|d1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(dt.d2 AS TIMESTAMP), HOUR),\n TIMESTAMP_TRUNC(CAST(dt.d1 AS TIMESTAMP), HOUR),\n HOUR\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(dt.d2 AS TIMESTAMP), HOUR),\n TIMESTAMP_TRUNC(CAST(dt.d1 AS TIMESTAMP), HOUR),\n HOUR\n )", + "diff|hour|d1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.d2 AS DATETIME), HOUR),\n DATETIME_TRUNC(CAST(dt.d1 AS DATETIME), HOUR),\n HOUR\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.d2 AS DATETIME), HOUR),\n DATETIME_TRUNC(CAST(dt.d1 AS DATETIME), HOUR),\n HOUR\n )", "diff|hour|d1-d2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('hour', toDateTime64(dt.d1, 6), toDateTime64(dt.d2, 6)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('hour', toDateTime64(dt.d1, 6), toDateTime64(dt.d2, 6))", "diff|hour|d1-d2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('HOUR', CAST(dt.d2 AS TIMESTAMP)) - DATE_TRUNC('HOUR', CAST(dt.d1 AS TIMESTAMP))\n )) AS BIGINT)\n ) // 3600 AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('HOUR', CAST(dt.d2 AS TIMESTAMP)) - DATE_TRUNC('HOUR', CAST(dt.d1 AS TIMESTAMP))\n )) AS BIGINT)\n ) // 3600", "diff|hour|d1-d2::mysql": "SELECT\n dt.id AS `dt.id`,\n CAST((\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(CAST(dt.d1 AS DATETIME), '%Y-%m-%d %H:00:00') AS DATETIME),\n CAST(DATE_FORMAT(CAST(dt.d2 AS DATETIME), '%Y-%m-%d %H:00:00') AS DATETIME)\n )\n ) / 3600 AS SIGNED) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(CAST(dt.d1 AS DATETIME), '%Y-%m-%d %H:00:00') AS DATETIME),\n CAST(DATE_FORMAT(CAST(dt.d2 AS DATETIME), '%Y-%m-%d %H:00:00') AS DATETIME)\n )\n ) / 3600 AS SIGNED)", @@ -487,7 +487,7 @@ "diff|hour|d1-d2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST((\n DATEDIFF(\n SECOND,\n DATE_TRUNC('HOUR', CAST(dt.d1 AS TIMESTAMP)),\n DATE_TRUNC('HOUR', CAST(dt.d2 AS TIMESTAMP))\n )\n ) / 3600 AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n DATEDIFF(\n SECOND,\n DATE_TRUNC('HOUR', CAST(dt.d1 AS TIMESTAMP)),\n DATE_TRUNC('HOUR', CAST(dt.d2 AS TIMESTAMP))\n )\n ) / 3600 AS INT)", "diff|hour|d1-d2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:00:00', DATETIME(dt.d2))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:00:00', DATETIME(dt.d1))) AS INTEGER)\n ) AS REAL) / 3600 AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:00:00', DATETIME(dt.d2))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:00:00', DATETIME(dt.d1))) AS INTEGER)\n ) AS REAL) / 3600 AS INTEGER)", "diff|hour|d1-d2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(HOUR, CAST(dt.d1 AS DATETIME2), CAST(dt.d2 AS DATETIME2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(HOUR, CAST(dt.d1 AS DATETIME2), CAST(dt.d2 AS DATETIME2))", - "diff|hour|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_DIFF(TIMESTAMP_TRUNC(dt.t2, HOUR), TIMESTAMP_TRUNC(CAST(dt.d1 AS TIMESTAMP), HOUR), HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_DIFF(TIMESTAMP_TRUNC(dt.t2, HOUR), TIMESTAMP_TRUNC(CAST(dt.d1 AS TIMESTAMP), HOUR), HOUR)", + "diff|hour|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.t2 AS DATETIME), HOUR),\n DATETIME_TRUNC(CAST(dt.d1 AS DATETIME), HOUR),\n HOUR\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.t2 AS DATETIME), HOUR),\n DATETIME_TRUNC(CAST(dt.d1 AS DATETIME), HOUR),\n HOUR\n )", "diff|hour|d1-t2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('hour', toDateTime64(dt.d1, 6), dt.t2) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('hour', toDateTime64(dt.d1, 6), dt.t2)", "diff|hour|d1-t2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('HOUR', dt.t2) - DATE_TRUNC('HOUR', CAST(dt.d1 AS TIMESTAMP))\n )) AS BIGINT)\n ) // 3600 AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('HOUR', dt.t2) - DATE_TRUNC('HOUR', CAST(dt.d1 AS TIMESTAMP))\n )) AS BIGINT)\n ) // 3600", "diff|hour|d1-t2::mysql": "SELECT\n dt.id AS `dt.id`,\n CAST((\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(CAST(dt.d1 AS DATETIME), '%Y-%m-%d %H:00:00') AS DATETIME),\n CAST(DATE_FORMAT(dt.t2, '%Y-%m-%d %H:00:00') AS DATETIME)\n )\n ) / 3600 AS SIGNED) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(CAST(dt.d1 AS DATETIME), '%Y-%m-%d %H:00:00') AS DATETIME),\n CAST(DATE_FORMAT(dt.t2, '%Y-%m-%d %H:00:00') AS DATETIME)\n )\n ) / 3600 AS SIGNED)", @@ -495,7 +495,7 @@ "diff|hour|d1-t2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST((\n DATEDIFF(SECOND, DATE_TRUNC('HOUR', CAST(dt.d1 AS TIMESTAMP)), DATE_TRUNC('HOUR', dt.t2))\n ) / 3600 AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n DATEDIFF(SECOND, DATE_TRUNC('HOUR', CAST(dt.d1 AS TIMESTAMP)), DATE_TRUNC('HOUR', dt.t2))\n ) / 3600 AS INT)", "diff|hour|d1-t2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:00:00', dt.t2)) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:00:00', DATETIME(dt.d1))) AS INTEGER)\n ) AS REAL) / 3600 AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:00:00', dt.t2)) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:00:00', DATETIME(dt.d1))) AS INTEGER)\n ) AS REAL) / 3600 AS INTEGER)", "diff|hour|d1-t2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(HOUR, CAST(dt.d1 AS DATETIME2), dt.t2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(HOUR, CAST(dt.d1 AS DATETIME2), dt.t2)", - "diff|hour|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_DIFF(TIMESTAMP_TRUNC(CAST(dt.d2 AS TIMESTAMP), HOUR), TIMESTAMP_TRUNC(dt.t1, HOUR), HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_DIFF(TIMESTAMP_TRUNC(CAST(dt.d2 AS TIMESTAMP), HOUR), TIMESTAMP_TRUNC(dt.t1, HOUR), HOUR)", + "diff|hour|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.d2 AS DATETIME), HOUR),\n DATETIME_TRUNC(CAST(dt.t1 AS DATETIME), HOUR),\n HOUR\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.d2 AS DATETIME), HOUR),\n DATETIME_TRUNC(CAST(dt.t1 AS DATETIME), HOUR),\n HOUR\n )", "diff|hour|t1-d2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('hour', dt.t1, toDateTime64(dt.d2, 6)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('hour', dt.t1, toDateTime64(dt.d2, 6))", "diff|hour|t1-d2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('HOUR', CAST(dt.d2 AS TIMESTAMP)) - DATE_TRUNC('HOUR', dt.t1)\n )) AS BIGINT)\n ) // 3600 AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('HOUR', CAST(dt.d2 AS TIMESTAMP)) - DATE_TRUNC('HOUR', dt.t1)\n )) AS BIGINT)\n ) // 3600", "diff|hour|t1-d2::mysql": "SELECT\n dt.id AS `dt.id`,\n CAST((\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(dt.t1, '%Y-%m-%d %H:00:00') AS DATETIME),\n CAST(DATE_FORMAT(CAST(dt.d2 AS DATETIME), '%Y-%m-%d %H:00:00') AS DATETIME)\n )\n ) / 3600 AS SIGNED) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(dt.t1, '%Y-%m-%d %H:00:00') AS DATETIME),\n CAST(DATE_FORMAT(CAST(dt.d2 AS DATETIME), '%Y-%m-%d %H:00:00') AS DATETIME)\n )\n ) / 3600 AS SIGNED)", @@ -503,7 +503,7 @@ "diff|hour|t1-d2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST((\n DATEDIFF(SECOND, DATE_TRUNC('HOUR', dt.t1), DATE_TRUNC('HOUR', CAST(dt.d2 AS TIMESTAMP)))\n ) / 3600 AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n DATEDIFF(SECOND, DATE_TRUNC('HOUR', dt.t1), DATE_TRUNC('HOUR', CAST(dt.d2 AS TIMESTAMP)))\n ) / 3600 AS INT)", "diff|hour|t1-d2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:00:00', DATETIME(dt.d2))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:00:00', dt.t1)) AS INTEGER)\n ) AS REAL) / 3600 AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:00:00', DATETIME(dt.d2))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:00:00', dt.t1)) AS INTEGER)\n ) AS REAL) / 3600 AS INTEGER)", "diff|hour|t1-d2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(HOUR, dt.t1, CAST(dt.d2 AS DATETIME2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(HOUR, dt.t1, CAST(dt.d2 AS DATETIME2))", - "diff|hour|t1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_DIFF(TIMESTAMP_TRUNC(dt.t2, HOUR), TIMESTAMP_TRUNC(dt.t1, HOUR), HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_DIFF(TIMESTAMP_TRUNC(dt.t2, HOUR), TIMESTAMP_TRUNC(dt.t1, HOUR), HOUR)", + "diff|hour|t1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.t2 AS DATETIME), HOUR),\n DATETIME_TRUNC(CAST(dt.t1 AS DATETIME), HOUR),\n HOUR\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.t2 AS DATETIME), HOUR),\n DATETIME_TRUNC(CAST(dt.t1 AS DATETIME), HOUR),\n HOUR\n )", "diff|hour|t1-t2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('hour', dt.t1, dt.t2) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('hour', dt.t1, dt.t2)", "diff|hour|t1-t2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('HOUR', dt.t2) - DATE_TRUNC('HOUR', dt.t1)\n )) AS BIGINT)\n ) // 3600 AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('HOUR', dt.t2) - DATE_TRUNC('HOUR', dt.t1)\n )) AS BIGINT)\n ) // 3600", "diff|hour|t1-t2::mysql": "SELECT\n dt.id AS `dt.id`,\n CAST((\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(dt.t1, '%Y-%m-%d %H:00:00') AS DATETIME),\n CAST(DATE_FORMAT(dt.t2, '%Y-%m-%d %H:00:00') AS DATETIME)\n )\n ) / 3600 AS SIGNED) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(dt.t1, '%Y-%m-%d %H:00:00') AS DATETIME),\n CAST(DATE_FORMAT(dt.t2, '%Y-%m-%d %H:00:00') AS DATETIME)\n )\n ) / 3600 AS SIGNED)", @@ -511,7 +511,7 @@ "diff|hour|t1-t2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST((\n DATEDIFF(SECOND, DATE_TRUNC('HOUR', dt.t1), DATE_TRUNC('HOUR', dt.t2))\n ) / 3600 AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n DATEDIFF(SECOND, DATE_TRUNC('HOUR', dt.t1), DATE_TRUNC('HOUR', dt.t2))\n ) / 3600 AS INT)", "diff|hour|t1-t2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:00:00', dt.t2)) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:00:00', dt.t1)) AS INTEGER)\n ) AS REAL) / 3600 AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:00:00', dt.t2)) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:00:00', dt.t1)) AS INTEGER)\n ) AS REAL) / 3600 AS INTEGER)", "diff|hour|t1-t2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(HOUR, dt.t1, dt.t2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(HOUR, dt.t1, dt.t2)", - "diff|minute|d1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(dt.d2 AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST(dt.d1 AS TIMESTAMP), MINUTE),\n MINUTE\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(dt.d2 AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST(dt.d1 AS TIMESTAMP), MINUTE),\n MINUTE\n )", + "diff|minute|d1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.d2 AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST(dt.d1 AS DATETIME), MINUTE),\n MINUTE\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.d2 AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST(dt.d1 AS DATETIME), MINUTE),\n MINUTE\n )", "diff|minute|d1-d2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('minute', toDateTime64(dt.d1, 6), toDateTime64(dt.d2, 6)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('minute', toDateTime64(dt.d1, 6), toDateTime64(dt.d2, 6))", "diff|minute|d1-d2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(dt.d2 AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST(dt.d1 AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60 AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(dt.d2 AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST(dt.d1 AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60", "diff|minute|d1-d2::mysql": "SELECT\n dt.id AS `dt.id`,\n CAST((\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(CAST(dt.d1 AS DATETIME), '%Y-%m-%d %H:%i:00') AS DATETIME),\n CAST(DATE_FORMAT(CAST(dt.d2 AS DATETIME), '%Y-%m-%d %H:%i:00') AS DATETIME)\n )\n ) / 60 AS SIGNED) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(CAST(dt.d1 AS DATETIME), '%Y-%m-%d %H:%i:00') AS DATETIME),\n CAST(DATE_FORMAT(CAST(dt.d2 AS DATETIME), '%Y-%m-%d %H:%i:00') AS DATETIME)\n )\n ) / 60 AS SIGNED)", @@ -519,7 +519,7 @@ "diff|minute|d1-d2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST((\n DATEDIFF(\n SECOND,\n DATE_TRUNC('MINUTE', CAST(dt.d1 AS TIMESTAMP)),\n DATE_TRUNC('MINUTE', CAST(dt.d2 AS TIMESTAMP))\n )\n ) / 60 AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n DATEDIFF(\n SECOND,\n DATE_TRUNC('MINUTE', CAST(dt.d1 AS TIMESTAMP)),\n DATE_TRUNC('MINUTE', CAST(dt.d2 AS TIMESTAMP))\n )\n ) / 60 AS INT)", "diff|minute|d1-d2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(dt.d2))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(dt.d1))) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(dt.d2))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(dt.d1))) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)", "diff|minute|d1-d2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(MINUTE, CAST(dt.d1 AS DATETIME2), CAST(dt.d2 AS DATETIME2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(MINUTE, CAST(dt.d1 AS DATETIME2), CAST(dt.d2 AS DATETIME2))", - "diff|minute|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(dt.t2, MINUTE),\n TIMESTAMP_TRUNC(CAST(dt.d1 AS TIMESTAMP), MINUTE),\n MINUTE\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(dt.t2, MINUTE),\n TIMESTAMP_TRUNC(CAST(dt.d1 AS TIMESTAMP), MINUTE),\n MINUTE\n )", + "diff|minute|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.t2 AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST(dt.d1 AS DATETIME), MINUTE),\n MINUTE\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.t2 AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST(dt.d1 AS DATETIME), MINUTE),\n MINUTE\n )", "diff|minute|d1-t2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('minute', toDateTime64(dt.d1, 6), dt.t2) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('minute', toDateTime64(dt.d1, 6), dt.t2)", "diff|minute|d1-t2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', dt.t2) - DATE_TRUNC('MINUTE', CAST(dt.d1 AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60 AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', dt.t2) - DATE_TRUNC('MINUTE', CAST(dt.d1 AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60", "diff|minute|d1-t2::mysql": "SELECT\n dt.id AS `dt.id`,\n CAST((\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(CAST(dt.d1 AS DATETIME), '%Y-%m-%d %H:%i:00') AS DATETIME),\n CAST(DATE_FORMAT(dt.t2, '%Y-%m-%d %H:%i:00') AS DATETIME)\n )\n ) / 60 AS SIGNED) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(CAST(dt.d1 AS DATETIME), '%Y-%m-%d %H:%i:00') AS DATETIME),\n CAST(DATE_FORMAT(dt.t2, '%Y-%m-%d %H:%i:00') AS DATETIME)\n )\n ) / 60 AS SIGNED)", @@ -527,7 +527,7 @@ "diff|minute|d1-t2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST((\n DATEDIFF(SECOND, DATE_TRUNC('MINUTE', CAST(dt.d1 AS TIMESTAMP)), DATE_TRUNC('MINUTE', dt.t2))\n ) / 60 AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n DATEDIFF(SECOND, DATE_TRUNC('MINUTE', CAST(dt.d1 AS TIMESTAMP)), DATE_TRUNC('MINUTE', dt.t2))\n ) / 60 AS INT)", "diff|minute|d1-t2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', dt.t2)) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(dt.d1))) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', dt.t2)) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(dt.d1))) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)", "diff|minute|d1-t2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(MINUTE, CAST(dt.d1 AS DATETIME2), dt.t2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(MINUTE, CAST(dt.d1 AS DATETIME2), dt.t2)", - "diff|minute|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(dt.d2 AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(dt.t1, MINUTE),\n MINUTE\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(dt.d2 AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(dt.t1, MINUTE),\n MINUTE\n )", + "diff|minute|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.d2 AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST(dt.t1 AS DATETIME), MINUTE),\n MINUTE\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.d2 AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST(dt.t1 AS DATETIME), MINUTE),\n MINUTE\n )", "diff|minute|t1-d2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('minute', dt.t1, toDateTime64(dt.d2, 6)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('minute', dt.t1, toDateTime64(dt.d2, 6))", "diff|minute|t1-d2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(dt.d2 AS TIMESTAMP)) - DATE_TRUNC('MINUTE', dt.t1)\n )) AS BIGINT)\n ) // 60 AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(dt.d2 AS TIMESTAMP)) - DATE_TRUNC('MINUTE', dt.t1)\n )) AS BIGINT)\n ) // 60", "diff|minute|t1-d2::mysql": "SELECT\n dt.id AS `dt.id`,\n CAST((\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(dt.t1, '%Y-%m-%d %H:%i:00') AS DATETIME),\n CAST(DATE_FORMAT(CAST(dt.d2 AS DATETIME), '%Y-%m-%d %H:%i:00') AS DATETIME)\n )\n ) / 60 AS SIGNED) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(dt.t1, '%Y-%m-%d %H:%i:00') AS DATETIME),\n CAST(DATE_FORMAT(CAST(dt.d2 AS DATETIME), '%Y-%m-%d %H:%i:00') AS DATETIME)\n )\n ) / 60 AS SIGNED)", @@ -535,7 +535,7 @@ "diff|minute|t1-d2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST((\n DATEDIFF(SECOND, DATE_TRUNC('MINUTE', dt.t1), DATE_TRUNC('MINUTE', CAST(dt.d2 AS TIMESTAMP)))\n ) / 60 AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n DATEDIFF(SECOND, DATE_TRUNC('MINUTE', dt.t1), DATE_TRUNC('MINUTE', CAST(dt.d2 AS TIMESTAMP)))\n ) / 60 AS INT)", "diff|minute|t1-d2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(dt.d2))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', dt.t1)) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(dt.d2))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', dt.t1)) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)", "diff|minute|t1-d2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(MINUTE, dt.t1, CAST(dt.d2 AS DATETIME2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(MINUTE, dt.t1, CAST(dt.d2 AS DATETIME2))", - "diff|minute|t1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_DIFF(TIMESTAMP_TRUNC(dt.t2, MINUTE), TIMESTAMP_TRUNC(dt.t1, MINUTE), MINUTE) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_DIFF(TIMESTAMP_TRUNC(dt.t2, MINUTE), TIMESTAMP_TRUNC(dt.t1, MINUTE), MINUTE)", + "diff|minute|t1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.t2 AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST(dt.t1 AS DATETIME), MINUTE),\n MINUTE\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.t2 AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST(dt.t1 AS DATETIME), MINUTE),\n MINUTE\n )", "diff|minute|t1-t2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('minute', dt.t1, dt.t2) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('minute', dt.t1, dt.t2)", "diff|minute|t1-t2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', dt.t2) - DATE_TRUNC('MINUTE', dt.t1)\n )) AS BIGINT)\n ) // 60 AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', dt.t2) - DATE_TRUNC('MINUTE', dt.t1)\n )) AS BIGINT)\n ) // 60", "diff|minute|t1-t2::mysql": "SELECT\n dt.id AS `dt.id`,\n CAST((\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(dt.t1, '%Y-%m-%d %H:%i:00') AS DATETIME),\n CAST(DATE_FORMAT(dt.t2, '%Y-%m-%d %H:%i:00') AS DATETIME)\n )\n ) / 60 AS SIGNED) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(dt.t1, '%Y-%m-%d %H:%i:00') AS DATETIME),\n CAST(DATE_FORMAT(dt.t2, '%Y-%m-%d %H:%i:00') AS DATETIME)\n )\n ) / 60 AS SIGNED)", @@ -551,7 +551,7 @@ "diff|month|d1-d2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n 12 * (\n CAST(DATE_PART(YEAR, dt.d2) AS INT) - CAST(DATE_PART(YEAR, dt.d1) AS INT)\n ) + (\n CAST(DATE_PART(MONTH, dt.d2) AS INT) - CAST(DATE_PART(MONTH, dt.d1) AS INT)\n ) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n 12 * (\n CAST(DATE_PART(YEAR, dt.d2) AS INT) - CAST(DATE_PART(YEAR, dt.d1) AS INT)\n ) + (\n CAST(DATE_PART(MONTH, dt.d2) AS INT) - CAST(DATE_PART(MONTH, dt.d1) AS INT)\n )", "diff|month|d1-d2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n 12 * (\n CAST(STRFTIME('%Y', dt.d2) AS INTEGER) - CAST(STRFTIME('%Y', dt.d1) AS INTEGER)\n ) + (\n CAST(STRFTIME('%m', dt.d2) AS INTEGER) - CAST(STRFTIME('%m', dt.d1) AS INTEGER)\n ) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n 12 * (\n CAST(STRFTIME('%Y', dt.d2) AS INTEGER) - CAST(STRFTIME('%Y', dt.d1) AS INTEGER)\n ) + (\n CAST(STRFTIME('%m', dt.d2) AS INTEGER) - CAST(STRFTIME('%m', dt.d1) AS INTEGER)\n )", "diff|month|d1-d2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(MONTH, dt.d1, dt.d2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(MONTH, dt.d1, dt.d2)", - "diff|month|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS TIMESTAMP) AS DATE), MONTH) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS TIMESTAMP) AS DATE), MONTH)", + "diff|month|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS DATETIME) AS DATE), MONTH) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS DATETIME) AS DATE), MONTH)", "diff|month|d1-t2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('month', toDateTime64(dt.d1, 6), dt.t2) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('month', toDateTime64(dt.d1, 6), dt.t2)", "diff|month|d1-t2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n 12 * (\n CAST(EXTRACT(YEAR FROM dt.t2) AS INT) - CAST(EXTRACT(YEAR FROM CAST(dt.d1 AS TIMESTAMP)) AS INT)\n ) + (\n CAST(EXTRACT(MONTH FROM dt.t2) AS INT) - CAST(EXTRACT(MONTH FROM CAST(dt.d1 AS TIMESTAMP)) AS INT)\n ) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n 12 * (\n CAST(EXTRACT(YEAR FROM dt.t2) AS INT) - CAST(EXTRACT(YEAR FROM CAST(dt.d1 AS TIMESTAMP)) AS INT)\n ) + (\n CAST(EXTRACT(MONTH FROM dt.t2) AS INT) - CAST(EXTRACT(MONTH FROM CAST(dt.d1 AS TIMESTAMP)) AS INT)\n )", "diff|month|d1-t2::mysql": "SELECT\n dt.id AS `dt.id`,\n 12 * (\n YEAR(dt.t2) - YEAR(CAST(dt.d1 AS DATETIME))\n ) + (\n MONTH(dt.t2) - MONTH(CAST(dt.d1 AS DATETIME))\n ) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n 12 * (\n YEAR(dt.t2) - YEAR(CAST(dt.d1 AS DATETIME))\n ) + (\n MONTH(dt.t2) - MONTH(CAST(dt.d1 AS DATETIME))\n )", @@ -559,7 +559,7 @@ "diff|month|d1-t2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n 12 * (\n CAST(DATE_PART(YEAR, dt.t2) AS INT) - CAST(DATE_PART(YEAR, CAST(dt.d1 AS TIMESTAMP)) AS INT)\n ) + (\n CAST(DATE_PART(MONTH, dt.t2) AS INT) - CAST(DATE_PART(MONTH, CAST(dt.d1 AS TIMESTAMP)) AS INT)\n ) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n 12 * (\n CAST(DATE_PART(YEAR, dt.t2) AS INT) - CAST(DATE_PART(YEAR, CAST(dt.d1 AS TIMESTAMP)) AS INT)\n ) + (\n CAST(DATE_PART(MONTH, dt.t2) AS INT) - CAST(DATE_PART(MONTH, CAST(dt.d1 AS TIMESTAMP)) AS INT)\n )", "diff|month|d1-t2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n 12 * (\n CAST(STRFTIME('%Y', dt.t2) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME(dt.d1)) AS INTEGER)\n ) + (\n CAST(STRFTIME('%m', dt.t2) AS INTEGER) - CAST(STRFTIME('%m', DATETIME(dt.d1)) AS INTEGER)\n ) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n 12 * (\n CAST(STRFTIME('%Y', dt.t2) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME(dt.d1)) AS INTEGER)\n ) + (\n CAST(STRFTIME('%m', dt.t2) AS INTEGER) - CAST(STRFTIME('%m', DATETIME(dt.d1)) AS INTEGER)\n )", "diff|month|d1-t2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(MONTH, CAST(dt.d1 AS DATETIME2), dt.t2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(MONTH, CAST(dt.d1 AS DATETIME2), dt.t2)", - "diff|month|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(CAST(dt.d2 AS TIMESTAMP) AS DATE), CAST(dt.t1 AS DATE), MONTH) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(CAST(dt.d2 AS TIMESTAMP) AS DATE), CAST(dt.t1 AS DATE), MONTH)", + "diff|month|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(CAST(dt.d2 AS DATETIME) AS DATE), CAST(dt.t1 AS DATE), MONTH) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(CAST(dt.d2 AS DATETIME) AS DATE), CAST(dt.t1 AS DATE), MONTH)", "diff|month|t1-d2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('month', dt.t1, toDateTime64(dt.d2, 6)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('month', dt.t1, toDateTime64(dt.d2, 6))", "diff|month|t1-d2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n 12 * (\n CAST(EXTRACT(YEAR FROM CAST(dt.d2 AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM dt.t1) AS INT)\n ) + (\n CAST(EXTRACT(MONTH FROM CAST(dt.d2 AS TIMESTAMP)) AS INT) - CAST(EXTRACT(MONTH FROM dt.t1) AS INT)\n ) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n 12 * (\n CAST(EXTRACT(YEAR FROM CAST(dt.d2 AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM dt.t1) AS INT)\n ) + (\n CAST(EXTRACT(MONTH FROM CAST(dt.d2 AS TIMESTAMP)) AS INT) - CAST(EXTRACT(MONTH FROM dt.t1) AS INT)\n )", "diff|month|t1-d2::mysql": "SELECT\n dt.id AS `dt.id`,\n 12 * (\n YEAR(CAST(dt.d2 AS DATETIME)) - YEAR(dt.t1)\n ) + (\n MONTH(CAST(dt.d2 AS DATETIME)) - MONTH(dt.t1)\n ) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n 12 * (\n YEAR(CAST(dt.d2 AS DATETIME)) - YEAR(dt.t1)\n ) + (\n MONTH(CAST(dt.d2 AS DATETIME)) - MONTH(dt.t1)\n )", @@ -583,7 +583,7 @@ "diff|quarter|d1-d2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n 4 * (\n CAST(DATE_PART(YEAR, dt.d2) AS INT) - CAST(DATE_PART(YEAR, dt.d1) AS INT)\n ) + (\n CAST(DATE_PART(QUARTER, dt.d2) AS INT) - CAST(DATE_PART(QUARTER, dt.d1) AS INT)\n ) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n 4 * (\n CAST(DATE_PART(YEAR, dt.d2) AS INT) - CAST(DATE_PART(YEAR, dt.d1) AS INT)\n ) + (\n CAST(DATE_PART(QUARTER, dt.d2) AS INT) - CAST(DATE_PART(QUARTER, dt.d1) AS INT)\n )", "diff|quarter|d1-d2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n 4 * (\n CAST(STRFTIME('%Y', dt.d2) AS INTEGER) - CAST(STRFTIME('%Y', dt.d1) AS INTEGER)\n ) + (\n CAST(CAST((\n CAST(STRFTIME('%m', dt.d2) AS INTEGER) + 2\n ) AS REAL) / 3 AS INTEGER) - CAST(CAST((\n CAST(STRFTIME('%m', dt.d1) AS INTEGER) + 2\n ) AS REAL) / 3 AS INTEGER)\n ) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n 4 * (\n CAST(STRFTIME('%Y', dt.d2) AS INTEGER) - CAST(STRFTIME('%Y', dt.d1) AS INTEGER)\n ) + (\n CAST(CAST((\n CAST(STRFTIME('%m', dt.d2) AS INTEGER) + 2\n ) AS REAL) / 3 AS INTEGER) - CAST(CAST((\n CAST(STRFTIME('%m', dt.d1) AS INTEGER) + 2\n ) AS REAL) / 3 AS INTEGER)\n )", "diff|quarter|d1-d2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(QUARTER, dt.d1, dt.d2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(QUARTER, dt.d1, dt.d2)", - "diff|quarter|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS TIMESTAMP) AS DATE), QUARTER) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS TIMESTAMP) AS DATE), QUARTER)", + "diff|quarter|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS DATETIME) AS DATE), QUARTER) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS DATETIME) AS DATE), QUARTER)", "diff|quarter|d1-t2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('quarter', toDateTime64(dt.d1, 6), dt.t2) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('quarter', toDateTime64(dt.d1, 6), dt.t2)", "diff|quarter|d1-t2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n 4 * (\n CAST(EXTRACT(YEAR FROM dt.t2) AS INT) - CAST(EXTRACT(YEAR FROM CAST(dt.d1 AS TIMESTAMP)) AS INT)\n ) + (\n CAST(EXTRACT(QUARTER FROM dt.t2) AS INT) - CAST(EXTRACT(QUARTER FROM CAST(dt.d1 AS TIMESTAMP)) AS INT)\n ) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n 4 * (\n CAST(EXTRACT(YEAR FROM dt.t2) AS INT) - CAST(EXTRACT(YEAR FROM CAST(dt.d1 AS TIMESTAMP)) AS INT)\n ) + (\n CAST(EXTRACT(QUARTER FROM dt.t2) AS INT) - CAST(EXTRACT(QUARTER FROM CAST(dt.d1 AS TIMESTAMP)) AS INT)\n )", "diff|quarter|d1-t2::mysql": "SELECT\n dt.id AS `dt.id`,\n 4 * (\n YEAR(dt.t2) - YEAR(CAST(dt.d1 AS DATETIME))\n ) + (\n QUARTER(dt.t2) - QUARTER(CAST(dt.d1 AS DATETIME))\n ) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n 4 * (\n YEAR(dt.t2) - YEAR(CAST(dt.d1 AS DATETIME))\n ) + (\n QUARTER(dt.t2) - QUARTER(CAST(dt.d1 AS DATETIME))\n )", @@ -591,7 +591,7 @@ "diff|quarter|d1-t2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n 4 * (\n CAST(DATE_PART(YEAR, dt.t2) AS INT) - CAST(DATE_PART(YEAR, CAST(dt.d1 AS TIMESTAMP)) AS INT)\n ) + (\n CAST(DATE_PART(QUARTER, dt.t2) AS INT) - CAST(DATE_PART(QUARTER, CAST(dt.d1 AS TIMESTAMP)) AS INT)\n ) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n 4 * (\n CAST(DATE_PART(YEAR, dt.t2) AS INT) - CAST(DATE_PART(YEAR, CAST(dt.d1 AS TIMESTAMP)) AS INT)\n ) + (\n CAST(DATE_PART(QUARTER, dt.t2) AS INT) - CAST(DATE_PART(QUARTER, CAST(dt.d1 AS TIMESTAMP)) AS INT)\n )", "diff|quarter|d1-t2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n 4 * (\n CAST(STRFTIME('%Y', dt.t2) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME(dt.d1)) AS INTEGER)\n ) + (\n CAST(CAST((\n CAST(STRFTIME('%m', dt.t2) AS INTEGER) + 2\n ) AS REAL) / 3 AS INTEGER) - CAST(CAST((\n CAST(STRFTIME('%m', DATETIME(dt.d1)) AS INTEGER) + 2\n ) AS REAL) / 3 AS INTEGER)\n ) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n 4 * (\n CAST(STRFTIME('%Y', dt.t2) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME(dt.d1)) AS INTEGER)\n ) + (\n CAST(CAST((\n CAST(STRFTIME('%m', dt.t2) AS INTEGER) + 2\n ) AS REAL) / 3 AS INTEGER) - CAST(CAST((\n CAST(STRFTIME('%m', DATETIME(dt.d1)) AS INTEGER) + 2\n ) AS REAL) / 3 AS INTEGER)\n )", "diff|quarter|d1-t2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(QUARTER, CAST(dt.d1 AS DATETIME2), dt.t2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(QUARTER, CAST(dt.d1 AS DATETIME2), dt.t2)", - "diff|quarter|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(CAST(dt.d2 AS TIMESTAMP) AS DATE), CAST(dt.t1 AS DATE), QUARTER) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(CAST(dt.d2 AS TIMESTAMP) AS DATE), CAST(dt.t1 AS DATE), QUARTER)", + "diff|quarter|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(CAST(dt.d2 AS DATETIME) AS DATE), CAST(dt.t1 AS DATE), QUARTER) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(CAST(dt.d2 AS DATETIME) AS DATE), CAST(dt.t1 AS DATE), QUARTER)", "diff|quarter|t1-d2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('quarter', dt.t1, toDateTime64(dt.d2, 6)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('quarter', dt.t1, toDateTime64(dt.d2, 6))", "diff|quarter|t1-d2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n 4 * (\n CAST(EXTRACT(YEAR FROM CAST(dt.d2 AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM dt.t1) AS INT)\n ) + (\n CAST(EXTRACT(QUARTER FROM CAST(dt.d2 AS TIMESTAMP)) AS INT) - CAST(EXTRACT(QUARTER FROM dt.t1) AS INT)\n ) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n 4 * (\n CAST(EXTRACT(YEAR FROM CAST(dt.d2 AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM dt.t1) AS INT)\n ) + (\n CAST(EXTRACT(QUARTER FROM CAST(dt.d2 AS TIMESTAMP)) AS INT) - CAST(EXTRACT(QUARTER FROM dt.t1) AS INT)\n )", "diff|quarter|t1-d2::mysql": "SELECT\n dt.id AS `dt.id`,\n 4 * (\n YEAR(CAST(dt.d2 AS DATETIME)) - YEAR(dt.t1)\n ) + (\n QUARTER(CAST(dt.d2 AS DATETIME)) - QUARTER(dt.t1)\n ) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n 4 * (\n YEAR(CAST(dt.d2 AS DATETIME)) - YEAR(dt.t1)\n ) + (\n QUARTER(CAST(dt.d2 AS DATETIME)) - QUARTER(dt.t1)\n )", @@ -607,7 +607,7 @@ "diff|quarter|t1-t2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n 4 * (\n CAST(DATE_PART(YEAR, dt.t2) AS INT) - CAST(DATE_PART(YEAR, dt.t1) AS INT)\n ) + (\n CAST(DATE_PART(QUARTER, dt.t2) AS INT) - CAST(DATE_PART(QUARTER, dt.t1) AS INT)\n ) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n 4 * (\n CAST(DATE_PART(YEAR, dt.t2) AS INT) - CAST(DATE_PART(YEAR, dt.t1) AS INT)\n ) + (\n CAST(DATE_PART(QUARTER, dt.t2) AS INT) - CAST(DATE_PART(QUARTER, dt.t1) AS INT)\n )", "diff|quarter|t1-t2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n 4 * (\n CAST(STRFTIME('%Y', dt.t2) AS INTEGER) - CAST(STRFTIME('%Y', dt.t1) AS INTEGER)\n ) + (\n CAST(CAST((\n CAST(STRFTIME('%m', dt.t2) AS INTEGER) + 2\n ) AS REAL) / 3 AS INTEGER) - CAST(CAST((\n CAST(STRFTIME('%m', dt.t1) AS INTEGER) + 2\n ) AS REAL) / 3 AS INTEGER)\n ) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n 4 * (\n CAST(STRFTIME('%Y', dt.t2) AS INTEGER) - CAST(STRFTIME('%Y', dt.t1) AS INTEGER)\n ) + (\n CAST(CAST((\n CAST(STRFTIME('%m', dt.t2) AS INTEGER) + 2\n ) AS REAL) / 3 AS INTEGER) - CAST(CAST((\n CAST(STRFTIME('%m', dt.t1) AS INTEGER) + 2\n ) AS REAL) / 3 AS INTEGER)\n )", "diff|quarter|t1-t2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(QUARTER, dt.t1, dt.t2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(QUARTER, dt.t1, dt.t2)", - "diff|second|d1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(dt.d2 AS TIMESTAMP), SECOND),\n TIMESTAMP_TRUNC(CAST(dt.d1 AS TIMESTAMP), SECOND),\n SECOND\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(dt.d2 AS TIMESTAMP), SECOND),\n TIMESTAMP_TRUNC(CAST(dt.d1 AS TIMESTAMP), SECOND),\n SECOND\n )", + "diff|second|d1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.d2 AS DATETIME), SECOND),\n DATETIME_TRUNC(CAST(dt.d1 AS DATETIME), SECOND),\n SECOND\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.d2 AS DATETIME), SECOND),\n DATETIME_TRUNC(CAST(dt.d1 AS DATETIME), SECOND),\n SECOND\n )", "diff|second|d1-d2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('second', toDateTime64(dt.d1, 6), toDateTime64(dt.d2, 6)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('second', toDateTime64(dt.d1, 6), toDateTime64(dt.d2, 6))", "diff|second|d1-d2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('SECOND', CAST(dt.d2 AS TIMESTAMP)) - DATE_TRUNC('SECOND', CAST(dt.d1 AS TIMESTAMP))\n )) AS BIGINT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('SECOND', CAST(dt.d2 AS TIMESTAMP)) - DATE_TRUNC('SECOND', CAST(dt.d1 AS TIMESTAMP))\n )) AS BIGINT)", "diff|second|d1-d2::mysql": "SELECT\n dt.id AS `dt.id`,\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(CAST(dt.d1 AS DATETIME), '%Y-%m-%d %H:%i:%s') AS DATETIME),\n CAST(DATE_FORMAT(CAST(dt.d2 AS DATETIME), '%Y-%m-%d %H:%i:%s') AS DATETIME)\n ) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(CAST(dt.d1 AS DATETIME), '%Y-%m-%d %H:%i:%s') AS DATETIME),\n CAST(DATE_FORMAT(CAST(dt.d2 AS DATETIME), '%Y-%m-%d %H:%i:%s') AS DATETIME)\n )", @@ -615,7 +615,7 @@ "diff|second|d1-d2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEDIFF(\n SECOND,\n DATE_TRUNC('SECOND', CAST(dt.d1 AS TIMESTAMP)),\n DATE_TRUNC('SECOND', CAST(dt.d2 AS TIMESTAMP))\n ) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF(\n SECOND,\n DATE_TRUNC('SECOND', CAST(dt.d1 AS TIMESTAMP)),\n DATE_TRUNC('SECOND', CAST(dt.d2 AS TIMESTAMP))\n )", "diff|second|d1-d2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:%S', DATETIME(dt.d2))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:%S', DATETIME(dt.d1))) AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:%S', DATETIME(dt.d2))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:%S', DATETIME(dt.d1))) AS INTEGER)", "diff|second|d1-d2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(SECOND, CAST(dt.d1 AS DATETIME2), CAST(dt.d2 AS DATETIME2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(SECOND, CAST(dt.d1 AS DATETIME2), CAST(dt.d2 AS DATETIME2))", - "diff|second|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(dt.t2, SECOND),\n TIMESTAMP_TRUNC(CAST(dt.d1 AS TIMESTAMP), SECOND),\n SECOND\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(dt.t2, SECOND),\n TIMESTAMP_TRUNC(CAST(dt.d1 AS TIMESTAMP), SECOND),\n SECOND\n )", + "diff|second|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.t2 AS DATETIME), SECOND),\n DATETIME_TRUNC(CAST(dt.d1 AS DATETIME), SECOND),\n SECOND\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.t2 AS DATETIME), SECOND),\n DATETIME_TRUNC(CAST(dt.d1 AS DATETIME), SECOND),\n SECOND\n )", "diff|second|d1-t2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('second', toDateTime64(dt.d1, 6), dt.t2) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('second', toDateTime64(dt.d1, 6), dt.t2)", "diff|second|d1-t2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('SECOND', dt.t2) - DATE_TRUNC('SECOND', CAST(dt.d1 AS TIMESTAMP))\n )) AS BIGINT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('SECOND', dt.t2) - DATE_TRUNC('SECOND', CAST(dt.d1 AS TIMESTAMP))\n )) AS BIGINT)", "diff|second|d1-t2::mysql": "SELECT\n dt.id AS `dt.id`,\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(CAST(dt.d1 AS DATETIME), '%Y-%m-%d %H:%i:%s') AS DATETIME),\n CAST(DATE_FORMAT(dt.t2, '%Y-%m-%d %H:%i:%s') AS DATETIME)\n ) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(CAST(dt.d1 AS DATETIME), '%Y-%m-%d %H:%i:%s') AS DATETIME),\n CAST(DATE_FORMAT(dt.t2, '%Y-%m-%d %H:%i:%s') AS DATETIME)\n )", @@ -623,7 +623,7 @@ "diff|second|d1-t2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEDIFF(SECOND, DATE_TRUNC('SECOND', CAST(dt.d1 AS TIMESTAMP)), DATE_TRUNC('SECOND', dt.t2)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF(SECOND, DATE_TRUNC('SECOND', CAST(dt.d1 AS TIMESTAMP)), DATE_TRUNC('SECOND', dt.t2))", "diff|second|d1-t2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:%S', dt.t2)) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:%S', DATETIME(dt.d1))) AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:%S', dt.t2)) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:%S', DATETIME(dt.d1))) AS INTEGER)", "diff|second|d1-t2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(SECOND, CAST(dt.d1 AS DATETIME2), dt.t2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(SECOND, CAST(dt.d1 AS DATETIME2), dt.t2)", - "diff|second|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(dt.d2 AS TIMESTAMP), SECOND),\n TIMESTAMP_TRUNC(dt.t1, SECOND),\n SECOND\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(dt.d2 AS TIMESTAMP), SECOND),\n TIMESTAMP_TRUNC(dt.t1, SECOND),\n SECOND\n )", + "diff|second|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.d2 AS DATETIME), SECOND),\n DATETIME_TRUNC(CAST(dt.t1 AS DATETIME), SECOND),\n SECOND\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.d2 AS DATETIME), SECOND),\n DATETIME_TRUNC(CAST(dt.t1 AS DATETIME), SECOND),\n SECOND\n )", "diff|second|t1-d2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('second', dt.t1, toDateTime64(dt.d2, 6)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('second', dt.t1, toDateTime64(dt.d2, 6))", "diff|second|t1-d2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('SECOND', CAST(dt.d2 AS TIMESTAMP)) - DATE_TRUNC('SECOND', dt.t1)\n )) AS BIGINT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('SECOND', CAST(dt.d2 AS TIMESTAMP)) - DATE_TRUNC('SECOND', dt.t1)\n )) AS BIGINT)", "diff|second|t1-d2::mysql": "SELECT\n dt.id AS `dt.id`,\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(dt.t1, '%Y-%m-%d %H:%i:%s') AS DATETIME),\n CAST(DATE_FORMAT(CAST(dt.d2 AS DATETIME), '%Y-%m-%d %H:%i:%s') AS DATETIME)\n ) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(dt.t1, '%Y-%m-%d %H:%i:%s') AS DATETIME),\n CAST(DATE_FORMAT(CAST(dt.d2 AS DATETIME), '%Y-%m-%d %H:%i:%s') AS DATETIME)\n )", @@ -631,7 +631,7 @@ "diff|second|t1-d2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEDIFF(SECOND, DATE_TRUNC('SECOND', dt.t1), DATE_TRUNC('SECOND', CAST(dt.d2 AS TIMESTAMP))) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF(SECOND, DATE_TRUNC('SECOND', dt.t1), DATE_TRUNC('SECOND', CAST(dt.d2 AS TIMESTAMP)))", "diff|second|t1-d2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:%S', DATETIME(dt.d2))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:%S', dt.t1)) AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:%S', DATETIME(dt.d2))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:%S', dt.t1)) AS INTEGER)", "diff|second|t1-d2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(SECOND, dt.t1, CAST(dt.d2 AS DATETIME2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(SECOND, dt.t1, CAST(dt.d2 AS DATETIME2))", - "diff|second|t1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_DIFF(TIMESTAMP_TRUNC(dt.t2, SECOND), TIMESTAMP_TRUNC(dt.t1, SECOND), SECOND) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_DIFF(TIMESTAMP_TRUNC(dt.t2, SECOND), TIMESTAMP_TRUNC(dt.t1, SECOND), SECOND)", + "diff|second|t1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.t2 AS DATETIME), SECOND),\n DATETIME_TRUNC(CAST(dt.t1 AS DATETIME), SECOND),\n SECOND\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(dt.t2 AS DATETIME), SECOND),\n DATETIME_TRUNC(CAST(dt.t1 AS DATETIME), SECOND),\n SECOND\n )", "diff|second|t1-t2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('second', dt.t1, dt.t2) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('second', dt.t1, dt.t2)", "diff|second|t1-t2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('SECOND', dt.t2) - DATE_TRUNC('SECOND', dt.t1)\n )) AS BIGINT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('SECOND', dt.t2) - DATE_TRUNC('SECOND', dt.t1)\n )) AS BIGINT)", "diff|second|t1-t2::mysql": "SELECT\n dt.id AS `dt.id`,\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(dt.t1, '%Y-%m-%d %H:%i:%s') AS DATETIME),\n CAST(DATE_FORMAT(dt.t2, '%Y-%m-%d %H:%i:%s') AS DATETIME)\n ) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMPDIFF(\n SECOND,\n CAST(DATE_FORMAT(dt.t1, '%Y-%m-%d %H:%i:%s') AS DATETIME),\n CAST(DATE_FORMAT(dt.t2, '%Y-%m-%d %H:%i:%s') AS DATETIME)\n )", @@ -647,7 +647,7 @@ "diff|week_sunday|d1-d2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST((\n CAST(DATEADD(DAY, -1, DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, dt.d2) AS TIMESTAMP))) AS DATE) - CAST(DATEADD(DAY, -1, DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, dt.d1) AS TIMESTAMP))) AS DATE)\n ) / 7 AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n CAST(DATEADD(DAY, -1, DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, dt.d2) AS TIMESTAMP))) AS DATE) - CAST(DATEADD(DAY, -1, DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, dt.d1) AS TIMESTAMP))) AS DATE)\n ) / 7 AS INT)", "diff|week_sunday|d1-d2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(CAST((\n CAST(JULIANDAY(\n DATE(\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(dt.d2, 1, 'day'), 'weekday 0', '-6 days'), -1, 'day')\n )\n ) - JULIANDAY(\n DATE(\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(dt.d1, 1, 'day'), 'weekday 0', '-6 days'), -1, 'day')\n )\n ) AS INTEGER)\n ) AS REAL) / 7 AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(CAST((\n CAST(JULIANDAY(\n DATE(\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(dt.d2, 1, 'day'), 'weekday 0', '-6 days'), -1, 'day')\n )\n ) - JULIANDAY(\n DATE(\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(dt.d1, 1, 'day'), 'weekday 0', '-6 days'), -1, 'day')\n )\n ) AS INTEGER)\n ) AS REAL) / 7 AS INTEGER)", "diff|week_sunday|d1-d2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(WEEK, dt.d1, dt.d2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(WEEK, dt.d1, dt.d2)", - "diff|week_sunday|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS TIMESTAMP) AS DATE), WEEK(SUNDAY)) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS TIMESTAMP) AS DATE), WEEK(SUNDAY))", + "diff|week_sunday|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS DATETIME) AS DATE), WEEK(SUNDAY)) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS DATETIME) AS DATE), WEEK(SUNDAY))", "diff|week_sunday|d1-t2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n CAST((\n CAST(addDays(dateTrunc('WEEK', CAST(addDays(dt.t2, 1) AS Nullable(DateTime))), -1) AS Nullable(DATE)) - CAST(addDays(\n dateTrunc('WEEK', CAST(addDays(toDateTime64(dt.d1, 6), 1) AS Nullable(DateTime))),\n -1\n ) AS Nullable(DATE))\n ) / 7 AS Nullable(Int32)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n CAST(addDays(dateTrunc('WEEK', CAST(addDays(dt.t2, 1) AS Nullable(DateTime))), -1) AS Nullable(DATE)) - CAST(addDays(\n dateTrunc('WEEK', CAST(addDays(toDateTime64(dt.d1, 6), 1) AS Nullable(DateTime))),\n -1\n ) AS Nullable(DATE))\n ) / 7 AS Nullable(Int32))", "diff|week_sunday|d1-t2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n (\n CAST(DATE_TRUNC('WEEK', CAST(dt.t2 + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY AS DATE) - CAST(DATE_TRUNC('WEEK', CAST(CAST(dt.d1 AS TIMESTAMP) + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY AS DATE)\n ) // 7 AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n (\n CAST(DATE_TRUNC('WEEK', CAST(dt.t2 + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY AS DATE) - CAST(DATE_TRUNC('WEEK', CAST(CAST(dt.d1 AS TIMESTAMP) + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY AS DATE)\n ) // 7", "diff|week_sunday|d1-t2::mysql": "SELECT\n dt.id AS `dt.id`,\n CAST((\n DATEDIFF(\n DATE_ADD(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(dt.t2, INTERVAL 1 DAY) AS DATETIME)), ' ', WEEK(CAST(DATE_ADD(dt.t2, INTERVAL 1 DAY) AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n INTERVAL -1 DAY\n ),\n DATE_ADD(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(CAST(dt.d1 AS DATETIME), INTERVAL 1 DAY) AS DATETIME)), ' ', WEEK(CAST(DATE_ADD(CAST(dt.d1 AS DATETIME), INTERVAL 1 DAY) AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n INTERVAL -1 DAY\n )\n )\n ) / 7 AS SIGNED) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n DATEDIFF(\n DATE_ADD(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(dt.t2, INTERVAL 1 DAY) AS DATETIME)), ' ', WEEK(CAST(DATE_ADD(dt.t2, INTERVAL 1 DAY) AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n INTERVAL -1 DAY\n ),\n DATE_ADD(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(CAST(dt.d1 AS DATETIME), INTERVAL 1 DAY) AS DATETIME)), ' ', WEEK(CAST(DATE_ADD(CAST(dt.d1 AS DATETIME), INTERVAL 1 DAY) AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n INTERVAL -1 DAY\n )\n )\n ) / 7 AS SIGNED)", @@ -655,7 +655,7 @@ "diff|week_sunday|d1-t2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST((\n CAST(DATEADD(DAY, -1, DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, dt.t2) AS TIMESTAMP))) AS DATE) - CAST(DATEADD(\n DAY,\n -1,\n DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, CAST(dt.d1 AS TIMESTAMP)) AS TIMESTAMP))\n ) AS DATE)\n ) / 7 AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n CAST(DATEADD(DAY, -1, DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, dt.t2) AS TIMESTAMP))) AS DATE) - CAST(DATEADD(\n DAY,\n -1,\n DATE_TRUNC('WEEK', CAST(DATEADD(DAY, 1, CAST(dt.d1 AS TIMESTAMP)) AS TIMESTAMP))\n ) AS DATE)\n ) / 7 AS INT)", "diff|week_sunday|d1-t2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(CAST((\n CAST(JULIANDAY(\n DATE(\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(dt.t2, 1, 'day'), 'weekday 0', '-6 days'), -1, 'day')\n )\n ) - JULIANDAY(\n DATE(\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(DATETIME(dt.d1), 1, 'day'), 'weekday 0', '-6 days'), -1, 'day')\n )\n ) AS INTEGER)\n ) AS REAL) / 7 AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(CAST((\n CAST(JULIANDAY(\n DATE(\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(dt.t2, 1, 'day'), 'weekday 0', '-6 days'), -1, 'day')\n )\n ) - JULIANDAY(\n DATE(\n SLAYER_DATE_ADD(DATE(SLAYER_DATE_ADD(DATETIME(dt.d1), 1, 'day'), 'weekday 0', '-6 days'), -1, 'day')\n )\n ) AS INTEGER)\n ) AS REAL) / 7 AS INTEGER)", "diff|week_sunday|d1-t2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(WEEK, CAST(dt.d1 AS DATETIME2), dt.t2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(WEEK, CAST(dt.d1 AS DATETIME2), dt.t2)", - "diff|week_sunday|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(CAST(dt.d2 AS TIMESTAMP) AS DATE), CAST(dt.t1 AS DATE), WEEK(SUNDAY)) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(CAST(dt.d2 AS TIMESTAMP) AS DATE), CAST(dt.t1 AS DATE), WEEK(SUNDAY))", + "diff|week_sunday|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(CAST(dt.d2 AS DATETIME) AS DATE), CAST(dt.t1 AS DATE), WEEK(SUNDAY)) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(CAST(dt.d2 AS DATETIME) AS DATE), CAST(dt.t1 AS DATE), WEEK(SUNDAY))", "diff|week_sunday|t1-d2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n CAST((\n CAST(addDays(\n dateTrunc('WEEK', CAST(addDays(toDateTime64(dt.d2, 6), 1) AS Nullable(DateTime))),\n -1\n ) AS Nullable(DATE)) - CAST(addDays(dateTrunc('WEEK', CAST(addDays(dt.t1, 1) AS Nullable(DateTime))), -1) AS Nullable(DATE))\n ) / 7 AS Nullable(Int32)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n CAST(addDays(\n dateTrunc('WEEK', CAST(addDays(toDateTime64(dt.d2, 6), 1) AS Nullable(DateTime))),\n -1\n ) AS Nullable(DATE)) - CAST(addDays(dateTrunc('WEEK', CAST(addDays(dt.t1, 1) AS Nullable(DateTime))), -1) AS Nullable(DATE))\n ) / 7 AS Nullable(Int32))", "diff|week_sunday|t1-d2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n (\n CAST(DATE_TRUNC('WEEK', CAST(CAST(dt.d2 AS TIMESTAMP) + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY AS DATE) - CAST(DATE_TRUNC('WEEK', CAST(dt.t1 + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY AS DATE)\n ) // 7 AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n (\n CAST(DATE_TRUNC('WEEK', CAST(CAST(dt.d2 AS TIMESTAMP) + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY AS DATE) - CAST(DATE_TRUNC('WEEK', CAST(dt.t1 + INTERVAL 1 DAY AS TIMESTAMP)) - INTERVAL 1 DAY AS DATE)\n ) // 7", "diff|week_sunday|t1-d2::mysql": "SELECT\n dt.id AS `dt.id`,\n CAST((\n DATEDIFF(\n DATE_ADD(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(CAST(dt.d2 AS DATETIME), INTERVAL 1 DAY) AS DATETIME)), ' ', WEEK(CAST(DATE_ADD(CAST(dt.d2 AS DATETIME), INTERVAL 1 DAY) AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n INTERVAL -1 DAY\n ),\n DATE_ADD(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(dt.t1, INTERVAL 1 DAY) AS DATETIME)), ' ', WEEK(CAST(DATE_ADD(dt.t1, INTERVAL 1 DAY) AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n INTERVAL -1 DAY\n )\n )\n ) / 7 AS SIGNED) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n DATEDIFF(\n DATE_ADD(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(CAST(dt.d2 AS DATETIME), INTERVAL 1 DAY) AS DATETIME)), ' ', WEEK(CAST(DATE_ADD(CAST(dt.d2 AS DATETIME), INTERVAL 1 DAY) AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n INTERVAL -1 DAY\n ),\n DATE_ADD(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(DATE_ADD(dt.t1, INTERVAL 1 DAY) AS DATETIME)), ' ', WEEK(CAST(DATE_ADD(dt.t1, INTERVAL 1 DAY) AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n INTERVAL -1 DAY\n )\n )\n ) / 7 AS SIGNED)", @@ -679,7 +679,7 @@ "diff|week|d1-d2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST((\n CAST(DATE_TRUNC('WEEK', dt.d2) AS DATE) - CAST(DATE_TRUNC('WEEK', dt.d1) AS DATE)\n ) / 7 AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n CAST(DATE_TRUNC('WEEK', dt.d2) AS DATE) - CAST(DATE_TRUNC('WEEK', dt.d1) AS DATE)\n ) / 7 AS INT)", "diff|week|d1-d2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(CAST((\n CAST(JULIANDAY(DATE(DATE(dt.d2, 'weekday 0', '-6 days'))) - JULIANDAY(DATE(DATE(dt.d1, 'weekday 0', '-6 days'))) AS INTEGER)\n ) AS REAL) / 7 AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(CAST((\n CAST(JULIANDAY(DATE(DATE(dt.d2, 'weekday 0', '-6 days'))) - JULIANDAY(DATE(DATE(dt.d1, 'weekday 0', '-6 days'))) AS INTEGER)\n ) AS REAL) / 7 AS INTEGER)", "diff|week|d1-d2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(WEEK, DATEADD(DAY, -1, dt.d1), DATEADD(DAY, -1, dt.d2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(WEEK, DATEADD(DAY, -1, dt.d1), DATEADD(DAY, -1, dt.d2))", - "diff|week|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS TIMESTAMP) AS DATE), WEEK(MONDAY)) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS TIMESTAMP) AS DATE), WEEK(MONDAY))", + "diff|week|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS DATETIME) AS DATE), WEEK(MONDAY)) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS DATETIME) AS DATE), WEEK(MONDAY))", "diff|week|d1-t2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n CAST((\n CAST(dateTrunc('WEEK', dt.t2) AS Nullable(DATE)) - CAST(dateTrunc('WEEK', CAST(toDateTime64(dt.d1, 6) AS Nullable(DateTime))) AS Nullable(DATE))\n ) / 7 AS Nullable(Int32)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n CAST(dateTrunc('WEEK', dt.t2) AS Nullable(DATE)) - CAST(dateTrunc('WEEK', CAST(toDateTime64(dt.d1, 6) AS Nullable(DateTime))) AS Nullable(DATE))\n ) / 7 AS Nullable(Int32))", "diff|week|d1-t2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n (\n CAST(DATE_TRUNC('WEEK', dt.t2) AS DATE) - CAST(DATE_TRUNC('WEEK', CAST(dt.d1 AS TIMESTAMP)) AS DATE)\n ) // 7 AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n (\n CAST(DATE_TRUNC('WEEK', dt.t2) AS DATE) - CAST(DATE_TRUNC('WEEK', CAST(dt.d1 AS TIMESTAMP)) AS DATE)\n ) // 7", "diff|week|d1-t2::mysql": "SELECT\n dt.id AS `dt.id`,\n CAST((\n DATEDIFF(\n STR_TO_DATE(CONCAT(YEAR(dt.t2), ' ', WEEK(dt.t2, 1), ' 1'), '%Y %u %w'),\n STR_TO_DATE(\n CONCAT(YEAR(CAST(dt.d1 AS DATETIME)), ' ', WEEK(CAST(dt.d1 AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n )\n )\n ) / 7 AS SIGNED) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n DATEDIFF(\n STR_TO_DATE(CONCAT(YEAR(dt.t2), ' ', WEEK(dt.t2, 1), ' 1'), '%Y %u %w'),\n STR_TO_DATE(\n CONCAT(YEAR(CAST(dt.d1 AS DATETIME)), ' ', WEEK(CAST(dt.d1 AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n )\n )\n ) / 7 AS SIGNED)", @@ -687,7 +687,7 @@ "diff|week|d1-t2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST((\n CAST(DATE_TRUNC('WEEK', dt.t2) AS DATE) - CAST(DATE_TRUNC('WEEK', CAST(dt.d1 AS TIMESTAMP)) AS DATE)\n ) / 7 AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n CAST(DATE_TRUNC('WEEK', dt.t2) AS DATE) - CAST(DATE_TRUNC('WEEK', CAST(dt.d1 AS TIMESTAMP)) AS DATE)\n ) / 7 AS INT)", "diff|week|d1-t2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(CAST((\n CAST(JULIANDAY(DATE(DATE(dt.t2, 'weekday 0', '-6 days'))) - JULIANDAY(DATE(DATE(DATETIME(dt.d1), 'weekday 0', '-6 days'))) AS INTEGER)\n ) AS REAL) / 7 AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(CAST((\n CAST(JULIANDAY(DATE(DATE(dt.t2, 'weekday 0', '-6 days'))) - JULIANDAY(DATE(DATE(DATETIME(dt.d1), 'weekday 0', '-6 days'))) AS INTEGER)\n ) AS REAL) / 7 AS INTEGER)", "diff|week|d1-t2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(WEEK, DATEADD(DAY, -1, CAST(dt.d1 AS DATETIME2)), DATEADD(DAY, -1, dt.t2)) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(WEEK, DATEADD(DAY, -1, CAST(dt.d1 AS DATETIME2)), DATEADD(DAY, -1, dt.t2))", - "diff|week|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(CAST(dt.d2 AS TIMESTAMP) AS DATE), CAST(dt.t1 AS DATE), WEEK(MONDAY)) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(CAST(dt.d2 AS TIMESTAMP) AS DATE), CAST(dt.t1 AS DATE), WEEK(MONDAY))", + "diff|week|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(CAST(dt.d2 AS DATETIME) AS DATE), CAST(dt.t1 AS DATE), WEEK(MONDAY)) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(CAST(dt.d2 AS DATETIME) AS DATE), CAST(dt.t1 AS DATE), WEEK(MONDAY))", "diff|week|t1-d2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n CAST((\n CAST(dateTrunc('WEEK', CAST(toDateTime64(dt.d2, 6) AS Nullable(DateTime))) AS Nullable(DATE)) - CAST(dateTrunc('WEEK', dt.t1) AS Nullable(DATE))\n ) / 7 AS Nullable(Int32)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n CAST(dateTrunc('WEEK', CAST(toDateTime64(dt.d2, 6) AS Nullable(DateTime))) AS Nullable(DATE)) - CAST(dateTrunc('WEEK', dt.t1) AS Nullable(DATE))\n ) / 7 AS Nullable(Int32))", "diff|week|t1-d2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n (\n CAST(DATE_TRUNC('WEEK', CAST(dt.d2 AS TIMESTAMP)) AS DATE) - CAST(DATE_TRUNC('WEEK', dt.t1) AS DATE)\n ) // 7 AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n (\n CAST(DATE_TRUNC('WEEK', CAST(dt.d2 AS TIMESTAMP)) AS DATE) - CAST(DATE_TRUNC('WEEK', dt.t1) AS DATE)\n ) // 7", "diff|week|t1-d2::mysql": "SELECT\n dt.id AS `dt.id`,\n CAST((\n DATEDIFF(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(dt.d2 AS DATETIME)), ' ', WEEK(CAST(dt.d2 AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n STR_TO_DATE(CONCAT(YEAR(dt.t1), ' ', WEEK(dt.t1, 1), ' 1'), '%Y %u %w')\n )\n ) / 7 AS SIGNED) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST((\n DATEDIFF(\n STR_TO_DATE(\n CONCAT(YEAR(CAST(dt.d2 AS DATETIME)), ' ', WEEK(CAST(dt.d2 AS DATETIME), 1), ' 1'),\n '%Y %u %w'\n ),\n STR_TO_DATE(CONCAT(YEAR(dt.t1), ' ', WEEK(dt.t1, 1), ' 1'), '%Y %u %w')\n )\n ) / 7 AS SIGNED)", @@ -711,7 +711,7 @@ "diff|year|d1-d2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST(DATE_PART(YEAR, dt.d2) AS INT) - CAST(DATE_PART(YEAR, dt.d1) AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(DATE_PART(YEAR, dt.d2) AS INT) - CAST(DATE_PART(YEAR, dt.d1) AS INT)", "diff|year|d1-d2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(STRFTIME('%Y', dt.d2) AS INTEGER) - CAST(STRFTIME('%Y', dt.d1) AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(STRFTIME('%Y', dt.d2) AS INTEGER) - CAST(STRFTIME('%Y', dt.d1) AS INTEGER)", "diff|year|d1-d2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(YEAR, dt.d1, dt.d2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(YEAR, dt.d1, dt.d2)", - "diff|year|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS TIMESTAMP) AS DATE), YEAR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS TIMESTAMP) AS DATE), YEAR)", + "diff|year|d1-t2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS DATETIME) AS DATE), YEAR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(dt.t2 AS DATE), CAST(CAST(dt.d1 AS DATETIME) AS DATE), YEAR)", "diff|year|d1-t2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('year', toDateTime64(dt.d1, 6), dt.t2) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('year', toDateTime64(dt.d1, 6), dt.t2)", "diff|year|d1-t2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n CAST(EXTRACT(YEAR FROM dt.t2) AS INT) - CAST(EXTRACT(YEAR FROM CAST(dt.d1 AS TIMESTAMP)) AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(EXTRACT(YEAR FROM dt.t2) AS INT) - CAST(EXTRACT(YEAR FROM CAST(dt.d1 AS TIMESTAMP)) AS INT)", "diff|year|d1-t2::mysql": "SELECT\n dt.id AS `dt.id`,\n YEAR(dt.t2) - YEAR(CAST(dt.d1 AS DATETIME)) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n YEAR(dt.t2) - YEAR(CAST(dt.d1 AS DATETIME))", @@ -719,7 +719,7 @@ "diff|year|d1-t2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST(DATE_PART(YEAR, dt.t2) AS INT) - CAST(DATE_PART(YEAR, CAST(dt.d1 AS TIMESTAMP)) AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(DATE_PART(YEAR, dt.t2) AS INT) - CAST(DATE_PART(YEAR, CAST(dt.d1 AS TIMESTAMP)) AS INT)", "diff|year|d1-t2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(STRFTIME('%Y', dt.t2) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME(dt.d1)) AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(STRFTIME('%Y', dt.t2) AS INTEGER) - CAST(STRFTIME('%Y', DATETIME(dt.d1)) AS INTEGER)", "diff|year|d1-t2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(YEAR, CAST(dt.d1 AS DATETIME2), dt.t2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(YEAR, CAST(dt.d1 AS DATETIME2), dt.t2)", - "diff|year|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(CAST(dt.d2 AS TIMESTAMP) AS DATE), CAST(dt.t1 AS DATE), YEAR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(CAST(dt.d2 AS TIMESTAMP) AS DATE), CAST(dt.t1 AS DATE), YEAR)", + "diff|year|t1-d2::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(CAST(dt.d2 AS DATETIME) AS DATE), CAST(dt.t1 AS DATE), YEAR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(CAST(dt.d2 AS DATETIME) AS DATE), CAST(dt.t1 AS DATE), YEAR)", "diff|year|t1-d2::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('year', dt.t1, toDateTime64(dt.d2, 6)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('year', dt.t1, toDateTime64(dt.d2, 6))", "diff|year|t1-d2::duckdb": "SELECT\n dt.id AS \"dt.id\",\n CAST(EXTRACT(YEAR FROM CAST(dt.d2 AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM dt.t1) AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(EXTRACT(YEAR FROM CAST(dt.d2 AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM dt.t1) AS INT)", "diff|year|t1-d2::mysql": "SELECT\n dt.id AS `dt.id`,\n YEAR(CAST(dt.d2 AS DATETIME)) - YEAR(dt.t1) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n YEAR(CAST(dt.d2 AS DATETIME)) - YEAR(dt.t1)", @@ -735,7 +735,7 @@ "diff|year|t1-t2::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST(DATE_PART(YEAR, dt.t2) AS INT) - CAST(DATE_PART(YEAR, dt.t1) AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(DATE_PART(YEAR, dt.t2) AS INT) - CAST(DATE_PART(YEAR, dt.t1) AS INT)", "diff|year|t1-t2::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(STRFTIME('%Y', dt.t2) AS INTEGER) - CAST(STRFTIME('%Y', dt.t1) AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(STRFTIME('%Y', dt.t2) AS INTEGER) - CAST(STRFTIME('%Y', dt.t1) AS INTEGER)", "diff|year|t1-t2::tsql": "SELECT\n dt.id AS [dt___id],\n DATEDIFF_BIG(YEAR, dt.t1, dt.t2) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF_BIG(YEAR, dt.t1, dt.t2)", - "interval|chain|t1::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL 2 HOUR\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL 2 HOUR\n )", + "interval|chain|t1::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL 2 HOUR\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL 2 HOUR\n )", "interval|chain|t1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addHours(addMonths(dt.t1, 1), 2) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addHours(addMonths(dt.t1, 1), 2)", "interval|chain|t1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + INTERVAL 1 MONTH + INTERVAL 2 HOUR AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + INTERVAL 1 MONTH + INTERVAL 2 HOUR", "interval|chain|t1::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(DATE_ADD(dt.t1, INTERVAL 1 MONTH), INTERVAL 2 HOUR) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(DATE_ADD(dt.t1, INTERVAL 1 MONTH), INTERVAL 2 HOUR)", @@ -751,7 +751,7 @@ "interval|commuted|d1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(WEEK, 2, dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(WEEK, 2, dt.d1)", "interval|commuted|d1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, 2, 'week') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, 2, 'week')", "interval|commuted|d1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(WEEK, 2, dt.d1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(WEEK, 2, dt.d1)", - "interval|minus_computed|t1::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(dt.t1, INTERVAL (CAST(TRUNC(-dt.n) AS INT64)) HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(dt.t1, INTERVAL (CAST(TRUNC(-dt.n) AS INT64)) HOUR)", + "interval|minus_computed|t1::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(-dt.n) AS INT64)) HOUR) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST(dt.t1 AS DATETIME), INTERVAL (CAST(TRUNC(-dt.n) AS INT64)) HOUR)", "interval|minus_computed|t1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addHours(dt.t1, CAST(trunc(-dt.n) AS Nullable(Int32))) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addHours(dt.t1, CAST(trunc(-dt.n) AS Nullable(Int32)))", "interval|minus_computed|t1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n dt.t1 + (\n CAST(TRUNC(-dt.n) AS INT)\n ) * INTERVAL 1 HOUR AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dt.t1 + (\n CAST(TRUNC(-dt.n) AS INT)\n ) * INTERVAL 1 HOUR", "interval|minus_computed|t1::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(-dt.n, 0) AS SIGNED)) HOUR) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(dt.t1, INTERVAL (CAST(TRUNCATE(-dt.n, 0) AS SIGNED)) HOUR)", @@ -767,7 +767,7 @@ "interval|plus|d1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n DATEADD(MONTH, 1, dt.d1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MONTH, 1, dt.d1)", "interval|plus|d1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n SLAYER_DATE_ADD(dt.d1, 1, 'month') AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n SLAYER_DATE_ADD(dt.d1, 1, 'month')", "interval|plus|d1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEADD(MONTH, 1, dt.d1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEADD(MONTH, 1, dt.d1)", - "literal|date::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(\n CAST(dt.t1 AS DATE),\n CAST(CAST(CAST('2024-01-01' AS DATE) AS TIMESTAMP) AS DATE),\n DAY\n ) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(\n CAST(dt.t1 AS DATE),\n CAST(CAST(CAST('2024-01-01' AS DATE) AS TIMESTAMP) AS DATE),\n DAY\n )", + "literal|date::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATE_DIFF(CAST(dt.t1 AS DATE), CAST(CAST(CAST('2024-01-01' AS DATE) AS DATETIME) AS DATE), DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_DIFF(CAST(dt.t1 AS DATE), CAST(CAST(CAST('2024-01-01' AS DATE) AS DATETIME) AS DATE), DAY)", "literal|date::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n dateDiff('day', toDateTime64(toDate('2024-01-01'), 6), dt.t1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n dateDiff('day', toDateTime64(toDate('2024-01-01'), 6), dt.t1)", "literal|date::duckdb": "SELECT\n dt.id AS \"dt.id\",\n CAST(dt.t1 AS DATE) - CAST(CAST(CAST('2024-01-01' AS DATE) AS TIMESTAMP) AS DATE) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(dt.t1 AS DATE) - CAST(CAST(CAST('2024-01-01' AS DATE) AS TIMESTAMP) AS DATE)", "literal|date::mysql": "SELECT\n dt.id AS `dt.id`,\n DATEDIFF(dt.t1, CAST(CAST('2024-01-01' AS DATE) AS DATETIME)) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEDIFF(dt.t1, CAST(CAST('2024-01-01' AS DATE) AS DATETIME))", @@ -783,7 +783,7 @@ "literal|in_coalesce::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST(DATE_PART(YEAR, COALESCE(dt.t2, CAST('2024-01-01' AS DATE))) AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(DATE_PART(YEAR, COALESCE(dt.t2, CAST('2024-01-01' AS DATE))) AS INT)", "literal|in_coalesce::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(STRFTIME('%Y', COALESCE(dt.t2, '2024-01-01')) AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(STRFTIME('%Y', COALESCE(dt.t2, '2024-01-01')) AS INTEGER)", "literal|in_coalesce::tsql": "SELECT\n dt.id AS [dt___id],\n DATEPART(YEAR, COALESCE(dt.t2, CAST('2024-01-01' AS DATE))) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEPART(YEAR, COALESCE(dt.t2, CAST('2024-01-01' AS DATE)))", - "literal|timestamp::bigquery": "SELECT\n dt.id AS `dt___id`,\n TIMESTAMP_ADD(CAST('2024-01-01 10:00:00' AS TIMESTAMP), INTERVAL 1 DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n TIMESTAMP_ADD(CAST('2024-01-01 10:00:00' AS TIMESTAMP), INTERVAL 1 DAY)", + "literal|timestamp::bigquery": "SELECT\n dt.id AS `dt___id`,\n DATETIME_ADD(CAST('2024-01-01 10:00:00' AS DATETIME), INTERVAL 1 DAY) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATETIME_ADD(CAST('2024-01-01 10:00:00' AS DATETIME), INTERVAL 1 DAY)", "literal|timestamp::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n addDays(toDateTime64('2024-01-01 10:00:00', 6), 1) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n addDays(toDateTime64('2024-01-01 10:00:00', 6), 1)", "literal|timestamp::duckdb": "SELECT\n dt.id AS \"dt.id\",\n CAST('2024-01-01 10:00:00' AS TIMESTAMP) + INTERVAL 1 DAY AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST('2024-01-01 10:00:00' AS TIMESTAMP) + INTERVAL 1 DAY", "literal|timestamp::mysql": "SELECT\n dt.id AS `dt.id`,\n DATE_ADD(CAST('2024-01-01 10:00:00' AS DATETIME), INTERVAL 1 DAY) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATE_ADD(CAST('2024-01-01 10:00:00' AS DATETIME), INTERVAL 1 DAY)", @@ -839,7 +839,7 @@ "part|day|t1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST(DATE_PART(DAY, dt.t1) AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(DATE_PART(DAY, dt.t1) AS INT)", "part|day|t1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(STRFTIME('%d', dt.t1) AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(STRFTIME('%d', dt.t1) AS INTEGER)", "part|day|t1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEPART(DAY, dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEPART(DAY, dt.t1)", - "part|hour|d1::bigquery": "SELECT\n dt.id AS `dt___id`,\n CAST(EXTRACT(HOUR FROM CAST(dt.d1 AS TIMESTAMP)) AS INT64) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(EXTRACT(HOUR FROM CAST(dt.d1 AS TIMESTAMP)) AS INT64)", + "part|hour|d1::bigquery": "SELECT\n dt.id AS `dt___id`,\n CAST(EXTRACT(HOUR FROM CAST(dt.d1 AS DATETIME)) AS INT64) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(EXTRACT(HOUR FROM CAST(dt.d1 AS DATETIME)) AS INT64)", "part|hour|d1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n toHour(toDateTime64(dt.d1, 6)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n toHour(toDateTime64(dt.d1, 6))", "part|hour|d1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n CAST(EXTRACT(HOUR FROM CAST(dt.d1 AS TIMESTAMP)) AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(EXTRACT(HOUR FROM CAST(dt.d1 AS TIMESTAMP)) AS INT)", "part|hour|d1::mysql": "SELECT\n dt.id AS `dt.id`,\n HOUR(CAST(dt.d1 AS DATETIME)) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n HOUR(CAST(dt.d1 AS DATETIME))", @@ -871,7 +871,7 @@ "part|iso_year|t1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST(DATE_PART(YEAROFWEEKISO, dt.t1) AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(DATE_PART(YEAROFWEEKISO, dt.t1) AS INT)", "part|iso_year|t1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(STRFTIME(\n '%Y',\n DATE(\n dt.t1,\n (\n 3 - (\n (\n CAST(STRFTIME('%w', dt.t1) AS INTEGER) + 6\n ) % 7\n )\n ) || ' days'\n )\n ) AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(STRFTIME(\n '%Y',\n DATE(\n dt.t1,\n (\n 3 - (\n (\n CAST(STRFTIME('%w', dt.t1) AS INTEGER) + 6\n ) % 7\n )\n ) || ' days'\n )\n ) AS INTEGER)", "part|iso_year|t1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEPART(\n YEAR,\n DATEADD(\n DAY,\n 3 - (\n (\n (\n DATEDIFF(DAY, CAST('1900-01-01' AS DATE), dt.t1) % 7\n ) + 7\n ) % 7\n ),\n dt.t1\n )\n ) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEPART(\n YEAR,\n DATEADD(\n DAY,\n 3 - (\n (\n (\n DATEDIFF(DAY, CAST('1900-01-01' AS DATE), dt.t1) % 7\n ) + 7\n ) % 7\n ),\n dt.t1\n )\n )", - "part|minute|d1::bigquery": "SELECT\n dt.id AS `dt___id`,\n CAST(EXTRACT(MINUTE FROM CAST(dt.d1 AS TIMESTAMP)) AS INT64) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(EXTRACT(MINUTE FROM CAST(dt.d1 AS TIMESTAMP)) AS INT64)", + "part|minute|d1::bigquery": "SELECT\n dt.id AS `dt___id`,\n CAST(EXTRACT(MINUTE FROM CAST(dt.d1 AS DATETIME)) AS INT64) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(EXTRACT(MINUTE FROM CAST(dt.d1 AS DATETIME)) AS INT64)", "part|minute|d1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n toMinute(toDateTime64(dt.d1, 6)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n toMinute(toDateTime64(dt.d1, 6))", "part|minute|d1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n CAST(EXTRACT(MINUTE FROM CAST(dt.d1 AS TIMESTAMP)) AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(EXTRACT(MINUTE FROM CAST(dt.d1 AS TIMESTAMP)) AS INT)", "part|minute|d1::mysql": "SELECT\n dt.id AS `dt.id`,\n MINUTE(CAST(dt.d1 AS DATETIME)) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n MINUTE(CAST(dt.d1 AS DATETIME))", @@ -919,7 +919,7 @@ "part|quarter|t1::snowflake": "SELECT\n dt.id AS \"dt.id\",\n CAST(DATE_PART(QUARTER, dt.t1) AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(DATE_PART(QUARTER, dt.t1) AS INT)", "part|quarter|t1::sqlite": "SELECT\n dt.id AS \"dt.id\",\n CAST(CAST((\n CAST(STRFTIME('%m', dt.t1) AS INTEGER) + 2\n ) AS REAL) / 3 AS INTEGER) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(CAST((\n CAST(STRFTIME('%m', dt.t1) AS INTEGER) + 2\n ) AS REAL) / 3 AS INTEGER)", "part|quarter|t1::tsql": "SELECT\n dt.id AS [dt___id],\n DATEPART(QUARTER, dt.t1) AS [dt___v]\nFROM dt AS dt\nGROUP BY\n dt.id,\n DATEPART(QUARTER, dt.t1)", - "part|second|d1::bigquery": "SELECT\n dt.id AS `dt___id`,\n CAST(FLOOR(EXTRACT(SECOND FROM CAST(dt.d1 AS TIMESTAMP))) AS INT64) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(FLOOR(EXTRACT(SECOND FROM CAST(dt.d1 AS TIMESTAMP))) AS INT64)", + "part|second|d1::bigquery": "SELECT\n dt.id AS `dt___id`,\n CAST(FLOOR(EXTRACT(SECOND FROM CAST(dt.d1 AS DATETIME))) AS INT64) AS `dt___v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(FLOOR(EXTRACT(SECOND FROM CAST(dt.d1 AS DATETIME))) AS INT64)", "part|second|d1::clickhouse": "SELECT\n dt.id AS \"dt.id\",\n toSecond(toDateTime64(dt.d1, 6)) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n toSecond(toDateTime64(dt.d1, 6))", "part|second|d1::duckdb": "SELECT\n dt.id AS \"dt.id\",\n CAST(FLOOR(EXTRACT(SECOND FROM CAST(dt.d1 AS TIMESTAMP))) AS INT) AS \"dt.v\"\nFROM dt AS dt\nGROUP BY\n dt.id,\n CAST(FLOOR(EXTRACT(SECOND FROM CAST(dt.d1 AS TIMESTAMP))) AS INT)", "part|second|d1::mysql": "SELECT\n dt.id AS `dt.id`,\n SECOND(CAST(dt.d1 AS DATETIME)) AS `dt.v`\nFROM dt AS dt\nGROUP BY\n dt.id,\n SECOND(CAST(dt.d1 AS DATETIME))", diff --git a/tests/golden/dev1747_sql_baseline.json b/tests/golden/dev1747_sql_baseline.json index ded92b317..c65d54ffc 100644 --- a/tests/golden/dev1747_sql_baseline.json +++ b/tests/golden/dev1747_sql_baseline.json @@ -1,5 +1,5 @@ { - "chain/consecutive_periods_two_names::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), cp_prev_streak_a AS (\n SELECT\n `orders___created_at`,\n `orders___amount_sum`,\n LAG(`orders___created_at`) OVER (ORDER BY `orders___created_at`) AS `_cp_prev_orders___streak_a`\n FROM base\n), cp_reset_streak_a AS (\n SELECT\n `orders___created_at`,\n `orders___amount_sum`,\n SUM(\n CASE\n WHEN NOT `orders___amount_sum` IS NULL\n AND `orders___amount_sum` <> 0\n AND CAST(`_cp_prev_orders___streak_a` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`orders___created_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___created_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___streak_a`\n FROM cp_prev_streak_a\n), cp_value_streak_a AS (\n SELECT\n `orders___created_at`,\n `orders___amount_sum`,\n CASE\n WHEN NOT `orders___amount_sum` IS NULL AND `orders___amount_sum` <> 0\n THEN SUM(\n CASE\n WHEN NOT `orders___amount_sum` IS NULL AND `orders___amount_sum` <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY `_cp_reset_orders___streak_a`\n ORDER BY `orders___created_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___streak_a`,\n CASE\n WHEN NOT `orders___amount_sum` IS NULL AND `orders___amount_sum` <> 0\n THEN SUM(\n CASE\n WHEN NOT `orders___amount_sum` IS NULL AND `orders___amount_sum` <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY `_cp_reset_orders___streak_a`\n ORDER BY `orders___created_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___streak_b`\n FROM cp_reset_streak_a\n)\nSELECT\n `orders___created_at`,\n `orders___streak_a`,\n `orders___streak_b`\nFROM (\n SELECT\n `orders___created_at`,\n `orders___amount_sum`,\n `orders___streak_a`,\n `orders___streak_b`\n FROM cp_value_streak_a\n) AS _outer", + "chain/consecutive_periods_two_names::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`,\n SUM(orders.amount) AS `orders___amount_sum`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), cp_prev_streak_a AS (\n SELECT\n `orders___created_at`,\n `orders___amount_sum`,\n LAG(`orders___created_at`) OVER (ORDER BY `orders___created_at`) AS `_cp_prev_orders___streak_a`\n FROM base\n), cp_reset_streak_a AS (\n SELECT\n `orders___created_at`,\n `orders___amount_sum`,\n SUM(\n CASE\n WHEN NOT `orders___amount_sum` IS NULL\n AND `orders___amount_sum` <> 0\n AND CAST(`_cp_prev_orders___streak_a` AS DATETIME) = DATETIME_ADD(CAST(`orders___created_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___created_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___streak_a`\n FROM cp_prev_streak_a\n), cp_value_streak_a AS (\n SELECT\n `orders___created_at`,\n `orders___amount_sum`,\n CASE\n WHEN NOT `orders___amount_sum` IS NULL AND `orders___amount_sum` <> 0\n THEN SUM(\n CASE\n WHEN NOT `orders___amount_sum` IS NULL AND `orders___amount_sum` <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY `_cp_reset_orders___streak_a`\n ORDER BY `orders___created_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___streak_a`,\n CASE\n WHEN NOT `orders___amount_sum` IS NULL AND `orders___amount_sum` <> 0\n THEN SUM(\n CASE\n WHEN NOT `orders___amount_sum` IS NULL AND `orders___amount_sum` <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY `_cp_reset_orders___streak_a`\n ORDER BY `orders___created_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___streak_b`\n FROM cp_reset_streak_a\n)\nSELECT\n `orders___created_at`,\n `orders___streak_a`,\n `orders___streak_b`\nFROM (\n SELECT\n `orders___created_at`,\n `orders___amount_sum`,\n `orders___streak_a`,\n `orders___streak_b`\n FROM cp_value_streak_a\n) AS _outer", "chain/consecutive_periods_two_names::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), cp_prev_streak_a AS (\n SELECT\n \"orders.created_at\",\n \"orders.amount_sum\",\n LAG(\"orders.created_at\") OVER (ORDER BY \"orders.created_at\") AS \"_cp_prev_orders.streak_a\"\n FROM base\n), cp_reset_streak_a AS (\n SELECT\n \"orders.created_at\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN NOT \"orders.amount_sum\" IS NULL\n AND \"orders.amount_sum\" <> 0\n AND \"_cp_prev_orders.streak_a\" = \"orders.created_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.created_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.streak_a\"\n FROM cp_prev_streak_a\n), cp_value_streak_a AS (\n SELECT\n \"orders.created_at\",\n \"orders.amount_sum\",\n CASE\n WHEN NOT \"orders.amount_sum\" IS NULL AND \"orders.amount_sum\" <> 0\n THEN SUM(\n CASE\n WHEN NOT \"orders.amount_sum\" IS NULL AND \"orders.amount_sum\" <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_orders.streak_a\"\n ORDER BY \"orders.created_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.streak_a\",\n CASE\n WHEN NOT \"orders.amount_sum\" IS NULL AND \"orders.amount_sum\" <> 0\n THEN SUM(\n CASE\n WHEN NOT \"orders.amount_sum\" IS NULL AND \"orders.amount_sum\" <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_orders.streak_a\"\n ORDER BY \"orders.created_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.streak_b\"\n FROM cp_reset_streak_a\n)\nSELECT\n \"orders.created_at\",\n \"orders.streak_a\",\n \"orders.streak_b\"\nFROM (\n SELECT\n \"orders.created_at\",\n \"orders.amount_sum\",\n \"orders.streak_a\",\n \"orders.streak_b\"\n FROM cp_value_streak_a\n) AS _outer", "chain/consecutive_periods_two_names::postgres": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), cp_prev_streak_a AS (\n SELECT\n \"orders.created_at\",\n \"orders.amount_sum\",\n LAG(\"orders.created_at\") OVER (ORDER BY \"orders.created_at\") AS \"_cp_prev_orders.streak_a\"\n FROM base\n), cp_reset_streak_a AS (\n SELECT\n \"orders.created_at\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN NOT \"orders.amount_sum\" IS NULL\n AND \"orders.amount_sum\" <> 0\n AND \"_cp_prev_orders.streak_a\" = \"orders.created_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.created_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.streak_a\"\n FROM cp_prev_streak_a\n), cp_value_streak_a AS (\n SELECT\n \"orders.created_at\",\n \"orders.amount_sum\",\n CASE\n WHEN NOT \"orders.amount_sum\" IS NULL AND \"orders.amount_sum\" <> 0\n THEN SUM(\n CASE\n WHEN NOT \"orders.amount_sum\" IS NULL AND \"orders.amount_sum\" <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_orders.streak_a\"\n ORDER BY \"orders.created_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.streak_a\",\n CASE\n WHEN NOT \"orders.amount_sum\" IS NULL AND \"orders.amount_sum\" <> 0\n THEN SUM(\n CASE\n WHEN NOT \"orders.amount_sum\" IS NULL AND \"orders.amount_sum\" <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_orders.streak_a\"\n ORDER BY \"orders.created_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.streak_b\"\n FROM cp_reset_streak_a\n)\nSELECT\n \"orders.created_at\",\n \"orders.streak_a\",\n \"orders.streak_b\"\nFROM (\n SELECT\n \"orders.created_at\",\n \"orders.amount_sum\",\n \"orders.streak_a\",\n \"orders.streak_b\"\n FROM cp_value_streak_a\n) AS _outer", "chain/consecutive_periods_two_names::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\",\n SUM(orders.amount) AS \"orders.amount_sum\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), cp_prev_streak_a AS (\n SELECT\n \"orders.created_at\",\n \"orders.amount_sum\",\n LAG(\"orders.created_at\") OVER (ORDER BY \"orders.created_at\") AS \"_cp_prev_orders.streak_a\"\n FROM base\n), cp_reset_streak_a AS (\n SELECT\n \"orders.created_at\",\n \"orders.amount_sum\",\n SUM(\n CASE\n WHEN NOT \"orders.amount_sum\" IS NULL\n AND \"orders.amount_sum\" <> 0\n AND \"_cp_prev_orders.streak_a\" = SLAYER_DATE_ADD(\"orders.created_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.created_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.streak_a\"\n FROM cp_prev_streak_a\n), cp_value_streak_a AS (\n SELECT\n \"orders.created_at\",\n \"orders.amount_sum\",\n CASE\n WHEN NOT \"orders.amount_sum\" IS NULL AND \"orders.amount_sum\" <> 0\n THEN SUM(\n CASE\n WHEN NOT \"orders.amount_sum\" IS NULL AND \"orders.amount_sum\" <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_orders.streak_a\"\n ORDER BY \"orders.created_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.streak_a\",\n CASE\n WHEN NOT \"orders.amount_sum\" IS NULL AND \"orders.amount_sum\" <> 0\n THEN SUM(\n CASE\n WHEN NOT \"orders.amount_sum\" IS NULL AND \"orders.amount_sum\" <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_orders.streak_a\"\n ORDER BY \"orders.created_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.streak_b\"\n FROM cp_reset_streak_a\n)\nSELECT\n \"orders.created_at\",\n \"orders.streak_a\",\n \"orders.streak_b\"\nFROM (\n SELECT\n \"orders.created_at\",\n \"orders.amount_sum\",\n \"orders.streak_a\",\n \"orders.streak_b\"\n FROM cp_value_streak_a\n) AS _outer", @@ -14,12 +14,12 @@ "chain/cross_model_window::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_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.created_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.cs\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), step1 AS (\n SELECT\n \"orders.created_at\",\n \"orders.cs\",\n SUM(\"orders.cs\") OVER (ORDER BY \"orders.created_at\") AS \"orders.run\"\n FROM base\n)\nSELECT\n \"orders.created_at\",\n \"orders.cs\",\n \"orders.run\"\nFROM (\n SELECT\n \"orders.created_at\",\n \"orders.cs\",\n \"orders.run\"\n FROM step1\n) AS _outer", "chain/cross_model_window::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_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.created_at\",\n _cm_orders__customers__spend_sum.\"customers.spend_sum\" AS \"orders.cs\"\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), step1 AS (\n SELECT\n \"orders.created_at\",\n \"orders.cs\",\n SUM(\"orders.cs\") OVER (ORDER BY \"orders.created_at\") AS \"orders.run\"\n FROM base\n)\nSELECT\n \"orders.created_at\",\n \"orders.cs\",\n \"orders.run\"\nFROM (\n SELECT\n \"orders.created_at\",\n \"orders.cs\",\n \"orders.run\"\n FROM step1\n) AS _outer", "chain/cross_model_window::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_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___created_at] AS [orders___created_at],\n _cm_orders__customers__spend_sum.[customers___spend_sum] AS [orders___cs]\n FROM _base\n CROSS JOIN _cm_orders__customers__spend_sum\n), step1 AS (\n SELECT\n [orders___created_at] AS [orders___created_at],\n [orders___cs] AS [orders___cs],\n SUM([orders___cs]) OVER (ORDER BY [orders___created_at]) AS [orders___run]\n FROM base\n)\nSELECT\n [orders___created_at],\n [orders___cs],\n [orders___run]\nFROM (\n SELECT\n [orders___created_at],\n [orders___cs],\n [orders___run]\n FROM step1\n) AS _outer", - "chain/local_consecutive_periods::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___rev`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), cp_prev_streak AS (\n SELECT\n `orders___created_at`,\n `orders___rev`,\n LAG(`orders___created_at`) OVER (ORDER BY `orders___created_at`) AS `_cp_prev_orders___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `orders___created_at`,\n `orders___rev`,\n SUM(\n CASE\n WHEN NOT `orders___rev` IS NULL\n AND `orders___rev` <> 0\n AND CAST(`_cp_prev_orders___streak` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`orders___created_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___created_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `orders___created_at`,\n `orders___rev`,\n CASE\n WHEN NOT `orders___rev` IS NULL AND `orders___rev` <> 0\n THEN SUM(CASE WHEN NOT `orders___rev` IS NULL AND `orders___rev` <> 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___streak`\n ORDER BY `orders___created_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___streak`\n FROM cp_reset_streak\n)\nSELECT\n `orders___created_at`,\n `orders___rev`,\n `orders___streak`\nFROM (\n SELECT\n `orders___created_at`,\n `orders___rev`,\n `orders___streak`\n FROM cp_value_streak\n) AS _outer", + "chain/local_consecutive_periods::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___rev`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), cp_prev_streak AS (\n SELECT\n `orders___created_at`,\n `orders___rev`,\n LAG(`orders___created_at`) OVER (ORDER BY `orders___created_at`) AS `_cp_prev_orders___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `orders___created_at`,\n `orders___rev`,\n SUM(\n CASE\n WHEN NOT `orders___rev` IS NULL\n AND `orders___rev` <> 0\n AND CAST(`_cp_prev_orders___streak` AS DATETIME) = DATETIME_ADD(CAST(`orders___created_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___created_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `orders___created_at`,\n `orders___rev`,\n CASE\n WHEN NOT `orders___rev` IS NULL AND `orders___rev` <> 0\n THEN SUM(CASE WHEN NOT `orders___rev` IS NULL AND `orders___rev` <> 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___streak`\n ORDER BY `orders___created_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___streak`\n FROM cp_reset_streak\n)\nSELECT\n `orders___created_at`,\n `orders___rev`,\n `orders___streak`\nFROM (\n SELECT\n `orders___created_at`,\n `orders___rev`,\n `orders___streak`\n FROM cp_value_streak\n) AS _outer", "chain/local_consecutive_periods::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.rev\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), cp_prev_streak AS (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n LAG(\"orders.created_at\") OVER (ORDER BY \"orders.created_at\") AS \"_cp_prev_orders.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n SUM(\n CASE\n WHEN NOT \"orders.rev\" IS NULL\n AND \"orders.rev\" <> 0\n AND \"_cp_prev_orders.streak\" = \"orders.created_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.created_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n CASE\n WHEN NOT \"orders.rev\" IS NULL AND \"orders.rev\" <> 0\n THEN SUM(CASE WHEN NOT \"orders.rev\" IS NULL AND \"orders.rev\" <> 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.streak\"\n ORDER BY \"orders.created_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"orders.created_at\",\n \"orders.rev\",\n \"orders.streak\"\nFROM (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n \"orders.streak\"\n FROM cp_value_streak\n) AS _outer", "chain/local_consecutive_periods::postgres": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.rev\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), cp_prev_streak AS (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n LAG(\"orders.created_at\") OVER (ORDER BY \"orders.created_at\") AS \"_cp_prev_orders.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n SUM(\n CASE\n WHEN NOT \"orders.rev\" IS NULL\n AND \"orders.rev\" <> 0\n AND \"_cp_prev_orders.streak\" = \"orders.created_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.created_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n CASE\n WHEN NOT \"orders.rev\" IS NULL AND \"orders.rev\" <> 0\n THEN SUM(CASE WHEN NOT \"orders.rev\" IS NULL AND \"orders.rev\" <> 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.streak\"\n ORDER BY \"orders.created_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"orders.created_at\",\n \"orders.rev\",\n \"orders.streak\"\nFROM (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n \"orders.streak\"\n FROM cp_value_streak\n) AS _outer", "chain/local_consecutive_periods::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.rev\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), cp_prev_streak AS (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n LAG(\"orders.created_at\") OVER (ORDER BY \"orders.created_at\") AS \"_cp_prev_orders.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n SUM(\n CASE\n WHEN NOT \"orders.rev\" IS NULL\n AND \"orders.rev\" <> 0\n AND \"_cp_prev_orders.streak\" = SLAYER_DATE_ADD(\"orders.created_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.created_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n CASE\n WHEN NOT \"orders.rev\" IS NULL AND \"orders.rev\" <> 0\n THEN SUM(CASE WHEN NOT \"orders.rev\" IS NULL AND \"orders.rev\" <> 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.streak\"\n ORDER BY \"orders.created_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"orders.created_at\",\n \"orders.rev\",\n \"orders.streak\"\nFROM (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n \"orders.streak\"\n FROM cp_value_streak\n) AS _outer", "chain/local_consecutive_periods::tsql": "WITH base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___rev]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), cp_prev_streak AS (\n SELECT\n [orders___created_at] AS [orders___created_at],\n [orders___rev] AS [orders___rev],\n LAG([orders___created_at]) OVER (ORDER BY [orders___created_at]) AS [_cp_prev_orders___streak]\n FROM base\n), cp_reset_streak AS (\n SELECT\n [orders___created_at] AS [orders___created_at],\n [orders___rev] AS [orders___rev],\n SUM(\n CASE\n WHEN NOT [orders___rev] IS NULL\n AND [orders___rev] <> 0\n AND [_cp_prev_orders___streak] = DATEADD(MONTH, -1, [orders___created_at])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [orders___created_at] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_orders___streak]\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n [orders___created_at] AS [orders___created_at],\n [orders___rev] AS [orders___rev],\n CASE\n WHEN NOT [orders___rev] IS NULL AND [orders___rev] <> 0\n THEN SUM(CASE WHEN NOT [orders___rev] IS NULL AND [orders___rev] <> 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY [_cp_reset_orders___streak]\n ORDER BY [orders___created_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [orders___streak]\n FROM cp_reset_streak\n)\nSELECT\n [orders___created_at],\n [orders___rev],\n [orders___streak]\nFROM (\n SELECT\n [orders___created_at],\n [orders___rev],\n [orders___streak]\n FROM cp_value_streak\n) AS _outer", - "chain/local_multi_step::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___rev`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), step1 AS (\n SELECT\n `orders___created_at`,\n `orders___rev`,\n SUM(`orders___rev`) OVER (ORDER BY `orders___created_at`) AS `orders___cs`\n FROM base\n), shifted__time_shift_inner AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___rev`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), sjoin__time_shift_inner AS (\n SELECT\n step1.`orders___created_at`,\n step1.`orders___rev`,\n step1.`orders___cs`,\n shifted__time_shift_inner.`orders___rev` AS `orders____time_shift_inner`\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON CAST(DATETIME_ADD(CAST(CAST(step1.`orders___created_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___created_at` AS TIMESTAMP)\n), step2 AS (\n SELECT\n `orders___created_at`,\n `orders___rev`,\n `orders___cs`,\n `orders____time_shift_inner`,\n `orders___rev` - `orders____time_shift_inner` AS `orders___ch`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___created_at`,\n `orders___rev`,\n `orders___cs`,\n `orders___ch`\nFROM (\n SELECT\n `orders___created_at`,\n `orders___rev`,\n `orders___cs`,\n `orders____time_shift_inner`,\n `orders___ch`\n FROM step2\n) AS _outer", + "chain/local_multi_step::bigquery": "WITH base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___rev`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), step1 AS (\n SELECT\n `orders___created_at`,\n `orders___rev`,\n SUM(`orders___rev`) OVER (ORDER BY `orders___created_at`) AS `orders___cs`\n FROM base\n), shifted__time_shift_inner AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___rev`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), sjoin__time_shift_inner AS (\n SELECT\n step1.`orders___created_at`,\n step1.`orders___rev`,\n step1.`orders___cs`,\n shifted__time_shift_inner.`orders___rev` AS `orders____time_shift_inner`\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON DATETIME_ADD(CAST(step1.`orders___created_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___created_at` AS DATETIME)\n), step2 AS (\n SELECT\n `orders___created_at`,\n `orders___rev`,\n `orders___cs`,\n `orders____time_shift_inner`,\n `orders___rev` - `orders____time_shift_inner` AS `orders___ch`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___created_at`,\n `orders___rev`,\n `orders___cs`,\n `orders___ch`\nFROM (\n SELECT\n `orders___created_at`,\n `orders___rev`,\n `orders___cs`,\n `orders____time_shift_inner`,\n `orders___ch`\n FROM step2\n) AS _outer", "chain/local_multi_step::duckdb": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.rev\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), step1 AS (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n SUM(\"orders.rev\") OVER (ORDER BY \"orders.created_at\") AS \"orders.cs\"\n FROM base\n), shifted__time_shift_inner AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.rev\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), sjoin__time_shift_inner AS (\n SELECT\n step1.\"orders.created_at\",\n step1.\"orders.rev\",\n step1.\"orders.cs\",\n shifted__time_shift_inner.\"orders.rev\" AS \"orders._time_shift_inner\"\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON step1.\"orders.created_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.created_at\"\n), step2 AS (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n \"orders.cs\",\n \"orders._time_shift_inner\",\n \"orders.rev\" - \"orders._time_shift_inner\" AS \"orders.ch\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.created_at\",\n \"orders.rev\",\n \"orders.cs\",\n \"orders.ch\"\nFROM (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n \"orders.cs\",\n \"orders._time_shift_inner\",\n \"orders.ch\"\n FROM step2\n) AS _outer", "chain/local_multi_step::postgres": "WITH base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.rev\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), step1 AS (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n SUM(\"orders.rev\") OVER (ORDER BY \"orders.created_at\") AS \"orders.cs\"\n FROM base\n), shifted__time_shift_inner AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.rev\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), sjoin__time_shift_inner AS (\n SELECT\n step1.\"orders.created_at\",\n step1.\"orders.rev\",\n step1.\"orders.cs\",\n shifted__time_shift_inner.\"orders.rev\" AS \"orders._time_shift_inner\"\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON step1.\"orders.created_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.created_at\"\n), step2 AS (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n \"orders.cs\",\n \"orders._time_shift_inner\",\n \"orders.rev\" - \"orders._time_shift_inner\" AS \"orders.ch\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.created_at\",\n \"orders.rev\",\n \"orders.cs\",\n \"orders.ch\"\nFROM (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n \"orders.cs\",\n \"orders._time_shift_inner\",\n \"orders.ch\"\n FROM step2\n) AS _outer", "chain/local_multi_step::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.rev\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), step1 AS (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n SUM(\"orders.rev\") OVER (ORDER BY \"orders.created_at\") AS \"orders.cs\"\n FROM base\n), shifted__time_shift_inner AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.rev\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), sjoin__time_shift_inner AS (\n SELECT\n step1.\"orders.created_at\",\n step1.\"orders.rev\",\n step1.\"orders.cs\",\n shifted__time_shift_inner.\"orders.rev\" AS \"orders._time_shift_inner\"\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON SLAYER_DATE_ADD(step1.\"orders.created_at\", -1, 'month') IS shifted__time_shift_inner.\"orders.created_at\"\n), step2 AS (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n \"orders.cs\",\n \"orders._time_shift_inner\",\n \"orders.rev\" - \"orders._time_shift_inner\" AS \"orders.ch\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.created_at\",\n \"orders.rev\",\n \"orders.cs\",\n \"orders.ch\"\nFROM (\n SELECT\n \"orders.created_at\",\n \"orders.rev\",\n \"orders.cs\",\n \"orders._time_shift_inner\",\n \"orders.ch\"\n FROM step2\n) AS _outer", @@ -94,12 +94,12 @@ "order/ungrouped_derived_crossing::postgres": "SELECT\n orders.status AS \"orders.status\"\nFROM orders AS orders\nLEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\nLEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\nORDER BY\n customers__regions.name ASC", "order/ungrouped_derived_crossing::sqlite": "SELECT\n orders.status AS \"orders.status\"\nFROM orders AS orders\nLEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\nLEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\nORDER BY\n customers__regions.name ASC NULLS LAST", "order/ungrouped_derived_crossing::tsql": "SELECT\n orders.status AS [orders___status]\nFROM orders AS orders\nLEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\nLEFT JOIN regions AS customers__regions\n ON customers.region_id = customers__regions.id\nORDER BY\n customers__regions.name ASC", - "order/windowed_cte::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_sum_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.`orders___created_at`\nORDER BY\n _cm_orders__amount_sum_window_90d.`orders___w` DESC", + "order/windowed_cte::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_sum_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.`orders___created_at`\nORDER BY\n _cm_orders__amount_sum_window_90d.`orders___w` DESC", "order/windowed_cte::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_sum_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.\"orders.created_at\"\nORDER BY\n _cm_orders__amount_sum_window_90d.\"orders.w\" DESC", "order/windowed_cte::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(SUM(_src._w_value) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_sum_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.\"orders.created_at\"\nORDER BY\n _cm_orders__amount_sum_window_90d.\"orders.w\" DESC NULLS LAST", "order/windowed_cte::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(SUM(_src._w_value) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_sum_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_sum_window_90d.\"orders.created_at\"\nORDER BY\n _cm_orders__amount_sum_window_90d.\"orders.w\" DESC", "order/windowed_cte::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n CAST(SUM(_src._w_value) AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _cm_orders__amount_sum_window_90d.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_sum_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_sum_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_sum_window_90d.[orders___created_at] IS NULL\n )\n )\nORDER BY\n _cm_orders__amount_sum_window_90d.[orders___w] DESC", - "order/windowed_cte_date_range::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n WHERE\n (\n orders.created_at >= '2024-01-01 00:00:00'\n AND orders.created_at < '2024-07-01 00:00:00'\n )\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n WHERE\n (\n orders.created_at >= '2024-01-01 00:00:00'\n AND orders.created_at < '2024-07-01 00:00:00'\n )\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_sum_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.`orders___created_at`\nORDER BY\n _cm_orders__amount_sum_window_90d.`orders___w` DESC", + "order/windowed_cte_date_range::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n WHERE\n (\n orders.created_at >= '2024-01-01 00:00:00'\n AND orders.created_at < '2024-07-01 00:00:00'\n )\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n WHERE\n (\n orders.created_at >= '2024-01-01 00:00:00'\n AND orders.created_at < '2024-07-01 00:00:00'\n )\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_sum_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.`orders___created_at`\nORDER BY\n _cm_orders__amount_sum_window_90d.`orders___w` DESC", "order/windowed_cte_date_range::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n WHERE\n (\n orders.created_at >= CAST('2024-01-01 00:00:00' AS TIMESTAMP)\n AND orders.created_at < CAST('2024-07-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n WHERE\n (\n orders.created_at >= CAST('2024-01-01 00:00:00' AS TIMESTAMP)\n AND orders.created_at < CAST('2024-07-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_sum_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.\"orders.created_at\"\nORDER BY\n _cm_orders__amount_sum_window_90d.\"orders.w\" DESC", "order/windowed_cte_date_range::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n WHERE\n (\n orders.created_at >= CAST('2024-01-01 00:00:00' AS TIMESTAMP)\n AND orders.created_at < CAST('2024-07-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(SUM(_src._w_value) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n WHERE\n (\n orders.created_at >= CAST('2024-01-01 00:00:00' AS TIMESTAMP)\n AND orders.created_at < CAST('2024-07-01 00:00:00' AS TIMESTAMP)\n )\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_sum_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.\"orders.created_at\"\nORDER BY\n _cm_orders__amount_sum_window_90d.\"orders.w\" DESC NULLS LAST", "order/windowed_cte_date_range::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n WHERE\n (\n orders.created_at >= '2024-01-01' AND orders.created_at < '2024-07-01'\n )\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(SUM(_src._w_value) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n WHERE\n (\n orders.created_at >= '2024-01-01' AND orders.created_at < '2024-07-01'\n )\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_sum_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_sum_window_90d.\"orders.created_at\"\nORDER BY\n _cm_orders__amount_sum_window_90d.\"orders.w\" DESC", diff --git a/tests/golden/dev1750_sql_baseline.json b/tests/golden/dev1750_sql_baseline.json index b259c5cae..92730f066 100644 --- a/tests/golden/dev1750_sql_baseline.json +++ b/tests/golden/dev1750_sql_baseline.json @@ -1,15 +1,15 @@ { - "a/local_ts_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_prev 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_prev AS (\n SELECT\n base.`orders___ordered_at`,\n base.`orders___amount_sum`,\n base.`orders___cm`,\n shifted_prev.`orders___amount_sum` 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", + "a/local_ts_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_prev 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_prev AS (\n SELECT\n base.`orders___ordered_at`,\n base.`orders___amount_sum`,\n base.`orders___cm`,\n shifted_prev.`orders___amount_sum` AS `orders___prev`\n FROM base\n LEFT JOIN shifted_prev\n ON DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_prev.`orders___ordered_at` AS DATETIME)\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", "a/local_ts_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_prev 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_prev AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.cm\",\n shifted_prev.\"orders.amount_sum\" 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", "a/local_ts_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_prev 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_prev AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.cm\",\n shifted_prev.\"orders.amount_sum\" 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", "a/local_ts_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_prev 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_prev AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.cm\",\n shifted_prev.\"orders.amount_sum\" AS \"orders.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS 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", "a/local_ts_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_prev 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_prev 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_prev.[orders___amount_sum] AS [orders___prev]\n FROM base\n LEFT JOIN shifted_prev\n ON (\n (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted_prev.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted_prev.[orders___ordered_at] IS NULL\n )\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND shifted_prev.[orders___ordered_at] IS NULL\n )\n )\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", - "b/host_rooted_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_prev 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___prev`\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)\nSELECT\n `orders___ordered_at`,\n `orders___prev`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_wscaled_sum_w_customers_regions_weight`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", + "b/host_rooted_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_prev 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___prev`\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(_cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___ordered_at` AS DATETIME)\n)\nSELECT\n `orders___ordered_at`,\n `orders___prev`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_wscaled_sum_w_customers_regions_weight`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", "b/host_rooted_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_prev 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.prev\"\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)\nSELECT\n \"orders.ordered_at\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "b/host_rooted_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_prev 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.prev\"\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)\nSELECT\n \"orders.ordered_at\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "b/host_rooted_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_prev 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.prev\"\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)\nSELECT\n \"orders.ordered_at\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "b/host_rooted_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 (\n _base.[orders___ordered_at] = _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at]\n AND NOT _base.[orders___ordered_at] IS NULL\n AND NOT _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at] IS NULL\n )\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_prev 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___prev]\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON (\n (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at] IS NULL\n )\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)\nSELECT\n [orders___ordered_at],\n [orders___prev]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders___amount_wscaled_sum_w_customers_regions_weight],\n [orders___prev]\n FROM sjoin_prev\n) AS _outer", - "b/host_rooted_wscaled_user_kwarg::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_prev 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___prev`\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)\nSELECT\n `orders___ordered_at`,\n `orders___prev`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_wscaled_sum_w_customers_regions_weight`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", + "b/host_rooted_wscaled_user_kwarg::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_prev 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___prev`\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(_cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___ordered_at` AS DATETIME)\n)\nSELECT\n `orders___ordered_at`,\n `orders___prev`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_wscaled_sum_w_customers_regions_weight`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", "b/host_rooted_wscaled_user_kwarg::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_prev 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.prev\"\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)\nSELECT\n \"orders.ordered_at\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "b/host_rooted_wscaled_user_kwarg::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_prev 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.prev\"\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)\nSELECT\n \"orders.ordered_at\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "b/host_rooted_wscaled_user_kwarg::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_prev 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.prev\"\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)\nSELECT\n \"orders.ordered_at\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", @@ -34,42 +34,42 @@ "error": "UnsafeJoinInputError", "message": "UnsafeJoinInputError: The aggregate reads an input across an unproven join hop to line_items from orders.\n at measure 'amount_liscaled_sum_f_line_items_factor'\n suggestion: Declare join cardinality or a covering unique key on the target." }, - "b/wscaled_with_local_sibling::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___s`\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 _base.`orders___s`,\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_prev AS (\n SELECT\n base.`orders___ordered_at`,\n base.`orders___s`,\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___prev`\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)\nSELECT\n `orders___ordered_at`,\n `orders___s`,\n `orders___prev`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___s`,\n `orders___amount_wscaled_sum_w_customers_regions_weight`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", + "b/wscaled_with_local_sibling::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___s`\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 _base.`orders___s`,\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_prev AS (\n SELECT\n base.`orders___ordered_at`,\n base.`orders___s`,\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___prev`\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(_cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___ordered_at` AS DATETIME)\n)\nSELECT\n `orders___ordered_at`,\n `orders___s`,\n `orders___prev`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___s`,\n `orders___amount_wscaled_sum_w_customers_regions_weight`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", "b/wscaled_with_local_sibling::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.s\"\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 _base.\"orders.s\",\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_prev AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.s\",\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.prev\"\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)\nSELECT\n \"orders.ordered_at\",\n \"orders.s\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.s\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "b/wscaled_with_local_sibling::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.s\"\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 _base.\"orders.s\",\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_prev AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.s\",\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.prev\"\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)\nSELECT\n \"orders.ordered_at\",\n \"orders.s\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.s\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "b/wscaled_with_local_sibling::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.s\"\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 _base.\"orders.s\",\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_prev AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.s\",\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.prev\"\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)\nSELECT\n \"orders.ordered_at\",\n \"orders.s\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.s\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "b/wscaled_with_local_sibling::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___s]\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 _base.[orders___s] AS [orders___s],\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 (\n _base.[orders___ordered_at] = _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at]\n AND NOT _base.[orders___ordered_at] IS NULL\n AND NOT _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at] IS NULL\n )\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_prev AS (\n SELECT\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[orders___s] AS [orders___s],\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___prev]\n FROM base\n LEFT JOIN _cm_orders__amount_wscaled_sum_w_customers_regions_weight\n ON (\n (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at] IS NULL\n )\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)\nSELECT\n [orders___ordered_at],\n [orders___s],\n [orders___prev]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders___s],\n [orders___amount_wscaled_sum_w_customers_regions_weight],\n [orders___prev]\n FROM sjoin_prev\n) AS _outer", - "c/target_grain_guarded::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_prev 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_prev AS (\n SELECT\n base.`orders___ordered_at`,\n base.`customers___spend_sum`,\n shifted_prev.`orders___customers___spend_sum` 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___prev`\nFROM (\n SELECT\n `orders___ordered_at`,\n `customers___spend_sum`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", + "c/target_grain_guarded::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_prev 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_prev AS (\n SELECT\n base.`orders___ordered_at`,\n base.`customers___spend_sum`,\n shifted_prev.`orders___customers___spend_sum` AS `orders___prev`\n FROM base\n LEFT JOIN shifted_prev\n ON DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_prev.`orders___ordered_at` AS DATETIME)\n)\nSELECT\n `orders___ordered_at`,\n `orders___prev`\nFROM (\n SELECT\n `orders___ordered_at`,\n `customers___spend_sum`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", "c/target_grain_guarded::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_prev 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_prev AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"customers.spend_sum\",\n shifted_prev.\"orders.customers.spend_sum\" 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.prev\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "c/target_grain_guarded::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_prev 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_prev AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"customers.spend_sum\",\n shifted_prev.\"orders.customers.spend_sum\" 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.prev\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "c/target_grain_guarded::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_prev 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_prev AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"customers.spend_sum\",\n shifted_prev.\"orders.customers.spend_sum\" AS \"orders.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted_prev.\"orders.ordered_at\"\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "c/target_grain_guarded::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_prev 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_prev AS (\n SELECT\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[customers___spend_sum] AS [customers___spend_sum],\n shifted_prev.[orders___customers___spend_sum] AS [orders___prev]\n FROM base\n LEFT JOIN shifted_prev\n ON (\n (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted_prev.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted_prev.[orders___ordered_at] IS NULL\n )\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND shifted_prev.[orders___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [orders___ordered_at],\n [orders___prev]\nFROM (\n SELECT\n [orders___ordered_at],\n [customers___spend_sum],\n [orders___prev]\n FROM sjoin_prev\n) AS _outer", - "change/of_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___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::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 DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(_cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___ordered_at` AS DATETIME)\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::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.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::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 (\n _base.[orders___ordered_at] = _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at]\n AND NOT _base.[orders___ordered_at] IS NULL\n AND NOT _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at] IS NULL\n )\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 (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at] IS NULL\n )\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(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::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 DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS DATETIME)\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 (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\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::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 DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_prev.`orders___ordered_at` AS DATETIME)\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", "composite/lifted::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_prev AS (\n SELECT\n STRFTIME('%Y-%m-01', 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 STRFTIME('%Y-%m-01', 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 SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS 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::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_prev AS (\n SELECT\n DATETRUNC(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 DATETRUNC(month, orders.ordered_at)\n), sjoin_prev 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_prev.[orders___shifted] AS [orders___prev]\n FROM base\n LEFT JOIN shifted_prev\n ON (\n (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted_prev.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted_prev.[orders___ordered_at] IS NULL\n )\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND shifted_prev.[orders___ordered_at] IS NULL\n )\n )\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", - "cp/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), cp_prev_streak AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___cm`,\n LAG(`orders___ordered_at`) OVER (ORDER BY `orders___ordered_at`) AS `_cp_prev_orders___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___cm`,\n SUM(\n CASE\n WHEN `orders___amount_sum` > 0\n AND CAST(`_cp_prev_orders___streak` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`orders___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___cm`,\n CASE\n WHEN `orders___amount_sum` > 0\n THEN SUM(CASE WHEN `orders___amount_sum` > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___streak`\n ORDER BY `orders___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___streak`\n FROM cp_reset_streak\n)\nSELECT\n `orders___ordered_at`,\n `orders___cm`,\n `orders___streak`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___cm`,\n `orders___streak`\n FROM cp_value_streak\n) AS _outer", + "cp/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), cp_prev_streak AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___cm`,\n LAG(`orders___ordered_at`) OVER (ORDER BY `orders___ordered_at`) AS `_cp_prev_orders___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___cm`,\n SUM(\n CASE\n WHEN `orders___amount_sum` > 0\n AND CAST(`_cp_prev_orders___streak` AS DATETIME) = DATETIME_ADD(CAST(`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___cm`,\n CASE\n WHEN `orders___amount_sum` > 0\n THEN SUM(CASE WHEN `orders___amount_sum` > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___streak`\n ORDER BY `orders___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___streak`\n FROM cp_reset_streak\n)\nSELECT\n `orders___ordered_at`,\n `orders___cm`,\n `orders___streak`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___cm`,\n `orders___streak`\n FROM cp_value_streak\n) AS _outer", "cp/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), cp_prev_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n LAG(\"orders.ordered_at\") OVER (ORDER BY \"orders.ordered_at\") AS \"_cp_prev_orders.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 0\n AND \"_cp_prev_orders.streak\" = \"orders.ordered_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n CASE\n WHEN \"orders.amount_sum\" > 0\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.streak\"\n ORDER BY \"orders.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.cm\",\n \"orders.streak\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/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), cp_prev_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n LAG(\"orders.ordered_at\") OVER (ORDER BY \"orders.ordered_at\") AS \"_cp_prev_orders.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 0\n AND \"_cp_prev_orders.streak\" = \"orders.ordered_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n CASE\n WHEN \"orders.amount_sum\" > 0\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.streak\"\n ORDER BY \"orders.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.cm\",\n \"orders.streak\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/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), cp_prev_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n LAG(\"orders.ordered_at\") OVER (ORDER BY \"orders.ordered_at\") AS \"_cp_prev_orders.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n SUM(\n CASE\n WHEN \"orders.amount_sum\" > 0\n AND \"_cp_prev_orders.streak\" = SLAYER_DATE_ADD(\"orders.ordered_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n CASE\n WHEN \"orders.amount_sum\" > 0\n THEN SUM(CASE WHEN \"orders.amount_sum\" > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.streak\"\n ORDER BY \"orders.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.cm\",\n \"orders.streak\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.cm\",\n \"orders.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/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), cp_prev_streak 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 LAG([orders___ordered_at]) OVER (ORDER BY [orders___ordered_at]) AS [_cp_prev_orders___streak]\n FROM base\n), cp_reset_streak 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 SUM(\n CASE\n WHEN [orders___amount_sum] > 0\n AND [_cp_prev_orders___streak] = DATEADD(MONTH, -1, [orders___ordered_at])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [orders___ordered_at] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_orders___streak]\n FROM cp_prev_streak\n), cp_value_streak 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 CASE\n WHEN [orders___amount_sum] > 0\n THEN SUM(CASE WHEN [orders___amount_sum] > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY [_cp_reset_orders___streak]\n ORDER BY [orders___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [orders___streak]\n FROM cp_reset_streak\n)\nSELECT\n [orders___ordered_at],\n [orders___cm],\n [orders___streak]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders___amount_sum],\n [orders___cm],\n [orders___streak]\n FROM cp_value_streak\n) AS _outer", - "cp/over_target_grain::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), cp_prev_streak AS (\n SELECT\n `orders___ordered_at`,\n `customers___spend_sum`,\n LAG(`orders___ordered_at`) OVER (ORDER BY `orders___ordered_at`) AS `_cp_prev_orders___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `orders___ordered_at`,\n `customers___spend_sum`,\n SUM(\n CASE\n WHEN `customers___spend_sum` > 0\n AND CAST(`_cp_prev_orders___streak` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`orders___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `orders___ordered_at`,\n `customers___spend_sum`,\n CASE\n WHEN `customers___spend_sum` > 0\n THEN SUM(CASE WHEN `customers___spend_sum` > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___streak`\n ORDER BY `orders___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___streak`\n FROM cp_reset_streak\n)\nSELECT\n `orders___ordered_at`,\n `orders___streak`\nFROM (\n SELECT\n `orders___ordered_at`,\n `customers___spend_sum`,\n `orders___streak`\n FROM cp_value_streak\n) AS _outer", + "cp/over_target_grain::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), cp_prev_streak AS (\n SELECT\n `orders___ordered_at`,\n `customers___spend_sum`,\n LAG(`orders___ordered_at`) OVER (ORDER BY `orders___ordered_at`) AS `_cp_prev_orders___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `orders___ordered_at`,\n `customers___spend_sum`,\n SUM(\n CASE\n WHEN `customers___spend_sum` > 0\n AND CAST(`_cp_prev_orders___streak` AS DATETIME) = DATETIME_ADD(CAST(`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `orders___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_orders___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `orders___ordered_at`,\n `customers___spend_sum`,\n CASE\n WHEN `customers___spend_sum` > 0\n THEN SUM(CASE WHEN `customers___spend_sum` > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_orders___streak`\n ORDER BY `orders___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `orders___streak`\n FROM cp_reset_streak\n)\nSELECT\n `orders___ordered_at`,\n `orders___streak`\nFROM (\n SELECT\n `orders___ordered_at`,\n `customers___spend_sum`,\n `orders___streak`\n FROM cp_value_streak\n) AS _outer", "cp/over_target_grain::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), cp_prev_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n LAG(\"orders.ordered_at\") OVER (ORDER BY \"orders.ordered_at\") AS \"_cp_prev_orders.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n SUM(\n CASE\n WHEN \"customers.spend_sum\" > 0\n AND \"_cp_prev_orders.streak\" = \"orders.ordered_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n CASE\n WHEN \"customers.spend_sum\" > 0\n THEN SUM(CASE WHEN \"customers.spend_sum\" > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.streak\"\n ORDER BY \"orders.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.streak\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/over_target_grain::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), cp_prev_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n LAG(\"orders.ordered_at\") OVER (ORDER BY \"orders.ordered_at\") AS \"_cp_prev_orders.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n SUM(\n CASE\n WHEN \"customers.spend_sum\" > 0\n AND \"_cp_prev_orders.streak\" = \"orders.ordered_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n CASE\n WHEN \"customers.spend_sum\" > 0\n THEN SUM(CASE WHEN \"customers.spend_sum\" > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.streak\"\n ORDER BY \"orders.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.streak\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/over_target_grain::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), cp_prev_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n LAG(\"orders.ordered_at\") OVER (ORDER BY \"orders.ordered_at\") AS \"_cp_prev_orders.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n SUM(\n CASE\n WHEN \"customers.spend_sum\" > 0\n AND \"_cp_prev_orders.streak\" = SLAYER_DATE_ADD(\"orders.ordered_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"orders.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_orders.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n CASE\n WHEN \"customers.spend_sum\" > 0\n THEN SUM(CASE WHEN \"customers.spend_sum\" > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_orders.streak\"\n ORDER BY \"orders.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"orders.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.streak\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"customers.spend_sum\",\n \"orders.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/over_target_grain::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), cp_prev_streak AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [customers___spend_sum] AS [customers___spend_sum],\n LAG([orders___ordered_at]) OVER (ORDER BY [orders___ordered_at]) AS [_cp_prev_orders___streak]\n FROM base\n), cp_reset_streak AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [customers___spend_sum] AS [customers___spend_sum],\n SUM(\n CASE\n WHEN [customers___spend_sum] > 0\n AND [_cp_prev_orders___streak] = DATEADD(MONTH, -1, [orders___ordered_at])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [orders___ordered_at] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_orders___streak]\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [customers___spend_sum] AS [customers___spend_sum],\n CASE\n WHEN [customers___spend_sum] > 0\n THEN SUM(CASE WHEN [customers___spend_sum] > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY [_cp_reset_orders___streak]\n ORDER BY [orders___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [orders___streak]\n FROM cp_reset_streak\n)\nSELECT\n [orders___ordered_at],\n [orders___streak]\nFROM (\n SELECT\n [orders___ordered_at],\n [customers___spend_sum],\n [orders___streak]\n FROM cp_value_streak\n) AS _outer", - "first_last/crossing_time_arg::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_last_customers_signup_at AS (\n SELECT\n _val_0 AS `orders___ordered_at`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS FLOAT64) AS `orders___amount_last_customers_signup_at`\n FROM (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS _val_0,\n orders.amount AS _val_1,\n ROW_NUMBER() OVER (\n PARTITION BY DATE_TRUNC(orders.ordered_at, MONTH)\n ORDER BY customers.signup_at DESC\n ) AS _ranked_rn\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n ) AS _ranked_src\n GROUP BY\n _val_0\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 _cm_orders__amount_last_customers_signup_at.`orders___amount_last_customers_signup_at` AS `orders___amount_last_customers_signup_at`\n FROM _base\n LEFT JOIN _cm_orders__amount_last_customers_signup_at\n ON _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_last_customers_signup_at.`orders___ordered_at`\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin_prev AS (\n SELECT\n base.`orders___ordered_at`,\n base.`orders___amount_last_customers_signup_at`,\n base.`orders___cm`,\n _cm_orders__amount_last_customers_signup_at.`orders___amount_last_customers_signup_at` AS `orders___prev`\n FROM base\n LEFT JOIN _cm_orders__amount_last_customers_signup_at\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_last_customers_signup_at.`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_last_customers_signup_at`,\n `orders___cm`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", + "first_last/crossing_time_arg::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_last_customers_signup_at AS (\n SELECT\n _val_0 AS `orders___ordered_at`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS FLOAT64) AS `orders___amount_last_customers_signup_at`\n FROM (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS _val_0,\n orders.amount AS _val_1,\n ROW_NUMBER() OVER (\n PARTITION BY DATE_TRUNC(orders.ordered_at, MONTH)\n ORDER BY customers.signup_at DESC\n ) AS _ranked_rn\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n ) AS _ranked_src\n GROUP BY\n _val_0\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 _cm_orders__amount_last_customers_signup_at.`orders___amount_last_customers_signup_at` AS `orders___amount_last_customers_signup_at`\n FROM _base\n LEFT JOIN _cm_orders__amount_last_customers_signup_at\n ON _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_last_customers_signup_at.`orders___ordered_at`\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin_prev AS (\n SELECT\n base.`orders___ordered_at`,\n base.`orders___amount_last_customers_signup_at`,\n base.`orders___cm`,\n _cm_orders__amount_last_customers_signup_at.`orders___amount_last_customers_signup_at` AS `orders___prev`\n FROM base\n LEFT JOIN _cm_orders__amount_last_customers_signup_at\n ON DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(_cm_orders__amount_last_customers_signup_at.`orders___ordered_at` AS DATETIME)\n)\nSELECT\n `orders___ordered_at`,\n `orders___cm`,\n `orders___prev`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_last_customers_signup_at`,\n `orders___cm`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", "first_last/crossing_time_arg::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_last_customers_signup_at AS (\n SELECT\n _val_0 AS \"orders.ordered_at\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS DOUBLE) AS \"orders.amount_last_customers_signup_at\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS _val_0,\n orders.amount AS _val_1,\n ROW_NUMBER() OVER (\n PARTITION BY DATE_TRUNC('MONTH', orders.ordered_at)\n ORDER BY customers.signup_at DESC\n ) AS _ranked_rn\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n ) AS _ranked_src\n GROUP BY\n _val_0\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 _cm_orders__amount_last_customers_signup_at.\"orders.amount_last_customers_signup_at\" AS \"orders.amount_last_customers_signup_at\"\n FROM _base\n LEFT JOIN _cm_orders__amount_last_customers_signup_at\n ON _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_last_customers_signup_at.\"orders.ordered_at\"\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin_prev AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_last_customers_signup_at\",\n base.\"orders.cm\",\n _cm_orders__amount_last_customers_signup_at.\"orders.amount_last_customers_signup_at\" AS \"orders.prev\"\n FROM base\n LEFT JOIN _cm_orders__amount_last_customers_signup_at\n ON base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM _cm_orders__amount_last_customers_signup_at.\"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_last_customers_signup_at\",\n \"orders.cm\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "first_last/crossing_time_arg::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_last_customers_signup_at AS (\n SELECT\n _val_0 AS \"orders.ordered_at\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS DOUBLE PRECISION) AS \"orders.amount_last_customers_signup_at\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS _val_0,\n orders.amount AS _val_1,\n ROW_NUMBER() OVER (\n PARTITION BY DATE_TRUNC('MONTH', orders.ordered_at)\n ORDER BY customers.signup_at DESC\n ) AS _ranked_rn\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n ) AS _ranked_src\n GROUP BY\n _val_0\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 _cm_orders__amount_last_customers_signup_at.\"orders.amount_last_customers_signup_at\" AS \"orders.amount_last_customers_signup_at\"\n FROM _base\n LEFT JOIN _cm_orders__amount_last_customers_signup_at\n ON _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_last_customers_signup_at.\"orders.ordered_at\"\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin_prev AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_last_customers_signup_at\",\n base.\"orders.cm\",\n _cm_orders__amount_last_customers_signup_at.\"orders.amount_last_customers_signup_at\" AS \"orders.prev\"\n FROM base\n LEFT JOIN _cm_orders__amount_last_customers_signup_at\n ON base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM _cm_orders__amount_last_customers_signup_at.\"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_last_customers_signup_at\",\n \"orders.cm\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "first_last/crossing_time_arg::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_last_customers_signup_at AS (\n SELECT\n _val_0 AS \"orders.ordered_at\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS REAL) AS \"orders.amount_last_customers_signup_at\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS _val_0,\n orders.amount AS _val_1,\n ROW_NUMBER() OVER (\n PARTITION BY STRFTIME('%Y-%m-01', orders.ordered_at)\n ORDER BY customers.signup_at DESC\n ) AS _ranked_rn\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n ) AS _ranked_src\n GROUP BY\n _val_0\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 _cm_orders__amount_last_customers_signup_at.\"orders.amount_last_customers_signup_at\" AS \"orders.amount_last_customers_signup_at\"\n FROM _base\n LEFT JOIN _cm_orders__amount_last_customers_signup_at\n ON _base.\"orders.ordered_at\" IS _cm_orders__amount_last_customers_signup_at.\"orders.ordered_at\"\n CROSS JOIN _cm_orders__customers__spend_sum\n), sjoin_prev AS (\n SELECT\n base.\"orders.ordered_at\",\n base.\"orders.amount_last_customers_signup_at\",\n base.\"orders.cm\",\n _cm_orders__amount_last_customers_signup_at.\"orders.amount_last_customers_signup_at\" AS \"orders.prev\"\n FROM base\n LEFT JOIN _cm_orders__amount_last_customers_signup_at\n ON SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS _cm_orders__amount_last_customers_signup_at.\"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_last_customers_signup_at\",\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 4960caa18..c9167bf91 100644 --- a/tests/golden/dev1800_sql_baseline.json +++ b/tests/golden/dev1800_sql_baseline.json @@ -1,45 +1,45 @@ { - "alt/last_over_change::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), 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 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____time_shift_inner`,\n FIRST_VALUE(`orders___amount_sum` - `orders____time_shift_inner`) OVER (\n ORDER BY `orders___ordered_at` DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS `orders___t`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___t`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n `orders___t`\n FROM step1\n) AS _outer", + "alt/last_over_change::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), 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 shifted__time_shift_inner.`orders___amount_sum` AS `orders____time_shift_inner`\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS DATETIME)\n), step1 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n FIRST_VALUE(`orders___amount_sum` - `orders____time_shift_inner`) OVER (\n ORDER BY `orders___ordered_at` DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS `orders___t`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___t`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n `orders___t`\n FROM step1\n) AS _outer", "alt/last_over_change::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), 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 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._time_shift_inner\",\n FIRST_VALUE(\"orders.amount_sum\" - \"orders._time_shift_inner\") OVER (\n ORDER BY \"orders.ordered_at\" DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS \"orders.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n \"orders.t\"\n FROM step1\n) AS _outer", "alt/last_over_change::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), 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 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._time_shift_inner\",\n FIRST_VALUE(\"orders.amount_sum\" - \"orders._time_shift_inner\") OVER (\n ORDER BY \"orders.ordered_at\" DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS \"orders.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n \"orders.t\"\n FROM step1\n) AS _outer", "alt/last_over_change::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), 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 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._time_shift_inner\",\n FIRST_VALUE(\"orders.amount_sum\" - \"orders._time_shift_inner\") OVER (\n ORDER BY \"orders.ordered_at\" DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS \"orders.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n \"orders.t\"\n FROM step1\n) AS _outer", "alt/last_over_change::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), 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 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 (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\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____time_shift_inner] AS [orders____time_shift_inner],\n FIRST_VALUE([orders___amount_sum] - [orders____time_shift_inner]) OVER (\n ORDER BY [orders___ordered_at] DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS [orders___t]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [orders___ordered_at],\n [orders___t]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders___amount_sum],\n [orders____time_shift_inner],\n [orders___t]\n FROM step1\n) AS _outer", - "alt/last_over_change_cumsum::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), step1 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n SUM(`orders___amount_sum`) OVER (ORDER BY `orders___ordered_at`) AS `orders____cumsum_inner`\n FROM base\n), shifted__time_shift_inner AS (\n SELECT\n `orders___ordered_at` AS `orders___ordered_at`,\n `orders____cumsum_inner` AS `orders____cumsum_inner`\n FROM step1\n), sjoin__time_shift_inner AS (\n SELECT\n step1.`orders___ordered_at`,\n step1.`orders___amount_sum`,\n step1.`orders____cumsum_inner`,\n shifted__time_shift_inner.`orders____cumsum_inner` AS `orders____time_shift_inner`\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON CAST(DATETIME_ADD(CAST(CAST(step1.`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), step2 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____cumsum_inner`,\n `orders____time_shift_inner`,\n FIRST_VALUE(`orders____cumsum_inner` - `orders____time_shift_inner`) OVER (\n ORDER BY `orders___ordered_at` DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS `orders___t`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___t`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____cumsum_inner`,\n `orders____time_shift_inner`,\n `orders___t`\n FROM step2\n) AS _outer", + "alt/last_over_change_cumsum::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), step1 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n SUM(`orders___amount_sum`) OVER (ORDER BY `orders___ordered_at`) AS `orders____cumsum_inner`\n FROM base\n), shifted__time_shift_inner AS (\n SELECT\n `orders___ordered_at` AS `orders___ordered_at`,\n `orders____cumsum_inner` AS `orders____cumsum_inner`\n FROM step1\n), sjoin__time_shift_inner AS (\n SELECT\n step1.`orders___ordered_at`,\n step1.`orders___amount_sum`,\n step1.`orders____cumsum_inner`,\n shifted__time_shift_inner.`orders____cumsum_inner` AS `orders____time_shift_inner`\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON DATETIME_ADD(CAST(step1.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS DATETIME)\n), step2 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____cumsum_inner`,\n `orders____time_shift_inner`,\n FIRST_VALUE(`orders____cumsum_inner` - `orders____time_shift_inner`) OVER (\n ORDER BY `orders___ordered_at` DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS `orders___t`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___t`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____cumsum_inner`,\n `orders____time_shift_inner`,\n `orders___t`\n FROM step2\n) AS _outer", "alt/last_over_change_cumsum::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), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n SUM(\"orders.amount_sum\") OVER (ORDER BY \"orders.ordered_at\") AS \"orders._cumsum_inner\"\n FROM base\n), shifted__time_shift_inner AS (\n SELECT\n \"orders.ordered_at\" AS \"orders.ordered_at\",\n \"orders._cumsum_inner\" AS \"orders._cumsum_inner\"\n FROM step1\n), sjoin__time_shift_inner AS (\n SELECT\n step1.\"orders.ordered_at\",\n step1.\"orders.amount_sum\",\n step1.\"orders._cumsum_inner\",\n shifted__time_shift_inner.\"orders._cumsum_inner\" AS \"orders._time_shift_inner\"\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON step1.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.ordered_at\"\n), step2 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._cumsum_inner\",\n \"orders._time_shift_inner\",\n FIRST_VALUE(\"orders._cumsum_inner\" - \"orders._time_shift_inner\") OVER (\n ORDER BY \"orders.ordered_at\" DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS \"orders.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._cumsum_inner\",\n \"orders._time_shift_inner\",\n \"orders.t\"\n FROM step2\n) AS _outer", "alt/last_over_change_cumsum::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), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n SUM(\"orders.amount_sum\") OVER (ORDER BY \"orders.ordered_at\") AS \"orders._cumsum_inner\"\n FROM base\n), shifted__time_shift_inner AS (\n SELECT\n \"orders.ordered_at\" AS \"orders.ordered_at\",\n \"orders._cumsum_inner\" AS \"orders._cumsum_inner\"\n FROM step1\n), sjoin__time_shift_inner AS (\n SELECT\n step1.\"orders.ordered_at\",\n step1.\"orders.amount_sum\",\n step1.\"orders._cumsum_inner\",\n shifted__time_shift_inner.\"orders._cumsum_inner\" AS \"orders._time_shift_inner\"\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON step1.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.ordered_at\"\n), step2 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._cumsum_inner\",\n \"orders._time_shift_inner\",\n FIRST_VALUE(\"orders._cumsum_inner\" - \"orders._time_shift_inner\") OVER (\n ORDER BY \"orders.ordered_at\" DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS \"orders.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._cumsum_inner\",\n \"orders._time_shift_inner\",\n \"orders.t\"\n FROM step2\n) AS _outer", "alt/last_over_change_cumsum::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), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n SUM(\"orders.amount_sum\") OVER (ORDER BY \"orders.ordered_at\") AS \"orders._cumsum_inner\"\n FROM base\n), shifted__time_shift_inner AS (\n SELECT\n \"orders.ordered_at\" AS \"orders.ordered_at\",\n \"orders._cumsum_inner\" AS \"orders._cumsum_inner\"\n FROM step1\n), sjoin__time_shift_inner AS (\n SELECT\n step1.\"orders.ordered_at\",\n step1.\"orders.amount_sum\",\n step1.\"orders._cumsum_inner\",\n shifted__time_shift_inner.\"orders._cumsum_inner\" AS \"orders._time_shift_inner\"\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON SLAYER_DATE_ADD(step1.\"orders.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"orders.ordered_at\"\n), step2 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._cumsum_inner\",\n \"orders._time_shift_inner\",\n FIRST_VALUE(\"orders._cumsum_inner\" - \"orders._time_shift_inner\") OVER (\n ORDER BY \"orders.ordered_at\" DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS \"orders.t\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.t\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._cumsum_inner\",\n \"orders._time_shift_inner\",\n \"orders.t\"\n FROM step2\n) AS _outer", "alt/last_over_change_cumsum::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), step1 AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___amount_sum] AS [orders___amount_sum],\n SUM([orders___amount_sum]) OVER (ORDER BY [orders___ordered_at]) AS [orders____cumsum_inner]\n FROM base\n), shifted__time_shift_inner AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [orders____cumsum_inner] AS [orders____cumsum_inner]\n FROM step1\n), sjoin__time_shift_inner AS (\n SELECT\n step1.[orders___ordered_at] AS [orders___ordered_at],\n step1.[orders___amount_sum] AS [orders___amount_sum],\n step1.[orders____cumsum_inner] AS [orders____cumsum_inner],\n shifted__time_shift_inner.[orders____cumsum_inner] AS [orders____time_shift_inner]\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON (\n (\n DATEADD(MONTH, -1, step1.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, step1.[orders___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\n OR (\n DATEADD(MONTH, -1, step1.[orders___ordered_at]) IS NULL\n AND shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\n )\n), step2 AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders____cumsum_inner] AS [orders____cumsum_inner],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n FIRST_VALUE([orders____cumsum_inner] - [orders____time_shift_inner]) OVER (\n ORDER BY [orders___ordered_at] DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS [orders___t]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [orders___ordered_at],\n [orders___t]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders___amount_sum],\n [orders____cumsum_inner],\n [orders____time_shift_inner],\n [orders___t]\n FROM step2\n) AS _outer", - "alt/last_over_change_filtered::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 GROUP BY\n orders.status,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n orders.status AS `orders___status`,\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 orders.status,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), sjoin__time_shift_inner AS (\n SELECT\n base.`orders___status`,\n base.`orders___ordered_at`,\n base.`orders___amount_sum`,\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___status` IS NOT DISTINCT FROM shifted__time_shift_inner.`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__time_shift_inner.`orders___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n FIRST_VALUE(`orders___amount_sum` - `orders____time_shift_inner`) OVER (\n PARTITION BY `orders___status`\n ORDER BY `orders___ordered_at` DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS `orders____last_inner`\n FROM sjoin__time_shift_inner\n), step2 AS (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n `orders____last_inner`,\n `orders___amount_sum` - `orders____time_shift_inner` AS `orders___ch`\n FROM step1\n)\nSELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___ch`\nFROM (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n `orders____last_inner`,\n `orders___ch`\n FROM step2\n WHERE\n `orders____last_inner` < 0\n) AS _outer", + "alt/last_over_change_filtered::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 GROUP BY\n orders.status,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n orders.status AS `orders___status`,\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 orders.status,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), sjoin__time_shift_inner AS (\n SELECT\n base.`orders___status`,\n base.`orders___ordered_at`,\n base.`orders___amount_sum`,\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___status` IS NOT DISTINCT FROM shifted__time_shift_inner.`orders___status`\n AND DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS DATETIME)\n), step1 AS (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n FIRST_VALUE(`orders___amount_sum` - `orders____time_shift_inner`) OVER (\n PARTITION BY `orders___status`\n ORDER BY `orders___ordered_at` DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS `orders____last_inner`\n FROM sjoin__time_shift_inner\n), step2 AS (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n `orders____last_inner`,\n `orders___amount_sum` - `orders____time_shift_inner` AS `orders___ch`\n FROM step1\n)\nSELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___ch`\nFROM (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____time_shift_inner`,\n `orders____last_inner`,\n `orders___ch`\n FROM step2\n WHERE\n `orders____last_inner` < 0\n) AS _outer", "alt/last_over_change_filtered::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 GROUP BY\n orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n orders.status AS \"orders.status\",\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 orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.status\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\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.status\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.status\"\n AND 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.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n FIRST_VALUE(\"orders.amount_sum\" - \"orders._time_shift_inner\") OVER (\n PARTITION BY \"orders.status\"\n ORDER BY \"orders.ordered_at\" DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS \"orders._last_inner\"\n FROM sjoin__time_shift_inner\n), step2 AS (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n \"orders._last_inner\",\n \"orders.amount_sum\" - \"orders._time_shift_inner\" AS \"orders.ch\"\n FROM step1\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.ch\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n \"orders._last_inner\",\n \"orders.ch\"\n FROM step2\n WHERE\n \"orders._last_inner\" < 0\n) AS _outer", "alt/last_over_change_filtered::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 GROUP BY\n orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n orders.status AS \"orders.status\",\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 orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.status\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\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.status\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.status\"\n AND 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.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n FIRST_VALUE(\"orders.amount_sum\" - \"orders._time_shift_inner\") OVER (\n PARTITION BY \"orders.status\"\n ORDER BY \"orders.ordered_at\" DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS \"orders._last_inner\"\n FROM sjoin__time_shift_inner\n), step2 AS (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n \"orders._last_inner\",\n \"orders.amount_sum\" - \"orders._time_shift_inner\" AS \"orders.ch\"\n FROM step1\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.ch\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n \"orders._last_inner\",\n \"orders.ch\"\n FROM step2\n WHERE\n \"orders._last_inner\" < 0\n) AS _outer", "alt/last_over_change_filtered::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 GROUP BY\n orders.status,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n orders.status AS \"orders.status\",\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 orders.status,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.status\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\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.status\" IS shifted__time_shift_inner.\"orders.status\"\n AND SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n FIRST_VALUE(\"orders.amount_sum\" - \"orders._time_shift_inner\") OVER (\n PARTITION BY \"orders.status\"\n ORDER BY \"orders.ordered_at\" DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS \"orders._last_inner\"\n FROM sjoin__time_shift_inner\n), step2 AS (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n \"orders._last_inner\",\n \"orders.amount_sum\" - \"orders._time_shift_inner\" AS \"orders.ch\"\n FROM step1\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.ch\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._time_shift_inner\",\n \"orders._last_inner\",\n \"orders.ch\"\n FROM step2\n WHERE\n \"orders._last_inner\" < 0\n) AS _outer", "alt/last_over_change_filtered::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 GROUP BY\n orders.status,\n DATETRUNC(month, orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n orders.status AS [orders___status],\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 orders.status,\n DATETRUNC(month, orders.ordered_at)\n), sjoin__time_shift_inner 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 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 (\n base.[orders___status] = shifted__time_shift_inner.[orders___status]\n AND NOT base.[orders___status] IS NULL\n AND NOT shifted__time_shift_inner.[orders___status] IS NULL\n )\n OR (\n base.[orders___status] IS NULL\n AND shifted__time_shift_inner.[orders___status] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\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___status] AS [orders___status],\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n FIRST_VALUE([orders___amount_sum] - [orders____time_shift_inner]) OVER (\n PARTITION BY [orders___status]\n ORDER BY [orders___ordered_at] DESC\n ROWS BETWEEN UNBOUNDED PRECEDING AND UNBOUNDED FOLLOWING\n ) AS [orders____last_inner]\n FROM sjoin__time_shift_inner\n), step2 AS (\n SELECT\n [orders___status] AS [orders___status],\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n [orders____last_inner] AS [orders____last_inner],\n [orders___amount_sum] - [orders____time_shift_inner] AS [orders___ch]\n FROM step1\n)\nSELECT\n [orders___status],\n [orders___ordered_at],\n [orders___ch]\nFROM (\n SELECT\n [orders___status],\n [orders___ordered_at],\n [orders___amount_sum],\n [orders____time_shift_inner],\n [orders____last_inner],\n [orders___ch]\n FROM step2\n WHERE\n [orders____last_inner] < 0\n) AS _outer", - "alt/two_level_composites::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), step1 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n SUM(`orders___amount_sum`) OVER (ORDER BY `orders___ordered_at`) AS `orders____cumsum_inner`\n FROM base\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 step1.`orders___ordered_at`,\n step1.`orders___amount_sum`,\n step1.`orders____cumsum_inner`,\n shifted__time_shift_inner.`orders___amount_sum` AS `orders____time_shift_inner`\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON CAST(DATETIME_ADD(CAST(CAST(step1.`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), shifted__time_shift_inner_2 AS (\n SELECT\n `orders___ordered_at` AS `orders___ordered_at`,\n `orders____cumsum_inner` AS `orders____cumsum_inner`\n FROM sjoin__time_shift_inner\n), sjoin__time_shift_inner_2 AS (\n SELECT\n sjoin__time_shift_inner.`orders___ordered_at`,\n sjoin__time_shift_inner.`orders___amount_sum`,\n sjoin__time_shift_inner.`orders____cumsum_inner`,\n sjoin__time_shift_inner.`orders____time_shift_inner`,\n shifted__time_shift_inner_2.`orders____cumsum_inner` AS `orders____time_shift_inner_2`\n FROM sjoin__time_shift_inner\n LEFT JOIN shifted__time_shift_inner_2\n ON CAST(DATETIME_ADD(\n CAST(CAST(sjoin__time_shift_inner.`orders___ordered_at` AS TIMESTAMP) AS DATETIME),\n INTERVAL -1 MONTH\n ) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner_2.`orders___ordered_at` AS TIMESTAMP)\n), step2 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____cumsum_inner`,\n `orders____time_shift_inner`,\n `orders____time_shift_inner_2`,\n `orders___amount_sum` - `orders____time_shift_inner` AS `orders___ch1`,\n `orders____cumsum_inner` - `orders____time_shift_inner_2` AS `orders___ch2`\n FROM sjoin__time_shift_inner_2\n)\nSELECT\n `orders___ordered_at`,\n `orders___ch1`,\n `orders___ch2`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____cumsum_inner`,\n `orders____time_shift_inner`,\n `orders____time_shift_inner_2`,\n `orders___ch1`,\n `orders___ch2`\n FROM step2\n) AS _outer", + "alt/two_level_composites::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), step1 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n SUM(`orders___amount_sum`) OVER (ORDER BY `orders___ordered_at`) AS `orders____cumsum_inner`\n FROM base\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 step1.`orders___ordered_at`,\n step1.`orders___amount_sum`,\n step1.`orders____cumsum_inner`,\n shifted__time_shift_inner.`orders___amount_sum` AS `orders____time_shift_inner`\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON DATETIME_ADD(CAST(step1.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS DATETIME)\n), shifted__time_shift_inner_2 AS (\n SELECT\n `orders___ordered_at` AS `orders___ordered_at`,\n `orders____cumsum_inner` AS `orders____cumsum_inner`\n FROM sjoin__time_shift_inner\n), sjoin__time_shift_inner_2 AS (\n SELECT\n sjoin__time_shift_inner.`orders___ordered_at`,\n sjoin__time_shift_inner.`orders___amount_sum`,\n sjoin__time_shift_inner.`orders____cumsum_inner`,\n sjoin__time_shift_inner.`orders____time_shift_inner`,\n shifted__time_shift_inner_2.`orders____cumsum_inner` AS `orders____time_shift_inner_2`\n FROM sjoin__time_shift_inner\n LEFT JOIN shifted__time_shift_inner_2\n ON DATETIME_ADD(CAST(sjoin__time_shift_inner.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner_2.`orders___ordered_at` AS DATETIME)\n), step2 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____cumsum_inner`,\n `orders____time_shift_inner`,\n `orders____time_shift_inner_2`,\n `orders___amount_sum` - `orders____time_shift_inner` AS `orders___ch1`,\n `orders____cumsum_inner` - `orders____time_shift_inner_2` AS `orders___ch2`\n FROM sjoin__time_shift_inner_2\n)\nSELECT\n `orders___ordered_at`,\n `orders___ch1`,\n `orders___ch2`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders____cumsum_inner`,\n `orders____time_shift_inner`,\n `orders____time_shift_inner_2`,\n `orders___ch1`,\n `orders___ch2`\n FROM step2\n) AS _outer", "alt/two_level_composites::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), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n SUM(\"orders.amount_sum\") OVER (ORDER BY \"orders.ordered_at\") AS \"orders._cumsum_inner\"\n FROM base\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 step1.\"orders.ordered_at\",\n step1.\"orders.amount_sum\",\n step1.\"orders._cumsum_inner\",\n shifted__time_shift_inner.\"orders.amount_sum\" AS \"orders._time_shift_inner\"\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON step1.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.ordered_at\"\n), shifted__time_shift_inner_2 AS (\n SELECT\n \"orders.ordered_at\" AS \"orders.ordered_at\",\n \"orders._cumsum_inner\" AS \"orders._cumsum_inner\"\n FROM sjoin__time_shift_inner\n), sjoin__time_shift_inner_2 AS (\n SELECT\n sjoin__time_shift_inner.\"orders.ordered_at\",\n sjoin__time_shift_inner.\"orders.amount_sum\",\n sjoin__time_shift_inner.\"orders._cumsum_inner\",\n sjoin__time_shift_inner.\"orders._time_shift_inner\",\n shifted__time_shift_inner_2.\"orders._cumsum_inner\" AS \"orders._time_shift_inner_2\"\n FROM sjoin__time_shift_inner\n LEFT JOIN shifted__time_shift_inner_2\n ON sjoin__time_shift_inner.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner_2.\"orders.ordered_at\"\n), step2 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._cumsum_inner\",\n \"orders._time_shift_inner\",\n \"orders._time_shift_inner_2\",\n \"orders.amount_sum\" - \"orders._time_shift_inner\" AS \"orders.ch1\",\n \"orders._cumsum_inner\" - \"orders._time_shift_inner_2\" AS \"orders.ch2\"\n FROM sjoin__time_shift_inner_2\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.ch1\",\n \"orders.ch2\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._cumsum_inner\",\n \"orders._time_shift_inner\",\n \"orders._time_shift_inner_2\",\n \"orders.ch1\",\n \"orders.ch2\"\n FROM step2\n) AS _outer", "alt/two_level_composites::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), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n SUM(\"orders.amount_sum\") OVER (ORDER BY \"orders.ordered_at\") AS \"orders._cumsum_inner\"\n FROM base\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 step1.\"orders.ordered_at\",\n step1.\"orders.amount_sum\",\n step1.\"orders._cumsum_inner\",\n shifted__time_shift_inner.\"orders.amount_sum\" AS \"orders._time_shift_inner\"\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON step1.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.ordered_at\"\n), shifted__time_shift_inner_2 AS (\n SELECT\n \"orders.ordered_at\" AS \"orders.ordered_at\",\n \"orders._cumsum_inner\" AS \"orders._cumsum_inner\"\n FROM sjoin__time_shift_inner\n), sjoin__time_shift_inner_2 AS (\n SELECT\n sjoin__time_shift_inner.\"orders.ordered_at\",\n sjoin__time_shift_inner.\"orders.amount_sum\",\n sjoin__time_shift_inner.\"orders._cumsum_inner\",\n sjoin__time_shift_inner.\"orders._time_shift_inner\",\n shifted__time_shift_inner_2.\"orders._cumsum_inner\" AS \"orders._time_shift_inner_2\"\n FROM sjoin__time_shift_inner\n LEFT JOIN shifted__time_shift_inner_2\n ON sjoin__time_shift_inner.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner_2.\"orders.ordered_at\"\n), step2 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._cumsum_inner\",\n \"orders._time_shift_inner\",\n \"orders._time_shift_inner_2\",\n \"orders.amount_sum\" - \"orders._time_shift_inner\" AS \"orders.ch1\",\n \"orders._cumsum_inner\" - \"orders._time_shift_inner_2\" AS \"orders.ch2\"\n FROM sjoin__time_shift_inner_2\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.ch1\",\n \"orders.ch2\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._cumsum_inner\",\n \"orders._time_shift_inner\",\n \"orders._time_shift_inner_2\",\n \"orders.ch1\",\n \"orders.ch2\"\n FROM step2\n) AS _outer", "alt/two_level_composites::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), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n SUM(\"orders.amount_sum\") OVER (ORDER BY \"orders.ordered_at\") AS \"orders._cumsum_inner\"\n FROM base\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 step1.\"orders.ordered_at\",\n step1.\"orders.amount_sum\",\n step1.\"orders._cumsum_inner\",\n shifted__time_shift_inner.\"orders.amount_sum\" AS \"orders._time_shift_inner\"\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON SLAYER_DATE_ADD(step1.\"orders.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"orders.ordered_at\"\n), shifted__time_shift_inner_2 AS (\n SELECT\n \"orders.ordered_at\" AS \"orders.ordered_at\",\n \"orders._cumsum_inner\" AS \"orders._cumsum_inner\"\n FROM sjoin__time_shift_inner\n), sjoin__time_shift_inner_2 AS (\n SELECT\n sjoin__time_shift_inner.\"orders.ordered_at\",\n sjoin__time_shift_inner.\"orders.amount_sum\",\n sjoin__time_shift_inner.\"orders._cumsum_inner\",\n sjoin__time_shift_inner.\"orders._time_shift_inner\",\n shifted__time_shift_inner_2.\"orders._cumsum_inner\" AS \"orders._time_shift_inner_2\"\n FROM sjoin__time_shift_inner\n LEFT JOIN shifted__time_shift_inner_2\n ON SLAYER_DATE_ADD(sjoin__time_shift_inner.\"orders.ordered_at\", -1, 'month') IS shifted__time_shift_inner_2.\"orders.ordered_at\"\n), step2 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._cumsum_inner\",\n \"orders._time_shift_inner\",\n \"orders._time_shift_inner_2\",\n \"orders.amount_sum\" - \"orders._time_shift_inner\" AS \"orders.ch1\",\n \"orders._cumsum_inner\" - \"orders._time_shift_inner_2\" AS \"orders.ch2\"\n FROM sjoin__time_shift_inner_2\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.ch1\",\n \"orders.ch2\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders._cumsum_inner\",\n \"orders._time_shift_inner\",\n \"orders._time_shift_inner_2\",\n \"orders.ch1\",\n \"orders.ch2\"\n FROM step2\n) AS _outer", "alt/two_level_composites::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), step1 AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___amount_sum] AS [orders___amount_sum],\n SUM([orders___amount_sum]) OVER (ORDER BY [orders___ordered_at]) AS [orders____cumsum_inner]\n FROM base\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 step1.[orders___ordered_at] AS [orders___ordered_at],\n step1.[orders___amount_sum] AS [orders___amount_sum],\n step1.[orders____cumsum_inner] AS [orders____cumsum_inner],\n shifted__time_shift_inner.[orders___amount_sum] AS [orders____time_shift_inner]\n FROM step1\n LEFT JOIN shifted__time_shift_inner\n ON (\n (\n DATEADD(MONTH, -1, step1.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, step1.[orders___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\n OR (\n DATEADD(MONTH, -1, step1.[orders___ordered_at]) IS NULL\n AND shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\n )\n), shifted__time_shift_inner_2 AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [orders____cumsum_inner] AS [orders____cumsum_inner]\n FROM sjoin__time_shift_inner\n), sjoin__time_shift_inner_2 AS (\n SELECT\n sjoin__time_shift_inner.[orders___ordered_at] AS [orders___ordered_at],\n sjoin__time_shift_inner.[orders___amount_sum] AS [orders___amount_sum],\n sjoin__time_shift_inner.[orders____cumsum_inner] AS [orders____cumsum_inner],\n sjoin__time_shift_inner.[orders____time_shift_inner] AS [orders____time_shift_inner],\n shifted__time_shift_inner_2.[orders____cumsum_inner] AS [orders____time_shift_inner_2]\n FROM sjoin__time_shift_inner\n LEFT JOIN shifted__time_shift_inner_2\n ON (\n (\n DATEADD(MONTH, -1, sjoin__time_shift_inner.[orders___ordered_at]) = shifted__time_shift_inner_2.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, sjoin__time_shift_inner.[orders___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner_2.[orders___ordered_at] IS NULL\n )\n OR (\n DATEADD(MONTH, -1, sjoin__time_shift_inner.[orders___ordered_at]) IS NULL\n AND shifted__time_shift_inner_2.[orders___ordered_at] IS NULL\n )\n )\n), step2 AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders____cumsum_inner] AS [orders____cumsum_inner],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n [orders____time_shift_inner_2] AS [orders____time_shift_inner_2],\n [orders___amount_sum] - [orders____time_shift_inner] AS [orders___ch1],\n [orders____cumsum_inner] - [orders____time_shift_inner_2] AS [orders___ch2]\n FROM sjoin__time_shift_inner_2\n)\nSELECT\n [orders___ordered_at],\n [orders___ch1],\n [orders___ch2]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders___amount_sum],\n [orders____cumsum_inner],\n [orders____time_shift_inner],\n [orders____time_shift_inner_2],\n [orders___ch1],\n [orders___ch2]\n FROM step2\n) AS _outer", - "fc/change_plus_count::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n COUNT(*) AS `orders____count`\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 _base.`orders____count`,\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.`orders____count`,\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 `orders____count`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `customers___spend_sum` - `orders____time_shift_inner` + `orders____count` AS `orders___c`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___c`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders____count`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders___c`\n FROM step1\n) AS _outer", + "fc/change_plus_count::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n COUNT(*) AS `orders____count`\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 _base.`orders____count`,\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.`orders____count`,\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 DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS DATETIME)\n), step1 AS (\n SELECT\n `orders___ordered_at`,\n `orders____count`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `customers___spend_sum` - `orders____time_shift_inner` + `orders____count` AS `orders___c`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___c`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders____count`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders___c`\n FROM step1\n) AS _outer", "fc/change_plus_count::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n COUNT(*) AS \"orders._count\"\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 _base.\"orders._count\",\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.\"orders._count\",\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 \"orders._count\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders._count\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders._count\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/change_plus_count::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n COUNT(*) AS \"orders._count\"\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 _base.\"orders._count\",\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.\"orders._count\",\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 \"orders._count\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders._count\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders._count\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/change_plus_count::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n COUNT(*) AS \"orders._count\"\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 _base.\"orders._count\",\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.\"orders._count\",\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 \"orders._count\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders._count\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders._count\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/change_plus_count::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n COUNT(*) AS [orders____count]\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 _base.[orders____count] AS [orders____count],\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.[orders____count] AS [orders____count],\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 (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\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____count] AS [orders____count],\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] + [orders____count] AS [orders___c]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [orders___ordered_at],\n [orders___c]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders____count],\n [customers___spend_sum],\n [orders____time_shift_inner],\n [orders___c]\n FROM step1\n) AS _outer", - "fc/change_plus_max::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n MAX(orders.amount) AS `orders___amount_max`\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 _base.`orders___amount_max`,\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.`orders___amount_max`,\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 `orders___amount_max`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `customers___spend_sum` - `orders____time_shift_inner` + `orders___amount_max` AS `orders___c`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___c`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_max`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders___c`\n FROM step1\n) AS _outer", + "fc/change_plus_max::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n MAX(orders.amount) AS `orders___amount_max`\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 _base.`orders___amount_max`,\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.`orders___amount_max`,\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 DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS DATETIME)\n), step1 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_max`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `customers___spend_sum` - `orders____time_shift_inner` + `orders___amount_max` AS `orders___c`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___c`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_max`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders___c`\n FROM step1\n) AS _outer", "fc/change_plus_max::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n MAX(orders.amount) AS \"orders.amount_max\"\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 _base.\"orders.amount_max\",\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.\"orders.amount_max\",\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 \"orders.amount_max\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders.amount_max\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_max\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/change_plus_max::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n MAX(orders.amount) AS \"orders.amount_max\"\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 _base.\"orders.amount_max\",\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.\"orders.amount_max\",\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 \"orders.amount_max\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders.amount_max\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_max\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/change_plus_max::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n MAX(orders.amount) AS \"orders.amount_max\"\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 _base.\"orders.amount_max\",\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.\"orders.amount_max\",\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 \"orders.amount_max\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders.amount_max\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_max\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/change_plus_max::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n MAX(orders.amount) AS [orders___amount_max]\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 _base.[orders___amount_max] AS [orders___amount_max],\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.[orders___amount_max] AS [orders___amount_max],\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 (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\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_max] AS [orders___amount_max],\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] + [orders___amount_max] AS [orders___c]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [orders___ordered_at],\n [orders___c]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders___amount_max],\n [customers___spend_sum],\n [orders____time_shift_inner],\n [orders___c]\n FROM step1\n) AS _outer", - "fc/change_plus_sum::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 _base.`orders___amount_sum`,\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.`orders___amount_sum`,\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 `orders___amount_sum`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `customers___spend_sum` - `orders____time_shift_inner` + `orders___amount_sum` AS `orders___c`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___c`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders___c`\n FROM step1\n) AS _outer", + "fc/change_plus_sum::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 _base.`orders___amount_sum`,\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.`orders___amount_sum`,\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 DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS DATETIME)\n), step1 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `customers___spend_sum` - `orders____time_shift_inner` + `orders___amount_sum` AS `orders___c`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___c`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders___c`\n FROM step1\n) AS _outer", "fc/change_plus_sum::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 _base.\"orders.amount_sum\",\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.\"orders.amount_sum\",\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 \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders.amount_sum\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/change_plus_sum::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 _base.\"orders.amount_sum\",\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.\"orders.amount_sum\",\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 \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders.amount_sum\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/change_plus_sum::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 _base.\"orders.amount_sum\",\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.\"orders.amount_sum\",\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 \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders.amount_sum\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/change_plus_sum::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 _base.[orders___amount_sum] AS [orders___amount_sum],\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.[orders___amount_sum] AS [orders___amount_sum],\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 (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\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 [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] + [orders___amount_sum] AS [orders___c]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [orders___ordered_at],\n [orders___c]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders___amount_sum],\n [customers___spend_sum],\n [orders____time_shift_inner],\n [orders___c]\n FROM step1\n) AS _outer", - "fc/change_plus_sum_by_status::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 GROUP BY\n orders.status,\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___status`,\n _base.`orders___ordered_at`,\n _base.`orders___amount_sum`,\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 orders.status AS `orders___status`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.status,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.`orders___status`,\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___status`,\n base.`orders___ordered_at`,\n base.`orders___amount_sum`,\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___status` IS NOT DISTINCT FROM shifted__time_shift_inner.`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__time_shift_inner.`orders___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___amount_sum`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `customers___spend_sum` - `orders____time_shift_inner` + `orders___amount_sum` AS `orders___c`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___c`\nFROM (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___amount_sum`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders___c`\n FROM step1\n) AS _outer", + "fc/change_plus_sum_by_status::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 GROUP BY\n orders.status,\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___status`,\n _base.`orders___ordered_at`,\n _base.`orders___amount_sum`,\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 orders.status AS `orders___status`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.status,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.`orders___status`,\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___status`,\n base.`orders___ordered_at`,\n base.`orders___amount_sum`,\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___status` IS NOT DISTINCT FROM shifted__time_shift_inner.`orders___status`\n AND DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS DATETIME)\n), step1 AS (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___amount_sum`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `customers___spend_sum` - `orders____time_shift_inner` + `orders___amount_sum` AS `orders___c`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___c`\nFROM (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___amount_sum`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders___c`\n FROM step1\n) AS _outer", "fc/change_plus_sum_by_status::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 GROUP BY\n orders.status,\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.status\",\n _base.\"orders.ordered_at\",\n _base.\"orders.amount_sum\",\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 orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.status\",\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.status\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\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.status\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.status\"\n AND 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.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders.amount_sum\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/change_plus_sum_by_status::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 GROUP BY\n orders.status,\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.status\",\n _base.\"orders.ordered_at\",\n _base.\"orders.amount_sum\",\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 orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.status\",\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.status\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\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.status\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.status\"\n AND 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.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders.amount_sum\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/change_plus_sum_by_status::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 GROUP BY\n orders.status,\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.status\",\n _base.\"orders.ordered_at\",\n _base.\"orders.amount_sum\",\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 orders.status AS \"orders.status\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.status,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.status\",\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.status\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\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.status\" IS shifted__time_shift_inner.\"orders.status\"\n AND SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders.amount_sum\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/change_plus_sum_by_status::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 GROUP BY\n orders.status,\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___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__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 orders.status AS [orders___status],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at]\n FROM orders AS orders\n GROUP BY\n orders.status,\n DATETRUNC(month, orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.[orders___status] AS [orders___status],\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___status] AS [orders___status],\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[orders___amount_sum] AS [orders___amount_sum],\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 (\n base.[orders___status] = shifted__time_shift_inner.[orders___status]\n AND NOT base.[orders___status] IS NULL\n AND NOT shifted__time_shift_inner.[orders___status] IS NULL\n )\n OR (\n base.[orders___status] IS NULL\n AND shifted__time_shift_inner.[orders___status] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\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___status] AS [orders___status],\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___amount_sum] AS [orders___amount_sum],\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] + [orders___amount_sum] AS [orders___c]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [orders___status],\n [orders___ordered_at],\n [orders___c]\nFROM (\n SELECT\n [orders___status],\n [orders___ordered_at],\n [orders___amount_sum],\n [customers___spend_sum],\n [orders____time_shift_inner],\n [orders___c]\n FROM step1\n) AS _outer", - "fc/change_wscaled_plus_sum::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__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 _base.`orders___amount_sum`,\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_sum`,\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_sum`,\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` + `orders___amount_sum` AS `orders___c`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___c`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___amount_wscaled_sum_w_customers_regions_weight`,\n `orders____time_shift_inner`,\n `orders___c`\n FROM step1\n) AS _outer", + "fc/change_wscaled_plus_sum::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__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 _base.`orders___amount_sum`,\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_sum`,\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 DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(_cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___ordered_at` AS DATETIME)\n), step1 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\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` + `orders___amount_sum` AS `orders___c`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___c`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___amount_wscaled_sum_w_customers_regions_weight`,\n `orders____time_shift_inner`,\n `orders___c`\n FROM step1\n) AS _outer", "fc/change_wscaled_plus_sum::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__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 _base.\"orders.amount_sum\",\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_sum\",\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_sum\",\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\" + \"orders.amount_sum\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/change_wscaled_plus_sum::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__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 _base.\"orders.amount_sum\",\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_sum\",\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_sum\",\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\" + \"orders.amount_sum\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/change_wscaled_plus_sum::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__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 _base.\"orders.amount_sum\",\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_sum\",\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_sum\",\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\" + \"orders.amount_sum\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.amount_wscaled_sum_w_customers_regions_weight\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", @@ -49,37 +49,37 @@ "fc/cumsum_plus_sum::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 _base.\"orders.amount_sum\",\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), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n SUM(\"customers.spend_sum\") OVER (ORDER BY \"orders.ordered_at\") AS \"orders._cumsum_inner\"\n FROM base\n), step2 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._cumsum_inner\",\n \"orders._cumsum_inner\" + \"orders.amount_sum\" AS \"orders.c\"\n FROM step1\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._cumsum_inner\",\n \"orders.c\"\n FROM step2\n) AS _outer", "fc/cumsum_plus_sum::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 _base.\"orders.amount_sum\",\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), step1 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n SUM(\"customers.spend_sum\") OVER (ORDER BY \"orders.ordered_at\") AS \"orders._cumsum_inner\"\n FROM base\n), step2 AS (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._cumsum_inner\",\n \"orders._cumsum_inner\" + \"orders.amount_sum\" AS \"orders.c\"\n FROM step1\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._cumsum_inner\",\n \"orders.c\"\n FROM step2\n) AS _outer", "fc/cumsum_plus_sum::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 _base.[orders___amount_sum] AS [orders___amount_sum],\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), step1 AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___amount_sum] AS [orders___amount_sum],\n [customers___spend_sum] AS [customers___spend_sum],\n SUM([customers___spend_sum]) OVER (ORDER BY [orders___ordered_at]) AS [orders____cumsum_inner]\n FROM base\n), step2 AS (\n SELECT\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___amount_sum] AS [orders___amount_sum],\n [customers___spend_sum] AS [customers___spend_sum],\n [orders____cumsum_inner] AS [orders____cumsum_inner],\n [orders____cumsum_inner] + [orders___amount_sum] AS [orders___c]\n FROM step1\n)\nSELECT\n [orders___ordered_at],\n [orders___c]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders___amount_sum],\n [customers___spend_sum],\n [orders____cumsum_inner],\n [orders___c]\n FROM step2\n) AS _outer", - "fc/iif_over_change::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 _base.`orders___amount_sum`,\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.`orders___amount_sum`,\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 `orders___amount_sum`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n CAST(CASE\n WHEN `customers___spend_sum` - `orders____time_shift_inner` > 0\n THEN `customers___spend_sum`\n ELSE `orders___amount_sum`\n END AS FLOAT64) AS `orders___c`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___c`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders___c`\n FROM step1\n) AS _outer", + "fc/iif_over_change::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 _base.`orders___amount_sum`,\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.`orders___amount_sum`,\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 DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS DATETIME)\n), step1 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n CAST(CASE\n WHEN `customers___spend_sum` - `orders____time_shift_inner` > 0\n THEN `customers___spend_sum`\n ELSE `orders___amount_sum`\n END AS FLOAT64) AS `orders___c`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___c`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders___c`\n FROM step1\n) AS _outer", "fc/iif_over_change::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 _base.\"orders.amount_sum\",\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.\"orders.amount_sum\",\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 \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n CAST(CASE\n WHEN \"customers.spend_sum\" - \"orders._time_shift_inner\" > 0\n THEN \"customers.spend_sum\"\n ELSE \"orders.amount_sum\"\n END AS DOUBLE) AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/iif_over_change::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 _base.\"orders.amount_sum\",\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.\"orders.amount_sum\",\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 \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n CAST(CASE\n WHEN \"customers.spend_sum\" - \"orders._time_shift_inner\" > 0\n THEN \"customers.spend_sum\"\n ELSE \"orders.amount_sum\"\n END AS DOUBLE PRECISION) AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/iif_over_change::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 _base.\"orders.amount_sum\",\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.\"orders.amount_sum\",\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 \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n CAST(CASE\n WHEN \"customers.spend_sum\" - \"orders._time_shift_inner\" > 0\n THEN \"customers.spend_sum\"\n ELSE \"orders.amount_sum\"\n END AS REAL) AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/iif_over_change::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 _base.[orders___amount_sum] AS [orders___amount_sum],\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.[orders___amount_sum] AS [orders___amount_sum],\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 (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\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 [customers___spend_sum] AS [customers___spend_sum],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n CAST(CASE\n WHEN [customers___spend_sum] - [orders____time_shift_inner] > 0\n THEN [customers___spend_sum]\n ELSE [orders___amount_sum]\n END AS FLOAT) AS [orders___c]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [orders___ordered_at],\n [orders___c]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders___amount_sum],\n [customers___spend_sum],\n [orders____time_shift_inner],\n [orders___c]\n FROM step1\n) AS _outer", - "fc/time_shift_plus_sum::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 _base.`orders___amount_sum`,\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.`orders___amount_sum`,\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 `orders___amount_sum`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders____time_shift_inner` + `orders___amount_sum` AS `orders___c`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___c`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders___c`\n FROM step1\n) AS _outer", + "fc/time_shift_plus_sum::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 _base.`orders___amount_sum`,\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.`orders___amount_sum`,\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 DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS DATETIME)\n), step1 AS (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders____time_shift_inner` + `orders___amount_sum` AS `orders___c`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___ordered_at`,\n `orders___c`\nFROM (\n SELECT\n `orders___ordered_at`,\n `orders___amount_sum`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders___c`\n FROM step1\n) AS _outer", "fc/time_shift_plus_sum::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 _base.\"orders.amount_sum\",\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.\"orders.amount_sum\",\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 \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders._time_shift_inner\" + \"orders.amount_sum\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/time_shift_plus_sum::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 _base.\"orders.amount_sum\",\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.\"orders.amount_sum\",\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 \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders._time_shift_inner\" + \"orders.amount_sum\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/time_shift_plus_sum::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 _base.\"orders.amount_sum\",\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.\"orders.amount_sum\",\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 \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders._time_shift_inner\" + \"orders.amount_sum\" AS \"orders.c\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.ordered_at\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders.c\"\n FROM step1\n) AS _outer", "fc/time_shift_plus_sum::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 _base.[orders___amount_sum] AS [orders___amount_sum],\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.[orders___amount_sum] AS [orders___amount_sum],\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 (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\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 [customers___spend_sum] AS [customers___spend_sum],\n [orders____time_shift_inner] AS [orders____time_shift_inner],\n [orders____time_shift_inner] + [orders___amount_sum] AS [orders___c]\n FROM sjoin__time_shift_inner\n)\nSELECT\n [orders___ordered_at],\n [orders___c]\nFROM (\n SELECT\n [orders___ordered_at],\n [orders___amount_sum],\n [customers___spend_sum],\n [orders____time_shift_inner],\n [orders___c]\n FROM step1\n) AS _outer", - "named/change_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 `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::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 DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS DATETIME)\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::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 \"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::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 (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\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(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::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 DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS DATETIME)\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 (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted__time_shift_inner.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[orders___ordered_at] IS NULL\n )\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::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 DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(_cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___ordered_at` AS DATETIME)\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 (\n _base.[orders___ordered_at] = _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at]\n AND NOT _base.[orders___ordered_at] IS NULL\n AND NOT _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at] IS NULL\n )\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 (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at] IS NULL\n )\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::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 DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(_cm_orders__amount_wscaled_sum_w_customers_regions_weight.`orders___ordered_at` AS DATETIME)\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", "named/change_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.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::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 (\n _base.[orders___ordered_at] = _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at]\n AND NOT _base.[orders___ordered_at] IS NULL\n AND NOT _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at] IS NULL\n )\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 (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT _cm_orders__amount_wscaled_sum_w_customers_regions_weight.[orders___ordered_at] IS NULL\n )\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___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", - "pos/filter_composite::bigquery": "WITH _base AS (\n SELECT\n orders.status AS `orders___status`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___a`\n FROM orders AS orders\n GROUP BY\n orders.status,\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___status`,\n _base.`orders___ordered_at`,\n _base.`orders___a`,\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 orders.status AS `orders___status`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.status,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.`orders___status`,\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___status`,\n base.`orders___ordered_at`,\n base.`orders___a`,\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___status` IS NOT DISTINCT FROM shifted__time_shift_inner.`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__time_shift_inner.`orders___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___a`\nFROM (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___a`,\n `customers___spend_sum`,\n `orders____time_shift_inner`\n FROM sjoin__time_shift_inner\n WHERE\n `customers___spend_sum` - `orders____time_shift_inner` + `orders___a` > 0\n) AS _outer", + "pos/filter_composite::bigquery": "WITH _base AS (\n SELECT\n orders.status AS `orders___status`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___a`\n FROM orders AS orders\n GROUP BY\n orders.status,\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___status`,\n _base.`orders___ordered_at`,\n _base.`orders___a`,\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 orders.status AS `orders___status`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.status,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.`orders___status`,\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___status`,\n base.`orders___ordered_at`,\n base.`orders___a`,\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___status` IS NOT DISTINCT FROM shifted__time_shift_inner.`orders___status`\n AND DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS DATETIME)\n)\nSELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___a`\nFROM (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___a`,\n `customers___spend_sum`,\n `orders____time_shift_inner`\n FROM sjoin__time_shift_inner\n WHERE\n `customers___spend_sum` - `orders____time_shift_inner` + `orders___a` > 0\n) AS _outer", "pos/filter_composite::duckdb": "WITH _base AS (\n SELECT\n orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.a\"\n FROM orders AS orders\n GROUP BY\n orders.status,\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.status\",\n _base.\"orders.ordered_at\",\n _base.\"orders.a\",\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 orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.status\",\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.status\",\n base.\"orders.ordered_at\",\n base.\"orders.a\",\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.status\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.status\"\n AND base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.ordered_at\"\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.a\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.a\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\"\n FROM sjoin__time_shift_inner\n WHERE\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders.a\" > 0\n) AS _outer", "pos/filter_composite::postgres": "WITH _base AS (\n SELECT\n orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.a\"\n FROM orders AS orders\n GROUP BY\n orders.status,\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.status\",\n _base.\"orders.ordered_at\",\n _base.\"orders.a\",\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 orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.status\",\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.status\",\n base.\"orders.ordered_at\",\n base.\"orders.a\",\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.status\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.status\"\n AND base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.ordered_at\"\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.a\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.a\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\"\n FROM sjoin__time_shift_inner\n WHERE\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders.a\" > 0\n) AS _outer", "pos/filter_composite::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 CAST(SUM(orders.amount) AS REAL) AS \"orders.a\"\n FROM orders AS orders\n GROUP BY\n orders.status,\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.status\",\n _base.\"orders.ordered_at\",\n _base.\"orders.a\",\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 orders.status AS \"orders.status\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.status,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.status\",\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.status\",\n base.\"orders.ordered_at\",\n base.\"orders.a\",\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.status\" IS shifted__time_shift_inner.\"orders.status\"\n AND SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"orders.ordered_at\"\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.a\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.a\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\"\n FROM sjoin__time_shift_inner\n WHERE\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders.a\" > 0\n) AS _outer", @@ -91,7 +91,7 @@ "pos/measure_mask::tsql": "SELECT\n orders.status AS [orders___status],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___a]\nFROM orders AS orders\nGROUP BY\n orders.status,\n DATETRUNC(month, orders.ordered_at)\nHAVING\n SUM(orders.amount) > 10", "pos/order_composite::bigquery": { "error": "ScopeLeakError", - "message": "Scope not closed \u2014 2 out-of-scope reference(s):\n - [unbound_table] orders._arith_+ in subquery _outer (bound sources: ['_base', '_cm_orders__customers__spend_sum', 'base', '_base_2', 'shifted__time_shift_inner', 'sjoin__time_shift_inner', 'step1'])\n - [unbound_table] orders._arith_+ in top-level SELECT (bound sources: ['_base', '_cm_orders__customers__spend_sum', 'base', '_base_2', 'shifted__time_shift_inner', 'sjoin__time_shift_inner', 'step1', '_outer'])\nSQL:\nWITH _base AS (\n SELECT\n orders.status AS `orders___status`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___a`\n FROM orders AS orders\n GROUP BY\n orders.status,\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___status`,\n _base.`orders___ordered_at`,\n _base.`orders___a`,\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 orders.status AS `orders___status`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.status,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.`orders___status`,\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___status`,\n base.`orders___ordered_at`,\n base.`orders___a`,\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___status` IS NOT DISTINCT FROM shifted__time_shift_inner.`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__time_shift_inner.`orders___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___a`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `customers___spend_sum` - `orders____time_shift_inner` + `orders___a` AS `orders._arith_+`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___a`\nFROM (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___a`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders._arith_+`\n FROM step1\n) AS _outer\nORDER BY\n `orders._arith_+` DESC" + "message": "Scope not closed \u2014 2 out-of-scope reference(s):\n - [unbound_table] orders._arith_+ in subquery _outer (bound sources: ['_base', '_cm_orders__customers__spend_sum', 'base', '_base_2', 'shifted__time_shift_inner', 'sjoin__time_shift_inner', 'step1'])\n - [unbound_table] orders._arith_+ in top-level SELECT (bound sources: ['_base', '_cm_orders__customers__spend_sum', 'base', '_base_2', 'shifted__time_shift_inner', 'sjoin__time_shift_inner', 'step1', '_outer'])\nSQL:\nWITH _base AS (\n SELECT\n orders.status AS `orders___status`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___a`\n FROM orders AS orders\n GROUP BY\n orders.status,\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___status`,\n _base.`orders___ordered_at`,\n _base.`orders___a`,\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 orders.status AS `orders___status`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.status,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.`orders___status`,\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___status`,\n base.`orders___ordered_at`,\n base.`orders___a`,\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___status` IS NOT DISTINCT FROM shifted__time_shift_inner.`orders___status`\n AND DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS DATETIME)\n), step1 AS (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___a`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `customers___spend_sum` - `orders____time_shift_inner` + `orders___a` AS `orders._arith_+`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___a`\nFROM (\n SELECT\n `orders___status`,\n `orders___ordered_at`,\n `orders___a`,\n `customers___spend_sum`,\n `orders____time_shift_inner`,\n `orders._arith_+`\n FROM step1\n) AS _outer\nORDER BY\n `orders._arith_+` DESC" }, "pos/order_composite::duckdb": "WITH _base AS (\n SELECT\n orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.a\"\n FROM orders AS orders\n GROUP BY\n orders.status,\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.status\",\n _base.\"orders.ordered_at\",\n _base.\"orders.a\",\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 orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.status\",\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.status\",\n base.\"orders.ordered_at\",\n base.\"orders.a\",\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.status\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.status\"\n AND 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.status\",\n \"orders.ordered_at\",\n \"orders.a\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders.a\" AS \"orders._arith_+\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.a\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.a\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders._arith_+\"\n FROM step1\n) AS _outer\nORDER BY\n \"orders._arith_+\" DESC", "pos/order_composite::postgres": "WITH _base AS (\n SELECT\n orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.a\"\n FROM orders AS orders\n GROUP BY\n orders.status,\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.status\",\n _base.\"orders.ordered_at\",\n _base.\"orders.a\",\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 orders.status AS \"orders.status\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.status,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.status\",\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.status\",\n base.\"orders.ordered_at\",\n base.\"orders.a\",\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.status\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.status\"\n AND 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.status\",\n \"orders.ordered_at\",\n \"orders.a\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"customers.spend_sum\" - \"orders._time_shift_inner\" + \"orders.a\" AS \"orders._arith_+\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.a\"\nFROM (\n SELECT\n \"orders.status\",\n \"orders.ordered_at\",\n \"orders.a\",\n \"customers.spend_sum\",\n \"orders._time_shift_inner\",\n \"orders._arith_+\"\n FROM step1\n) AS _outer\nORDER BY\n \"orders._arith_+\" DESC NULLS LAST", diff --git a/tests/golden/dev1824_sql_baseline.json b/tests/golden/dev1824_sql_baseline.json index a62e73222..2ea9221e9 100644 --- a/tests/golden/dev1824_sql_baseline.json +++ b/tests/golden/dev1824_sql_baseline.json @@ -84,7 +84,7 @@ "lift/coexist_transform::postgres": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\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 orders.region,\n orders.city,\n DATE_TRUNC('MONTH', orders.ordered_at)\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.rt\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), base AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_sum_partition_by_region.\"orders.rt\",\n _base.\"orders.amount_sum\"\n FROM _base\n LEFT 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\"\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.city\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.rt\",\n SUM(\"orders.amount_sum\") OVER (PARTITION BY \"orders.region\", \"orders.city\" ORDER BY \"orders.ordered_at\") AS \"orders.c\"\n FROM base\n)\nSELECT\n \"orders.region\",\n \"orders.city\",\n \"orders.ordered_at\",\n \"orders.rt\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.city\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.rt\",\n \"orders.c\"\n FROM step1\n) AS _outer", "lift/coexist_transform::sqlite": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\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 orders.region,\n orders.city,\n STRFTIME('%Y-%m-01', orders.ordered_at)\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.rt\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), base AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_sum_partition_by_region.\"orders.rt\",\n _base.\"orders.amount_sum\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON _base.\"orders.region\" IS _cm_orders__amount_sum_partition_by_region.\"orders.region\"\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.city\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.rt\",\n SUM(\"orders.amount_sum\") OVER (PARTITION BY \"orders.region\", \"orders.city\" ORDER BY \"orders.ordered_at\") AS \"orders.c\"\n FROM base\n)\nSELECT\n \"orders.region\",\n \"orders.city\",\n \"orders.ordered_at\",\n \"orders.rt\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.city\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.rt\",\n \"orders.c\"\n FROM step1\n) AS _outer", "lift/coexist_transform::tsql": "WITH _base AS (\n SELECT\n orders.region AS [orders___region],\n orders.city AS [orders___city],\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 orders.region,\n orders.city,\n DATETRUNC(month, orders.ordered_at)\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___rt]\n FROM orders AS orders\n GROUP BY\n orders.region\n), base AS (\n SELECT\n _base.[orders___region] AS [orders___region],\n _base.[orders___city] AS [orders___city],\n _base.[orders___ordered_at] AS [orders___ordered_at],\n _cm_orders__amount_sum_partition_by_region.[orders___rt] AS [orders___rt],\n _base.[orders___amount_sum] AS [orders___amount_sum]\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON (\n (\n _base.[orders___region] = _cm_orders__amount_sum_partition_by_region.[orders___region]\n AND NOT _base.[orders___region] IS NULL\n AND NOT _cm_orders__amount_sum_partition_by_region.[orders___region] IS NULL\n )\n OR (\n _base.[orders___region] IS NULL\n AND _cm_orders__amount_sum_partition_by_region.[orders___region] IS NULL\n )\n )\n), step1 AS (\n SELECT\n [orders___region] AS [orders___region],\n [orders___city] AS [orders___city],\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___amount_sum] AS [orders___amount_sum],\n [orders___rt] AS [orders___rt],\n SUM([orders___amount_sum]) OVER (PARTITION BY [orders___region], [orders___city] ORDER BY [orders___ordered_at]) AS [orders___c]\n FROM base\n)\nSELECT\n [orders___region],\n [orders___city],\n [orders___ordered_at],\n [orders___rt],\n [orders___c]\nFROM (\n SELECT\n [orders___region],\n [orders___city],\n [orders___ordered_at],\n [orders___amount_sum],\n [orders___rt],\n [orders___c]\n FROM step1\n) AS _outer", - "lift/coexist_windowed::bigquery": "WITH _base AS (\n SELECT\n orders.region AS `orders___region`,\n orders.city AS `orders___city`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n DATE_TRUNC(orders.ordered_at, MONTH)\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___rt`\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_window_1y AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___city`,\n _base.`orders___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n orders.city AS `orders___city`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n DATE_TRUNC(orders.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.city AS _w_dim_1,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON (\n _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_dim_1 IS NOT DISTINCT FROM _base.`orders___city`\n )\n AND _src._w_time >= CAST(DATETIME_ADD(\n CAST(CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP) AS DATETIME),\n INTERVAL -1 YEAR\n ) AS TIMESTAMP)\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___city`,\n _base.`orders___ordered_at`\n)\nSELECT\n _base.`orders___region`,\n _base.`orders___city`,\n _base.`orders___ordered_at`,\n _cm_orders__amount_sum_partition_by_region.`orders___rt`,\n _cm_orders__amount_sum_window_1y.`orders___w`\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`\nLEFT JOIN _cm_orders__amount_sum_window_1y\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.`orders___region`\n AND _base.`orders___city` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.`orders___city`\n AND _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.`orders___ordered_at`", + "lift/coexist_windowed::bigquery": "WITH _base AS (\n SELECT\n orders.region AS `orders___region`,\n orders.city AS `orders___city`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n DATE_TRUNC(orders.ordered_at, MONTH)\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___rt`\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_window_1y AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___city`,\n _base.`orders___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n orders.city AS `orders___city`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n DATE_TRUNC(orders.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.city AS _w_dim_1,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON (\n _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_dim_1 IS NOT DISTINCT FROM _base.`orders___city`\n )\n AND _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -1 YEAR\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___city`,\n _base.`orders___ordered_at`\n)\nSELECT\n _base.`orders___region`,\n _base.`orders___city`,\n _base.`orders___ordered_at`,\n _cm_orders__amount_sum_partition_by_region.`orders___rt`,\n _cm_orders__amount_sum_window_1y.`orders___w`\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`\nLEFT JOIN _cm_orders__amount_sum_window_1y\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.`orders___region`\n AND _base.`orders___city` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.`orders___city`\n AND _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.`orders___ordered_at`", "lift/coexist_windowed::duckdb": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n DATE_TRUNC('MONTH', orders.ordered_at)\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.rt\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_window_1y AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n DATE_TRUNC('MONTH', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.city AS _w_dim_1,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON (\n _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_dim_1 IS NOT DISTINCT FROM _base.\"orders.city\"\n )\n AND _src._w_time >= _base.\"orders.ordered_at\" + INTERVAL 1 MONTH - INTERVAL 1 YEAR\n AND _src._w_time < _base.\"orders.ordered_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.ordered_at\"\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_sum_partition_by_region.\"orders.rt\",\n _cm_orders__amount_sum_window_1y.\"orders.w\"\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\"\nLEFT JOIN _cm_orders__amount_sum_window_1y\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.\"orders.region\"\n AND _base.\"orders.city\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.\"orders.city\"\n AND _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.\"orders.ordered_at\"", "lift/coexist_windowed::postgres": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n DATE_TRUNC('MONTH', orders.ordered_at)\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.rt\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_window_1y AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n DATE_TRUNC('MONTH', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.city AS _w_dim_1,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON (\n _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_dim_1 IS NOT DISTINCT FROM _base.\"orders.city\"\n )\n AND _src._w_time >= _base.\"orders.ordered_at\" + INTERVAL '1 MONTH' - INTERVAL '1 YEAR'\n AND _src._w_time < _base.\"orders.ordered_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.ordered_at\"\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_sum_partition_by_region.\"orders.rt\",\n _cm_orders__amount_sum_window_1y.\"orders.w\"\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\"\nLEFT JOIN _cm_orders__amount_sum_window_1y\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.\"orders.region\"\n AND _base.\"orders.city\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.\"orders.city\"\n AND _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.\"orders.ordered_at\"", "lift/coexist_windowed::sqlite": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n STRFTIME('%Y-%m-01', orders.ordered_at)\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.rt\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_sum_window_1y AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.city AS _w_dim_1,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON (\n _src._w_dim_0 IS _base.\"orders.region\" AND _src._w_dim_1 IS _base.\"orders.city\"\n )\n AND DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.ordered_at\", 1, 'month'), -1, 'year')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.ordered_at\", 1, 'month')\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.ordered_at\"\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_sum_partition_by_region.\"orders.rt\",\n _cm_orders__amount_sum_window_1y.\"orders.w\"\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\"\nLEFT JOIN _cm_orders__amount_sum_window_1y\n ON _base.\"orders.region\" IS _cm_orders__amount_sum_window_1y.\"orders.region\"\n AND _base.\"orders.city\" IS _cm_orders__amount_sum_window_1y.\"orders.city\"\n AND _base.\"orders.ordered_at\" IS _cm_orders__amount_sum_window_1y.\"orders.ordered_at\"", @@ -109,7 +109,7 @@ "lift/dim_two_partition_sets::postgres": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.amount_sum_partition_by_city\" AS \"amount_sum_partition_by_city\"\n FROM (\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 ) AS _stage_inner\n), _cm_amount_sum_partition_by_region AS (\n SELECT\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.amount_sum_partition_by_region\" AS \"amount_sum_partition_by_region\"\n FROM (\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 ) AS _stage_inner\n)\nSELECT\n orders.region AS \"orders.region\",\n _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" - _cm_amount_sum_partition_by_region.\"amount_sum_partition_by_region\" AS \"orders.gap\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.s\"\nFROM orders AS orders\nLEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\nLEFT JOIN _cm_amount_sum_partition_by_region\n ON orders.region IS NOT DISTINCT FROM _cm_amount_sum_partition_by_region.\"region\"\nGROUP BY\n orders.region,\n _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" - _cm_amount_sum_partition_by_region.\"amount_sum_partition_by_region\"", "lift/dim_two_partition_sets::sqlite": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.amount_sum_partition_by_city\" AS \"amount_sum_partition_by_city\"\n FROM (\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 ) AS _stage_inner\n), _cm_amount_sum_partition_by_region AS (\n SELECT\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.amount_sum_partition_by_region\" AS \"amount_sum_partition_by_region\"\n FROM (\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 ) AS _stage_inner\n)\nSELECT\n orders.region AS \"orders.region\",\n _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" - _cm_amount_sum_partition_by_region.\"amount_sum_partition_by_region\" AS \"orders.gap\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.s\"\nFROM orders AS orders\nLEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS _cm_amount_sum_partition_by_city.\"city\"\nLEFT JOIN _cm_amount_sum_partition_by_region\n ON orders.region IS _cm_amount_sum_partition_by_region.\"region\"\nGROUP BY\n orders.region,\n _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" - _cm_amount_sum_partition_by_region.\"amount_sum_partition_by_region\"", "lift/dim_two_partition_sets::tsql": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.[orders___city] AS [city],\n _stage_inner.[orders___amount_sum_partition_by_city] AS [amount_sum_partition_by_city]\n FROM (\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 ) AS _stage_inner\n), _cm_amount_sum_partition_by_region AS (\n SELECT\n _stage_inner.[orders___region] AS [region],\n _stage_inner.[orders___amount_sum_partition_by_region] AS [amount_sum_partition_by_region]\n FROM (\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 ) AS _stage_inner\n)\nSELECT\n orders.region AS [orders___region],\n _cm_amount_sum_partition_by_city.[amount_sum_partition_by_city] - _cm_amount_sum_partition_by_region.[amount_sum_partition_by_region] AS [orders___gap],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___s]\nFROM orders AS orders\nLEFT JOIN _cm_amount_sum_partition_by_city\n ON (\n (\n orders.city = _cm_amount_sum_partition_by_city.[city]\n AND NOT orders.city IS NULL\n AND NOT _cm_amount_sum_partition_by_city.[city] IS NULL\n )\n OR (\n orders.city IS NULL AND _cm_amount_sum_partition_by_city.[city] IS NULL\n )\n )\nLEFT JOIN _cm_amount_sum_partition_by_region\n ON (\n (\n orders.region = _cm_amount_sum_partition_by_region.[region]\n AND NOT orders.region IS NULL\n AND NOT _cm_amount_sum_partition_by_region.[region] IS NULL\n )\n OR (\n orders.region IS NULL AND _cm_amount_sum_partition_by_region.[region] IS NULL\n )\n )\nGROUP BY\n orders.region,\n _cm_amount_sum_partition_by_city.[amount_sum_partition_by_city] - _cm_amount_sum_partition_by_region.[amount_sum_partition_by_region]", - "lift/dim_window::bigquery": "WITH _cm_amount_sum_window_90d_partition_by_region AS (\n SELECT\n _stage_inner.`orders___region` AS `region`,\n _stage_inner.`orders___ordered_at_month` AS `ordered_at_month`,\n _stage_inner.`orders___amount_sum_window_90d_partition_by_region` AS `amount_sum_window_90d_partition_by_region`\n FROM (\n SELECT\n _base.`orders___region`,\n _base.`orders___ordered_at_month`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___amount_sum_window_90d_partition_by_region`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at_month`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at_month` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at_month` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___ordered_at_month`\n ) AS _stage_inner\n)\nSELECT\n orders.region AS `orders___region`,\n CASE\n WHEN _cm_amount_sum_window_90d_partition_by_region.`amount_sum_window_90d_partition_by_region` > 50\n THEN 1\n ELSE 0\n END AS `orders___wband`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___s`\nFROM orders AS orders\nLEFT JOIN _cm_amount_sum_window_90d_partition_by_region\n ON orders.region IS NOT DISTINCT FROM _cm_amount_sum_window_90d_partition_by_region.`region`\n AND DATE_TRUNC(orders.ordered_at, MONTH) IS NOT DISTINCT FROM _cm_amount_sum_window_90d_partition_by_region.`ordered_at_month`\nGROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_window_90d_partition_by_region.`amount_sum_window_90d_partition_by_region` > 50\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC(orders.ordered_at, MONTH)", + "lift/dim_window::bigquery": "WITH _cm_amount_sum_window_90d_partition_by_region AS (\n SELECT\n _stage_inner.`orders___region` AS `region`,\n _stage_inner.`orders___ordered_at_month` AS `ordered_at_month`,\n _stage_inner.`orders___amount_sum_window_90d_partition_by_region` AS `amount_sum_window_90d_partition_by_region`\n FROM (\n SELECT\n _base.`orders___region`,\n _base.`orders___ordered_at_month`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___amount_sum_window_90d_partition_by_region`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at_month`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at_month` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___ordered_at_month` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___ordered_at_month`\n ) AS _stage_inner\n)\nSELECT\n orders.region AS `orders___region`,\n CASE\n WHEN _cm_amount_sum_window_90d_partition_by_region.`amount_sum_window_90d_partition_by_region` > 50\n THEN 1\n ELSE 0\n END AS `orders___wband`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___s`\nFROM orders AS orders\nLEFT JOIN _cm_amount_sum_window_90d_partition_by_region\n ON orders.region IS NOT DISTINCT FROM _cm_amount_sum_window_90d_partition_by_region.`region`\n AND DATE_TRUNC(orders.ordered_at, MONTH) IS NOT DISTINCT FROM _cm_amount_sum_window_90d_partition_by_region.`ordered_at_month`\nGROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_window_90d_partition_by_region.`amount_sum_window_90d_partition_by_region` > 50\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC(orders.ordered_at, MONTH)", "lift/dim_window::duckdb": "WITH _cm_amount_sum_window_90d_partition_by_region AS (\n SELECT\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.ordered_at_month\" AS \"ordered_at_month\",\n _stage_inner.\"orders.amount_sum_window_90d_partition_by_region\" AS \"amount_sum_window_90d_partition_by_region\"\n FROM (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at_month\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"orders.amount_sum_window_90d_partition_by_region\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at_month\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_time >= _base.\"orders.ordered_at_month\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.ordered_at_month\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at_month\"\n ) AS _stage_inner\n)\nSELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_window_90d_partition_by_region.\"amount_sum_window_90d_partition_by_region\" > 50\n THEN 1\n ELSE 0\n END AS \"orders.wband\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.s\"\nFROM orders AS orders\nLEFT JOIN _cm_amount_sum_window_90d_partition_by_region\n ON orders.region IS NOT DISTINCT FROM _cm_amount_sum_window_90d_partition_by_region.\"region\"\n AND DATE_TRUNC('MONTH', orders.ordered_at) IS NOT DISTINCT FROM _cm_amount_sum_window_90d_partition_by_region.\"ordered_at_month\"\nGROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_window_90d_partition_by_region.\"amount_sum_window_90d_partition_by_region\" > 50\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC('MONTH', orders.ordered_at)", "lift/dim_window::postgres": "WITH _cm_amount_sum_window_90d_partition_by_region AS (\n SELECT\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.ordered_at_month\" AS \"ordered_at_month\",\n _stage_inner.\"orders.amount_sum_window_90d_partition_by_region\" AS \"amount_sum_window_90d_partition_by_region\"\n FROM (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at_month\",\n CAST(SUM(_src._w_value) AS DOUBLE PRECISION) AS \"orders.amount_sum_window_90d_partition_by_region\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at_month\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_time >= _base.\"orders.ordered_at_month\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.ordered_at_month\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at_month\"\n ) AS _stage_inner\n)\nSELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_window_90d_partition_by_region.\"amount_sum_window_90d_partition_by_region\" > 50\n THEN 1\n ELSE 0\n END AS \"orders.wband\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.s\"\nFROM orders AS orders\nLEFT JOIN _cm_amount_sum_window_90d_partition_by_region\n ON orders.region IS NOT DISTINCT FROM _cm_amount_sum_window_90d_partition_by_region.\"region\"\n AND DATE_TRUNC('MONTH', orders.ordered_at) IS NOT DISTINCT FROM _cm_amount_sum_window_90d_partition_by_region.\"ordered_at_month\"\nGROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_window_90d_partition_by_region.\"amount_sum_window_90d_partition_by_region\" > 50\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC('MONTH', orders.ordered_at)", "lift/dim_window::sqlite": "WITH _cm_amount_sum_window_90d_partition_by_region AS (\n SELECT\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.ordered_at_month\" AS \"ordered_at_month\",\n _stage_inner.\"orders.amount_sum_window_90d_partition_by_region\" AS \"amount_sum_window_90d_partition_by_region\"\n FROM (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at_month\",\n CAST(SUM(_src._w_value) AS REAL) AS \"orders.amount_sum_window_90d_partition_by_region\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at_month\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS _base.\"orders.region\"\n AND DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.ordered_at_month\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.ordered_at_month\", 1, 'month')\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at_month\"\n ) AS _stage_inner\n)\nSELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_window_90d_partition_by_region.\"amount_sum_window_90d_partition_by_region\" > 50\n THEN 1\n ELSE 0\n END AS \"orders.wband\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.s\"\nFROM orders AS orders\nLEFT JOIN _cm_amount_sum_window_90d_partition_by_region\n ON orders.region IS _cm_amount_sum_window_90d_partition_by_region.\"region\"\n AND STRFTIME('%Y-%m-01', orders.ordered_at) IS _cm_amount_sum_window_90d_partition_by_region.\"ordered_at_month\"\nGROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_window_90d_partition_by_region.\"amount_sum_window_90d_partition_by_region\" > 50\n THEN 1\n ELSE 0\n END,\n STRFTIME('%Y-%m-01', orders.ordered_at)", @@ -149,7 +149,7 @@ "lift/temporal_partition_last::postgres": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_last_partition_by_ordered_at_region AS (\n SELECT\n _val_1 AS \"orders.ordered_at\",\n _val_0 AS \"orders.region\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_2 END) AS DOUBLE PRECISION) AS \"orders.l\"\n FROM (\n SELECT\n orders.region AS _val_0,\n DATE_TRUNC('MONTH', orders.ordered_at) AS _val_1,\n orders.amount AS _val_2,\n ROW_NUMBER() OVER (\n PARTITION BY orders.region, DATE_TRUNC('MONTH', orders.ordered_at)\n ORDER BY orders.ordered_at DESC\n ) AS _ranked_rn\n FROM orders AS orders\n ) AS _ranked_src\n GROUP BY\n _val_1,\n _val_0\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_last_partition_by_ordered_at_region.\"orders.l\"\nFROM _base\nLEFT JOIN _cm_orders__amount_last_partition_by_ordered_at_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_last_partition_by_ordered_at_region.\"orders.region\"\n AND _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_last_partition_by_ordered_at_region.\"orders.ordered_at\"", "lift/temporal_partition_last::sqlite": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__amount_last_partition_by_ordered_at_region AS (\n SELECT\n _val_1 AS \"orders.ordered_at\",\n _val_0 AS \"orders.region\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_2 END) AS REAL) AS \"orders.l\"\n FROM (\n SELECT\n orders.region AS _val_0,\n STRFTIME('%Y-%m-01', orders.ordered_at) AS _val_1,\n orders.amount AS _val_2,\n ROW_NUMBER() OVER (\n PARTITION BY orders.region, STRFTIME('%Y-%m-01', orders.ordered_at)\n ORDER BY orders.ordered_at DESC\n ) AS _ranked_rn\n FROM orders AS orders\n ) AS _ranked_src\n GROUP BY\n _val_1,\n _val_0\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_last_partition_by_ordered_at_region.\"orders.l\"\nFROM _base\nLEFT JOIN _cm_orders__amount_last_partition_by_ordered_at_region\n ON _base.\"orders.region\" IS _cm_orders__amount_last_partition_by_ordered_at_region.\"orders.region\"\n AND _base.\"orders.ordered_at\" IS _cm_orders__amount_last_partition_by_ordered_at_region.\"orders.ordered_at\"", "lift/temporal_partition_last::tsql": "WITH _base AS (\n SELECT\n orders.region AS [orders___region],\n orders.city AS [orders___city],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at]\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n DATETRUNC(month, orders.ordered_at)\n), _cm_orders__amount_last_partition_by_ordered_at_region AS (\n SELECT\n _val_1 AS [orders___ordered_at],\n _val_0 AS [orders___region],\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_2 END) AS FLOAT) AS [orders___l]\n FROM (\n SELECT\n orders.region AS _val_0,\n DATETRUNC(month, orders.ordered_at) AS _val_1,\n orders.amount AS _val_2,\n ROW_NUMBER() OVER (\n PARTITION BY orders.region, DATETRUNC(month, orders.ordered_at)\n ORDER BY orders.ordered_at DESC\n ) AS _ranked_rn\n FROM orders AS orders\n ) AS _ranked_src\n GROUP BY\n _val_1,\n _val_0\n)\nSELECT\n _base.[orders___region],\n _base.[orders___city],\n _base.[orders___ordered_at],\n _cm_orders__amount_last_partition_by_ordered_at_region.[orders___l]\nFROM _base\nLEFT JOIN _cm_orders__amount_last_partition_by_ordered_at_region\n ON (\n (\n _base.[orders___region] = _cm_orders__amount_last_partition_by_ordered_at_region.[orders___region]\n AND NOT _base.[orders___region] IS NULL\n AND NOT _cm_orders__amount_last_partition_by_ordered_at_region.[orders___region] IS NULL\n )\n OR (\n _base.[orders___region] IS NULL\n AND _cm_orders__amount_last_partition_by_ordered_at_region.[orders___region] IS NULL\n )\n )\n AND (\n (\n _base.[orders___ordered_at] = _cm_orders__amount_last_partition_by_ordered_at_region.[orders___ordered_at]\n AND NOT _base.[orders___ordered_at] IS NULL\n AND NOT _cm_orders__amount_last_partition_by_ordered_at_region.[orders___ordered_at] IS NULL\n )\n OR (\n _base.[orders___ordered_at] IS NULL\n AND _cm_orders__amount_last_partition_by_ordered_at_region.[orders___ordered_at] IS NULL\n )\n )", - "lift/three_level_nesting::bigquery": "WITH base_2 AS (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at_month`,\n SUM(orders.amount) AS `orders___amount_sum_partition_by_ordered_at_region`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), step1 AS (\n SELECT\n `orders___region`,\n `orders___ordered_at_month`,\n `orders___amount_sum_partition_by_ordered_at_region`,\n SUM(`orders___amount_sum_partition_by_ordered_at_region`) OVER (PARTITION BY `orders___region` ORDER BY `orders___ordered_at_month`) AS `orders___cumsum`\n FROM base_2\n), _cm_cumsum AS (\n SELECT\n _stage_inner.`orders___region` AS `region`,\n _stage_inner.`orders___ordered_at_month` AS `ordered_at_month`,\n _stage_inner.`orders___cumsum` AS `cumsum`\n FROM (\n SELECT\n `orders___region`,\n `orders___ordered_at_month`,\n `orders___cumsum`\n FROM (\n SELECT\n `orders___region`,\n `orders___ordered_at_month`,\n `orders___amount_sum_partition_by_ordered_at_region`,\n `orders___cumsum`\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS `orders___region`,\n CASE WHEN _cm_cumsum.`cumsum` > 50 THEN 1 ELSE 0 END AS `orders___cband`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___s`\n FROM orders AS orders\n LEFT JOIN _cm_cumsum\n ON orders.region IS NOT DISTINCT FROM _cm_cumsum.`region`\n AND DATE_TRUNC(orders.ordered_at, MONTH) IS NOT DISTINCT FROM _cm_cumsum.`ordered_at_month`\n GROUP BY\n orders.region,\n CASE WHEN _cm_cumsum.`cumsum` > 50 THEN 1 ELSE 0 END,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___ordered_at`\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___l`\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)\nSELECT\n _base.`orders___region`,\n _base.`orders___cband`,\n _base.`orders___ordered_at`,\n _base.`orders___s`,\n _cm_orders__amount_sum_window_90d_partition_by_region.`orders___w`,\n _cm_orders__amount_last_partition_by_region.`orders___l`\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d_partition_by_region\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.`orders___region`\n AND _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.`orders___ordered_at`\nLEFT JOIN _cm_orders__amount_last_partition_by_region\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_last_partition_by_region.`orders___region`", + "lift/three_level_nesting::bigquery": "WITH base_2 AS (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at_month`,\n SUM(orders.amount) AS `orders___amount_sum_partition_by_ordered_at_region`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), step1 AS (\n SELECT\n `orders___region`,\n `orders___ordered_at_month`,\n `orders___amount_sum_partition_by_ordered_at_region`,\n SUM(`orders___amount_sum_partition_by_ordered_at_region`) OVER (PARTITION BY `orders___region` ORDER BY `orders___ordered_at_month`) AS `orders___cumsum`\n FROM base_2\n), _cm_cumsum AS (\n SELECT\n _stage_inner.`orders___region` AS `region`,\n _stage_inner.`orders___ordered_at_month` AS `ordered_at_month`,\n _stage_inner.`orders___cumsum` AS `cumsum`\n FROM (\n SELECT\n `orders___region`,\n `orders___ordered_at_month`,\n `orders___cumsum`\n FROM (\n SELECT\n `orders___region`,\n `orders___ordered_at_month`,\n `orders___amount_sum_partition_by_ordered_at_region`,\n `orders___cumsum`\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS `orders___region`,\n CASE WHEN _cm_cumsum.`cumsum` > 50 THEN 1 ELSE 0 END AS `orders___cband`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___s`\n FROM orders AS orders\n LEFT JOIN _cm_cumsum\n ON orders.region IS NOT DISTINCT FROM _cm_cumsum.`region`\n AND DATE_TRUNC(orders.ordered_at, MONTH) IS NOT DISTINCT FROM _cm_cumsum.`ordered_at_month`\n GROUP BY\n orders.region,\n CASE WHEN _cm_cumsum.`cumsum` > 50 THEN 1 ELSE 0 END,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___ordered_at`\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___l`\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)\nSELECT\n _base.`orders___region`,\n _base.`orders___cband`,\n _base.`orders___ordered_at`,\n _base.`orders___s`,\n _cm_orders__amount_sum_window_90d_partition_by_region.`orders___w`,\n _cm_orders__amount_last_partition_by_region.`orders___l`\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d_partition_by_region\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.`orders___region`\n AND _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.`orders___ordered_at`\nLEFT JOIN _cm_orders__amount_last_partition_by_region\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_last_partition_by_region.`orders___region`", "lift/three_level_nesting::duckdb": "WITH base_2 AS (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at_month\",\n SUM(orders.amount) AS \"orders.amount_sum_partition_by_ordered_at_region\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.ordered_at_month\",\n \"orders.amount_sum_partition_by_ordered_at_region\",\n SUM(\"orders.amount_sum_partition_by_ordered_at_region\") OVER (PARTITION BY \"orders.region\" ORDER BY \"orders.ordered_at_month\") AS \"orders.cumsum\"\n FROM base_2\n), _cm_cumsum AS (\n SELECT\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.ordered_at_month\" AS \"ordered_at_month\",\n _stage_inner.\"orders.cumsum\" AS \"cumsum\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.ordered_at_month\",\n \"orders.cumsum\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.ordered_at_month\",\n \"orders.amount_sum_partition_by_ordered_at_region\",\n \"orders.cumsum\"\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE WHEN _cm_cumsum.\"cumsum\" > 50 THEN 1 ELSE 0 END AS \"orders.cband\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.s\"\n FROM orders AS orders\n LEFT JOIN _cm_cumsum\n ON orders.region IS NOT DISTINCT FROM _cm_cumsum.\"region\"\n AND DATE_TRUNC('MONTH', orders.ordered_at) IS NOT DISTINCT FROM _cm_cumsum.\"ordered_at_month\"\n GROUP BY\n orders.region,\n CASE WHEN _cm_cumsum.\"cumsum\" > 50 THEN 1 ELSE 0 END,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_time >= _base.\"orders.ordered_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.ordered_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at\"\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.l\"\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)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.cband\",\n _base.\"orders.ordered_at\",\n _base.\"orders.s\",\n _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.w\",\n _cm_orders__amount_last_partition_by_region.\"orders.l\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d_partition_by_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.region\"\n AND _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.ordered_at\"\nLEFT JOIN _cm_orders__amount_last_partition_by_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_last_partition_by_region.\"orders.region\"", "lift/three_level_nesting::postgres": "WITH base_2 AS (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at_month\",\n SUM(orders.amount) AS \"orders.amount_sum_partition_by_ordered_at_region\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.ordered_at_month\",\n \"orders.amount_sum_partition_by_ordered_at_region\",\n SUM(\"orders.amount_sum_partition_by_ordered_at_region\") OVER (PARTITION BY \"orders.region\" ORDER BY \"orders.ordered_at_month\") AS \"orders.cumsum\"\n FROM base_2\n), _cm_cumsum AS (\n SELECT\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.ordered_at_month\" AS \"ordered_at_month\",\n _stage_inner.\"orders.cumsum\" AS \"cumsum\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.ordered_at_month\",\n \"orders.cumsum\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.ordered_at_month\",\n \"orders.amount_sum_partition_by_ordered_at_region\",\n \"orders.cumsum\"\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE WHEN _cm_cumsum.\"cumsum\" > 50 THEN 1 ELSE 0 END AS \"orders.cband\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.s\"\n FROM orders AS orders\n LEFT JOIN _cm_cumsum\n ON orders.region IS NOT DISTINCT FROM _cm_cumsum.\"region\"\n AND DATE_TRUNC('MONTH', orders.ordered_at) IS NOT DISTINCT FROM _cm_cumsum.\"ordered_at_month\"\n GROUP BY\n orders.region,\n CASE WHEN _cm_cumsum.\"cumsum\" > 50 THEN 1 ELSE 0 END,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_time >= _base.\"orders.ordered_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.ordered_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at\"\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.l\"\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)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.cband\",\n _base.\"orders.ordered_at\",\n _base.\"orders.s\",\n _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.w\",\n _cm_orders__amount_last_partition_by_region.\"orders.l\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d_partition_by_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.region\"\n AND _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.ordered_at\"\nLEFT JOIN _cm_orders__amount_last_partition_by_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_last_partition_by_region.\"orders.region\"", "lift/three_level_nesting::sqlite": "WITH base_2 AS (\n SELECT\n orders.region AS \"orders.region\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at_month\",\n SUM(orders.amount) AS \"orders.amount_sum_partition_by_ordered_at_region\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.ordered_at_month\",\n \"orders.amount_sum_partition_by_ordered_at_region\",\n SUM(\"orders.amount_sum_partition_by_ordered_at_region\") OVER (PARTITION BY \"orders.region\" ORDER BY \"orders.ordered_at_month\") AS \"orders.cumsum\"\n FROM base_2\n), _cm_cumsum AS (\n SELECT\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.ordered_at_month\" AS \"ordered_at_month\",\n _stage_inner.\"orders.cumsum\" AS \"cumsum\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.ordered_at_month\",\n \"orders.cumsum\"\n FROM (\n SELECT\n \"orders.region\",\n \"orders.ordered_at_month\",\n \"orders.amount_sum_partition_by_ordered_at_region\",\n \"orders.cumsum\"\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE WHEN _cm_cumsum.\"cumsum\" > 50 THEN 1 ELSE 0 END AS \"orders.cband\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.s\"\n FROM orders AS orders\n LEFT JOIN _cm_cumsum\n ON orders.region IS _cm_cumsum.\"region\"\n AND STRFTIME('%Y-%m-01', orders.ordered_at) IS _cm_cumsum.\"ordered_at_month\"\n GROUP BY\n orders.region,\n CASE WHEN _cm_cumsum.\"cumsum\" > 50 THEN 1 ELSE 0 END,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS _base.\"orders.region\"\n AND DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.ordered_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.ordered_at\", 1, 'month')\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at\"\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 REAL) AS \"orders.l\"\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)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.cband\",\n _base.\"orders.ordered_at\",\n _base.\"orders.s\",\n _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.w\",\n _cm_orders__amount_last_partition_by_region.\"orders.l\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d_partition_by_region\n ON _base.\"orders.region\" IS _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.region\"\n AND _base.\"orders.ordered_at\" IS _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.ordered_at\"\nLEFT JOIN _cm_orders__amount_last_partition_by_region\n ON _base.\"orders.region\" IS _cm_orders__amount_last_partition_by_region.\"orders.region\"", @@ -159,7 +159,7 @@ "lift/two_ranked_producers::postgres": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city\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.a\"\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_last_partition_by_city AS (\n SELECT\n _val_2 AS \"orders.city\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_3 END) AS DOUBLE PRECISION) AS \"orders.b\"\n FROM (\n SELECT\n orders.city AS _val_2,\n orders.amount AS _val_3,\n ROW_NUMBER() OVER (PARTITION BY orders.city ORDER BY orders.ordered_at DESC) AS _ranked_rn\n FROM orders AS orders\n ) AS _ranked_src\n GROUP BY\n _val_2\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _cm_orders__amount_last_partition_by_region.\"orders.a\",\n _cm_orders__amount_last_partition_by_city.\"orders.b\"\nFROM _base\nLEFT JOIN _cm_orders__amount_last_partition_by_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_last_partition_by_region.\"orders.region\"\nLEFT JOIN _cm_orders__amount_last_partition_by_city\n ON _base.\"orders.city\" IS NOT DISTINCT FROM _cm_orders__amount_last_partition_by_city.\"orders.city\"", "lift/two_ranked_producers::sqlite": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city\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 REAL) AS \"orders.a\"\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_last_partition_by_city AS (\n SELECT\n _val_2 AS \"orders.city\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_3 END) AS REAL) AS \"orders.b\"\n FROM (\n SELECT\n orders.city AS _val_2,\n orders.amount AS _val_3,\n ROW_NUMBER() OVER (PARTITION BY orders.city ORDER BY orders.ordered_at DESC) AS _ranked_rn\n FROM orders AS orders\n ) AS _ranked_src\n GROUP BY\n _val_2\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _cm_orders__amount_last_partition_by_region.\"orders.a\",\n _cm_orders__amount_last_partition_by_city.\"orders.b\"\nFROM _base\nLEFT JOIN _cm_orders__amount_last_partition_by_region\n ON _base.\"orders.region\" IS _cm_orders__amount_last_partition_by_region.\"orders.region\"\nLEFT JOIN _cm_orders__amount_last_partition_by_city\n ON _base.\"orders.city\" IS _cm_orders__amount_last_partition_by_city.\"orders.city\"", "lift/two_ranked_producers::tsql": "WITH _base AS (\n SELECT\n orders.region AS [orders___region],\n orders.city AS [orders___city]\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city\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 FLOAT) AS [orders___a]\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_last_partition_by_city AS (\n SELECT\n _val_2 AS [orders___city],\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_3 END) AS FLOAT) AS [orders___b]\n FROM (\n SELECT\n orders.city AS _val_2,\n orders.amount AS _val_3,\n ROW_NUMBER() OVER (PARTITION BY orders.city ORDER BY orders.ordered_at DESC) AS _ranked_rn\n FROM orders AS orders\n ) AS _ranked_src\n GROUP BY\n _val_2\n)\nSELECT\n _base.[orders___region],\n _base.[orders___city],\n _cm_orders__amount_last_partition_by_region.[orders___a],\n _cm_orders__amount_last_partition_by_city.[orders___b]\nFROM _base\nLEFT JOIN _cm_orders__amount_last_partition_by_region\n ON (\n (\n _base.[orders___region] = _cm_orders__amount_last_partition_by_region.[orders___region]\n AND NOT _base.[orders___region] IS NULL\n AND NOT _cm_orders__amount_last_partition_by_region.[orders___region] IS NULL\n )\n OR (\n _base.[orders___region] IS NULL\n AND _cm_orders__amount_last_partition_by_region.[orders___region] IS NULL\n )\n )\nLEFT JOIN _cm_orders__amount_last_partition_by_city\n ON (\n (\n _base.[orders___city] = _cm_orders__amount_last_partition_by_city.[orders___city]\n AND NOT _base.[orders___city] IS NULL\n AND NOT _cm_orders__amount_last_partition_by_city.[orders___city] IS NULL\n )\n OR (\n _base.[orders___city] IS NULL\n AND _cm_orders__amount_last_partition_by_city.[orders___city] IS NULL\n )\n )", - "lift/window_partition::bigquery": "WITH _base AS (\n SELECT\n orders.region AS `orders___region`,\n orders.city AS `orders___city`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___ordered_at`\n)\nSELECT\n _base.`orders___region`,\n _base.`orders___city`,\n _base.`orders___ordered_at`,\n _cm_orders__amount_sum_window_90d_partition_by_region.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d_partition_by_region\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.`orders___region`\n AND _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.`orders___ordered_at`", + "lift/window_partition::bigquery": "WITH _base AS (\n SELECT\n orders.region AS `orders___region`,\n orders.city AS `orders___city`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___ordered_at`\n)\nSELECT\n _base.`orders___region`,\n _base.`orders___city`,\n _base.`orders___ordered_at`,\n _cm_orders__amount_sum_window_90d_partition_by_region.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d_partition_by_region\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.`orders___region`\n AND _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.`orders___ordered_at`", "lift/window_partition::duckdb": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_time >= _base.\"orders.ordered_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.ordered_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at\"\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d_partition_by_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.region\"\n AND _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.ordered_at\"", "lift/window_partition::postgres": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_time >= _base.\"orders.ordered_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.ordered_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at\"\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d_partition_by_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.region\"\n AND _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.ordered_at\"", "lift/window_partition::sqlite": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n orders.city AS \"orders.city\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n orders.city,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS _base.\"orders.region\"\n AND DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.ordered_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.ordered_at\", 1, 'month')\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at\"\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.city\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d_partition_by_region\n ON _base.\"orders.region\" IS _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.region\"\n AND _base.\"orders.ordered_at\" IS _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.ordered_at\"", diff --git a/tests/golden/dev1832_sql_baseline.json b/tests/golden/dev1832_sql_baseline.json index 7c52cdd34..b5c524e14 100644 --- a/tests/golden/dev1832_sql_baseline.json +++ b/tests/golden/dev1832_sql_baseline.json @@ -69,7 +69,7 @@ "lifted/two_branch::snowflake": "WITH _base AS (\n SELECT\n orders.status AS \"orders.status\"\n FROM orders AS orders\n GROUP BY\n orders.status\n), _cm_orders__customers_spend_stores_rent_sum AS (\n SELECT\n orders.status AS \"orders.status\",\n SUM(customers.spend - stores.rent) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN stores AS stores\n ON orders.store_co = stores.co AND orders.store_no = stores.no\n GROUP BY\n orders.status\n)\nSELECT\n _base.\"orders.status\",\n _cm_orders__customers_spend_stores_rent_sum.\"orders.m\"\nFROM _base\nLEFT JOIN _cm_orders__customers_spend_stores_rent_sum\n ON _base.\"orders.status\" IS NOT DISTINCT FROM _cm_orders__customers_spend_stores_rent_sum.\"orders.status\"", "lifted/two_branch::sqlite": "WITH _base AS (\n SELECT\n orders.status AS \"orders.status\"\n FROM orders AS orders\n GROUP BY\n orders.status\n), _cm_orders__customers_spend_stores_rent_sum AS (\n SELECT\n orders.status AS \"orders.status\",\n SUM(customers.spend - stores.rent) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN stores AS stores\n ON orders.store_co = stores.co AND orders.store_no = stores.no\n GROUP BY\n orders.status\n)\nSELECT\n _base.\"orders.status\",\n _cm_orders__customers_spend_stores_rent_sum.\"orders.m\"\nFROM _base\nLEFT JOIN _cm_orders__customers_spend_stores_rent_sum\n ON _base.\"orders.status\" IS _cm_orders__customers_spend_stores_rent_sum.\"orders.status\"", "lifted/two_branch::tsql": "WITH _base AS (\n SELECT\n orders.status AS [orders___status]\n FROM orders AS orders\n GROUP BY\n orders.status\n), _cm_orders__customers_spend_stores_rent_sum AS (\n SELECT\n orders.status AS [orders___status],\n SUM(customers.spend - stores.rent) AS [orders___m]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n LEFT JOIN stores AS stores\n ON orders.store_co = stores.co AND orders.store_no = stores.no\n GROUP BY\n orders.status\n)\nSELECT\n _base.[orders___status],\n _cm_orders__customers_spend_stores_rent_sum.[orders___m]\nFROM _base\nLEFT JOIN _cm_orders__customers_spend_stores_rent_sum\n ON (\n (\n _base.[orders___status] = _cm_orders__customers_spend_stores_rent_sum.[orders___status]\n AND NOT _base.[orders___status] IS NULL\n AND NOT _cm_orders__customers_spend_stores_rent_sum.[orders___status] IS NULL\n )\n OR (\n _base.[orders___status] IS NULL\n AND _cm_orders__customers_spend_stores_rent_sum.[orders___status] IS NULL\n )\n )", - "lifted/windowed_inner::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_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at_month`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at_month`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `monthly___amount_sum_window_90d_partition_by_region`\n FROM (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at_month`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`monthly___region`\n AND _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`monthly___ordered_at_month` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`monthly___ordered_at_month` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`monthly___region`,\n _base.`monthly___ordered_at_month`\n), base_2 AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at_month`,\n _cm_monthly__amount_sum_window_90d_partition_by_region.`monthly___amount_sum_window_90d_partition_by_region` AS `monthly___amount_sum_window_90d_partition_by_region`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_window_90d_partition_by_region\n ON _base_2.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d_partition_by_region.`monthly___region`\n AND _base_2.`monthly___ordered_at_month` IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d_partition_by_region.`monthly___ordered_at_month`\n), step1 AS (\n SELECT\n `monthly___region`,\n `monthly___ordered_at_month`,\n `monthly___amount_sum_window_90d_partition_by_region`,\n CASE\n WHEN `monthly___amount_sum_window_90d_partition_by_region` IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN `monthly___amount_sum_window_90d_partition_by_region` IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY `monthly___amount_sum_window_90d_partition_by_region` DESC\n )\n END AS `monthly___rank`\n FROM base_2\n), _cm_rank 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___rank` AS `rank`\n FROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at_month`,\n `monthly___rank`\n FROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at_month`,\n `monthly___amount_sum_window_90d_partition_by_region`,\n `monthly___rank`\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n), _cm_monthly___sum AS (\n SELECT\n _base.`monthly___ordered_at_month` AS `monthly___ordered_at_month`,\n SUM(_base._v) AS `monthly___m`\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_rank.`rank`) AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_rank\n ON monthly.region IS NOT DISTINCT FROM _cm_rank.`region`\n AND DATE_TRUNC(monthly.ordered_at, MONTH) IS NOT DISTINCT FROM _cm_rank.`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___sum.`monthly___m`\nFROM _base\nLEFT JOIN _cm_monthly___sum\n ON _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly___sum.`monthly___ordered_at_month`", + "lifted/windowed_inner::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_2 AS (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at_month`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at_month`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `monthly___amount_sum_window_90d_partition_by_region`\n FROM (\n SELECT\n monthly.region AS `monthly___region`,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS `monthly___ordered_at_month`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`monthly___region`\n AND _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`monthly___ordered_at_month` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`monthly___ordered_at_month` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`monthly___region`,\n _base.`monthly___ordered_at_month`\n), base_2 AS (\n SELECT\n _base_2.`monthly___region`,\n _base_2.`monthly___ordered_at_month`,\n _cm_monthly__amount_sum_window_90d_partition_by_region.`monthly___amount_sum_window_90d_partition_by_region` AS `monthly___amount_sum_window_90d_partition_by_region`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_window_90d_partition_by_region\n ON _base_2.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d_partition_by_region.`monthly___region`\n AND _base_2.`monthly___ordered_at_month` IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d_partition_by_region.`monthly___ordered_at_month`\n), step1 AS (\n SELECT\n `monthly___region`,\n `monthly___ordered_at_month`,\n `monthly___amount_sum_window_90d_partition_by_region`,\n CASE\n WHEN `monthly___amount_sum_window_90d_partition_by_region` IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN `monthly___amount_sum_window_90d_partition_by_region` IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY `monthly___amount_sum_window_90d_partition_by_region` DESC\n )\n END AS `monthly___rank`\n FROM base_2\n), _cm_rank 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___rank` AS `rank`\n FROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at_month`,\n `monthly___rank`\n FROM (\n SELECT\n `monthly___region`,\n `monthly___ordered_at_month`,\n `monthly___amount_sum_window_90d_partition_by_region`,\n `monthly___rank`\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n), _cm_monthly___sum AS (\n SELECT\n _base.`monthly___ordered_at_month` AS `monthly___ordered_at_month`,\n SUM(_base._v) AS `monthly___m`\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_rank.`rank`) AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_rank\n ON monthly.region IS NOT DISTINCT FROM _cm_rank.`region`\n AND DATE_TRUNC(monthly.ordered_at, MONTH) IS NOT DISTINCT FROM _cm_rank.`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___sum.`monthly___m`\nFROM _base\nLEFT JOIN _cm_monthly___sum\n ON _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly___sum.`monthly___ordered_at_month`", "lifted/windowed_inner::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_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at_month\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"monthly.amount_sum_window_90d_partition_by_region\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"monthly.region\"\n AND _src._w_time >= _base.\"monthly.ordered_at_month\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"monthly.ordered_at_month\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at_month\"\n), base_2 AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at_month\",\n _cm_monthly__amount_sum_window_90d_partition_by_region.\"monthly.amount_sum_window_90d_partition_by_region\" AS \"monthly.amount_sum_window_90d_partition_by_region\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_window_90d_partition_by_region\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d_partition_by_region.\"monthly.region\"\n AND _base_2.\"monthly.ordered_at_month\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d_partition_by_region.\"monthly.ordered_at_month\"\n), step1 AS (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.amount_sum_window_90d_partition_by_region\",\n CASE\n WHEN \"monthly.amount_sum_window_90d_partition_by_region\" IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN \"monthly.amount_sum_window_90d_partition_by_region\" IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY \"monthly.amount_sum_window_90d_partition_by_region\" DESC\n )\n END AS \"monthly.rank\"\n FROM base_2\n), _cm_rank 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.rank\" AS \"rank\"\n FROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.rank\"\n FROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.amount_sum_window_90d_partition_by_region\",\n \"monthly.rank\"\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n), _cm_monthly___sum AS (\n SELECT\n _base.\"monthly.ordered_at_month\" AS \"monthly.ordered_at_month\",\n SUM(_base._v) AS \"monthly.m\"\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_rank.\"rank\") AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_rank\n ON monthly.region IS NOT DISTINCT FROM _cm_rank.\"region\"\n AND DATE_TRUNC('MONTH', monthly.ordered_at) IS NOT DISTINCT FROM _cm_rank.\"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___sum.\"monthly.m\"\nFROM _base\nLEFT JOIN _cm_monthly___sum\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly___sum.\"monthly.ordered_at_month\"", "lifted/windowed_inner::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(monthly.ordered_at), ' ', MONTH(monthly.ordered_at), ' 1'), '%Y %c %e') AS `monthly.ordered_at`\n FROM monthly AS monthly\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(monthly.ordered_at), ' ', MONTH(monthly.ordered_at), ' 1'), '%Y %c %e')\n), _base_2 AS (\n SELECT\n monthly.region AS `monthly.region`,\n STR_TO_DATE(CONCAT(YEAR(monthly.ordered_at), ' ', MONTH(monthly.ordered_at), ' 1'), '%Y %c %e') AS `monthly.ordered_at_month`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STR_TO_DATE(CONCAT(YEAR(monthly.ordered_at), ' ', MONTH(monthly.ordered_at), ' 1'), '%Y %c %e')\n), _cm_monthly__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.`monthly.region`,\n _base.`monthly.ordered_at_month`,\n CAST(SUM(_src._w_value) AS DOUBLE) AS `monthly.amount_sum_window_90d_partition_by_region`\n FROM (\n SELECT\n monthly.region AS `monthly.region`,\n STR_TO_DATE(CONCAT(YEAR(monthly.ordered_at), ' ', MONTH(monthly.ordered_at), ' 1'), '%Y %c %e') AS `monthly.ordered_at_month`\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n STR_TO_DATE(CONCAT(YEAR(monthly.ordered_at), ' ', MONTH(monthly.ordered_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 <=> _base.`monthly.region`\n AND _src._w_time >= DATE_ADD(DATE_ADD(_base.`monthly.ordered_at_month`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`monthly.ordered_at_month`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`monthly.region`,\n _base.`monthly.ordered_at_month`\n), base_2 AS (\n SELECT\n _base_2.`monthly.region`,\n _base_2.`monthly.ordered_at_month`,\n _cm_monthly__amount_sum_window_90d_partition_by_region.`monthly.amount_sum_window_90d_partition_by_region` AS `monthly.amount_sum_window_90d_partition_by_region`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_window_90d_partition_by_region\n ON _base_2.`monthly.region` <=> _cm_monthly__amount_sum_window_90d_partition_by_region.`monthly.region`\n AND _base_2.`monthly.ordered_at_month` <=> _cm_monthly__amount_sum_window_90d_partition_by_region.`monthly.ordered_at_month`\n), step1 AS (\n SELECT\n `monthly.region`,\n `monthly.ordered_at_month`,\n `monthly.amount_sum_window_90d_partition_by_region`,\n CASE\n WHEN `monthly.amount_sum_window_90d_partition_by_region` IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN `monthly.amount_sum_window_90d_partition_by_region` IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY `monthly.amount_sum_window_90d_partition_by_region` DESC\n )\n END AS `monthly.rank`\n FROM base_2\n), _cm_rank 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.rank` AS `rank`\n FROM (\n SELECT\n `monthly.region`,\n `monthly.ordered_at_month`,\n `monthly.rank`\n FROM (\n SELECT\n `monthly.region`,\n `monthly.ordered_at_month`,\n `monthly.amount_sum_window_90d_partition_by_region`,\n `monthly.rank`\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n), _cm_monthly___sum AS (\n SELECT\n _base.`monthly.ordered_at_month` AS `monthly.ordered_at_month`,\n SUM(_base._v) AS `monthly.m`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(monthly.ordered_at), ' ', MONTH(monthly.ordered_at), ' 1'), '%Y %c %e') AS `monthly.ordered_at_month`,\n monthly.region AS _ek0,\n STR_TO_DATE(CONCAT(YEAR(monthly.ordered_at), ' ', MONTH(monthly.ordered_at), ' 1'), '%Y %c %e') AS _ek1,\n MAX(_cm_rank.`rank`) AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_rank\n ON monthly.region <=> _cm_rank.`region`\n AND STR_TO_DATE(CONCAT(YEAR(monthly.ordered_at), ' ', MONTH(monthly.ordered_at), ' 1'), '%Y %c %e') <=> _cm_rank.`ordered_at_month`\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(monthly.ordered_at), ' ', MONTH(monthly.ordered_at), ' 1'), '%Y %c %e'),\n monthly.region,\n STR_TO_DATE(CONCAT(YEAR(monthly.ordered_at), ' ', MONTH(monthly.ordered_at), ' 1'), '%Y %c %e')\n ) AS _base\n GROUP BY\n _base.`monthly.ordered_at_month`\n)\nSELECT\n _base.`monthly.ordered_at`,\n _cm_monthly___sum.`monthly.m`\nFROM _base\nLEFT JOIN _cm_monthly___sum\n ON _base.`monthly.ordered_at` <=> _cm_monthly___sum.`monthly.ordered_at_month`", "lifted/windowed_inner::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_2 AS (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n), _cm_monthly__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at_month\",\n CAST(SUM(_src._w_value) AS DOUBLE PRECISION) AS \"monthly.amount_sum_window_90d_partition_by_region\"\n FROM (\n SELECT\n monthly.region AS \"monthly.region\",\n DATE_TRUNC('MONTH', monthly.ordered_at) AS \"monthly.ordered_at_month\"\n FROM monthly AS monthly\n GROUP BY\n monthly.region,\n DATE_TRUNC('MONTH', monthly.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"monthly.region\"\n AND _src._w_time >= _base.\"monthly.ordered_at_month\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"monthly.ordered_at_month\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at_month\"\n), base_2 AS (\n SELECT\n _base_2.\"monthly.region\",\n _base_2.\"monthly.ordered_at_month\",\n _cm_monthly__amount_sum_window_90d_partition_by_region.\"monthly.amount_sum_window_90d_partition_by_region\" AS \"monthly.amount_sum_window_90d_partition_by_region\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_window_90d_partition_by_region\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d_partition_by_region.\"monthly.region\"\n AND _base_2.\"monthly.ordered_at_month\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d_partition_by_region.\"monthly.ordered_at_month\"\n), step1 AS (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.amount_sum_window_90d_partition_by_region\",\n CASE\n WHEN \"monthly.amount_sum_window_90d_partition_by_region\" IS NULL\n THEN NULL\n ELSE RANK() OVER (\n PARTITION BY CASE\n WHEN \"monthly.amount_sum_window_90d_partition_by_region\" IS NULL\n THEN 1\n ELSE 0\n END\n ORDER BY \"monthly.amount_sum_window_90d_partition_by_region\" DESC\n )\n END AS \"monthly.rank\"\n FROM base_2\n), _cm_rank 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.rank\" AS \"rank\"\n FROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.rank\"\n FROM (\n SELECT\n \"monthly.region\",\n \"monthly.ordered_at_month\",\n \"monthly.amount_sum_window_90d_partition_by_region\",\n \"monthly.rank\"\n FROM step1\n ) AS _outer\n ) AS _stage_inner\n), _cm_monthly___sum AS (\n SELECT\n _base.\"monthly.ordered_at_month\" AS \"monthly.ordered_at_month\",\n SUM(_base._v) AS \"monthly.m\"\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_rank.\"rank\") AS _v\n FROM monthly AS monthly\n LEFT JOIN _cm_rank\n ON monthly.region IS NOT DISTINCT FROM _cm_rank.\"region\"\n AND DATE_TRUNC('MONTH', monthly.ordered_at) IS NOT DISTINCT FROM _cm_rank.\"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___sum.\"monthly.m\"\nFROM _base\nLEFT JOIN _cm_monthly___sum\n ON _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly___sum.\"monthly.ordered_at_month\"", diff --git a/tests/golden/dev1835_sql_baseline.json b/tests/golden/dev1835_sql_baseline.json index 2a38eb51d..cb897de14 100644 --- a/tests/golden/dev1835_sql_baseline.json +++ b/tests/golden/dev1835_sql_baseline.json @@ -4,12 +4,12 @@ "dedup/dual_role::postgres": "WITH _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.rt\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), _base AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_orders__amount_sum_partition_by_region.\"orders.rt\" > 55\n THEN 1\n ELSE 0\n END AS \"orders.rband\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON orders.region IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_region.\"orders.region\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_orders__amount_sum_partition_by_region.\"orders.rt\" > 55\n THEN 1\n ELSE 0\n END\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.rband\",\n _base.\"orders.m\",\n _cm_orders__amount_sum_partition_by_region.\"orders.rt\"\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\"", "dedup/dual_role::sqlite": "WITH _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.rt\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), _base AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_orders__amount_sum_partition_by_region.\"orders.rt\" > 55\n THEN 1\n ELSE 0\n END AS \"orders.rband\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON orders.region IS _cm_orders__amount_sum_partition_by_region.\"orders.region\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_orders__amount_sum_partition_by_region.\"orders.rt\" > 55\n THEN 1\n ELSE 0\n END\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.rband\",\n _base.\"orders.m\",\n _cm_orders__amount_sum_partition_by_region.\"orders.rt\"\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\"", "dedup/dual_role::tsql": "WITH _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___rt]\n FROM orders AS orders\n GROUP BY\n orders.region\n), _base AS (\n SELECT\n orders.region AS [orders___region],\n CASE\n WHEN _cm_orders__amount_sum_partition_by_region.[orders___rt] > 55\n THEN 1\n ELSE 0\n END AS [orders___rband],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___m]\n FROM orders AS orders\n LEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON (\n (\n orders.region = _cm_orders__amount_sum_partition_by_region.[orders___region]\n AND NOT orders.region IS NULL\n AND NOT _cm_orders__amount_sum_partition_by_region.[orders___region] IS NULL\n )\n OR (\n orders.region IS NULL\n AND _cm_orders__amount_sum_partition_by_region.[orders___region] IS NULL\n )\n )\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_orders__amount_sum_partition_by_region.[orders___rt] > 55\n THEN 1\n ELSE 0\n END\n)\nSELECT\n _base.[orders___region],\n _base.[orders___rband],\n _base.[orders___m],\n _cm_orders__amount_sum_partition_by_region.[orders___rt]\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON (\n (\n _base.[orders___region] = _cm_orders__amount_sum_partition_by_region.[orders___region]\n AND NOT _base.[orders___region] IS NULL\n AND NOT _cm_orders__amount_sum_partition_by_region.[orders___region] IS NULL\n )\n OR (\n _base.[orders___region] IS NULL\n AND _cm_orders__amount_sum_partition_by_region.[orders___region] IS NULL\n )\n )", - "lift/band_x_wm::bigquery": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.`orders___city` AS `city`,\n _stage_inner.`orders___amount_sum_partition_by_city` AS `amount_sum_partition_by_city`\n FROM (\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 ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS `orders___region`,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END AS `orders___band`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___m`\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.`city`\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_sum_window_1y AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___band`,\n _base.`orders___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END AS `orders___band`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.`city`\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC(orders.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END AS _w_dim_1,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.`city`\n ) AS _src\n ON (\n _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_dim_1 IS NOT DISTINCT FROM _base.`orders___band`\n )\n AND _src._w_time >= CAST(DATETIME_ADD(\n CAST(CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP) AS DATETIME),\n INTERVAL -1 YEAR\n ) AS TIMESTAMP)\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___band`,\n _base.`orders___ordered_at`\n)\nSELECT\n _base.`orders___region`,\n _base.`orders___band`,\n _base.`orders___ordered_at`,\n _base.`orders___m`,\n _cm_orders__amount_sum_window_1y.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_1y\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.`orders___region`\n AND _base.`orders___band` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.`orders___band`\n AND _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.`orders___ordered_at`", + "lift/band_x_wm::bigquery": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.`orders___city` AS `city`,\n _stage_inner.`orders___amount_sum_partition_by_city` AS `amount_sum_partition_by_city`\n FROM (\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 ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS `orders___region`,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END AS `orders___band`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___m`\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.`city`\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_sum_window_1y AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___band`,\n _base.`orders___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END AS `orders___band`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.`city`\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC(orders.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END AS _w_dim_1,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.`city`\n ) AS _src\n ON (\n _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_dim_1 IS NOT DISTINCT FROM _base.`orders___band`\n )\n AND _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -1 YEAR\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___band`,\n _base.`orders___ordered_at`\n)\nSELECT\n _base.`orders___region`,\n _base.`orders___band`,\n _base.`orders___ordered_at`,\n _base.`orders___m`,\n _cm_orders__amount_sum_window_1y.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_1y\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.`orders___region`\n AND _base.`orders___band` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.`orders___band`\n AND _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.`orders___ordered_at`", "lift/band_x_wm::duckdb": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.amount_sum_partition_by_city\" AS \"amount_sum_partition_by_city\"\n FROM (\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 ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_window_1y AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.band\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC('MONTH', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS _w_dim_1,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\n ) AS _src\n ON (\n _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_dim_1 IS NOT DISTINCT FROM _base.\"orders.band\"\n )\n AND _src._w_time >= _base.\"orders.ordered_at\" + INTERVAL 1 MONTH - INTERVAL 1 YEAR\n AND _src._w_time < _base.\"orders.ordered_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.band\",\n _base.\"orders.ordered_at\"\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.band\",\n _base.\"orders.ordered_at\",\n _base.\"orders.m\",\n _cm_orders__amount_sum_window_1y.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_1y\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.\"orders.region\"\n AND _base.\"orders.band\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.\"orders.band\"\n AND _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.\"orders.ordered_at\"", "lift/band_x_wm::postgres": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.amount_sum_partition_by_city\" AS \"amount_sum_partition_by_city\"\n FROM (\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 ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_window_1y AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.band\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC('MONTH', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS _w_dim_1,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\n ) AS _src\n ON (\n _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_dim_1 IS NOT DISTINCT FROM _base.\"orders.band\"\n )\n AND _src._w_time >= _base.\"orders.ordered_at\" + INTERVAL '1 MONTH' - INTERVAL '1 YEAR'\n AND _src._w_time < _base.\"orders.ordered_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.band\",\n _base.\"orders.ordered_at\"\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.band\",\n _base.\"orders.ordered_at\",\n _base.\"orders.m\",\n _cm_orders__amount_sum_window_1y.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_1y\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.\"orders.region\"\n AND _base.\"orders.band\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.\"orders.band\"\n AND _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_1y.\"orders.ordered_at\"", "lift/band_x_wm::sqlite": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.amount_sum_partition_by_city\" AS \"amount_sum_partition_by_city\"\n FROM (\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 ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__amount_sum_window_1y AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.band\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS _w_dim_1,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS _cm_amount_sum_partition_by_city.\"city\"\n ) AS _src\n ON (\n _src._w_dim_0 IS _base.\"orders.region\" AND _src._w_dim_1 IS _base.\"orders.band\"\n )\n AND DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.ordered_at\", 1, 'month'), -1, 'year')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.ordered_at\", 1, 'month')\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.band\",\n _base.\"orders.ordered_at\"\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.band\",\n _base.\"orders.ordered_at\",\n _base.\"orders.m\",\n _cm_orders__amount_sum_window_1y.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_1y\n ON _base.\"orders.region\" IS _cm_orders__amount_sum_window_1y.\"orders.region\"\n AND _base.\"orders.band\" IS _cm_orders__amount_sum_window_1y.\"orders.band\"\n AND _base.\"orders.ordered_at\" IS _cm_orders__amount_sum_window_1y.\"orders.ordered_at\"", "lift/band_x_wm::tsql": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.[orders___city] AS [city],\n _stage_inner.[orders___amount_sum_partition_by_city] AS [amount_sum_partition_by_city]\n FROM (\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 ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS [orders___region],\n CASE\n WHEN _cm_amount_sum_partition_by_city.[amount_sum_partition_by_city] > 35\n THEN 1\n ELSE 0\n END AS [orders___band],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___m]\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON (\n (\n orders.city = _cm_amount_sum_partition_by_city.[city]\n AND NOT orders.city IS NULL\n AND NOT _cm_amount_sum_partition_by_city.[city] IS NULL\n )\n OR (\n orders.city IS NULL AND _cm_amount_sum_partition_by_city.[city] IS NULL\n )\n )\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.[amount_sum_partition_by_city] > 35\n THEN 1\n ELSE 0\n END,\n DATETRUNC(month, orders.ordered_at)\n), _cm_orders__amount_sum_window_1y AS (\n SELECT\n _base.[orders___region] AS [orders___region],\n _base.[orders___band] AS [orders___band],\n _base.[orders___ordered_at] AS [orders___ordered_at],\n CAST(SUM(_src._w_value) AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n orders.region AS [orders___region],\n CASE\n WHEN _cm_amount_sum_partition_by_city.[amount_sum_partition_by_city] > 35\n THEN 1\n ELSE 0\n END AS [orders___band],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at]\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON (\n (\n orders.city = _cm_amount_sum_partition_by_city.[city]\n AND NOT orders.city IS NULL\n AND NOT _cm_amount_sum_partition_by_city.[city] IS NULL\n )\n OR (\n orders.city IS NULL AND _cm_amount_sum_partition_by_city.[city] IS NULL\n )\n )\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.[amount_sum_partition_by_city] > 35\n THEN 1\n ELSE 0\n END,\n DATETRUNC(month, orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n CASE\n WHEN _cm_amount_sum_partition_by_city.[amount_sum_partition_by_city] > 35\n THEN 1\n ELSE 0\n END AS _w_dim_1,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON (\n (\n orders.city = _cm_amount_sum_partition_by_city.[city]\n AND NOT orders.city IS NULL\n AND NOT _cm_amount_sum_partition_by_city.[city] IS NULL\n )\n OR (\n orders.city IS NULL AND _cm_amount_sum_partition_by_city.[city] IS NULL\n )\n )\n ) AS _src\n ON (\n (\n (\n _src._w_dim_0 = _base.[orders___region]\n AND NOT _src._w_dim_0 IS NULL\n AND NOT _base.[orders___region] IS NULL\n )\n OR (\n _src._w_dim_0 IS NULL AND _base.[orders___region] IS NULL\n )\n )\n AND (\n (\n _src._w_dim_1 = _base.[orders___band]\n AND NOT _src._w_dim_1 IS NULL\n AND NOT _base.[orders___band] IS NULL\n )\n OR (\n _src._w_dim_1 IS NULL AND _base.[orders___band] IS NULL\n )\n )\n )\n AND _src._w_time >= DATEADD(YEAR, -1, DATEADD(MONTH, 1, _base.[orders___ordered_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___ordered_at])\n GROUP BY\n _base.[orders___region],\n _base.[orders___band],\n _base.[orders___ordered_at]\n)\nSELECT\n _base.[orders___region],\n _base.[orders___band],\n _base.[orders___ordered_at],\n _base.[orders___m],\n _cm_orders__amount_sum_window_1y.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_1y\n ON (\n (\n _base.[orders___region] = _cm_orders__amount_sum_window_1y.[orders___region]\n AND NOT _base.[orders___region] IS NULL\n AND NOT _cm_orders__amount_sum_window_1y.[orders___region] IS NULL\n )\n OR (\n _base.[orders___region] IS NULL\n AND _cm_orders__amount_sum_window_1y.[orders___region] IS NULL\n )\n )\n AND (\n (\n _base.[orders___band] = _cm_orders__amount_sum_window_1y.[orders___band]\n AND NOT _base.[orders___band] IS NULL\n AND NOT _cm_orders__amount_sum_window_1y.[orders___band] IS NULL\n )\n OR (\n _base.[orders___band] IS NULL\n AND _cm_orders__amount_sum_window_1y.[orders___band] IS NULL\n )\n )\n AND (\n (\n _base.[orders___ordered_at] = _cm_orders__amount_sum_window_1y.[orders___ordered_at]\n AND NOT _base.[orders___ordered_at] IS NULL\n AND NOT _cm_orders__amount_sum_window_1y.[orders___ordered_at] IS NULL\n )\n OR (\n _base.[orders___ordered_at] IS NULL\n AND _cm_orders__amount_sum_window_1y.[orders___ordered_at] IS NULL\n )\n )", - "lift/cumsum_over_bare_wm::bigquery": "WITH _base AS (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___amount_sum_window_90d`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___ordered_at`\n), base AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___ordered_at`,\n _cm_orders__amount_sum_window_90d.`orders___amount_sum_window_90d` AS `orders___amount_sum_window_90d`\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.`orders___region`\n AND _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.`orders___ordered_at`\n), step1 AS (\n SELECT\n `orders___region`,\n `orders___ordered_at`,\n `orders___amount_sum_window_90d`,\n SUM(`orders___amount_sum_window_90d`) OVER (PARTITION BY `orders___region` ORDER BY `orders___ordered_at`) AS `orders___x`\n FROM base\n)\nSELECT\n `orders___region`,\n `orders___ordered_at`,\n `orders___x`\nFROM (\n SELECT\n `orders___region`,\n `orders___ordered_at`,\n `orders___amount_sum_window_90d`,\n `orders___x`\n FROM step1\n) AS _outer", + "lift/cumsum_over_bare_wm::bigquery": "WITH _base AS (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___amount_sum_window_90d`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___ordered_at`\n), base AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___ordered_at`,\n _cm_orders__amount_sum_window_90d.`orders___amount_sum_window_90d` AS `orders___amount_sum_window_90d`\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.`orders___region`\n AND _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.`orders___ordered_at`\n), step1 AS (\n SELECT\n `orders___region`,\n `orders___ordered_at`,\n `orders___amount_sum_window_90d`,\n SUM(`orders___amount_sum_window_90d`) OVER (PARTITION BY `orders___region` ORDER BY `orders___ordered_at`) AS `orders___x`\n FROM base\n)\nSELECT\n `orders___region`,\n `orders___ordered_at`,\n `orders___x`\nFROM (\n SELECT\n `orders___region`,\n `orders___ordered_at`,\n `orders___amount_sum_window_90d`,\n `orders___x`\n FROM step1\n) AS _outer", "lift/cumsum_over_bare_wm::duckdb": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"orders.amount_sum_window_90d\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_time >= _base.\"orders.ordered_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.ordered_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at\"\n), base AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_sum_window_90d.\"orders.amount_sum_window_90d\" AS \"orders.amount_sum_window_90d\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.\"orders.region\"\n AND _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.ordered_at\",\n \"orders.amount_sum_window_90d\",\n SUM(\"orders.amount_sum_window_90d\") OVER (PARTITION BY \"orders.region\" ORDER BY \"orders.ordered_at\") AS \"orders.x\"\n FROM base\n)\nSELECT\n \"orders.region\",\n \"orders.ordered_at\",\n \"orders.x\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.ordered_at\",\n \"orders.amount_sum_window_90d\",\n \"orders.x\"\n FROM step1\n) AS _outer", "lift/cumsum_over_bare_wm::postgres": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE PRECISION) AS \"orders.amount_sum_window_90d\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_time >= _base.\"orders.ordered_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.ordered_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at\"\n), base AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_sum_window_90d.\"orders.amount_sum_window_90d\" AS \"orders.amount_sum_window_90d\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.\"orders.region\"\n AND _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.ordered_at\",\n \"orders.amount_sum_window_90d\",\n SUM(\"orders.amount_sum_window_90d\") OVER (PARTITION BY \"orders.region\" ORDER BY \"orders.ordered_at\") AS \"orders.x\"\n FROM base\n)\nSELECT\n \"orders.region\",\n \"orders.ordered_at\",\n \"orders.x\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.ordered_at\",\n \"orders.amount_sum_window_90d\",\n \"orders.x\"\n FROM step1\n) AS _outer", "lift/cumsum_over_bare_wm::sqlite": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS REAL) AS \"orders.amount_sum_window_90d\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS _base.\"orders.region\"\n AND DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.ordered_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.ordered_at\", 1, 'month')\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at\"\n), base AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_sum_window_90d.\"orders.amount_sum_window_90d\" AS \"orders.amount_sum_window_90d\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.\"orders.region\" IS _cm_orders__amount_sum_window_90d.\"orders.region\"\n AND _base.\"orders.ordered_at\" IS _cm_orders__amount_sum_window_90d.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.ordered_at\",\n \"orders.amount_sum_window_90d\",\n SUM(\"orders.amount_sum_window_90d\") OVER (PARTITION BY \"orders.region\" ORDER BY \"orders.ordered_at\") AS \"orders.x\"\n FROM base\n)\nSELECT\n \"orders.region\",\n \"orders.ordered_at\",\n \"orders.x\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.ordered_at\",\n \"orders.amount_sum_window_90d\",\n \"orders.x\"\n FROM step1\n) AS _outer", @@ -19,7 +19,7 @@ "mig/bare_rk::postgres": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.m\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_last 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.l\"\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)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.m\",\n _cm_orders__amount_last.\"orders.l\"\nFROM _base\nLEFT JOIN _cm_orders__amount_last\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_last.\"orders.region\"", "mig/bare_rk::sqlite": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.m\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_last AS (\n SELECT\n _val_0 AS \"orders.region\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS REAL) AS \"orders.l\"\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)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.m\",\n _cm_orders__amount_last.\"orders.l\"\nFROM _base\nLEFT JOIN _cm_orders__amount_last\n ON _base.\"orders.region\" IS _cm_orders__amount_last.\"orders.region\"", "mig/bare_rk::tsql": "WITH _base AS (\n SELECT\n orders.region AS [orders___region],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___m]\n FROM orders AS orders\n GROUP BY\n orders.region\n), _cm_orders__amount_last AS (\n SELECT\n _val_0 AS [orders___region],\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS FLOAT) AS [orders___l]\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)\nSELECT\n _base.[orders___region],\n _base.[orders___m],\n _cm_orders__amount_last.[orders___l]\nFROM _base\nLEFT JOIN _cm_orders__amount_last\n ON (\n (\n _base.[orders___region] = _cm_orders__amount_last.[orders___region]\n AND NOT _base.[orders___region] IS NULL\n AND NOT _cm_orders__amount_last.[orders___region] IS NULL\n )\n OR (\n _base.[orders___region] IS NULL AND _cm_orders__amount_last.[orders___region] IS NULL\n )\n )", - "mig/bare_wm::bigquery": "WITH _base AS (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___m`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___ordered_at`\n)\nSELECT\n _base.`orders___region`,\n _base.`orders___ordered_at`,\n _base.`orders___m`,\n _cm_orders__amount_sum_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.`orders___region`\n AND _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.`orders___ordered_at`", + "mig/bare_wm::bigquery": "WITH _base AS (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___m`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___ordered_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___ordered_at`\n)\nSELECT\n _base.`orders___region`,\n _base.`orders___ordered_at`,\n _base.`orders___m`,\n _cm_orders__amount_sum_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.`orders___region`\n AND _base.`orders___ordered_at` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.`orders___ordered_at`", "mig/bare_wm::duckdb": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.m\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_time >= _base.\"orders.ordered_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.ordered_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at\"\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n _base.\"orders.m\",\n _cm_orders__amount_sum_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.\"orders.region\"\n AND _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.\"orders.ordered_at\"", "mig/bare_wm::postgres": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.m\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_time >= _base.\"orders.ordered_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.ordered_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at\"\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n _base.\"orders.m\",\n _cm_orders__amount_sum_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.\"orders.region\"\n AND _base.\"orders.ordered_at\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d.\"orders.ordered_at\"", "mig/bare_wm::sqlite": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.m\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__amount_sum_window_90d AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n CAST(SUM(_src._w_value) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS _base.\"orders.region\"\n AND DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.ordered_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.ordered_at\", 1, 'month')\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at\"\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n _base.\"orders.m\",\n _cm_orders__amount_sum_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_sum_window_90d\n ON _base.\"orders.region\" IS _cm_orders__amount_sum_window_90d.\"orders.region\"\n AND _base.\"orders.ordered_at\" IS _cm_orders__amount_sum_window_90d.\"orders.ordered_at\"", diff --git a/tests/golden/dev1837_sql_baseline.json b/tests/golden/dev1837_sql_baseline.json index ae019ebf1..f04b71383 100644 --- a/tests/golden/dev1837_sql_baseline.json +++ b/tests/golden/dev1837_sql_baseline.json @@ -4,12 +4,12 @@ "lift/band_cumsum::postgres": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.amount_sum_partition_by_city\" AS \"amount_sum_partition_by_city\"\n FROM (\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 ) AS _stage_inner\n), base AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n SUM(\"orders.m\") OVER (PARTITION BY \"orders.region\", \"orders.band\" ORDER BY \"orders.ordered_at\") AS \"orders.c\"\n FROM base\n)\nSELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.c\"\n FROM step1\n) AS _outer", "lift/band_cumsum::sqlite": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.amount_sum_partition_by_city\" AS \"amount_sum_partition_by_city\"\n FROM (\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 ) AS _stage_inner\n), base AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n SUM(\"orders.m\") OVER (PARTITION BY \"orders.region\", \"orders.band\" ORDER BY \"orders.ordered_at\") AS \"orders.c\"\n FROM base\n)\nSELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.c\"\n FROM step1\n) AS _outer", "lift/band_cumsum::tsql": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.[orders___city] AS [city],\n _stage_inner.[orders___amount_sum_partition_by_city] AS [amount_sum_partition_by_city]\n FROM (\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 ) AS _stage_inner\n), base AS (\n SELECT\n orders.region AS [orders___region],\n CASE\n WHEN _cm_amount_sum_partition_by_city.[amount_sum_partition_by_city] > 35\n THEN 1\n ELSE 0\n END AS [orders___band],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___m]\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON (\n (\n orders.city = _cm_amount_sum_partition_by_city.[city]\n AND NOT orders.city IS NULL\n AND NOT _cm_amount_sum_partition_by_city.[city] IS NULL\n )\n OR (\n orders.city IS NULL AND _cm_amount_sum_partition_by_city.[city] IS NULL\n )\n )\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.[amount_sum_partition_by_city] > 35\n THEN 1\n ELSE 0\n END,\n DATETRUNC(month, orders.ordered_at)\n), step1 AS (\n SELECT\n [orders___region] AS [orders___region],\n [orders___band] AS [orders___band],\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___m] AS [orders___m],\n SUM([orders___m]) OVER (PARTITION BY [orders___region], [orders___band] ORDER BY [orders___ordered_at]) AS [orders___c]\n FROM base\n)\nSELECT\n [orders___region],\n [orders___band],\n [orders___ordered_at],\n [orders___m],\n [orders___c]\nFROM (\n SELECT\n [orders___region],\n [orders___band],\n [orders___ordered_at],\n [orders___m],\n [orders___c]\n FROM step1\n) AS _outer", - "lift/band_part_time_shift_cross::bigquery": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.`orders___city` AS `city`,\n _stage_inner.`orders___amount_sum_partition_by_city` AS `amount_sum_partition_by_city`\n FROM (\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 ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS `orders___region`,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END AS `orders___band`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___m`\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.`city`\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC(orders.ordered_at, MONTH)\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___rt`\n FROM orders AS orders\n GROUP BY\n orders.region\n), base AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___band`,\n _base.`orders___ordered_at`,\n _base.`orders___m`,\n _cm_orders__amount_sum_partition_by_region.`orders___rt`\n FROM _base\n LEFT 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`\n), shifted_prev AS (\n SELECT\n orders.region AS `orders___region`,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END AS `orders___band`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___m`\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.`city`\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), sjoin_prev AS (\n SELECT\n base.`orders___region`,\n base.`orders___band`,\n base.`orders___ordered_at`,\n base.`orders___m`,\n base.`orders___rt`,\n shifted_prev.`orders___m` AS `orders___prev`\n FROM base\n LEFT JOIN shifted_prev\n ON base.`orders___region` IS NOT DISTINCT FROM shifted_prev.`orders___region`\n AND base.`orders___band` IS NOT DISTINCT FROM shifted_prev.`orders___band`\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_prev.`orders___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `orders___region`,\n `orders___band`,\n `orders___ordered_at`,\n `orders___m`,\n `orders___rt`,\n `orders___prev`\nFROM (\n SELECT\n `orders___region`,\n `orders___band`,\n `orders___ordered_at`,\n `orders___m`,\n `orders___rt`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", + "lift/band_part_time_shift_cross::bigquery": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.`orders___city` AS `city`,\n _stage_inner.`orders___amount_sum_partition_by_city` AS `amount_sum_partition_by_city`\n FROM (\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 ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS `orders___region`,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END AS `orders___band`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___m`\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.`city`\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC(orders.ordered_at, MONTH)\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___rt`\n FROM orders AS orders\n GROUP BY\n orders.region\n), base AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___band`,\n _base.`orders___ordered_at`,\n _base.`orders___m`,\n _cm_orders__amount_sum_partition_by_region.`orders___rt`\n FROM _base\n LEFT 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`\n), shifted_prev AS (\n SELECT\n orders.region AS `orders___region`,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END AS `orders___band`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___m`\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.`city`\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), sjoin_prev AS (\n SELECT\n base.`orders___region`,\n base.`orders___band`,\n base.`orders___ordered_at`,\n base.`orders___m`,\n base.`orders___rt`,\n shifted_prev.`orders___m` AS `orders___prev`\n FROM base\n LEFT JOIN shifted_prev\n ON base.`orders___region` IS NOT DISTINCT FROM shifted_prev.`orders___region`\n AND base.`orders___band` IS NOT DISTINCT FROM shifted_prev.`orders___band`\n AND DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_prev.`orders___ordered_at` AS DATETIME)\n)\nSELECT\n `orders___region`,\n `orders___band`,\n `orders___ordered_at`,\n `orders___m`,\n `orders___rt`,\n `orders___prev`\nFROM (\n SELECT\n `orders___region`,\n `orders___band`,\n `orders___ordered_at`,\n `orders___m`,\n `orders___rt`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", "lift/band_part_time_shift_cross::duckdb": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.amount_sum_partition_by_city\" AS \"amount_sum_partition_by_city\"\n FROM (\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 ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC('MONTH', orders.ordered_at)\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.rt\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), base AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.band\",\n _base.\"orders.ordered_at\",\n _base.\"orders.m\",\n _cm_orders__amount_sum_partition_by_region.\"orders.rt\"\n FROM _base\n LEFT 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\"\n), shifted_prev AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"orders.region\",\n base.\"orders.band\",\n base.\"orders.ordered_at\",\n base.\"orders.m\",\n base.\"orders.rt\",\n shifted_prev.\"orders.m\" AS \"orders.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"orders.region\" IS NOT DISTINCT FROM shifted_prev.\"orders.region\"\n AND base.\"orders.band\" IS NOT DISTINCT FROM shifted_prev.\"orders.band\"\n AND base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_prev.\"orders.ordered_at\"\n)\nSELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.rt\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.rt\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "lift/band_part_time_shift_cross::postgres": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.amount_sum_partition_by_city\" AS \"amount_sum_partition_by_city\"\n FROM (\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 ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC('MONTH', orders.ordered_at)\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.rt\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), base AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.band\",\n _base.\"orders.ordered_at\",\n _base.\"orders.m\",\n _cm_orders__amount_sum_partition_by_region.\"orders.rt\"\n FROM _base\n LEFT 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\"\n), shifted_prev AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"orders.region\",\n base.\"orders.band\",\n base.\"orders.ordered_at\",\n base.\"orders.m\",\n base.\"orders.rt\",\n shifted_prev.\"orders.m\" AS \"orders.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"orders.region\" IS NOT DISTINCT FROM shifted_prev.\"orders.region\"\n AND base.\"orders.band\" IS NOT DISTINCT FROM shifted_prev.\"orders.band\"\n AND base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_prev.\"orders.ordered_at\"\n)\nSELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.rt\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.rt\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "lift/band_part_time_shift_cross::sqlite": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.amount_sum_partition_by_city\" AS \"amount_sum_partition_by_city\"\n FROM (\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 ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n STRFTIME('%Y-%m-01', orders.ordered_at)\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.rt\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), base AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.band\",\n _base.\"orders.ordered_at\",\n _base.\"orders.m\",\n _cm_orders__amount_sum_partition_by_region.\"orders.rt\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON _base.\"orders.region\" IS _cm_orders__amount_sum_partition_by_region.\"orders.region\"\n), shifted_prev AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"orders.region\",\n base.\"orders.band\",\n base.\"orders.ordered_at\",\n base.\"orders.m\",\n base.\"orders.rt\",\n shifted_prev.\"orders.m\" AS \"orders.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"orders.region\" IS shifted_prev.\"orders.region\"\n AND base.\"orders.band\" IS shifted_prev.\"orders.band\"\n AND SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted_prev.\"orders.ordered_at\"\n)\nSELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.rt\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.rt\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "lift/band_part_time_shift_cross::tsql": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.[orders___city] AS [city],\n _stage_inner.[orders___amount_sum_partition_by_city] AS [amount_sum_partition_by_city]\n FROM (\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 ) AS _stage_inner\n), _base AS (\n SELECT\n orders.region AS [orders___region],\n CASE\n WHEN _cm_amount_sum_partition_by_city.[amount_sum_partition_by_city] > 35\n THEN 1\n ELSE 0\n END AS [orders___band],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___m]\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON (\n (\n orders.city = _cm_amount_sum_partition_by_city.[city]\n AND NOT orders.city IS NULL\n AND NOT _cm_amount_sum_partition_by_city.[city] IS NULL\n )\n OR (\n orders.city IS NULL AND _cm_amount_sum_partition_by_city.[city] IS NULL\n )\n )\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.[amount_sum_partition_by_city] > 35\n THEN 1\n ELSE 0\n END,\n DATETRUNC(month, orders.ordered_at)\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___rt]\n FROM orders AS orders\n GROUP BY\n orders.region\n), base AS (\n SELECT\n _base.[orders___region] AS [orders___region],\n _base.[orders___band] AS [orders___band],\n _base.[orders___ordered_at] AS [orders___ordered_at],\n _base.[orders___m] AS [orders___m],\n _cm_orders__amount_sum_partition_by_region.[orders___rt] AS [orders___rt]\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON (\n (\n _base.[orders___region] = _cm_orders__amount_sum_partition_by_region.[orders___region]\n AND NOT _base.[orders___region] IS NULL\n AND NOT _cm_orders__amount_sum_partition_by_region.[orders___region] IS NULL\n )\n OR (\n _base.[orders___region] IS NULL\n AND _cm_orders__amount_sum_partition_by_region.[orders___region] IS NULL\n )\n )\n), shifted_prev AS (\n SELECT\n orders.region AS [orders___region],\n CASE\n WHEN _cm_amount_sum_partition_by_city.[amount_sum_partition_by_city] > 35\n THEN 1\n ELSE 0\n END AS [orders___band],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___m]\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON (\n (\n orders.city = _cm_amount_sum_partition_by_city.[city]\n AND NOT orders.city IS NULL\n AND NOT _cm_amount_sum_partition_by_city.[city] IS NULL\n )\n OR (\n orders.city IS NULL AND _cm_amount_sum_partition_by_city.[city] IS NULL\n )\n )\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.[amount_sum_partition_by_city] > 35\n THEN 1\n ELSE 0\n END,\n DATETRUNC(month, orders.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.[orders___region] AS [orders___region],\n base.[orders___band] AS [orders___band],\n base.[orders___ordered_at] AS [orders___ordered_at],\n base.[orders___m] AS [orders___m],\n base.[orders___rt] AS [orders___rt],\n shifted_prev.[orders___m] AS [orders___prev]\n FROM base\n LEFT JOIN shifted_prev\n ON (\n (\n base.[orders___region] = shifted_prev.[orders___region]\n AND NOT base.[orders___region] IS NULL\n AND NOT shifted_prev.[orders___region] IS NULL\n )\n OR (\n base.[orders___region] IS NULL AND shifted_prev.[orders___region] IS NULL\n )\n )\n AND (\n (\n base.[orders___band] = shifted_prev.[orders___band]\n AND NOT base.[orders___band] IS NULL\n AND NOT shifted_prev.[orders___band] IS NULL\n )\n OR (\n base.[orders___band] IS NULL AND shifted_prev.[orders___band] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted_prev.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted_prev.[orders___ordered_at] IS NULL\n )\n OR (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND shifted_prev.[orders___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [orders___region],\n [orders___band],\n [orders___ordered_at],\n [orders___m],\n [orders___rt],\n [orders___prev]\nFROM (\n SELECT\n [orders___region],\n [orders___band],\n [orders___ordered_at],\n [orders___m],\n [orders___rt],\n [orders___prev]\n FROM sjoin_prev\n) AS _outer", - "lift/band_time_shift_plain::bigquery": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.`orders___city` AS `city`,\n _stage_inner.`orders___amount_sum_partition_by_city` AS `amount_sum_partition_by_city`\n FROM (\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 ) AS _stage_inner\n), base AS (\n SELECT\n orders.region AS `orders___region`,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END AS `orders___band`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___m`\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.`city`\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted_prev AS (\n SELECT\n orders.region AS `orders___region`,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END AS `orders___band`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___m`\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.`city`\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), sjoin_prev AS (\n SELECT\n base.`orders___region`,\n base.`orders___band`,\n base.`orders___ordered_at`,\n base.`orders___m`,\n shifted_prev.`orders___m` AS `orders___prev`\n FROM base\n LEFT JOIN shifted_prev\n ON base.`orders___region` IS NOT DISTINCT FROM shifted_prev.`orders___region`\n AND base.`orders___band` IS NOT DISTINCT FROM shifted_prev.`orders___band`\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_prev.`orders___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `orders___region`,\n `orders___band`,\n `orders___ordered_at`,\n `orders___m`,\n `orders___prev`\nFROM (\n SELECT\n `orders___region`,\n `orders___band`,\n `orders___ordered_at`,\n `orders___m`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", + "lift/band_time_shift_plain::bigquery": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.`orders___city` AS `city`,\n _stage_inner.`orders___amount_sum_partition_by_city` AS `amount_sum_partition_by_city`\n FROM (\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 ) AS _stage_inner\n), base AS (\n SELECT\n orders.region AS `orders___region`,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END AS `orders___band`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___m`\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.`city`\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted_prev AS (\n SELECT\n orders.region AS `orders___region`,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END AS `orders___band`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___m`\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.`city`\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.`amount_sum_partition_by_city` > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), sjoin_prev AS (\n SELECT\n base.`orders___region`,\n base.`orders___band`,\n base.`orders___ordered_at`,\n base.`orders___m`,\n shifted_prev.`orders___m` AS `orders___prev`\n FROM base\n LEFT JOIN shifted_prev\n ON base.`orders___region` IS NOT DISTINCT FROM shifted_prev.`orders___region`\n AND base.`orders___band` IS NOT DISTINCT FROM shifted_prev.`orders___band`\n AND DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_prev.`orders___ordered_at` AS DATETIME)\n)\nSELECT\n `orders___region`,\n `orders___band`,\n `orders___ordered_at`,\n `orders___m`,\n `orders___prev`\nFROM (\n SELECT\n `orders___region`,\n `orders___band`,\n `orders___ordered_at`,\n `orders___m`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", "lift/band_time_shift_plain::duckdb": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.amount_sum_partition_by_city\" AS \"amount_sum_partition_by_city\"\n FROM (\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 ) AS _stage_inner\n), base AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted_prev AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"orders.region\",\n base.\"orders.band\",\n base.\"orders.ordered_at\",\n base.\"orders.m\",\n shifted_prev.\"orders.m\" AS \"orders.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"orders.region\" IS NOT DISTINCT FROM shifted_prev.\"orders.region\"\n AND base.\"orders.band\" IS NOT DISTINCT FROM shifted_prev.\"orders.band\"\n AND base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_prev.\"orders.ordered_at\"\n)\nSELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "lift/band_time_shift_plain::postgres": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.amount_sum_partition_by_city\" AS \"amount_sum_partition_by_city\"\n FROM (\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 ) AS _stage_inner\n), base AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted_prev AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"orders.region\",\n base.\"orders.band\",\n base.\"orders.ordered_at\",\n base.\"orders.m\",\n shifted_prev.\"orders.m\" AS \"orders.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"orders.region\" IS NOT DISTINCT FROM shifted_prev.\"orders.region\"\n AND base.\"orders.band\" IS NOT DISTINCT FROM shifted_prev.\"orders.band\"\n AND base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_prev.\"orders.ordered_at\"\n)\nSELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "lift/band_time_shift_plain::sqlite": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.amount_sum_partition_by_city\" AS \"amount_sum_partition_by_city\"\n FROM (\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 ) AS _stage_inner\n), base AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), shifted_prev AS (\n SELECT\n orders.region AS \"orders.region\",\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END AS \"orders.band\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n CASE\n WHEN _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" > 35\n THEN 1\n ELSE 0\n END,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"orders.region\",\n base.\"orders.band\",\n base.\"orders.ordered_at\",\n base.\"orders.m\",\n shifted_prev.\"orders.m\" AS \"orders.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"orders.region\" IS shifted_prev.\"orders.region\"\n AND base.\"orders.band\" IS shifted_prev.\"orders.band\"\n AND SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted_prev.\"orders.ordered_at\"\n)\nSELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.band\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", @@ -19,7 +19,7 @@ "lift/bare_cumsum::postgres": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.amount_sum_partition_by_city\" AS \"amount_sum_partition_by_city\"\n FROM (\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 ) AS _stage_inner\n), base AS (\n SELECT\n orders.region AS \"orders.region\",\n _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" AS \"orders.ct\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\",\n DATE_TRUNC('MONTH', orders.ordered_at)\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.ct\",\n \"orders.ordered_at\",\n \"orders.m\",\n SUM(\"orders.m\") OVER (PARTITION BY \"orders.region\", \"orders.ct\" ORDER BY \"orders.ordered_at\") AS \"orders.c\"\n FROM base\n)\nSELECT\n \"orders.region\",\n \"orders.ct\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.ct\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.c\"\n FROM step1\n) AS _outer", "lift/bare_cumsum::sqlite": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.\"orders.city\" AS \"city\",\n _stage_inner.\"orders.amount_sum_partition_by_city\" AS \"amount_sum_partition_by_city\"\n FROM (\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 ) AS _stage_inner\n), base AS (\n SELECT\n orders.region AS \"orders.region\",\n _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\" AS \"orders.ct\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.m\"\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON orders.city IS _cm_amount_sum_partition_by_city.\"city\"\n GROUP BY\n orders.region,\n _cm_amount_sum_partition_by_city.\"amount_sum_partition_by_city\",\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), step1 AS (\n SELECT\n \"orders.region\",\n \"orders.ct\",\n \"orders.ordered_at\",\n \"orders.m\",\n SUM(\"orders.m\") OVER (PARTITION BY \"orders.region\", \"orders.ct\" ORDER BY \"orders.ordered_at\") AS \"orders.c\"\n FROM base\n)\nSELECT\n \"orders.region\",\n \"orders.ct\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.c\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.ct\",\n \"orders.ordered_at\",\n \"orders.m\",\n \"orders.c\"\n FROM step1\n) AS _outer", "lift/bare_cumsum::tsql": "WITH _cm_amount_sum_partition_by_city AS (\n SELECT\n _stage_inner.[orders___city] AS [city],\n _stage_inner.[orders___amount_sum_partition_by_city] AS [amount_sum_partition_by_city]\n FROM (\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 ) AS _stage_inner\n), base AS (\n SELECT\n orders.region AS [orders___region],\n _cm_amount_sum_partition_by_city.[amount_sum_partition_by_city] AS [orders___ct],\n DATETRUNC(month, orders.ordered_at) AS [orders___ordered_at],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___m]\n FROM orders AS orders\n LEFT JOIN _cm_amount_sum_partition_by_city\n ON (\n (\n orders.city = _cm_amount_sum_partition_by_city.[city]\n AND NOT orders.city IS NULL\n AND NOT _cm_amount_sum_partition_by_city.[city] IS NULL\n )\n OR (\n orders.city IS NULL AND _cm_amount_sum_partition_by_city.[city] IS NULL\n )\n )\n GROUP BY\n orders.region,\n _cm_amount_sum_partition_by_city.[amount_sum_partition_by_city],\n DATETRUNC(month, orders.ordered_at)\n), step1 AS (\n SELECT\n [orders___region] AS [orders___region],\n [orders___ct] AS [orders___ct],\n [orders___ordered_at] AS [orders___ordered_at],\n [orders___m] AS [orders___m],\n SUM([orders___m]) OVER (PARTITION BY [orders___region], [orders___ct] ORDER BY [orders___ordered_at]) AS [orders___c]\n FROM base\n)\nSELECT\n [orders___region],\n [orders___ct],\n [orders___ordered_at],\n [orders___m],\n [orders___c]\nFROM (\n SELECT\n [orders___region],\n [orders___ct],\n [orders___ordered_at],\n [orders___m],\n [orders___c]\n FROM step1\n) AS _outer", - "lift/part_time_shift_fixed::bigquery": "WITH _base AS (\n SELECT\n orders.region AS `orders___region`,\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 orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\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___rt`\n FROM orders AS orders\n GROUP BY\n orders.region\n), base AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___ordered_at`,\n _cm_orders__amount_sum_partition_by_region.`orders___rt`,\n _base.`orders___amount_sum`\n FROM _base\n LEFT 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`\n), shifted_prev AS (\n SELECT\n orders.region AS `orders___region`,\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 orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), sjoin_prev AS (\n SELECT\n base.`orders___region`,\n base.`orders___ordered_at`,\n base.`orders___amount_sum`,\n base.`orders___rt`,\n shifted_prev.`orders___amount_sum` AS `orders___prev`\n FROM base\n LEFT JOIN shifted_prev\n ON base.`orders___region` IS NOT DISTINCT FROM shifted_prev.`orders___region`\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_prev.`orders___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `orders___region`,\n `orders___ordered_at`,\n `orders___rt`,\n `orders___prev`\nFROM (\n SELECT\n `orders___region`,\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___rt`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", + "lift/part_time_shift_fixed::bigquery": "WITH _base AS (\n SELECT\n orders.region AS `orders___region`,\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 orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\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___rt`\n FROM orders AS orders\n GROUP BY\n orders.region\n), base AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___ordered_at`,\n _cm_orders__amount_sum_partition_by_region.`orders___rt`,\n _base.`orders___amount_sum`\n FROM _base\n LEFT 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`\n), shifted_prev AS (\n SELECT\n orders.region AS `orders___region`,\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 orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), sjoin_prev AS (\n SELECT\n base.`orders___region`,\n base.`orders___ordered_at`,\n base.`orders___amount_sum`,\n base.`orders___rt`,\n shifted_prev.`orders___amount_sum` AS `orders___prev`\n FROM base\n LEFT JOIN shifted_prev\n ON base.`orders___region` IS NOT DISTINCT FROM shifted_prev.`orders___region`\n AND DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_prev.`orders___ordered_at` AS DATETIME)\n)\nSELECT\n `orders___region`,\n `orders___ordered_at`,\n `orders___rt`,\n `orders___prev`\nFROM (\n SELECT\n `orders___region`,\n `orders___ordered_at`,\n `orders___amount_sum`,\n `orders___rt`,\n `orders___prev`\n FROM sjoin_prev\n) AS _outer", "lift/part_time_shift_fixed::duckdb": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\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 orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\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.rt\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), base AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_sum_partition_by_region.\"orders.rt\",\n _base.\"orders.amount_sum\"\n FROM _base\n LEFT 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\"\n), shifted_prev AS (\n SELECT\n orders.region AS \"orders.region\",\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 orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"orders.region\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.rt\",\n shifted_prev.\"orders.amount_sum\" AS \"orders.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"orders.region\" IS NOT DISTINCT FROM shifted_prev.\"orders.region\"\n AND base.\"orders.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_prev.\"orders.ordered_at\"\n)\nSELECT\n \"orders.region\",\n \"orders.ordered_at\",\n \"orders.rt\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.rt\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "lift/part_time_shift_fixed::postgres": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\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 orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\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.rt\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), base AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_sum_partition_by_region.\"orders.rt\",\n _base.\"orders.amount_sum\"\n FROM _base\n LEFT 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\"\n), shifted_prev AS (\n SELECT\n orders.region AS \"orders.region\",\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 orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"orders.region\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.rt\",\n shifted_prev.\"orders.amount_sum\" AS \"orders.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"orders.region\" IS NOT DISTINCT FROM shifted_prev.\"orders.region\"\n AND base.\"orders.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_prev.\"orders.ordered_at\"\n)\nSELECT\n \"orders.region\",\n \"orders.ordered_at\",\n \"orders.rt\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.rt\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", "lift/part_time_shift_fixed::sqlite": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\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 orders.region,\n STRFTIME('%Y-%m-01', orders.ordered_at)\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.rt\"\n FROM orders AS orders\n GROUP BY\n orders.region\n), base AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at\",\n _cm_orders__amount_sum_partition_by_region.\"orders.rt\",\n _base.\"orders.amount_sum\"\n FROM _base\n LEFT JOIN _cm_orders__amount_sum_partition_by_region\n ON _base.\"orders.region\" IS _cm_orders__amount_sum_partition_by_region.\"orders.region\"\n), shifted_prev AS (\n SELECT\n orders.region AS \"orders.region\",\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 orders.region,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.\"orders.region\",\n base.\"orders.ordered_at\",\n base.\"orders.amount_sum\",\n base.\"orders.rt\",\n shifted_prev.\"orders.amount_sum\" AS \"orders.prev\"\n FROM base\n LEFT JOIN shifted_prev\n ON base.\"orders.region\" IS shifted_prev.\"orders.region\"\n AND SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted_prev.\"orders.ordered_at\"\n)\nSELECT\n \"orders.region\",\n \"orders.ordered_at\",\n \"orders.rt\",\n \"orders.prev\"\nFROM (\n SELECT\n \"orders.region\",\n \"orders.ordered_at\",\n \"orders.amount_sum\",\n \"orders.rt\",\n \"orders.prev\"\n FROM sjoin_prev\n) AS _outer", diff --git a/tests/golden/dev1839_sql_baseline.json b/tests/golden/dev1839_sql_baseline.json index 90aae48ec..d519a33c1 100644 --- a/tests/golden/dev1839_sql_baseline.json +++ b/tests/golden/dev1839_sql_baseline.json @@ -59,7 +59,7 @@ "lift/dim_mixed_rank::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 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.rr\",\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_mixed_rank::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 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.rr\",\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_mixed_rank::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 (\n _base_2.[orders___region] = _cm_orders__amount_sum_partition_by_region.[orders___region]\n AND NOT _base_2.[orders___region] IS NULL\n AND NOT _cm_orders__amount_sum_partition_by_region.[orders___region] IS NULL\n )\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 (\n _base_2.[orders___city] = _cm_orders__amount_sum_partition_by_city.[orders___city]\n AND NOT _base_2.[orders___city] IS NULL\n AND NOT _cm_orders__amount_sum_partition_by_city.[orders___city] IS NULL\n )\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 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___rr],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___s]\nFROM orders AS orders\nLEFT JOIN _cm_rank\n ON (\n (\n orders.city = _cm_rank.[city]\n AND NOT orders.city IS NULL\n AND NOT _cm_rank.[city] IS NULL\n )\n OR (\n orders.city IS NULL AND _cm_rank.[city] IS NULL\n )\n )\n AND (\n (\n orders.region = _cm_rank.[region]\n AND NOT orders.region IS NULL\n AND NOT _cm_rank.[region] IS NULL\n )\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_mixed_windowed::bigquery": "WITH _base_2 AS (\n SELECT\n orders.city AS `orders___city`,\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at_month`\n FROM orders AS orders\n GROUP BY\n orders.city,\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___ordered_at_month`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___amount_sum_window_90d_partition_by_region`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at_month`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at_month` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at_month` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___ordered_at_month`\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 _base_2.`orders___ordered_at_month`,\n _cm_orders__amount_sum_window_90d_partition_by_region.`orders___amount_sum_window_90d_partition_by_region` AS `orders___amount_sum_window_90d_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_window_90d_partition_by_region\n ON _base_2.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.`orders___region`\n AND _base_2.`orders___ordered_at_month` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.`orders___ordered_at_month`\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___ordered_at_month`,\n `orders___amount_sum_window_90d_partition_by_region`,\n `orders___amount_sum_partition_by_city`,\n CASE\n WHEN `orders___amount_sum_window_90d_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_sum_window_90d_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_window_90d_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___ordered_at_month` AS `ordered_at_month`,\n _stage_inner.`orders___rank` AS `rank`\n FROM (\n SELECT\n `orders___city`,\n `orders___region`,\n `orders___ordered_at_month`,\n `orders___rank`\n FROM (\n SELECT\n `orders___city`,\n `orders___region`,\n `orders___ordered_at_month`,\n `orders___amount_sum_window_90d_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 DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\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`\n AND DATE_TRUNC(orders.ordered_at, MONTH) IS NOT DISTINCT FROM _cm_rank.`ordered_at_month`\nGROUP BY\n orders.region,\n orders.city,\n _cm_rank.`rank`,\n DATE_TRUNC(orders.ordered_at, MONTH)", + "lift/dim_mixed_windowed::bigquery": "WITH _base_2 AS (\n SELECT\n orders.city AS `orders___city`,\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at_month`\n FROM orders AS orders\n GROUP BY\n orders.city,\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___ordered_at_month`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `orders___amount_sum_window_90d_partition_by_region`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at_month`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.ordered_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___ordered_at_month` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___ordered_at_month` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___ordered_at_month`\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 _base_2.`orders___ordered_at_month`,\n _cm_orders__amount_sum_window_90d_partition_by_region.`orders___amount_sum_window_90d_partition_by_region` AS `orders___amount_sum_window_90d_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_window_90d_partition_by_region\n ON _base_2.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.`orders___region`\n AND _base_2.`orders___ordered_at_month` IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.`orders___ordered_at_month`\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___ordered_at_month`,\n `orders___amount_sum_window_90d_partition_by_region`,\n `orders___amount_sum_partition_by_city`,\n CASE\n WHEN `orders___amount_sum_window_90d_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_sum_window_90d_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_window_90d_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___ordered_at_month` AS `ordered_at_month`,\n _stage_inner.`orders___rank` AS `rank`\n FROM (\n SELECT\n `orders___city`,\n `orders___region`,\n `orders___ordered_at_month`,\n `orders___rank`\n FROM (\n SELECT\n `orders___city`,\n `orders___region`,\n `orders___ordered_at_month`,\n `orders___amount_sum_window_90d_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 DATE_TRUNC(orders.ordered_at, MONTH) AS `orders___ordered_at`,\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`\n AND DATE_TRUNC(orders.ordered_at, MONTH) IS NOT DISTINCT FROM _cm_rank.`ordered_at_month`\nGROUP BY\n orders.region,\n orders.city,\n _cm_rank.`rank`,\n DATE_TRUNC(orders.ordered_at, MONTH)", "lift/dim_mixed_windowed::duckdb": "WITH _base_2 AS (\n SELECT\n orders.city AS \"orders.city\",\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at_month\"\n FROM orders AS orders\n GROUP BY\n orders.city,\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at_month\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"orders.amount_sum_window_90d_partition_by_region\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at_month\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_time >= _base.\"orders.ordered_at_month\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.ordered_at_month\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at_month\"\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 _base_2.\"orders.ordered_at_month\",\n _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.amount_sum_window_90d_partition_by_region\" AS \"orders.amount_sum_window_90d_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_window_90d_partition_by_region\n ON _base_2.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.region\"\n AND _base_2.\"orders.ordered_at_month\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.ordered_at_month\"\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.ordered_at_month\",\n \"orders.amount_sum_window_90d_partition_by_region\",\n \"orders.amount_sum_partition_by_city\",\n CASE\n WHEN \"orders.amount_sum_window_90d_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_sum_window_90d_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_window_90d_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.ordered_at_month\" AS \"ordered_at_month\",\n _stage_inner.\"orders.rank\" AS \"rank\"\n FROM (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.ordered_at_month\",\n \"orders.rank\"\n FROM (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.ordered_at_month\",\n \"orders.amount_sum_window_90d_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 DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\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\"\n AND DATE_TRUNC('MONTH', orders.ordered_at) IS NOT DISTINCT FROM _cm_rank.\"ordered_at_month\"\nGROUP BY\n orders.region,\n orders.city,\n _cm_rank.\"rank\",\n DATE_TRUNC('MONTH', orders.ordered_at)", "lift/dim_mixed_windowed::postgres": "WITH _base_2 AS (\n SELECT\n orders.city AS \"orders.city\",\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at_month\"\n FROM orders AS orders\n GROUP BY\n orders.city,\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at_month\",\n CAST(SUM(_src._w_value) AS DOUBLE PRECISION) AS \"orders.amount_sum_window_90d_partition_by_region\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at_month\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_time >= _base.\"orders.ordered_at_month\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.ordered_at_month\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at_month\"\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 _base_2.\"orders.ordered_at_month\",\n _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.amount_sum_window_90d_partition_by_region\" AS \"orders.amount_sum_window_90d_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_window_90d_partition_by_region\n ON _base_2.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.region\"\n AND _base_2.\"orders.ordered_at_month\" IS NOT DISTINCT FROM _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.ordered_at_month\"\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.ordered_at_month\",\n \"orders.amount_sum_window_90d_partition_by_region\",\n \"orders.amount_sum_partition_by_city\",\n CASE\n WHEN \"orders.amount_sum_window_90d_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_sum_window_90d_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_window_90d_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.ordered_at_month\" AS \"ordered_at_month\",\n _stage_inner.\"orders.rank\" AS \"rank\"\n FROM (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.ordered_at_month\",\n \"orders.rank\"\n FROM (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.ordered_at_month\",\n \"orders.amount_sum_window_90d_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 DATE_TRUNC('MONTH', orders.ordered_at) AS \"orders.ordered_at\",\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\"\n AND DATE_TRUNC('MONTH', orders.ordered_at) IS NOT DISTINCT FROM _cm_rank.\"ordered_at_month\"\nGROUP BY\n orders.region,\n orders.city,\n _cm_rank.\"rank\",\n DATE_TRUNC('MONTH', orders.ordered_at)", "lift/dim_mixed_windowed::sqlite": "WITH _base_2 AS (\n SELECT\n orders.city AS \"orders.city\",\n orders.region AS \"orders.region\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at_month\"\n FROM orders AS orders\n GROUP BY\n orders.city,\n orders.region,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__amount_sum_window_90d_partition_by_region AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.ordered_at_month\",\n CAST(SUM(_src._w_value) AS REAL) AS \"orders.amount_sum_window_90d_partition_by_region\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at_month\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.ordered_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS _base.\"orders.region\"\n AND DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.ordered_at_month\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.ordered_at_month\", 1, 'month')\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.ordered_at_month\"\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 _base_2.\"orders.ordered_at_month\",\n _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.amount_sum_window_90d_partition_by_region\" AS \"orders.amount_sum_window_90d_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_window_90d_partition_by_region\n ON _base_2.\"orders.region\" IS _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.region\"\n AND _base_2.\"orders.ordered_at_month\" IS _cm_orders__amount_sum_window_90d_partition_by_region.\"orders.ordered_at_month\"\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.ordered_at_month\",\n \"orders.amount_sum_window_90d_partition_by_region\",\n \"orders.amount_sum_partition_by_city\",\n CASE\n WHEN \"orders.amount_sum_window_90d_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_sum_window_90d_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_window_90d_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.ordered_at_month\" AS \"ordered_at_month\",\n _stage_inner.\"orders.rank\" AS \"rank\"\n FROM (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.ordered_at_month\",\n \"orders.rank\"\n FROM (\n SELECT\n \"orders.city\",\n \"orders.region\",\n \"orders.ordered_at_month\",\n \"orders.amount_sum_window_90d_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 STRFTIME('%Y-%m-01', orders.ordered_at) AS \"orders.ordered_at\",\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\"\n AND orders.region IS _cm_rank.\"region\"\n AND STRFTIME('%Y-%m-01', orders.ordered_at) IS _cm_rank.\"ordered_at_month\"\nGROUP BY\n orders.region,\n orders.city,\n _cm_rank.\"rank\",\n STRFTIME('%Y-%m-01', orders.ordered_at)", diff --git a/tests/golden/dev1846_sql_baseline.json b/tests/golden/dev1846_sql_baseline.json index f2991d338..778c29cc7 100644 --- a/tests/golden/dev1846_sql_baseline.json +++ b/tests/golden/dev1846_sql_baseline.json @@ -1,65 +1,65 @@ { - "cp/and_simple::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 SUM(sales.cost) AS `sales___cost_sum`\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n SUM(\n CASE\n WHEN `sales___revenue_sum` > 40\n AND `sales___cost_sum` > 10\n AND CAST(`_cp_prev_sales___streak` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n CASE\n WHEN `sales___revenue_sum` > 40 AND `sales___cost_sum` > 10\n THEN SUM(CASE WHEN `sales___revenue_sum` > 40 AND `sales___cost_sum` > 10 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", + "cp/and_simple::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 SUM(sales.cost) AS `sales___cost_sum`\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n SUM(\n CASE\n WHEN `sales___revenue_sum` > 40\n AND `sales___cost_sum` > 10\n AND CAST(`_cp_prev_sales___streak` AS DATETIME) = DATETIME_ADD(CAST(`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n CASE\n WHEN `sales___revenue_sum` > 40 AND `sales___cost_sum` > 10\n THEN SUM(CASE WHEN `sales___revenue_sum` > 40 AND `sales___cost_sum` > 10 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", "cp/and_simple::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 SUM(sales.cost) AS \"sales.cost_sum\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n SUM(\n CASE\n WHEN \"sales.revenue_sum\" > 40\n AND \"sales.cost_sum\" > 10\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n CASE\n WHEN \"sales.revenue_sum\" > 40 AND \"sales.cost_sum\" > 10\n THEN SUM(CASE WHEN \"sales.revenue_sum\" > 40 AND \"sales.cost_sum\" > 10 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/and_simple::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 SUM(sales.cost) AS \"sales.cost_sum\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n SUM(\n CASE\n WHEN \"sales.revenue_sum\" > 40\n AND \"sales.cost_sum\" > 10\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n CASE\n WHEN \"sales.revenue_sum\" > 40 AND \"sales.cost_sum\" > 10\n THEN SUM(CASE WHEN \"sales.revenue_sum\" > 40 AND \"sales.cost_sum\" > 10 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/and_simple::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\",\n SUM(sales.cost) AS \"sales.cost_sum\"\n FROM sales AS sales\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n SUM(\n CASE\n WHEN \"sales.revenue_sum\" > 40\n AND \"sales.cost_sum\" > 10\n AND \"_cp_prev_sales.streak\" = SLAYER_DATE_ADD(\"sales.ordered_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n CASE\n WHEN \"sales.revenue_sum\" > 40 AND \"sales.cost_sum\" > 10\n THEN SUM(CASE WHEN \"sales.revenue_sum\" > 40 AND \"sales.cost_sum\" > 10 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/and_simple::tsql": "WITH base AS (\n SELECT\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at],\n SUM(sales.revenue) AS [sales___revenue_sum],\n SUM(sales.cost) AS [sales___cost_sum]\n FROM sales AS sales\n GROUP BY\n DATETRUNC(month, sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales___cost_sum] AS [sales___cost_sum],\n LAG([sales___ordered_at]) OVER (ORDER BY [sales___ordered_at]) AS [_cp_prev_sales___streak]\n FROM base\n), cp_reset_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales___cost_sum] AS [sales___cost_sum],\n SUM(\n CASE\n WHEN [sales___revenue_sum] > 40\n AND [sales___cost_sum] > 10\n AND [_cp_prev_sales___streak] = DATEADD(MONTH, -1, [sales___ordered_at])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [sales___ordered_at] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_sales___streak]\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales___cost_sum] AS [sales___cost_sum],\n CASE\n WHEN [sales___revenue_sum] > 40 AND [sales___cost_sum] > 10\n THEN SUM(CASE WHEN [sales___revenue_sum] > 40 AND [sales___cost_sum] > 10 THEN 1 ELSE 0 END) OVER (\n PARTITION BY [_cp_reset_sales___streak]\n ORDER BY [sales___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [sales___streak]\n FROM cp_reset_streak\n)\nSELECT\n [sales___ordered_at],\n [sales___streak]\nFROM (\n SELECT\n [sales___ordered_at],\n [sales___revenue_sum],\n [sales___cost_sum],\n [sales___streak]\n FROM cp_value_streak\n) AS _outer", - "cp/bare_cumsum::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), step1 AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n SUM(`sales___revenue_sum`) OVER (ORDER BY `sales___ordered_at`) AS `sales____cumsum_inner`\n FROM base\n), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____cumsum_inner`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM step1\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____cumsum_inner`,\n SUM(\n CASE\n WHEN NOT `sales____cumsum_inner` IS NULL\n AND `sales____cumsum_inner` <> 0\n AND CAST(`_cp_prev_sales___streak` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____cumsum_inner`,\n CASE\n WHEN NOT `sales____cumsum_inner` IS NULL AND `sales____cumsum_inner` <> 0\n THEN SUM(\n CASE\n WHEN NOT `sales____cumsum_inner` IS NULL AND `sales____cumsum_inner` <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____cumsum_inner`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", + "cp/bare_cumsum::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), step1 AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n SUM(`sales___revenue_sum`) OVER (ORDER BY `sales___ordered_at`) AS `sales____cumsum_inner`\n FROM base\n), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____cumsum_inner`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM step1\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____cumsum_inner`,\n SUM(\n CASE\n WHEN NOT `sales____cumsum_inner` IS NULL\n AND `sales____cumsum_inner` <> 0\n AND CAST(`_cp_prev_sales___streak` AS DATETIME) = DATETIME_ADD(CAST(`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____cumsum_inner`,\n CASE\n WHEN NOT `sales____cumsum_inner` IS NULL AND `sales____cumsum_inner` <> 0\n THEN SUM(\n CASE\n WHEN NOT `sales____cumsum_inner` IS NULL AND `sales____cumsum_inner` <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____cumsum_inner`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", "cp/bare_cumsum::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), step1 AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\"sales.revenue_sum\") OVER (ORDER BY \"sales.ordered_at\") AS \"sales._cumsum_inner\"\n FROM base\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM step1\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n SUM(\n CASE\n WHEN NOT \"sales._cumsum_inner\" IS NULL\n AND \"sales._cumsum_inner\" <> 0\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n CASE\n WHEN NOT \"sales._cumsum_inner\" IS NULL AND \"sales._cumsum_inner\" <> 0\n THEN SUM(\n CASE\n WHEN NOT \"sales._cumsum_inner\" IS NULL AND \"sales._cumsum_inner\" <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/bare_cumsum::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), step1 AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\"sales.revenue_sum\") OVER (ORDER BY \"sales.ordered_at\") AS \"sales._cumsum_inner\"\n FROM base\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM step1\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n SUM(\n CASE\n WHEN NOT \"sales._cumsum_inner\" IS NULL\n AND \"sales._cumsum_inner\" <> 0\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n CASE\n WHEN NOT \"sales._cumsum_inner\" IS NULL AND \"sales._cumsum_inner\" <> 0\n THEN SUM(\n CASE\n WHEN NOT \"sales._cumsum_inner\" IS NULL AND \"sales._cumsum_inner\" <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/bare_cumsum::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\"\n FROM sales AS sales\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), step1 AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\"sales.revenue_sum\") OVER (ORDER BY \"sales.ordered_at\") AS \"sales._cumsum_inner\"\n FROM base\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM step1\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n SUM(\n CASE\n WHEN NOT \"sales._cumsum_inner\" IS NULL\n AND \"sales._cumsum_inner\" <> 0\n AND \"_cp_prev_sales.streak\" = SLAYER_DATE_ADD(\"sales.ordered_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n CASE\n WHEN NOT \"sales._cumsum_inner\" IS NULL AND \"sales._cumsum_inner\" <> 0\n THEN SUM(\n CASE\n WHEN NOT \"sales._cumsum_inner\" IS NULL AND \"sales._cumsum_inner\" <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/bare_cumsum::tsql": "WITH base AS (\n SELECT\n DATETRUNC(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 DATETRUNC(month, sales.ordered_at)\n), step1 AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n SUM([sales___revenue_sum]) OVER (ORDER BY [sales___ordered_at]) AS [sales____cumsum_inner]\n FROM base\n), cp_prev_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales____cumsum_inner] AS [sales____cumsum_inner],\n LAG([sales___ordered_at]) OVER (ORDER BY [sales___ordered_at]) AS [_cp_prev_sales___streak]\n FROM step1\n), cp_reset_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales____cumsum_inner] AS [sales____cumsum_inner],\n SUM(\n CASE\n WHEN NOT [sales____cumsum_inner] IS NULL\n AND [sales____cumsum_inner] <> 0\n AND [_cp_prev_sales___streak] = DATEADD(MONTH, -1, [sales___ordered_at])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [sales___ordered_at] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_sales___streak]\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales____cumsum_inner] AS [sales____cumsum_inner],\n CASE\n WHEN NOT [sales____cumsum_inner] IS NULL AND [sales____cumsum_inner] <> 0\n THEN SUM(\n CASE\n WHEN NOT [sales____cumsum_inner] IS NULL AND [sales____cumsum_inner] <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY [_cp_reset_sales___streak]\n ORDER BY [sales___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [sales___streak]\n FROM cp_reset_streak\n)\nSELECT\n [sales___ordered_at],\n [sales___streak]\nFROM (\n SELECT\n [sales___ordered_at],\n [sales___revenue_sum],\n [sales____cumsum_inner],\n [sales___streak]\n FROM cp_value_streak\n) AS _outer", - "cp/boolean_numeric::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 SUM(sales.cost) AS `sales___cost_sum`\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), cp_prev_x AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___x`\n FROM base\n), cp_reset_x AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n SUM(\n CASE\n WHEN NOT CAST(`sales___revenue_sum` > 0 AS INT64) + CAST(`sales___cost_sum` > 0 AS INT64) IS NULL\n AND CAST(`sales___revenue_sum` > 0 AS INT64) + CAST(`sales___cost_sum` > 0 AS INT64) <> 0\n AND CAST(`_cp_prev_sales___x` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___x`\n FROM cp_prev_x\n), cp_value_x AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n CASE\n WHEN NOT CAST(`sales___revenue_sum` > 0 AS INT64) + CAST(`sales___cost_sum` > 0 AS INT64) IS NULL\n AND CAST(`sales___revenue_sum` > 0 AS INT64) + CAST(`sales___cost_sum` > 0 AS INT64) <> 0\n THEN SUM(\n CASE\n WHEN NOT CAST(`sales___revenue_sum` > 0 AS INT64) + CAST(`sales___cost_sum` > 0 AS INT64) IS NULL\n AND CAST(`sales___revenue_sum` > 0 AS INT64) + CAST(`sales___cost_sum` > 0 AS INT64) <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY `_cp_reset_sales___x`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___x`\n FROM cp_reset_x\n)\nSELECT\n `sales___ordered_at`,\n `sales___x`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n `sales___x`\n FROM cp_value_x\n) AS _outer", + "cp/boolean_numeric::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 SUM(sales.cost) AS `sales___cost_sum`\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), cp_prev_x AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___x`\n FROM base\n), cp_reset_x AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n SUM(\n CASE\n WHEN NOT CAST(`sales___revenue_sum` > 0 AS INT64) + CAST(`sales___cost_sum` > 0 AS INT64) IS NULL\n AND CAST(`sales___revenue_sum` > 0 AS INT64) + CAST(`sales___cost_sum` > 0 AS INT64) <> 0\n AND CAST(`_cp_prev_sales___x` AS DATETIME) = DATETIME_ADD(CAST(`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___x`\n FROM cp_prev_x\n), cp_value_x AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n CASE\n WHEN NOT CAST(`sales___revenue_sum` > 0 AS INT64) + CAST(`sales___cost_sum` > 0 AS INT64) IS NULL\n AND CAST(`sales___revenue_sum` > 0 AS INT64) + CAST(`sales___cost_sum` > 0 AS INT64) <> 0\n THEN SUM(\n CASE\n WHEN NOT CAST(`sales___revenue_sum` > 0 AS INT64) + CAST(`sales___cost_sum` > 0 AS INT64) IS NULL\n AND CAST(`sales___revenue_sum` > 0 AS INT64) + CAST(`sales___cost_sum` > 0 AS INT64) <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY `_cp_reset_sales___x`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___x`\n FROM cp_reset_x\n)\nSELECT\n `sales___ordered_at`,\n `sales___x`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n `sales___x`\n FROM cp_value_x\n) AS _outer", "cp/boolean_numeric::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 SUM(sales.cost) AS \"sales.cost_sum\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), cp_prev_x AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.x\"\n FROM base\n), cp_reset_x AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n SUM(\n CASE\n WHEN NOT CAST(\"sales.revenue_sum\" > 0 AS INT) + CAST(\"sales.cost_sum\" > 0 AS INT) IS NULL\n AND CAST(\"sales.revenue_sum\" > 0 AS INT) + CAST(\"sales.cost_sum\" > 0 AS INT) <> 0\n AND \"_cp_prev_sales.x\" = \"sales.ordered_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.x\"\n FROM cp_prev_x\n), cp_value_x AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n CASE\n WHEN NOT CAST(\"sales.revenue_sum\" > 0 AS INT) + CAST(\"sales.cost_sum\" > 0 AS INT) IS NULL\n AND CAST(\"sales.revenue_sum\" > 0 AS INT) + CAST(\"sales.cost_sum\" > 0 AS INT) <> 0\n THEN SUM(\n CASE\n WHEN NOT CAST(\"sales.revenue_sum\" > 0 AS INT) + CAST(\"sales.cost_sum\" > 0 AS INT) IS NULL\n AND CAST(\"sales.revenue_sum\" > 0 AS INT) + CAST(\"sales.cost_sum\" > 0 AS INT) <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_sales.x\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.x\"\n FROM cp_reset_x\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.x\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n \"sales.x\"\n FROM cp_value_x\n) AS _outer", "cp/boolean_numeric::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 SUM(sales.cost) AS \"sales.cost_sum\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), cp_prev_x AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.x\"\n FROM base\n), cp_reset_x AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n SUM(\n CASE\n WHEN NOT CAST(\"sales.revenue_sum\" > 0 AS INT) + CAST(\"sales.cost_sum\" > 0 AS INT) IS NULL\n AND CAST(\"sales.revenue_sum\" > 0 AS INT) + CAST(\"sales.cost_sum\" > 0 AS INT) <> 0\n AND \"_cp_prev_sales.x\" = \"sales.ordered_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.x\"\n FROM cp_prev_x\n), cp_value_x AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n CASE\n WHEN NOT CAST(\"sales.revenue_sum\" > 0 AS INT) + CAST(\"sales.cost_sum\" > 0 AS INT) IS NULL\n AND CAST(\"sales.revenue_sum\" > 0 AS INT) + CAST(\"sales.cost_sum\" > 0 AS INT) <> 0\n THEN SUM(\n CASE\n WHEN NOT CAST(\"sales.revenue_sum\" > 0 AS INT) + CAST(\"sales.cost_sum\" > 0 AS INT) IS NULL\n AND CAST(\"sales.revenue_sum\" > 0 AS INT) + CAST(\"sales.cost_sum\" > 0 AS INT) <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_sales.x\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.x\"\n FROM cp_reset_x\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.x\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n \"sales.x\"\n FROM cp_value_x\n) AS _outer", "cp/boolean_numeric::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\",\n SUM(sales.cost) AS \"sales.cost_sum\"\n FROM sales AS sales\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), cp_prev_x AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.x\"\n FROM base\n), cp_reset_x AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n SUM(\n CASE\n WHEN NOT CAST(\"sales.revenue_sum\" > 0 AS INTEGER) + CAST(\"sales.cost_sum\" > 0 AS INTEGER) IS NULL\n AND CAST(\"sales.revenue_sum\" > 0 AS INTEGER) + CAST(\"sales.cost_sum\" > 0 AS INTEGER) <> 0\n AND \"_cp_prev_sales.x\" = SLAYER_DATE_ADD(\"sales.ordered_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.x\"\n FROM cp_prev_x\n), cp_value_x AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n CASE\n WHEN NOT CAST(\"sales.revenue_sum\" > 0 AS INTEGER) + CAST(\"sales.cost_sum\" > 0 AS INTEGER) IS NULL\n AND CAST(\"sales.revenue_sum\" > 0 AS INTEGER) + CAST(\"sales.cost_sum\" > 0 AS INTEGER) <> 0\n THEN SUM(\n CASE\n WHEN NOT CAST(\"sales.revenue_sum\" > 0 AS INTEGER) + CAST(\"sales.cost_sum\" > 0 AS INTEGER) IS NULL\n AND CAST(\"sales.revenue_sum\" > 0 AS INTEGER) + CAST(\"sales.cost_sum\" > 0 AS INTEGER) <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_sales.x\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.x\"\n FROM cp_reset_x\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.x\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n \"sales.x\"\n FROM cp_value_x\n) AS _outer", "cp/boolean_numeric::tsql": "WITH base AS (\n SELECT\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at],\n SUM(sales.revenue) AS [sales___revenue_sum],\n SUM(sales.cost) AS [sales___cost_sum]\n FROM sales AS sales\n GROUP BY\n DATETRUNC(month, sales.ordered_at)\n), cp_prev_x AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales___cost_sum] AS [sales___cost_sum],\n LAG([sales___ordered_at]) OVER (ORDER BY [sales___ordered_at]) AS [_cp_prev_sales___x]\n FROM base\n), cp_reset_x AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales___cost_sum] AS [sales___cost_sum],\n SUM(\n CASE\n WHEN NOT CAST(CAST(CASE\n WHEN [sales___revenue_sum] > 0\n THEN 1\n WHEN NOT (\n [sales___revenue_sum] > 0\n )\n THEN 0\n END AS BIT) AS INTEGER) + CAST(CAST(CASE WHEN [sales___cost_sum] > 0 THEN 1 WHEN NOT (\n [sales___cost_sum] > 0\n ) THEN 0 END AS BIT) AS INTEGER) IS NULL\n AND CAST(CAST(CASE\n WHEN [sales___revenue_sum] > 0\n THEN 1\n WHEN NOT (\n [sales___revenue_sum] > 0\n )\n THEN 0\n END AS BIT) AS INTEGER) + CAST(CAST(CASE WHEN [sales___cost_sum] > 0 THEN 1 WHEN NOT (\n [sales___cost_sum] > 0\n ) THEN 0 END AS BIT) AS INTEGER) <> 0\n AND [_cp_prev_sales___x] = DATEADD(MONTH, -1, [sales___ordered_at])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [sales___ordered_at] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_sales___x]\n FROM cp_prev_x\n), cp_value_x AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales___cost_sum] AS [sales___cost_sum],\n CASE\n WHEN NOT CAST(CAST(CASE\n WHEN [sales___revenue_sum] > 0\n THEN 1\n WHEN NOT (\n [sales___revenue_sum] > 0\n )\n THEN 0\n END AS BIT) AS INTEGER) + CAST(CAST(CASE WHEN [sales___cost_sum] > 0 THEN 1 WHEN NOT (\n [sales___cost_sum] > 0\n ) THEN 0 END AS BIT) AS INTEGER) IS NULL\n AND CAST(CAST(CASE\n WHEN [sales___revenue_sum] > 0\n THEN 1\n WHEN NOT (\n [sales___revenue_sum] > 0\n )\n THEN 0\n END AS BIT) AS INTEGER) + CAST(CAST(CASE WHEN [sales___cost_sum] > 0 THEN 1 WHEN NOT (\n [sales___cost_sum] > 0\n ) THEN 0 END AS BIT) AS INTEGER) <> 0\n THEN SUM(\n CASE\n WHEN NOT CAST(CAST(CASE\n WHEN [sales___revenue_sum] > 0\n THEN 1\n WHEN NOT (\n [sales___revenue_sum] > 0\n )\n THEN 0\n END AS BIT) AS INTEGER) + CAST(CAST(CASE WHEN [sales___cost_sum] > 0 THEN 1 WHEN NOT (\n [sales___cost_sum] > 0\n ) THEN 0 END AS BIT) AS INTEGER) IS NULL\n AND CAST(CAST(CASE\n WHEN [sales___revenue_sum] > 0\n THEN 1\n WHEN NOT (\n [sales___revenue_sum] > 0\n )\n THEN 0\n END AS BIT) AS INTEGER) + CAST(CAST(CASE WHEN [sales___cost_sum] > 0 THEN 1 WHEN NOT (\n [sales___cost_sum] > 0\n ) THEN 0 END AS BIT) AS INTEGER) <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY [_cp_reset_sales___x]\n ORDER BY [sales___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [sales___x]\n FROM cp_reset_x\n)\nSELECT\n [sales___ordered_at],\n [sales___x]\nFROM (\n SELECT\n [sales___ordered_at],\n [sales___revenue_sum],\n [sales___cost_sum],\n [sales___x]\n FROM cp_value_x\n) AS _outer", - "cp/change_gt_anchor::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__time_shift_inner AS (\n SELECT\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`,\n CAST(SUM(sales.revenue) AS FLOAT64) AS `sales___revenue_sum`\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), sjoin__time_shift_inner AS (\n SELECT\n base.`sales___ordered_at`,\n base.`sales___revenue_sum`,\n shifted__time_shift_inner.`sales___revenue_sum` AS `sales____time_shift_inner`\n FROM base\n LEFT JOIN shifted__time_shift_inner\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__time_shift_inner.`sales___ordered_at` AS TIMESTAMP)\n), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____time_shift_inner`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM sjoin__time_shift_inner\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____time_shift_inner`,\n SUM(\n CASE\n WHEN `sales___revenue_sum` - `sales____time_shift_inner` > 0\n AND CAST(`_cp_prev_sales___streak` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____time_shift_inner`,\n CASE\n WHEN `sales___revenue_sum` - `sales____time_shift_inner` > 0\n THEN SUM(CASE WHEN `sales___revenue_sum` - `sales____time_shift_inner` > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____time_shift_inner`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", + "cp/change_gt_anchor::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__time_shift_inner AS (\n SELECT\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`,\n CAST(SUM(sales.revenue) AS FLOAT64) AS `sales___revenue_sum`\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), sjoin__time_shift_inner AS (\n SELECT\n base.`sales___ordered_at`,\n base.`sales___revenue_sum`,\n shifted__time_shift_inner.`sales___revenue_sum` AS `sales____time_shift_inner`\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON DATETIME_ADD(CAST(base.`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`sales___ordered_at` AS DATETIME)\n), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____time_shift_inner`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM sjoin__time_shift_inner\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____time_shift_inner`,\n SUM(\n CASE\n WHEN `sales___revenue_sum` - `sales____time_shift_inner` > 0\n AND CAST(`_cp_prev_sales___streak` AS DATETIME) = DATETIME_ADD(CAST(`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____time_shift_inner`,\n CASE\n WHEN `sales___revenue_sum` - `sales____time_shift_inner` > 0\n THEN SUM(CASE WHEN `sales___revenue_sum` - `sales____time_shift_inner` > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____time_shift_inner`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", "cp/change_gt_anchor::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__time_shift_inner AS (\n SELECT\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n CAST(SUM(sales.revenue) AS DOUBLE) AS \"sales.revenue_sum\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n shifted__time_shift_inner.\"sales.revenue_sum\" AS \"sales._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"sales.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted__time_shift_inner.\"sales.ordered_at\"\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._time_shift_inner\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM sjoin__time_shift_inner\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._time_shift_inner\",\n SUM(\n CASE\n WHEN \"sales.revenue_sum\" - \"sales._time_shift_inner\" > 0\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._time_shift_inner\",\n CASE\n WHEN \"sales.revenue_sum\" - \"sales._time_shift_inner\" > 0\n THEN SUM(CASE WHEN \"sales.revenue_sum\" - \"sales._time_shift_inner\" > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._time_shift_inner\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/change_gt_anchor::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__time_shift_inner AS (\n SELECT\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\",\n CAST(SUM(sales.revenue) AS DOUBLE PRECISION) AS \"sales.revenue_sum\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n shifted__time_shift_inner.\"sales.revenue_sum\" AS \"sales._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"sales.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted__time_shift_inner.\"sales.ordered_at\"\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._time_shift_inner\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM sjoin__time_shift_inner\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._time_shift_inner\",\n SUM(\n CASE\n WHEN \"sales.revenue_sum\" - \"sales._time_shift_inner\" > 0\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._time_shift_inner\",\n CASE\n WHEN \"sales.revenue_sum\" - \"sales._time_shift_inner\" > 0\n THEN SUM(CASE WHEN \"sales.revenue_sum\" - \"sales._time_shift_inner\" > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._time_shift_inner\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/change_gt_anchor::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\"\n FROM sales AS sales\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n CAST(SUM(sales.revenue) AS REAL) AS \"sales.revenue_sum\"\n FROM sales AS sales\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n shifted__time_shift_inner.\"sales.revenue_sum\" AS \"sales._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON SLAYER_DATE_ADD(base.\"sales.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"sales.ordered_at\"\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._time_shift_inner\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM sjoin__time_shift_inner\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._time_shift_inner\",\n SUM(\n CASE\n WHEN \"sales.revenue_sum\" - \"sales._time_shift_inner\" > 0\n AND \"_cp_prev_sales.streak\" = SLAYER_DATE_ADD(\"sales.ordered_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._time_shift_inner\",\n CASE\n WHEN \"sales.revenue_sum\" - \"sales._time_shift_inner\" > 0\n THEN SUM(CASE WHEN \"sales.revenue_sum\" - \"sales._time_shift_inner\" > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._time_shift_inner\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/change_gt_anchor::tsql": "WITH base AS (\n SELECT\n DATETRUNC(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 DATETRUNC(month, sales.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at],\n CAST(SUM(sales.revenue) AS FLOAT) AS [sales___revenue_sum]\n FROM sales AS sales\n GROUP BY\n DATETRUNC(month, sales.ordered_at)\n), sjoin__time_shift_inner AS (\n SELECT\n base.[sales___ordered_at] AS [sales___ordered_at],\n base.[sales___revenue_sum] AS [sales___revenue_sum],\n shifted__time_shift_inner.[sales___revenue_sum] AS [sales____time_shift_inner]\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON (\n (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) = shifted__time_shift_inner.[sales___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[sales___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[sales___ordered_at] IS NULL\n )\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), cp_prev_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales____time_shift_inner] AS [sales____time_shift_inner],\n LAG([sales___ordered_at]) OVER (ORDER BY [sales___ordered_at]) AS [_cp_prev_sales___streak]\n FROM sjoin__time_shift_inner\n), cp_reset_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales____time_shift_inner] AS [sales____time_shift_inner],\n SUM(\n CASE\n WHEN [sales___revenue_sum] - [sales____time_shift_inner] > 0\n AND [_cp_prev_sales___streak] = DATEADD(MONTH, -1, [sales___ordered_at])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [sales___ordered_at] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_sales___streak]\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales____time_shift_inner] AS [sales____time_shift_inner],\n CASE\n WHEN [sales___revenue_sum] - [sales____time_shift_inner] > 0\n THEN SUM(CASE WHEN [sales___revenue_sum] - [sales____time_shift_inner] > 0 THEN 1 ELSE 0 END) OVER (\n PARTITION BY [_cp_reset_sales___streak]\n ORDER BY [sales___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [sales___streak]\n FROM cp_reset_streak\n)\nSELECT\n [sales___ordered_at],\n [sales___streak]\nFROM (\n SELECT\n [sales___ordered_at],\n [sales___revenue_sum],\n [sales____time_shift_inner],\n [sales___streak]\n FROM cp_value_streak\n) AS _outer", - "cp/iif::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), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n SUM(\n CASE\n WHEN NOT CASE WHEN `sales___revenue_sum` > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN `sales___revenue_sum` > 0 THEN 1 ELSE 0 END <> 0\n AND CAST(`_cp_prev_sales___streak` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n CASE\n WHEN NOT CASE WHEN `sales___revenue_sum` > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN `sales___revenue_sum` > 0 THEN 1 ELSE 0 END <> 0\n THEN SUM(\n CASE\n WHEN NOT CASE WHEN `sales___revenue_sum` > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN `sales___revenue_sum` > 0 THEN 1 ELSE 0 END <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", + "cp/iif::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), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n SUM(\n CASE\n WHEN NOT CASE WHEN `sales___revenue_sum` > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN `sales___revenue_sum` > 0 THEN 1 ELSE 0 END <> 0\n AND CAST(`_cp_prev_sales___streak` AS DATETIME) = DATETIME_ADD(CAST(`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n CASE\n WHEN NOT CASE WHEN `sales___revenue_sum` > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN `sales___revenue_sum` > 0 THEN 1 ELSE 0 END <> 0\n THEN SUM(\n CASE\n WHEN NOT CASE WHEN `sales___revenue_sum` > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN `sales___revenue_sum` > 0 THEN 1 ELSE 0 END <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", "cp/iif::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), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\n CASE\n WHEN NOT CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END <> 0\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n CASE\n WHEN NOT CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END <> 0\n THEN SUM(\n CASE\n WHEN NOT CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/iif::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), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\n CASE\n WHEN NOT CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END <> 0\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n CASE\n WHEN NOT CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END <> 0\n THEN SUM(\n CASE\n WHEN NOT CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/iif::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\"\n FROM sales AS sales\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\n CASE\n WHEN NOT CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END <> 0\n AND \"_cp_prev_sales.streak\" = SLAYER_DATE_ADD(\"sales.ordered_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n CASE\n WHEN NOT CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END <> 0\n THEN SUM(\n CASE\n WHEN NOT CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/iif::tsql": "WITH base AS (\n SELECT\n DATETRUNC(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 DATETRUNC(month, sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n LAG([sales___ordered_at]) OVER (ORDER BY [sales___ordered_at]) AS [_cp_prev_sales___streak]\n FROM base\n), cp_reset_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n SUM(\n CASE\n WHEN NOT CASE WHEN [sales___revenue_sum] > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN [sales___revenue_sum] > 0 THEN 1 ELSE 0 END <> 0\n AND [_cp_prev_sales___streak] = DATEADD(MONTH, -1, [sales___ordered_at])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [sales___ordered_at] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_sales___streak]\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n CASE\n WHEN NOT CASE WHEN [sales___revenue_sum] > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN [sales___revenue_sum] > 0 THEN 1 ELSE 0 END <> 0\n THEN SUM(\n CASE\n WHEN NOT CASE WHEN [sales___revenue_sum] > 0 THEN 1 ELSE 0 END IS NULL\n AND CASE WHEN [sales___revenue_sum] > 0 THEN 1 ELSE 0 END <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY [_cp_reset_sales___streak]\n ORDER BY [sales___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [sales___streak]\n FROM cp_reset_streak\n)\nSELECT\n [sales___ordered_at],\n [sales___streak]\nFROM (\n SELECT\n [sales___ordered_at],\n [sales___revenue_sum],\n [sales___streak]\n FROM cp_value_streak\n) AS _outer", - "cp/in::bigquery": "WITH base AS (\n SELECT\n sales.store AS `sales___store`,\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC(sales.ordered_at, MONTH)\n), cp_prev_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n LAG(`sales___ordered_at`) OVER (PARTITION BY `sales___store` ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n SUM(\n CASE\n WHEN `sales___store` IN ('A', 'B')\n AND CAST(`_cp_prev_sales___streak` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY `sales___store`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n CASE\n WHEN `sales___store` IN ('A', 'B')\n THEN SUM(CASE WHEN `sales___store` IN ('A', 'B') THEN 1 ELSE 0 END) OVER (\n PARTITION BY `sales___store`, `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", + "cp/in::bigquery": "WITH base AS (\n SELECT\n sales.store AS `sales___store`,\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC(sales.ordered_at, MONTH)\n), cp_prev_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n LAG(`sales___ordered_at`) OVER (PARTITION BY `sales___store` ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n SUM(\n CASE\n WHEN `sales___store` IN ('A', 'B')\n AND CAST(`_cp_prev_sales___streak` AS DATETIME) = DATETIME_ADD(CAST(`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY `sales___store`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n CASE\n WHEN `sales___store` IN ('A', 'B')\n THEN SUM(CASE WHEN `sales___store` IN ('A', 'B') THEN 1 ELSE 0 END) OVER (\n PARTITION BY `sales___store`, `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", "cp/in::duckdb": "WITH base AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n LAG(\"sales.ordered_at\") OVER (PARTITION BY \"sales.store\" ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n SUM(\n CASE\n WHEN \"sales.store\" IN ('A', 'B')\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY \"sales.store\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n CASE\n WHEN \"sales.store\" IN ('A', 'B')\n THEN SUM(CASE WHEN \"sales.store\" IN ('A', 'B') THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"sales.store\", \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/in::postgres": "WITH base AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n LAG(\"sales.ordered_at\") OVER (PARTITION BY \"sales.store\" ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n SUM(\n CASE\n WHEN \"sales.store\" IN ('A', 'B')\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY \"sales.store\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n CASE\n WHEN \"sales.store\" IN ('A', 'B')\n THEN SUM(CASE WHEN \"sales.store\" IN ('A', 'B') THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"sales.store\", \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/in::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 FROM sales AS sales\n GROUP BY\n sales.store,\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n LAG(\"sales.ordered_at\") OVER (PARTITION BY \"sales.store\" ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n SUM(\n CASE\n WHEN \"sales.store\" IN ('A', 'B')\n AND \"_cp_prev_sales.streak\" = SLAYER_DATE_ADD(\"sales.ordered_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY \"sales.store\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n CASE\n WHEN \"sales.store\" IN ('A', 'B')\n THEN SUM(CASE WHEN \"sales.store\" IN ('A', 'B') THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"sales.store\", \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/in::tsql": "WITH base AS (\n SELECT\n sales.store AS [sales___store],\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at]\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATETRUNC(month, sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n [sales___store] AS [sales___store],\n [sales___ordered_at] AS [sales___ordered_at],\n LAG([sales___ordered_at]) OVER (PARTITION BY [sales___store] ORDER BY [sales___ordered_at]) AS [_cp_prev_sales___streak]\n FROM base\n), cp_reset_streak AS (\n SELECT\n [sales___store] AS [sales___store],\n [sales___ordered_at] AS [sales___ordered_at],\n SUM(\n CASE\n WHEN [sales___store] IN ('A', 'B')\n AND [_cp_prev_sales___streak] = DATEADD(MONTH, -1, [sales___ordered_at])\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY [sales___store]\n ORDER BY [sales___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS [_cp_reset_sales___streak]\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n [sales___store] AS [sales___store],\n [sales___ordered_at] AS [sales___ordered_at],\n CASE\n WHEN [sales___store] IN ('A', 'B')\n THEN SUM(CASE WHEN [sales___store] IN ('A', 'B') THEN 1 ELSE 0 END) OVER (\n PARTITION BY [sales___store], [_cp_reset_sales___streak]\n ORDER BY [sales___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [sales___streak]\n FROM cp_reset_streak\n)\nSELECT\n [sales___store],\n [sales___ordered_at],\n [sales___streak]\nFROM (\n SELECT\n [sales___store],\n [sales___ordered_at],\n [sales___streak]\n FROM cp_value_streak\n) AS _outer", - "cp/is_not_null_and::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 SUM(sales.cost) AS `sales___cost_sum`\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n `sales___cost_sum`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n `sales___cost_sum`,\n SUM(\n CASE\n WHEN NOT `sales___hi_rev_sum` IS NULL\n AND `sales___cost_sum` > 0\n AND CAST(`_cp_prev_sales___streak` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n `sales___cost_sum`,\n CASE\n WHEN NOT `sales___hi_rev_sum` IS NULL AND `sales___cost_sum` > 0\n THEN SUM(\n CASE WHEN NOT `sales___hi_rev_sum` IS NULL AND `sales___cost_sum` > 0 THEN 1 ELSE 0 END\n ) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n `sales___cost_sum`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", + "cp/is_not_null_and::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 SUM(sales.cost) AS `sales___cost_sum`\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n `sales___cost_sum`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n `sales___cost_sum`,\n SUM(\n CASE\n WHEN NOT `sales___hi_rev_sum` IS NULL\n AND `sales___cost_sum` > 0\n AND CAST(`_cp_prev_sales___streak` AS DATETIME) = DATETIME_ADD(CAST(`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n `sales___cost_sum`,\n CASE\n WHEN NOT `sales___hi_rev_sum` IS NULL AND `sales___cost_sum` > 0\n THEN SUM(\n CASE WHEN NOT `sales___hi_rev_sum` IS NULL AND `sales___cost_sum` > 0 THEN 1 ELSE 0 END\n ) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n `sales___cost_sum`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", "cp/is_not_null_and::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 SUM(sales.cost) AS \"sales.cost_sum\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.cost_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.cost_sum\",\n SUM(\n CASE\n WHEN NOT \"sales.hi_rev_sum\" IS NULL\n AND \"sales.cost_sum\" > 0\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.cost_sum\",\n CASE\n WHEN NOT \"sales.hi_rev_sum\" IS NULL AND \"sales.cost_sum\" > 0\n THEN SUM(\n CASE WHEN NOT \"sales.hi_rev_sum\" IS NULL AND \"sales.cost_sum\" > 0 THEN 1 ELSE 0 END\n ) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.cost_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/is_not_null_and::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 SUM(sales.cost) AS \"sales.cost_sum\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.cost_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.cost_sum\",\n SUM(\n CASE\n WHEN NOT \"sales.hi_rev_sum\" IS NULL\n AND \"sales.cost_sum\" > 0\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.cost_sum\",\n CASE\n WHEN NOT \"sales.hi_rev_sum\" IS NULL AND \"sales.cost_sum\" > 0\n THEN SUM(\n CASE WHEN NOT \"sales.hi_rev_sum\" IS NULL AND \"sales.cost_sum\" > 0 THEN 1 ELSE 0 END\n ) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.cost_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/is_not_null_and::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(CASE WHEN sales.revenue > 15 THEN sales.revenue END) AS \"sales.hi_rev_sum\",\n SUM(sales.cost) AS \"sales.cost_sum\"\n FROM sales AS sales\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.cost_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.cost_sum\",\n SUM(\n CASE\n WHEN NOT \"sales.hi_rev_sum\" IS NULL\n AND \"sales.cost_sum\" > 0\n AND \"_cp_prev_sales.streak\" = SLAYER_DATE_ADD(\"sales.ordered_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.cost_sum\",\n CASE\n WHEN NOT \"sales.hi_rev_sum\" IS NULL AND \"sales.cost_sum\" > 0\n THEN SUM(\n CASE WHEN NOT \"sales.hi_rev_sum\" IS NULL AND \"sales.cost_sum\" > 0 THEN 1 ELSE 0 END\n ) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.cost_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/is_not_null_and::tsql": "WITH base AS (\n SELECT\n DATETRUNC(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 SUM(sales.cost) AS [sales___cost_sum]\n FROM sales AS sales\n GROUP BY\n DATETRUNC(month, sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___hi_rev_sum] AS [sales___hi_rev_sum],\n [sales___cost_sum] AS [sales___cost_sum],\n LAG([sales___ordered_at]) OVER (ORDER BY [sales___ordered_at]) AS [_cp_prev_sales___streak]\n FROM base\n), cp_reset_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___hi_rev_sum] AS [sales___hi_rev_sum],\n [sales___cost_sum] AS [sales___cost_sum],\n SUM(\n CASE\n WHEN NOT [sales___hi_rev_sum] IS NULL\n AND [sales___cost_sum] > 0\n AND [_cp_prev_sales___streak] = DATEADD(MONTH, -1, [sales___ordered_at])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [sales___ordered_at] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_sales___streak]\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___hi_rev_sum] AS [sales___hi_rev_sum],\n [sales___cost_sum] AS [sales___cost_sum],\n CASE\n WHEN NOT [sales___hi_rev_sum] IS NULL AND [sales___cost_sum] > 0\n THEN SUM(\n CASE WHEN NOT [sales___hi_rev_sum] IS NULL AND [sales___cost_sum] > 0 THEN 1 ELSE 0 END\n ) OVER (\n PARTITION BY [_cp_reset_sales___streak]\n ORDER BY [sales___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [sales___streak]\n FROM cp_reset_streak\n)\nSELECT\n [sales___ordered_at],\n [sales___streak]\nFROM (\n SELECT\n [sales___ordered_at],\n [sales___hi_rev_sum],\n [sales___cost_sum],\n [sales___streak]\n FROM cp_value_streak\n) AS _outer", - "cp/is_null_top::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), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n SUM(\n CASE\n WHEN `sales___hi_rev_sum` IS NULL\n AND CAST(`_cp_prev_sales___streak` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n CASE\n WHEN `sales___hi_rev_sum` IS NULL\n THEN SUM(CASE WHEN `sales___hi_rev_sum` IS NULL THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", + "cp/is_null_top::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), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n SUM(\n CASE\n WHEN `sales___hi_rev_sum` IS NULL\n AND CAST(`_cp_prev_sales___streak` AS DATETIME) = DATETIME_ADD(CAST(`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n CASE\n WHEN `sales___hi_rev_sum` IS NULL\n THEN SUM(CASE WHEN `sales___hi_rev_sum` IS NULL THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___hi_rev_sum`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", "cp/is_null_top::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), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n SUM(\n CASE\n WHEN \"sales.hi_rev_sum\" IS NULL\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n CASE\n WHEN \"sales.hi_rev_sum\" IS NULL\n THEN SUM(CASE WHEN \"sales.hi_rev_sum\" IS NULL THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/is_null_top::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), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n SUM(\n CASE\n WHEN \"sales.hi_rev_sum\" IS NULL\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n CASE\n WHEN \"sales.hi_rev_sum\" IS NULL\n THEN SUM(CASE WHEN \"sales.hi_rev_sum\" IS NULL THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/is_null_top::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', 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 STRFTIME('%Y-%m-01', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n SUM(\n CASE\n WHEN \"sales.hi_rev_sum\" IS NULL\n AND \"_cp_prev_sales.streak\" = SLAYER_DATE_ADD(\"sales.ordered_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n CASE\n WHEN \"sales.hi_rev_sum\" IS NULL\n THEN SUM(CASE WHEN \"sales.hi_rev_sum\" IS NULL THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.hi_rev_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/is_null_top::tsql": "WITH base AS (\n SELECT\n DATETRUNC(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 DATETRUNC(month, sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___hi_rev_sum] AS [sales___hi_rev_sum],\n LAG([sales___ordered_at]) OVER (ORDER BY [sales___ordered_at]) AS [_cp_prev_sales___streak]\n FROM base\n), cp_reset_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___hi_rev_sum] AS [sales___hi_rev_sum],\n SUM(\n CASE\n WHEN [sales___hi_rev_sum] IS NULL\n AND [_cp_prev_sales___streak] = DATEADD(MONTH, -1, [sales___ordered_at])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [sales___ordered_at] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_sales___streak]\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___hi_rev_sum] AS [sales___hi_rev_sum],\n CASE\n WHEN [sales___hi_rev_sum] IS NULL\n THEN SUM(CASE WHEN [sales___hi_rev_sum] IS NULL THEN 1 ELSE 0 END) OVER (\n PARTITION BY [_cp_reset_sales___streak]\n ORDER BY [sales___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [sales___streak]\n FROM cp_reset_streak\n)\nSELECT\n [sales___ordered_at],\n [sales___streak]\nFROM (\n SELECT\n [sales___ordered_at],\n [sales___hi_rev_sum],\n [sales___streak]\n FROM cp_value_streak\n) AS _outer", - "cp/negated_in::bigquery": "WITH base AS (\n SELECT\n sales.store AS `sales___store`,\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC(sales.ordered_at, MONTH)\n), cp_prev_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n LAG(`sales___ordered_at`) OVER (PARTITION BY `sales___store` ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n SUM(\n CASE\n WHEN NOT `sales___store` IN ('B', 'C')\n AND CAST(`_cp_prev_sales___streak` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY `sales___store`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n CASE\n WHEN NOT `sales___store` IN ('B', 'C')\n THEN SUM(CASE WHEN NOT `sales___store` IN ('B', 'C') THEN 1 ELSE 0 END) OVER (\n PARTITION BY `sales___store`, `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", + "cp/negated_in::bigquery": "WITH base AS (\n SELECT\n sales.store AS `sales___store`,\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC(sales.ordered_at, MONTH)\n), cp_prev_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n LAG(`sales___ordered_at`) OVER (PARTITION BY `sales___store` ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n SUM(\n CASE\n WHEN NOT `sales___store` IN ('B', 'C')\n AND CAST(`_cp_prev_sales___streak` AS DATETIME) = DATETIME_ADD(CAST(`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY `sales___store`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n CASE\n WHEN NOT `sales___store` IN ('B', 'C')\n THEN SUM(CASE WHEN NOT `sales___store` IN ('B', 'C') THEN 1 ELSE 0 END) OVER (\n PARTITION BY `sales___store`, `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", "cp/negated_in::duckdb": "WITH base AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n LAG(\"sales.ordered_at\") OVER (PARTITION BY \"sales.store\" ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n SUM(\n CASE\n WHEN NOT \"sales.store\" IN ('B', 'C')\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY \"sales.store\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n CASE\n WHEN NOT \"sales.store\" IN ('B', 'C')\n THEN SUM(CASE WHEN NOT \"sales.store\" IN ('B', 'C') THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"sales.store\", \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/negated_in::postgres": "WITH base AS (\n SELECT\n sales.store AS \"sales.store\",\n DATE_TRUNC('MONTH', sales.ordered_at) AS \"sales.ordered_at\"\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n LAG(\"sales.ordered_at\") OVER (PARTITION BY \"sales.store\" ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n SUM(\n CASE\n WHEN NOT \"sales.store\" IN ('B', 'C')\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY \"sales.store\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n CASE\n WHEN NOT \"sales.store\" IN ('B', 'C')\n THEN SUM(CASE WHEN NOT \"sales.store\" IN ('B', 'C') THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"sales.store\", \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/negated_in::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 FROM sales AS sales\n GROUP BY\n sales.store,\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n LAG(\"sales.ordered_at\") OVER (PARTITION BY \"sales.store\" ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n SUM(\n CASE\n WHEN NOT \"sales.store\" IN ('B', 'C')\n AND \"_cp_prev_sales.streak\" = SLAYER_DATE_ADD(\"sales.ordered_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY \"sales.store\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n CASE\n WHEN NOT \"sales.store\" IN ('B', 'C')\n THEN SUM(CASE WHEN NOT \"sales.store\" IN ('B', 'C') THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"sales.store\", \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/negated_in::tsql": "WITH base AS (\n SELECT\n sales.store AS [sales___store],\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at]\n FROM sales AS sales\n GROUP BY\n sales.store,\n DATETRUNC(month, sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n [sales___store] AS [sales___store],\n [sales___ordered_at] AS [sales___ordered_at],\n LAG([sales___ordered_at]) OVER (PARTITION BY [sales___store] ORDER BY [sales___ordered_at]) AS [_cp_prev_sales___streak]\n FROM base\n), cp_reset_streak AS (\n SELECT\n [sales___store] AS [sales___store],\n [sales___ordered_at] AS [sales___ordered_at],\n SUM(\n CASE\n WHEN NOT [sales___store] IN ('B', 'C')\n AND [_cp_prev_sales___streak] = DATEADD(MONTH, -1, [sales___ordered_at])\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY [sales___store]\n ORDER BY [sales___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS [_cp_reset_sales___streak]\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n [sales___store] AS [sales___store],\n [sales___ordered_at] AS [sales___ordered_at],\n CASE\n WHEN NOT [sales___store] IN ('B', 'C')\n THEN SUM(CASE WHEN NOT [sales___store] IN ('B', 'C') THEN 1 ELSE 0 END) OVER (\n PARTITION BY [sales___store], [_cp_reset_sales___streak]\n ORDER BY [sales___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [sales___streak]\n FROM cp_reset_streak\n)\nSELECT\n [sales___store],\n [sales___ordered_at],\n [sales___streak]\nFROM (\n SELECT\n [sales___store],\n [sales___ordered_at],\n [sales___streak]\n FROM cp_value_streak\n) AS _outer", - "cp/nested_in_and::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 FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC(sales.ordered_at, MONTH)\n), cp_prev_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n LAG(`sales___ordered_at`) OVER (PARTITION BY `sales___store` ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n SUM(\n CASE\n WHEN `sales___store` IN ('A', 'C')\n AND `sales___revenue_sum` > 0\n AND CAST(`_cp_prev_sales___streak` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY `sales___store`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n CASE\n WHEN `sales___store` IN ('A', 'C') AND `sales___revenue_sum` > 0\n THEN SUM(\n CASE WHEN `sales___store` IN ('A', 'C') AND `sales___revenue_sum` > 0 THEN 1 ELSE 0 END\n ) OVER (\n PARTITION BY `sales___store`, `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", + "cp/nested_in_and::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 FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC(sales.ordered_at, MONTH)\n), cp_prev_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n LAG(`sales___ordered_at`) OVER (PARTITION BY `sales___store` ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n SUM(\n CASE\n WHEN `sales___store` IN ('A', 'C')\n AND `sales___revenue_sum` > 0\n AND CAST(`_cp_prev_sales___streak` AS DATETIME) = DATETIME_ADD(CAST(`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY `sales___store`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n CASE\n WHEN `sales___store` IN ('A', 'C') AND `sales___revenue_sum` > 0\n THEN SUM(\n CASE WHEN `sales___store` IN ('A', 'C') AND `sales___revenue_sum` > 0 THEN 1 ELSE 0 END\n ) OVER (\n PARTITION BY `sales___store`, `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", "cp/nested_in_and::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 FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n LAG(\"sales.ordered_at\") OVER (PARTITION BY \"sales.store\" ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\n CASE\n WHEN \"sales.store\" IN ('A', 'C')\n AND \"sales.revenue_sum\" > 0\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY \"sales.store\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n CASE\n WHEN \"sales.store\" IN ('A', 'C') AND \"sales.revenue_sum\" > 0\n THEN SUM(\n CASE WHEN \"sales.store\" IN ('A', 'C') AND \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END\n ) OVER (\n PARTITION BY \"sales.store\", \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/nested_in_and::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 FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n LAG(\"sales.ordered_at\") OVER (PARTITION BY \"sales.store\" ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\n CASE\n WHEN \"sales.store\" IN ('A', 'C')\n AND \"sales.revenue_sum\" > 0\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY \"sales.store\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n CASE\n WHEN \"sales.store\" IN ('A', 'C') AND \"sales.revenue_sum\" > 0\n THEN SUM(\n CASE WHEN \"sales.store\" IN ('A', 'C') AND \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END\n ) OVER (\n PARTITION BY \"sales.store\", \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/nested_in_and::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 FROM sales AS sales\n GROUP BY\n sales.store,\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n LAG(\"sales.ordered_at\") OVER (PARTITION BY \"sales.store\" ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\n CASE\n WHEN \"sales.store\" IN ('A', 'C')\n AND \"sales.revenue_sum\" > 0\n AND \"_cp_prev_sales.streak\" = SLAYER_DATE_ADD(\"sales.ordered_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY \"sales.store\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n CASE\n WHEN \"sales.store\" IN ('A', 'C') AND \"sales.revenue_sum\" > 0\n THEN SUM(\n CASE WHEN \"sales.store\" IN ('A', 'C') AND \"sales.revenue_sum\" > 0 THEN 1 ELSE 0 END\n ) OVER (\n PARTITION BY \"sales.store\", \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/nested_in_and::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 FROM sales AS sales\n GROUP BY\n sales.store,\n DATETRUNC(month, sales.ordered_at)\n), cp_prev_streak 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 LAG([sales___ordered_at]) OVER (PARTITION BY [sales___store] ORDER BY [sales___ordered_at]) AS [_cp_prev_sales___streak]\n FROM base\n), cp_reset_streak 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 SUM(\n CASE\n WHEN [sales___store] IN ('A', 'C')\n AND [sales___revenue_sum] > 0\n AND [_cp_prev_sales___streak] = DATEADD(MONTH, -1, [sales___ordered_at])\n THEN 0\n ELSE 1\n END\n ) OVER (\n PARTITION BY [sales___store]\n ORDER BY [sales___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n ) AS [_cp_reset_sales___streak]\n FROM cp_prev_streak\n), cp_value_streak 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 CASE\n WHEN [sales___store] IN ('A', 'C') AND [sales___revenue_sum] > 0\n THEN SUM(\n CASE WHEN [sales___store] IN ('A', 'C') AND [sales___revenue_sum] > 0 THEN 1 ELSE 0 END\n ) OVER (\n PARTITION BY [sales___store], [_cp_reset_sales___streak]\n ORDER BY [sales___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [sales___streak]\n FROM cp_reset_streak\n)\nSELECT\n [sales___store],\n [sales___ordered_at],\n [sales___streak]\nFROM (\n SELECT\n [sales___store],\n [sales___ordered_at],\n [sales___revenue_sum],\n [sales___streak]\n FROM cp_value_streak\n) AS _outer", - "cp/not::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), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n SUM(\n CASE\n WHEN NOT `sales___revenue_sum` > 90\n AND CAST(`_cp_prev_sales___streak` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n CASE\n WHEN NOT `sales___revenue_sum` > 90\n THEN SUM(CASE WHEN NOT `sales___revenue_sum` > 90 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", + "cp/not::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), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n SUM(\n CASE\n WHEN NOT `sales___revenue_sum` > 90\n AND CAST(`_cp_prev_sales___streak` AS DATETIME) = DATETIME_ADD(CAST(`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n CASE\n WHEN NOT `sales___revenue_sum` > 90\n THEN SUM(CASE WHEN NOT `sales___revenue_sum` > 90 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", "cp/not::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), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\n CASE\n WHEN NOT \"sales.revenue_sum\" > 90\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n CASE\n WHEN NOT \"sales.revenue_sum\" > 90\n THEN SUM(CASE WHEN NOT \"sales.revenue_sum\" > 90 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/not::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), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\n CASE\n WHEN NOT \"sales.revenue_sum\" > 90\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n CASE\n WHEN NOT \"sales.revenue_sum\" > 90\n THEN SUM(CASE WHEN NOT \"sales.revenue_sum\" > 90 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/not::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\"\n FROM sales AS sales\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\n CASE\n WHEN NOT \"sales.revenue_sum\" > 90\n AND \"_cp_prev_sales.streak\" = SLAYER_DATE_ADD(\"sales.ordered_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n CASE\n WHEN NOT \"sales.revenue_sum\" > 90\n THEN SUM(CASE WHEN NOT \"sales.revenue_sum\" > 90 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/not::tsql": "WITH base AS (\n SELECT\n DATETRUNC(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 DATETRUNC(month, sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n LAG([sales___ordered_at]) OVER (ORDER BY [sales___ordered_at]) AS [_cp_prev_sales___streak]\n FROM base\n), cp_reset_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n SUM(\n CASE\n WHEN NOT [sales___revenue_sum] > 90\n AND [_cp_prev_sales___streak] = DATEADD(MONTH, -1, [sales___ordered_at])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [sales___ordered_at] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_sales___streak]\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n CASE\n WHEN NOT [sales___revenue_sum] > 90\n THEN SUM(CASE WHEN NOT [sales___revenue_sum] > 90 THEN 1 ELSE 0 END) OVER (\n PARTITION BY [_cp_reset_sales___streak]\n ORDER BY [sales___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [sales___streak]\n FROM cp_reset_streak\n)\nSELECT\n [sales___ordered_at],\n [sales___streak]\nFROM (\n SELECT\n [sales___ordered_at],\n [sales___revenue_sum],\n [sales___streak]\n FROM cp_value_streak\n) AS _outer", - "cp/numeric_delta::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 SUM(sales.cost) AS `sales___cost_sum`\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n SUM(\n CASE\n WHEN NOT `sales___revenue_sum` - `sales___cost_sum` IS NULL\n AND `sales___revenue_sum` - `sales___cost_sum` <> 0\n AND CAST(`_cp_prev_sales___streak` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n CASE\n WHEN NOT `sales___revenue_sum` - `sales___cost_sum` IS NULL\n AND `sales___revenue_sum` - `sales___cost_sum` <> 0\n THEN SUM(\n CASE\n WHEN NOT `sales___revenue_sum` - `sales___cost_sum` IS NULL\n AND `sales___revenue_sum` - `sales___cost_sum` <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", + "cp/numeric_delta::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 SUM(sales.cost) AS `sales___cost_sum`\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n SUM(\n CASE\n WHEN NOT `sales___revenue_sum` - `sales___cost_sum` IS NULL\n AND `sales___revenue_sum` - `sales___cost_sum` <> 0\n AND CAST(`_cp_prev_sales___streak` AS DATETIME) = DATETIME_ADD(CAST(`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n CASE\n WHEN NOT `sales___revenue_sum` - `sales___cost_sum` IS NULL\n AND `sales___revenue_sum` - `sales___cost_sum` <> 0\n THEN SUM(\n CASE\n WHEN NOT `sales___revenue_sum` - `sales___cost_sum` IS NULL\n AND `sales___revenue_sum` - `sales___cost_sum` <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", "cp/numeric_delta::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 SUM(sales.cost) AS \"sales.cost_sum\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n SUM(\n CASE\n WHEN NOT \"sales.revenue_sum\" - \"sales.cost_sum\" IS NULL\n AND \"sales.revenue_sum\" - \"sales.cost_sum\" <> 0\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n CASE\n WHEN NOT \"sales.revenue_sum\" - \"sales.cost_sum\" IS NULL\n AND \"sales.revenue_sum\" - \"sales.cost_sum\" <> 0\n THEN SUM(\n CASE\n WHEN NOT \"sales.revenue_sum\" - \"sales.cost_sum\" IS NULL\n AND \"sales.revenue_sum\" - \"sales.cost_sum\" <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/numeric_delta::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 SUM(sales.cost) AS \"sales.cost_sum\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n SUM(\n CASE\n WHEN NOT \"sales.revenue_sum\" - \"sales.cost_sum\" IS NULL\n AND \"sales.revenue_sum\" - \"sales.cost_sum\" <> 0\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n CASE\n WHEN NOT \"sales.revenue_sum\" - \"sales.cost_sum\" IS NULL\n AND \"sales.revenue_sum\" - \"sales.cost_sum\" <> 0\n THEN SUM(\n CASE\n WHEN NOT \"sales.revenue_sum\" - \"sales.cost_sum\" IS NULL\n AND \"sales.revenue_sum\" - \"sales.cost_sum\" <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/numeric_delta::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\",\n SUM(sales.cost) AS \"sales.cost_sum\"\n FROM sales AS sales\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n SUM(\n CASE\n WHEN NOT \"sales.revenue_sum\" - \"sales.cost_sum\" IS NULL\n AND \"sales.revenue_sum\" - \"sales.cost_sum\" <> 0\n AND \"_cp_prev_sales.streak\" = SLAYER_DATE_ADD(\"sales.ordered_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n CASE\n WHEN NOT \"sales.revenue_sum\" - \"sales.cost_sum\" IS NULL\n AND \"sales.revenue_sum\" - \"sales.cost_sum\" <> 0\n THEN SUM(\n CASE\n WHEN NOT \"sales.revenue_sum\" - \"sales.cost_sum\" IS NULL\n AND \"sales.revenue_sum\" - \"sales.cost_sum\" <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/numeric_delta::tsql": "WITH base AS (\n SELECT\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at],\n SUM(sales.revenue) AS [sales___revenue_sum],\n SUM(sales.cost) AS [sales___cost_sum]\n FROM sales AS sales\n GROUP BY\n DATETRUNC(month, sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales___cost_sum] AS [sales___cost_sum],\n LAG([sales___ordered_at]) OVER (ORDER BY [sales___ordered_at]) AS [_cp_prev_sales___streak]\n FROM base\n), cp_reset_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales___cost_sum] AS [sales___cost_sum],\n SUM(\n CASE\n WHEN NOT [sales___revenue_sum] - [sales___cost_sum] IS NULL\n AND [sales___revenue_sum] - [sales___cost_sum] <> 0\n AND [_cp_prev_sales___streak] = DATEADD(MONTH, -1, [sales___ordered_at])\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY [sales___ordered_at] ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS [_cp_reset_sales___streak]\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n [sales___cost_sum] AS [sales___cost_sum],\n CASE\n WHEN NOT [sales___revenue_sum] - [sales___cost_sum] IS NULL\n AND [sales___revenue_sum] - [sales___cost_sum] <> 0\n THEN SUM(\n CASE\n WHEN NOT [sales___revenue_sum] - [sales___cost_sum] IS NULL\n AND [sales___revenue_sum] - [sales___cost_sum] <> 0\n THEN 1\n ELSE 0\n END\n ) OVER (\n PARTITION BY [_cp_reset_sales___streak]\n ORDER BY [sales___ordered_at]\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS [sales___streak]\n FROM cp_reset_streak\n)\nSELECT\n [sales___ordered_at],\n [sales___streak]\nFROM (\n SELECT\n [sales___ordered_at],\n [sales___revenue_sum],\n [sales___cost_sum],\n [sales___streak]\n FROM cp_value_streak\n) AS _outer", - "cp/or::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 SUM(sales.cost) AS `sales___cost_sum`\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n SUM(\n CASE\n WHEN `sales___revenue_sum` > 90\n OR `sales___cost_sum` > 40\n AND CAST(`_cp_prev_sales___streak` AS TIMESTAMP) = CAST(DATETIME_ADD(CAST(CAST(`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n CASE\n WHEN `sales___revenue_sum` > 90 OR `sales___cost_sum` > 40\n THEN SUM(CASE WHEN `sales___revenue_sum` > 90 OR `sales___cost_sum` > 40 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", + "cp/or::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 SUM(sales.cost) AS `sales___cost_sum`\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), cp_prev_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n LAG(`sales___ordered_at`) OVER (ORDER BY `sales___ordered_at`) AS `_cp_prev_sales___streak`\n FROM base\n), cp_reset_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n SUM(\n CASE\n WHEN `sales___revenue_sum` > 90\n OR `sales___cost_sum` > 40\n AND CAST(`_cp_prev_sales___streak` AS DATETIME) = DATETIME_ADD(CAST(`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH)\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY `sales___ordered_at` ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS `_cp_reset_sales___streak`\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n CASE\n WHEN `sales___revenue_sum` > 90 OR `sales___cost_sum` > 40\n THEN SUM(CASE WHEN `sales___revenue_sum` > 90 OR `sales___cost_sum` > 40 THEN 1 ELSE 0 END) OVER (\n PARTITION BY `_cp_reset_sales___streak`\n ORDER BY `sales___ordered_at`\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS `sales___streak`\n FROM cp_reset_streak\n)\nSELECT\n `sales___ordered_at`,\n `sales___streak`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___cost_sum`,\n `sales___streak`\n FROM cp_value_streak\n) AS _outer", "cp/or::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 SUM(sales.cost) AS \"sales.cost_sum\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n SUM(\n CASE\n WHEN \"sales.revenue_sum\" > 90\n OR \"sales.cost_sum\" > 40\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL 1 MONTH\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n CASE\n WHEN \"sales.revenue_sum\" > 90 OR \"sales.cost_sum\" > 40\n THEN SUM(CASE WHEN \"sales.revenue_sum\" > 90 OR \"sales.cost_sum\" > 40 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/or::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 SUM(sales.cost) AS \"sales.cost_sum\"\n FROM sales AS sales\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n SUM(\n CASE\n WHEN \"sales.revenue_sum\" > 90\n OR \"sales.cost_sum\" > 40\n AND \"_cp_prev_sales.streak\" = \"sales.ordered_at\" - INTERVAL '1 MONTH'\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n CASE\n WHEN \"sales.revenue_sum\" > 90 OR \"sales.cost_sum\" > 40\n THEN SUM(CASE WHEN \"sales.revenue_sum\" > 90 OR \"sales.cost_sum\" > 40 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", "cp/or::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\",\n SUM(sales.cost) AS \"sales.cost_sum\"\n FROM sales AS sales\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), cp_prev_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n LAG(\"sales.ordered_at\") OVER (ORDER BY \"sales.ordered_at\") AS \"_cp_prev_sales.streak\"\n FROM base\n), cp_reset_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n SUM(\n CASE\n WHEN \"sales.revenue_sum\" > 90\n OR \"sales.cost_sum\" > 40\n AND \"_cp_prev_sales.streak\" = SLAYER_DATE_ADD(\"sales.ordered_at\", -1, 'month')\n THEN 0\n ELSE 1\n END\n ) OVER (ORDER BY \"sales.ordered_at\" ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW) AS \"_cp_reset_sales.streak\"\n FROM cp_prev_streak\n), cp_value_streak AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n CASE\n WHEN \"sales.revenue_sum\" > 90 OR \"sales.cost_sum\" > 40\n THEN SUM(CASE WHEN \"sales.revenue_sum\" > 90 OR \"sales.cost_sum\" > 40 THEN 1 ELSE 0 END) OVER (\n PARTITION BY \"_cp_reset_sales.streak\"\n ORDER BY \"sales.ordered_at\"\n ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW\n )\n ELSE 0\n END AS \"sales.streak\"\n FROM cp_reset_streak\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.streak\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.cost_sum\",\n \"sales.streak\"\n FROM cp_value_streak\n) AS _outer", @@ -84,27 +84,27 @@ "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) / 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::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 DATETIME_ADD(CAST(base.`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`sales___ordered_at` AS DATETIME)\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 (\n base.[sales___store] = shifted__time_shift_inner.[sales___store]\n AND NOT base.[sales___store] IS NULL\n AND NOT shifted__time_shift_inner.[sales___store] IS NULL\n )\n OR (\n base.[sales___store] IS NULL AND shifted__time_shift_inner.[sales___store] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) = shifted__time_shift_inner.[sales___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[sales___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[sales___ordered_at] IS NULL\n )\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::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 DATETIME_ADD(CAST(base.`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_prev.`sales___ordered_at` AS DATETIME)\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", "ts/coalesce_missing::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\"\n FROM sales AS sales\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), shifted_prev AS (\n SELECT\n STRFTIME('%Y-%m-01', 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 STRFTIME('%Y-%m-01', 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 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_sum\",\n \"sales.prev\"\n FROM sjoin_prev\n) AS _outer", "ts/coalesce_missing::tsql": "WITH base AS (\n SELECT\n DATETRUNC(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 DATETRUNC(month, sales.ordered_at)\n), shifted_prev AS (\n SELECT\n DATETRUNC(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 DATETRUNC(month, sales.ordered_at)\n), sjoin_prev AS (\n SELECT\n base.[sales___ordered_at] AS [sales___ordered_at],\n base.[sales___revenue_sum] AS [sales___revenue_sum],\n shifted_prev.[sales___shifted] AS [sales___prev]\n FROM base\n LEFT JOIN shifted_prev\n ON (\n (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) = shifted_prev.[sales___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[sales___ordered_at]) IS NULL\n AND NOT shifted_prev.[sales___ordered_at] IS NULL\n )\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_sum],\n [sales___prev]\n FROM sjoin_prev\n) AS _outer", - "ts/crossing_join::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`\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 _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) * 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(sales.ordered_at, MONTH)\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 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_wrevenue_sum_f_regions_factor`,\n `sales___prev`\n FROM sjoin_prev\n) AS _outer", + "ts/crossing_join::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(sales.ordered_at, MONTH) AS `sales___ordered_at`\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 _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) * 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(sales.ordered_at, MONTH)\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 DATETIME_ADD(CAST(base.`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_prev.`sales___ordered_at` AS DATETIME)\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::duckdb": "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) 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::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 (\n _base.[sales___ordered_at] = _cm_sales__revenue_wrevenue_sum_f_regions_factor.[sales___ordered_at]\n AND NOT _base.[sales___ordered_at] IS NULL\n AND NOT _cm_sales__revenue_wrevenue_sum_f_regions_factor.[sales___ordered_at] IS NULL\n )\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 (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) = shifted_prev.[sales___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[sales___ordered_at]) IS NULL\n AND NOT shifted_prev.[sales___ordered_at] IS NULL\n )\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) / 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::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 DATETIME_ADD(CAST(base.`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_prev.`sales___ordered_at` AS DATETIME)\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 (\n base.[sales___store] = shifted_prev.[sales___store]\n AND NOT base.[sales___store] IS NULL\n AND NOT shifted_prev.[sales___store] IS NULL\n )\n OR (\n base.[sales___store] IS NULL AND shifted_prev.[sales___store] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) = shifted_prev.[sales___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[sales___ordered_at]) IS NULL\n AND NOT shifted_prev.[sales___ordered_at] IS NULL\n )\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::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 DATETIME_ADD(CAST(base.`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_prev.`sales___ordered_at` AS DATETIME)\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", "ts/two_leaves::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', 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 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 _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 _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) + 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 STRFTIME('%Y-%m-01', 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 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.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/dev1859_sql_baseline.json b/tests/golden/dev1859_sql_baseline.json index a1973fbdc..5b6b5a029 100644 --- a/tests/golden/dev1859_sql_baseline.json +++ b/tests/golden/dev1859_sql_baseline.json @@ -76,14 +76,14 @@ "param/ungrained_reagg::snowflake": "WITH _base AS (\n SELECT\n sales.region AS \"sales.region\"\n FROM sales AS sales\n GROUP BY\n sales.region\n), _base_2 AS (\n SELECT\n sales.city AS \"sales.city\",\n sales.region AS \"sales.region\",\n CAST(SUM(sales.amount) AS DOUBLE) AS \"sales.amount_sum_partition_by_city_region\"\n FROM sales AS sales\n GROUP BY\n sales.city,\n sales.region\n), _cm_sales__id_count_partition_by_region AS (\n SELECT\n sales.region AS \"sales.region\",\n COUNT(sales.id) AS \"sales.id_count_partition_by_region\"\n FROM sales AS sales\n GROUP BY\n sales.region\n), _cm_amount_sum_partition_by_city_region AS (\n SELECT\n _stage_inner.\"sales.city\" AS \"city\",\n _stage_inner.\"sales.region\" AS \"region\",\n _stage_inner.\"sales.amount_sum_partition_by_city_region\" AS \"amount_sum_partition_by_city_region\",\n _stage_inner.\"sales.id_count_partition_by_region\" AS \"id_count_partition_by_region\"\n FROM (\n SELECT\n _base_2.\"sales.city\",\n _base_2.\"sales.region\",\n _base_2.\"sales.amount_sum_partition_by_city_region\",\n COALESCE(_cm_sales__id_count_partition_by_region.\"sales.id_count_partition_by_region\", 0) AS \"sales.id_count_partition_by_region\"\n FROM _base_2\n LEFT JOIN _cm_sales__id_count_partition_by_region\n ON _base_2.\"sales.region\" IS NOT DISTINCT FROM _cm_sales__id_count_partition_by_region.\"sales.region\"\n ) AS _stage_inner\n), _cm_sales___wsum_weight_count_id AS (\n SELECT\n _base.\"sales.region\" AS \"sales.region\",\n SUM(_base._v * _base._p0) AS \"sales.w\"\n FROM (\n SELECT\n sales.region AS \"sales.region\",\n sales.city AS _ek0,\n sales.region AS _ek1,\n MAX(_cm_amount_sum_partition_by_city_region.\"amount_sum_partition_by_city_region\") AS _v,\n MAX(\n COALESCE(_cm_amount_sum_partition_by_city_region.\"id_count_partition_by_region\", 0)\n ) AS _p0\n FROM sales AS sales\n LEFT JOIN _cm_amount_sum_partition_by_city_region\n ON sales.city IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city_region.\"city\"\n AND sales.region IS NOT DISTINCT FROM _cm_amount_sum_partition_by_city_region.\"region\"\n GROUP BY\n sales.region,\n sales.city,\n sales.region\n ) AS _base\n GROUP BY\n _base.\"sales.region\"\n)\nSELECT\n _base.\"sales.region\",\n _cm_sales___wsum_weight_count_id.\"sales.w\"\nFROM _base\nLEFT JOIN _cm_sales___wsum_weight_count_id\n ON _base.\"sales.region\" IS NOT DISTINCT FROM _cm_sales___wsum_weight_count_id.\"sales.region\"", "param/ungrained_reagg::sqlite": "WITH _base AS (\n SELECT\n sales.region AS \"sales.region\"\n FROM sales AS sales\n GROUP BY\n sales.region\n), _base_2 AS (\n SELECT\n sales.city AS \"sales.city\",\n sales.region AS \"sales.region\",\n CAST(SUM(sales.amount) AS REAL) AS \"sales.amount_sum_partition_by_city_region\"\n FROM sales AS sales\n GROUP BY\n sales.city,\n sales.region\n), _cm_sales__id_count_partition_by_region AS (\n SELECT\n sales.region AS \"sales.region\",\n COUNT(sales.id) AS \"sales.id_count_partition_by_region\"\n FROM sales AS sales\n GROUP BY\n sales.region\n), _cm_amount_sum_partition_by_city_region AS (\n SELECT\n _stage_inner.\"sales.city\" AS \"city\",\n _stage_inner.\"sales.region\" AS \"region\",\n _stage_inner.\"sales.amount_sum_partition_by_city_region\" AS \"amount_sum_partition_by_city_region\",\n _stage_inner.\"sales.id_count_partition_by_region\" AS \"id_count_partition_by_region\"\n FROM (\n SELECT\n _base_2.\"sales.city\",\n _base_2.\"sales.region\",\n _base_2.\"sales.amount_sum_partition_by_city_region\",\n COALESCE(_cm_sales__id_count_partition_by_region.\"sales.id_count_partition_by_region\", 0) AS \"sales.id_count_partition_by_region\"\n FROM _base_2\n LEFT JOIN _cm_sales__id_count_partition_by_region\n ON _base_2.\"sales.region\" IS _cm_sales__id_count_partition_by_region.\"sales.region\"\n ) AS _stage_inner\n), _cm_sales___wsum_weight_count_id AS (\n SELECT\n _base.\"sales.region\" AS \"sales.region\",\n SUM(_base._v * _base._p0) AS \"sales.w\"\n FROM (\n SELECT\n sales.region AS \"sales.region\",\n sales.city AS _ek0,\n sales.region AS _ek1,\n MAX(_cm_amount_sum_partition_by_city_region.\"amount_sum_partition_by_city_region\") AS _v,\n MAX(\n COALESCE(_cm_amount_sum_partition_by_city_region.\"id_count_partition_by_region\", 0)\n ) AS _p0\n FROM sales AS sales\n LEFT JOIN _cm_amount_sum_partition_by_city_region\n ON sales.city IS _cm_amount_sum_partition_by_city_region.\"city\"\n AND sales.region IS _cm_amount_sum_partition_by_city_region.\"region\"\n GROUP BY\n sales.region,\n sales.city,\n sales.region\n ) AS _base\n GROUP BY\n _base.\"sales.region\"\n)\nSELECT\n _base.\"sales.region\",\n _cm_sales___wsum_weight_count_id.\"sales.w\"\nFROM _base\nLEFT JOIN _cm_sales___wsum_weight_count_id\n ON _base.\"sales.region\" IS _cm_sales___wsum_weight_count_id.\"sales.region\"", "param/ungrained_reagg::tsql": "WITH _base AS (\n SELECT\n sales.region AS [sales___region]\n FROM sales AS sales\n GROUP BY\n sales.region\n), _base_2 AS (\n SELECT\n sales.city AS [sales___city],\n sales.region AS [sales___region],\n CAST(SUM(sales.amount) AS FLOAT) AS [sales___amount_sum_partition_by_city_region]\n FROM sales AS sales\n GROUP BY\n sales.city,\n sales.region\n), _cm_sales__id_count_partition_by_region AS (\n SELECT\n sales.region AS [sales___region],\n COUNT(sales.id) AS [sales___id_count_partition_by_region]\n FROM sales AS sales\n GROUP BY\n sales.region\n), _cm_amount_sum_partition_by_city_region AS (\n SELECT\n _stage_inner.[sales___city] AS [city],\n _stage_inner.[sales___region] AS [region],\n _stage_inner.[sales___amount_sum_partition_by_city_region] AS [amount_sum_partition_by_city_region],\n _stage_inner.[sales___id_count_partition_by_region] AS [id_count_partition_by_region]\n FROM (\n SELECT\n _base_2.[sales___city] AS [sales___city],\n _base_2.[sales___region] AS [sales___region],\n _base_2.[sales___amount_sum_partition_by_city_region] AS [sales___amount_sum_partition_by_city_region],\n COALESCE(_cm_sales__id_count_partition_by_region.[sales___id_count_partition_by_region], 0) AS [sales___id_count_partition_by_region]\n FROM _base_2\n LEFT JOIN _cm_sales__id_count_partition_by_region\n ON (\n (\n _base_2.[sales___region] = _cm_sales__id_count_partition_by_region.[sales___region]\n AND NOT _base_2.[sales___region] IS NULL\n AND NOT _cm_sales__id_count_partition_by_region.[sales___region] IS NULL\n )\n OR (\n _base_2.[sales___region] IS NULL\n AND _cm_sales__id_count_partition_by_region.[sales___region] IS NULL\n )\n )\n ) AS _stage_inner\n), _cm_sales___wsum_weight_count_id AS (\n SELECT\n _base.[sales___region] AS [sales___region],\n SUM(_base._v * _base._p0) AS [sales___w]\n FROM (\n SELECT\n sales.region AS [sales___region],\n sales.city AS _ek0,\n sales.region AS _ek1,\n MAX(_cm_amount_sum_partition_by_city_region.[amount_sum_partition_by_city_region]) AS _v,\n MAX(\n COALESCE(_cm_amount_sum_partition_by_city_region.[id_count_partition_by_region], 0)\n ) AS _p0\n FROM sales AS sales\n LEFT JOIN _cm_amount_sum_partition_by_city_region\n ON (\n (\n sales.city = _cm_amount_sum_partition_by_city_region.[city]\n AND NOT sales.city IS NULL\n AND NOT _cm_amount_sum_partition_by_city_region.[city] IS NULL\n )\n OR (\n sales.city IS NULL AND _cm_amount_sum_partition_by_city_region.[city] IS NULL\n )\n )\n AND (\n (\n sales.region = _cm_amount_sum_partition_by_city_region.[region]\n AND NOT sales.region IS NULL\n AND NOT _cm_amount_sum_partition_by_city_region.[region] IS NULL\n )\n OR (\n sales.region IS NULL AND _cm_amount_sum_partition_by_city_region.[region] IS NULL\n )\n )\n GROUP BY\n sales.region,\n sales.city,\n sales.region\n ) AS _base\n GROUP BY\n _base.[sales___region]\n)\nSELECT\n _base.[sales___region],\n _cm_sales___wsum_weight_count_id.[sales___w]\nFROM _base\nLEFT JOIN _cm_sales___wsum_weight_count_id\n ON (\n (\n _base.[sales___region] = _cm_sales___wsum_weight_count_id.[sales___region]\n AND NOT _base.[sales___region] IS NULL\n AND NOT _cm_sales___wsum_weight_count_id.[sales___region] IS NULL\n )\n OR (\n _base.[sales___region] IS NULL\n AND _cm_sales___wsum_weight_count_id.[sales___region] IS NULL\n )\n )", - "param/windowed::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n), _cm_orders__amount_sum_partition_by_regions_name AS (\n SELECT\n _stage_inner.`orders___customers___regions___name` AS `customers__regions__name`,\n _stage_inner.`orders___amount_sum_partition_by_customers_regions_name` AS `amount_sum_partition_by_customers_regions_name`\n FROM (\n SELECT\n customers__regions.name AS `orders___customers___regions___name`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum_partition_by_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 ) AS _stage_inner\n), _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y AS (\n SELECT\n _base.`customers___signup_at_month`,\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS FLOAT64) AS `customers___spend_weighted_avg_weight_sum_orders_amount_by_regions_name_window_1y`\n FROM (\n SELECT\n `_e`.`orders___customers___signup_at` AS `customers___signup_at_month`\n FROM (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n _cm_orders__amount_sum_partition_by_regions_name.`amount_sum_partition_by_customers_regions_name` AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN _cm_orders__amount_sum_partition_by_regions_name\n ON regions.name IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_regions_name.`customers__regions__name`\n ) AS _src\n ON _src._w_time >= CAST(DATETIME_ADD(\n CAST(CAST(DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP) AS DATETIME),\n INTERVAL -1 YEAR\n ) AS TIMESTAMP)\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`customers___signup_at_month`\n)\nSELECT\n _base.`orders___customers___signup_at`,\n _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y.`customers___spend_weighted_avg_weight_sum_orders_amount_by_regions_name_window_1y` AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y\n ON _base.`orders___customers___signup_at` IS NOT DISTINCT FROM _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y.`customers___signup_at_month`", + "param/windowed::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n), _cm_orders__amount_sum_partition_by_regions_name AS (\n SELECT\n _stage_inner.`orders___customers___regions___name` AS `customers__regions__name`,\n _stage_inner.`orders___amount_sum_partition_by_customers_regions_name` AS `amount_sum_partition_by_customers_regions_name`\n FROM (\n SELECT\n customers__regions.name AS `orders___customers___regions___name`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum_partition_by_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 ) AS _stage_inner\n), _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y AS (\n SELECT\n _base.`customers___signup_at_month`,\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS FLOAT64) AS `customers___spend_weighted_avg_weight_sum_orders_amount_by_regions_name_window_1y`\n FROM (\n SELECT\n `_e`.`orders___customers___signup_at` AS `customers___signup_at_month`\n FROM (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n _cm_orders__amount_sum_partition_by_regions_name.`amount_sum_partition_by_customers_regions_name` AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN _cm_orders__amount_sum_partition_by_regions_name\n ON regions.name IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_regions_name.`customers__regions__name`\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -1 YEAR\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`customers___signup_at_month`\n)\nSELECT\n _base.`orders___customers___signup_at`,\n _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y.`customers___spend_weighted_avg_weight_sum_orders_amount_by_regions_name_window_1y` AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y\n ON _base.`orders___customers___signup_at` IS NOT DISTINCT FROM _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y.`customers___signup_at_month`", "param/windowed::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n), _cm_orders__amount_sum_partition_by_regions_name AS (\n SELECT\n _stage_inner.\"orders.customers.regions.name\" AS \"customers__regions__name\",\n _stage_inner.\"orders.amount_sum_partition_by_customers_regions_name\" AS \"amount_sum_partition_by_customers_regions_name\"\n FROM (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum_partition_by_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 ) AS _stage_inner\n), _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y AS (\n SELECT\n _base.\"customers.signup_at_month\",\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS DOUBLE) AS \"customers.spend_weighted_avg_weight_sum_orders_amount_by_regions_name_window_1y\"\n FROM (\n SELECT\n \"_e\".\"orders.customers.signup_at\" AS \"customers.signup_at_month\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n _cm_orders__amount_sum_partition_by_regions_name.\"amount_sum_partition_by_customers_regions_name\" AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN _cm_orders__amount_sum_partition_by_regions_name\n ON regions.name IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_regions_name.\"customers__regions__name\"\n ) AS _src\n ON _src._w_time >= _base.\"customers.signup_at_month\" + INTERVAL 1 MONTH - INTERVAL 1 YEAR\n AND _src._w_time < _base.\"customers.signup_at_month\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"customers.signup_at_month\"\n)\nSELECT\n _base.\"orders.customers.signup_at\",\n _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y.\"customers.spend_weighted_avg_weight_sum_orders_amount_by_regions_name_window_1y\" AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y\n ON _base.\"orders.customers.signup_at\" IS NOT DISTINCT FROM _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y.\"customers.signup_at_month\"", "param/windowed::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n ) AS `orders.customers.signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n )\n), _cm_orders__amount_sum_partition_by_regions_name AS (\n SELECT\n _stage_inner.`orders.customers.regions.name` AS `customers__regions__name`,\n _stage_inner.`orders.amount_sum_partition_by_customers_regions_name` AS `amount_sum_partition_by_customers_regions_name`\n FROM (\n SELECT\n customers__regions.name AS `orders.customers.regions.name`,\n CAST(SUM(orders.amount) AS DOUBLE) AS `orders.amount_sum_partition_by_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 ) AS _stage_inner\n), _cm_orders__customers__spen_112117e4_mers_regions_name_window_1y AS (\n SELECT\n _base.`customers.signup_at_month`,\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS DOUBLE) AS `customers.spend_weighted_av_6c63ef1e_t_by_regions_name_window_1y`\n FROM (\n SELECT\n `_e`.`orders.customers.signup_at` AS `customers.signup_at_month`\n FROM (\n SELECT\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n ) AS `orders.customers.signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n )\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n _cm_orders__amount_sum_partition_by_regions_name.`amount_sum_partition_by_customers_regions_name` AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN _cm_orders__amount_sum_partition_by_regions_name\n ON regions.name <=> _cm_orders__amount_sum_partition_by_regions_name.`customers__regions__name`\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`customers.signup_at_month`, INTERVAL 1 MONTH), INTERVAL -1 YEAR)\n AND _src._w_time < DATE_ADD(_base.`customers.signup_at_month`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`customers.signup_at_month`\n)\nSELECT\n _base.`orders.customers.signup_at`,\n _cm_orders__customers__spen_112117e4_mers_regions_name_window_1y.`customers.spend_weighted_av_6c63ef1e_t_by_regions_name_window_1y` AS `orders.w`\nFROM _base\nLEFT JOIN _cm_orders__customers__spen_112117e4_mers_regions_name_window_1y\n ON _base.`orders.customers.signup_at` <=> _cm_orders__customers__spen_112117e4_mers_regions_name_window_1y.`customers.signup_at_month`", "param/windowed::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n), _cm_orders__amount_sum_partition_by_regions_name AS (\n SELECT\n _stage_inner.\"orders.customers.regions.name\" AS \"customers__regions__name\",\n _stage_inner.\"orders.amount_sum_partition_by_customers_regions_name\" AS \"amount_sum_partition_by_customers_regions_name\"\n FROM (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum_partition_by_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 ) AS _stage_inner\n), _cm_orders__customers__spen_112117e4_ers_regions_name_window_1y AS (\n SELECT\n _base.\"customers.signup_at_month\",\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN _src._w_value IS NOT NULL THEN _src._w_p0 END), 0) AS DOUBLE PRECISION) AS \"customers.spend_weighted_av_6c63ef1e_by_regions_name_window_1y\"\n FROM (\n SELECT\n \"_e\".\"orders.customers.signup_at\" AS \"customers.signup_at_month\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n _cm_orders__amount_sum_partition_by_regions_name.\"amount_sum_partition_by_customers_regions_name\" AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN _cm_orders__amount_sum_partition_by_regions_name\n ON regions.name IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_regions_name.\"customers__regions__name\"\n ) AS _src\n ON _src._w_time >= _base.\"customers.signup_at_month\" + INTERVAL '1 MONTH' - INTERVAL '1 YEAR'\n AND _src._w_time < _base.\"customers.signup_at_month\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"customers.signup_at_month\"\n)\nSELECT\n _base.\"orders.customers.signup_at\",\n _cm_orders__customers__spen_112117e4_ers_regions_name_window_1y.\"customers.spend_weighted_av_6c63ef1e_by_regions_name_window_1y\" AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spen_112117e4_ers_regions_name_window_1y\n ON _base.\"orders.customers.signup_at\" IS NOT DISTINCT FROM _cm_orders__customers__spen_112117e4_ers_regions_name_window_1y.\"customers.signup_at_month\"", "param/windowed::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n), _cm_orders__amount_sum_partition_by_regions_name AS (\n SELECT\n _stage_inner.\"orders.customers.regions.name\" AS \"customers__regions__name\",\n _stage_inner.\"orders.amount_sum_partition_by_customers_regions_name\" AS \"amount_sum_partition_by_customers_regions_name\"\n FROM (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum_partition_by_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 ) AS _stage_inner\n), _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y AS (\n SELECT\n _base.\"customers.signup_at_month\",\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS DOUBLE) AS \"customers.spend_weighted_avg_weight_sum_orders_amount_by_regions_name_window_1y\"\n FROM (\n SELECT\n \"_e\".\"orders.customers.signup_at\" AS \"customers.signup_at_month\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n _cm_orders__amount_sum_partition_by_regions_name.\"amount_sum_partition_by_customers_regions_name\" AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN _cm_orders__amount_sum_partition_by_regions_name\n ON regions.name IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_regions_name.\"customers__regions__name\"\n ) AS _src\n ON _src._w_time >= DATEADD(YEAR, -1, DATEADD(MONTH, 1, _base.\"customers.signup_at_month\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"customers.signup_at_month\")\n GROUP BY\n _base.\"customers.signup_at_month\"\n)\nSELECT\n _base.\"orders.customers.signup_at\",\n _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y.\"customers.spend_weighted_avg_weight_sum_orders_amount_by_regions_name_window_1y\" AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y\n ON _base.\"orders.customers.signup_at\" IS NOT DISTINCT FROM _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y.\"customers.signup_at_month\"", "param/windowed::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n STRFTIME('%Y-%m-01', customers.signup_at)\n), _cm_orders__amount_sum_partition_by_regions_name AS (\n SELECT\n _stage_inner.\"orders.customers.regions.name\" AS \"customers__regions__name\",\n _stage_inner.\"orders.amount_sum_partition_by_customers_regions_name\" AS \"amount_sum_partition_by_customers_regions_name\"\n FROM (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum_partition_by_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 ) AS _stage_inner\n), _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y AS (\n SELECT\n _base.\"customers.signup_at_month\",\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS REAL) AS \"customers.spend_weighted_avg_weight_sum_orders_amount_by_regions_name_window_1y\"\n FROM (\n SELECT\n \"_e\".\"orders.customers.signup_at\" AS \"customers.signup_at_month\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n STRFTIME('%Y-%m-01', customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n _cm_orders__amount_sum_partition_by_regions_name.\"amount_sum_partition_by_customers_regions_name\" AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN _cm_orders__amount_sum_partition_by_regions_name\n ON regions.name IS _cm_orders__amount_sum_partition_by_regions_name.\"customers__regions__name\"\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"customers.signup_at_month\", 1, 'month'), -1, 'year')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"customers.signup_at_month\", 1, 'month')\n GROUP BY\n _base.\"customers.signup_at_month\"\n)\nSELECT\n _base.\"orders.customers.signup_at\",\n _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y.\"customers.spend_weighted_avg_weight_sum_orders_amount_by_regions_name_window_1y\" AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y\n ON _base.\"orders.customers.signup_at\" IS _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y.\"customers.signup_at_month\"", "param/windowed::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, customers.signup_at) AS [orders___customers___signup_at]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATETRUNC(month, customers.signup_at)\n), _cm_orders__amount_sum_partition_by_regions_name AS (\n SELECT\n _stage_inner.[orders___customers___regions___name] AS [customers__regions__name],\n _stage_inner.[orders___amount_sum_partition_by_customers_regions_name] AS [amount_sum_partition_by_customers_regions_name]\n FROM (\n SELECT\n customers__regions.name AS [orders___customers___regions___name],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___amount_sum_partition_by_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 ) AS _stage_inner\n), _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y AS (\n SELECT\n _base.[customers___signup_at_month] AS [customers___signup_at_month],\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS FLOAT) AS [customers___spend_weighted_avg_weight_sum_orders_amount_by_regions_name_window_1y]\n FROM (\n SELECT\n [_e].[orders___customers___signup_at] AS [customers___signup_at_month]\n FROM (\n SELECT\n DATETRUNC(month, customers.signup_at) AS [orders___customers___signup_at]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATETRUNC(month, customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n _cm_orders__amount_sum_partition_by_regions_name.[amount_sum_partition_by_customers_regions_name] AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN _cm_orders__amount_sum_partition_by_regions_name\n ON (\n (\n regions.name = _cm_orders__amount_sum_partition_by_regions_name.[customers__regions__name]\n AND NOT regions.name IS NULL\n AND NOT _cm_orders__amount_sum_partition_by_regions_name.[customers__regions__name] IS NULL\n )\n OR (\n regions.name IS NULL\n AND _cm_orders__amount_sum_partition_by_regions_name.[customers__regions__name] IS NULL\n )\n )\n ) AS _src\n ON _src._w_time >= DATEADD(YEAR, -1, DATEADD(MONTH, 1, _base.[customers___signup_at_month]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[customers___signup_at_month])\n GROUP BY\n _base.[customers___signup_at_month]\n)\nSELECT\n _base.[orders___customers___signup_at],\n _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y.[customers___spend_weighted_avg_weight_sum_orders_amount_by_regions_name_window_1y] AS [orders___w]\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y\n ON (\n (\n _base.[orders___customers___signup_at] = _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y.[customers___signup_at_month]\n AND NOT _base.[orders___customers___signup_at] IS NULL\n AND NOT _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y.[customers___signup_at_month] IS NULL\n )\n OR (\n _base.[orders___customers___signup_at] IS NULL\n AND _cm_orders__customers__spend_weighted_avg_weight_sum_amount_by_customers_regions_name_window_1y.[customers___signup_at_month] IS NULL\n )\n )", - "param/windowed_custom::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n), _cm_orders__amount_sum_partition_by_regions_name AS (\n SELECT\n _stage_inner.`orders___customers___regions___name` AS `customers__regions__name`,\n _stage_inner.`orders___amount_sum_partition_by_customers_regions_name` AS `amount_sum_partition_by_customers_regions_name`\n FROM (\n SELECT\n customers__regions.name AS `orders___customers___regions___name`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum_partition_by_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 ) AS _stage_inner\n), _cm_orders__customers__spend_wsum_weight_sum_amount_by_customers_regions_name_window_1y AS (\n SELECT\n _base.`customers___signup_at_month`,\n CAST(CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS FLOAT64) AS `customers___spend_wsum_weight_sum_orders_amount_by_regions_name_window_1y`\n FROM (\n SELECT\n `_e`.`orders___customers___signup_at` AS `customers___signup_at_month`\n FROM (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n _cm_orders__amount_sum_partition_by_regions_name.`amount_sum_partition_by_customers_regions_name` AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN _cm_orders__amount_sum_partition_by_regions_name\n ON regions.name IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_regions_name.`customers__regions__name`\n ) AS _src\n ON _src._w_time >= CAST(DATETIME_ADD(\n CAST(CAST(DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP) AS DATETIME),\n INTERVAL -1 YEAR\n ) AS TIMESTAMP)\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`customers___signup_at_month`\n)\nSELECT\n _base.`orders___customers___signup_at`,\n _cm_orders__customers__spend_wsum_weight_sum_amount_by_customers_regions_name_window_1y.`customers___spend_wsum_weight_sum_orders_amount_by_regions_name_window_1y` AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_wsum_weight_sum_amount_by_customers_regions_name_window_1y\n ON _base.`orders___customers___signup_at` IS NOT DISTINCT FROM _cm_orders__customers__spend_wsum_weight_sum_amount_by_customers_regions_name_window_1y.`customers___signup_at_month`", + "param/windowed_custom::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n), _cm_orders__amount_sum_partition_by_regions_name AS (\n SELECT\n _stage_inner.`orders___customers___regions___name` AS `customers__regions__name`,\n _stage_inner.`orders___amount_sum_partition_by_customers_regions_name` AS `amount_sum_partition_by_customers_regions_name`\n FROM (\n SELECT\n customers__regions.name AS `orders___customers___regions___name`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum_partition_by_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 ) AS _stage_inner\n), _cm_orders__customers__spend_wsum_weight_sum_amount_by_customers_regions_name_window_1y AS (\n SELECT\n _base.`customers___signup_at_month`,\n CAST(CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS FLOAT64) AS `customers___spend_wsum_weight_sum_orders_amount_by_regions_name_window_1y`\n FROM (\n SELECT\n `_e`.`orders___customers___signup_at` AS `customers___signup_at_month`\n FROM (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n _cm_orders__amount_sum_partition_by_regions_name.`amount_sum_partition_by_customers_regions_name` AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN _cm_orders__amount_sum_partition_by_regions_name\n ON regions.name IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_regions_name.`customers__regions__name`\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -1 YEAR\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`customers___signup_at_month`\n)\nSELECT\n _base.`orders___customers___signup_at`,\n _cm_orders__customers__spend_wsum_weight_sum_amount_by_customers_regions_name_window_1y.`customers___spend_wsum_weight_sum_orders_amount_by_regions_name_window_1y` AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_wsum_weight_sum_amount_by_customers_regions_name_window_1y\n ON _base.`orders___customers___signup_at` IS NOT DISTINCT FROM _cm_orders__customers__spend_wsum_weight_sum_amount_by_customers_regions_name_window_1y.`customers___signup_at_month`", "param/windowed_custom::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n), _cm_orders__amount_sum_partition_by_regions_name AS (\n SELECT\n _stage_inner.\"orders.customers.regions.name\" AS \"customers__regions__name\",\n _stage_inner.\"orders.amount_sum_partition_by_customers_regions_name\" AS \"amount_sum_partition_by_customers_regions_name\"\n FROM (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum_partition_by_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 ) AS _stage_inner\n), _cm_orders__customers__spend_wsum_weight_sum_amount_by_customers_regions_name_window_1y AS (\n SELECT\n _base.\"customers.signup_at_month\",\n CAST(CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS DOUBLE) AS \"customers.spend_wsum_weight_sum_orders_amount_by_regions_name_window_1y\"\n FROM (\n SELECT\n \"_e\".\"orders.customers.signup_at\" AS \"customers.signup_at_month\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n _cm_orders__amount_sum_partition_by_regions_name.\"amount_sum_partition_by_customers_regions_name\" AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN _cm_orders__amount_sum_partition_by_regions_name\n ON regions.name IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_regions_name.\"customers__regions__name\"\n ) AS _src\n ON _src._w_time >= _base.\"customers.signup_at_month\" + INTERVAL 1 MONTH - INTERVAL 1 YEAR\n AND _src._w_time < _base.\"customers.signup_at_month\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"customers.signup_at_month\"\n)\nSELECT\n _base.\"orders.customers.signup_at\",\n _cm_orders__customers__spend_wsum_weight_sum_amount_by_customers_regions_name_window_1y.\"customers.spend_wsum_weight_sum_orders_amount_by_regions_name_window_1y\" AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_wsum_weight_sum_amount_by_customers_regions_name_window_1y\n ON _base.\"orders.customers.signup_at\" IS NOT DISTINCT FROM _cm_orders__customers__spend_wsum_weight_sum_amount_by_customers_regions_name_window_1y.\"customers.signup_at_month\"", "param/windowed_custom::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n ) AS `orders.customers.signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n )\n), _cm_orders__amount_sum_partition_by_regions_name AS (\n SELECT\n _stage_inner.`orders.customers.regions.name` AS `customers__regions__name`,\n _stage_inner.`orders.amount_sum_partition_by_customers_regions_name` AS `amount_sum_partition_by_customers_regions_name`\n FROM (\n SELECT\n customers__regions.name AS `orders.customers.regions.name`,\n CAST(SUM(orders.amount) AS DOUBLE) AS `orders.amount_sum_partition_by_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 ) AS _stage_inner\n), _cm_orders__customers__spen_d0a1809f_mers_regions_name_window_1y AS (\n SELECT\n _base.`customers.signup_at_month`,\n CAST(CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS DOUBLE) AS `customers.spend_wsum_weight_730ac295_t_by_regions_name_window_1y`\n FROM (\n SELECT\n `_e`.`orders.customers.signup_at` AS `customers.signup_at_month`\n FROM (\n SELECT\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n ) AS `orders.customers.signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n )\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n _cm_orders__amount_sum_partition_by_regions_name.`amount_sum_partition_by_customers_regions_name` AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN _cm_orders__amount_sum_partition_by_regions_name\n ON regions.name <=> _cm_orders__amount_sum_partition_by_regions_name.`customers__regions__name`\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`customers.signup_at_month`, INTERVAL 1 MONTH), INTERVAL -1 YEAR)\n AND _src._w_time < DATE_ADD(_base.`customers.signup_at_month`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`customers.signup_at_month`\n)\nSELECT\n _base.`orders.customers.signup_at`,\n _cm_orders__customers__spen_d0a1809f_mers_regions_name_window_1y.`customers.spend_wsum_weight_730ac295_t_by_regions_name_window_1y` AS `orders.w`\nFROM _base\nLEFT JOIN _cm_orders__customers__spen_d0a1809f_mers_regions_name_window_1y\n ON _base.`orders.customers.signup_at` <=> _cm_orders__customers__spen_d0a1809f_mers_regions_name_window_1y.`customers.signup_at_month`", "param/windowed_custom::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n), _cm_orders__amount_sum_partition_by_regions_name AS (\n SELECT\n _stage_inner.\"orders.customers.regions.name\" AS \"customers__regions__name\",\n _stage_inner.\"orders.amount_sum_partition_by_customers_regions_name\" AS \"amount_sum_partition_by_customers_regions_name\"\n FROM (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum_partition_by_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 ) AS _stage_inner\n), _cm_orders__customers__spen_d0a1809f_ers_regions_name_window_1y AS (\n SELECT\n _base.\"customers.signup_at_month\",\n CAST(CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS DOUBLE PRECISION) AS \"customers.spend_wsum_weight_730ac295_by_regions_name_window_1y\"\n FROM (\n SELECT\n \"_e\".\"orders.customers.signup_at\" AS \"customers.signup_at_month\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n _cm_orders__amount_sum_partition_by_regions_name.\"amount_sum_partition_by_customers_regions_name\" AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN _cm_orders__amount_sum_partition_by_regions_name\n ON regions.name IS NOT DISTINCT FROM _cm_orders__amount_sum_partition_by_regions_name.\"customers__regions__name\"\n ) AS _src\n ON _src._w_time >= _base.\"customers.signup_at_month\" + INTERVAL '1 MONTH' - INTERVAL '1 YEAR'\n AND _src._w_time < _base.\"customers.signup_at_month\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"customers.signup_at_month\"\n)\nSELECT\n _base.\"orders.customers.signup_at\",\n _cm_orders__customers__spen_d0a1809f_ers_regions_name_window_1y.\"customers.spend_wsum_weight_730ac295_by_regions_name_window_1y\" AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spen_d0a1809f_ers_regions_name_window_1y\n ON _base.\"orders.customers.signup_at\" IS NOT DISTINCT FROM _cm_orders__customers__spen_d0a1809f_ers_regions_name_window_1y.\"customers.signup_at_month\"", diff --git a/tests/golden/dev1868_sql_baseline.json b/tests/golden/dev1868_sql_baseline.json index bf2726c4c..d498b2a7d 100644 --- a/tests/golden/dev1868_sql_baseline.json +++ b/tests/golden/dev1868_sql_baseline.json @@ -39,27 +39,27 @@ "error": "ComputedDimensionError", "message": "ComputedDimensionError: The aggregate 'sum(amount)' inside the transform in the computed dimension must declare partition_by= explicitly: the ungrained default (the query's own dimensions) would include the dimension being defined.\n at dimension 'b'" }, - "ts/series_cm_leaf::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), _cm_sales__regions__factor_sum AS (\n SELECT\n CAST(SUM(regions.factor) AS FLOAT64) AS `regions___factor_sum`\n FROM regions AS regions\n), base AS (\n SELECT\n _base.`sales___ordered_at`,\n _base.`sales___revenue_sum`,\n _cm_sales__regions__factor_sum.`regions___factor_sum` AS `regions___factor_sum`\n FROM _base\n CROSS JOIN _cm_sales__regions__factor_sum\n), shifted_t AS (\n SELECT\n `sales___ordered_at` AS `sales___ordered_at`,\n `sales___revenue_sum` + `regions___factor_sum` AS `t__ts`\n FROM base\n), sjoin_t AS (\n SELECT\n base.`sales___ordered_at`,\n base.`sales___revenue_sum`,\n base.`regions___factor_sum`,\n shifted_t.`t__ts` AS `sales___t`\n FROM base\n LEFT JOIN shifted_t\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_t.`sales___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `sales___ordered_at`,\n `sales___t`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `regions___factor_sum`,\n `sales___t`\n FROM sjoin_t\n) AS _outer", + "ts/series_cm_leaf::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), _cm_sales__regions__factor_sum AS (\n SELECT\n CAST(SUM(regions.factor) AS FLOAT64) AS `regions___factor_sum`\n FROM regions AS regions\n), base AS (\n SELECT\n _base.`sales___ordered_at`,\n _base.`sales___revenue_sum`,\n _cm_sales__regions__factor_sum.`regions___factor_sum` AS `regions___factor_sum`\n FROM _base\n CROSS JOIN _cm_sales__regions__factor_sum\n), shifted_t AS (\n SELECT\n `sales___ordered_at` AS `sales___ordered_at`,\n `sales___revenue_sum` + `regions___factor_sum` AS `t__ts`\n FROM base\n), sjoin_t AS (\n SELECT\n base.`sales___ordered_at`,\n base.`sales___revenue_sum`,\n base.`regions___factor_sum`,\n shifted_t.`t__ts` AS `sales___t`\n FROM base\n LEFT JOIN shifted_t\n ON DATETIME_ADD(CAST(base.`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`sales___ordered_at` AS DATETIME)\n)\nSELECT\n `sales___ordered_at`,\n `sales___t`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `regions___factor_sum`,\n `sales___t`\n FROM sjoin_t\n) AS _outer", "ts/series_cm_leaf::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), _cm_sales__regions__factor_sum AS (\n SELECT\n CAST(SUM(regions.factor) AS DOUBLE) AS \"regions.factor_sum\"\n FROM regions AS regions\n), base AS (\n SELECT\n _base.\"sales.ordered_at\",\n _base.\"sales.revenue_sum\",\n _cm_sales__regions__factor_sum.\"regions.factor_sum\" AS \"regions.factor_sum\"\n FROM _base\n CROSS JOIN _cm_sales__regions__factor_sum\n), shifted_t AS (\n SELECT\n \"sales.ordered_at\" AS \"sales.ordered_at\",\n \"sales.revenue_sum\" + \"regions.factor_sum\" AS \"t__ts\"\n FROM base\n), sjoin_t AS (\n SELECT\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n base.\"regions.factor_sum\",\n shifted_t.\"t__ts\" AS \"sales.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"sales.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.t\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"regions.factor_sum\",\n \"sales.t\"\n FROM sjoin_t\n) AS _outer", "ts/series_cm_leaf::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), _cm_sales__regions__factor_sum AS (\n SELECT\n CAST(SUM(regions.factor) AS DOUBLE PRECISION) AS \"regions.factor_sum\"\n FROM regions AS regions\n), base AS (\n SELECT\n _base.\"sales.ordered_at\",\n _base.\"sales.revenue_sum\",\n _cm_sales__regions__factor_sum.\"regions.factor_sum\" AS \"regions.factor_sum\"\n FROM _base\n CROSS JOIN _cm_sales__regions__factor_sum\n), shifted_t AS (\n SELECT\n \"sales.ordered_at\" AS \"sales.ordered_at\",\n \"sales.revenue_sum\" + \"regions.factor_sum\" AS \"t__ts\"\n FROM base\n), sjoin_t AS (\n SELECT\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n base.\"regions.factor_sum\",\n shifted_t.\"t__ts\" AS \"sales.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"sales.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.t\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"regions.factor_sum\",\n \"sales.t\"\n FROM sjoin_t\n) AS _outer", "ts/series_cm_leaf::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\"\n FROM sales AS sales\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), _cm_sales__regions__factor_sum AS (\n SELECT\n CAST(SUM(regions.factor) AS REAL) AS \"regions.factor_sum\"\n FROM regions AS regions\n), base AS (\n SELECT\n _base.\"sales.ordered_at\",\n _base.\"sales.revenue_sum\",\n _cm_sales__regions__factor_sum.\"regions.factor_sum\" AS \"regions.factor_sum\"\n FROM _base\n CROSS JOIN _cm_sales__regions__factor_sum\n), shifted_t AS (\n SELECT\n \"sales.ordered_at\" AS \"sales.ordered_at\",\n \"sales.revenue_sum\" + \"regions.factor_sum\" AS \"t__ts\"\n FROM base\n), sjoin_t AS (\n SELECT\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n base.\"regions.factor_sum\",\n shifted_t.\"t__ts\" AS \"sales.t\"\n FROM base\n LEFT JOIN shifted_t\n ON SLAYER_DATE_ADD(base.\"sales.ordered_at\", -1, 'month') IS shifted_t.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.t\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"regions.factor_sum\",\n \"sales.t\"\n FROM sjoin_t\n) AS _outer", "ts/series_cm_leaf::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(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 DATETRUNC(month, sales.ordered_at)\n), _cm_sales__regions__factor_sum AS (\n SELECT\n CAST(SUM(regions.factor) AS FLOAT) AS [regions___factor_sum]\n FROM regions AS regions\n), base AS (\n SELECT\n _base.[sales___ordered_at] AS [sales___ordered_at],\n _base.[sales___revenue_sum] AS [sales___revenue_sum],\n _cm_sales__regions__factor_sum.[regions___factor_sum] AS [regions___factor_sum]\n FROM _base\n CROSS JOIN _cm_sales__regions__factor_sum\n), shifted_t AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] + [regions___factor_sum] AS [t__ts]\n FROM base\n), sjoin_t AS (\n SELECT\n base.[sales___ordered_at] AS [sales___ordered_at],\n base.[sales___revenue_sum] AS [sales___revenue_sum],\n base.[regions___factor_sum] AS [regions___factor_sum],\n shifted_t.[t__ts] AS [sales___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) = shifted_t.[sales___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[sales___ordered_at]) IS NULL\n AND NOT shifted_t.[sales___ordered_at] IS NULL\n )\n OR (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) IS NULL\n AND shifted_t.[sales___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [sales___ordered_at],\n [sales___t]\nFROM (\n SELECT\n [sales___ordered_at],\n [sales___revenue_sum],\n [regions___factor_sum],\n [sales___t]\n FROM sjoin_t\n) AS _outer", - "ts/series_filters_once::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 WHERE\n sales.status = 'a'\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), step1 AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n SUM(`sales___revenue_sum`) OVER (ORDER BY `sales___ordered_at`) AS `sales____cumsum_inner`\n FROM base\n), shifted_t AS (\n SELECT\n `sales___ordered_at` AS `sales___ordered_at`,\n `sales____cumsum_inner` AS `sales____cumsum_inner`\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.`sales___ordered_at`,\n step1.`sales___revenue_sum`,\n step1.`sales____cumsum_inner`,\n shifted_t.`sales____cumsum_inner` AS `sales___t`\n FROM step1\n LEFT JOIN shifted_t\n ON CAST(DATETIME_ADD(CAST(CAST(step1.`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`sales___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `sales___ordered_at`,\n `sales___t`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____cumsum_inner`,\n `sales___t`\n FROM sjoin_t\n) AS _outer", + "ts/series_filters_once::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 WHERE\n sales.status = 'a'\n GROUP BY\n DATE_TRUNC(sales.ordered_at, MONTH)\n), step1 AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n SUM(`sales___revenue_sum`) OVER (ORDER BY `sales___ordered_at`) AS `sales____cumsum_inner`\n FROM base\n), shifted_t AS (\n SELECT\n `sales___ordered_at` AS `sales___ordered_at`,\n `sales____cumsum_inner` AS `sales____cumsum_inner`\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.`sales___ordered_at`,\n step1.`sales___revenue_sum`,\n step1.`sales____cumsum_inner`,\n shifted_t.`sales____cumsum_inner` AS `sales___t`\n FROM step1\n LEFT JOIN shifted_t\n ON DATETIME_ADD(CAST(step1.`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`sales___ordered_at` AS DATETIME)\n)\nSELECT\n `sales___ordered_at`,\n `sales___t`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____cumsum_inner`,\n `sales___t`\n FROM sjoin_t\n) AS _outer", "ts/series_filters_once::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 WHERE\n sales.status = 'a'\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), step1 AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\"sales.revenue_sum\") OVER (ORDER BY \"sales.ordered_at\") AS \"sales._cumsum_inner\"\n FROM base\n), shifted_t AS (\n SELECT\n \"sales.ordered_at\" AS \"sales.ordered_at\",\n \"sales._cumsum_inner\" AS \"sales._cumsum_inner\"\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.\"sales.ordered_at\",\n step1.\"sales.revenue_sum\",\n step1.\"sales._cumsum_inner\",\n shifted_t.\"sales._cumsum_inner\" AS \"sales.t\"\n FROM step1\n LEFT JOIN shifted_t\n ON step1.\"sales.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.t\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n \"sales.t\"\n FROM sjoin_t\n) AS _outer", "ts/series_filters_once::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 WHERE\n sales.status = 'a'\n GROUP BY\n DATE_TRUNC('MONTH', sales.ordered_at)\n), step1 AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\"sales.revenue_sum\") OVER (ORDER BY \"sales.ordered_at\") AS \"sales._cumsum_inner\"\n FROM base\n), shifted_t AS (\n SELECT\n \"sales.ordered_at\" AS \"sales.ordered_at\",\n \"sales._cumsum_inner\" AS \"sales._cumsum_inner\"\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.\"sales.ordered_at\",\n step1.\"sales.revenue_sum\",\n step1.\"sales._cumsum_inner\",\n shifted_t.\"sales._cumsum_inner\" AS \"sales.t\"\n FROM step1\n LEFT JOIN shifted_t\n ON step1.\"sales.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.t\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n \"sales.t\"\n FROM sjoin_t\n) AS _outer", "ts/series_filters_once::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\"\n FROM sales AS sales\n WHERE\n sales.status = 'a'\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), step1 AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\"sales.revenue_sum\") OVER (ORDER BY \"sales.ordered_at\") AS \"sales._cumsum_inner\"\n FROM base\n), shifted_t AS (\n SELECT\n \"sales.ordered_at\" AS \"sales.ordered_at\",\n \"sales._cumsum_inner\" AS \"sales._cumsum_inner\"\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.\"sales.ordered_at\",\n step1.\"sales.revenue_sum\",\n step1.\"sales._cumsum_inner\",\n shifted_t.\"sales._cumsum_inner\" AS \"sales.t\"\n FROM step1\n LEFT JOIN shifted_t\n ON SLAYER_DATE_ADD(step1.\"sales.ordered_at\", -1, 'month') IS shifted_t.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.t\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n \"sales.t\"\n FROM sjoin_t\n) AS _outer", "ts/series_filters_once::tsql": "WITH base AS (\n SELECT\n DATETRUNC(month, sales.ordered_at) AS [sales___ordered_at],\n SUM(sales.revenue) AS [sales___revenue_sum]\n FROM sales AS sales\n WHERE\n sales.status = 'a'\n GROUP BY\n DATETRUNC(month, sales.ordered_at)\n), step1 AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___revenue_sum] AS [sales___revenue_sum],\n SUM([sales___revenue_sum]) OVER (ORDER BY [sales___ordered_at]) AS [sales____cumsum_inner]\n FROM base\n), shifted_t AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales____cumsum_inner] AS [sales____cumsum_inner]\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.[sales___ordered_at] AS [sales___ordered_at],\n step1.[sales___revenue_sum] AS [sales___revenue_sum],\n step1.[sales____cumsum_inner] AS [sales____cumsum_inner],\n shifted_t.[sales____cumsum_inner] AS [sales___t]\n FROM step1\n LEFT JOIN shifted_t\n ON (\n (\n DATEADD(MONTH, -1, step1.[sales___ordered_at]) = shifted_t.[sales___ordered_at]\n AND NOT DATEADD(MONTH, -1, step1.[sales___ordered_at]) IS NULL\n AND NOT shifted_t.[sales___ordered_at] IS NULL\n )\n OR (\n DATEADD(MONTH, -1, step1.[sales___ordered_at]) IS NULL\n AND shifted_t.[sales___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [sales___ordered_at],\n [sales___t]\nFROM (\n SELECT\n [sales___ordered_at],\n [sales___revenue_sum],\n [sales____cumsum_inner],\n [sales___t]\n FROM sjoin_t\n) AS _outer", - "ts/series_in_pred::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_t AS (\n SELECT\n `sales___ordered_at` AS `sales___ordered_at`,\n `sales___revenue_sum` IN (100, 999) AS `t__ts`\n FROM base\n), sjoin_t AS (\n SELECT\n base.`sales___ordered_at`,\n base.`sales___revenue_sum`,\n shifted_t.`t__ts` AS `sales___t`\n FROM base\n LEFT JOIN shifted_t\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_t.`sales___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `sales___ordered_at`,\n `sales___t`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___t`\n FROM sjoin_t\n) AS _outer", + "ts/series_in_pred::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_t AS (\n SELECT\n `sales___ordered_at` AS `sales___ordered_at`,\n `sales___revenue_sum` IN (100, 999) AS `t__ts`\n FROM base\n), sjoin_t AS (\n SELECT\n base.`sales___ordered_at`,\n base.`sales___revenue_sum`,\n shifted_t.`t__ts` AS `sales___t`\n FROM base\n LEFT JOIN shifted_t\n ON DATETIME_ADD(CAST(base.`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`sales___ordered_at` AS DATETIME)\n)\nSELECT\n `sales___ordered_at`,\n `sales___t`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales___t`\n FROM sjoin_t\n) AS _outer", "ts/series_in_pred::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_t AS (\n SELECT\n \"sales.ordered_at\" AS \"sales.ordered_at\",\n \"sales.revenue_sum\" IN (100, 999) AS \"t__ts\"\n FROM base\n), sjoin_t AS (\n SELECT\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n shifted_t.\"t__ts\" AS \"sales.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"sales.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.t\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.t\"\n FROM sjoin_t\n) AS _outer", "ts/series_in_pred::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_t AS (\n SELECT\n \"sales.ordered_at\" AS \"sales.ordered_at\",\n \"sales.revenue_sum\" IN (100, 999) AS \"t__ts\"\n FROM base\n), sjoin_t AS (\n SELECT\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n shifted_t.\"t__ts\" AS \"sales.t\"\n FROM base\n LEFT JOIN shifted_t\n ON base.\"sales.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.t\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.t\"\n FROM sjoin_t\n) AS _outer", "ts/series_in_pred::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\"\n FROM sales AS sales\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), shifted_t AS (\n SELECT\n \"sales.ordered_at\" AS \"sales.ordered_at\",\n \"sales.revenue_sum\" IN (100, 999) AS \"t__ts\"\n FROM base\n), sjoin_t AS (\n SELECT\n base.\"sales.ordered_at\",\n base.\"sales.revenue_sum\",\n shifted_t.\"t__ts\" AS \"sales.t\"\n FROM base\n LEFT JOIN shifted_t\n ON SLAYER_DATE_ADD(base.\"sales.ordered_at\", -1, 'month') IS shifted_t.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.t\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales.t\"\n FROM sjoin_t\n) AS _outer", "ts/series_in_pred::tsql": "WITH base AS (\n SELECT\n DATETRUNC(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 DATETRUNC(month, sales.ordered_at)\n), shifted_t AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n CAST(CASE\n WHEN [sales___revenue_sum] IN (100, 999)\n THEN 1\n WHEN NOT (\n [sales___revenue_sum] IN (100, 999)\n )\n THEN 0\n END AS BIT) AS [t__ts]\n FROM base\n), sjoin_t AS (\n SELECT\n base.[sales___ordered_at] AS [sales___ordered_at],\n base.[sales___revenue_sum] AS [sales___revenue_sum],\n shifted_t.[t__ts] AS [sales___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) = shifted_t.[sales___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[sales___ordered_at]) IS NULL\n AND NOT shifted_t.[sales___ordered_at] IS NULL\n )\n OR (\n DATEADD(MONTH, -1, base.[sales___ordered_at]) IS NULL\n AND shifted_t.[sales___ordered_at] IS NULL\n )\n )\n)\nSELECT\n [sales___ordered_at],\n [sales___t]\nFROM (\n SELECT\n [sales___ordered_at],\n [sales___revenue_sum],\n [sales___t]\n FROM sjoin_t\n) AS _outer", - "ts/series_nested_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 FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC(sales.ordered_at, MONTH)\n), step1 AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n SUM(`sales___revenue_sum`) OVER (PARTITION BY `sales___store` ORDER BY `sales___ordered_at`) AS `sales____cumsum_inner`\n FROM base\n), shifted_t AS (\n SELECT\n `sales___ordered_at` AS `sales___ordered_at`,\n `sales___store` AS `sales___store`,\n `sales____cumsum_inner` AS `sales____cumsum_inner`\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.`sales___store`,\n step1.`sales___ordered_at`,\n step1.`sales___revenue_sum`,\n step1.`sales____cumsum_inner`,\n shifted_t.`sales____cumsum_inner` AS `sales___t`\n FROM step1\n LEFT JOIN shifted_t\n ON CAST(DATETIME_ADD(CAST(CAST(step1.`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`sales___ordered_at` AS TIMESTAMP)\n AND step1.`sales___store` IS NOT DISTINCT FROM shifted_t.`sales___store`\n)\nSELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___t`\nFROM (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____cumsum_inner`,\n `sales___t`\n FROM sjoin_t\n) AS _outer", + "ts/series_nested_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 FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC(sales.ordered_at, MONTH)\n), step1 AS (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n SUM(`sales___revenue_sum`) OVER (PARTITION BY `sales___store` ORDER BY `sales___ordered_at`) AS `sales____cumsum_inner`\n FROM base\n), shifted_t AS (\n SELECT\n `sales___ordered_at` AS `sales___ordered_at`,\n `sales___store` AS `sales___store`,\n `sales____cumsum_inner` AS `sales____cumsum_inner`\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.`sales___store`,\n step1.`sales___ordered_at`,\n step1.`sales___revenue_sum`,\n step1.`sales____cumsum_inner`,\n shifted_t.`sales____cumsum_inner` AS `sales___t`\n FROM step1\n LEFT JOIN shifted_t\n ON DATETIME_ADD(CAST(step1.`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`sales___ordered_at` AS DATETIME)\n AND step1.`sales___store` IS NOT DISTINCT FROM shifted_t.`sales___store`\n)\nSELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___t`\nFROM (\n SELECT\n `sales___store`,\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____cumsum_inner`,\n `sales___t`\n FROM sjoin_t\n) AS _outer", "ts/series_nested_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 FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), step1 AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\"sales.revenue_sum\") OVER (PARTITION BY \"sales.store\" ORDER BY \"sales.ordered_at\") AS \"sales._cumsum_inner\"\n FROM base\n), shifted_t AS (\n SELECT\n \"sales.ordered_at\" AS \"sales.ordered_at\",\n \"sales.store\" AS \"sales.store\",\n \"sales._cumsum_inner\" AS \"sales._cumsum_inner\"\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.\"sales.store\",\n step1.\"sales.ordered_at\",\n step1.\"sales.revenue_sum\",\n step1.\"sales._cumsum_inner\",\n shifted_t.\"sales._cumsum_inner\" AS \"sales.t\"\n FROM step1\n LEFT JOIN shifted_t\n ON step1.\"sales.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"sales.ordered_at\"\n AND step1.\"sales.store\" IS NOT DISTINCT FROM shifted_t.\"sales.store\"\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.t\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n \"sales.t\"\n FROM sjoin_t\n) AS _outer", "ts/series_nested_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 FROM sales AS sales\n GROUP BY\n sales.store,\n DATE_TRUNC('MONTH', sales.ordered_at)\n), step1 AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\"sales.revenue_sum\") OVER (PARTITION BY \"sales.store\" ORDER BY \"sales.ordered_at\") AS \"sales._cumsum_inner\"\n FROM base\n), shifted_t AS (\n SELECT\n \"sales.ordered_at\" AS \"sales.ordered_at\",\n \"sales.store\" AS \"sales.store\",\n \"sales._cumsum_inner\" AS \"sales._cumsum_inner\"\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.\"sales.store\",\n step1.\"sales.ordered_at\",\n step1.\"sales.revenue_sum\",\n step1.\"sales._cumsum_inner\",\n shifted_t.\"sales._cumsum_inner\" AS \"sales.t\"\n FROM step1\n LEFT JOIN shifted_t\n ON step1.\"sales.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"sales.ordered_at\"\n AND step1.\"sales.store\" IS NOT DISTINCT FROM shifted_t.\"sales.store\"\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.t\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n \"sales.t\"\n FROM sjoin_t\n) AS _outer", "ts/series_nested_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 FROM sales AS sales\n GROUP BY\n sales.store,\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), step1 AS (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\"sales.revenue_sum\") OVER (PARTITION BY \"sales.store\" ORDER BY \"sales.ordered_at\") AS \"sales._cumsum_inner\"\n FROM base\n), shifted_t AS (\n SELECT\n \"sales.ordered_at\" AS \"sales.ordered_at\",\n \"sales.store\" AS \"sales.store\",\n \"sales._cumsum_inner\" AS \"sales._cumsum_inner\"\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.\"sales.store\",\n step1.\"sales.ordered_at\",\n step1.\"sales.revenue_sum\",\n step1.\"sales._cumsum_inner\",\n shifted_t.\"sales._cumsum_inner\" AS \"sales.t\"\n FROM step1\n LEFT JOIN shifted_t\n ON SLAYER_DATE_ADD(step1.\"sales.ordered_at\", -1, 'month') IS shifted_t.\"sales.ordered_at\"\n AND step1.\"sales.store\" IS shifted_t.\"sales.store\"\n)\nSELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.t\"\nFROM (\n SELECT\n \"sales.store\",\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n \"sales.t\"\n FROM sjoin_t\n) AS _outer", "ts/series_nested_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 FROM sales AS sales\n GROUP BY\n sales.store,\n DATETRUNC(month, sales.ordered_at)\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 SUM([sales___revenue_sum]) OVER (PARTITION BY [sales___store] ORDER BY [sales___ordered_at]) AS [sales____cumsum_inner]\n FROM base\n), shifted_t AS (\n SELECT\n [sales___ordered_at] AS [sales___ordered_at],\n [sales___store] AS [sales___store],\n [sales____cumsum_inner] AS [sales____cumsum_inner]\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.[sales___store] AS [sales___store],\n step1.[sales___ordered_at] AS [sales___ordered_at],\n step1.[sales___revenue_sum] AS [sales___revenue_sum],\n step1.[sales____cumsum_inner] AS [sales____cumsum_inner],\n shifted_t.[sales____cumsum_inner] AS [sales___t]\n FROM step1\n LEFT JOIN shifted_t\n ON (\n (\n DATEADD(MONTH, -1, step1.[sales___ordered_at]) = shifted_t.[sales___ordered_at]\n AND NOT DATEADD(MONTH, -1, step1.[sales___ordered_at]) IS NULL\n AND NOT shifted_t.[sales___ordered_at] IS NULL\n )\n OR (\n DATEADD(MONTH, -1, step1.[sales___ordered_at]) IS NULL\n AND shifted_t.[sales___ordered_at] IS NULL\n )\n )\n AND (\n (\n step1.[sales___store] = shifted_t.[sales___store]\n AND NOT step1.[sales___store] IS NULL\n AND NOT shifted_t.[sales___store] IS NULL\n )\n OR (\n step1.[sales___store] IS NULL AND shifted_t.[sales___store] IS NULL\n )\n )\n)\nSELECT\n [sales___store],\n [sales___ordered_at],\n [sales___t]\nFROM (\n SELECT\n [sales___store],\n [sales___ordered_at],\n [sales___revenue_sum],\n [sales____cumsum_inner],\n [sales___t]\n FROM sjoin_t\n) AS _outer", - "ts/series_nested_cumsum::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), step1 AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n SUM(`sales___revenue_sum`) OVER (ORDER BY `sales___ordered_at`) AS `sales____cumsum_inner`\n FROM base\n), shifted_t AS (\n SELECT\n `sales___ordered_at` AS `sales___ordered_at`,\n `sales____cumsum_inner` AS `sales____cumsum_inner`\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.`sales___ordered_at`,\n step1.`sales___revenue_sum`,\n step1.`sales____cumsum_inner`,\n shifted_t.`sales____cumsum_inner` AS `sales___t`\n FROM step1\n LEFT JOIN shifted_t\n ON CAST(DATETIME_ADD(CAST(CAST(step1.`sales___ordered_at` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) IS NOT DISTINCT FROM CAST(shifted_t.`sales___ordered_at` AS TIMESTAMP)\n)\nSELECT\n `sales___ordered_at`,\n `sales___t`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____cumsum_inner`,\n `sales___t`\n FROM sjoin_t\n) AS _outer", + "ts/series_nested_cumsum::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), step1 AS (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n SUM(`sales___revenue_sum`) OVER (ORDER BY `sales___ordered_at`) AS `sales____cumsum_inner`\n FROM base\n), shifted_t AS (\n SELECT\n `sales___ordered_at` AS `sales___ordered_at`,\n `sales____cumsum_inner` AS `sales____cumsum_inner`\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.`sales___ordered_at`,\n step1.`sales___revenue_sum`,\n step1.`sales____cumsum_inner`,\n shifted_t.`sales____cumsum_inner` AS `sales___t`\n FROM step1\n LEFT JOIN shifted_t\n ON DATETIME_ADD(CAST(step1.`sales___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`sales___ordered_at` AS DATETIME)\n)\nSELECT\n `sales___ordered_at`,\n `sales___t`\nFROM (\n SELECT\n `sales___ordered_at`,\n `sales___revenue_sum`,\n `sales____cumsum_inner`,\n `sales___t`\n FROM sjoin_t\n) AS _outer", "ts/series_nested_cumsum::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), step1 AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\"sales.revenue_sum\") OVER (ORDER BY \"sales.ordered_at\") AS \"sales._cumsum_inner\"\n FROM base\n), shifted_t AS (\n SELECT\n \"sales.ordered_at\" AS \"sales.ordered_at\",\n \"sales._cumsum_inner\" AS \"sales._cumsum_inner\"\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.\"sales.ordered_at\",\n step1.\"sales.revenue_sum\",\n step1.\"sales._cumsum_inner\",\n shifted_t.\"sales._cumsum_inner\" AS \"sales.t\"\n FROM step1\n LEFT JOIN shifted_t\n ON step1.\"sales.ordered_at\" - INTERVAL 1 MONTH IS NOT DISTINCT FROM shifted_t.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.t\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n \"sales.t\"\n FROM sjoin_t\n) AS _outer", "ts/series_nested_cumsum::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), step1 AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\"sales.revenue_sum\") OVER (ORDER BY \"sales.ordered_at\") AS \"sales._cumsum_inner\"\n FROM base\n), shifted_t AS (\n SELECT\n \"sales.ordered_at\" AS \"sales.ordered_at\",\n \"sales._cumsum_inner\" AS \"sales._cumsum_inner\"\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.\"sales.ordered_at\",\n step1.\"sales.revenue_sum\",\n step1.\"sales._cumsum_inner\",\n shifted_t.\"sales._cumsum_inner\" AS \"sales.t\"\n FROM step1\n LEFT JOIN shifted_t\n ON step1.\"sales.ordered_at\" - INTERVAL '1 MONTH' IS NOT DISTINCT FROM shifted_t.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.t\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n \"sales.t\"\n FROM sjoin_t\n) AS _outer", "ts/series_nested_cumsum::sqlite": "WITH base AS (\n SELECT\n STRFTIME('%Y-%m-01', sales.ordered_at) AS \"sales.ordered_at\",\n SUM(sales.revenue) AS \"sales.revenue_sum\"\n FROM sales AS sales\n GROUP BY\n STRFTIME('%Y-%m-01', sales.ordered_at)\n), step1 AS (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n SUM(\"sales.revenue_sum\") OVER (ORDER BY \"sales.ordered_at\") AS \"sales._cumsum_inner\"\n FROM base\n), shifted_t AS (\n SELECT\n \"sales.ordered_at\" AS \"sales.ordered_at\",\n \"sales._cumsum_inner\" AS \"sales._cumsum_inner\"\n FROM step1\n), sjoin_t AS (\n SELECT\n step1.\"sales.ordered_at\",\n step1.\"sales.revenue_sum\",\n step1.\"sales._cumsum_inner\",\n shifted_t.\"sales._cumsum_inner\" AS \"sales.t\"\n FROM step1\n LEFT JOIN shifted_t\n ON SLAYER_DATE_ADD(step1.\"sales.ordered_at\", -1, 'month') IS shifted_t.\"sales.ordered_at\"\n)\nSELECT\n \"sales.ordered_at\",\n \"sales.t\"\nFROM (\n SELECT\n \"sales.ordered_at\",\n \"sales.revenue_sum\",\n \"sales._cumsum_inner\",\n \"sales.t\"\n FROM sjoin_t\n) AS _outer", @@ -84,7 +84,7 @@ "w1/order::postgres": "WITH _base AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.s\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n WHERE\n NOT customers.tier IS NULL\n GROUP BY\n customers.tier\n), _cm_orders__customers__spen_bf4ad85f_artition_by_customers_tier AS (\n SELECT\n _val_0 AS \"customers.tier\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS DOUBLE PRECISION) AS \"customers.spend_last_signup_at_partition_by_tier\"\n FROM (\n SELECT\n customers.tier AS _val_0,\n customers.spend AS _val_1,\n ROW_NUMBER() OVER (PARTITION BY customers.tier ORDER BY customers.signup_at DESC) AS _ranked_rn\n FROM customers AS customers\n WHERE\n NOT customers.tier IS NULL\n ) AS _ranked_src\n GROUP BY\n _val_0\n)\nSELECT\n _base.\"orders.customers.tier\",\n _base.\"orders.s\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spen_bf4ad85f_artition_by_customers_tier\n ON _base.\"orders.customers.tier\" IS NOT DISTINCT FROM _cm_orders__customers__spen_bf4ad85f_artition_by_customers_tier.\"customers.tier\"\nORDER BY\n _cm_orders__customers__spen_bf4ad85f_artition_by_customers_tier.\"customers.spend_last_signup_at_partition_by_tier\" DESC NULLS LAST", "w1/order::sqlite": "WITH _base AS (\n SELECT\n customers.tier AS \"orders.customers.tier\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.s\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n WHERE\n NOT customers.tier IS NULL\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_tier AS (\n SELECT\n _val_0 AS \"customers.tier\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS REAL) AS \"customers.spend_last_signup_at_partition_by_tier\"\n FROM (\n SELECT\n customers.tier AS _val_0,\n customers.spend AS _val_1,\n ROW_NUMBER() OVER (PARTITION BY customers.tier ORDER BY customers.signup_at DESC) AS _ranked_rn\n FROM customers AS customers\n WHERE\n NOT customers.tier IS NULL\n ) AS _ranked_src\n GROUP BY\n _val_0\n)\nSELECT\n _base.\"orders.customers.tier\",\n _base.\"orders.s\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_tier\n ON _base.\"orders.customers.tier\" IS _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_tier.\"customers.tier\"\nORDER BY\n _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_tier.\"customers.spend_last_signup_at_partition_by_tier\" DESC", "w1/order::tsql": "WITH _base AS (\n SELECT\n customers.tier AS [orders___customers___tier],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___s]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n WHERE\n NOT customers.tier IS NULL\n GROUP BY\n customers.tier\n), _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_tier AS (\n SELECT\n _val_0 AS [customers___tier],\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS FLOAT) AS [customers___spend_last_signup_at_partition_by_tier]\n FROM (\n SELECT\n customers.tier AS _val_0,\n customers.spend AS _val_1,\n ROW_NUMBER() OVER (PARTITION BY customers.tier ORDER BY customers.signup_at DESC) AS _ranked_rn\n FROM customers AS customers\n WHERE\n NOT customers.tier IS NULL\n ) AS _ranked_src\n GROUP BY\n _val_0\n)\nSELECT\n _base.[orders___customers___tier],\n _base.[orders___s]\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_tier\n ON (\n (\n _base.[orders___customers___tier] = _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_tier.[customers___tier]\n AND NOT _base.[orders___customers___tier] IS NULL\n AND NOT _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_tier.[customers___tier] IS NULL\n )\n OR (\n _base.[orders___customers___tier] IS NULL\n AND _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_tier.[customers___tier] IS NULL\n )\n )\nORDER BY\n _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_tier.[customers___spend_last_signup_at_partition_by_tier] DESC", - "w2/change_last_region::bigquery": "WITH _base AS (\n SELECT\n customers__regions.name AS `orders___customers___regions___name`,\n DATE_TRUNC(orders.ordered_at, MONTH) 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 GROUP BY\n customers__regions.name,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name AS (\n SELECT\n _val_0 AS `customers___regions___name`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS FLOAT64) AS `customers___spend_last_signup_at_partition_by_regions_name`\n FROM (\n SELECT\n regions.name AS _val_0,\n customers.spend AS _val_1,\n ROW_NUMBER() OVER (PARTITION BY regions.name ORDER BY customers.signup_at DESC) AS _ranked_rn\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n ) AS _ranked_src\n GROUP BY\n _val_0\n), base AS (\n SELECT\n _base.`orders___customers___regions___name`,\n _base.`orders___ordered_at`,\n _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name.`customers___spend_last_signup_at_partition_by_regions_name` AS `customers___spend_last_signup_at_partition_by_regions_name`\n FROM _base\n LEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name\n ON _base.`orders___customers___regions___name` IS NOT DISTINCT FROM _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name.`customers___regions___name`\n), _base_2 AS (\n SELECT\n customers__regions.name AS `orders___customers___regions___name`,\n DATE_TRUNC(orders.ordered_at, MONTH) 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 GROUP BY\n customers__regions.name,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.`orders___customers___regions___name`,\n _base_2.`orders___ordered_at`,\n _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name.`customers___spend_last_signup_at_partition_by_regions_name` AS `orders___customers___spend_last_customers_signup_at_partition_by_customers_regions_name`\n FROM _base_2\n LEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name\n ON _base_2.`orders___customers___regions___name` IS NOT DISTINCT FROM _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name.`customers___regions___name`\n), sjoin__time_shift_inner AS (\n SELECT\n base.`orders___customers___regions___name`,\n base.`orders___ordered_at`,\n base.`customers___spend_last_signup_at_partition_by_regions_name`,\n shifted__time_shift_inner.`orders___customers___spend_last_customers_signup_at_partition_by_customers_regions_name` AS `orders____time_shift_inner`\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.`orders___customers___regions___name` IS NOT DISTINCT FROM shifted__time_shift_inner.`orders___customers___regions___name`\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__time_shift_inner.`orders___ordered_at` AS TIMESTAMP)\n), step1 AS (\n SELECT\n `orders___customers___regions___name`,\n `orders___ordered_at`,\n `customers___spend_last_signup_at_partition_by_regions_name`,\n `orders____time_shift_inner`,\n `customers___spend_last_signup_at_partition_by_regions_name` - `orders____time_shift_inner` AS `orders___ch`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___customers___regions___name`,\n `orders___ordered_at`,\n `orders___ch`\nFROM (\n SELECT\n `orders___customers___regions___name`,\n `orders___ordered_at`,\n `customers___spend_last_signup_at_partition_by_regions_name`,\n `orders____time_shift_inner`,\n `orders___ch`\n FROM step1\n) AS _outer", + "w2/change_last_region::bigquery": "WITH _base AS (\n SELECT\n customers__regions.name AS `orders___customers___regions___name`,\n DATE_TRUNC(orders.ordered_at, MONTH) 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 GROUP BY\n customers__regions.name,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name AS (\n SELECT\n _val_0 AS `customers___regions___name`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS FLOAT64) AS `customers___spend_last_signup_at_partition_by_regions_name`\n FROM (\n SELECT\n regions.name AS _val_0,\n customers.spend AS _val_1,\n ROW_NUMBER() OVER (PARTITION BY regions.name ORDER BY customers.signup_at DESC) AS _ranked_rn\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n ) AS _ranked_src\n GROUP BY\n _val_0\n), base AS (\n SELECT\n _base.`orders___customers___regions___name`,\n _base.`orders___ordered_at`,\n _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name.`customers___spend_last_signup_at_partition_by_regions_name` AS `customers___spend_last_signup_at_partition_by_regions_name`\n FROM _base\n LEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name\n ON _base.`orders___customers___regions___name` IS NOT DISTINCT FROM _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name.`customers___regions___name`\n), _base_2 AS (\n SELECT\n customers__regions.name AS `orders___customers___regions___name`,\n DATE_TRUNC(orders.ordered_at, MONTH) 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 GROUP BY\n customers__regions.name,\n DATE_TRUNC(orders.ordered_at, MONTH)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.`orders___customers___regions___name`,\n _base_2.`orders___ordered_at`,\n _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name.`customers___spend_last_signup_at_partition_by_regions_name` AS `orders___customers___spend_last_customers_signup_at_partition_by_customers_regions_name`\n FROM _base_2\n LEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name\n ON _base_2.`orders___customers___regions___name` IS NOT DISTINCT FROM _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name.`customers___regions___name`\n), sjoin__time_shift_inner AS (\n SELECT\n base.`orders___customers___regions___name`,\n base.`orders___ordered_at`,\n base.`customers___spend_last_signup_at_partition_by_regions_name`,\n shifted__time_shift_inner.`orders___customers___spend_last_customers_signup_at_partition_by_customers_regions_name` AS `orders____time_shift_inner`\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.`orders___customers___regions___name` IS NOT DISTINCT FROM shifted__time_shift_inner.`orders___customers___regions___name`\n AND DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`orders___ordered_at` AS DATETIME)\n), step1 AS (\n SELECT\n `orders___customers___regions___name`,\n `orders___ordered_at`,\n `customers___spend_last_signup_at_partition_by_regions_name`,\n `orders____time_shift_inner`,\n `customers___spend_last_signup_at_partition_by_regions_name` - `orders____time_shift_inner` AS `orders___ch`\n FROM sjoin__time_shift_inner\n)\nSELECT\n `orders___customers___regions___name`,\n `orders___ordered_at`,\n `orders___ch`\nFROM (\n SELECT\n `orders___customers___regions___name`,\n `orders___ordered_at`,\n `customers___spend_last_signup_at_partition_by_regions_name`,\n `orders____time_shift_inner`,\n `orders___ch`\n FROM step1\n) AS _outer", "w2/change_last_region::duckdb": "WITH _base AS (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\",\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 GROUP BY\n customers__regions.name,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name AS (\n SELECT\n _val_0 AS \"customers.regions.name\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS DOUBLE) AS \"customers.spend_last_signup_at_partition_by_regions_name\"\n FROM (\n SELECT\n regions.name AS _val_0,\n customers.spend AS _val_1,\n ROW_NUMBER() OVER (PARTITION BY regions.name ORDER BY customers.signup_at DESC) AS _ranked_rn\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n ) AS _ranked_src\n GROUP BY\n _val_0\n), base AS (\n SELECT\n _base.\"orders.customers.regions.name\",\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name.\"customers.spend_last_signup_at_partition_by_regions_name\" AS \"customers.spend_last_signup_at_partition_by_regions_name\"\n FROM _base\n LEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name\n ON _base.\"orders.customers.regions.name\" IS NOT DISTINCT FROM _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name.\"customers.regions.name\"\n), _base_2 AS (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\",\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 GROUP BY\n customers__regions.name,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.customers.regions.name\",\n _base_2.\"orders.ordered_at\",\n _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name.\"customers.spend_last_signup_at_partition_by_regions_name\" AS \"orders.customers.spend_last_customers_signup_at_partition_by_customers_regions_name\"\n FROM _base_2\n LEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name\n ON _base_2.\"orders.customers.regions.name\" IS NOT DISTINCT FROM _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name.\"customers.regions.name\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.customers.regions.name\",\n base.\"orders.ordered_at\",\n base.\"customers.spend_last_signup_at_partition_by_regions_name\",\n shifted__time_shift_inner.\"orders.customers.spend_last_customers_signup_at_partition_by_customers_regions_name\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"orders.customers.regions.name\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.customers.regions.name\"\n AND 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.customers.regions.name\",\n \"orders.ordered_at\",\n \"customers.spend_last_signup_at_partition_by_regions_name\",\n \"orders._time_shift_inner\",\n \"customers.spend_last_signup_at_partition_by_regions_name\" - \"orders._time_shift_inner\" AS \"orders.ch\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.customers.regions.name\",\n \"orders.ordered_at\",\n \"orders.ch\"\nFROM (\n SELECT\n \"orders.customers.regions.name\",\n \"orders.ordered_at\",\n \"customers.spend_last_signup_at_partition_by_regions_name\",\n \"orders._time_shift_inner\",\n \"orders.ch\"\n FROM step1\n) AS _outer", "w2/change_last_region::postgres": "WITH _base AS (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\",\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 GROUP BY\n customers__regions.name,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), _cm_orders__customers__spen_7031fb60_by_customers_regions_name AS (\n SELECT\n _val_0 AS \"customers.regions.name\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS DOUBLE PRECISION) AS \"customers.spend_last_signup_at_partition_by_regions_name\"\n FROM (\n SELECT\n regions.name AS _val_0,\n customers.spend AS _val_1,\n ROW_NUMBER() OVER (PARTITION BY regions.name ORDER BY customers.signup_at DESC) AS _ranked_rn\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n ) AS _ranked_src\n GROUP BY\n _val_0\n), base AS (\n SELECT\n _base.\"orders.customers.regions.name\",\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spen_7031fb60_by_customers_regions_name.\"customers.spend_last_signup_at_partition_by_regions_name\" AS \"customers.spend_last_signup_at_partition_by_regions_name\"\n FROM _base\n LEFT JOIN _cm_orders__customers__spen_7031fb60_by_customers_regions_name\n ON _base.\"orders.customers.regions.name\" IS NOT DISTINCT FROM _cm_orders__customers__spen_7031fb60_by_customers_regions_name.\"customers.regions.name\"\n), _base_2 AS (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\",\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 GROUP BY\n customers__regions.name,\n DATE_TRUNC('MONTH', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.customers.regions.name\",\n _base_2.\"orders.ordered_at\",\n _cm_orders__customers__spen_7031fb60_by_customers_regions_name.\"customers.spend_last_signup_at_partition_by_regions_name\" AS \"orders.customers.spend_last_07c4915c_by_customers_regions_name\"\n FROM _base_2\n LEFT JOIN _cm_orders__customers__spen_7031fb60_by_customers_regions_name\n ON _base_2.\"orders.customers.regions.name\" IS NOT DISTINCT FROM _cm_orders__customers__spen_7031fb60_by_customers_regions_name.\"customers.regions.name\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.customers.regions.name\",\n base.\"orders.ordered_at\",\n base.\"customers.spend_last_signup_at_partition_by_regions_name\",\n shifted__time_shift_inner.\"orders.customers.spend_last_07c4915c_by_customers_regions_name\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"orders.customers.regions.name\" IS NOT DISTINCT FROM shifted__time_shift_inner.\"orders.customers.regions.name\"\n AND 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.customers.regions.name\",\n \"orders.ordered_at\",\n \"customers.spend_last_signup_at_partition_by_regions_name\",\n \"orders._time_shift_inner\",\n \"customers.spend_last_signup_at_partition_by_regions_name\" - \"orders._time_shift_inner\" AS \"orders.ch\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.customers.regions.name\",\n \"orders.ordered_at\",\n \"orders.ch\"\nFROM (\n SELECT\n \"orders.customers.regions.name\",\n \"orders.ordered_at\",\n \"customers.spend_last_signup_at_partition_by_regions_name\",\n \"orders._time_shift_inner\",\n \"orders.ch\"\n FROM step1\n) AS _outer", "w2/change_last_region::sqlite": "WITH _base AS (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\",\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 GROUP BY\n customers__regions.name,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name AS (\n SELECT\n _val_0 AS \"customers.regions.name\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_1 END) AS REAL) AS \"customers.spend_last_signup_at_partition_by_regions_name\"\n FROM (\n SELECT\n regions.name AS _val_0,\n customers.spend AS _val_1,\n ROW_NUMBER() OVER (PARTITION BY regions.name ORDER BY customers.signup_at DESC) AS _ranked_rn\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n ) AS _ranked_src\n GROUP BY\n _val_0\n), base AS (\n SELECT\n _base.\"orders.customers.regions.name\",\n _base.\"orders.ordered_at\",\n _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name.\"customers.spend_last_signup_at_partition_by_regions_name\" AS \"customers.spend_last_signup_at_partition_by_regions_name\"\n FROM _base\n LEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name\n ON _base.\"orders.customers.regions.name\" IS _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name.\"customers.regions.name\"\n), _base_2 AS (\n SELECT\n customers__regions.name AS \"orders.customers.regions.name\",\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 GROUP BY\n customers__regions.name,\n STRFTIME('%Y-%m-01', orders.ordered_at)\n), shifted__time_shift_inner AS (\n SELECT\n _base_2.\"orders.customers.regions.name\",\n _base_2.\"orders.ordered_at\",\n _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name.\"customers.spend_last_signup_at_partition_by_regions_name\" AS \"orders.customers.spend_last_customers_signup_at_partition_by_customers_regions_name\"\n FROM _base_2\n LEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name\n ON _base_2.\"orders.customers.regions.name\" IS _cm_orders__customers__spend_last_customers_signup_at_partition_by_customers_regions_name.\"customers.regions.name\"\n), sjoin__time_shift_inner AS (\n SELECT\n base.\"orders.customers.regions.name\",\n base.\"orders.ordered_at\",\n base.\"customers.spend_last_signup_at_partition_by_regions_name\",\n shifted__time_shift_inner.\"orders.customers.spend_last_customers_signup_at_partition_by_customers_regions_name\" AS \"orders._time_shift_inner\"\n FROM base\n LEFT JOIN shifted__time_shift_inner\n ON base.\"orders.customers.regions.name\" IS shifted__time_shift_inner.\"orders.customers.regions.name\"\n AND SLAYER_DATE_ADD(base.\"orders.ordered_at\", -1, 'month') IS shifted__time_shift_inner.\"orders.ordered_at\"\n), step1 AS (\n SELECT\n \"orders.customers.regions.name\",\n \"orders.ordered_at\",\n \"customers.spend_last_signup_at_partition_by_regions_name\",\n \"orders._time_shift_inner\",\n \"customers.spend_last_signup_at_partition_by_regions_name\" - \"orders._time_shift_inner\" AS \"orders.ch\"\n FROM sjoin__time_shift_inner\n)\nSELECT\n \"orders.customers.regions.name\",\n \"orders.ordered_at\",\n \"orders.ch\"\nFROM (\n SELECT\n \"orders.customers.regions.name\",\n \"orders.ordered_at\",\n \"customers.spend_last_signup_at_partition_by_regions_name\",\n \"orders._time_shift_inner\",\n \"orders.ch\"\n FROM step1\n) AS _outer", diff --git a/tests/golden/dev1908_sql_baseline.json b/tests/golden/dev1908_sql_baseline.json index 606c809ac..621fe31e0 100644 --- a/tests/golden/dev1908_sql_baseline.json +++ b/tests/golden/dev1908_sql_baseline.json @@ -62,7 +62,7 @@ "cancel/two_frame::snowflake": "WITH _base AS (\n SELECT\n 1 AS _placeholder\n), _cm_orders__customers__regions__countries__gdp_wsum_two_w1_customers_regions_pop_w2_customers_plans_fee AS (\n SELECT\n SUM(regions__countries.gdp * regions.pop * plans.fee) AS \"customers.regions.countries.gdp_wsum_two_w1_regions_pop_w2_plans_fee_host\"\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN countries AS regions__countries\n ON regions.country_id = regions__countries.id\n LEFT JOIN plans AS plans\n ON customers.plan_code = plans.code\n)\nSELECT\n _cm_orders__customers__regions__countries__gdp_wsum_two_w1_customers_regions_pop_w2_customers_plans_fee.\"customers.regions.countries.gdp_wsum_two_w1_regions_pop_w2_plans_fee_host\" AS \"orders.w\"\nFROM _base\nCROSS JOIN _cm_orders__customers__regions__countries__gdp_wsum_two_w1_customers_regions_pop_w2_customers_plans_fee", "cancel/two_frame::sqlite": "WITH _base AS (\n SELECT\n 1 AS _placeholder\n), _cm_orders__customers__regions__countries__gdp_wsum_two_w1_customers_regions_pop_w2_customers_plans_fee AS (\n SELECT\n SUM(regions__countries.gdp * regions.pop * plans.fee) AS \"customers.regions.countries.gdp_wsum_two_w1_regions_pop_w2_plans_fee_host\"\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN countries AS regions__countries\n ON regions.country_id = regions__countries.id\n LEFT JOIN plans AS plans\n ON customers.plan_code = plans.code\n)\nSELECT\n _cm_orders__customers__regions__countries__gdp_wsum_two_w1_customers_regions_pop_w2_customers_plans_fee.\"customers.regions.countries.gdp_wsum_two_w1_regions_pop_w2_plans_fee_host\" AS \"orders.w\"\nFROM _base\nCROSS JOIN _cm_orders__customers__regions__countries__gdp_wsum_two_w1_customers_regions_pop_w2_customers_plans_fee", "cancel/two_frame::tsql": "WITH _base AS (\n SELECT\n 1 AS _placeholder\n), _cm_orders__customers__regions__countries__gdp_wsum_two_w1_customers_regions_pop_w2_customers_plans_fee AS (\n SELECT\n SUM(regions__countries.gdp * regions.pop * plans.fee) AS [customers___regions___countries___gdp_wsum_two_w1_regions_pop_w2_plans_fee_host]\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN countries AS regions__countries\n ON regions.country_id = regions__countries.id\n LEFT JOIN plans AS plans\n ON customers.plan_code = plans.code\n)\nSELECT\n _cm_orders__customers__regions__countries__gdp_wsum_two_w1_customers_regions_pop_w2_customers_plans_fee.[customers___regions___countries___gdp_wsum_two_w1_regions_pop_w2_plans_fee_host] AS [orders___w]\nFROM _base\nCROSS JOIN _cm_orders__customers__regions__countries__gdp_wsum_two_w1_customers_regions_pop_w2_customers_plans_fee", - "cancel/windowed_expr::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n), _cm_orders__customers__regions__countries__gdp_wsum_cust_spend2_expr_weight_expr_283e54f9_window_1y AS (\n SELECT\n _base.`customers___signup_at_month`,\n CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS `customers___regions___countries___gdp_wsum_cust_spend2_expr_weight_expr_90e5f235_window_1y_host`\n FROM (\n SELECT\n `_e`.`orders___customers___signup_at` AS `customers___signup_at_month`\n FROM (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n regions__countries.gdp AS _w_value,\n customers.spend * 1 AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN countries AS regions__countries\n ON regions.country_id = regions__countries.id\n ) AS _src\n ON _src._w_time >= CAST(DATETIME_ADD(\n CAST(CAST(DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP) AS DATETIME),\n INTERVAL -1 YEAR\n ) AS TIMESTAMP)\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`customers___signup_at_month`\n)\nSELECT\n _base.`orders___customers___signup_at`,\n _cm_orders__customers__regions__countries__gdp_wsum_cust_spend2_expr_weight_expr_283e54f9_window_1y.`customers___regions___countries___gdp_wsum_cust_spend2_expr_weight_expr_90e5f235_window_1y_host` AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__customers__regions__countries__gdp_wsum_cust_spend2_expr_weight_expr_283e54f9_window_1y\n ON _base.`orders___customers___signup_at` IS NOT DISTINCT FROM _cm_orders__customers__regions__countries__gdp_wsum_cust_spend2_expr_weight_expr_283e54f9_window_1y.`customers___signup_at_month`", + "cancel/windowed_expr::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n), _cm_orders__customers__regions__countries__gdp_wsum_cust_spend2_expr_weight_expr_283e54f9_window_1y AS (\n SELECT\n _base.`customers___signup_at_month`,\n CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS `customers___regions___countries___gdp_wsum_cust_spend2_expr_weight_expr_90e5f235_window_1y_host`\n FROM (\n SELECT\n `_e`.`orders___customers___signup_at` AS `customers___signup_at_month`\n FROM (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n regions__countries.gdp AS _w_value,\n customers.spend * 1 AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN countries AS regions__countries\n ON regions.country_id = regions__countries.id\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -1 YEAR\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`customers___signup_at_month`\n)\nSELECT\n _base.`orders___customers___signup_at`,\n _cm_orders__customers__regions__countries__gdp_wsum_cust_spend2_expr_weight_expr_283e54f9_window_1y.`customers___regions___countries___gdp_wsum_cust_spend2_expr_weight_expr_90e5f235_window_1y_host` AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__customers__regions__countries__gdp_wsum_cust_spend2_expr_weight_expr_283e54f9_window_1y\n ON _base.`orders___customers___signup_at` IS NOT DISTINCT FROM _cm_orders__customers__regions__countries__gdp_wsum_cust_spend2_expr_weight_expr_283e54f9_window_1y.`customers___signup_at_month`", "cancel/windowed_expr::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n), _cm_orders__customers__regions__countries__gdp_wsum_cust_spend2_expr_weight_expr_283e54f9_window_1y AS (\n SELECT\n _base.\"customers.signup_at_month\",\n CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS \"customers.regions.countries.gdp_wsum_cust_spend2_expr_weight_expr_90e5f235_window_1y_host\"\n FROM (\n SELECT\n \"_e\".\"orders.customers.signup_at\" AS \"customers.signup_at_month\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n regions__countries.gdp AS _w_value,\n customers.spend * 1 AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN countries AS regions__countries\n ON regions.country_id = regions__countries.id\n ) AS _src\n ON _src._w_time >= _base.\"customers.signup_at_month\" + INTERVAL 1 MONTH - INTERVAL 1 YEAR\n AND _src._w_time < _base.\"customers.signup_at_month\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"customers.signup_at_month\"\n)\nSELECT\n _base.\"orders.customers.signup_at\",\n _cm_orders__customers__regions__countries__gdp_wsum_cust_spend2_expr_weight_expr_283e54f9_window_1y.\"customers.regions.countries.gdp_wsum_cust_spend2_expr_weight_expr_90e5f235_window_1y_host\" AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__customers__regions__countries__gdp_wsum_cust_spend2_expr_weight_expr_283e54f9_window_1y\n ON _base.\"orders.customers.signup_at\" IS NOT DISTINCT FROM _cm_orders__customers__regions__countries__gdp_wsum_cust_spend2_expr_weight_expr_283e54f9_window_1y.\"customers.signup_at_month\"", "cancel/windowed_expr::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n ) AS `orders.customers.signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n )\n), _cm_orders__customers__regi_218e39b2_ght_expr_283e54f9_window_1y AS (\n SELECT\n _base.`customers.signup_at_month`,\n CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS `customers.regions.countries_e3cb96b6_xpr_90e5f235_window_1y_host`\n FROM (\n SELECT\n `_e`.`orders.customers.signup_at` AS `customers.signup_at_month`\n FROM (\n SELECT\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n ) AS `orders.customers.signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n )\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n regions__countries.gdp AS _w_value,\n customers.spend * 1 AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN countries AS regions__countries\n ON regions.country_id = regions__countries.id\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`customers.signup_at_month`, INTERVAL 1 MONTH), INTERVAL -1 YEAR)\n AND _src._w_time < DATE_ADD(_base.`customers.signup_at_month`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`customers.signup_at_month`\n)\nSELECT\n _base.`orders.customers.signup_at`,\n _cm_orders__customers__regi_218e39b2_ght_expr_283e54f9_window_1y.`customers.regions.countries_e3cb96b6_xpr_90e5f235_window_1y_host` AS `orders.w`\nFROM _base\nLEFT JOIN _cm_orders__customers__regi_218e39b2_ght_expr_283e54f9_window_1y\n ON _base.`orders.customers.signup_at` <=> _cm_orders__customers__regi_218e39b2_ght_expr_283e54f9_window_1y.`customers.signup_at_month`", "cancel/windowed_expr::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n), _cm_orders__customers__regi_218e39b2_ht_expr_283e54f9_window_1y AS (\n SELECT\n _base.\"customers.signup_at_month\",\n CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS \"customers.regions.countries_e3cb96b6_pr_90e5f235_window_1y_host\"\n FROM (\n SELECT\n \"_e\".\"orders.customers.signup_at\" AS \"customers.signup_at_month\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n regions__countries.gdp AS _w_value,\n customers.spend * 1 AS _w_p0\n FROM customers AS customers\n LEFT JOIN regions AS regions\n ON customers.region_id = regions.id\n LEFT JOIN countries AS regions__countries\n ON regions.country_id = regions__countries.id\n ) AS _src\n ON _src._w_time >= _base.\"customers.signup_at_month\" + INTERVAL '1 MONTH' - INTERVAL '1 YEAR'\n AND _src._w_time < _base.\"customers.signup_at_month\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"customers.signup_at_month\"\n)\nSELECT\n _base.\"orders.customers.signup_at\",\n _cm_orders__customers__regi_218e39b2_ht_expr_283e54f9_window_1y.\"customers.regions.countries_e3cb96b6_pr_90e5f235_window_1y_host\" AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__customers__regi_218e39b2_ht_expr_283e54f9_window_1y\n ON _base.\"orders.customers.signup_at\" IS NOT DISTINCT FROM _cm_orders__customers__regi_218e39b2_ht_expr_283e54f9_window_1y.\"customers.signup_at_month\"", diff --git a/tests/golden/dev1909_sql_baseline.json b/tests/golden/dev1909_sql_baseline.json index 973c020cd..adf141645 100644 --- a/tests/golden/dev1909_sql_baseline.json +++ b/tests/golden/dev1909_sql_baseline.json @@ -55,7 +55,7 @@ "producer/producer_only::snowflake": "WITH _base AS (\n SELECT\n 1 AS _placeholder\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n LIMIT 1\n), _cm_customers__orders__amount_sum AS (\n SELECT\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.status = 'ok'\n)\nSELECT\n _cm_customers__orders__amount_sum.\"orders.amount_sum\" AS \"customers.oa\"\nFROM _base\nCROSS JOIN _cm_customers__orders__amount_sum", "producer/producer_only::sqlite": "WITH _base AS (\n SELECT\n 1 AS _placeholder\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n LIMIT 1\n), _cm_customers__orders__amount_sum AS (\n SELECT\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.status = 'ok'\n)\nSELECT\n _cm_customers__orders__amount_sum.\"orders.amount_sum\" AS \"customers.oa\"\nFROM _base\nCROSS JOIN _cm_customers__orders__amount_sum", "producer/producer_only::tsql": "WITH _base AS (\n SELECT\n TOP 1\n 1 AS _placeholder\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n), _cm_customers__orders__amount_sum AS (\n SELECT\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___amount_sum]\n FROM orders AS orders\n WHERE\n orders.status = 'ok'\n)\nSELECT\n _cm_customers__orders__amount_sum.[orders___amount_sum] AS [customers___oa]\nFROM _base\nCROSS JOIN _cm_customers__orders__amount_sum", - "producer/windowed::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `customers___signup_at`\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n), _cm_customers__spend_sum_window_1y AS (\n SELECT\n _base.`customers___signup_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `customers___w`\n FROM (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `customers___signup_at`\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n ) AS _src\n ON _src._w_time >= CAST(DATETIME_ADD(\n CAST(CAST(DATETIME_ADD(CAST(_base.`customers___signup_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP) AS DATETIME),\n INTERVAL -1 YEAR\n ) AS TIMESTAMP)\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`customers___signup_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`customers___signup_at`\n)\nSELECT\n _base.`customers___signup_at`,\n _cm_customers__spend_sum_window_1y.`customers___w`\nFROM _base\nLEFT JOIN _cm_customers__spend_sum_window_1y\n ON _base.`customers___signup_at` IS NOT DISTINCT FROM _cm_customers__spend_sum_window_1y.`customers___signup_at`", + "producer/windowed::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `customers___signup_at`\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n), _cm_customers__spend_sum_window_1y AS (\n SELECT\n _base.`customers___signup_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `customers___w`\n FROM (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `customers___signup_at`\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`customers___signup_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -1 YEAR\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`customers___signup_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`customers___signup_at`\n)\nSELECT\n _base.`customers___signup_at`,\n _cm_customers__spend_sum_window_1y.`customers___w`\nFROM _base\nLEFT JOIN _cm_customers__spend_sum_window_1y\n ON _base.`customers___signup_at` IS NOT DISTINCT FROM _cm_customers__spend_sum_window_1y.`customers___signup_at`", "producer/windowed::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"customers.signup_at\"\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n), _cm_customers__spend_sum_window_1y AS (\n SELECT\n _base.\"customers.signup_at\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"customers.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"customers.signup_at\"\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n ) AS _src\n ON _src._w_time >= _base.\"customers.signup_at\" + INTERVAL 1 MONTH - INTERVAL 1 YEAR\n AND _src._w_time < _base.\"customers.signup_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"customers.signup_at\"\n)\nSELECT\n _base.\"customers.signup_at\",\n _cm_customers__spend_sum_window_1y.\"customers.w\"\nFROM _base\nLEFT JOIN _cm_customers__spend_sum_window_1y\n ON _base.\"customers.signup_at\" IS NOT DISTINCT FROM _cm_customers__spend_sum_window_1y.\"customers.signup_at\"", "producer/windowed::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n ) AS `customers.signup_at`\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n GROUP BY\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n )\n), _cm_customers__spend_sum_window_1y AS (\n SELECT\n _base.`customers.signup_at`,\n CAST(SUM(_src._w_value) AS DOUBLE) AS `customers.w`\n FROM (\n SELECT\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n ) AS `customers.signup_at`\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n GROUP BY\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n )\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`customers.signup_at`, INTERVAL 1 MONTH), INTERVAL -1 YEAR)\n AND _src._w_time < DATE_ADD(_base.`customers.signup_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`customers.signup_at`\n)\nSELECT\n _base.`customers.signup_at`,\n _cm_customers__spend_sum_window_1y.`customers.w`\nFROM _base\nLEFT JOIN _cm_customers__spend_sum_window_1y\n ON _base.`customers.signup_at` <=> _cm_customers__spend_sum_window_1y.`customers.signup_at`", "producer/windowed::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"customers.signup_at\"\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n), _cm_customers__spend_sum_window_1y AS (\n SELECT\n _base.\"customers.signup_at\",\n CAST(SUM(_src._w_value) AS DOUBLE PRECISION) AS \"customers.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"customers.signup_at\"\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value\n FROM customers AS customers\n WHERE\n EXISTS(\n SELECT\n 1\n FROM orders AS orders\n WHERE\n customers.id = orders.customer_id AND orders.status = 'ok'\n )\n ) AS _src\n ON _src._w_time >= _base.\"customers.signup_at\" + INTERVAL '1 MONTH' - INTERVAL '1 YEAR'\n AND _src._w_time < _base.\"customers.signup_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"customers.signup_at\"\n)\nSELECT\n _base.\"customers.signup_at\",\n _cm_customers__spend_sum_window_1y.\"customers.w\"\nFROM _base\nLEFT JOIN _cm_customers__spend_sum_window_1y\n ON _base.\"customers.signup_at\" IS NOT DISTINCT FROM _cm_customers__spend_sum_window_1y.\"customers.signup_at\"", diff --git a/tests/golden/dev1915_sql_baseline.json b/tests/golden/dev1915_sql_baseline.json index e71945949..0aa96e0e0 100644 --- a/tests/golden/dev1915_sql_baseline.json +++ b/tests/golden/dev1915_sql_baseline.json @@ -1,117 +1,117 @@ { - "corr::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_corr_other_qty_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(CORR(_src._w_value, _src._w_p0) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_corr_other_qty_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_corr_other_qty_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_corr_other_qty_window_90d.`orders___created_at`", + "corr::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_corr_other_qty_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(CORR(_src._w_value, _src._w_p0) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_corr_other_qty_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_corr_other_qty_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_corr_other_qty_window_90d.`orders___created_at`", "corr::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_corr_other_qty_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(CORR(_src._w_value, _src._w_p0) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_corr_other_qty_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_corr_other_qty_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_corr_other_qty_window_90d.\"orders.created_at\"", "corr::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_corr_other_qty_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n CAST((\n VAR_SAMP(\n CASE WHEN NOT _src._w_p0 IS NULL THEN _src._w_value END + CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END\n ) - VAR_SAMP(CASE WHEN NOT _src._w_p0 IS NULL THEN _src._w_value END) - VAR_SAMP(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END)\n ) / 2 / NULLIF(\n (\n STDDEV_SAMP(CASE WHEN NOT _src._w_p0 IS NULL THEN _src._w_value END) * STDDEV_SAMP(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END)\n ),\n 0\n ) AS DOUBLE) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _cm_orders__amount_corr_other_qty_window_90d.`orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_corr_other_qty_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_corr_other_qty_window_90d.`orders.created_at`", "corr::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_corr_other_qty_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(CORR(_src._w_value, _src._w_p0) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_corr_other_qty_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_corr_other_qty_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_corr_other_qty_window_90d.\"orders.created_at\"", "corr::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_corr_other_qty_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(CORR(_src._w_value, _src._w_p0) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_corr_other_qty_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_corr_other_qty_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_corr_other_qty_window_90d.\"orders.created_at\"", "corr::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_corr_other_qty_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(CORR(_src._w_value, _src._w_p0) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_corr_other_qty_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_corr_other_qty_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_corr_other_qty_window_90d.\"orders.created_at\"", "corr::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_corr_other_qty_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n CAST(CAST(CAST((\n VAR(\n CASE WHEN NOT _src._w_p0 IS NULL THEN _src._w_value END + CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END\n ) - VAR(CASE WHEN NOT _src._w_p0 IS NULL THEN _src._w_value END) - VAR(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END)\n ) AS FLOAT) / 2 AS FLOAT) / NULLIF(\n (\n STDEV(CASE WHEN NOT _src._w_p0 IS NULL THEN _src._w_value END) * STDEV(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END)\n ),\n 0\n ) AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _cm_orders__amount_corr_other_qty_window_90d.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_corr_other_qty_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_corr_other_qty_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_corr_other_qty_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_corr_other_qty_window_90d.[orders___created_at] IS NULL\n )\n )", - "count::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_count_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n COUNT(_src._w_value) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n COALESCE(_cm_orders__amount_count_window_90d.`orders___w`, 0) AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d.`orders___created_at`", + "count::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_count_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n COUNT(_src._w_value) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n COALESCE(_cm_orders__amount_count_window_90d.`orders___w`, 0) AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d.`orders___created_at`", "count::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_count_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(_src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_count_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d.\"orders.created_at\"", "count::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_count_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n COUNT(_src._w_value) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n COALESCE(_cm_orders__amount_count_window_90d.`orders.w`, 0) AS `orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_count_window_90d.`orders.created_at`", "count::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_count_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(_src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_count_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d.\"orders.created_at\"", "count::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_count_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(_src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_count_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d.\"orders.created_at\"", "count::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_count_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(_src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_count_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_count_window_90d.\"orders.created_at\"", "count::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_count_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n COUNT(_src._w_value) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n COALESCE(_cm_orders__amount_count_window_90d.[orders___w], 0) AS [orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_count_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_count_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_count_window_90d.[orders___created_at] IS NULL\n )\n )", - "count_distinct::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_count_distinct_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n COUNT(DISTINCT _src._w_value) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n COALESCE(_cm_orders__amount_count_distinct_window_90d.`orders___w`, 0) AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_count_distinct_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_count_distinct_window_90d.`orders___created_at`", + "count_distinct::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_count_distinct_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n COUNT(DISTINCT _src._w_value) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n COALESCE(_cm_orders__amount_count_distinct_window_90d.`orders___w`, 0) AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_count_distinct_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_count_distinct_window_90d.`orders___created_at`", "count_distinct::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_count_distinct_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(DISTINCT _src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_count_distinct_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_distinct_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_count_distinct_window_90d.\"orders.created_at\"", "count_distinct::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_count_distinct_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n COUNT(DISTINCT _src._w_value) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n COALESCE(_cm_orders__amount_count_distinct_window_90d.`orders.w`, 0) AS `orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_count_distinct_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_count_distinct_window_90d.`orders.created_at`", "count_distinct::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_count_distinct_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(DISTINCT _src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_count_distinct_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_distinct_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_count_distinct_window_90d.\"orders.created_at\"", "count_distinct::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_count_distinct_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(DISTINCT _src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_count_distinct_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_distinct_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_count_distinct_window_90d.\"orders.created_at\"", "count_distinct::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_count_distinct_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(DISTINCT _src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_count_distinct_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_distinct_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_count_distinct_window_90d.\"orders.created_at\"", "count_distinct::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_count_distinct_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n COUNT(DISTINCT _src._w_value) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n COALESCE(_cm_orders__amount_count_distinct_window_90d.[orders___w], 0) AS [orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_count_distinct_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_count_distinct_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_count_distinct_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_count_distinct_window_90d.[orders___created_at] IS NULL\n )\n )", - "count_distinct_approx::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_count_distinct_approx_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n APPROX_COUNT_DISTINCT(_src._w_value) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n COALESCE(_cm_orders__amount_count_distinct_approx_window_90d.`orders___w`, 0) AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_count_distinct_approx_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_count_distinct_approx_window_90d.`orders___created_at`", + "count_distinct_approx::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_count_distinct_approx_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n APPROX_COUNT_DISTINCT(_src._w_value) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n COALESCE(_cm_orders__amount_count_distinct_approx_window_90d.`orders___w`, 0) AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_count_distinct_approx_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_count_distinct_approx_window_90d.`orders___created_at`", "count_distinct_approx::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_count_distinct_approx_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n APPROX_COUNT_DISTINCT(_src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_count_distinct_approx_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_distinct_approx_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_count_distinct_approx_window_90d.\"orders.created_at\"", "count_distinct_approx::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_count_distinct_approx_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n COUNT(DISTINCT _src._w_value) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n COALESCE(_cm_orders__amount_count_distinct_approx_window_90d.`orders.w`, 0) AS `orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_count_distinct_approx_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_count_distinct_approx_window_90d.`orders.created_at`", "count_distinct_approx::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_count_distinct_approx_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(DISTINCT _src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_count_distinct_approx_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_distinct_approx_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_count_distinct_approx_window_90d.\"orders.created_at\"", "count_distinct_approx::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_count_distinct_approx_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n APPROX_COUNT_DISTINCT(_src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_count_distinct_approx_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_distinct_approx_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_count_distinct_approx_window_90d.\"orders.created_at\"", "count_distinct_approx::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_count_distinct_approx_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(DISTINCT _src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_count_distinct_approx_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_distinct_approx_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_count_distinct_approx_window_90d.\"orders.created_at\"", "count_distinct_approx::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_count_distinct_approx_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n APPROX_COUNT_DISTINCT(_src._w_value) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n COALESCE(_cm_orders__amount_count_distinct_approx_window_90d.[orders___w], 0) AS [orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_count_distinct_approx_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_count_distinct_approx_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_count_distinct_approx_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_count_distinct_approx_window_90d.[orders___created_at] IS NULL\n )\n )", - "covar_pop::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_covar_pop_other_qty_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(COVAR_POP(_src._w_value, _src._w_p0) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_covar_pop_other_qty_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_covar_pop_other_qty_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_covar_pop_other_qty_window_90d.`orders___created_at`", + "covar_pop::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_covar_pop_other_qty_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(COVAR_POP(_src._w_value, _src._w_p0) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_covar_pop_other_qty_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_covar_pop_other_qty_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_covar_pop_other_qty_window_90d.`orders___created_at`", "covar_pop::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_covar_pop_other_qty_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(COVAR_POP(_src._w_value, _src._w_p0) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_covar_pop_other_qty_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_covar_pop_other_qty_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_covar_pop_other_qty_window_90d.\"orders.created_at\"", "covar_pop::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_covar_pop_other_qty_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n CAST((\n VAR_POP(\n CASE WHEN NOT _src._w_p0 IS NULL THEN _src._w_value END + CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END\n ) - VAR_POP(CASE WHEN NOT _src._w_p0 IS NULL THEN _src._w_value END) - VAR_POP(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END)\n ) / 2 AS DOUBLE) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _cm_orders__amount_covar_pop_other_qty_window_90d.`orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_covar_pop_other_qty_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_covar_pop_other_qty_window_90d.`orders.created_at`", "covar_pop::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_covar_pop_other_qty_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(COVAR_POP(_src._w_value, _src._w_p0) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_covar_pop_other_qty_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_covar_pop_other_qty_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_covar_pop_other_qty_window_90d.\"orders.created_at\"", "covar_pop::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_covar_pop_other_qty_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(COVAR_POP(_src._w_value, _src._w_p0) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_covar_pop_other_qty_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_covar_pop_other_qty_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_covar_pop_other_qty_window_90d.\"orders.created_at\"", "covar_pop::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_covar_pop_other_qty_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(COVAR_POP(_src._w_value, _src._w_p0) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_covar_pop_other_qty_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_covar_pop_other_qty_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_covar_pop_other_qty_window_90d.\"orders.created_at\"", "covar_pop::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_covar_pop_other_qty_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n CAST(CAST((\n VARP(\n CASE WHEN NOT _src._w_p0 IS NULL THEN _src._w_value END + CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END\n ) - VARP(CASE WHEN NOT _src._w_p0 IS NULL THEN _src._w_value END) - VARP(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END)\n ) AS FLOAT) / 2 AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _cm_orders__amount_covar_pop_other_qty_window_90d.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_covar_pop_other_qty_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_covar_pop_other_qty_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_covar_pop_other_qty_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_covar_pop_other_qty_window_90d.[orders___created_at] IS NULL\n )\n )", - "covar_samp::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_covar_samp_other_qty_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(COVAR_SAMP(_src._w_value, _src._w_p0) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_covar_samp_other_qty_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_covar_samp_other_qty_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_covar_samp_other_qty_window_90d.`orders___created_at`", + "covar_samp::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_covar_samp_other_qty_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(COVAR_SAMP(_src._w_value, _src._w_p0) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_covar_samp_other_qty_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_covar_samp_other_qty_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_covar_samp_other_qty_window_90d.`orders___created_at`", "covar_samp::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_covar_samp_other_qty_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(COVAR_SAMP(_src._w_value, _src._w_p0) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_covar_samp_other_qty_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_covar_samp_other_qty_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_covar_samp_other_qty_window_90d.\"orders.created_at\"", "covar_samp::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_covar_samp_other_qty_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n CAST((\n VAR_SAMP(\n CASE WHEN NOT _src._w_p0 IS NULL THEN _src._w_value END + CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END\n ) - VAR_SAMP(CASE WHEN NOT _src._w_p0 IS NULL THEN _src._w_value END) - VAR_SAMP(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END)\n ) / 2 AS DOUBLE) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _cm_orders__amount_covar_samp_other_qty_window_90d.`orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_covar_samp_other_qty_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_covar_samp_other_qty_window_90d.`orders.created_at`", "covar_samp::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_covar_samp_other_qty_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(COVAR_SAMP(_src._w_value, _src._w_p0) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_covar_samp_other_qty_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_covar_samp_other_qty_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_covar_samp_other_qty_window_90d.\"orders.created_at\"", "covar_samp::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_covar_samp_other_qty_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(COVAR_SAMP(_src._w_value, _src._w_p0) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_covar_samp_other_qty_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_covar_samp_other_qty_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_covar_samp_other_qty_window_90d.\"orders.created_at\"", "covar_samp::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_covar_samp_other_qty_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(COVAR_SAMP(_src._w_value, _src._w_p0) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_covar_samp_other_qty_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_covar_samp_other_qty_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_covar_samp_other_qty_window_90d.\"orders.created_at\"", "covar_samp::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_covar_samp_other_qty_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n CAST(CAST((\n VAR(\n CASE WHEN NOT _src._w_p0 IS NULL THEN _src._w_value END + CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END\n ) - VAR(CASE WHEN NOT _src._w_p0 IS NULL THEN _src._w_value END) - VAR(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END)\n ) AS FLOAT) / 2 AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _cm_orders__amount_covar_samp_other_qty_window_90d.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_covar_samp_other_qty_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_covar_samp_other_qty_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_covar_samp_other_qty_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_covar_samp_other_qty_window_90d.[orders___created_at] IS NULL\n )\n )", - "cross_model_last::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n), _cm_orders__customers__spend_last_customers_signup_at_window_1y AS (\n SELECT\n _ranked_src.`customers___signup_at_month` AS `customers___signup_at_month`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS FLOAT64) AS `customers___spend_last_signup_at_window_1y`\n FROM (\n SELECT\n _base.`customers___signup_at_month` AS `customers___signup_at_month`,\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.`customers___signup_at_month` ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n `_e`.`orders___customers___signup_at` AS `customers___signup_at_month`\n FROM (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n customers.signup_at AS _w_rank\n FROM customers AS customers\n ) AS _src\n ON _src._w_time >= CAST(DATETIME_ADD(\n CAST(CAST(DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP) AS DATETIME),\n INTERVAL -1 YEAR\n ) AS TIMESTAMP)\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n ) AS _ranked_src\n GROUP BY\n _ranked_src.`customers___signup_at_month`\n)\nSELECT\n _base.`orders___customers___signup_at`,\n _cm_orders__customers__spend_last_customers_signup_at_window_1y.`customers___spend_last_signup_at_window_1y` AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_window_1y\n ON _base.`orders___customers___signup_at` IS NOT DISTINCT FROM _cm_orders__customers__spend_last_customers_signup_at_window_1y.`customers___signup_at_month`", + "cross_model_last::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n), _cm_orders__customers__spend_last_customers_signup_at_window_1y AS (\n SELECT\n _ranked_src.`customers___signup_at_month` AS `customers___signup_at_month`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS FLOAT64) AS `customers___spend_last_signup_at_window_1y`\n FROM (\n SELECT\n _base.`customers___signup_at_month` AS `customers___signup_at_month`,\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.`customers___signup_at_month` ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n `_e`.`orders___customers___signup_at` AS `customers___signup_at_month`\n FROM (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n customers.signup_at AS _w_rank\n FROM customers AS customers\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -1 YEAR\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH)\n ) AS _ranked_src\n GROUP BY\n _ranked_src.`customers___signup_at_month`\n)\nSELECT\n _base.`orders___customers___signup_at`,\n _cm_orders__customers__spend_last_customers_signup_at_window_1y.`customers___spend_last_signup_at_window_1y` AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_window_1y\n ON _base.`orders___customers___signup_at` IS NOT DISTINCT FROM _cm_orders__customers__spend_last_customers_signup_at_window_1y.`customers___signup_at_month`", "cross_model_last::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n), _cm_orders__customers__spend_last_customers_signup_at_window_1y AS (\n SELECT\n _ranked_src.\"customers.signup_at_month\" AS \"customers.signup_at_month\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS DOUBLE) AS \"customers.spend_last_signup_at_window_1y\"\n FROM (\n SELECT\n _base.\"customers.signup_at_month\" AS \"customers.signup_at_month\",\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.\"customers.signup_at_month\" ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n \"_e\".\"orders.customers.signup_at\" AS \"customers.signup_at_month\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n customers.signup_at AS _w_rank\n FROM customers AS customers\n ) AS _src\n ON _src._w_time >= _base.\"customers.signup_at_month\" + INTERVAL 1 MONTH - INTERVAL 1 YEAR\n AND _src._w_time < _base.\"customers.signup_at_month\" + INTERVAL 1 MONTH\n ) AS _ranked_src\n GROUP BY\n _ranked_src.\"customers.signup_at_month\"\n)\nSELECT\n _base.\"orders.customers.signup_at\",\n _cm_orders__customers__spend_last_customers_signup_at_window_1y.\"customers.spend_last_signup_at_window_1y\" AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_window_1y\n ON _base.\"orders.customers.signup_at\" IS NOT DISTINCT FROM _cm_orders__customers__spend_last_customers_signup_at_window_1y.\"customers.signup_at_month\"", "cross_model_last::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n ) AS `orders.customers.signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n )\n), _cm_orders__customers__spend_last_customers_signup_at_window_1y AS (\n SELECT\n _ranked_src.`customers.signup_at_month` AS `customers.signup_at_month`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS DOUBLE) AS `customers.spend_last_signup_at_window_1y`\n FROM (\n SELECT\n _base.`customers.signup_at_month` AS `customers.signup_at_month`,\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.`customers.signup_at_month` ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n `_e`.`orders.customers.signup_at` AS `customers.signup_at_month`\n FROM (\n SELECT\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n ) AS `orders.customers.signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n )\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n customers.signup_at AS _w_rank\n FROM customers AS customers\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`customers.signup_at_month`, INTERVAL 1 MONTH), INTERVAL -1 YEAR)\n AND _src._w_time < DATE_ADD(_base.`customers.signup_at_month`, INTERVAL 1 MONTH)\n ) AS _ranked_src\n GROUP BY\n _ranked_src.`customers.signup_at_month`\n)\nSELECT\n _base.`orders.customers.signup_at`,\n _cm_orders__customers__spend_last_customers_signup_at_window_1y.`customers.spend_last_signup_at_window_1y` AS `orders.w`\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_window_1y\n ON _base.`orders.customers.signup_at` <=> _cm_orders__customers__spend_last_customers_signup_at_window_1y.`customers.signup_at_month`", "cross_model_last::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n), _cm_orders__customers__spend_last_customers_signup_at_window_1y AS (\n SELECT\n _ranked_src.\"customers.signup_at_month\" AS \"customers.signup_at_month\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS DOUBLE PRECISION) AS \"customers.spend_last_signup_at_window_1y\"\n FROM (\n SELECT\n _base.\"customers.signup_at_month\" AS \"customers.signup_at_month\",\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.\"customers.signup_at_month\" ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n \"_e\".\"orders.customers.signup_at\" AS \"customers.signup_at_month\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n customers.signup_at AS _w_rank\n FROM customers AS customers\n ) AS _src\n ON _src._w_time >= _base.\"customers.signup_at_month\" + INTERVAL '1 MONTH' - INTERVAL '1 YEAR'\n AND _src._w_time < _base.\"customers.signup_at_month\" + INTERVAL '1 MONTH'\n ) AS _ranked_src\n GROUP BY\n _ranked_src.\"customers.signup_at_month\"\n)\nSELECT\n _base.\"orders.customers.signup_at\",\n _cm_orders__customers__spend_last_customers_signup_at_window_1y.\"customers.spend_last_signup_at_window_1y\" AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_window_1y\n ON _base.\"orders.customers.signup_at\" IS NOT DISTINCT FROM _cm_orders__customers__spend_last_customers_signup_at_window_1y.\"customers.signup_at_month\"", "cross_model_last::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n), _cm_orders__customers__spend_last_customers_signup_at_window_1y AS (\n SELECT\n _ranked_src.\"customers.signup_at_month\" AS \"customers.signup_at_month\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS DOUBLE) AS \"customers.spend_last_signup_at_window_1y\"\n FROM (\n SELECT\n _base.\"customers.signup_at_month\" AS \"customers.signup_at_month\",\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.\"customers.signup_at_month\" ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n \"_e\".\"orders.customers.signup_at\" AS \"customers.signup_at_month\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n customers.signup_at AS _w_rank\n FROM customers AS customers\n ) AS _src\n ON _src._w_time >= DATEADD(YEAR, -1, DATEADD(MONTH, 1, _base.\"customers.signup_at_month\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"customers.signup_at_month\")\n ) AS _ranked_src\n GROUP BY\n _ranked_src.\"customers.signup_at_month\"\n)\nSELECT\n _base.\"orders.customers.signup_at\",\n _cm_orders__customers__spend_last_customers_signup_at_window_1y.\"customers.spend_last_signup_at_window_1y\" AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_window_1y\n ON _base.\"orders.customers.signup_at\" IS NOT DISTINCT FROM _cm_orders__customers__spend_last_customers_signup_at_window_1y.\"customers.signup_at_month\"", "cross_model_last::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n STRFTIME('%Y-%m-01', customers.signup_at)\n), _cm_orders__customers__spend_last_customers_signup_at_window_1y AS (\n SELECT\n _ranked_src.\"customers.signup_at_month\" AS \"customers.signup_at_month\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS REAL) AS \"customers.spend_last_signup_at_window_1y\"\n FROM (\n SELECT\n _base.\"customers.signup_at_month\" AS \"customers.signup_at_month\",\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.\"customers.signup_at_month\" ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n \"_e\".\"orders.customers.signup_at\" AS \"customers.signup_at_month\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n STRFTIME('%Y-%m-01', customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n customers.signup_at AS _w_rank\n FROM customers AS customers\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"customers.signup_at_month\", 1, 'month'), -1, 'year')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"customers.signup_at_month\", 1, 'month')\n ) AS _ranked_src\n GROUP BY\n _ranked_src.\"customers.signup_at_month\"\n)\nSELECT\n _base.\"orders.customers.signup_at\",\n _cm_orders__customers__spend_last_customers_signup_at_window_1y.\"customers.spend_last_signup_at_window_1y\" AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_window_1y\n ON _base.\"orders.customers.signup_at\" IS _cm_orders__customers__spend_last_customers_signup_at_window_1y.\"customers.signup_at_month\"", "cross_model_last::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, customers.signup_at) AS [orders___customers___signup_at]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATETRUNC(month, customers.signup_at)\n), _cm_orders__customers__spend_last_customers_signup_at_window_1y AS (\n SELECT\n _ranked_src.[customers___signup_at_month] AS [customers___signup_at_month],\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS FLOAT) AS [customers___spend_last_signup_at_window_1y]\n FROM (\n SELECT\n _base.[customers___signup_at_month] AS [customers___signup_at_month],\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.[customers___signup_at_month] ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n [_e].[orders___customers___signup_at] AS [customers___signup_at_month]\n FROM (\n SELECT\n DATETRUNC(month, customers.signup_at) AS [orders___customers___signup_at]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATETRUNC(month, customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n customers.signup_at AS _w_rank\n FROM customers AS customers\n ) AS _src\n ON _src._w_time >= DATEADD(YEAR, -1, DATEADD(MONTH, 1, _base.[customers___signup_at_month]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[customers___signup_at_month])\n ) AS _ranked_src\n GROUP BY\n _ranked_src.[customers___signup_at_month]\n)\nSELECT\n _base.[orders___customers___signup_at],\n _cm_orders__customers__spend_last_customers_signup_at_window_1y.[customers___spend_last_signup_at_window_1y] AS [orders___w]\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_last_customers_signup_at_window_1y\n ON (\n (\n _base.[orders___customers___signup_at] = _cm_orders__customers__spend_last_customers_signup_at_window_1y.[customers___signup_at_month]\n AND NOT _base.[orders___customers___signup_at] IS NULL\n AND NOT _cm_orders__customers__spend_last_customers_signup_at_window_1y.[customers___signup_at_month] IS NULL\n )\n OR (\n _base.[orders___customers___signup_at] IS NULL\n AND _cm_orders__customers__spend_last_customers_signup_at_window_1y.[customers___signup_at_month] IS NULL\n )\n )", - "custom_default_literal_p::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(CASE\n WHEN COUNT(_src._w_time) = 0\n THEN NULL\n ELSE AVG(CASE WHEN _src._w_value BETWEEN 0 AND 1000 THEN _src._w_value END)\n END AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.`orders___created_at`", + "custom_default_literal_p::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(CASE\n WHEN COUNT(_src._w_time) = 0\n THEN NULL\n ELSE AVG(CASE WHEN _src._w_value BETWEEN 0 AND 1000 THEN _src._w_value END)\n END AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.`orders___created_at`", "custom_default_literal_p::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(CASE\n WHEN COUNT(_src._w_time) = 0\n THEN NULL\n ELSE AVG(CASE WHEN _src._w_value BETWEEN 0 AND 1000 THEN _src._w_value END)\n END AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.\"orders.created_at\"", "custom_default_literal_p::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n CAST(CASE\n WHEN COUNT(_src._w_time) = 0\n THEN NULL\n ELSE AVG(CASE WHEN _src._w_value BETWEEN 0 AND 1000 THEN _src._w_value END)\n END AS DOUBLE) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.`orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.`orders.created_at`", "custom_default_literal_p::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(CASE\n WHEN COUNT(_src._w_time) = 0\n THEN NULL\n ELSE AVG(CASE WHEN _src._w_value BETWEEN 0 AND 1000 THEN _src._w_value END)\n END AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.\"orders.created_at\"", "custom_default_literal_p::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(CASE\n WHEN COUNT(_src._w_time) = 0\n THEN NULL\n ELSE AVG(CASE WHEN _src._w_value BETWEEN 0 AND 1000 THEN _src._w_value END)\n END AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.\"orders.created_at\"", "custom_default_literal_p::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(CASE\n WHEN COUNT(_src._w_time) = 0\n THEN NULL\n ELSE AVG(CASE WHEN _src._w_value BETWEEN 0 AND 1000 THEN _src._w_value END)\n END AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.\"orders.created_at\"", "custom_default_literal_p::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n CAST(CASE\n WHEN COUNT(_src._w_time) = 0\n THEN NULL\n ELSE AVG(CASE WHEN _src._w_value BETWEEN 0 AND 1000 THEN _src._w_value END)\n END AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_trimmed_mean_hi_1000_lo_0_window_90d.[orders___created_at] IS NULL\n )\n )", - "custom_joined_default_column::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n), _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y AS (\n SELECT\n _base.`customers___signup_at_month`,\n CAST(CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS FLOAT64) AS `customers___spend_disc_spend_d_discount_window_1y`\n FROM (\n SELECT\n `_e`.`orders___customers___signup_at` AS `customers___signup_at_month`\n FROM (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n customers.discount AS _w_p0\n FROM customers AS customers\n ) AS _src\n ON _src._w_time >= CAST(DATETIME_ADD(\n CAST(CAST(DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP) AS DATETIME),\n INTERVAL -1 YEAR\n ) AS TIMESTAMP)\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`customers___signup_at_month`\n)\nSELECT\n _base.`orders___customers___signup_at`,\n _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y.`customers___spend_disc_spend_d_discount_window_1y` AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y\n ON _base.`orders___customers___signup_at` IS NOT DISTINCT FROM _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y.`customers___signup_at_month`", + "custom_joined_default_column::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n), _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y AS (\n SELECT\n _base.`customers___signup_at_month`,\n CAST(CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS FLOAT64) AS `customers___spend_disc_spend_d_discount_window_1y`\n FROM (\n SELECT\n `_e`.`orders___customers___signup_at` AS `customers___signup_at_month`\n FROM (\n SELECT\n DATE_TRUNC(customers.signup_at, MONTH) AS `orders___customers___signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC(customers.signup_at, MONTH)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n customers.discount AS _w_p0\n FROM customers AS customers\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -1 YEAR\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`customers___signup_at_month` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`customers___signup_at_month`\n)\nSELECT\n _base.`orders___customers___signup_at`,\n _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y.`customers___spend_disc_spend_d_discount_window_1y` AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y\n ON _base.`orders___customers___signup_at` IS NOT DISTINCT FROM _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y.`customers___signup_at_month`", "custom_joined_default_column::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n), _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y AS (\n SELECT\n _base.\"customers.signup_at_month\",\n CAST(CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS DOUBLE) AS \"customers.spend_disc_spend_d_discount_window_1y\"\n FROM (\n SELECT\n \"_e\".\"orders.customers.signup_at\" AS \"customers.signup_at_month\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n customers.discount AS _w_p0\n FROM customers AS customers\n ) AS _src\n ON _src._w_time >= _base.\"customers.signup_at_month\" + INTERVAL 1 MONTH - INTERVAL 1 YEAR\n AND _src._w_time < _base.\"customers.signup_at_month\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"customers.signup_at_month\"\n)\nSELECT\n _base.\"orders.customers.signup_at\",\n _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y.\"customers.spend_disc_spend_d_discount_window_1y\" AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y\n ON _base.\"orders.customers.signup_at\" IS NOT DISTINCT FROM _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y.\"customers.signup_at_month\"", "custom_joined_default_column::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n ) AS `orders.customers.signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n )\n), _cm_orders__customers__spen_9cde6242_ustomers_discount_window_1y AS (\n SELECT\n _base.`customers.signup_at_month`,\n CAST(CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS DOUBLE) AS `customers.spend_disc_spend_d_discount_window_1y`\n FROM (\n SELECT\n `_e`.`orders.customers.signup_at` AS `customers.signup_at_month`\n FROM (\n SELECT\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n ) AS `orders.customers.signup_at`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n STR_TO_DATE(\n CONCAT(YEAR(customers.signup_at), ' ', MONTH(customers.signup_at), ' 1'),\n '%Y %c %e'\n )\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n customers.discount AS _w_p0\n FROM customers AS customers\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`customers.signup_at_month`, INTERVAL 1 MONTH), INTERVAL -1 YEAR)\n AND _src._w_time < DATE_ADD(_base.`customers.signup_at_month`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`customers.signup_at_month`\n)\nSELECT\n _base.`orders.customers.signup_at`,\n _cm_orders__customers__spen_9cde6242_ustomers_discount_window_1y.`customers.spend_disc_spend_d_discount_window_1y` AS `orders.w`\nFROM _base\nLEFT JOIN _cm_orders__customers__spen_9cde6242_ustomers_discount_window_1y\n ON _base.`orders.customers.signup_at` <=> _cm_orders__customers__spen_9cde6242_ustomers_discount_window_1y.`customers.signup_at_month`", "custom_joined_default_column::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n), _cm_orders__customers__spen_9cde6242_stomers_discount_window_1y AS (\n SELECT\n _base.\"customers.signup_at_month\",\n CAST(CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS DOUBLE PRECISION) AS \"customers.spend_disc_spend_d_discount_window_1y\"\n FROM (\n SELECT\n \"_e\".\"orders.customers.signup_at\" AS \"customers.signup_at_month\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n customers.discount AS _w_p0\n FROM customers AS customers\n ) AS _src\n ON _src._w_time >= _base.\"customers.signup_at_month\" + INTERVAL '1 MONTH' - INTERVAL '1 YEAR'\n AND _src._w_time < _base.\"customers.signup_at_month\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"customers.signup_at_month\"\n)\nSELECT\n _base.\"orders.customers.signup_at\",\n _cm_orders__customers__spen_9cde6242_stomers_discount_window_1y.\"customers.spend_disc_spend_d_discount_window_1y\" AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spen_9cde6242_stomers_discount_window_1y\n ON _base.\"orders.customers.signup_at\" IS NOT DISTINCT FROM _cm_orders__customers__spen_9cde6242_stomers_discount_window_1y.\"customers.signup_at_month\"", "custom_joined_default_column::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n), _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y AS (\n SELECT\n _base.\"customers.signup_at_month\",\n CAST(CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS DOUBLE) AS \"customers.spend_disc_spend_d_discount_window_1y\"\n FROM (\n SELECT\n \"_e\".\"orders.customers.signup_at\" AS \"customers.signup_at_month\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATE_TRUNC('MONTH', customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n customers.discount AS _w_p0\n FROM customers AS customers\n ) AS _src\n ON _src._w_time >= DATEADD(YEAR, -1, DATEADD(MONTH, 1, _base.\"customers.signup_at_month\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"customers.signup_at_month\")\n GROUP BY\n _base.\"customers.signup_at_month\"\n)\nSELECT\n _base.\"orders.customers.signup_at\",\n _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y.\"customers.spend_disc_spend_d_discount_window_1y\" AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y\n ON _base.\"orders.customers.signup_at\" IS NOT DISTINCT FROM _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y.\"customers.signup_at_month\"", "custom_joined_default_column::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n STRFTIME('%Y-%m-01', customers.signup_at)\n), _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y AS (\n SELECT\n _base.\"customers.signup_at_month\",\n CAST(CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS REAL) AS \"customers.spend_disc_spend_d_discount_window_1y\"\n FROM (\n SELECT\n \"_e\".\"orders.customers.signup_at\" AS \"customers.signup_at_month\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', customers.signup_at) AS \"orders.customers.signup_at\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n STRFTIME('%Y-%m-01', customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n customers.discount AS _w_p0\n FROM customers AS customers\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"customers.signup_at_month\", 1, 'month'), -1, 'year')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"customers.signup_at_month\", 1, 'month')\n GROUP BY\n _base.\"customers.signup_at_month\"\n)\nSELECT\n _base.\"orders.customers.signup_at\",\n _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y.\"customers.spend_disc_spend_d_discount_window_1y\" AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y\n ON _base.\"orders.customers.signup_at\" IS _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y.\"customers.signup_at_month\"", "custom_joined_default_column::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, customers.signup_at) AS [orders___customers___signup_at]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATETRUNC(month, customers.signup_at)\n), _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y AS (\n SELECT\n _base.[customers___signup_at_month] AS [customers___signup_at_month],\n CAST(CASE WHEN COUNT(_src._w_time) = 0 THEN NULL ELSE SUM(_src._w_value * _src._w_p0) END AS FLOAT) AS [customers___spend_disc_spend_d_discount_window_1y]\n FROM (\n SELECT\n [_e].[orders___customers___signup_at] AS [customers___signup_at_month]\n FROM (\n SELECT\n DATETRUNC(month, customers.signup_at) AS [orders___customers___signup_at]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n GROUP BY\n DATETRUNC(month, customers.signup_at)\n ) AS _e\n ) AS _base\n LEFT JOIN (\n SELECT\n customers.signup_at AS _w_time,\n customers.spend AS _w_value,\n customers.discount AS _w_p0\n FROM customers AS customers\n ) AS _src\n ON _src._w_time >= DATEADD(YEAR, -1, DATEADD(MONTH, 1, _base.[customers___signup_at_month]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[customers___signup_at_month])\n GROUP BY\n _base.[customers___signup_at_month]\n)\nSELECT\n _base.[orders___customers___signup_at],\n _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y.[customers___spend_disc_spend_d_discount_window_1y] AS [orders___w]\nFROM _base\nLEFT JOIN _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y\n ON (\n (\n _base.[orders___customers___signup_at] = _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y.[customers___signup_at_month]\n AND NOT _base.[orders___customers___signup_at] IS NULL\n AND NOT _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y.[customers___signup_at_month] IS NULL\n )\n OR (\n _base.[orders___customers___signup_at] IS NULL\n AND _cm_orders__customers__spend_disc_spend_d_customers_discount_window_1y.[customers___signup_at_month] IS NULL\n )\n )", - "custom_trimmed_mean::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(CASE\n WHEN COUNT(_src._w_time) = 0\n THEN NULL\n ELSE AVG(CASE WHEN _src._w_value BETWEEN 150 AND 350 THEN _src._w_value END)\n END AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.`orders___created_at`", + "custom_trimmed_mean::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(CASE\n WHEN COUNT(_src._w_time) = 0\n THEN NULL\n ELSE AVG(CASE WHEN _src._w_value BETWEEN 150 AND 350 THEN _src._w_value END)\n END AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.`orders___created_at`", "custom_trimmed_mean::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(CASE\n WHEN COUNT(_src._w_time) = 0\n THEN NULL\n ELSE AVG(CASE WHEN _src._w_value BETWEEN 150 AND 350 THEN _src._w_value END)\n END AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.\"orders.created_at\"", "custom_trimmed_mean::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n CAST(CASE\n WHEN COUNT(_src._w_time) = 0\n THEN NULL\n ELSE AVG(CASE WHEN _src._w_value BETWEEN 150 AND 350 THEN _src._w_value END)\n END AS DOUBLE) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.`orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.`orders.created_at`", "custom_trimmed_mean::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(CASE\n WHEN COUNT(_src._w_time) = 0\n THEN NULL\n ELSE AVG(CASE WHEN _src._w_value BETWEEN 150 AND 350 THEN _src._w_value END)\n END AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.\"orders.created_at\"", "custom_trimmed_mean::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(CASE\n WHEN COUNT(_src._w_time) = 0\n THEN NULL\n ELSE AVG(CASE WHEN _src._w_value BETWEEN 150 AND 350 THEN _src._w_value END)\n END AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.\"orders.created_at\"", "custom_trimmed_mean::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(CASE\n WHEN COUNT(_src._w_time) = 0\n THEN NULL\n ELSE AVG(CASE WHEN _src._w_value BETWEEN 150 AND 350 THEN _src._w_value END)\n END AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.\"orders.created_at\"", "custom_trimmed_mean::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n CAST(CASE\n WHEN COUNT(_src._w_time) = 0\n THEN NULL\n ELSE AVG(CASE WHEN _src._w_value BETWEEN 150 AND 350 THEN _src._w_value END)\n END AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_trimmed_mean_hi_350_lo_150_window_90d.[orders___created_at] IS NULL\n )\n )", - "expression_source_count_distinct::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_qty_count_distinct_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n COUNT(DISTINCT _src._w_value) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount - orders.qty AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n COALESCE(_cm_orders__amount_qty_count_distinct_window_90d.`orders___w`, 0) AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_qty_count_distinct_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_qty_count_distinct_window_90d.`orders___created_at`", + "expression_source_count_distinct::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_qty_count_distinct_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n COUNT(DISTINCT _src._w_value) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount - orders.qty AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n COALESCE(_cm_orders__amount_qty_count_distinct_window_90d.`orders___w`, 0) AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_qty_count_distinct_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_qty_count_distinct_window_90d.`orders___created_at`", "expression_source_count_distinct::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_qty_count_distinct_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(DISTINCT _src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount - orders.qty AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_qty_count_distinct_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_qty_count_distinct_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_qty_count_distinct_window_90d.\"orders.created_at\"", "expression_source_count_distinct::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_qty_count_distinct_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n COUNT(DISTINCT _src._w_value) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount - orders.qty AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n COALESCE(_cm_orders__amount_qty_count_distinct_window_90d.`orders.w`, 0) AS `orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_qty_count_distinct_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_qty_count_distinct_window_90d.`orders.created_at`", "expression_source_count_distinct::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_qty_count_distinct_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(DISTINCT _src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount - orders.qty AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_qty_count_distinct_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_qty_count_distinct_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_qty_count_distinct_window_90d.\"orders.created_at\"", "expression_source_count_distinct::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_qty_count_distinct_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(DISTINCT _src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount - orders.qty AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_qty_count_distinct_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_qty_count_distinct_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_qty_count_distinct_window_90d.\"orders.created_at\"", "expression_source_count_distinct::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_qty_count_distinct_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(DISTINCT _src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount - orders.qty AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_qty_count_distinct_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_qty_count_distinct_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_qty_count_distinct_window_90d.\"orders.created_at\"", "expression_source_count_distinct::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_qty_count_distinct_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n COUNT(DISTINCT _src._w_value) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount - orders.qty AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n COALESCE(_cm_orders__amount_qty_count_distinct_window_90d.[orders___w], 0) AS [orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_qty_count_distinct_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_qty_count_distinct_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_qty_count_distinct_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_qty_count_distinct_window_90d.[orders___created_at] IS NULL\n )\n )", - "filter_only_count::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___s`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_count_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n COUNT(_src._w_value) AS `orders___amount_count_window_90d`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _base.`orders___s`\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d.`orders___created_at`\nWHERE\n COALESCE(_cm_orders__amount_count_window_90d.`orders___amount_count_window_90d`, 0) >= 3", + "filter_only_count::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___s`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_count_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n COUNT(_src._w_value) AS `orders___amount_count_window_90d`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _base.`orders___s`\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d.`orders___created_at`\nWHERE\n COALESCE(_cm_orders__amount_count_window_90d.`orders___amount_count_window_90d`, 0) >= 3", "filter_only_count::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.s\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_count_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(_src._w_value) AS \"orders.amount_count_window_90d\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _base.\"orders.s\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d.\"orders.created_at\"\nWHERE\n COALESCE(_cm_orders__amount_count_window_90d.\"orders.amount_count_window_90d\", 0) >= 3", "filter_only_count::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`,\n CAST(SUM(orders.amount) AS DOUBLE) AS `orders.s`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_count_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n COUNT(_src._w_value) AS `orders.amount_count_window_90d`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _base.`orders.s`\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_count_window_90d.`orders.created_at`\nWHERE\n COALESCE(_cm_orders__amount_count_window_90d.`orders.amount_count_window_90d`, 0) >= 3", "filter_only_count::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.s\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_count_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(_src._w_value) AS \"orders.amount_count_window_90d\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _base.\"orders.s\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d.\"orders.created_at\"\nWHERE\n COALESCE(_cm_orders__amount_count_window_90d.\"orders.amount_count_window_90d\", 0) >= 3", "filter_only_count::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.s\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_count_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(_src._w_value) AS \"orders.amount_count_window_90d\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _base.\"orders.s\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d.\"orders.created_at\"\nWHERE\n COALESCE(_cm_orders__amount_count_window_90d.\"orders.amount_count_window_90d\", 0) >= 3", "filter_only_count::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.s\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_count_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(_src._w_value) AS \"orders.amount_count_window_90d\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _base.\"orders.s\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_count_window_90d.\"orders.created_at\"\nWHERE\n COALESCE(_cm_orders__amount_count_window_90d.\"orders.amount_count_window_90d\", 0) >= 3", "filter_only_count::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___s]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_count_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n COUNT(_src._w_value) AS [orders___amount_count_window_90d]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _base.[orders___s]\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_count_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_count_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_count_window_90d.[orders___created_at] IS NULL\n )\n )\nWHERE\n COALESCE(_cm_orders__amount_count_window_90d.[orders___amount_count_window_90d], 0) >= 3", - "first::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_first_window_90d AS (\n SELECT\n _ranked_src.`orders___created_at` AS `orders___created_at`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n _base.`orders___created_at` AS `orders___created_at`,\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.`orders___created_at` ORDER BY _src._w_rank) AS _ranked_rn\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.created_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n ) AS _ranked_src\n GROUP BY\n _ranked_src.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_first_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_first_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_first_window_90d.`orders___created_at`", + "first::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_first_window_90d AS (\n SELECT\n _ranked_src.`orders___created_at` AS `orders___created_at`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n _base.`orders___created_at` AS `orders___created_at`,\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.`orders___created_at` ORDER BY _src._w_rank) AS _ranked_rn\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.created_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n ) AS _ranked_src\n GROUP BY\n _ranked_src.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_first_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_first_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_first_window_90d.`orders___created_at`", "first::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_first_window_90d AS (\n SELECT\n _ranked_src.\"orders.created_at\" AS \"orders.created_at\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n _base.\"orders.created_at\" AS \"orders.created_at\",\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.\"orders.created_at\" ORDER BY _src._w_rank) AS _ranked_rn\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.created_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n ) AS _ranked_src\n GROUP BY\n _ranked_src.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_first_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_first_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_first_window_90d.\"orders.created_at\"", "first::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_first_window_90d AS (\n SELECT\n _ranked_src.`orders.created_at` AS `orders.created_at`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS DOUBLE) AS `orders.w`\n FROM (\n SELECT\n _base.`orders.created_at` AS `orders.created_at`,\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.`orders.created_at` ORDER BY _src._w_rank) AS _ranked_rn\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.created_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n ) AS _ranked_src\n GROUP BY\n _ranked_src.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _cm_orders__amount_first_window_90d.`orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_first_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_first_window_90d.`orders.created_at`", "first::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_first_window_90d AS (\n SELECT\n _ranked_src.\"orders.created_at\" AS \"orders.created_at\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n _base.\"orders.created_at\" AS \"orders.created_at\",\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.\"orders.created_at\" ORDER BY _src._w_rank) AS _ranked_rn\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.created_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n ) AS _ranked_src\n GROUP BY\n _ranked_src.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_first_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_first_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_first_window_90d.\"orders.created_at\"", "first::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_first_window_90d AS (\n SELECT\n _ranked_src.\"orders.created_at\" AS \"orders.created_at\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n _base.\"orders.created_at\" AS \"orders.created_at\",\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.\"orders.created_at\" ORDER BY _src._w_rank) AS _ranked_rn\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.created_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n ) AS _ranked_src\n GROUP BY\n _ranked_src.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_first_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_first_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_first_window_90d.\"orders.created_at\"", "first::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_first_window_90d AS (\n SELECT\n _ranked_src.\"orders.created_at\" AS \"orders.created_at\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n _base.\"orders.created_at\" AS \"orders.created_at\",\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.\"orders.created_at\" ORDER BY _src._w_rank) AS _ranked_rn\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.created_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n ) AS _ranked_src\n GROUP BY\n _ranked_src.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_first_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_first_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_first_window_90d.\"orders.created_at\"", "first::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_first_window_90d AS (\n SELECT\n _ranked_src.[orders___created_at] AS [orders___created_at],\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.[orders___created_at] ORDER BY _src._w_rank) AS _ranked_rn\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.created_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n ) AS _ranked_src\n GROUP BY\n _ranked_src.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _cm_orders__amount_first_window_90d.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_first_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_first_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_first_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_first_window_90d.[orders___created_at] IS NULL\n )\n )", - "last::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_last_window_90d AS (\n SELECT\n _ranked_src.`orders___created_at` AS `orders___created_at`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n _base.`orders___created_at` AS `orders___created_at`,\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.`orders___created_at` ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.created_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n ) AS _ranked_src\n GROUP BY\n _ranked_src.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_last_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_last_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_last_window_90d.`orders___created_at`", + "last::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_last_window_90d AS (\n SELECT\n _ranked_src.`orders___created_at` AS `orders___created_at`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n _base.`orders___created_at` AS `orders___created_at`,\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.`orders___created_at` ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.created_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n ) AS _ranked_src\n GROUP BY\n _ranked_src.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_last_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_last_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_last_window_90d.`orders___created_at`", "last::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_last_window_90d AS (\n SELECT\n _ranked_src.\"orders.created_at\" AS \"orders.created_at\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n _base.\"orders.created_at\" AS \"orders.created_at\",\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.\"orders.created_at\" ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.created_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n ) AS _ranked_src\n GROUP BY\n _ranked_src.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_last_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_last_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_last_window_90d.\"orders.created_at\"", "last::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_last_window_90d AS (\n SELECT\n _ranked_src.`orders.created_at` AS `orders.created_at`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS DOUBLE) AS `orders.w`\n FROM (\n SELECT\n _base.`orders.created_at` AS `orders.created_at`,\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.`orders.created_at` ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.created_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n ) AS _ranked_src\n GROUP BY\n _ranked_src.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _cm_orders__amount_last_window_90d.`orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_last_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_last_window_90d.`orders.created_at`", "last::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_last_window_90d AS (\n SELECT\n _ranked_src.\"orders.created_at\" AS \"orders.created_at\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n _base.\"orders.created_at\" AS \"orders.created_at\",\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.\"orders.created_at\" ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.created_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n ) AS _ranked_src\n GROUP BY\n _ranked_src.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_last_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_last_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_last_window_90d.\"orders.created_at\"", "last::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_last_window_90d AS (\n SELECT\n _ranked_src.\"orders.created_at\" AS \"orders.created_at\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n _base.\"orders.created_at\" AS \"orders.created_at\",\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.\"orders.created_at\" ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.created_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n ) AS _ranked_src\n GROUP BY\n _ranked_src.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_last_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_last_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_last_window_90d.\"orders.created_at\"", "last::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_last_window_90d AS (\n SELECT\n _ranked_src.\"orders.created_at\" AS \"orders.created_at\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n _base.\"orders.created_at\" AS \"orders.created_at\",\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.\"orders.created_at\" ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.created_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n ) AS _ranked_src\n GROUP BY\n _ranked_src.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_last_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_last_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_last_window_90d.\"orders.created_at\"", "last::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_last_window_90d AS (\n SELECT\n _ranked_src.[orders___created_at] AS [orders___created_at],\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.[orders___created_at] ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.created_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n ) AS _ranked_src\n GROUP BY\n _ranked_src.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _cm_orders__amount_last_window_90d.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_last_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_last_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_last_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_last_window_90d.[orders___created_at] IS NULL\n )\n )", - "last_explicit_time::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_last_updated_at_window_90d AS (\n SELECT\n _ranked_src.`orders___created_at` AS `orders___created_at`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n _base.`orders___created_at` AS `orders___created_at`,\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.`orders___created_at` ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.updated_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n ) AS _ranked_src\n GROUP BY\n _ranked_src.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_last_updated_at_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_last_updated_at_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_last_updated_at_window_90d.`orders___created_at`", + "last_explicit_time::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_last_updated_at_window_90d AS (\n SELECT\n _ranked_src.`orders___created_at` AS `orders___created_at`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n _base.`orders___created_at` AS `orders___created_at`,\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.`orders___created_at` ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.updated_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n ) AS _ranked_src\n GROUP BY\n _ranked_src.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_last_updated_at_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_last_updated_at_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_last_updated_at_window_90d.`orders___created_at`", "last_explicit_time::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_last_updated_at_window_90d AS (\n SELECT\n _ranked_src.\"orders.created_at\" AS \"orders.created_at\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n _base.\"orders.created_at\" AS \"orders.created_at\",\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.\"orders.created_at\" ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.updated_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n ) AS _ranked_src\n GROUP BY\n _ranked_src.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_last_updated_at_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_last_updated_at_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_last_updated_at_window_90d.\"orders.created_at\"", "last_explicit_time::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_last_updated_at_window_90d AS (\n SELECT\n _ranked_src.`orders.created_at` AS `orders.created_at`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS DOUBLE) AS `orders.w`\n FROM (\n SELECT\n _base.`orders.created_at` AS `orders.created_at`,\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.`orders.created_at` ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.updated_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n ) AS _ranked_src\n GROUP BY\n _ranked_src.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _cm_orders__amount_last_updated_at_window_90d.`orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_last_updated_at_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_last_updated_at_window_90d.`orders.created_at`", "last_explicit_time::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_last_updated_at_window_90d AS (\n SELECT\n _ranked_src.\"orders.created_at\" AS \"orders.created_at\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n _base.\"orders.created_at\" AS \"orders.created_at\",\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.\"orders.created_at\" ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.updated_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n ) AS _ranked_src\n GROUP BY\n _ranked_src.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_last_updated_at_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_last_updated_at_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_last_updated_at_window_90d.\"orders.created_at\"", "last_explicit_time::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_last_updated_at_window_90d AS (\n SELECT\n _ranked_src.\"orders.created_at\" AS \"orders.created_at\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n _base.\"orders.created_at\" AS \"orders.created_at\",\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.\"orders.created_at\" ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.updated_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n ) AS _ranked_src\n GROUP BY\n _ranked_src.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_last_updated_at_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_last_updated_at_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_last_updated_at_window_90d.\"orders.created_at\"", "last_explicit_time::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_last_updated_at_window_90d AS (\n SELECT\n _ranked_src.\"orders.created_at\" AS \"orders.created_at\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n _base.\"orders.created_at\" AS \"orders.created_at\",\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.\"orders.created_at\" ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.updated_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n ) AS _ranked_src\n GROUP BY\n _ranked_src.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_last_updated_at_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_last_updated_at_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_last_updated_at_window_90d.\"orders.created_at\"", "last_explicit_time::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_last_updated_at_window_90d AS (\n SELECT\n _ranked_src.[orders___created_at] AS [orders___created_at],\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _ranked_src._w_value END) AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n _src._w_value AS _w_value,\n ROW_NUMBER() OVER (PARTITION BY _base.[orders___created_at] ORDER BY _src._w_rank DESC) AS _ranked_rn\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.updated_at AS _w_rank\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n ) AS _ranked_src\n GROUP BY\n _ranked_src.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _cm_orders__amount_last_updated_at_window_90d.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_last_updated_at_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_last_updated_at_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_last_updated_at_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_last_updated_at_window_90d.[orders___created_at] IS NULL\n )\n )", - "max::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_max_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(MAX(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_max_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_max_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_max_window_90d.`orders___created_at`", + "max::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_max_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(MAX(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_max_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_max_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_max_window_90d.`orders___created_at`", "max::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_max_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(MAX(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_max_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_max_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_max_window_90d.\"orders.created_at\"", "max::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_max_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n CAST(MAX(_src._w_value) AS DOUBLE) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _cm_orders__amount_max_window_90d.`orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_max_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_max_window_90d.`orders.created_at`", "max::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_max_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(MAX(_src._w_value) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_max_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_max_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_max_window_90d.\"orders.created_at\"", "max::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_max_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(MAX(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_max_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_max_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_max_window_90d.\"orders.created_at\"", "max::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_max_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(MAX(_src._w_value) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_max_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_max_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_max_window_90d.\"orders.created_at\"", "max::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_max_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n CAST(MAX(_src._w_value) AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _cm_orders__amount_max_window_90d.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_max_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_max_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_max_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_max_window_90d.[orders___created_at] IS NULL\n )\n )", - "median::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_median_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY\n _src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_median_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_median_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_median_window_90d.`orders___created_at`", + "median::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_median_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY\n _src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_median_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_median_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_median_window_90d.`orders___created_at`", "median::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_median_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(QUANTILE_CONT(_src._w_value, 0.5\n ORDER BY\n _src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_median_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_median_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_median_window_90d.\"orders.created_at\"", "median::mysql": { "error": "NotImplementedError", @@ -124,28 +124,28 @@ "error": "NotImplementedError", "message": "Aggregation 'median' is not supported on T-SQL (SQL Server): PERCENTILE_CONT in T-SQL is a window function (requires OVER clause) and cannot be used as a GROUP BY aggregate. Use a window subquery or compute the value client-side." }, - "min::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_min_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(MIN(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_min_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_min_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_min_window_90d.`orders___created_at`", + "min::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_min_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(MIN(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_min_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_min_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_min_window_90d.`orders___created_at`", "min::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_min_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(MIN(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_min_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_min_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_min_window_90d.\"orders.created_at\"", "min::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_min_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n CAST(MIN(_src._w_value) AS DOUBLE) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _cm_orders__amount_min_window_90d.`orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_min_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_min_window_90d.`orders.created_at`", "min::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_min_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(MIN(_src._w_value) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_min_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_min_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_min_window_90d.\"orders.created_at\"", "min::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_min_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(MIN(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_min_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_min_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_min_window_90d.\"orders.created_at\"", "min::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_min_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(MIN(_src._w_value) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_min_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_min_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_min_window_90d.\"orders.created_at\"", "min::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_min_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n CAST(MIN(_src._w_value) AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _cm_orders__amount_min_window_90d.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_min_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_min_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_min_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_min_window_90d.[orders___created_at] IS NULL\n )\n )", - "order_only_max::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___s`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_max_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(MAX(_src._w_value) AS FLOAT64) AS `orders___amount_max_window_90d`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _base.`orders___s`\nFROM _base\nLEFT JOIN _cm_orders__amount_max_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_max_window_90d.`orders___created_at`\nORDER BY\n _cm_orders__amount_max_window_90d.`orders___amount_max_window_90d` DESC", + "order_only_max::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___s`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_max_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(MAX(_src._w_value) AS FLOAT64) AS `orders___amount_max_window_90d`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _base.`orders___s`\nFROM _base\nLEFT JOIN _cm_orders__amount_max_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_max_window_90d.`orders___created_at`\nORDER BY\n _cm_orders__amount_max_window_90d.`orders___amount_max_window_90d` DESC", "order_only_max::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.s\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_max_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(MAX(_src._w_value) AS DOUBLE) AS \"orders.amount_max_window_90d\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _base.\"orders.s\"\nFROM _base\nLEFT JOIN _cm_orders__amount_max_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_max_window_90d.\"orders.created_at\"\nORDER BY\n _cm_orders__amount_max_window_90d.\"orders.amount_max_window_90d\" DESC", "order_only_max::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`,\n CAST(SUM(orders.amount) AS DOUBLE) AS `orders.s`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_max_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n CAST(MAX(_src._w_value) AS DOUBLE) AS `orders.amount_max_window_90d`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _base.`orders.s`\nFROM _base\nLEFT JOIN _cm_orders__amount_max_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_max_window_90d.`orders.created_at`\nORDER BY\n _cm_orders__amount_max_window_90d.`orders.amount_max_window_90d` DESC", "order_only_max::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.s\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_max_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(MAX(_src._w_value) AS DOUBLE PRECISION) AS \"orders.amount_max_window_90d\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _base.\"orders.s\"\nFROM _base\nLEFT JOIN _cm_orders__amount_max_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_max_window_90d.\"orders.created_at\"\nORDER BY\n _cm_orders__amount_max_window_90d.\"orders.amount_max_window_90d\" DESC NULLS LAST", "order_only_max::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.s\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_max_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(MAX(_src._w_value) AS DOUBLE) AS \"orders.amount_max_window_90d\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _base.\"orders.s\"\nFROM _base\nLEFT JOIN _cm_orders__amount_max_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_max_window_90d.\"orders.created_at\"\nORDER BY\n _cm_orders__amount_max_window_90d.\"orders.amount_max_window_90d\" DESC NULLS LAST", "order_only_max::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.s\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_max_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(MAX(_src._w_value) AS REAL) AS \"orders.amount_max_window_90d\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _base.\"orders.s\"\nFROM _base\nLEFT JOIN _cm_orders__amount_max_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_max_window_90d.\"orders.created_at\"\nORDER BY\n _cm_orders__amount_max_window_90d.\"orders.amount_max_window_90d\" DESC", "order_only_max::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___s]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_max_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n CAST(MAX(_src._w_value) AS FLOAT) AS [orders___amount_max_window_90d]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _base.[orders___s]\nFROM _base\nLEFT JOIN _cm_orders__amount_max_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_max_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_max_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_max_window_90d.[orders___created_at] IS NULL\n )\n )\nORDER BY\n _cm_orders__amount_max_window_90d.[orders___amount_max_window_90d] DESC", - "partitioned_count::bigquery": "WITH _base AS (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_count_window_90d_partition_by_region AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___created_at`,\n COUNT(_src._w_value) AS `orders___w`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___region`,\n _base.`orders___created_at`,\n COALESCE(_cm_orders__amount_count_window_90d_partition_by_region.`orders___w`, 0) AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d_partition_by_region\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d_partition_by_region.`orders___region`\n AND _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d_partition_by_region.`orders___created_at`", + "partitioned_count::bigquery": "WITH _base AS (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_count_window_90d_partition_by_region AS (\n SELECT\n _base.`orders___region`,\n _base.`orders___created_at`,\n COUNT(_src._w_value) AS `orders___w`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`orders___region`\n AND _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___region`,\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___region`,\n _base.`orders___created_at`,\n COALESCE(_cm_orders__amount_count_window_90d_partition_by_region.`orders___w`, 0) AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d_partition_by_region\n ON _base.`orders___region` IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d_partition_by_region.`orders___region`\n AND _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d_partition_by_region.`orders___created_at`", "partitioned_count::duckdb": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_count_window_90d_partition_by_region AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.created_at\",\n COUNT(_src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_count_window_90d_partition_by_region.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d_partition_by_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d_partition_by_region.\"orders.region\"\n AND _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d_partition_by_region.\"orders.created_at\"", "partitioned_count::mysql": "WITH _base AS (\n SELECT\n orders.region AS `orders.region`,\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_count_window_90d_partition_by_region AS (\n SELECT\n _base.`orders.region`,\n _base.`orders.created_at`,\n COUNT(_src._w_value) AS `orders.w`\n FROM (\n SELECT\n orders.region AS `orders.region`,\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n orders.region,\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 <=> _base.`orders.region`\n AND _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.region`,\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.region`,\n _base.`orders.created_at`,\n COALESCE(_cm_orders__amount_count_window_90d_partition_by_region.`orders.w`, 0) AS `orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d_partition_by_region\n ON _base.`orders.region` <=> _cm_orders__amount_count_window_90d_partition_by_region.`orders.region`\n AND _base.`orders.created_at` <=> _cm_orders__amount_count_window_90d_partition_by_region.`orders.created_at`", "partitioned_count::postgres": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_count_window_90d_partition_by_region AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.created_at\",\n COUNT(_src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_count_window_90d_partition_by_region.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d_partition_by_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d_partition_by_region.\"orders.region\"\n AND _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d_partition_by_region.\"orders.created_at\"", "partitioned_count::snowflake": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_count_window_90d_partition_by_region AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.created_at\",\n COUNT(_src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"orders.region\"\n AND _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_count_window_90d_partition_by_region.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d_partition_by_region\n ON _base.\"orders.region\" IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d_partition_by_region.\"orders.region\"\n AND _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_count_window_90d_partition_by_region.\"orders.created_at\"", "partitioned_count::sqlite": "WITH _base AS (\n SELECT\n orders.region AS \"orders.region\",\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_count_window_90d_partition_by_region AS (\n SELECT\n _base.\"orders.region\",\n _base.\"orders.created_at\",\n COUNT(_src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n orders.region,\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_dim_0 IS _base.\"orders.region\"\n AND DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.region\",\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.region\",\n _base.\"orders.created_at\",\n COALESCE(_cm_orders__amount_count_window_90d_partition_by_region.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d_partition_by_region\n ON _base.\"orders.region\" IS _cm_orders__amount_count_window_90d_partition_by_region.\"orders.region\"\n AND _base.\"orders.created_at\" IS _cm_orders__amount_count_window_90d_partition_by_region.\"orders.created_at\"", "partitioned_count::tsql": "WITH _base AS (\n SELECT\n orders.region AS [orders___region],\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_count_window_90d_partition_by_region AS (\n SELECT\n _base.[orders___region] AS [orders___region],\n _base.[orders___created_at] AS [orders___created_at],\n COUNT(_src._w_value) AS [orders___w]\n FROM (\n SELECT\n orders.region AS [orders___region],\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n orders.region,\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.region AS _w_dim_0,\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON (\n (\n _src._w_dim_0 = _base.[orders___region]\n AND NOT _src._w_dim_0 IS NULL\n AND NOT _base.[orders___region] IS NULL\n )\n OR (\n _src._w_dim_0 IS NULL AND _base.[orders___region] IS NULL\n )\n )\n AND _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___region],\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___region],\n _base.[orders___created_at],\n COALESCE(_cm_orders__amount_count_window_90d_partition_by_region.[orders___w], 0) AS [orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_count_window_90d_partition_by_region\n ON (\n (\n _base.[orders___region] = _cm_orders__amount_count_window_90d_partition_by_region.[orders___region]\n AND NOT _base.[orders___region] IS NULL\n AND NOT _cm_orders__amount_count_window_90d_partition_by_region.[orders___region] IS NULL\n )\n OR (\n _base.[orders___region] IS NULL\n AND _cm_orders__amount_count_window_90d_partition_by_region.[orders___region] IS NULL\n )\n )\n AND (\n (\n _base.[orders___created_at] = _cm_orders__amount_count_window_90d_partition_by_region.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_count_window_90d_partition_by_region.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_count_window_90d_partition_by_region.[orders___created_at] IS NULL\n )\n )", - "percentile_p09::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_percentile_p_0_9_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(PERCENTILE_CONT(0.9) WITHIN GROUP (ORDER BY\n _src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_percentile_p_0_9_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_percentile_p_0_9_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_percentile_p_0_9_window_90d.`orders___created_at`", + "percentile_p09::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_percentile_p_0_9_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(PERCENTILE_CONT(0.9) WITHIN GROUP (ORDER BY\n _src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_percentile_p_0_9_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_percentile_p_0_9_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_percentile_p_0_9_window_90d.`orders___created_at`", "percentile_p09::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_percentile_p_0_9_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(QUANTILE_CONT(_src._w_value, 0.9\n ORDER BY\n _src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_percentile_p_0_9_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_percentile_p_0_9_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_percentile_p_0_9_window_90d.\"orders.created_at\"", "percentile_p09::mysql": { "error": "NotImplementedError", @@ -158,49 +158,49 @@ "error": "NotImplementedError", "message": "Aggregation 'percentile' is not supported on T-SQL (SQL Server): PERCENTILE_CONT requires a window function OVER clause in T-SQL and is not valid as a GROUP BY aggregate. Compute the value client-side or restructure as a window query." }, - "star_count::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders___count_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n COUNT(_src._w_value) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n 1 AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n COALESCE(_cm_orders___count_window_90d.`orders___w`, 0) AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders___count_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders___count_window_90d.`orders___created_at`", + "star_count::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders___count_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n COUNT(_src._w_value) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n 1 AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n COALESCE(_cm_orders___count_window_90d.`orders___w`, 0) AS `orders___w`\nFROM _base\nLEFT JOIN _cm_orders___count_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders___count_window_90d.`orders___created_at`", "star_count::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders___count_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(_src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n 1 AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders___count_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders___count_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders___count_window_90d.\"orders.created_at\"", "star_count::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders___count_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n COUNT(_src._w_value) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n 1 AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n COALESCE(_cm_orders___count_window_90d.`orders.w`, 0) AS `orders.w`\nFROM _base\nLEFT JOIN _cm_orders___count_window_90d\n ON _base.`orders.created_at` <=> _cm_orders___count_window_90d.`orders.created_at`", "star_count::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders___count_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(_src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n 1 AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders___count_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders___count_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders___count_window_90d.\"orders.created_at\"", "star_count::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders___count_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(_src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n 1 AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders___count_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders___count_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders___count_window_90d.\"orders.created_at\"", "star_count::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders___count_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n COUNT(_src._w_value) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n 1 AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n COALESCE(_cm_orders___count_window_90d.\"orders.w\", 0) AS \"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders___count_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders___count_window_90d.\"orders.created_at\"", "star_count::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders___count_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n COUNT(_src._w_value) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n 1 AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n COALESCE(_cm_orders___count_window_90d.[orders___w], 0) AS [orders___w]\nFROM _base\nLEFT JOIN _cm_orders___count_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders___count_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders___count_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders___count_window_90d.[orders___created_at] IS NULL\n )\n )", - "stddev_pop::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_stddev_pop_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(STDDEV_POP(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_stddev_pop_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_stddev_pop_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_stddev_pop_window_90d.`orders___created_at`", + "stddev_pop::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_stddev_pop_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(STDDEV_POP(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_stddev_pop_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_stddev_pop_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_stddev_pop_window_90d.`orders___created_at`", "stddev_pop::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_stddev_pop_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(STDDEV_POP(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_stddev_pop_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_stddev_pop_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_stddev_pop_window_90d.\"orders.created_at\"", "stddev_pop::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_stddev_pop_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n CAST(STDDEV_POP(_src._w_value) AS DOUBLE) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _cm_orders__amount_stddev_pop_window_90d.`orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_stddev_pop_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_stddev_pop_window_90d.`orders.created_at`", "stddev_pop::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_stddev_pop_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(STDDEV_POP(_src._w_value) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_stddev_pop_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_stddev_pop_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_stddev_pop_window_90d.\"orders.created_at\"", "stddev_pop::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_stddev_pop_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(STDDEV_POP(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_stddev_pop_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_stddev_pop_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_stddev_pop_window_90d.\"orders.created_at\"", "stddev_pop::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_stddev_pop_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(STDDEV_POP(_src._w_value) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_stddev_pop_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_stddev_pop_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_stddev_pop_window_90d.\"orders.created_at\"", "stddev_pop::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_stddev_pop_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n CAST(STDEVP(_src._w_value) AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _cm_orders__amount_stddev_pop_window_90d.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_stddev_pop_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_stddev_pop_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_stddev_pop_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_stddev_pop_window_90d.[orders___created_at] IS NULL\n )\n )", - "stddev_samp::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_stddev_samp_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(STDDEV_SAMP(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_stddev_samp_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_stddev_samp_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_stddev_samp_window_90d.`orders___created_at`", + "stddev_samp::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_stddev_samp_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(STDDEV_SAMP(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_stddev_samp_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_stddev_samp_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_stddev_samp_window_90d.`orders___created_at`", "stddev_samp::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_stddev_samp_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(STDDEV_SAMP(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_stddev_samp_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_stddev_samp_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_stddev_samp_window_90d.\"orders.created_at\"", "stddev_samp::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_stddev_samp_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n CAST(STDDEV_SAMP(_src._w_value) AS DOUBLE) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _cm_orders__amount_stddev_samp_window_90d.`orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_stddev_samp_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_stddev_samp_window_90d.`orders.created_at`", "stddev_samp::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_stddev_samp_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(STDDEV_SAMP(_src._w_value) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_stddev_samp_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_stddev_samp_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_stddev_samp_window_90d.\"orders.created_at\"", "stddev_samp::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_stddev_samp_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(STDDEV(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_stddev_samp_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_stddev_samp_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_stddev_samp_window_90d.\"orders.created_at\"", "stddev_samp::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_stddev_samp_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(STDDEV_SAMP(_src._w_value) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_stddev_samp_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_stddev_samp_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_stddev_samp_window_90d.\"orders.created_at\"", "stddev_samp::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_stddev_samp_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n CAST(STDEV(_src._w_value) AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _cm_orders__amount_stddev_samp_window_90d.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_stddev_samp_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_stddev_samp_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_stddev_samp_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_stddev_samp_window_90d.[orders___created_at] IS NULL\n )\n )", - "var_pop::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_var_pop_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(VAR_POP(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_var_pop_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_var_pop_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_var_pop_window_90d.`orders___created_at`", + "var_pop::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_var_pop_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(VAR_POP(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_var_pop_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_var_pop_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_var_pop_window_90d.`orders___created_at`", "var_pop::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_var_pop_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(VAR_POP(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_var_pop_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_var_pop_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_var_pop_window_90d.\"orders.created_at\"", "var_pop::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_var_pop_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n CAST(VAR_POP(_src._w_value) AS DOUBLE) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _cm_orders__amount_var_pop_window_90d.`orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_var_pop_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_var_pop_window_90d.`orders.created_at`", "var_pop::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_var_pop_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(VAR_POP(_src._w_value) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_var_pop_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_var_pop_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_var_pop_window_90d.\"orders.created_at\"", "var_pop::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_var_pop_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(VARIANCE_POP(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_var_pop_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_var_pop_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_var_pop_window_90d.\"orders.created_at\"", "var_pop::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_var_pop_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(VARIANCE_POP(_src._w_value) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_var_pop_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_var_pop_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_var_pop_window_90d.\"orders.created_at\"", "var_pop::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_var_pop_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n CAST(VARP(_src._w_value) AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _cm_orders__amount_var_pop_window_90d.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_var_pop_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_var_pop_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_var_pop_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_var_pop_window_90d.[orders___created_at] IS NULL\n )\n )", - "var_samp::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_var_samp_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(VAR_SAMP(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_var_samp_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_var_samp_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_var_samp_window_90d.`orders___created_at`", + "var_samp::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_var_samp_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(VAR_SAMP(_src._w_value) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_var_samp_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_var_samp_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_var_samp_window_90d.`orders___created_at`", "var_samp::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_var_samp_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(VARIANCE(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_var_samp_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_var_samp_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_var_samp_window_90d.\"orders.created_at\"", "var_samp::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_var_samp_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n CAST(VAR_SAMP(_src._w_value) AS DOUBLE) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _cm_orders__amount_var_samp_window_90d.`orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_var_samp_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_var_samp_window_90d.`orders.created_at`", "var_samp::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_var_samp_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(VAR_SAMP(_src._w_value) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_var_samp_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_var_samp_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_var_samp_window_90d.\"orders.created_at\"", "var_samp::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_var_samp_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(VARIANCE(_src._w_value) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_var_samp_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_var_samp_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_var_samp_window_90d.\"orders.created_at\"", "var_samp::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_var_samp_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(VARIANCE(_src._w_value) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_var_samp_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_var_samp_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_var_samp_window_90d.\"orders.created_at\"", "var_samp::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_var_samp_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n CAST(VAR(_src._w_value) AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _cm_orders__amount_var_samp_window_90d.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_var_samp_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_var_samp_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_var_samp_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_var_samp_window_90d.[orders___created_at] IS NULL\n )\n )", - "weighted_avg::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_weighted_avg_weight_qty_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_weighted_avg_weight_qty_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_weighted_avg_weight_qty_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_weighted_avg_weight_qty_window_90d.`orders___created_at`", + "weighted_avg::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_orders__amount_weighted_avg_weight_qty_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_weighted_avg_weight_qty_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_weighted_avg_weight_qty_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_weighted_avg_weight_qty_window_90d.`orders___created_at`", "weighted_avg::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_weighted_avg_weight_qty_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_weighted_avg_weight_qty_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_weighted_avg_weight_qty_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_weighted_avg_weight_qty_window_90d.\"orders.created_at\"", "weighted_avg::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_orders__amount_weighted_avg_weight_qty_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS DOUBLE) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _cm_orders__amount_weighted_avg_weight_qty_window_90d.`orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_weighted_avg_weight_qty_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_weighted_avg_weight_qty_window_90d.`orders.created_at`", "weighted_avg::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_weighted_avg_weight_qty_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN _src._w_value IS NOT NULL THEN _src._w_p0 END), 0) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_weighted_avg_weight_qty_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_weighted_avg_weight_qty_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_weighted_avg_weight_qty_window_90d.\"orders.created_at\"", "weighted_avg::snowflake": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_orders__amount_weighted_avg_weight_qty_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.\"orders.created_at\"))\n AND _src._w_time < DATEADD(MONTH, 1, _base.\"orders.created_at\")\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_weighted_avg_weight_qty_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_weighted_avg_weight_qty_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_weighted_avg_weight_qty_window_90d.\"orders.created_at\"", "weighted_avg::sqlite": "WITH _base AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n), _cm_orders__amount_weighted_avg_weight_qty_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS REAL) AS \"orders.w\"\n FROM (\n SELECT\n STRFTIME('%Y-%m-01', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n STRFTIME('%Y-%m-01', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"orders.created_at\", 1, 'month')\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_weighted_avg_weight_qty_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_weighted_avg_weight_qty_window_90d\n ON _base.\"orders.created_at\" IS _cm_orders__amount_weighted_avg_weight_qty_window_90d.\"orders.created_at\"", "weighted_avg::tsql": "WITH _base AS (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n), _cm_orders__amount_weighted_avg_weight_qty_window_90d AS (\n SELECT\n _base.[orders___created_at] AS [orders___created_at],\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS FLOAT) AS [orders___w]\n FROM (\n SELECT\n DATETRUNC(month, orders.created_at) AS [orders___created_at]\n FROM orders AS orders\n GROUP BY\n DATETRUNC(month, orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n orders.qty AS _w_p0\n FROM orders AS orders\n ) AS _src\n ON _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[orders___created_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[orders___created_at])\n GROUP BY\n _base.[orders___created_at]\n)\nSELECT\n _base.[orders___created_at],\n _cm_orders__amount_weighted_avg_weight_qty_window_90d.[orders___w]\nFROM _base\nLEFT JOIN _cm_orders__amount_weighted_avg_weight_qty_window_90d\n ON (\n (\n _base.[orders___created_at] = _cm_orders__amount_weighted_avg_weight_qty_window_90d.[orders___created_at]\n AND NOT _base.[orders___created_at] IS NULL\n AND NOT _cm_orders__amount_weighted_avg_weight_qty_window_90d.[orders___created_at] IS NULL\n )\n OR (\n _base.[orders___created_at] IS NULL\n AND _cm_orders__amount_weighted_avg_weight_qty_window_90d.[orders___created_at] IS NULL\n )\n )", - "weighted_avg_attached_weight::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_qty_sum_partition_by_region AS (\n SELECT\n _stage_inner.`orders___region` AS `region`,\n _stage_inner.`orders___qty_sum_partition_by_region` AS `qty_sum_partition_by_region`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n CAST(SUM(orders.qty) AS FLOAT64) AS `orders___qty_sum_partition_by_region`\n FROM orders AS orders\n GROUP BY\n orders.region\n ) AS _stage_inner\n), _cm_orders__amount_weighted_avg_weight_sum_qty_by_region_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n LEFT JOIN _cm_qty_sum_partition_by_region\n ON orders.region IS NOT DISTINCT FROM _cm_qty_sum_partition_by_region.`region`\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n _cm_qty_sum_partition_by_region.`qty_sum_partition_by_region` AS _w_p0\n FROM orders AS orders\n LEFT JOIN _cm_qty_sum_partition_by_region\n ON orders.region IS NOT DISTINCT FROM _cm_qty_sum_partition_by_region.`region`\n ) AS _src\n ON _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_weighted_avg_weight_sum_qty_by_region_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_weighted_avg_weight_sum_qty_by_region_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_weighted_avg_weight_sum_qty_by_region_window_90d.`orders___created_at`", + "weighted_avg_attached_weight::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n), _cm_qty_sum_partition_by_region AS (\n SELECT\n _stage_inner.`orders___region` AS `region`,\n _stage_inner.`orders___qty_sum_partition_by_region` AS `qty_sum_partition_by_region`\n FROM (\n SELECT\n orders.region AS `orders___region`,\n CAST(SUM(orders.qty) AS FLOAT64) AS `orders___qty_sum_partition_by_region`\n FROM orders AS orders\n GROUP BY\n orders.region\n ) AS _stage_inner\n), _cm_orders__amount_weighted_avg_weight_sum_qty_by_region_window_90d AS (\n SELECT\n _base.`orders___created_at`,\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS FLOAT64) AS `orders___w`\n FROM (\n SELECT\n DATE_TRUNC(orders.created_at, MONTH) AS `orders___created_at`\n FROM orders AS orders\n LEFT JOIN _cm_qty_sum_partition_by_region\n ON orders.region IS NOT DISTINCT FROM _cm_qty_sum_partition_by_region.`region`\n GROUP BY\n DATE_TRUNC(orders.created_at, MONTH)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n _cm_qty_sum_partition_by_region.`qty_sum_partition_by_region` AS _w_p0\n FROM orders AS orders\n LEFT JOIN _cm_qty_sum_partition_by_region\n ON orders.region IS NOT DISTINCT FROM _cm_qty_sum_partition_by_region.`region`\n ) AS _src\n ON _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`orders___created_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders___created_at`\n)\nSELECT\n _base.`orders___created_at`,\n _cm_orders__amount_weighted_avg_weight_sum_qty_by_region_window_90d.`orders___w`\nFROM _base\nLEFT JOIN _cm_orders__amount_weighted_avg_weight_sum_qty_by_region_window_90d\n ON _base.`orders___created_at` IS NOT DISTINCT FROM _cm_orders__amount_weighted_avg_weight_sum_qty_by_region_window_90d.`orders___created_at`", "weighted_avg_attached_weight::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_qty_sum_partition_by_region AS (\n SELECT\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.qty_sum_partition_by_region\" AS \"qty_sum_partition_by_region\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n CAST(SUM(orders.qty) AS DOUBLE) AS \"orders.qty_sum_partition_by_region\"\n FROM orders AS orders\n GROUP BY\n orders.region\n ) AS _stage_inner\n), _cm_orders__amount_weighted_avg_weight_sum_qty_by_region_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS DOUBLE) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n LEFT JOIN _cm_qty_sum_partition_by_region\n ON orders.region IS NOT DISTINCT FROM _cm_qty_sum_partition_by_region.\"region\"\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n _cm_qty_sum_partition_by_region.\"qty_sum_partition_by_region\" AS _w_p0\n FROM orders AS orders\n LEFT JOIN _cm_qty_sum_partition_by_region\n ON orders.region IS NOT DISTINCT FROM _cm_qty_sum_partition_by_region.\"region\"\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_weighted_avg_weight_sum_qty_by_region_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_weighted_avg_weight_sum_qty_by_region_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_weighted_avg_weight_sum_qty_by_region_window_90d.\"orders.created_at\"", "weighted_avg_attached_weight::mysql": "WITH _base AS (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n), _cm_qty_sum_partition_by_region AS (\n SELECT\n _stage_inner.`orders.region` AS `region`,\n _stage_inner.`orders.qty_sum_partition_by_region` AS `qty_sum_partition_by_region`\n FROM (\n SELECT\n orders.region AS `orders.region`,\n CAST(SUM(orders.qty) AS DOUBLE) AS `orders.qty_sum_partition_by_region`\n FROM orders AS orders\n GROUP BY\n orders.region\n ) AS _stage_inner\n), _cm_orders__amount_weighted_ef9f13c3_um_qty_by_region_window_90d AS (\n SELECT\n _base.`orders.created_at`,\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN NOT _src._w_value IS NULL THEN _src._w_p0 END), 0) AS DOUBLE) AS `orders.w`\n FROM (\n SELECT\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e') AS `orders.created_at`\n FROM orders AS orders\n LEFT JOIN _cm_qty_sum_partition_by_region\n ON orders.region <=> _cm_qty_sum_partition_by_region.`region`\n GROUP BY\n STR_TO_DATE(CONCAT(YEAR(orders.created_at), ' ', MONTH(orders.created_at), ' 1'), '%Y %c %e')\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n _cm_qty_sum_partition_by_region.`qty_sum_partition_by_region` AS _w_p0\n FROM orders AS orders\n LEFT JOIN _cm_qty_sum_partition_by_region\n ON orders.region <=> _cm_qty_sum_partition_by_region.`region`\n ) AS _src\n ON _src._w_time >= DATE_ADD(DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH), INTERVAL -90 DAY)\n AND _src._w_time < DATE_ADD(_base.`orders.created_at`, INTERVAL 1 MONTH)\n GROUP BY\n _base.`orders.created_at`\n)\nSELECT\n _base.`orders.created_at`,\n _cm_orders__amount_weighted_ef9f13c3_um_qty_by_region_window_90d.`orders.w`\nFROM _base\nLEFT JOIN _cm_orders__amount_weighted_ef9f13c3_um_qty_by_region_window_90d\n ON _base.`orders.created_at` <=> _cm_orders__amount_weighted_ef9f13c3_um_qty_by_region_window_90d.`orders.created_at`", "weighted_avg_attached_weight::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n), _cm_qty_sum_partition_by_region AS (\n SELECT\n _stage_inner.\"orders.region\" AS \"region\",\n _stage_inner.\"orders.qty_sum_partition_by_region\" AS \"qty_sum_partition_by_region\"\n FROM (\n SELECT\n orders.region AS \"orders.region\",\n CAST(SUM(orders.qty) AS DOUBLE PRECISION) AS \"orders.qty_sum_partition_by_region\"\n FROM orders AS orders\n GROUP BY\n orders.region\n ) AS _stage_inner\n), _cm_orders__amount_weighted_ef9f13c3_m_qty_by_region_window_90d AS (\n SELECT\n _base.\"orders.created_at\",\n CAST(SUM(_src._w_value * _src._w_p0) * 1.0 / NULLIF(SUM(CASE WHEN _src._w_value IS NOT NULL THEN _src._w_p0 END), 0) AS DOUBLE PRECISION) AS \"orders.w\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', orders.created_at) AS \"orders.created_at\"\n FROM orders AS orders\n LEFT JOIN _cm_qty_sum_partition_by_region\n ON orders.region IS NOT DISTINCT FROM _cm_qty_sum_partition_by_region.\"region\"\n GROUP BY\n DATE_TRUNC('MONTH', orders.created_at)\n ) AS _base\n LEFT JOIN (\n SELECT\n orders.created_at AS _w_time,\n orders.amount AS _w_value,\n _cm_qty_sum_partition_by_region.\"qty_sum_partition_by_region\" AS _w_p0\n FROM orders AS orders\n LEFT JOIN _cm_qty_sum_partition_by_region\n ON orders.region IS NOT DISTINCT FROM _cm_qty_sum_partition_by_region.\"region\"\n ) AS _src\n ON _src._w_time >= _base.\"orders.created_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"orders.created_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"orders.created_at\"\n)\nSELECT\n _base.\"orders.created_at\",\n _cm_orders__amount_weighted_ef9f13c3_m_qty_by_region_window_90d.\"orders.w\"\nFROM _base\nLEFT JOIN _cm_orders__amount_weighted_ef9f13c3_m_qty_by_region_window_90d\n ON _base.\"orders.created_at\" IS NOT DISTINCT FROM _cm_orders__amount_weighted_ef9f13c3_m_qty_by_region_window_90d.\"orders.created_at\"", diff --git a/tests/golden/dev1934_dialect_hooks.json b/tests/golden/dev1934_dialect_hooks.json index 36ea596e4..520dbf840 100644 --- a/tests/golden/dev1934_dialect_hooks.json +++ b/tests/golden/dev1934_dialect_hooks.json @@ -4,16 +4,16 @@ "bigquery|covar_pop": "COVAR_POP(orders.amount, orders.quantity)", "bigquery|covar_samp": "COVAR_SAMP(orders.amount, orders.quantity)", "bigquery|median": "PERCENTILE_CONT(0.5) WITHIN GROUP (ORDER BY orders.amount)", - "bigquery|offset|day|-1": "TIMESTAMP_ADD(orders.created_at, INTERVAL -1 DAY)", - "bigquery|offset|day|2": "TIMESTAMP_ADD(orders.created_at, INTERVAL 2 DAY)", - "bigquery|offset|month|-1": "CAST(DATETIME_ADD(CAST(orders.created_at AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)", - "bigquery|offset|month|2": "CAST(DATETIME_ADD(CAST(orders.created_at AS DATETIME), INTERVAL 2 MONTH) AS TIMESTAMP)", - "bigquery|offset|quarter|-1": "CAST(DATETIME_ADD(CAST(orders.created_at AS DATETIME), INTERVAL -1 QUARTER) AS TIMESTAMP)", - "bigquery|offset|quarter|2": "CAST(DATETIME_ADD(CAST(orders.created_at AS DATETIME), INTERVAL 2 QUARTER) AS TIMESTAMP)", - "bigquery|offset|week_sunday|-1": "TIMESTAMP_ADD(orders.created_at, INTERVAL ((-1) * 7) DAY)", - "bigquery|offset|week_sunday|2": "TIMESTAMP_ADD(orders.created_at, INTERVAL ((2) * 7) DAY)", - "bigquery|offset|week|-1": "TIMESTAMP_ADD(orders.created_at, INTERVAL ((-1) * 7) DAY)", - "bigquery|offset|week|2": "TIMESTAMP_ADD(orders.created_at, INTERVAL ((2) * 7) DAY)", + "bigquery|offset|day|-1": "DATETIME_ADD(CAST(orders.created_at AS DATETIME), INTERVAL -1 DAY)", + "bigquery|offset|day|2": "DATETIME_ADD(CAST(orders.created_at AS DATETIME), INTERVAL 2 DAY)", + "bigquery|offset|month|-1": "DATETIME_ADD(CAST(orders.created_at AS DATETIME), INTERVAL -1 MONTH)", + "bigquery|offset|month|2": "DATETIME_ADD(CAST(orders.created_at AS DATETIME), INTERVAL 2 MONTH)", + "bigquery|offset|quarter|-1": "DATETIME_ADD(CAST(orders.created_at AS DATETIME), INTERVAL -1 QUARTER)", + "bigquery|offset|quarter|2": "DATETIME_ADD(CAST(orders.created_at AS DATETIME), INTERVAL 2 QUARTER)", + "bigquery|offset|week_sunday|-1": "DATETIME_ADD(CAST(orders.created_at AS DATETIME), INTERVAL ((-1) * 7) DAY)", + "bigquery|offset|week_sunday|2": "DATETIME_ADD(CAST(orders.created_at AS DATETIME), INTERVAL ((2) * 7) DAY)", + "bigquery|offset|week|-1": "DATETIME_ADD(CAST(orders.created_at AS DATETIME), INTERVAL ((-1) * 7) DAY)", + "bigquery|offset|week|2": "DATETIME_ADD(CAST(orders.created_at AS DATETIME), INTERVAL ((2) * 7) DAY)", "bigquery|percentile": "PERCENTILE_CONT(0.50) WITHIN GROUP (ORDER BY orders.amount)", "bigquery|stddev_pop": "STDDEV_POP(orders.amount)", "bigquery|stddev_samp": "STDDEV_SAMP(orders.amount)", diff --git a/tests/golden/dev1958_sql_baseline.json b/tests/golden/dev1958_sql_baseline.json index 3aac177a6..896b0d97f 100644 --- a/tests/golden/dev1958_sql_baseline.json +++ b/tests/golden/dev1958_sql_baseline.json @@ -1,90 +1,90 @@ { - "frame/bare_partitioned::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 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_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 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 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 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), 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___amount_sum_partition_by_ordered_at` 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", + "frame/bare_partitioned::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 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_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 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 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 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), 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___amount_sum_partition_by_ordered_at` AS `monthly___t`\n FROM base\n LEFT JOIN shifted_t\n ON DATETIME_ADD(CAST(base.`monthly___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS DATETIME)\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", "frame/bare_partitioned::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 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_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 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 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) AS \"monthly.amount_sum_partition_by_ordered_at\"\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.amount_sum_partition_by_ordered_at\" 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", "frame/bare_partitioned::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 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_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.ordered_at < CAST('2024-04-01 00:00:00' AS TIMESTAMP)\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 _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) AS \"monthly.amount_sum_partition_by_ordered_at\"\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.amount_sum_partition_by_ordered_at\" 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", "frame/bare_partitioned::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 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_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.ordered_at < '2024-04-01'\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 _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), shifted_t 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), 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.amount_sum_partition_by_ordered_at\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON 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_partition_by_ordered_at\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "frame/bare_partitioned::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 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_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.ordered_at < CAST('2024-04-01 00:00:00' AS DATETIME2)\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 _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 (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n AND NOT _base.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\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), shifted_t 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), 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_partition_by_ordered_at] AS [monthly___amount_sum_partition_by_ordered_at],\n shifted_t.[monthly___amount_sum_partition_by_ordered_at] AS [monthly___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND NOT shifted_t.[monthly___ordered_at] IS NULL\n )\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_partition_by_ordered_at],\n [monthly___t]\n FROM sjoin_t\n) AS _outer", - "frame/bare_ranked::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 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_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 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 ) 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), shifted_t AS (\n SELECT\n _val_4 AS `monthly___ordered_at`,\n _val_3 AS `monthly___region`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_5 END) AS FLOAT64) AS `monthly___amount_last`\n FROM (\n SELECT\n monthly.region AS _val_3,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS _val_4,\n monthly.amount AS _val_5,\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_4,\n _val_3\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_last`,\n shifted_t.`monthly___amount_last` 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", + "frame/bare_ranked::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 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_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 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 ) 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), shifted_t AS (\n SELECT\n _val_4 AS `monthly___ordered_at`,\n _val_3 AS `monthly___region`,\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_5 END) AS FLOAT64) AS `monthly___amount_last`\n FROM (\n SELECT\n monthly.region AS _val_3,\n DATE_TRUNC(monthly.ordered_at, MONTH) AS _val_4,\n monthly.amount AS _val_5,\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_4,\n _val_3\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_last`,\n shifted_t.`monthly___amount_last` 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 DATETIME_ADD(CAST(base.`monthly___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS DATETIME)\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", "frame/bare_ranked::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 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_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 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 ) 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), shifted_t AS (\n SELECT\n _val_4 AS \"monthly.ordered_at\",\n _val_3 AS \"monthly.region\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_5 END) AS DOUBLE) AS \"monthly.amount_last\"\n FROM (\n SELECT\n monthly.region AS _val_3,\n DATE_TRUNC('MONTH', monthly.ordered_at) AS _val_4,\n monthly.amount AS _val_5,\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_4,\n _val_3\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_last\",\n shifted_t.\"monthly.amount_last\" 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", "frame/bare_ranked::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 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_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 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 ) 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), shifted_t AS (\n SELECT\n _val_4 AS \"monthly.ordered_at\",\n _val_3 AS \"monthly.region\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_5 END) AS DOUBLE PRECISION) AS \"monthly.amount_last\"\n FROM (\n SELECT\n monthly.region AS _val_3,\n DATE_TRUNC('MONTH', monthly.ordered_at) AS _val_4,\n monthly.amount AS _val_5,\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_4,\n _val_3\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_last\",\n shifted_t.\"monthly.amount_last\" 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", "frame/bare_ranked::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 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_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 WHERE\n (\n monthly.ordered_at >= '2024-02-01' AND monthly.ordered_at < '2024-04-01'\n )\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), shifted_t AS (\n SELECT\n _val_4 AS \"monthly.ordered_at\",\n _val_3 AS \"monthly.region\",\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_5 END) AS REAL) AS \"monthly.amount_last\"\n FROM (\n SELECT\n monthly.region AS _val_3,\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS _val_4,\n monthly.amount AS _val_5,\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_4,\n _val_3\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_last\",\n shifted_t.\"monthly.amount_last\" 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", "frame/bare_ranked::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 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_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 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 ) 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 (\n _base.[monthly___region] = _cm_monthly__amount_last.[monthly___region]\n AND NOT _base.[monthly___region] IS NULL\n AND NOT _cm_monthly__amount_last.[monthly___region] IS NULL\n )\n OR (\n _base.[monthly___region] IS NULL\n AND _cm_monthly__amount_last.[monthly___region] IS NULL\n )\n )\n AND (\n (\n _base.[monthly___ordered_at] = _cm_monthly__amount_last.[monthly___ordered_at]\n AND NOT _base.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_last.[monthly___ordered_at] IS NULL\n )\n OR (\n _base.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_last.[monthly___ordered_at] IS NULL\n )\n )\n), shifted_t AS (\n SELECT\n _val_4 AS [monthly___ordered_at],\n _val_3 AS [monthly___region],\n CAST(MAX(CASE WHEN _ranked_rn = 1 THEN _val_5 END) AS FLOAT) AS [monthly___amount_last]\n FROM (\n SELECT\n monthly.region AS _val_3,\n DATETRUNC(month, monthly.ordered_at) AS _val_4,\n monthly.amount AS _val_5,\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_4,\n _val_3\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___amount_last] AS [monthly___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n (\n base.[monthly___region] = shifted_t.[monthly___region]\n AND NOT base.[monthly___region] IS NULL\n AND NOT shifted_t.[monthly___region] IS NULL\n )\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND NOT shifted_t.[monthly___ordered_at] IS NULL\n )\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", - "frame/bare_windowed::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 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_window_90d AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `monthly___amount_sum_window_90d`\n FROM (\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 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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`monthly___region`\n AND _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`monthly___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`monthly___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`monthly___region`,\n _base.`monthly___ordered_at`\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _cm_monthly__amount_sum_window_90d.`monthly___amount_sum_window_90d` AS `monthly___amount_sum_window_90d`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON _base.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.`monthly___region`\n AND _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.`monthly___ordered_at`\n), shifted_t AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `monthly___amount_sum_window_90d`\n FROM (\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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`monthly___region`\n AND _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`monthly___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`monthly___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`monthly___region`,\n _base.`monthly___ordered_at`\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum_window_90d`,\n shifted_t.`monthly___amount_sum_window_90d` 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_window_90d`,\n `monthly___t`\n FROM sjoin_t\n) AS _outer", + "frame/bare_windowed::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 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_window_90d AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `monthly___amount_sum_window_90d`\n FROM (\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 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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`monthly___region`\n AND _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`monthly___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`monthly___ordered_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`monthly___region`,\n _base.`monthly___ordered_at`\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _cm_monthly__amount_sum_window_90d.`monthly___amount_sum_window_90d` AS `monthly___amount_sum_window_90d`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON _base.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.`monthly___region`\n AND _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.`monthly___ordered_at`\n), shifted_t AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `monthly___amount_sum_window_90d`\n FROM (\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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`monthly___region`\n AND _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`monthly___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`monthly___ordered_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`monthly___region`,\n _base.`monthly___ordered_at`\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum_window_90d`,\n shifted_t.`monthly___amount_sum_window_90d` 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 DATETIME_ADD(CAST(base.`monthly___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS DATETIME)\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_window_90d`,\n `monthly___t`\n FROM sjoin_t\n) AS _outer", "frame/bare_windowed::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 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_window_90d AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"monthly.amount_sum_window_90d\"\n FROM (\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 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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"monthly.region\"\n AND _src._w_time >= _base.\"monthly.ordered_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"monthly.ordered_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\"\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _cm_monthly__amount_sum_window_90d.\"monthly.amount_sum_window_90d\" AS \"monthly.amount_sum_window_90d\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.\"monthly.region\"\n AND _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.\"monthly.ordered_at\"\n), shifted_t AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"monthly.amount_sum_window_90d\"\n FROM (\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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"monthly.region\"\n AND _src._w_time >= _base.\"monthly.ordered_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"monthly.ordered_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum_window_90d\",\n shifted_t.\"monthly.amount_sum_window_90d\" 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_window_90d\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "frame/bare_windowed::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 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_window_90d AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE PRECISION) AS \"monthly.amount_sum_window_90d\"\n FROM (\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 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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"monthly.region\"\n AND _src._w_time >= _base.\"monthly.ordered_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"monthly.ordered_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\"\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _cm_monthly__amount_sum_window_90d.\"monthly.amount_sum_window_90d\" AS \"monthly.amount_sum_window_90d\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.\"monthly.region\"\n AND _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.\"monthly.ordered_at\"\n), shifted_t AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE PRECISION) AS \"monthly.amount_sum_window_90d\"\n FROM (\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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"monthly.region\"\n AND _src._w_time >= _base.\"monthly.ordered_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"monthly.ordered_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum_window_90d\",\n shifted_t.\"monthly.amount_sum_window_90d\" 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_window_90d\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "frame/bare_windowed::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 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_window_90d AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n CAST(SUM(_src._w_value) AS REAL) AS \"monthly.amount_sum_window_90d\"\n FROM (\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 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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS _base.\"monthly.region\"\n AND DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"monthly.ordered_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"monthly.ordered_at\", 1, 'month')\n GROUP BY\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\"\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _cm_monthly__amount_sum_window_90d.\"monthly.amount_sum_window_90d\" AS \"monthly.amount_sum_window_90d\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON _base.\"monthly.region\" IS _cm_monthly__amount_sum_window_90d.\"monthly.region\"\n AND _base.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_window_90d.\"monthly.ordered_at\"\n), shifted_t AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n CAST(SUM(_src._w_value) AS REAL) AS \"monthly.amount_sum_window_90d\"\n FROM (\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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS _base.\"monthly.region\"\n AND DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"monthly.ordered_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"monthly.ordered_at\", 1, 'month')\n GROUP BY\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum_window_90d\",\n shifted_t.\"monthly.amount_sum_window_90d\" 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_window_90d\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "frame/bare_windowed::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 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_window_90d AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(SUM(_src._w_value) AS FLOAT) AS [monthly___amount_sum_window_90d]\n FROM (\n SELECT\n monthly.region AS [monthly___region],\n DATETRUNC(month, monthly.ordered_at) AS [monthly___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.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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON (\n (\n _src._w_dim_0 = _base.[monthly___region]\n AND NOT _src._w_dim_0 IS NULL\n AND NOT _base.[monthly___region] IS NULL\n )\n OR (\n _src._w_dim_0 IS NULL AND _base.[monthly___region] IS NULL\n )\n )\n AND _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[monthly___ordered_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[monthly___ordered_at])\n GROUP BY\n _base.[monthly___region],\n _base.[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 _cm_monthly__amount_sum_window_90d.[monthly___amount_sum_window_90d] AS [monthly___amount_sum_window_90d]\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON (\n (\n _base.[monthly___region] = _cm_monthly__amount_sum_window_90d.[monthly___region]\n AND NOT _base.[monthly___region] IS NULL\n AND NOT _cm_monthly__amount_sum_window_90d.[monthly___region] IS NULL\n )\n OR (\n _base.[monthly___region] IS NULL\n AND _cm_monthly__amount_sum_window_90d.[monthly___region] IS NULL\n )\n )\n AND (\n (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_window_90d.[monthly___ordered_at]\n AND NOT _base.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_sum_window_90d.[monthly___ordered_at] IS NULL\n )\n OR (\n _base.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_window_90d.[monthly___ordered_at] IS NULL\n )\n )\n), shifted_t AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(SUM(_src._w_value) AS FLOAT) AS [monthly___amount_sum_window_90d]\n FROM (\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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON (\n (\n _src._w_dim_0 = _base.[monthly___region]\n AND NOT _src._w_dim_0 IS NULL\n AND NOT _base.[monthly___region] IS NULL\n )\n OR (\n _src._w_dim_0 IS NULL AND _base.[monthly___region] IS NULL\n )\n )\n AND _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[monthly___ordered_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[monthly___ordered_at])\n GROUP BY\n _base.[monthly___region],\n _base.[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_window_90d] AS [monthly___amount_sum_window_90d],\n shifted_t.[monthly___amount_sum_window_90d] AS [monthly___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n (\n base.[monthly___region] = shifted_t.[monthly___region]\n AND NOT base.[monthly___region] IS NULL\n AND NOT shifted_t.[monthly___region] IS NULL\n )\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND NOT shifted_t.[monthly___ordered_at] IS NULL\n )\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_window_90d],\n [monthly___t]\n FROM sjoin_t\n) AS _outer", - "frame/mixed_conjunction::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' AND monthly.region = 'North'\n )\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 WHERE\n (\n monthly.ordered_at >= '2024-02-01 00:00:00' AND monthly.region = 'North'\n )\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 WHERE\n monthly.region = 'North'\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_ordered_at_2 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 WHERE\n monthly.region = 'North'\n GROUP BY\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_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 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", + "frame/mixed_conjunction::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' AND monthly.region = 'North'\n )\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 WHERE\n (\n monthly.ordered_at >= '2024-02-01 00:00:00' AND monthly.region = 'North'\n )\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 WHERE\n monthly.region = 'North'\n GROUP BY\n monthly.region,\n DATE_TRUNC(monthly.ordered_at, MONTH)\n), _cm_monthly__amount_sum_partition_by_ordered_at_2 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 WHERE\n monthly.region = 'North'\n GROUP BY\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_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 DATETIME_ADD(CAST(base.`monthly___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS DATETIME)\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::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.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) 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) 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::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 (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n AND NOT _base.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\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 (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at_2.[monthly___ordered_at]\n AND NOT _base_2.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_ordered_at_2.[monthly___ordered_at] IS NULL\n )\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 (\n base.[monthly___region] = shifted_t.[monthly___region]\n AND NOT base.[monthly___region] IS NULL\n AND NOT shifted_t.[monthly___region] IS NULL\n )\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND NOT shifted_t.[monthly___ordered_at] IS NULL\n )\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` / 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::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 DATETIME_ADD(CAST(base.`monthly___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS DATETIME)\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 (\n _base.[monthly___region] = _cm_monthly__amount_sum_partition_by_region.[monthly___region]\n AND NOT _base.[monthly___region] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_region.[monthly___region] IS NULL\n )\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 (\n _base_2.[monthly___region] = _cm_monthly__amount_sum_partition_by_region.[monthly___region]\n AND NOT _base_2.[monthly___region] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_region.[monthly___region] IS NULL\n )\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 (\n base.[monthly___region] = shifted_t.[monthly___region]\n AND NOT base.[monthly___region] IS NULL\n AND NOT shifted_t.[monthly___region] IS NULL\n )\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND NOT shifted_t.[monthly___ordered_at] IS NULL\n )\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::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 DATETIME_ADD(CAST(base.`monthly___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t1.`monthly___ordered_at` AS DATETIME)\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 DATETIME_ADD(CAST(sjoin_t1.`monthly___ordered_at` AS DATETIME), INTERVAL -2 MONTH) IS NOT DISTINCT FROM CAST(shifted_t1.`monthly___ordered_at` AS DATETIME)\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 (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n AND NOT _base.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\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 (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n AND NOT _base_2.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\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 (\n base.[monthly___region] = shifted_t1.[monthly___region]\n AND NOT base.[monthly___region] IS NULL\n AND NOT shifted_t1.[monthly___region] IS NULL\n )\n OR (\n base.[monthly___region] IS NULL AND shifted_t1.[monthly___region] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t1.[monthly___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND NOT shifted_t1.[monthly___ordered_at] IS NULL\n )\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 (\n sjoin_t1.[monthly___region] = shifted_t1.[monthly___region]\n AND NOT sjoin_t1.[monthly___region] IS NULL\n AND NOT shifted_t1.[monthly___region] IS NULL\n )\n OR (\n sjoin_t1.[monthly___region] IS NULL AND shifted_t1.[monthly___region] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -2, sjoin_t1.[monthly___ordered_at]) = shifted_t1.[monthly___ordered_at]\n AND NOT DATEADD(MONTH, -2, sjoin_t1.[monthly___ordered_at]) IS NULL\n AND NOT shifted_t1.[monthly___ordered_at] IS NULL\n )\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::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(DATETIME_ADD(CAST(base.`monthly___ordered_at` AS DATETIME), INTERVAL -1 DAY) AS DATETIME),\n MONTH\n ) AS DATETIME) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS DATETIME)\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 (\n base.[monthly___region] = shifted_t.[monthly___region]\n AND NOT base.[monthly___region] IS NULL\n AND NOT shifted_t.[monthly___region] IS NULL\n )\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n (\n DATETRUNC(month, CAST(DATEADD(DAY, -1, base.[monthly___ordered_at]) AS DATETIME2)) = shifted_t.[monthly___ordered_at]\n AND NOT DATETRUNC(month, CAST(DATEADD(DAY, -1, base.[monthly___ordered_at]) AS DATETIME2)) IS NULL\n AND NOT shifted_t.[monthly___ordered_at] IS NULL\n )\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` / 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::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 DATETIME_ADD(CAST(base.`monthly___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS DATETIME)\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 (\n monthly.region = _cm_amount_sum_partition_by_region.[region]\n AND NOT monthly.region IS NULL\n AND NOT _cm_amount_sum_partition_by_region.[region] IS NULL\n )\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 (\n _base.[monthly___region] = _cm_monthly___max_partition_by_region.[monthly___region]\n AND NOT _base.[monthly___region] IS NULL\n AND NOT _cm_monthly___max_partition_by_region.[monthly___region] IS NULL\n )\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 (\n _base_2.[monthly___region] = _cm_monthly___max_partition_by_region.[monthly___region]\n AND NOT _base_2.[monthly___region] IS NULL\n AND NOT _cm_monthly___max_partition_by_region.[monthly___region] IS NULL\n )\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 (\n base.[monthly___region] = shifted_t.[monthly___region]\n AND NOT base.[monthly___region] IS NULL\n AND NOT shifted_t.[monthly___region] IS NULL\n )\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND NOT shifted_t.[monthly___ordered_at] IS NULL\n )\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::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 DATETIME_ADD(CAST(base.`monthly___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`monthly___ordered_at` AS DATETIME)\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 (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n AND NOT _base.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\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 (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n AND NOT _base_2.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\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 (\n base.[monthly___region] = shifted__time_shift_inner.[monthly___region]\n AND NOT base.[monthly___region] IS NULL\n AND NOT shifted__time_shift_inner.[monthly___region] IS NULL\n )\n OR (\n base.[monthly___region] IS NULL\n AND shifted__time_shift_inner.[monthly___region] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted__time_shift_inner.[monthly___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[monthly___ordered_at] IS NULL\n )\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::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 DATETIME_ADD(CAST(base.`monthly___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted__time_shift_inner.`monthly___ordered_at` AS DATETIME)\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 (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n AND NOT _base.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\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 (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n AND NOT _base_2.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\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 (\n base.[monthly___region] = shifted__time_shift_inner.[monthly___region]\n AND NOT base.[monthly___region] IS NULL\n AND NOT shifted__time_shift_inner.[monthly___region] IS NULL\n )\n OR (\n base.[monthly___region] IS NULL\n AND shifted__time_shift_inner.[monthly___region] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted__time_shift_inner.[monthly___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND NOT shifted__time_shift_inner.[monthly___ordered_at] IS NULL\n )\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::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 DATETIME_ADD(CAST(base.`monthly___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS DATETIME)\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 (\n _base.[monthly___region] = _cm_monthly__amount_sum_partition_by_region.[monthly___region]\n AND NOT _base.[monthly___region] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_region.[monthly___region] IS NULL\n )\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 (\n _base_2.[monthly___region] = _cm_monthly__amount_sum_partition_by_region.[monthly___region]\n AND NOT _base_2.[monthly___region] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_region.[monthly___region] IS NULL\n )\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 (\n base.[monthly___region] = shifted_t.[monthly___region]\n AND NOT base.[monthly___region] IS NULL\n AND NOT shifted_t.[monthly___region] IS NULL\n )\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND NOT shifted_t.[monthly___ordered_at] IS NULL\n )\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::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 DATETIME_ADD(CAST(base.`monthly___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS DATETIME)\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 (\n _base.[monthly___region] = _cm_monthly__amount_last.[monthly___region]\n AND NOT _base.[monthly___region] IS NULL\n AND NOT _cm_monthly__amount_last.[monthly___region] IS NULL\n )\n OR (\n _base.[monthly___region] IS NULL\n AND _cm_monthly__amount_last.[monthly___region] IS NULL\n )\n )\n AND (\n (\n _base.[monthly___ordered_at] = _cm_monthly__amount_last.[monthly___ordered_at]\n AND NOT _base.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_last.[monthly___ordered_at] IS NULL\n )\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 (\n _base_2.[monthly___region] = _cm_monthly__amount_last.[monthly___region]\n AND NOT _base_2.[monthly___region] IS NULL\n AND NOT _cm_monthly__amount_last.[monthly___region] IS NULL\n )\n OR (\n _base_2.[monthly___region] IS NULL\n AND _cm_monthly__amount_last.[monthly___region] IS NULL\n )\n )\n AND (\n (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_last.[monthly___ordered_at]\n AND NOT _base_2.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_last.[monthly___ordered_at] IS NULL\n )\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 (\n base.[monthly___region] = shifted_t.[monthly___region]\n AND NOT base.[monthly___region] IS NULL\n AND NOT shifted_t.[monthly___region] IS NULL\n )\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND NOT shifted_t.[monthly___ordered_at] IS NULL\n )\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` / 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::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 DATETIME_ADD(CAST(base_2.`monthly___ordered_at_month` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_time_shift.`monthly___ordered_at_month` AS DATETIME)\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 (\n _base_3.[monthly___ordered_at_month] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at_month]\n AND NOT _base_3.[monthly___ordered_at_month] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at_month] IS NULL\n )\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 (\n _base_2.[monthly___ordered_at_month] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at_month]\n AND NOT _base_2.[monthly___ordered_at_month] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at_month] IS NULL\n )\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 (\n base_2.[monthly___region] = shifted_time_shift.[monthly___region]\n AND NOT base_2.[monthly___region] IS NULL\n AND NOT shifted_time_shift.[monthly___region] IS NULL\n )\n OR (\n base_2.[monthly___region] IS NULL AND shifted_time_shift.[monthly___region] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base_2.[monthly___ordered_at_month]) = shifted_time_shift.[monthly___ordered_at_month]\n AND NOT DATEADD(MONTH, -1, base_2.[monthly___ordered_at_month]) IS NULL\n AND NOT shifted_time_shift.[monthly___ordered_at_month] IS NULL\n )\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 (\n monthly.region = _cm_time_shift.[region]\n AND NOT monthly.region IS NULL\n AND NOT _cm_time_shift.[region] IS NULL\n )\n OR (\n monthly.region IS NULL AND _cm_time_shift.[region] IS NULL\n )\n )\n AND (\n (\n DATETRUNC(month, monthly.ordered_at) = _cm_time_shift.[ordered_at_month]\n AND NOT DATETRUNC(month, monthly.ordered_at) IS NULL\n AND NOT _cm_time_shift.[ordered_at_month] IS NULL\n )\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 (\n _base.[monthly___ordered_at] = _cm_monthly___avg.[monthly___ordered_at_month]\n AND NOT _base.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly___avg.[monthly___ordered_at_month] IS NULL\n )\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::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 DATETIME_ADD(CAST(base.`monthly___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS DATETIME)\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 (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n AND NOT _base.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\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 (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n AND NOT _base_2.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\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 (\n base.[monthly___region] = shifted_t.[monthly___region]\n AND NOT base.[monthly___region] IS NULL\n AND NOT shifted_t.[monthly___region] IS NULL\n )\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND NOT shifted_t.[monthly___ordered_at] IS NULL\n )\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::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 DATETIME_ADD(CAST(base.`monthly___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS DATETIME)\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", "leaf/trivial_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_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 _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), shifted_t AS (\n SELECT\n STRFTIME('%Y-%m-01', monthly.ordered_at) AS \"monthly.ordered_at\",\n CAST(SUM(monthly.amount) AS REAL) / 2 AS \"monthly.shifted\"\n FROM monthly AS monthly\n GROUP BY\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_partition_by_ordered_at\",\n shifted_t.\"monthly.shifted\" AS \"monthly.t\"\n FROM base\n LEFT JOIN shifted_t\n ON 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_partition_by_ordered_at\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "leaf/trivial_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_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 _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 (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at]\n AND NOT _base.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_sum_partition_by_ordered_at.[monthly___ordered_at] IS NULL\n )\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), shifted_t AS (\n SELECT\n DATETRUNC(month, monthly.ordered_at) AS [monthly___ordered_at],\n CAST(SUM(monthly.amount) AS FLOAT) / 2 AS [monthly___shifted]\n FROM monthly AS monthly\n GROUP BY\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_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 (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND NOT shifted_t.[monthly___ordered_at] IS NULL\n )\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_partition_by_ordered_at],\n [monthly___t]\n FROM sjoin_t\n) AS _outer", - "leaf/windowed_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_window_90d AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `monthly___amount_sum_window_90d`\n FROM (\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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`monthly___region`\n AND _src._w_time >= TIMESTAMP_ADD(\n CAST(DATETIME_ADD(CAST(_base.`monthly___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP),\n INTERVAL -90 DAY\n )\n AND _src._w_time < CAST(DATETIME_ADD(CAST(_base.`monthly___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS TIMESTAMP)\n GROUP BY\n _base.`monthly___region`,\n _base.`monthly___ordered_at`\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _cm_monthly__amount_sum_window_90d.`monthly___amount_sum_window_90d` AS `monthly___amount_sum_window_90d`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON _base.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.`monthly___region`\n AND _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.`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_sum_window_90d.`monthly___amount_sum_window_90d` / 2 AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON _base_2.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.`monthly___region`\n AND _base_2.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.`monthly___ordered_at`\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum_window_90d`,\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_window_90d`,\n `monthly___t`\n FROM sjoin_t\n) AS _outer", + "leaf/windowed_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_window_90d AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n CAST(SUM(_src._w_value) AS FLOAT64) AS `monthly___amount_sum_window_90d`\n FROM (\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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.`monthly___region`\n AND _src._w_time >= DATETIME_ADD(\n CAST(DATETIME_ADD(CAST(_base.`monthly___ordered_at` AS DATETIME), INTERVAL 1 MONTH) AS DATETIME),\n INTERVAL -90 DAY\n )\n AND _src._w_time < DATETIME_ADD(CAST(_base.`monthly___ordered_at` AS DATETIME), INTERVAL 1 MONTH)\n GROUP BY\n _base.`monthly___region`,\n _base.`monthly___ordered_at`\n), base AS (\n SELECT\n _base.`monthly___region`,\n _base.`monthly___ordered_at`,\n _cm_monthly__amount_sum_window_90d.`monthly___amount_sum_window_90d` AS `monthly___amount_sum_window_90d`\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON _base.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.`monthly___region`\n AND _base.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.`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_sum_window_90d.`monthly___amount_sum_window_90d` / 2 AS `monthly___shifted`\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON _base_2.`monthly___region` IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.`monthly___region`\n AND _base_2.`monthly___ordered_at` IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.`monthly___ordered_at`\n), sjoin_t AS (\n SELECT\n base.`monthly___region`,\n base.`monthly___ordered_at`,\n base.`monthly___amount_sum_window_90d`,\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 DATETIME_ADD(CAST(base.`monthly___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`monthly___ordered_at` AS DATETIME)\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_window_90d`,\n `monthly___t`\n FROM sjoin_t\n) AS _outer", "leaf/windowed_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_window_90d AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE) AS \"monthly.amount_sum_window_90d\"\n FROM (\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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"monthly.region\"\n AND _src._w_time >= _base.\"monthly.ordered_at\" + INTERVAL 1 MONTH - INTERVAL 90 DAY\n AND _src._w_time < _base.\"monthly.ordered_at\" + INTERVAL 1 MONTH\n GROUP BY\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\"\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _cm_monthly__amount_sum_window_90d.\"monthly.amount_sum_window_90d\" AS \"monthly.amount_sum_window_90d\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.\"monthly.region\"\n AND _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.\"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_sum_window_90d.\"monthly.amount_sum_window_90d\" / 2 AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.\"monthly.region\"\n AND _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum_window_90d\",\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_window_90d\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "leaf/windowed_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_window_90d AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n CAST(SUM(_src._w_value) AS DOUBLE PRECISION) AS \"monthly.amount_sum_window_90d\"\n FROM (\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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS NOT DISTINCT FROM _base.\"monthly.region\"\n AND _src._w_time >= _base.\"monthly.ordered_at\" + INTERVAL '1 MONTH' - INTERVAL '90 DAY'\n AND _src._w_time < _base.\"monthly.ordered_at\" + INTERVAL '1 MONTH'\n GROUP BY\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\"\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _cm_monthly__amount_sum_window_90d.\"monthly.amount_sum_window_90d\" AS \"monthly.amount_sum_window_90d\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON _base.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.\"monthly.region\"\n AND _base.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.\"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_sum_window_90d.\"monthly.amount_sum_window_90d\" AS DOUBLE PRECISION) / 2 AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON _base_2.\"monthly.region\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.\"monthly.region\"\n AND _base_2.\"monthly.ordered_at\" IS NOT DISTINCT FROM _cm_monthly__amount_sum_window_90d.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum_window_90d\",\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_window_90d\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "leaf/windowed_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_sum_window_90d AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n CAST(SUM(_src._w_value) AS REAL) AS \"monthly.amount_sum_window_90d\"\n FROM (\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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON _src._w_dim_0 IS _base.\"monthly.region\"\n AND DATETIME(_src._w_time) >= SLAYER_DATE_ADD(SLAYER_DATE_ADD(_base.\"monthly.ordered_at\", 1, 'month'), -90, 'day')\n AND DATETIME(_src._w_time) < SLAYER_DATE_ADD(_base.\"monthly.ordered_at\", 1, 'month')\n GROUP BY\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\"\n), base AS (\n SELECT\n _base.\"monthly.region\",\n _base.\"monthly.ordered_at\",\n _cm_monthly__amount_sum_window_90d.\"monthly.amount_sum_window_90d\" AS \"monthly.amount_sum_window_90d\"\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON _base.\"monthly.region\" IS _cm_monthly__amount_sum_window_90d.\"monthly.region\"\n AND _base.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_window_90d.\"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_sum_window_90d.\"monthly.amount_sum_window_90d\" AS REAL) / 2 AS \"monthly.shifted\"\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON _base_2.\"monthly.region\" IS _cm_monthly__amount_sum_window_90d.\"monthly.region\"\n AND _base_2.\"monthly.ordered_at\" IS _cm_monthly__amount_sum_window_90d.\"monthly.ordered_at\"\n), sjoin_t AS (\n SELECT\n base.\"monthly.region\",\n base.\"monthly.ordered_at\",\n base.\"monthly.amount_sum_window_90d\",\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_window_90d\",\n \"monthly.t\"\n FROM sjoin_t\n) AS _outer", "leaf/windowed_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_sum_window_90d AS (\n SELECT\n _base.[monthly___region] AS [monthly___region],\n _base.[monthly___ordered_at] AS [monthly___ordered_at],\n CAST(SUM(_src._w_value) AS FLOAT) AS [monthly___amount_sum_window_90d]\n FROM (\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 ) AS _base\n LEFT JOIN (\n SELECT\n monthly.region AS _w_dim_0,\n monthly.ordered_at AS _w_time,\n monthly.amount AS _w_value\n FROM monthly AS monthly\n ) AS _src\n ON (\n (\n _src._w_dim_0 = _base.[monthly___region]\n AND NOT _src._w_dim_0 IS NULL\n AND NOT _base.[monthly___region] IS NULL\n )\n OR (\n _src._w_dim_0 IS NULL AND _base.[monthly___region] IS NULL\n )\n )\n AND _src._w_time >= DATEADD(DAY, -90, DATEADD(MONTH, 1, _base.[monthly___ordered_at]))\n AND _src._w_time < DATEADD(MONTH, 1, _base.[monthly___ordered_at])\n GROUP BY\n _base.[monthly___region],\n _base.[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 _cm_monthly__amount_sum_window_90d.[monthly___amount_sum_window_90d] AS [monthly___amount_sum_window_90d]\n FROM _base\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON (\n (\n _base.[monthly___region] = _cm_monthly__amount_sum_window_90d.[monthly___region]\n AND NOT _base.[monthly___region] IS NULL\n AND NOT _cm_monthly__amount_sum_window_90d.[monthly___region] IS NULL\n )\n OR (\n _base.[monthly___region] IS NULL\n AND _cm_monthly__amount_sum_window_90d.[monthly___region] IS NULL\n )\n )\n AND (\n (\n _base.[monthly___ordered_at] = _cm_monthly__amount_sum_window_90d.[monthly___ordered_at]\n AND NOT _base.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_sum_window_90d.[monthly___ordered_at] IS NULL\n )\n OR (\n _base.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_window_90d.[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_sum_window_90d.[monthly___amount_sum_window_90d] AS FLOAT) / 2 AS [monthly___shifted]\n FROM _base_2\n LEFT JOIN _cm_monthly__amount_sum_window_90d\n ON (\n (\n _base_2.[monthly___region] = _cm_monthly__amount_sum_window_90d.[monthly___region]\n AND NOT _base_2.[monthly___region] IS NULL\n AND NOT _cm_monthly__amount_sum_window_90d.[monthly___region] IS NULL\n )\n OR (\n _base_2.[monthly___region] IS NULL\n AND _cm_monthly__amount_sum_window_90d.[monthly___region] IS NULL\n )\n )\n AND (\n (\n _base_2.[monthly___ordered_at] = _cm_monthly__amount_sum_window_90d.[monthly___ordered_at]\n AND NOT _base_2.[monthly___ordered_at] IS NULL\n AND NOT _cm_monthly__amount_sum_window_90d.[monthly___ordered_at] IS NULL\n )\n OR (\n _base_2.[monthly___ordered_at] IS NULL\n AND _cm_monthly__amount_sum_window_90d.[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_window_90d] AS [monthly___amount_sum_window_90d],\n shifted_t.[monthly___shifted] AS [monthly___t]\n FROM base\n LEFT JOIN shifted_t\n ON (\n (\n base.[monthly___region] = shifted_t.[monthly___region]\n AND NOT base.[monthly___region] IS NULL\n AND NOT shifted_t.[monthly___region] IS NULL\n )\n OR (\n base.[monthly___region] IS NULL AND shifted_t.[monthly___region] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[monthly___ordered_at]) = shifted_t.[monthly___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[monthly___ordered_at]) IS NULL\n AND NOT shifted_t.[monthly___ordered_at] IS NULL\n )\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_window_90d],\n [monthly___t]\n FROM sjoin_t\n) AS _outer", - "population/associate_dimension::bigquery": "WITH _base AS (\n SELECT\n customers__regions__region_events.value AS `orders___customers___regions___region_events___value`,\n DATE_TRUNC(orders.ordered_at, MONTH) 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(orders.ordered_at, MONTH)\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 FLOAT64) 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(orders.ordered_at, MONTH) 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(orders.ordered_at, MONTH),\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(orders.ordered_at, MONTH) 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(orders.ordered_at, MONTH)\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 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___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::bigquery": "WITH _base AS (\n SELECT\n customers__regions__region_events.value AS `orders___customers___regions___region_events___value`,\n DATE_TRUNC(orders.ordered_at, MONTH) 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(orders.ordered_at, MONTH)\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 FLOAT64) 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(orders.ordered_at, MONTH) 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(orders.ordered_at, MONTH),\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(orders.ordered_at, MONTH) 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(orders.ordered_at, MONTH)\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 DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`orders___ordered_at` AS DATETIME)\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::duckdb": "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) 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::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 (\n _base.[orders___customers___regions___region_events___value] = _cm_orders__amount_sum.[orders___customers___regions___region_events___value]\n AND NOT _base.[orders___customers___regions___region_events___value] IS NULL\n AND NOT _cm_orders__amount_sum.[orders___customers___regions___region_events___value] IS NULL\n )\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 (\n _base.[orders___ordered_at] = _cm_orders__amount_sum.[orders___ordered_at_month]\n AND NOT _base.[orders___ordered_at] IS NULL\n AND NOT _cm_orders__amount_sum.[orders___ordered_at_month] IS NULL\n )\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 (\n _base_2.[orders___customers___regions___region_events___value] = _cm_orders__amount_sum.[orders___customers___regions___region_events___value]\n AND NOT _base_2.[orders___customers___regions___region_events___value] IS NULL\n AND NOT _cm_orders__amount_sum.[orders___customers___regions___region_events___value] IS NULL\n )\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 (\n _base_2.[orders___ordered_at] = _cm_orders__amount_sum.[orders___ordered_at_month]\n AND NOT _base_2.[orders___ordered_at] IS NULL\n AND NOT _cm_orders__amount_sum.[orders___ordered_at_month] IS NULL\n )\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 (\n base.[orders___customers___regions___region_events___value] = shifted_t.[orders___customers___regions___region_events___value]\n AND NOT base.[orders___customers___regions___region_events___value] IS NULL\n AND NOT shifted_t.[orders___customers___regions___region_events___value] IS NULL\n )\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 (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted_t.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted_t.[orders___ordered_at] IS NULL\n )\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` / 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::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 DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`orders___ordered_at` AS DATETIME)\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", @@ -109,12 +109,12 @@ "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` / 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::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 DATETIME_ADD(CAST(base.`orders___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`orders___ordered_at` AS DATETIME)\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 (\n _base.[orders___customers___tier] = _cm_orders__amount_sum_partition_by_customers_tier.[orders___customers___tier]\n AND NOT _base.[orders___customers___tier] IS NULL\n AND NOT _cm_orders__amount_sum_partition_by_customers_tier.[orders___customers___tier] IS NULL\n )\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 (\n _base_2.[orders___customers___tier] = _cm_orders__amount_sum_partition_by_customers_tier.[orders___customers___tier]\n AND NOT _base_2.[orders___customers___tier] IS NULL\n AND NOT _cm_orders__amount_sum_partition_by_customers_tier.[orders___customers___tier] IS NULL\n )\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 (\n base.[orders___customers___tier] = shifted_t.[orders___customers___tier]\n AND NOT base.[orders___customers___tier] IS NULL\n AND NOT shifted_t.[orders___customers___tier] IS NULL\n )\n OR (\n base.[orders___customers___tier] IS NULL\n AND shifted_t.[orders___customers___tier] IS NULL\n )\n )\n AND (\n (\n DATEADD(MONTH, -1, base.[orders___ordered_at]) = shifted_t.[orders___ordered_at]\n AND NOT DATEADD(MONTH, -1, base.[orders___ordered_at]) IS NULL\n AND NOT shifted_t.[orders___ordered_at] IS NULL\n )\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::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 DATETIME_ADD(CAST(base.`s1___ordered_at` AS DATETIME), INTERVAL -1 MONTH) IS NOT DISTINCT FROM CAST(shifted_t.`s1___ordered_at` AS DATETIME)\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", diff --git a/tests/golden/dev2015_sql_baseline.json b/tests/golden/dev2015_sql_baseline.json index 00c1ddff8..1496e9a07 100644 --- a/tests/golden/dev2015_sql_baseline.json +++ b/tests/golden/dev2015_sql_baseline.json @@ -1,20 +1,20 @@ { - "custom/fiscal_year::bigquery": "SELECT\n CAST(DATETIME_ADD(\n CAST(CAST('2000-04-01 00:00:00' AS TIMESTAMP) AS DATETIME),\n INTERVAL (CASE\n WHEN CAST(DATETIME_ADD(\n CAST(CAST('2000-04-01 00:00:00' AS TIMESTAMP) AS DATETIME),\n INTERVAL (DATE_DIFF(\n CAST(CAST(orders.order_date AS TIMESTAMP) AS DATE),\n CAST(CAST('2000-04-01 00:00:00' AS TIMESTAMP) AS DATE),\n YEAR\n )) YEAR\n ) AS TIMESTAMP) > CAST(orders.order_date AS TIMESTAMP)\n THEN (\n DATE_DIFF(\n CAST(CAST(orders.order_date AS TIMESTAMP) AS DATE),\n CAST(CAST('2000-04-01 00:00:00' AS TIMESTAMP) AS DATE),\n YEAR\n )\n ) - 1\n ELSE DATE_DIFF(\n CAST(CAST(orders.order_date AS TIMESTAMP) AS DATE),\n CAST(CAST('2000-04-01 00:00:00' AS TIMESTAMP) AS DATE),\n YEAR\n )\n END) YEAR\n ) AS TIMESTAMP) AS `orders___order_date`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___s`\nFROM orders AS orders\nGROUP BY\n CAST(DATETIME_ADD(\n CAST(CAST('2000-04-01 00:00:00' AS TIMESTAMP) AS DATETIME),\n INTERVAL (CASE\n WHEN CAST(DATETIME_ADD(\n CAST(CAST('2000-04-01 00:00:00' AS TIMESTAMP) AS DATETIME),\n INTERVAL (DATE_DIFF(\n CAST(CAST(orders.order_date AS TIMESTAMP) AS DATE),\n CAST(CAST('2000-04-01 00:00:00' AS TIMESTAMP) AS DATE),\n YEAR\n )) YEAR\n ) AS TIMESTAMP) > CAST(orders.order_date AS TIMESTAMP)\n THEN (\n DATE_DIFF(\n CAST(CAST(orders.order_date AS TIMESTAMP) AS DATE),\n CAST(CAST('2000-04-01 00:00:00' AS TIMESTAMP) AS DATE),\n YEAR\n )\n ) - 1\n ELSE DATE_DIFF(\n CAST(CAST(orders.order_date AS TIMESTAMP) AS DATE),\n CAST(CAST('2000-04-01 00:00:00' AS TIMESTAMP) AS DATE),\n YEAR\n )\n END) YEAR\n ) AS TIMESTAMP)", + "custom/fiscal_year::bigquery": "SELECT\n DATETIME_ADD(\n CAST('2000-04-01 00:00:00' AS DATETIME),\n INTERVAL (CASE\n WHEN DATETIME_ADD(\n CAST('2000-04-01 00:00:00' AS DATETIME),\n INTERVAL (DATE_DIFF(\n CAST(CAST(orders.order_date AS DATETIME) AS DATE),\n CAST(CAST('2000-04-01 00:00:00' AS DATETIME) AS DATE),\n YEAR\n )) YEAR\n ) > CAST(orders.order_date AS DATETIME)\n THEN (\n DATE_DIFF(\n CAST(CAST(orders.order_date AS DATETIME) AS DATE),\n CAST(CAST('2000-04-01 00:00:00' AS DATETIME) AS DATE),\n YEAR\n )\n ) - 1\n ELSE DATE_DIFF(\n CAST(CAST(orders.order_date AS DATETIME) AS DATE),\n CAST(CAST('2000-04-01 00:00:00' AS DATETIME) AS DATE),\n YEAR\n )\n END) YEAR\n ) AS `orders___order_date`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___s`\nFROM orders AS orders\nGROUP BY\n DATETIME_ADD(\n CAST('2000-04-01 00:00:00' AS DATETIME),\n INTERVAL (CASE\n WHEN DATETIME_ADD(\n CAST('2000-04-01 00:00:00' AS DATETIME),\n INTERVAL (DATE_DIFF(\n CAST(CAST(orders.order_date AS DATETIME) AS DATE),\n CAST(CAST('2000-04-01 00:00:00' AS DATETIME) AS DATE),\n YEAR\n )) YEAR\n ) > CAST(orders.order_date AS DATETIME)\n THEN (\n DATE_DIFF(\n CAST(CAST(orders.order_date AS DATETIME) AS DATE),\n CAST(CAST('2000-04-01 00:00:00' AS DATETIME) AS DATE),\n YEAR\n )\n ) - 1\n ELSE DATE_DIFF(\n CAST(CAST(orders.order_date AS DATETIME) AS DATE),\n CAST(CAST('2000-04-01 00:00:00' AS DATETIME) AS DATE),\n YEAR\n )\n END) YEAR\n )", "custom/fiscal_year::duckdb": "SELECT\n CAST('2000-04-01 00:00:00' AS TIMESTAMP) + (\n CASE\n WHEN CAST('2000-04-01 00:00:00' AS TIMESTAMP) + (\n CAST(EXTRACT(YEAR FROM CAST(orders.order_date AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM CAST('2000-04-01 00:00:00' AS TIMESTAMP)) AS INT)\n ) * INTERVAL 1 YEAR > CAST(orders.order_date AS TIMESTAMP)\n THEN (\n CAST(EXTRACT(YEAR FROM CAST(orders.order_date AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM CAST('2000-04-01 00:00:00' AS TIMESTAMP)) AS INT)\n ) - 1\n ELSE CAST(EXTRACT(YEAR FROM CAST(orders.order_date AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM CAST('2000-04-01 00:00:00' AS TIMESTAMP)) AS INT)\n END\n ) * INTERVAL 1 YEAR AS \"orders.order_date\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.s\"\nFROM orders AS orders\nGROUP BY\n CAST('2000-04-01 00:00:00' AS TIMESTAMP) + (\n CASE\n WHEN CAST('2000-04-01 00:00:00' AS TIMESTAMP) + (\n CAST(EXTRACT(YEAR FROM CAST(orders.order_date AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM CAST('2000-04-01 00:00:00' AS TIMESTAMP)) AS INT)\n ) * INTERVAL 1 YEAR > CAST(orders.order_date AS TIMESTAMP)\n THEN (\n CAST(EXTRACT(YEAR FROM CAST(orders.order_date AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM CAST('2000-04-01 00:00:00' AS TIMESTAMP)) AS INT)\n ) - 1\n ELSE CAST(EXTRACT(YEAR FROM CAST(orders.order_date AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM CAST('2000-04-01 00:00:00' AS TIMESTAMP)) AS INT)\n END\n ) * INTERVAL 1 YEAR", "custom/fiscal_year::postgres": "SELECT\n CAST('2000-04-01 00:00:00' AS TIMESTAMP) + (\n CASE\n WHEN CAST('2000-04-01 00:00:00' AS TIMESTAMP) + (\n CAST(EXTRACT(YEAR FROM CAST(orders.order_date AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM CAST('2000-04-01 00:00:00' AS TIMESTAMP)) AS INT)\n ) * INTERVAL '1 YEAR' > CAST(orders.order_date AS TIMESTAMP)\n THEN (\n CAST(EXTRACT(YEAR FROM CAST(orders.order_date AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM CAST('2000-04-01 00:00:00' AS TIMESTAMP)) AS INT)\n ) - 1\n ELSE CAST(EXTRACT(YEAR FROM CAST(orders.order_date AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM CAST('2000-04-01 00:00:00' AS TIMESTAMP)) AS INT)\n END\n ) * INTERVAL '1 YEAR' AS \"orders.order_date\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.s\"\nFROM orders AS orders\nGROUP BY\n CAST('2000-04-01 00:00:00' AS TIMESTAMP) + (\n CASE\n WHEN CAST('2000-04-01 00:00:00' AS TIMESTAMP) + (\n CAST(EXTRACT(YEAR FROM CAST(orders.order_date AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM CAST('2000-04-01 00:00:00' AS TIMESTAMP)) AS INT)\n ) * INTERVAL '1 YEAR' > CAST(orders.order_date AS TIMESTAMP)\n THEN (\n CAST(EXTRACT(YEAR FROM CAST(orders.order_date AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM CAST('2000-04-01 00:00:00' AS TIMESTAMP)) AS INT)\n ) - 1\n ELSE CAST(EXTRACT(YEAR FROM CAST(orders.order_date AS TIMESTAMP)) AS INT) - CAST(EXTRACT(YEAR FROM CAST('2000-04-01 00:00:00' AS TIMESTAMP)) AS INT)\n END\n ) * INTERVAL '1 YEAR'", "custom/fiscal_year::sqlite": "SELECT\n SLAYER_DATE_ADD(\n '2000-04-01 00:00:00',\n CASE\n WHEN SLAYER_DATE_ADD(\n '2000-04-01 00:00:00',\n CAST(STRFTIME('%Y', DATETIME(orders.order_date)) AS INTEGER) - CAST(STRFTIME('%Y', '2000-04-01 00:00:00') AS INTEGER),\n 'year'\n ) > DATETIME(orders.order_date)\n THEN (\n CAST(STRFTIME('%Y', DATETIME(orders.order_date)) AS INTEGER) - CAST(STRFTIME('%Y', '2000-04-01 00:00:00') AS INTEGER)\n ) - 1\n ELSE CAST(STRFTIME('%Y', DATETIME(orders.order_date)) AS INTEGER) - CAST(STRFTIME('%Y', '2000-04-01 00:00:00') AS INTEGER)\n END,\n 'year'\n ) AS \"orders.order_date\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.s\"\nFROM orders AS orders\nGROUP BY\n SLAYER_DATE_ADD(\n '2000-04-01 00:00:00',\n CASE\n WHEN SLAYER_DATE_ADD(\n '2000-04-01 00:00:00',\n CAST(STRFTIME('%Y', DATETIME(orders.order_date)) AS INTEGER) - CAST(STRFTIME('%Y', '2000-04-01 00:00:00') AS INTEGER),\n 'year'\n ) > DATETIME(orders.order_date)\n THEN (\n CAST(STRFTIME('%Y', DATETIME(orders.order_date)) AS INTEGER) - CAST(STRFTIME('%Y', '2000-04-01 00:00:00') AS INTEGER)\n ) - 1\n ELSE CAST(STRFTIME('%Y', DATETIME(orders.order_date)) AS INTEGER) - CAST(STRFTIME('%Y', '2000-04-01 00:00:00') AS INTEGER)\n END,\n 'year'\n )", "custom/fiscal_year::tsql": "SELECT\n DATEADD(\n YEAR,\n CASE\n WHEN DATEADD(\n YEAR,\n DATEDIFF_BIG(YEAR, CAST('2000-04-01 00:00:00' AS DATETIME2), CAST(orders.order_date AS DATETIME2)),\n CAST('2000-04-01 00:00:00' AS DATETIME2)\n ) > CAST(orders.order_date AS DATETIME2)\n THEN (\n DATEDIFF_BIG(YEAR, CAST('2000-04-01 00:00:00' AS DATETIME2), CAST(orders.order_date AS DATETIME2))\n ) - 1\n ELSE DATEDIFF_BIG(YEAR, CAST('2000-04-01 00:00:00' AS DATETIME2), CAST(orders.order_date AS DATETIME2))\n END,\n CAST('2000-04-01 00:00:00' AS DATETIME2)\n ) AS [orders___order_date],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___s]\nFROM orders AS orders\nGROUP BY\n DATEADD(\n YEAR,\n CASE\n WHEN DATEADD(\n YEAR,\n DATEDIFF_BIG(YEAR, CAST('2000-04-01 00:00:00' AS DATETIME2), CAST(orders.order_date AS DATETIME2)),\n CAST('2000-04-01 00:00:00' AS DATETIME2)\n ) > CAST(orders.order_date AS DATETIME2)\n THEN (\n DATEDIFF_BIG(YEAR, CAST('2000-04-01 00:00:00' AS DATETIME2), CAST(orders.order_date AS DATETIME2))\n ) - 1\n ELSE DATEDIFF_BIG(YEAR, CAST('2000-04-01 00:00:00' AS DATETIME2), CAST(orders.order_date AS DATETIME2))\n END,\n CAST('2000-04-01 00:00:00' AS DATETIME2)\n )", - "spine/per_group::bigquery": "WITH _base AS (\n SELECT\n customers.region AS `customers___region`,\n DATE_TRUNC(time_spine.timestamp, MONTH) AS `time_spine___timestamp`\n FROM customers AS customers\n CROSS JOIN (\n SELECT\n CAST(DATETIME_ADD(\n CAST(DATE_TRUNC(CAST('2025-01-01 00:00:00' AS TIMESTAMP), MONTH) AS DATETIME),\n INTERVAL _seq.i MONTH\n ) AS TIMESTAMP) AS `timestamp`\n FROM (\n SELECT\n i\n FROM UNNEST(GENERATE_ARRAY(0, 3)) AS i\n ) AS _seq\n WHERE\n CAST(DATETIME_ADD(\n CAST(DATE_TRUNC(CAST('2025-01-01 00:00:00' AS TIMESTAMP), MONTH) AS DATETIME),\n INTERVAL _seq.i MONTH\n ) AS TIMESTAMP) < '2025-04-01 00:00:00'\n AND CAST(DATETIME_ADD(\n CAST(DATE_TRUNC(CAST('2025-01-01 00:00:00' AS TIMESTAMP), MONTH) AS DATETIME),\n INTERVAL (_seq.i + 1) MONTH\n ) AS TIMESTAMP) > '2025-01-01 00:00:00'\n ) AS time_spine\n GROUP BY\n customers.region,\n DATE_TRUNC(time_spine.timestamp, MONTH)\n), _cm_customers__orders__amount_sum AS (\n SELECT\n customers.region AS `orders___customers___region`,\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date_month`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n WHERE\n orders.order_date >= '2025-01-01 00:00:00'\n AND orders.order_date < '2025-04-01 00:00:00'\n GROUP BY\n customers.region,\n DATE_TRUNC(orders.order_date, MONTH)\n), _cm_customers__returns__amount_sum AS (\n SELECT\n customers.region AS `returns___customers___region`,\n DATE_TRUNC(returns.return_date, MONTH) AS `returns___return_date_month`,\n CAST(SUM(returns.amount) AS FLOAT64) AS `returns___amount_sum`\n FROM returns AS returns\n LEFT JOIN customers AS customers\n ON returns.customer_id = customers.id\n WHERE\n returns.return_date >= '2025-01-01 00:00:00'\n AND returns.return_date < '2025-04-01 00:00:00'\n GROUP BY\n customers.region,\n DATE_TRUNC(returns.return_date, MONTH)\n)\nSELECT\n _base.`customers___region`,\n _base.`time_spine___timestamp`,\n _cm_customers__orders__amount_sum.`orders___amount_sum` AS `customers___o`,\n _cm_customers__returns__amount_sum.`returns___amount_sum` AS `customers___r`\nFROM _base\nLEFT JOIN _cm_customers__orders__amount_sum\n ON _base.`customers___region` IS NOT DISTINCT FROM _cm_customers__orders__amount_sum.`orders___customers___region`\n AND _base.`time_spine___timestamp` IS NOT DISTINCT FROM _cm_customers__orders__amount_sum.`orders___order_date_month`\nLEFT JOIN _cm_customers__returns__amount_sum\n ON _base.`customers___region` IS NOT DISTINCT FROM _cm_customers__returns__amount_sum.`returns___customers___region`\n AND _base.`time_spine___timestamp` IS NOT DISTINCT FROM _cm_customers__returns__amount_sum.`returns___return_date_month`", + "spine/per_group::bigquery": "WITH _base AS (\n SELECT\n customers.region AS `customers___region`,\n DATE_TRUNC(time_spine.timestamp, MONTH) AS `time_spine___timestamp`\n FROM customers AS customers\n CROSS JOIN (\n SELECT\n DATETIME_ADD(\n CAST(DATE_TRUNC(CAST('2025-01-01 00:00:00' AS DATETIME), MONTH) AS DATETIME),\n INTERVAL _seq.i MONTH\n ) AS `timestamp`\n FROM (\n SELECT\n i\n FROM UNNEST(GENERATE_ARRAY(0, 3)) AS i\n ) AS _seq\n WHERE\n DATETIME_ADD(\n CAST(DATE_TRUNC(CAST('2025-01-01 00:00:00' AS DATETIME), MONTH) AS DATETIME),\n INTERVAL _seq.i MONTH\n ) < '2025-04-01 00:00:00'\n AND DATETIME_ADD(\n CAST(DATE_TRUNC(CAST('2025-01-01 00:00:00' AS DATETIME), MONTH) AS DATETIME),\n INTERVAL (_seq.i + 1) MONTH\n ) > '2025-01-01 00:00:00'\n ) AS time_spine\n GROUP BY\n customers.region,\n DATE_TRUNC(time_spine.timestamp, MONTH)\n), _cm_customers__orders__amount_sum AS (\n SELECT\n customers.region AS `orders___customers___region`,\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date_month`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum`\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n WHERE\n orders.order_date >= '2025-01-01 00:00:00'\n AND orders.order_date < '2025-04-01 00:00:00'\n GROUP BY\n customers.region,\n DATE_TRUNC(orders.order_date, MONTH)\n), _cm_customers__returns__amount_sum AS (\n SELECT\n customers.region AS `returns___customers___region`,\n DATE_TRUNC(returns.return_date, MONTH) AS `returns___return_date_month`,\n CAST(SUM(returns.amount) AS FLOAT64) AS `returns___amount_sum`\n FROM returns AS returns\n LEFT JOIN customers AS customers\n ON returns.customer_id = customers.id\n WHERE\n returns.return_date >= '2025-01-01 00:00:00'\n AND returns.return_date < '2025-04-01 00:00:00'\n GROUP BY\n customers.region,\n DATE_TRUNC(returns.return_date, MONTH)\n)\nSELECT\n _base.`customers___region`,\n _base.`time_spine___timestamp`,\n _cm_customers__orders__amount_sum.`orders___amount_sum` AS `customers___o`,\n _cm_customers__returns__amount_sum.`returns___amount_sum` AS `customers___r`\nFROM _base\nLEFT JOIN _cm_customers__orders__amount_sum\n ON _base.`customers___region` IS NOT DISTINCT FROM _cm_customers__orders__amount_sum.`orders___customers___region`\n AND _base.`time_spine___timestamp` IS NOT DISTINCT FROM _cm_customers__orders__amount_sum.`orders___order_date_month`\nLEFT JOIN _cm_customers__returns__amount_sum\n ON _base.`customers___region` IS NOT DISTINCT FROM _cm_customers__returns__amount_sum.`returns___customers___region`\n AND _base.`time_spine___timestamp` IS NOT DISTINCT FROM _cm_customers__returns__amount_sum.`returns___return_date_month`", "spine/per_group::duckdb": "WITH _base AS (\n SELECT\n customers.region AS \"customers.region\",\n DATE_TRUNC('MONTH', time_spine.timestamp) AS \"time_spine.timestamp\"\n FROM customers AS customers\n CROSS JOIN (\n SELECT\n DATE_TRUNC('MONTH', CAST('2025-01-01 00:00:00' AS TIMESTAMP)) + (\n _seq.i\n ) * INTERVAL 1 MONTH AS \"timestamp\"\n FROM (\n SELECT\n i\n FROM RANGE(0, 4) AS _seq(i)\n ) AS _seq\n WHERE\n DATE_TRUNC('MONTH', CAST('2025-01-01 00:00:00' AS TIMESTAMP)) + (\n _seq.i\n ) * INTERVAL 1 MONTH < CAST('2025-04-01 00:00:00' AS TIMESTAMP)\n AND DATE_TRUNC('MONTH', CAST('2025-01-01 00:00:00' AS TIMESTAMP)) + (\n _seq.i + 1\n ) * INTERVAL 1 MONTH > CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n ) AS time_spine\n GROUP BY\n customers.region,\n DATE_TRUNC('MONTH', time_spine.timestamp)\n), _cm_customers__orders__amount_sum AS (\n SELECT\n customers.region AS \"orders.customers.region\",\n DATE_TRUNC('MONTH', orders.order_date) AS \"orders.order_date_month\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n WHERE\n orders.order_date >= CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n AND orders.order_date < CAST('2025-04-01 00:00:00' AS TIMESTAMP)\n GROUP BY\n customers.region,\n DATE_TRUNC('MONTH', orders.order_date)\n), _cm_customers__returns__amount_sum AS (\n SELECT\n customers.region AS \"returns.customers.region\",\n DATE_TRUNC('MONTH', returns.return_date) AS \"returns.return_date_month\",\n CAST(SUM(returns.amount) AS DOUBLE) AS \"returns.amount_sum\"\n FROM returns AS returns\n LEFT JOIN customers AS customers\n ON returns.customer_id = customers.id\n WHERE\n returns.return_date >= CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n AND returns.return_date < CAST('2025-04-01 00:00:00' AS TIMESTAMP)\n GROUP BY\n customers.region,\n DATE_TRUNC('MONTH', returns.return_date)\n)\nSELECT\n _base.\"customers.region\",\n _base.\"time_spine.timestamp\",\n _cm_customers__orders__amount_sum.\"orders.amount_sum\" AS \"customers.o\",\n _cm_customers__returns__amount_sum.\"returns.amount_sum\" AS \"customers.r\"\nFROM _base\nLEFT JOIN _cm_customers__orders__amount_sum\n ON _base.\"customers.region\" IS NOT DISTINCT FROM _cm_customers__orders__amount_sum.\"orders.customers.region\"\n AND _base.\"time_spine.timestamp\" IS NOT DISTINCT FROM _cm_customers__orders__amount_sum.\"orders.order_date_month\"\nLEFT JOIN _cm_customers__returns__amount_sum\n ON _base.\"customers.region\" IS NOT DISTINCT FROM _cm_customers__returns__amount_sum.\"returns.customers.region\"\n AND _base.\"time_spine.timestamp\" IS NOT DISTINCT FROM _cm_customers__returns__amount_sum.\"returns.return_date_month\"", "spine/per_group::postgres": "WITH _base AS (\n SELECT\n customers.region AS \"customers.region\",\n DATE_TRUNC('MONTH', time_spine.timestamp) AS \"time_spine.timestamp\"\n FROM customers AS customers\n CROSS JOIN (\n SELECT\n DATE_TRUNC('MONTH', CAST('2025-01-01 00:00:00' AS TIMESTAMP)) + (\n _seq.i\n ) * INTERVAL '1 MONTH' AS \"timestamp\"\n FROM (\n SELECT\n i\n FROM GENERATE_SERIES(0, 3) AS _seq(i)\n ) AS _seq\n WHERE\n DATE_TRUNC('MONTH', CAST('2025-01-01 00:00:00' AS TIMESTAMP)) + (\n _seq.i\n ) * INTERVAL '1 MONTH' < CAST('2025-04-01 00:00:00' AS TIMESTAMP)\n AND DATE_TRUNC('MONTH', CAST('2025-01-01 00:00:00' AS TIMESTAMP)) + (\n _seq.i + 1\n ) * INTERVAL '1 MONTH' > CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n ) AS time_spine\n GROUP BY\n customers.region,\n DATE_TRUNC('MONTH', time_spine.timestamp)\n), _cm_customers__orders__amount_sum AS (\n SELECT\n customers.region AS \"orders.customers.region\",\n DATE_TRUNC('MONTH', orders.order_date) AS \"orders.order_date_month\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n WHERE\n orders.order_date >= CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n AND orders.order_date < CAST('2025-04-01 00:00:00' AS TIMESTAMP)\n GROUP BY\n customers.region,\n DATE_TRUNC('MONTH', orders.order_date)\n), _cm_customers__returns__amount_sum AS (\n SELECT\n customers.region AS \"returns.customers.region\",\n DATE_TRUNC('MONTH', returns.return_date) AS \"returns.return_date_month\",\n CAST(SUM(returns.amount) AS DOUBLE PRECISION) AS \"returns.amount_sum\"\n FROM returns AS returns\n LEFT JOIN customers AS customers\n ON returns.customer_id = customers.id\n WHERE\n returns.return_date >= CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n AND returns.return_date < CAST('2025-04-01 00:00:00' AS TIMESTAMP)\n GROUP BY\n customers.region,\n DATE_TRUNC('MONTH', returns.return_date)\n)\nSELECT\n _base.\"customers.region\",\n _base.\"time_spine.timestamp\",\n _cm_customers__orders__amount_sum.\"orders.amount_sum\" AS \"customers.o\",\n _cm_customers__returns__amount_sum.\"returns.amount_sum\" AS \"customers.r\"\nFROM _base\nLEFT JOIN _cm_customers__orders__amount_sum\n ON _base.\"customers.region\" IS NOT DISTINCT FROM _cm_customers__orders__amount_sum.\"orders.customers.region\"\n AND _base.\"time_spine.timestamp\" IS NOT DISTINCT FROM _cm_customers__orders__amount_sum.\"orders.order_date_month\"\nLEFT JOIN _cm_customers__returns__amount_sum\n ON _base.\"customers.region\" IS NOT DISTINCT FROM _cm_customers__returns__amount_sum.\"returns.customers.region\"\n AND _base.\"time_spine.timestamp\" IS NOT DISTINCT FROM _cm_customers__returns__amount_sum.\"returns.return_date_month\"", "spine/per_group::sqlite": "WITH RECURSIVE _w__seq(i) AS (\n SELECT\n 0 AS i\n UNION ALL\n SELECT\n i + 1\n FROM _w__seq AS _seq\n WHERE\n i < 3\n), _base AS (\n SELECT\n customers.region AS \"customers.region\",\n STRFTIME('%Y-%m-01', time_spine.timestamp) AS \"time_spine.timestamp\"\n FROM customers AS customers\n CROSS JOIN (\n SELECT\n SLAYER_DATE_ADD(STRFTIME('%Y-%m-01', '2025-01-01 00:00:00'), _seq.i, 'month') AS \"timestamp\"\n FROM (\n SELECT\n i\n FROM _w__seq AS _seq\n ) AS _seq\n WHERE\n SLAYER_DATE_ADD(STRFTIME('%Y-%m-01', '2025-01-01 00:00:00'), _seq.i, 'month') < '2025-04-01'\n AND STRFTIME(\n '%Y-%m-%d %H:%M:%f',\n SLAYER_DATE_ADD(STRFTIME('%Y-%m-01', '2025-01-01 00:00:00'), _seq.i + 1, 'month')\n ) > STRFTIME('%Y-%m-%d %H:%M:%f', '2025-01-01 00:00:00')\n ) AS time_spine\n GROUP BY\n customers.region,\n STRFTIME('%Y-%m-01', time_spine.timestamp)\n), _cm_customers__orders__amount_sum AS (\n SELECT\n customers.region AS \"orders.customers.region\",\n STRFTIME('%Y-%m-01', orders.order_date) AS \"orders.order_date_month\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum\"\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n WHERE\n orders.order_date >= '2025-01-01' AND orders.order_date < '2025-04-01'\n GROUP BY\n customers.region,\n STRFTIME('%Y-%m-01', orders.order_date)\n), _cm_customers__returns__amount_sum AS (\n SELECT\n customers.region AS \"returns.customers.region\",\n STRFTIME('%Y-%m-01', returns.return_date) AS \"returns.return_date_month\",\n CAST(SUM(returns.amount) AS REAL) AS \"returns.amount_sum\"\n FROM returns AS returns\n LEFT JOIN customers AS customers\n ON returns.customer_id = customers.id\n WHERE\n returns.return_date >= '2025-01-01' AND returns.return_date < '2025-04-01'\n GROUP BY\n customers.region,\n STRFTIME('%Y-%m-01', returns.return_date)\n)\nSELECT\n _base.\"customers.region\",\n _base.\"time_spine.timestamp\",\n _cm_customers__orders__amount_sum.\"orders.amount_sum\" AS \"customers.o\",\n _cm_customers__returns__amount_sum.\"returns.amount_sum\" AS \"customers.r\"\nFROM _base\nLEFT JOIN _cm_customers__orders__amount_sum\n ON _base.\"customers.region\" IS _cm_customers__orders__amount_sum.\"orders.customers.region\"\n AND _base.\"time_spine.timestamp\" IS _cm_customers__orders__amount_sum.\"orders.order_date_month\"\nLEFT JOIN _cm_customers__returns__amount_sum\n ON _base.\"customers.region\" IS _cm_customers__returns__amount_sum.\"returns.customers.region\"\n AND _base.\"time_spine.timestamp\" IS _cm_customers__returns__amount_sum.\"returns.return_date_month\"", "spine/per_group::tsql": "WITH _base AS (\n SELECT\n customers.region AS [customers___region],\n DATETRUNC(month, time_spine.timestamp) AS [time_spine___timestamp]\n FROM customers AS customers\n CROSS JOIN (\n SELECT\n DATEADD(MONTH, _seq.i, DATETRUNC(month, CAST('2025-01-01 00:00:00' AS DATETIME2))) AS [timestamp]\n FROM (\n SELECT\n value AS i\n FROM GENERATE_SERIES(0, 3) AS _seq\n ) AS _seq\n WHERE\n DATEADD(MONTH, _seq.i, DATETRUNC(month, CAST('2025-01-01 00:00:00' AS DATETIME2))) < CAST('2025-04-01 00:00:00' AS DATETIME2)\n AND DATEADD(MONTH, _seq.i + 1, DATETRUNC(month, CAST('2025-01-01 00:00:00' AS DATETIME2))) > CAST('2025-01-01 00:00:00' AS DATETIME2)\n ) AS time_spine\n GROUP BY\n customers.region,\n DATETRUNC(month, time_spine.timestamp)\n), _cm_customers__orders__amount_sum AS (\n SELECT\n customers.region AS [orders___customers___region],\n DATETRUNC(month, orders.order_date) AS [orders___order_date_month],\n CAST(SUM(orders.amount) AS FLOAT) AS [orders___amount_sum]\n FROM orders AS orders\n LEFT JOIN customers AS customers\n ON orders.customer_id = customers.id\n WHERE\n orders.order_date >= CAST('2025-01-01 00:00:00' AS DATETIME2)\n AND orders.order_date < CAST('2025-04-01 00:00:00' AS DATETIME2)\n GROUP BY\n customers.region,\n DATETRUNC(month, orders.order_date)\n), _cm_customers__returns__amount_sum AS (\n SELECT\n customers.region AS [returns___customers___region],\n DATETRUNC(month, returns.return_date) AS [returns___return_date_month],\n CAST(SUM(returns.amount) AS FLOAT) AS [returns___amount_sum]\n FROM returns AS returns\n LEFT JOIN customers AS customers\n ON returns.customer_id = customers.id\n WHERE\n returns.return_date >= CAST('2025-01-01 00:00:00' AS DATETIME2)\n AND returns.return_date < CAST('2025-04-01 00:00:00' AS DATETIME2)\n GROUP BY\n customers.region,\n DATETRUNC(month, returns.return_date)\n)\nSELECT\n _base.[customers___region],\n _base.[time_spine___timestamp],\n _cm_customers__orders__amount_sum.[orders___amount_sum] AS [customers___o],\n _cm_customers__returns__amount_sum.[returns___amount_sum] AS [customers___r]\nFROM _base\nLEFT JOIN _cm_customers__orders__amount_sum\n ON (\n (\n _base.[customers___region] = _cm_customers__orders__amount_sum.[orders___customers___region]\n AND NOT _base.[customers___region] IS NULL\n AND NOT _cm_customers__orders__amount_sum.[orders___customers___region] IS NULL\n )\n OR (\n _base.[customers___region] IS NULL\n AND _cm_customers__orders__amount_sum.[orders___customers___region] IS NULL\n )\n )\n AND (\n (\n _base.[time_spine___timestamp] = _cm_customers__orders__amount_sum.[orders___order_date_month]\n AND NOT _base.[time_spine___timestamp] IS NULL\n AND NOT _cm_customers__orders__amount_sum.[orders___order_date_month] IS NULL\n )\n OR (\n _base.[time_spine___timestamp] IS NULL\n AND _cm_customers__orders__amount_sum.[orders___order_date_month] IS NULL\n )\n )\nLEFT JOIN _cm_customers__returns__amount_sum\n ON (\n (\n _base.[customers___region] = _cm_customers__returns__amount_sum.[returns___customers___region]\n AND NOT _base.[customers___region] IS NULL\n AND NOT _cm_customers__returns__amount_sum.[returns___customers___region] IS NULL\n )\n OR (\n _base.[customers___region] IS NULL\n AND _cm_customers__returns__amount_sum.[returns___customers___region] IS NULL\n )\n )\n AND (\n (\n _base.[time_spine___timestamp] = _cm_customers__returns__amount_sum.[returns___return_date_month]\n AND NOT _base.[time_spine___timestamp] IS NULL\n AND NOT _cm_customers__returns__amount_sum.[returns___return_date_month] IS NULL\n )\n OR (\n _base.[time_spine___timestamp] IS NULL\n AND _cm_customers__returns__amount_sum.[returns___return_date_month] IS NULL\n )\n )", - "spine/quarter_hour::bigquery": "WITH _base AS (\n SELECT\n TIMESTAMP_ADD(\n CAST('2000-01-01 00:00:00' AS TIMESTAMP),\n INTERVAL ((\n CASE\n WHEN (\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(time_spine.timestamp AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ) >= 0\n THEN DIV(\n (\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(time_spine.timestamp AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(time_spine.timestamp AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15) MINUTE\n ) AS `time_spine___timestamp`\n FROM (\n SELECT\n TIMESTAMP_ADD(\n TIMESTAMP_ADD(\n CAST('2000-01-01 00:00:00' AS TIMESTAMP),\n INTERVAL ((\n CASE\n WHEN (\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ) >= 0\n THEN DIV(\n (\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15) MINUTE\n ),\n INTERVAL ((\n _seq.i\n ) * 15) MINUTE\n ) AS `timestamp`\n FROM (\n SELECT\n i\n FROM UNNEST(GENERATE_ARRAY(0, 95)) AS i\n ) AS _seq\n WHERE\n TIMESTAMP_ADD(\n TIMESTAMP_ADD(\n CAST('2000-01-01 00:00:00' AS TIMESTAMP),\n INTERVAL ((\n CASE\n WHEN (\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ) >= 0\n THEN DIV(\n (\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15) MINUTE\n ),\n INTERVAL ((\n _seq.i\n ) * 15) MINUTE\n ) < '2025-01-02 00:00:00'\n AND TIMESTAMP_ADD(\n TIMESTAMP_ADD(\n CAST('2000-01-01 00:00:00' AS TIMESTAMP),\n INTERVAL ((\n CASE\n WHEN (\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ) >= 0\n THEN DIV(\n (\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15) MINUTE\n ),\n INTERVAL ((\n _seq.i + 1\n ) * 15) MINUTE\n ) > '2025-01-01 00:00:00'\n ) AS time_spine\n GROUP BY\n TIMESTAMP_ADD(\n CAST('2000-01-01 00:00:00' AS TIMESTAMP),\n INTERVAL ((\n CASE\n WHEN (\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(time_spine.timestamp AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ) >= 0\n THEN DIV(\n (\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(time_spine.timestamp AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(time_spine.timestamp AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15) MINUTE\n )\n), _cm_time_spine__orders__id_count AS (\n SELECT\n TIMESTAMP_ADD(\n CAST('2000-01-01 00:00:00' AS TIMESTAMP),\n INTERVAL ((\n CASE\n WHEN (\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(orders.order_date AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ) >= 0\n THEN DIV(\n (\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(orders.order_date AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(orders.order_date AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15) MINUTE\n ) AS `orders___order_date_quarter_hour`,\n COUNT(orders.id) AS `orders___id_count`\n FROM orders AS orders\n WHERE\n orders.order_date >= '2025-01-01 00:00:00'\n AND orders.order_date < '2025-01-02 00:00:00'\n GROUP BY\n TIMESTAMP_ADD(\n CAST('2000-01-01 00:00:00' AS TIMESTAMP),\n INTERVAL ((\n CASE\n WHEN (\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(orders.order_date AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ) >= 0\n THEN DIV(\n (\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(orders.order_date AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n TIMESTAMP_DIFF(\n TIMESTAMP_TRUNC(CAST(orders.order_date AS TIMESTAMP), MINUTE),\n TIMESTAMP_TRUNC(CAST('2000-01-01 00:00:00' AS TIMESTAMP), MINUTE),\n MINUTE\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15) MINUTE\n )\n)\nSELECT\n _base.`time_spine___timestamp`,\n COALESCE(_cm_time_spine__orders__id_count.`orders___id_count`, 0) AS `time_spine___n`\nFROM _base\nLEFT JOIN _cm_time_spine__orders__id_count\n ON _base.`time_spine___timestamp` IS NOT DISTINCT FROM _cm_time_spine__orders__id_count.`orders___order_date_quarter_hour`", + "spine/quarter_hour::bigquery": "WITH _base AS (\n SELECT\n DATETIME_ADD(\n CAST('2000-01-01 00:00:00' AS DATETIME),\n INTERVAL ((\n CASE\n WHEN (\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(time_spine.timestamp AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ) >= 0\n THEN DIV(\n (\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(time_spine.timestamp AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(time_spine.timestamp AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15) MINUTE\n ) AS `time_spine___timestamp`\n FROM (\n SELECT\n DATETIME_ADD(\n CAST(DATETIME_ADD(\n CAST('2000-01-01 00:00:00' AS DATETIME),\n INTERVAL ((\n CASE\n WHEN (\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST('2025-01-01 00:00:00' AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ) >= 0\n THEN DIV(\n (\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST('2025-01-01 00:00:00' AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST('2025-01-01 00:00:00' AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15) MINUTE\n ) AS DATETIME),\n INTERVAL ((\n _seq.i\n ) * 15) MINUTE\n ) AS `timestamp`\n FROM (\n SELECT\n i\n FROM UNNEST(GENERATE_ARRAY(0, 95)) AS i\n ) AS _seq\n WHERE\n DATETIME_ADD(\n CAST(DATETIME_ADD(\n CAST('2000-01-01 00:00:00' AS DATETIME),\n INTERVAL ((\n CASE\n WHEN (\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST('2025-01-01 00:00:00' AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ) >= 0\n THEN DIV(\n (\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST('2025-01-01 00:00:00' AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST('2025-01-01 00:00:00' AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15) MINUTE\n ) AS DATETIME),\n INTERVAL ((\n _seq.i\n ) * 15) MINUTE\n ) < '2025-01-02 00:00:00'\n AND DATETIME_ADD(\n CAST(DATETIME_ADD(\n CAST('2000-01-01 00:00:00' AS DATETIME),\n INTERVAL ((\n CASE\n WHEN (\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST('2025-01-01 00:00:00' AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ) >= 0\n THEN DIV(\n (\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST('2025-01-01 00:00:00' AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST('2025-01-01 00:00:00' AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15) MINUTE\n ) AS DATETIME),\n INTERVAL ((\n _seq.i + 1\n ) * 15) MINUTE\n ) > '2025-01-01 00:00:00'\n ) AS time_spine\n GROUP BY\n DATETIME_ADD(\n CAST('2000-01-01 00:00:00' AS DATETIME),\n INTERVAL ((\n CASE\n WHEN (\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(time_spine.timestamp AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ) >= 0\n THEN DIV(\n (\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(time_spine.timestamp AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(time_spine.timestamp AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15) MINUTE\n )\n), _cm_time_spine__orders__id_count AS (\n SELECT\n DATETIME_ADD(\n CAST('2000-01-01 00:00:00' AS DATETIME),\n INTERVAL ((\n CASE\n WHEN (\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(orders.order_date AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ) >= 0\n THEN DIV(\n (\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(orders.order_date AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(orders.order_date AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15) MINUTE\n ) AS `orders___order_date_quarter_hour`,\n COUNT(orders.id) AS `orders___id_count`\n FROM orders AS orders\n WHERE\n orders.order_date >= '2025-01-01 00:00:00'\n AND orders.order_date < '2025-01-02 00:00:00'\n GROUP BY\n DATETIME_ADD(\n CAST('2000-01-01 00:00:00' AS DATETIME),\n INTERVAL ((\n CASE\n WHEN (\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(orders.order_date AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ) >= 0\n THEN DIV(\n (\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(orders.order_date AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n DATETIME_DIFF(\n DATETIME_TRUNC(CAST(orders.order_date AS DATETIME), MINUTE),\n DATETIME_TRUNC(CAST('2000-01-01 00:00:00' AS DATETIME), MINUTE),\n MINUTE\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15) MINUTE\n )\n)\nSELECT\n _base.`time_spine___timestamp`,\n COALESCE(_cm_time_spine__orders__id_count.`orders___id_count`, 0) AS `time_spine___n`\nFROM _base\nLEFT JOIN _cm_time_spine__orders__id_count\n ON _base.`time_spine___timestamp` IS NOT DISTINCT FROM _cm_time_spine__orders__id_count.`orders___order_date_quarter_hour`", "spine/quarter_hour::duckdb": "WITH _base AS (\n SELECT\n CAST('2000-01-01 00:00:00' AS TIMESTAMP) + (\n (\n CASE\n WHEN (\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(time_spine.timestamp AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) >= 0\n THEN (\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(time_spine.timestamp AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) // 15\n ELSE -(\n (\n -(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(time_spine.timestamp AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) + 14\n ) // 15\n )\n END\n ) * 15\n ) * INTERVAL 1 MINUTE AS \"time_spine.timestamp\"\n FROM (\n SELECT\n CAST('2000-01-01 00:00:00' AS TIMESTAMP) + (\n (\n CASE\n WHEN (\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) >= 0\n THEN (\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) // 15\n ELSE -(\n (\n -(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) + 14\n ) // 15\n )\n END\n ) * 15\n ) * INTERVAL 1 MINUTE + (\n (\n _seq.i\n ) * 15\n ) * INTERVAL 1 MINUTE AS \"timestamp\"\n FROM (\n SELECT\n i\n FROM RANGE(0, 96) AS _seq(i)\n ) AS _seq\n WHERE\n CAST('2000-01-01 00:00:00' AS TIMESTAMP) + (\n (\n CASE\n WHEN (\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) >= 0\n THEN (\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) // 15\n ELSE -(\n (\n -(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) + 14\n ) // 15\n )\n END\n ) * 15\n ) * INTERVAL 1 MINUTE + (\n (\n _seq.i\n ) * 15\n ) * INTERVAL 1 MINUTE < CAST('2025-01-02 00:00:00' AS TIMESTAMP)\n AND CAST('2000-01-01 00:00:00' AS TIMESTAMP) + (\n (\n CASE\n WHEN (\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) >= 0\n THEN (\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) // 15\n ELSE -(\n (\n -(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) + 14\n ) // 15\n )\n END\n ) * 15\n ) * INTERVAL 1 MINUTE + (\n (\n _seq.i + 1\n ) * 15\n ) * INTERVAL 1 MINUTE > CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n ) AS time_spine\n GROUP BY\n CAST('2000-01-01 00:00:00' AS TIMESTAMP) + (\n (\n CASE\n WHEN (\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(time_spine.timestamp AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) >= 0\n THEN (\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(time_spine.timestamp AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) // 15\n ELSE -(\n (\n -(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(time_spine.timestamp AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) + 14\n ) // 15\n )\n END\n ) * 15\n ) * INTERVAL 1 MINUTE\n), _cm_time_spine__orders__id_count AS (\n SELECT\n CAST('2000-01-01 00:00:00' AS TIMESTAMP) + (\n (\n CASE\n WHEN (\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(orders.order_date AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) >= 0\n THEN (\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(orders.order_date AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) // 15\n ELSE -(\n (\n -(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(orders.order_date AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) + 14\n ) // 15\n )\n END\n ) * 15\n ) * INTERVAL 1 MINUTE AS \"orders.order_date_quarter_hour\",\n COUNT(orders.id) AS \"orders.id_count\"\n FROM orders AS orders\n WHERE\n orders.order_date >= CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n AND orders.order_date < CAST('2025-01-02 00:00:00' AS TIMESTAMP)\n GROUP BY\n CAST('2000-01-01 00:00:00' AS TIMESTAMP) + (\n (\n CASE\n WHEN (\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(orders.order_date AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) >= 0\n THEN (\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(orders.order_date AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) // 15\n ELSE -(\n (\n -(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(orders.order_date AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ) // 60\n ) + 14\n ) // 15\n )\n END\n ) * 15\n ) * INTERVAL 1 MINUTE\n)\nSELECT\n _base.\"time_spine.timestamp\",\n COALESCE(_cm_time_spine__orders__id_count.\"orders.id_count\", 0) AS \"time_spine.n\"\nFROM _base\nLEFT JOIN _cm_time_spine__orders__id_count\n ON _base.\"time_spine.timestamp\" IS NOT DISTINCT FROM _cm_time_spine__orders__id_count.\"orders.order_date_quarter_hour\"", "spine/quarter_hour::postgres": "WITH _base AS (\n SELECT\n CAST('2000-01-01 00:00:00' AS TIMESTAMP) + (\n (\n CASE\n WHEN (\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(time_spine.timestamp AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ) >= 0\n THEN DIV(\n (\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(time_spine.timestamp AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(time_spine.timestamp AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15\n ) * INTERVAL '1 MINUTE' AS \"time_spine.timestamp\"\n FROM (\n SELECT\n CAST('2000-01-01 00:00:00' AS TIMESTAMP) + (\n (\n CASE\n WHEN (\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ) >= 0\n THEN DIV(\n (\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15\n ) * INTERVAL '1 MINUTE' + (\n (\n _seq.i\n ) * 15\n ) * INTERVAL '1 MINUTE' AS \"timestamp\"\n FROM (\n SELECT\n i\n FROM GENERATE_SERIES(0, 95) AS _seq(i)\n ) AS _seq\n WHERE\n CAST('2000-01-01 00:00:00' AS TIMESTAMP) + (\n (\n CASE\n WHEN (\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ) >= 0\n THEN DIV(\n (\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15\n ) * INTERVAL '1 MINUTE' + (\n (\n _seq.i\n ) * 15\n ) * INTERVAL '1 MINUTE' < CAST('2025-01-02 00:00:00' AS TIMESTAMP)\n AND CAST('2000-01-01 00:00:00' AS TIMESTAMP) + (\n (\n CASE\n WHEN (\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ) >= 0\n THEN DIV(\n (\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(CAST('2025-01-01 00:00:00' AS TIMESTAMP) AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15\n ) * INTERVAL '1 MINUTE' + (\n (\n _seq.i + 1\n ) * 15\n ) * INTERVAL '1 MINUTE' > CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n ) AS time_spine\n GROUP BY\n CAST('2000-01-01 00:00:00' AS TIMESTAMP) + (\n (\n CASE\n WHEN (\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(time_spine.timestamp AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ) >= 0\n THEN DIV(\n (\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(time_spine.timestamp AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(time_spine.timestamp AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15\n ) * INTERVAL '1 MINUTE'\n), _cm_time_spine__orders__id_count AS (\n SELECT\n CAST('2000-01-01 00:00:00' AS TIMESTAMP) + (\n (\n CASE\n WHEN (\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(orders.order_date AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ) >= 0\n THEN DIV(\n (\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(orders.order_date AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(orders.order_date AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15\n ) * INTERVAL '1 MINUTE' AS \"orders.order_date_quarter_hour\",\n COUNT(orders.id) AS \"orders.id_count\"\n FROM orders AS orders\n WHERE\n orders.order_date >= CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n AND orders.order_date < CAST('2025-01-02 00:00:00' AS TIMESTAMP)\n GROUP BY\n CAST('2000-01-01 00:00:00' AS TIMESTAMP) + (\n (\n CASE\n WHEN (\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(orders.order_date AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ) >= 0\n THEN DIV(\n (\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(orders.order_date AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ),\n 15\n )\n ELSE -(\n DIV(\n (\n -(\n DIV(\n (\n CAST(EXTRACT(EPOCH FROM (\n DATE_TRUNC('MINUTE', CAST(orders.order_date AS TIMESTAMP)) - DATE_TRUNC('MINUTE', CAST('2000-01-01 00:00:00' AS TIMESTAMP))\n )) AS BIGINT)\n ),\n 60\n )\n ) + 14\n ),\n 15\n )\n )\n END\n ) * 15\n ) * INTERVAL '1 MINUTE'\n)\nSELECT\n _base.\"time_spine.timestamp\",\n COALESCE(_cm_time_spine__orders__id_count.\"orders.id_count\", 0) AS \"time_spine.n\"\nFROM _base\nLEFT JOIN _cm_time_spine__orders__id_count\n ON _base.\"time_spine.timestamp\" IS NOT DISTINCT FROM _cm_time_spine__orders__id_count.\"orders.order_date_quarter_hour\"", "spine/quarter_hour::sqlite": "WITH RECURSIVE _w__seq(i) AS (\n SELECT\n 0 AS i\n UNION ALL\n SELECT\n i + 1\n FROM _w__seq AS _seq\n WHERE\n i < 95\n), _base AS (\n SELECT\n SLAYER_DATE_ADD(\n '2000-01-01 00:00:00',\n (\n CASE\n WHEN (\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(time_spine.timestamp))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) >= 0\n THEN CAST(CAST((\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(time_spine.timestamp))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) AS REAL) / 15 AS INTEGER)\n ELSE -(\n CAST(CAST((\n -(\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(time_spine.timestamp))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) + 14\n ) AS REAL) / 15 AS INTEGER)\n )\n END\n ) * 15,\n 'minute'\n ) AS \"time_spine.timestamp\"\n FROM (\n SELECT\n SLAYER_DATE_ADD(\n SLAYER_DATE_ADD(\n '2000-01-01 00:00:00',\n (\n CASE\n WHEN (\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME('2025-01-01 00:00:00'))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) >= 0\n THEN CAST(CAST((\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME('2025-01-01 00:00:00'))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) AS REAL) / 15 AS INTEGER)\n ELSE -(\n CAST(CAST((\n -(\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME('2025-01-01 00:00:00'))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) + 14\n ) AS REAL) / 15 AS INTEGER)\n )\n END\n ) * 15,\n 'minute'\n ),\n (\n _seq.i\n ) * 15,\n 'minute'\n ) AS \"timestamp\"\n FROM (\n SELECT\n i\n FROM _w__seq AS _seq\n ) AS _seq\n WHERE\n SLAYER_DATE_ADD(\n SLAYER_DATE_ADD(\n '2000-01-01 00:00:00',\n (\n CASE\n WHEN (\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME('2025-01-01 00:00:00'))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) >= 0\n THEN CAST(CAST((\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME('2025-01-01 00:00:00'))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) AS REAL) / 15 AS INTEGER)\n ELSE -(\n CAST(CAST((\n -(\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME('2025-01-01 00:00:00'))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) + 14\n ) AS REAL) / 15 AS INTEGER)\n )\n END\n ) * 15,\n 'minute'\n ),\n (\n _seq.i\n ) * 15,\n 'minute'\n ) < '2025-01-02'\n AND STRFTIME(\n '%Y-%m-%d %H:%M:%f',\n SLAYER_DATE_ADD(\n SLAYER_DATE_ADD(\n '2000-01-01 00:00:00',\n (\n CASE\n WHEN (\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME('2025-01-01 00:00:00'))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) >= 0\n THEN CAST(CAST((\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME('2025-01-01 00:00:00'))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) AS REAL) / 15 AS INTEGER)\n ELSE -(\n CAST(CAST((\n -(\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME('2025-01-01 00:00:00'))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) + 14\n ) AS REAL) / 15 AS INTEGER)\n )\n END\n ) * 15,\n 'minute'\n ),\n (\n _seq.i + 1\n ) * 15,\n 'minute'\n )\n ) > STRFTIME('%Y-%m-%d %H:%M:%f', '2025-01-01 00:00:00')\n ) AS time_spine\n GROUP BY\n SLAYER_DATE_ADD(\n '2000-01-01 00:00:00',\n (\n CASE\n WHEN (\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(time_spine.timestamp))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) >= 0\n THEN CAST(CAST((\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(time_spine.timestamp))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) AS REAL) / 15 AS INTEGER)\n ELSE -(\n CAST(CAST((\n -(\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(time_spine.timestamp))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) + 14\n ) AS REAL) / 15 AS INTEGER)\n )\n END\n ) * 15,\n 'minute'\n )\n), _cm_time_spine__orders__id_count AS (\n SELECT\n SLAYER_DATE_ADD(\n '2000-01-01 00:00:00',\n (\n CASE\n WHEN (\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(orders.order_date))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) >= 0\n THEN CAST(CAST((\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(orders.order_date))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) AS REAL) / 15 AS INTEGER)\n ELSE -(\n CAST(CAST((\n -(\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(orders.order_date))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) + 14\n ) AS REAL) / 15 AS INTEGER)\n )\n END\n ) * 15,\n 'minute'\n ) AS \"orders.order_date_quarter_hour\",\n COUNT(orders.id) AS \"orders.id_count\"\n FROM orders AS orders\n WHERE\n orders.order_date >= '2025-01-01' AND orders.order_date < '2025-01-02'\n GROUP BY\n SLAYER_DATE_ADD(\n '2000-01-01 00:00:00',\n (\n CASE\n WHEN (\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(orders.order_date))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) >= 0\n THEN CAST(CAST((\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(orders.order_date))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) AS REAL) / 15 AS INTEGER)\n ELSE -(\n CAST(CAST((\n -(\n CAST(CAST((\n CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', DATETIME(orders.order_date))) AS INTEGER) - CAST(STRFTIME('%s', STRFTIME('%Y-%m-%d %H:%M:00', '2000-01-01 00:00:00')) AS INTEGER)\n ) AS REAL) / 60 AS INTEGER)\n ) + 14\n ) AS REAL) / 15 AS INTEGER)\n )\n END\n ) * 15,\n 'minute'\n )\n)\nSELECT\n _base.\"time_spine.timestamp\",\n COALESCE(_cm_time_spine__orders__id_count.\"orders.id_count\", 0) AS \"time_spine.n\"\nFROM _base\nLEFT JOIN _cm_time_spine__orders__id_count\n ON _base.\"time_spine.timestamp\" IS _cm_time_spine__orders__id_count.\"orders.order_date_quarter_hour\"", "spine/quarter_hour::tsql": "WITH _base AS (\n SELECT\n DATEADD(\n MINUTE,\n (\n CASE\n WHEN (\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(time_spine.timestamp AS DATETIME2)\n )\n ) >= 0\n THEN CAST(CAST((\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(time_spine.timestamp AS DATETIME2)\n )\n ) AS FLOAT) / 15 AS INTEGER)\n ELSE -(\n CAST(CAST((\n -(\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(time_spine.timestamp AS DATETIME2)\n )\n ) + 14\n ) AS FLOAT) / 15 AS INTEGER)\n )\n END\n ) * 15,\n CAST('2000-01-01 00:00:00' AS DATETIME2)\n ) AS [time_spine___timestamp]\n FROM (\n SELECT\n DATEADD(\n MINUTE,\n (\n _seq.i\n ) * 15,\n DATEADD(\n MINUTE,\n (\n CASE\n WHEN (\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(CAST('2025-01-01 00:00:00' AS DATETIME2) AS DATETIME2)\n )\n ) >= 0\n THEN CAST(CAST((\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(CAST('2025-01-01 00:00:00' AS DATETIME2) AS DATETIME2)\n )\n ) AS FLOAT) / 15 AS INTEGER)\n ELSE -(\n CAST(CAST((\n -(\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(CAST('2025-01-01 00:00:00' AS DATETIME2) AS DATETIME2)\n )\n ) + 14\n ) AS FLOAT) / 15 AS INTEGER)\n )\n END\n ) * 15,\n CAST('2000-01-01 00:00:00' AS DATETIME2)\n )\n ) AS [timestamp]\n FROM (\n SELECT\n value AS i\n FROM GENERATE_SERIES(0, 95) AS _seq\n ) AS _seq\n WHERE\n DATEADD(\n MINUTE,\n (\n _seq.i\n ) * 15,\n DATEADD(\n MINUTE,\n (\n CASE\n WHEN (\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(CAST('2025-01-01 00:00:00' AS DATETIME2) AS DATETIME2)\n )\n ) >= 0\n THEN CAST(CAST((\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(CAST('2025-01-01 00:00:00' AS DATETIME2) AS DATETIME2)\n )\n ) AS FLOAT) / 15 AS INTEGER)\n ELSE -(\n CAST(CAST((\n -(\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(CAST('2025-01-01 00:00:00' AS DATETIME2) AS DATETIME2)\n )\n ) + 14\n ) AS FLOAT) / 15 AS INTEGER)\n )\n END\n ) * 15,\n CAST('2000-01-01 00:00:00' AS DATETIME2)\n )\n ) < CAST('2025-01-02 00:00:00' AS DATETIME2)\n AND DATEADD(\n MINUTE,\n (\n _seq.i + 1\n ) * 15,\n DATEADD(\n MINUTE,\n (\n CASE\n WHEN (\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(CAST('2025-01-01 00:00:00' AS DATETIME2) AS DATETIME2)\n )\n ) >= 0\n THEN CAST(CAST((\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(CAST('2025-01-01 00:00:00' AS DATETIME2) AS DATETIME2)\n )\n ) AS FLOAT) / 15 AS INTEGER)\n ELSE -(\n CAST(CAST((\n -(\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(CAST('2025-01-01 00:00:00' AS DATETIME2) AS DATETIME2)\n )\n ) + 14\n ) AS FLOAT) / 15 AS INTEGER)\n )\n END\n ) * 15,\n CAST('2000-01-01 00:00:00' AS DATETIME2)\n )\n ) > CAST('2025-01-01 00:00:00' AS DATETIME2)\n ) AS time_spine\n GROUP BY\n DATEADD(\n MINUTE,\n (\n CASE\n WHEN (\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(time_spine.timestamp AS DATETIME2)\n )\n ) >= 0\n THEN CAST(CAST((\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(time_spine.timestamp AS DATETIME2)\n )\n ) AS FLOAT) / 15 AS INTEGER)\n ELSE -(\n CAST(CAST((\n -(\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(time_spine.timestamp AS DATETIME2)\n )\n ) + 14\n ) AS FLOAT) / 15 AS INTEGER)\n )\n END\n ) * 15,\n CAST('2000-01-01 00:00:00' AS DATETIME2)\n )\n), _cm_time_spine__orders__id_count AS (\n SELECT\n DATEADD(\n MINUTE,\n (\n CASE\n WHEN (\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(orders.order_date AS DATETIME2)\n )\n ) >= 0\n THEN CAST(CAST((\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(orders.order_date AS DATETIME2)\n )\n ) AS FLOAT) / 15 AS INTEGER)\n ELSE -(\n CAST(CAST((\n -(\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(orders.order_date AS DATETIME2)\n )\n ) + 14\n ) AS FLOAT) / 15 AS INTEGER)\n )\n END\n ) * 15,\n CAST('2000-01-01 00:00:00' AS DATETIME2)\n ) AS [orders___order_date_quarter_hour],\n COUNT(orders.id) AS [orders___id_count]\n FROM orders AS orders\n WHERE\n orders.order_date >= CAST('2025-01-01 00:00:00' AS DATETIME2)\n AND orders.order_date < CAST('2025-01-02 00:00:00' AS DATETIME2)\n GROUP BY\n DATEADD(\n MINUTE,\n (\n CASE\n WHEN (\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(orders.order_date AS DATETIME2)\n )\n ) >= 0\n THEN CAST(CAST((\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(orders.order_date AS DATETIME2)\n )\n ) AS FLOAT) / 15 AS INTEGER)\n ELSE -(\n CAST(CAST((\n -(\n DATEDIFF_BIG(\n MINUTE,\n CAST('2000-01-01 00:00:00' AS DATETIME2),\n CAST(orders.order_date AS DATETIME2)\n )\n ) + 14\n ) AS FLOAT) / 15 AS INTEGER)\n )\n END\n ) * 15,\n CAST('2000-01-01 00:00:00' AS DATETIME2)\n )\n)\nSELECT\n _base.[time_spine___timestamp],\n COALESCE(_cm_time_spine__orders__id_count.[orders___id_count], 0) AS [time_spine___n]\nFROM _base\nLEFT JOIN _cm_time_spine__orders__id_count\n ON (\n (\n _base.[time_spine___timestamp] = _cm_time_spine__orders__id_count.[orders___order_date_quarter_hour]\n AND NOT _base.[time_spine___timestamp] IS NULL\n AND NOT _cm_time_spine__orders__id_count.[orders___order_date_quarter_hour] IS NULL\n )\n OR (\n _base.[time_spine___timestamp] IS NULL\n AND _cm_time_spine__orders__id_count.[orders___order_date_quarter_hour] IS NULL\n )\n )", - "spine/two_facts::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(time_spine.timestamp, MONTH) AS `time_spine___timestamp`\n FROM (\n SELECT\n CAST(DATETIME_ADD(\n CAST(DATE_TRUNC(CAST('2025-01-01 00:00:00' AS TIMESTAMP), MONTH) AS DATETIME),\n INTERVAL _seq.i MONTH\n ) AS TIMESTAMP) AS `timestamp`\n FROM (\n SELECT\n i\n FROM UNNEST(GENERATE_ARRAY(0, 6)) AS i\n ) AS _seq\n WHERE\n CAST(DATETIME_ADD(\n CAST(DATE_TRUNC(CAST('2025-01-01 00:00:00' AS TIMESTAMP), MONTH) AS DATETIME),\n INTERVAL _seq.i MONTH\n ) AS TIMESTAMP) < '2025-07-01 00:00:00'\n AND CAST(DATETIME_ADD(\n CAST(DATE_TRUNC(CAST('2025-01-01 00:00:00' AS TIMESTAMP), MONTH) AS DATETIME),\n INTERVAL (_seq.i + 1) MONTH\n ) AS TIMESTAMP) > '2025-01-01 00:00:00'\n ) AS time_spine\n GROUP BY\n DATE_TRUNC(time_spine.timestamp, MONTH)\n), _cm_time_spine__orders__amount_sum AS (\n SELECT\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date_month`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.order_date >= '2025-01-01 00:00:00'\n AND orders.order_date < '2025-07-01 00:00:00'\n GROUP BY\n DATE_TRUNC(orders.order_date, MONTH)\n), _cm_time_spine__returns__amount_sum AS (\n SELECT\n DATE_TRUNC(returns.return_date, MONTH) AS `returns___return_date_month`,\n CAST(SUM(returns.amount) AS FLOAT64) AS `returns___amount_sum`\n FROM returns AS returns\n WHERE\n returns.return_date >= '2025-01-01 00:00:00'\n AND returns.return_date < '2025-07-01 00:00:00'\n GROUP BY\n DATE_TRUNC(returns.return_date, MONTH)\n), _cm_time_spine__orders__id_count AS (\n SELECT\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date_month`,\n COUNT(orders.id) AS `orders___id_count`\n FROM orders AS orders\n WHERE\n orders.order_date >= '2025-01-01 00:00:00'\n AND orders.order_date < '2025-07-01 00:00:00'\n GROUP BY\n DATE_TRUNC(orders.order_date, MONTH)\n)\nSELECT\n _base.`time_spine___timestamp`,\n _cm_time_spine__orders__amount_sum.`orders___amount_sum` AS `time_spine___o`,\n _cm_time_spine__returns__amount_sum.`returns___amount_sum` AS `time_spine___r`,\n COALESCE(_cm_time_spine__orders__id_count.`orders___id_count`, 0) AS `time_spine___n`\nFROM _base\nLEFT JOIN _cm_time_spine__orders__amount_sum\n ON _base.`time_spine___timestamp` IS NOT DISTINCT FROM _cm_time_spine__orders__amount_sum.`orders___order_date_month`\nLEFT JOIN _cm_time_spine__returns__amount_sum\n ON _base.`time_spine___timestamp` IS NOT DISTINCT FROM _cm_time_spine__returns__amount_sum.`returns___return_date_month`\nLEFT JOIN _cm_time_spine__orders__id_count\n ON _base.`time_spine___timestamp` IS NOT DISTINCT FROM _cm_time_spine__orders__id_count.`orders___order_date_month`", + "spine/two_facts::bigquery": "WITH _base AS (\n SELECT\n DATE_TRUNC(time_spine.timestamp, MONTH) AS `time_spine___timestamp`\n FROM (\n SELECT\n DATETIME_ADD(\n CAST(DATE_TRUNC(CAST('2025-01-01 00:00:00' AS DATETIME), MONTH) AS DATETIME),\n INTERVAL _seq.i MONTH\n ) AS `timestamp`\n FROM (\n SELECT\n i\n FROM UNNEST(GENERATE_ARRAY(0, 6)) AS i\n ) AS _seq\n WHERE\n DATETIME_ADD(\n CAST(DATE_TRUNC(CAST('2025-01-01 00:00:00' AS DATETIME), MONTH) AS DATETIME),\n INTERVAL _seq.i MONTH\n ) < '2025-07-01 00:00:00'\n AND DATETIME_ADD(\n CAST(DATE_TRUNC(CAST('2025-01-01 00:00:00' AS DATETIME), MONTH) AS DATETIME),\n INTERVAL (_seq.i + 1) MONTH\n ) > '2025-01-01 00:00:00'\n ) AS time_spine\n GROUP BY\n DATE_TRUNC(time_spine.timestamp, MONTH)\n), _cm_time_spine__orders__amount_sum AS (\n SELECT\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date_month`,\n CAST(SUM(orders.amount) AS FLOAT64) AS `orders___amount_sum`\n FROM orders AS orders\n WHERE\n orders.order_date >= '2025-01-01 00:00:00'\n AND orders.order_date < '2025-07-01 00:00:00'\n GROUP BY\n DATE_TRUNC(orders.order_date, MONTH)\n), _cm_time_spine__returns__amount_sum AS (\n SELECT\n DATE_TRUNC(returns.return_date, MONTH) AS `returns___return_date_month`,\n CAST(SUM(returns.amount) AS FLOAT64) AS `returns___amount_sum`\n FROM returns AS returns\n WHERE\n returns.return_date >= '2025-01-01 00:00:00'\n AND returns.return_date < '2025-07-01 00:00:00'\n GROUP BY\n DATE_TRUNC(returns.return_date, MONTH)\n), _cm_time_spine__orders__id_count AS (\n SELECT\n DATE_TRUNC(orders.order_date, MONTH) AS `orders___order_date_month`,\n COUNT(orders.id) AS `orders___id_count`\n FROM orders AS orders\n WHERE\n orders.order_date >= '2025-01-01 00:00:00'\n AND orders.order_date < '2025-07-01 00:00:00'\n GROUP BY\n DATE_TRUNC(orders.order_date, MONTH)\n)\nSELECT\n _base.`time_spine___timestamp`,\n _cm_time_spine__orders__amount_sum.`orders___amount_sum` AS `time_spine___o`,\n _cm_time_spine__returns__amount_sum.`returns___amount_sum` AS `time_spine___r`,\n COALESCE(_cm_time_spine__orders__id_count.`orders___id_count`, 0) AS `time_spine___n`\nFROM _base\nLEFT JOIN _cm_time_spine__orders__amount_sum\n ON _base.`time_spine___timestamp` IS NOT DISTINCT FROM _cm_time_spine__orders__amount_sum.`orders___order_date_month`\nLEFT JOIN _cm_time_spine__returns__amount_sum\n ON _base.`time_spine___timestamp` IS NOT DISTINCT FROM _cm_time_spine__returns__amount_sum.`returns___return_date_month`\nLEFT JOIN _cm_time_spine__orders__id_count\n ON _base.`time_spine___timestamp` IS NOT DISTINCT FROM _cm_time_spine__orders__id_count.`orders___order_date_month`", "spine/two_facts::duckdb": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', time_spine.timestamp) AS \"time_spine.timestamp\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', CAST('2025-01-01 00:00:00' AS TIMESTAMP)) + (\n _seq.i\n ) * INTERVAL 1 MONTH AS \"timestamp\"\n FROM (\n SELECT\n i\n FROM RANGE(0, 7) AS _seq(i)\n ) AS _seq\n WHERE\n DATE_TRUNC('MONTH', CAST('2025-01-01 00:00:00' AS TIMESTAMP)) + (\n _seq.i\n ) * INTERVAL 1 MONTH < CAST('2025-07-01 00:00:00' AS TIMESTAMP)\n AND DATE_TRUNC('MONTH', CAST('2025-01-01 00:00:00' AS TIMESTAMP)) + (\n _seq.i + 1\n ) * INTERVAL 1 MONTH > CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n ) AS time_spine\n GROUP BY\n DATE_TRUNC('MONTH', time_spine.timestamp)\n), _cm_time_spine__orders__amount_sum AS (\n SELECT\n DATE_TRUNC('MONTH', orders.order_date) AS \"orders.order_date_month\",\n CAST(SUM(orders.amount) AS DOUBLE) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.order_date >= CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n AND orders.order_date < CAST('2025-07-01 00:00:00' AS TIMESTAMP)\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), _cm_time_spine__returns__amount_sum AS (\n SELECT\n DATE_TRUNC('MONTH', returns.return_date) AS \"returns.return_date_month\",\n CAST(SUM(returns.amount) AS DOUBLE) AS \"returns.amount_sum\"\n FROM returns AS returns\n WHERE\n returns.return_date >= CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n AND returns.return_date < CAST('2025-07-01 00:00:00' AS TIMESTAMP)\n GROUP BY\n DATE_TRUNC('MONTH', returns.return_date)\n), _cm_time_spine__orders__id_count AS (\n SELECT\n DATE_TRUNC('MONTH', orders.order_date) AS \"orders.order_date_month\",\n COUNT(orders.id) AS \"orders.id_count\"\n FROM orders AS orders\n WHERE\n orders.order_date >= CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n AND orders.order_date < CAST('2025-07-01 00:00:00' AS TIMESTAMP)\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n)\nSELECT\n _base.\"time_spine.timestamp\",\n _cm_time_spine__orders__amount_sum.\"orders.amount_sum\" AS \"time_spine.o\",\n _cm_time_spine__returns__amount_sum.\"returns.amount_sum\" AS \"time_spine.r\",\n COALESCE(_cm_time_spine__orders__id_count.\"orders.id_count\", 0) AS \"time_spine.n\"\nFROM _base\nLEFT JOIN _cm_time_spine__orders__amount_sum\n ON _base.\"time_spine.timestamp\" IS NOT DISTINCT FROM _cm_time_spine__orders__amount_sum.\"orders.order_date_month\"\nLEFT JOIN _cm_time_spine__returns__amount_sum\n ON _base.\"time_spine.timestamp\" IS NOT DISTINCT FROM _cm_time_spine__returns__amount_sum.\"returns.return_date_month\"\nLEFT JOIN _cm_time_spine__orders__id_count\n ON _base.\"time_spine.timestamp\" IS NOT DISTINCT FROM _cm_time_spine__orders__id_count.\"orders.order_date_month\"", "spine/two_facts::postgres": "WITH _base AS (\n SELECT\n DATE_TRUNC('MONTH', time_spine.timestamp) AS \"time_spine.timestamp\"\n FROM (\n SELECT\n DATE_TRUNC('MONTH', CAST('2025-01-01 00:00:00' AS TIMESTAMP)) + (\n _seq.i\n ) * INTERVAL '1 MONTH' AS \"timestamp\"\n FROM (\n SELECT\n i\n FROM GENERATE_SERIES(0, 6) AS _seq(i)\n ) AS _seq\n WHERE\n DATE_TRUNC('MONTH', CAST('2025-01-01 00:00:00' AS TIMESTAMP)) + (\n _seq.i\n ) * INTERVAL '1 MONTH' < CAST('2025-07-01 00:00:00' AS TIMESTAMP)\n AND DATE_TRUNC('MONTH', CAST('2025-01-01 00:00:00' AS TIMESTAMP)) + (\n _seq.i + 1\n ) * INTERVAL '1 MONTH' > CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n ) AS time_spine\n GROUP BY\n DATE_TRUNC('MONTH', time_spine.timestamp)\n), _cm_time_spine__orders__amount_sum AS (\n SELECT\n DATE_TRUNC('MONTH', orders.order_date) AS \"orders.order_date_month\",\n CAST(SUM(orders.amount) AS DOUBLE PRECISION) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.order_date >= CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n AND orders.order_date < CAST('2025-07-01 00:00:00' AS TIMESTAMP)\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n), _cm_time_spine__returns__amount_sum AS (\n SELECT\n DATE_TRUNC('MONTH', returns.return_date) AS \"returns.return_date_month\",\n CAST(SUM(returns.amount) AS DOUBLE PRECISION) AS \"returns.amount_sum\"\n FROM returns AS returns\n WHERE\n returns.return_date >= CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n AND returns.return_date < CAST('2025-07-01 00:00:00' AS TIMESTAMP)\n GROUP BY\n DATE_TRUNC('MONTH', returns.return_date)\n), _cm_time_spine__orders__id_count AS (\n SELECT\n DATE_TRUNC('MONTH', orders.order_date) AS \"orders.order_date_month\",\n COUNT(orders.id) AS \"orders.id_count\"\n FROM orders AS orders\n WHERE\n orders.order_date >= CAST('2025-01-01 00:00:00' AS TIMESTAMP)\n AND orders.order_date < CAST('2025-07-01 00:00:00' AS TIMESTAMP)\n GROUP BY\n DATE_TRUNC('MONTH', orders.order_date)\n)\nSELECT\n _base.\"time_spine.timestamp\",\n _cm_time_spine__orders__amount_sum.\"orders.amount_sum\" AS \"time_spine.o\",\n _cm_time_spine__returns__amount_sum.\"returns.amount_sum\" AS \"time_spine.r\",\n COALESCE(_cm_time_spine__orders__id_count.\"orders.id_count\", 0) AS \"time_spine.n\"\nFROM _base\nLEFT JOIN _cm_time_spine__orders__amount_sum\n ON _base.\"time_spine.timestamp\" IS NOT DISTINCT FROM _cm_time_spine__orders__amount_sum.\"orders.order_date_month\"\nLEFT JOIN _cm_time_spine__returns__amount_sum\n ON _base.\"time_spine.timestamp\" IS NOT DISTINCT FROM _cm_time_spine__returns__amount_sum.\"returns.return_date_month\"\nLEFT JOIN _cm_time_spine__orders__id_count\n ON _base.\"time_spine.timestamp\" IS NOT DISTINCT FROM _cm_time_spine__orders__id_count.\"orders.order_date_month\"", "spine/two_facts::sqlite": "WITH RECURSIVE _w__seq(i) AS (\n SELECT\n 0 AS i\n UNION ALL\n SELECT\n i + 1\n FROM _w__seq AS _seq\n WHERE\n i < 6\n), _base AS (\n SELECT\n STRFTIME('%Y-%m-01', time_spine.timestamp) AS \"time_spine.timestamp\"\n FROM (\n SELECT\n SLAYER_DATE_ADD(STRFTIME('%Y-%m-01', '2025-01-01 00:00:00'), _seq.i, 'month') AS \"timestamp\"\n FROM (\n SELECT\n i\n FROM _w__seq AS _seq\n ) AS _seq\n WHERE\n SLAYER_DATE_ADD(STRFTIME('%Y-%m-01', '2025-01-01 00:00:00'), _seq.i, 'month') < '2025-07-01'\n AND STRFTIME(\n '%Y-%m-%d %H:%M:%f',\n SLAYER_DATE_ADD(STRFTIME('%Y-%m-01', '2025-01-01 00:00:00'), _seq.i + 1, 'month')\n ) > STRFTIME('%Y-%m-%d %H:%M:%f', '2025-01-01 00:00:00')\n ) AS time_spine\n GROUP BY\n STRFTIME('%Y-%m-01', time_spine.timestamp)\n), _cm_time_spine__orders__amount_sum AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.order_date) AS \"orders.order_date_month\",\n CAST(SUM(orders.amount) AS REAL) AS \"orders.amount_sum\"\n FROM orders AS orders\n WHERE\n orders.order_date >= '2025-01-01' AND orders.order_date < '2025-07-01'\n GROUP BY\n STRFTIME('%Y-%m-01', orders.order_date)\n), _cm_time_spine__returns__amount_sum AS (\n SELECT\n STRFTIME('%Y-%m-01', returns.return_date) AS \"returns.return_date_month\",\n CAST(SUM(returns.amount) AS REAL) AS \"returns.amount_sum\"\n FROM returns AS returns\n WHERE\n returns.return_date >= '2025-01-01' AND returns.return_date < '2025-07-01'\n GROUP BY\n STRFTIME('%Y-%m-01', returns.return_date)\n), _cm_time_spine__orders__id_count AS (\n SELECT\n STRFTIME('%Y-%m-01', orders.order_date) AS \"orders.order_date_month\",\n COUNT(orders.id) AS \"orders.id_count\"\n FROM orders AS orders\n WHERE\n orders.order_date >= '2025-01-01' AND orders.order_date < '2025-07-01'\n GROUP BY\n STRFTIME('%Y-%m-01', orders.order_date)\n)\nSELECT\n _base.\"time_spine.timestamp\",\n _cm_time_spine__orders__amount_sum.\"orders.amount_sum\" AS \"time_spine.o\",\n _cm_time_spine__returns__amount_sum.\"returns.amount_sum\" AS \"time_spine.r\",\n COALESCE(_cm_time_spine__orders__id_count.\"orders.id_count\", 0) AS \"time_spine.n\"\nFROM _base\nLEFT JOIN _cm_time_spine__orders__amount_sum\n ON _base.\"time_spine.timestamp\" IS _cm_time_spine__orders__amount_sum.\"orders.order_date_month\"\nLEFT JOIN _cm_time_spine__returns__amount_sum\n ON _base.\"time_spine.timestamp\" IS _cm_time_spine__returns__amount_sum.\"returns.return_date_month\"\nLEFT JOIN _cm_time_spine__orders__id_count\n ON _base.\"time_spine.timestamp\" IS _cm_time_spine__orders__id_count.\"orders.order_date_month\"", diff --git a/tests/integration/test_dev2120_postgres.py b/tests/integration/test_dev2120_postgres.py new file mode 100644 index 000000000..6f1dfc59e --- /dev/null +++ b/tests/integration/test_dev2120_postgres.py @@ -0,0 +1,78 @@ +"""The portable Mode-B library on a real Postgres (spec: queries/scalar-functions, regex, json, mixed-type-coercion).""" + +import pytest + +from slayer.core.models import DatasourceConfig +from slayer.engine.ingestion import ingest_datasource +from slayer.engine.query_engine import SlayerQueryEngine +from slayer.sql import engine_factory +from slayer.storage.yaml_storage import YAMLStorage +from tests._dev2120_fixtures import ( + DOCS_ROWS, + LIB, + check_library, + check_native_json, + lib_model, + lib_query, + server_table_statements, +) + +pytest.importorskip("pytest_postgresql") + +from pytest_postgresql import factories # ALLOW(import-not-top): optional DB driver, gated by pytest.importorskip above + +postgresql_proc = factories.postgresql_proc(port=None) +postgresql = factories.postgresql("postgresql_proc") + + +@pytest.fixture +async def pg(postgresql, tmp_path): + cur = postgresql.cursor() + for stmt in server_table_statements(LIB, dialect="postgres"): + cur.execute(stmt) + cur.execute("CREATE TABLE docs (id INTEGER PRIMARY KEY, payload JSONB)") + cur.execute("CREATE TABLE docs_json (id INTEGER PRIMARY KEY, payload JSON)") + for table in ("docs", "docs_json"): + cur.executemany(f"INSERT INTO {table} VALUES (%s, %s)", DOCS_ROWS) + cur.execute("SELECT current_setting('server_version_num')") + version_num = int(cur.fetchone()[0]) + postgresql.commit() + info = postgresql.info + ds = DatasourceConfig(name="pg", type="postgres", host=info.host, port=info.port, database=info.dbname, + username=info.user, password="") + storage = YAMLStorage(base_dir=str(tmp_path)) + await storage.save_datasource(ds) + await storage.save_model(lib_model(data_source="pg")) + try: + for model in ingest_datasource(datasource=ds, include_tables=["docs", "docs_json"]): + await storage.save_model(model) + yield SlayerQueryEngine(storage=storage), version_num + finally: + engine_factory.invalidate_engine(ds) + + +@pytest.mark.integration +async def test_library(pg) -> None: + engine, version_num = pg + if version_num < 160000: + pytest.skip("the NULL-on-error cases need Postgres 16+") + await check_library(engine) + + +@pytest.mark.integration +@pytest.mark.parametrize("model", ["docs", "docs_json"]) +async def test_native_json_columns(pg, model: str) -> None: + await check_native_json(pg[0], model=model) + + +@pytest.mark.integration +async def test_author_cast_keeps_postgres_error(pg) -> None: + query = lib_query(filters=["CAST(num_txt AS INT) > 100"]) + with pytest.raises(Exception, match="(?i)invalid input syntax"): # noqa: B017 — Postgres's own error + await pg[0].execute(query) + + +@pytest.mark.integration +async def test_double_modulo_runs(pg) -> None: + resp = await pg[0].execute(lib_query("x % 2", filters=["id = 7"])) + assert float(resp.data[0]["lib.v"]) == -1.5 diff --git a/tests/integration/test_integration_bigquery.py b/tests/integration/test_integration_bigquery.py index 13933e13c..d05d459bb 100644 --- a/tests/integration/test_integration_bigquery.py +++ b/tests/integration/test_integration_bigquery.py @@ -13,17 +13,30 @@ import os import uuid +from datetime import datetime from pathlib import Path import pytest +from slayer.async_utils import run_sync from slayer.core.enums import DataType from slayer.core.models import DatasourceConfig +from slayer.core.query import SlayerQuery from slayer.engine.ingestion import ( ingest_datasource, ingest_datasource_idempotent, ) +from slayer.engine.query_engine import SlayerQueryEngine from slayer.storage.yaml_storage import YAMLStorage +from tests._dev2120_fixtures import ( + DOCS_ROWS, + LIB, + check_library, + check_native_json, + lib_model, + server_literal, + server_table_statements as dev2120_table_statements, +) from tests._reserved_alias_probe import ( BIGQUERY_KEYWORDS, keyword_universe, @@ -257,3 +270,61 @@ def fails(sql: str) -> bool: dialect="bigquery", words=keyword_universe(BIGQUERY_KEYWORDS), table=f"{dataset_id}.plain", column="x", fails=fails, workers=8, ) == [] + + +# --------------------------------------------------------------------------- +# Portable Mode-B library (spec: queries/scalar-functions, regex, json, mixed-type-coercion, string-matching) +# --------------------------------------------------------------------------- + + +@pytest.fixture(scope="module") +def bq_dev2120_storage(bq_dataset, tmp_path_factory): + client, dataset_id = bq_dataset + for stmt in dev2120_table_statements(LIB, dialect="bigquery", prefix=f"{dataset_id}."): + client.query(stmt).result() + rows = ", ".join(f"({rid}, PARSE_JSON({server_literal(doc, kind='TEXT', dialect='bigquery')}))" + for rid, doc in DOCS_ROWS) + client.query(f"CREATE TABLE {dataset_id}.docs (id INT64, payload JSON)").result() + client.query(f"INSERT INTO {dataset_id}.docs VALUES {rows}").result() + client.query(f"CREATE TABLE {dataset_id}.events (id INT64, zoned_ts TIMESTAMP, wall_ts DATETIME)").result() + client.query(f"INSERT INTO {dataset_id}.events VALUES {_EVENT_ROWS}").result() + ds = _ds_config(dataset_id) + storage = YAMLStorage(base_dir=str(tmp_path_factory.mktemp("bq_dev2120"))) + run_sync(storage.save_datasource(ds)) + run_sync(storage.save_model(lib_model(data_source=ds.name))) + for model in ingest_datasource(datasource=ds, include_tables=["docs", "events"]): + run_sync(storage.save_model(model)) + return storage + + +async def test_dev2120_library(bq_dev2120_storage) -> None: + await check_library(SlayerQueryEngine(storage=bq_dev2120_storage)) + + +async def test_dev2120_native_json_column(bq_dev2120_storage) -> None: + await check_native_json(SlayerQueryEngine(storage=bq_dev2120_storage)) + + +_EVENT_ROWS = ("(1, TIMESTAMP '2024-02-29 10:00:00 UTC', DATETIME '2024-02-29 10:00:00'), " + "(2, TIMESTAMP '2025-06-01 23:30:00 UTC', DATETIME '2025-06-01 23:30:00')") + + +async def test_dev2120_zoned_timestamp_column(bq_dev2120_storage) -> None: + model = await bq_dev2120_storage.get_model("events", data_source="bqtest") + db_types = {c.name: c.db_type for c in model.columns if c.name in ("zoned_ts", "wall_ts")} + assert db_types == {"zoned_ts": "TIMESTAMP", "wall_ts": None} + engine = SlayerQueryEngine(storage=bq_dev2120_storage) + for column in ("zoned_ts", "wall_ts"): + resp = await engine.execute(SlayerQuery.model_validate({ + "source_model": "events", "dimensions": ["id", {"expression": f"date_add({column}, 1, 'day')", "name": "v"}], + "filters": [f"{column} < now()", f"{column} > date_add(now(), -36500, 'day')"], + })) + got = {int(r["events.id"]): r["events.v"] for r in resp.data} + assert got == {1: datetime(2024, 3, 1, 10, 0), 2: datetime(2025, 6, 2, 23, 30)}, (column, resp.sql) + resp = await engine.execute(SlayerQuery.model_validate({ + "source_model": "events", + "dimensions": ["id", column, {"expression": f"month({column})", "name": "bucket"}], + })) + rows = {int(r["events.id"]): (r[f"events.{column}"], r["events.bucket"]) for r in resp.data} + assert rows == {1: (datetime(2024, 2, 29, 10, 0), datetime(2024, 2, 1)), + 2: (datetime(2025, 6, 1, 23, 30), datetime(2025, 6, 1))}, (column, resp.sql) diff --git a/tests/integration/test_integration_clickhouse.py b/tests/integration/test_integration_clickhouse.py index ad92f20bf..0148aff10 100644 --- a/tests/integration/test_integration_clickhouse.py +++ b/tests/integration/test_integration_clickhouse.py @@ -31,6 +31,7 @@ from decimal import Decimal import pytest +import requests import sqlalchemy as sa from sqlalchemy.exc import DBAPIError @@ -75,6 +76,15 @@ matrix_query, server_seed_statements, ) +from tests._dev2120_fixtures import ( + DOCS_ROWS, + LIB, + check_library, + check_native_json, + lib_model, + server_literal, + server_table_statements as dev2120_table_statements, +) from tests._engine_helpers import disposable_engine from tests._reserved_alias_probe import keyword_universe, sa_statement_fails, unquoted_alias_failures @@ -1864,3 +1874,51 @@ def test_every_clickhouse_alias_failure_is_quoted(clickhouse_container) -> None: ) == [] finally: _drop_module_db(clickhouse_container, db_name) + + +# --------------------------------------------------------------------------- +# Portable Mode-B library (spec: queries/scalar-functions, regex, json, mixed-type-coercion, string-matching) +# --------------------------------------------------------------------------- + +def _http(clickhouse_container, db_name: str, sql: str, **settings: str) -> None: + """Run one statement over HTTP, where per-query server settings ride as URL parameters.""" + host = clickhouse_container.get_container_host_ip() + port = int(clickhouse_container.get_exposed_port(8123)) + user = getattr(clickhouse_container, "username", "default") or "default" + password = getattr(clickhouse_container, "password", "") or "" + resp = requests.post(f"http://{host}:{port}/", params={"database": db_name, **settings}, data=sql.encode(), + auth=(user, password), timeout=60) + assert resp.ok, resp.text + + +@pytest.fixture(scope="module") +def _clickhouse_dev2120_storage(clickhouse_container, tmp_path_factory): + db_name = _create_module_db(clickhouse_container) + try: + with disposable_engine(_ds_url_for_db(clickhouse_container, db_name)) as engine: + with engine.begin() as conn: + for stmt in dev2120_table_statements(LIB, dialect="clickhouse"): + conn.execute(sa.text(stmt)) + _http(clickhouse_container, db_name, "CREATE TABLE docs (id Int32, payload JSON) ENGINE = MergeTree ORDER BY id", + allow_experimental_json_type="1") + rows = ", ".join(f"({rid}, {server_literal(doc or '{}', kind='TEXT', dialect='clickhouse')})" + for rid, doc in DOCS_ROWS) + _http(clickhouse_container, db_name, f"INSERT INTO docs VALUES {rows}", allow_experimental_json_type="1") + ds = _ds_config(clickhouse_container, db_name) + storage = YAMLStorage(base_dir=str(tmp_path_factory.mktemp("clickhouse_dev2120"))) + run_sync(storage.save_datasource(ds)) + run_sync(storage.save_model(lib_model(data_source="testclickhouse"))) + for model in ingest_datasource(datasource=ds, include_tables=["docs"]): + run_sync(storage.save_model(model)) + yield storage + finally: + _drop_module_db(clickhouse_container, db_name) + + +@pytest.mark.integration +class TestClickHousePortableLibrary: + async def test_library(self, _clickhouse_dev2120_storage) -> None: + await check_library(SlayerQueryEngine(storage=_clickhouse_dev2120_storage)) + + async def test_native_json_column(self, _clickhouse_dev2120_storage) -> None: + await check_native_json(SlayerQueryEngine(storage=_clickhouse_dev2120_storage)) diff --git a/tests/integration/test_integration_mysql.py b/tests/integration/test_integration_mysql.py index 32bfe35e4..d36199c1e 100644 --- a/tests/integration/test_integration_mysql.py +++ b/tests/integration/test_integration_mysql.py @@ -64,6 +64,15 @@ dev2101_models, seed_server as dev2101_seed_server, ) +from tests._dev2120_fixtures import ( + DOCS_ROWS, + LIB, + check_library, + check_native_json, + lib_model, + lib_query, + server_table_statements as dev2120_table_statements, +) from tests.integration._consecutive_periods_calendar import ( CALENDAR_CASES, assert_calendar_streak, @@ -1627,3 +1636,46 @@ async def test_try_cast(self, _mysql_dev2101_storage) -> None: async def test_filtered_aggregations(self, _mysql_dev2101_storage) -> None: await check_filtered_aggregations(SlayerQueryEngine(storage=_mysql_dev2101_storage)) + + +# --------------------------------------------------------------------------- +# Portable Mode-B library (spec: queries/scalar-functions, regex, json, mixed-type-coercion, string-matching) +# --------------------------------------------------------------------------- + +@pytest.fixture(scope="module") +def _mysql_dev2120_storage(mysql_container, tmp_path_factory): + db_name = _create_module_db(mysql_container) + try: + conn = _admin_connect(mysql_container, dbname=db_name) + try: + with conn.cursor() as cur: + for stmt in dev2120_table_statements(LIB, dialect="mysql"): + cur.execute(stmt) + cur.execute("CREATE TABLE docs (id INTEGER PRIMARY KEY, payload JSON)") + cur.executemany("INSERT INTO docs VALUES (%s, %s)", DOCS_ROWS) + finally: + conn.close() + ds = _ds_config(mysql_container, db_name) + storage = YAMLStorage(base_dir=str(tmp_path_factory.mktemp("mysql_dev2120"))) + run_sync(storage.save_datasource(ds)) + run_sync(storage.save_model(lib_model(data_source="testmysql"))) + for model in ingest_datasource(datasource=ds, include_tables=["docs"]): + run_sync(storage.save_model(model)) + yield storage + finally: + _drop_module_db(mysql_container, db_name) + + +@pytest.mark.integration +class TestMySQLPortableLibrary: + async def test_library(self, _mysql_dev2120_storage) -> None: + await check_library(SlayerQueryEngine(storage=_mysql_dev2120_storage)) + + async def test_native_json_column(self, _mysql_dev2120_storage) -> None: + await check_native_json(SlayerQueryEngine(storage=_mysql_dev2120_storage)) + + async def test_comparisons_follow_the_column_collation(self, _mysql_dev2120_storage) -> None: + engine = SlayerQueryEngine(storage=_mysql_dev2120_storage) + for filt, expected in (("word = 'ada'", {3, 4}), ("word IN ('paid')", {1, 2}), ("word LIKE 'ada%'", {3, 4})): + resp = await engine.execute(lib_query(filters=[filt])) + assert {int(r["lib.id"]) for r in resp.data} == expected, (filt, resp.sql) diff --git a/tests/integration/test_integration_snowflake.py b/tests/integration/test_integration_snowflake.py index 24b4dde18..f602d5aec 100644 --- a/tests/integration/test_integration_snowflake.py +++ b/tests/integration/test_integration_snowflake.py @@ -16,6 +16,7 @@ import pathlib import tomllib import uuid +from typing import NoReturn import pytest import sqlalchemy as sa @@ -34,6 +35,15 @@ from slayer.engine.query_engine import SlayerQueryEngine from slayer.sql import client, engine_factory from slayer.storage.yaml_storage import YAMLStorage +from tests._dev2120_fixtures import ( + DOCS_ROWS, + LIB, + check_library, + check_native_json, + lib_model, + server_literal, + server_table_statements as dev2120_table_statements, +) from tests._reserved_alias_probe import ( SNOWFLAKE_KEYWORDS, keyword_universe, @@ -51,11 +61,13 @@ _TOML_PATH = pathlib.Path("~/.snowflake/connections.toml").expanduser() _CONNECTION_NAME = os.environ.get("SLAYER_SNOWFLAKE_CONNECTION", "slayer_test") +# Set by CI when the secret is present: an unreachable Snowflake fails instead of skipping. +_REQUIRED = os.environ.get("SLAYER_SNOWFLAKE_REQUIRED") == "1" pytestmark = [ pytest.mark.integration, pytest.mark.skipif( - not _TOML_PATH.is_file(), + not _TOML_PATH.is_file() and not _REQUIRED, reason=f"{_TOML_PATH} not present; skipping Snowflake live tests", ), ] @@ -64,6 +76,8 @@ def _load_profile() -> dict: """Read the named profile from connections.toml. Returns {} if the profile is absent; tests using this surface their own skip reason.""" + if not _TOML_PATH.is_file(): + return {} with open(_TOML_PATH, "rb") as f: data = tomllib.load(f) profile = data.get(_CONNECTION_NAME) @@ -72,10 +86,16 @@ def _load_profile() -> dict: return profile +def _unavailable(reason: str) -> NoReturn: + if _REQUIRED: + pytest.fail(reason) + pytest.skip(reason) + + def _profile_or_skip() -> dict: profile = _load_profile() if not profile: - pytest.skip( + _unavailable( f"Snowflake profile '{_CONNECTION_NAME}' not found in {_TOML_PATH}; " f"set $SLAYER_SNOWFLAKE_CONNECTION or add a [{_CONNECTION_NAME}] profile." ) @@ -100,7 +120,7 @@ def sf_transient_schema(): try: conn = snowflake.connector.connect(connection_name=_CONNECTION_NAME) except Exception as exc: - pytest.skip(f"Could not connect to Snowflake via '{_CONNECTION_NAME}': {exc}") + _unavailable(f"Could not connect to Snowflake via '{_CONNECTION_NAME}': {exc}") return # for type checkers schema_name = f"SLAYER_TEST_{uuid.uuid4().hex[:12].upper()}" db_name = profile.get("database") @@ -848,3 +868,46 @@ def test_every_snowflake_alias_failure_is_quoted(sf_engine) -> None: dialect="snowflake", words=keyword_universe(SNOWFLAKE_KEYWORDS), table="regions", column="id", fails=sa_statement_fails(sf_engine), workers=8, ) == [] + + +# --------------------------------------------------------------------------- +# Portable Mode-B library (spec: queries/scalar-functions, regex, json, mixed-type-coercion, string-matching) +# --------------------------------------------------------------------------- + + +@pytest.fixture +def sf_dev2120_storage(sf_transient_schema: str, sf_datasource: DatasourceConfig, tmp_path): + conn = snowflake.connector.connect(connection_name=_CONNECTION_NAME) + cur = conn.cursor() + try: + cur.execute(f"USE SCHEMA {sf_transient_schema}") + for stmt in dev2120_table_statements(LIB, dialect="snowflake"): + cur.execute(stmt) + cur.execute("CREATE TABLE docs (id NUMBER(38,0), payload VARIANT)") + rows = ", ".join(f"({rid}, {server_literal(doc, kind='TEXT', dialect='snowflake')})" for rid, doc in DOCS_ROWS) + cur.execute(f"INSERT INTO docs SELECT column1, PARSE_JSON(column2) FROM VALUES {rows}") + conn.commit() + storage = YAMLStorage(base_dir=str(tmp_path)) + run_sync(storage.save_datasource(sf_datasource)) + base = lib_model(data_source="sf_test") + run_sync(storage.save_model(base.model_copy(update={ + "columns": [c.model_copy(update={"sql": c.name}) for c in base.columns]}))) + for model in ingest_datasource(datasource=sf_datasource, include_tables=["docs"]): + run_sync(storage.save_model(model)) + yield storage + finally: + try: + cur.execute("DROP TABLE IF EXISTS lib") + cur.execute("DROP TABLE IF EXISTS docs") + conn.commit() + finally: + cur.close() + conn.close() + + +def test_dev2120_library(sf_dev2120_storage) -> None: + run_sync(check_library(SlayerQueryEngine(storage=sf_dev2120_storage))) + + +def test_dev2120_variant_column(sf_dev2120_storage) -> None: + run_sync(check_native_json(SlayerQueryEngine(storage=sf_dev2120_storage))) diff --git a/tests/integration/test_integration_sqlserver.py b/tests/integration/test_integration_sqlserver.py index e55af9b98..22ca4ba55 100644 --- a/tests/integration/test_integration_sqlserver.py +++ b/tests/integration/test_integration_sqlserver.py @@ -103,6 +103,13 @@ dev2101_models, seed_server as dev2101_seed_server, ) +from tests._dev2120_fixtures import ( + LIB, + REGEX_NAMES, + check_library, + lib_model, + server_table_statements as dev2120_table_statements, +) from tests.integration._consecutive_periods_calendar import ( CALENDAR_CASES, assert_calendar_streak, @@ -1651,3 +1658,49 @@ async def test_try_cast(self, _sqlserver_dev2101_storage) -> None: async def test_filtered_aggregations(self, _sqlserver_dev2101_storage) -> None: await check_filtered_aggregations(SlayerQueryEngine(storage=_sqlserver_dev2101_storage)) + + +# --------------------------------------------------------------------------- +# Portable Mode-B library (spec: queries/scalar-functions, regex, mixed-type-coercion, string-matching) +# --------------------------------------------------------------------------- + +@pytest.fixture(scope="module") +def sqlserver_2025_container(): + """SQL Server 2025, the first release with the regex functions.""" + with SqlServerContainer("mcr.microsoft.com/mssql/server:2025-latest", password=_SA_PASSWORD) as c: + yield c + + +def _dev2120_storage(container, tmp_path_factory, *, label: str): + db_name = _create_module_db(container) + try: + with disposable_engine(_db_url(container, db_name)) as engine: + with engine.begin() as conn: + for stmt in dev2120_table_statements(LIB, dialect="tsql"): + conn.execute(sa.text(stmt)) + storage = YAMLStorage(base_dir=str(tmp_path_factory.mktemp(f"sqlserver_dev2120_{label}"))) + run_sync(storage.save_datasource(_ds_config(container, db_name))) + run_sync(storage.save_model(lib_model(data_source="testmssql"))) + yield storage + finally: + _drop_module_db(container, db_name) + + +@pytest.fixture(scope="module") +def _sqlserver_2022_dev2120_storage(sqlserver_container, tmp_path_factory): + yield from _dev2120_storage(sqlserver_container, tmp_path_factory, label="2022") + + +@pytest.fixture(scope="module") +def _sqlserver_2025_dev2120_storage(sqlserver_2025_container, tmp_path_factory): + yield from _dev2120_storage(sqlserver_2025_container, tmp_path_factory, label="2025") + + +@pytest.mark.integration +class TestSQLServerPortableLibrary: + async def test_library_on_2022_refuses_regex(self, _sqlserver_2022_dev2120_storage) -> None: + await check_library(SlayerQueryEngine(storage=_sqlserver_2022_dev2120_storage), gated=REGEX_NAMES, + refusal="2025") + + async def test_library_on_2025(self, _sqlserver_2025_dev2120_storage) -> None: + await check_library(SlayerQueryEngine(storage=_sqlserver_2025_dev2120_storage)) diff --git a/tests/integration/test_integration_trino.py b/tests/integration/test_integration_trino.py index 30710da55..ec9b58527 100644 --- a/tests/integration/test_integration_trino.py +++ b/tests/integration/test_integration_trino.py @@ -43,6 +43,12 @@ server_seed_statements, sql_literal, ) +from tests._dev2120_fixtures import ( + LIB, + check_library, + lib_model, + server_table_statements as dev2120_table_statements, +) from tests._engine_helpers import disposable_engine from tests._reserved_alias_probe import keyword_universe, sa_statement_fails, unquoted_alias_failures from tests.integration._consecutive_periods_calendar import ( @@ -1272,3 +1278,23 @@ def test_every_trino_alias_failure_is_quoted(trino_container) -> None: dialect="trino", words=keyword_universe(), table="kw_probe", column="a", fails=sa_statement_fails(engine), workers=8, ) == [] + + +# --------------------------------------------------------------------------- +# Portable Mode-B library (spec: queries/scalar-functions, regex, json, mixed-type-coercion, string-matching) +# --------------------------------------------------------------------------- + + +@pytest.fixture(scope="module") +def _trino_dev2120_storage(trino_container, tmp_path_factory): + with _seeded_schema(trino_container, dev2120_table_statements(LIB, dialect="trino")) as schema: + yield _storage( + str(tmp_path_factory.mktemp("trino_dev2120")), _ds_config(trino_container, schema), + [lib_model(data_source=_DS)], + ) + + +@pytest.mark.integration +class TestTrinoPortableLibrary: + async def test_library(self, _trino_dev2120_storage) -> None: + await check_library(SlayerQueryEngine(storage=_trino_dev2120_storage)) diff --git a/tests/integration/test_notebooks.py b/tests/integration/test_notebooks.py index 800a93257..fa7a92b6f 100644 --- a/tests/integration/test_notebooks.py +++ b/tests/integration/test_notebooks.py @@ -166,6 +166,7 @@ def _bootstrap_failure_is_transient(error_text: str) -> bool: r"broken pipe", r"could not establish", r"failed to (?:connect|download)", + r"remote file has changed", # CDN edges serving different ETags mid-read ) # httpfs transport errors DuckDB emits without naming the URL, but which can only diff --git a/tests/test_dev1737_date_arith_regressions.py b/tests/test_dev1737_date_arith_regressions.py index b7e75c9d9..ea4154c6f 100644 --- a/tests/test_dev1737_date_arith_regressions.py +++ b/tests/test_dev1737_date_arith_regressions.py @@ -111,14 +111,13 @@ async def test_consecutive_periods_over_date_column( @pytest.mark.parametrize("dim", ["d", "d_expr", "ts"]) # DATE, DATETIME and TIMESTAMP buckets @pytest.mark.parametrize("formula,comparison", [ ("consecutive_periods(sum(v) > 0)", - "CAST(`_cp_prev_ev___x` AS TIMESTAMP) = " - "CAST(DATETIME_ADD(CAST(CAST(`ev___{dim}` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP)"), + "CAST(`_cp_prev_ev___x` AS DATETIME) = DATETIME_ADD(CAST(`ev___{dim}` AS DATETIME), INTERVAL -1 MONTH)"), ("time_shift(v:sum, -1, 'month')", - "CAST(DATETIME_ADD(CAST(CAST(base.`ev___{dim}` AS TIMESTAMP) AS DATETIME), INTERVAL -1 MONTH) AS TIMESTAMP) " - "IS NOT DISTINCT FROM CAST(shifted_x.`ev___{dim}` AS TIMESTAMP)"), + "DATETIME_ADD(CAST(base.`ev___{dim}` AS DATETIME), INTERVAL -1 MONTH) " + "IS NOT DISTINCT FROM CAST(shifted_x.`ev___{dim}` AS DATETIME)"), ]) -async def test_bigquery_bucket_comparisons_are_timestamps(dim: str, formula: str, comparison: str) -> None: - # BigQuery compares none of DATE / DATETIME / TIMESTAMP with another; buckets meet as TIMESTAMP. +async def test_bigquery_bucket_comparisons_are_datetimes(dim: str, formula: str, comparison: str) -> None: + # BigQuery compares none of DATE / DATETIME / TIMESTAMP with another; buckets meet as DATETIME. model = _ev_model() model.columns.append(Column(name="d_expr", sql="DATE(ts)", type=DataType.DATE)) sql = await _engine_generate(query=SlayerQuery.model_validate({ diff --git a/tests/test_dev1744_value_expr.py b/tests/test_dev1744_value_expr.py index 845894cbf..aa09cb25d 100644 --- a/tests/test_dev1744_value_expr.py +++ b/tests/test_dev1744_value_expr.py @@ -817,16 +817,16 @@ def test_round_keeps_the_dev1576_postgres_cast(self) -> None: assert "DECIMAL" in out.upper(), out def test_like_stays_the_sql_operator(self) -> None: - """``like(value, pattern)`` is the one allowlist member that is an - OPERATOR, not a function call. Both legacy paths special-case it; the - unified renderer keeps that.""" + """``like(value, pattern)`` is an OPERATOR, not a function call, with the backslash + escape of the one LIKE pattern language.""" key = ScalarCallKey( name="like", args=(ColumnKey(leaf="label"), LiteralKey(value="x%")), ) out = render_value_key(key=key, ctx=_filter_ctx("postgres")) - assert isinstance(out, exp.Like) - assert _sql(out) == "orders.label LIKE 'x%'" + assert isinstance(out, exp.Escape) + assert isinstance(out.this, exp.Like) + assert _sql(out) == "orders.label LIKE 'x%' ESCAPE '\\'" def test_nested_scalar_calls_use_one_policy_throughout(self) -> None: """The policy applies at every depth — a nested call must not fall back diff --git a/tests/test_dev1753_last_four_scalars.py b/tests/test_dev1753_last_four_scalars.py index 0cbfc342c..74556cbd3 100644 --- a/tests/test_dev1753_last_four_scalars.py +++ b/tests/test_dev1753_last_four_scalars.py @@ -1,15 +1,13 @@ -"""DEV-1753: admit the last four parser-only scalars — greatest, least, trunc, mod. +"""Admit the last four parser-only scalars — greatest, least, trunc, mod. Closes the parser/binder allowlist divergence pinned by ``tests/test_dev1744_value_expr.py::TestParserAndBinderScalarSetsAgree``. After this change ``SCALAR_PASSTHROUGH - SCALAR_FUNCTIONS == set()``. -Ratified decisions (DEV-1753 decision trail, git history): -* ``greatest`` / ``least`` — the NULL divergence is RATIFIED, not normalised: - SQLite emits scalar ``MAX(a,b)`` / ``MIN(a,b)`` (propagates NULL), every - GREATEST-native backend ignores NULLs (Snowflake via ``..._IGNORE_NULLS``). - Witnessed live on SQLite (propagate, here) and DuckDB (ignore, in - ``tests/integration/test_integration_duckdb.py``). +Ratified decisions (decision trail, git history): +* ``greatest`` / ``least`` — ignore NULL arguments on every backend: a + NULL-propagating form (SQLite scalar ``MAX`` / ``MIN``, MySQL, ClickHouse, + BigQuery) takes one ``COALESCE`` per argument, Snowflake ``..._IGNORE_NULLS``. * ``trunc`` — 1-arg only; the 2-arg form silently drops the digits on SQLite. * ``mod`` — routed through the ``%`` composer so complex operands are parenthesised correctly; a raw ``exp.Mod`` mis-groups ``mod(a+b, c)``. @@ -119,30 +117,30 @@ def test_ltrim_rtrim_stay_one_arg(self) -> None: _GREATEST_EXPECTED = { - "sqlite": "MAX(a, b)", + "sqlite": "MAX(COALESCE(a, b), COALESCE(b, a))", "postgres": "GREATEST(a, b)", "duckdb": "GREATEST(a, b)", - "mysql": "GREATEST(a, b)", - "clickhouse": "GREATEST(a, b)", + "mysql": "GREATEST(COALESCE(a, b), COALESCE(b, a))", + "clickhouse": "greatest(COALESCE(a, b), COALESCE(b, a))", "tsql": "GREATEST(a, b)", "snowflake": "GREATEST_IGNORE_NULLS(a, b)", - "bigquery": "GREATEST(a, b)", + "bigquery": "GREATEST(COALESCE(a, b), COALESCE(b, a))", } _LEAST_EXPECTED = { - "sqlite": "MIN(a, b)", + "sqlite": "MIN(COALESCE(a, b), COALESCE(b, a))", "postgres": "LEAST(a, b)", "duckdb": "LEAST(a, b)", - "mysql": "LEAST(a, b)", - "clickhouse": "LEAST(a, b)", + "mysql": "LEAST(COALESCE(a, b), COALESCE(b, a))", + "clickhouse": "least(COALESCE(a, b), COALESCE(b, a))", "tsql": "LEAST(a, b)", "snowflake": "LEAST_IGNORE_NULLS(a, b)", - "bigquery": "LEAST(a, b)", + "bigquery": "LEAST(COALESCE(a, b), COALESCE(b, a))", } _TRUNC_EXPECTED = { "sqlite": "TRUNC(x)", "postgres": "TRUNC(x)", "duckdb": "TRUNC(x)", - # MySQL has no single-arg TRUNCATE; SLayer adds the ``, 0`` (DEV-1753). + # MySQL has no single-arg TRUNCATE; SLayer adds the ``, 0``. "mysql": "TRUNCATE(x, 0)", "clickhouse": "trunc(x)", "tsql": "ROUND(x, 0, 1)", @@ -182,7 +180,7 @@ def test_mod_emits_percent_or_bigquery_func(self, dialect) -> None: # =========================================================================== -# C. mod precedence / round-trip (the DEV-1744 `%` re-verification). +# C. mod precedence / round-trip (the `%` re-verification). # =========================================================================== @@ -338,10 +336,9 @@ async def test_arity_errors_surface_at_bind_time( class TestGreatestLeastNullSemanticsSqlite: - """The ratified divergence, witnessed live on SQLite (the default store): - scalar ``MAX(a,b)`` / ``MIN(a,b)`` PROPAGATE NULL. Grouped by ``id`` so each - aggregate is over one row, isolating the scalar's NULL behavior. The - NULL-ignoring side is witnessed on DuckDB in the integration suite.""" + """Witnessed live on SQLite (the default store): NULL arguments are ignored, NULL only + when every argument is NULL. Grouped by ``id`` so each aggregate is over one row, + isolating the scalar's NULL behavior.""" async def _values(self, engine, formula): resp = await engine.execute( @@ -353,10 +350,10 @@ async def _values(self, engine, formula): ) return {int(r["orders.id"]): r["orders.g"] for r in resp.data} - async def test_greatest_propagates_null(self, engine) -> None: + async def test_greatest_ignores_null(self, engine) -> None: got = await self._values(engine, "greatest(amount:max, disc:max)") - assert got == {1: None, 2: 20.0, 3: None, 4: None} + assert got == {1: 10.0, 2: 20.0, 3: 30.0, 4: None} - async def test_least_propagates_null(self, engine) -> None: + async def test_least_ignores_null(self, engine) -> None: got = await self._values(engine, "least(amount:max, disc:max)") - assert got == {1: None, 2: 5.0, 3: None, 4: None} + assert got == {1: 10.0, 2: 5.0, 3: 30.0, 4: None} diff --git a/tests/test_dev1902_join_key_spelling.py b/tests/test_dev1902_join_key_spelling.py index 7ea92f1ba..4a303c574 100644 --- a/tests/test_dev1902_join_key_spelling.py +++ b/tests/test_dev1902_join_key_spelling.py @@ -199,7 +199,6 @@ def _customer_totals(*, key: str = "customer_id") -> SlayerModel: class TestQueryBackedJoinKeys: - @pytest.mark.xfail(strict=True, reason="DEV-1918: joins on a query-backed model are not traversable") async def test_join_on_backing_output_column_executes(self, all_renamed): await all_renamed.save_model(_customer_totals()) resp = await all_renamed.execute(_query( diff --git a/tests/test_dev2073_join_edge_identity.py b/tests/test_dev2073_join_edge_identity.py index e14b2ca5e..0fbd6bc9b 100644 --- a/tests/test_dev2073_join_edge_identity.py +++ b/tests/test_dev2073_join_edge_identity.py @@ -6,7 +6,9 @@ import pytest -from slayer.core.join_edges import JoinEdgeRef, edge_reference, relationship_signature, resolve_join_ref +from slayer.core.enums import JoinCardinality, JoinType +from slayer.core.join_edges import JoinEdgeRef, edge_reference, relationship_signature, resolve_join_ref, same_edge +from slayer.core.models import ModelJoin from slayer.engine.query_engine import SlayerQueryEngine from tests._dev2073_fixtures import ( @@ -88,6 +90,24 @@ def test_differs_on_key_pairs(self) -> None: assert billing != shipping +class TestSameEdge: + def test_ignores_metadata_and_pair_order(self) -> None: + stored = ModelJoin(target_model="t", join_pairs=[["a", "x"], ["b", "y"]], description="stored", meta={"k": 1}) + repeat = ModelJoin(target_model="t", join_pairs=[["b", "y"], ["a", "x"]]) + assert same_edge(stored, repeat) + + @pytest.mark.parametrize("change", [ + {"name": "other"}, + {"join_type": JoinType.INNER}, + {"cardinality": JoinCardinality.MANY_TO_ONE}, + {"join_pairs": [["a", "y"]]}, + {"target_model": "u"}, + ]) + def test_any_semantic_field_differing_is_another_edge(self, change: dict) -> None: + stored = ModelJoin(target_model="t", join_pairs=[["a", "x"]]) + assert not same_edge(stored, stored.model_copy(update=change)) + + class TestEngineRemovalByExactReference: async def test_removes_exactly_the_referenced_join(self) -> None: async with model_store(addresses_model(), orders_with(*unnamed_pair())) as storage: diff --git a/tests/test_dev2120_bigquery_timestamps.py b/tests/test_dev2120_bigquery_timestamps.py new file mode 100644 index 000000000..56d353d10 --- /dev/null +++ b/tests/test_dev2120_bigquery_timestamps.py @@ -0,0 +1,218 @@ +"""BigQuery: SLayer's TIMESTAMP is naive DATETIME; a zoned TIMESTAMP column compares through a cast of the other side.""" + +from __future__ import annotations + +from unittest.mock import MagicMock, patch + +import pytest +import sqlalchemy as sa + +from slayer.core.enums import DataType +from slayer.core.models import Column, ModelJoin, SlayerModel +from slayer.core.query import SlayerQuery +from slayer.engine import ingestion +from slayer.engine.introspect_utils import _get_columns_fallback +from tests._dev1840_fixtures import dev1840_models, signup_month_td +from tests._dev1919_fixtures import WINDOWED_PARAM +from tests._dev2015_fixtures import JAN_MAR, TWO_FACTS, spine_models, spine_td +from tests._dev2120_fixtures import emit_lib, lib_model, lib_query +from tests._engine_helpers import _engine_generate + + +def _zoned_lib() -> SlayerModel: + base = lib_model() + return base.model_copy(update={"columns": [ + c.model_copy(update={"db_type": "TIMESTAMP"}) if c.name == "ts" else c for c in base.columns]}) + + +async def _sql(expr: str, *, dialect: str = "bigquery", filtered: bool = False, zoned: bool = False) -> str: + query = lib_query(filters=[expr]) if filtered else lib_query(expr) + sql = await emit_lib(query, dialect=dialect, models=[_zoned_lib()] if zoned else None) + return " ".join(sql.upper().split()) + + +class TestNaiveValues: + async def test_now_is_current_datetime(self) -> None: + sql = await _sql("now()") + assert "CURRENT_DATETIME()" in sql, sql + assert "CURRENT_TIMESTAMP" not in sql, sql + + @pytest.mark.parametrize("expr", ["TRY_CAST(code AS TIMESTAMP)", "json_value(payload, '$.t' RETURNING TIMESTAMP)"]) + async def test_portable_timestamp_casts_read_as_datetime(self, expr: str) -> None: + sql = await _sql(expr) + assert "AS DATETIME)" in sql, sql + assert "AS TIMESTAMP)" not in sql, sql + + async def test_author_cast_is_the_databases_own(self) -> None: + assert "CAST(LIB.CODE AS TIMESTAMP)" in await _sql("CAST(code AS TIMESTAMP)") + + @pytest.mark.parametrize("unit", ["hour", "day", "week", "month"]) + async def test_date_add_stays_datetime(self, unit: str) -> None: + sql = await _sql(f"date_add(ts, 1, '{unit}')") + assert "DATETIME_ADD(CAST(LIB.TS AS DATETIME)" in sql, sql + assert "TIMESTAMP" not in sql, sql + + async def test_sub_day_date_diff_uses_datetime_functions(self) -> None: + sql = await _sql("date_diff('hour', ts, now())") + assert "DATETIME_DIFF(" in sql, sql + assert "DATETIME_TRUNC(" in sql, sql + assert "TIMESTAMP_" not in sql, sql + + async def test_naive_column_compares_with_now_directly(self) -> None: + assert "WHERE LIB.TS < CURRENT_DATETIME()" in await _sql("ts < now()", filtered=True) + + +class TestZonedColumn: + @pytest.mark.parametrize(("expr", "where"), [ + ("ts < now()", "LIB.TS < CAST(CURRENT_DATETIME() AS TIMESTAMP)"), + ("now() > ts", "CAST(CURRENT_DATETIME() AS TIMESTAMP) > LIB.TS"), + ("ts < date_add(now(), -1, 'day')", "LIB.TS < CAST(DATETIME_ADD(CURRENT_DATETIME(), INTERVAL -1 DAY) AS TIMESTAMP)"), + ]) + async def test_other_side_converts_and_the_column_stays_bare(self, expr: str, where: str) -> None: + assert f"WHERE {where}" in await _sql(expr, filtered=True, zoned=True) + + async def test_temporal_literal_keeps_its_iso_text(self) -> None: + sql = await _sql("ts > TIMESTAMP '2024-01-01 10:00'", filtered=True, zoned=True) + assert "WHERE LIB.TS > '2024-01-01 10:00:00'" in sql, sql + + async def test_column_against_itself_is_untouched(self) -> None: + assert "WHERE LIB.TS = LIB.TS" in await _sql("ts = ts", filtered=True, zoned=True) + + async def test_a_stage_reads_the_zoned_column_naive(self) -> None: + s1 = SlayerQuery.model_validate({"name": "s1", "source_model": "lib", "dimensions": ["id", "ts"]}) + root = SlayerQuery.model_validate({"source_model": "s1", "dimensions": ["id"], "filters": ["ts < now()"]}) + sql = " ".join((await _engine_generate(query=[s1, root], model=_zoned_lib(), dialect="bigquery")).upper().split()) + assert "CAST(LIB.TS AS DATETIME) AS `LIB___TS`" in sql, sql + assert "WHERE S1.TS < CURRENT_DATETIME()" in sql, sql + + async def test_other_dialects_ignore_the_db_type(self) -> None: + zoned = await _sql("ts < now()", dialect="postgres", filtered=True, zoned=True) + assert zoned == await _sql("ts < now()", dialect="postgres", filtered=True) + + +class TestZonedColumnReadsNaive: + @pytest.mark.parametrize(("expr", "fragment"), [ + ("ts", "CAST(LIB.TS AS DATETIME) AS `LIB___V`"), + ("coalesce(ts, now())", "COALESCE(CAST(LIB.TS AS DATETIME), CURRENT_DATETIME())"), + ("date_trunc('month', ts)", "DATE_TRUNC(CAST(LIB.TS AS DATETIME), MONTH)"), + ]) + async def test_value_positions(self, expr: str, fragment: str) -> None: + assert fragment in await _sql(expr, zoned=True) + + async def test_time_dimension_bucket_and_date_range(self) -> None: + query = SlayerQuery.model_validate({"source_model": "lib", "measures": [{"formula": "*:count"}], "time_dimensions": [ + {"dimension": "ts", "granularity": "month", "date_range": ["2024-01-01", "2024-03-31"]}]}) + sql = " ".join((await _engine_generate(query=query, model=_zoned_lib(), dialect="bigquery")).upper().split()) + assert "DATE_TRUNC(CAST(LIB.TS AS DATETIME), MONTH)" in sql, sql + assert "LIB.TS >= '2024-01-01 00:00:00'" in sql, sql + + @pytest.mark.parametrize(("formula", "fragment"), [ + ("max(ts)", "MAX(CAST(LIB.TS AS DATETIME))"), ("count_distinct(ts)", "COUNT(DISTINCT CAST(LIB.TS AS DATETIME))"), + ]) + async def test_aggregate_input_reads_naive(self, formula: str, fragment: str) -> None: + query = SlayerQuery.model_validate({"source_model": "lib", "measures": [{"formula": formula, "name": "agg_v"}]}) + sql = " ".join((await _engine_generate(query=query, model=_zoned_lib(), dialect="bigquery")).upper().split()) + assert fragment in sql, sql + + async def test_derived_aggregate_source_reads_naive_once(self) -> None: + base = _zoned_lib() + model = base.model_copy(update={"columns": [*base.columns, Column( + name="ts_shifted", sql="TIMESTAMP_ADD(ts, INTERVAL 1 HOUR)", type=DataType.TIMESTAMP, db_type="TIMESTAMP")]}) + query = SlayerQuery.model_validate({"source_model": "lib", "measures": [{"formula": "max(ts_shifted)", + "name": "agg_v"}]}) + sql = " ".join((await _engine_generate(query=query, model=model, dialect="bigquery")).upper().split()) + assert "MAX(CAST(TIMESTAMP_ADD(LIB.TS, INTERVAL '1' HOUR) AS DATETIME))" in sql, sql + assert "AS DATETIME) AS DATETIME))" not in sql, sql + + @pytest.mark.parametrize("agg", ["first", "last"]) + async def test_ranked_pick_reads_naive(self, agg: str) -> None: + query = SlayerQuery.model_validate({"source_model": "lib", "measures": [{"formula": f"{agg}(ts)", "name": "agg_v"}], + "time_dimensions": [{"dimension": "ts", "granularity": "month"}]}) + sql = " ".join((await _engine_generate(query=query, model=_zoned_lib(), dialect="bigquery")).upper().split()) + assert "CAST(LIB.TS AS DATETIME) AS _VAL_1" in sql, sql + + async def test_derived_time_column_reads_naive(self) -> None: + base = _zoned_lib() + model = base.model_copy(update={"columns": [*base.columns, Column( + name="ts_shifted", sql="TIMESTAMP_ADD(ts, INTERVAL 1 HOUR)", type=DataType.TIMESTAMP, db_type="TIMESTAMP")]}) + query = SlayerQuery.model_validate({"source_model": "lib", "measures": [{"formula": "*:count"}], + "time_dimensions": [{"dimension": "ts_shifted", "granularity": "month"}]}) + sql = " ".join((await _engine_generate(query=query, model=model, dialect="bigquery")).upper().split()) + assert "DATE_TRUNC(CAST(TIMESTAMP_ADD(LIB.TS, INTERVAL '1' HOUR) AS DATETIME), MONTH)" in sql, sql + + @pytest.mark.parametrize(("target_db_type", "on"), [ + (None, "ON CAST(a.at_raw AS DATETIME) = b.bt"), ("TIMESTAMP", "ON a.at_raw = b.bt"), + ]) + async def test_join_keys_meet_in_one_type(self, target_db_type: str | None, on: str) -> None: + # The zoned key's logical name differs from its physical one. + a = SlayerModel(name="a", sql_table="a", data_source="test", joins=[ + ModelJoin(target_model="b", join_pairs=[["at", "bt"]])], columns=[ + Column(name="id", type=DataType.INT, primary_key=True), + Column(name="at", sql="at_raw", type=DataType.TIMESTAMP, db_type="TIMESTAMP"), + Column(name="ts_shifted", sql="TIMESTAMP_ADD(at_raw, INTERVAL 1 HOUR)", type=DataType.TIMESTAMP)]) + b = SlayerModel(name="b", sql_table="b", data_source="test", columns=[ + Column(name="bt", type=DataType.TIMESTAMP, db_type=target_db_type, primary_key=True), + Column(name="label", type=DataType.TEXT)]) + query = SlayerQuery.model_validate({"source_model": "a", "dimensions": ["b.label"]}) + sql = await _engine_generate(query=query, model=a, extra_models=[b], dialect="bigquery") + assert on in " ".join(sql.split()), sql + + async def test_window_time_reads_naive(self) -> None: + models = _zoned(dev1840_models(), {("customers", "signup_at")}) + query = SlayerQuery.model_validate({"source_model": "orders", "time_dimensions": signup_month_td(), + "measures": [{"formula": WINDOWED_PARAM, "name": "w"}]}) + sql = await _engine_generate(query=query, model=models[0], extra_models=models[1:], dialect="bigquery", + validate=False) + assert "CAST(customers.signup_at AS DATETIME) AS _w_time" in " ".join(sql.split()), sql + + async def test_spine_fact_bucket_reads_naive(self) -> None: + models = spine_models() + models = _zoned(models, {(m.name, c.name) for m in models for c in m.columns + if m.name in ("orders", "returns") and c.type in (DataType.DATE, DataType.TIMESTAMP)}) + query = SlayerQuery.model_validate({"source_model": "customers", "measures": TWO_FACTS, + "dimensions": ["customers.region"], + "time_dimensions": [spine_td(date_range=JAN_MAR)]}) + sql = " ".join((await _engine_generate(query=query, model=models[0], extra_models=models[1:], + dialect="bigquery", validate=False)).split()) + assert "DATE_TRUNC(CAST(orders.order_date AS DATETIME), MONTH)" in sql, sql + assert "orders.order_date >= '2025-01-01 00:00:00'" in sql, sql + + +def _zoned(models: list[SlayerModel], columns: set[tuple[str, str]]) -> list[SlayerModel]: + return [m.model_copy(update={"columns": [ + c.model_copy(update={"db_type": "TIMESTAMP", "type": DataType.TIMESTAMP}) if (m.name, c.name) in columns else c + for c in m.columns]}) for m in models] + + +class TestIngestionRecordsZonedType: + @pytest.mark.parametrize(("sa_type", "zoned", "db_type"), [ + (sa.TIMESTAMP(), frozenset({"TIMESTAMP"}), "TIMESTAMP"), + (sa.DATETIME(), frozenset({"TIMESTAMP"}), None), + (sa.TIMESTAMP(), frozenset(), None), + ]) + def test_inspector_column(self, sa_type: sa.types.TypeEngine, zoned: frozenset[str], db_type: str | None) -> None: + col = ingestion._introspected_column({"type": sa_type}, name="ts", primary_key=False, zoned_types=zoned) + assert col.type is DataType.TIMESTAMP + assert col.db_type == db_type + + @pytest.mark.parametrize(("dialect", "db_type"), [("bigquery", "TIMESTAMP"), ("postgresql", None)]) + def test_inspector_path_reads_the_engine_dialect(self, dialect: str, db_type: str | None) -> None: + engine = MagicMock() + engine.dialect.name = dialect + with patch.object(ingestion, "_safe_get_pk_constraint", return_value={}), \ + patch.object(ingestion, "_safe_get_columns", return_value=[{"name": "ts", "type": sa.TIMESTAMP()}]): + cols = ingestion._introspect_query_columns_via_inspector(engine, MagicMock(), "t", None) + assert [c.db_type for c in cols] == [db_type] + + @pytest.mark.parametrize(("dialect", "expected"), [ + ("bigquery", {"ts": "TIMESTAMP", "dt": None}), ("postgresql", {"ts": None, "dt": None}), + ]) + def test_information_schema_fallback(self, dialect: str, expected: dict[str, str | None]) -> None: + engine = MagicMock() + engine.dialect.name = dialect + conn = MagicMock() + engine.connect.return_value.__enter__ = MagicMock(return_value=conn) + engine.connect.return_value.__exit__ = MagicMock(return_value=False) + conn.execute.return_value.fetchall.return_value = [("ts", "TIMESTAMP"), ("dt", "DATETIME")] + result = _get_columns_fallback(sa_engine=engine, table_name="t", ref=None) + assert {c["name"]: c["db_type"] for c in result} == expected diff --git a/tests/test_dev2120_coercion.py b/tests/test_dev2120_coercion.py new file mode 100644 index 000000000..a2292a3c2 --- /dev/null +++ b/tests/test_dev2120_coercion.py @@ -0,0 +1,160 @@ +"""TEXT against a number is numeric, through ``TRY_CAST(text AS DOUBLE)`` (spec: queries/mixed-type-coercion).""" + +from __future__ import annotations + +from typing import Any + +import pytest +import sqlglot +from sqlglot import exp + +from slayer.core.errors import SlayerError +from slayer.core.query import SlayerQuery +from slayer.engine.query_engine import SlayerQueryEngine +from tests._dev2120_fixtures import ( + EXEC_BACKENDS, + emit_lib, + lib_engine, + lib_ids, + lib_query, + lib_values, + patch_profile, +) + + +@pytest.fixture(params=EXEC_BACKENDS) +async def engine(request): + async with lib_engine(request.param) as e: + yield e + + +def _measure(formula: str, **kw: Any) -> SlayerQuery: + return SlayerQuery.model_validate({"source_model": "lib", "measures": [{"formula": formula, "name": "v"}], **kw}) + + +def _where(sql: str, *, dialect: str) -> exp.Where: + where = sqlglot.parse_one(sql, dialect=dialect).find(exp.Where) + assert where is not None, sql + return where + + +class TestScenarios: + async def test_comparison_against_an_integer_literal(self, engine: SlayerQueryEngine) -> None: + assert lib_ids(await engine.execute(lib_query(filters=["num_txt > 100"]))) == {1} + + async def test_comparison_against_a_numeric_column(self, engine: SlayerQueryEngine) -> None: + assert 5 in lib_ids(await engine.execute(lib_query(filters=["num_txt = qty"]))) + + async def test_numeric_not_lexicographic(self, engine: SlayerQueryEngine) -> None: + assert 6 not in lib_ids(await engine.execute(lib_query(filters=["num_txt < 9"]))) + + async def test_arithmetic(self, engine: SlayerQueryEngine) -> None: + values = lib_values(await engine.execute(lib_query("num_txt * 2", filters=["id = 7"]))) + assert float(values[7]) == 3.0 + + async def test_arithmetic_result_aggregates_as_a_number(self, engine: SlayerQueryEngine) -> None: + resp = await engine.execute(_measure("sum(num_txt * 2)", filters=["id IN (5, 7)"])) + assert float(resp.data[0]["lib.v"]) == 9.0 + + async def test_in_list(self, engine: SlayerQueryEngine) -> None: + assert lib_ids(await engine.execute(lib_query(filters=["num_txt IN (1, 2)"]))) == {8, 9} + + async def test_numeric_string_literal(self, engine: SlayerQueryEngine) -> None: + assert lib_ids(await engine.execute(lib_query(filters=["qty > '1'"]))) == {1, 4, 5, 7, 9} + + @pytest.mark.parametrize("filt", ["qty > 'abc'", "qty IN (1, 'abc')", "qty BETWEEN 'abc' AND 3", "qty + 'abc' > 1"]) + async def test_non_numeric_literal_rejected(self, engine: SlayerQueryEngine, filt: str) -> None: + query = lib_query(filters=[filt]) + with pytest.raises(SlayerError, match="'abc'"): + await engine.execute(query) + + async def test_exact_large_integers(self, engine: SlayerQueryEngine) -> None: + exact = lib_ids(await engine.execute(lib_query( + filters=["TRY_CAST('12345678901234567' AS BIGINT) = 12345678901234567"]))) + off_by_one = lib_ids(await engine.execute(lib_query( + filters=["TRY_CAST('12345678901234567' AS BIGINT) = 12345678901234568"]))) + assert (len(exact), off_by_one) == (10, set()) + + +class TestLimitedToMixedOperands: + @pytest.mark.parametrize("formula", ["sum(num_txt)", "avg(num_txt)"]) + async def test_numeric_aggregation_over_text_names_try_cast(self, engine: SlayerQueryEngine, formula: str) -> None: + query = _measure(formula) + with pytest.raises(SlayerError, match="TRY_CAST"): + await engine.execute(query) + + async def test_numeric_function_over_text_names_try_cast(self, engine: SlayerQueryEngine) -> None: + query = lib_query("abs(num_txt)") + with pytest.raises(SlayerError, match="TRY_CAST"): + await engine.execute(query) + + async def test_text_against_text_is_untouched(self) -> None: + sql = await emit_lib(lib_query(filters=["num_txt = '1'"]), dialect="duckdb") + assert "TRY_CAST" not in sql.upper(), sql + + async def test_text_against_a_timestamp_is_a_time_point(self) -> None: + sql = await emit_lib(lib_query(filters=["ts > '2025-03-01'"]), dialect="duckdb") + assert "DOUBLE" not in sql.upper(), sql + + async def test_concat_with_a_number_is_text(self, engine: SlayerQueryEngine) -> None: + values = lib_values(await engine.execute(lib_query("num_txt || qty", filters=["id = 1"]))) + assert values == {1: "120.53"} + + async def test_concat_ws_with_a_number_is_text(self, engine: SlayerQueryEngine) -> None: + values = lib_values(await engine.execute(lib_query("concat_ws('-', word, qty)", filters=["id = 1"]))) + assert values == {1: "paid-3"} + + @pytest.mark.parametrize("expr", ["word || (qty > 1)", "concat(word, qty > 1)", "concat_ws('-', word, qty > 1)", + "concat_ws(qty > 1, word)"]) + async def test_boolean_in_concatenation_is_refused(self, engine: SlayerQueryEngine, expr: str) -> None: + query = lib_query(expr) + with pytest.raises(SlayerError, match="CASE WHEN"): + await engine.execute(query) + + @pytest.mark.parametrize("dialect", ["bigquery", "clickhouse"]) + async def test_concat_ws_array_engines_get_text_elements(self, dialect: str) -> None: + sql = await emit_lib(lib_query("concat_ws('-', word, qty)"), dialect=dialect) + assert "CAST(LIB.QTY AS " in sql.upper(), sql + + +class TestEmission: + async def test_text_side_is_a_try_cast_to_double(self) -> None: + sql = await emit_lib(lib_query(filters=["num_txt > 100"]), dialect="duckdb") + casts = [c for c in _where(sql, dialect="duckdb").find_all(exp.TryCast)] + assert any(c.to.is_type(exp.DataType.Type.DOUBLE) for c in casts), sql + + async def test_author_cast_is_never_rewritten(self) -> None: + sql = await emit_lib(lib_query(filters=["CAST(num_txt AS INT) > 100"]), dialect="duckdb") + where = _where(sql, dialect="duckdb") + assert not list(where.find_all(exp.TryCast)), sql + assert len([c for c in where.find_all(exp.Cast) if not isinstance(c, exp.TryCast)]) == 1, sql + + async def test_numeric_string_literal_becomes_a_number(self) -> None: + sql = await emit_lib(lib_query(filters=["qty > '1'"]), dialect="duckdb") + literals = list(_where(sql, dialect="duckdb").find_all(exp.Literal)) + assert literals, sql + assert not any(lit.is_string for lit in literals), sql + + async def test_postgres_16_gets_the_null_on_error_form(self, monkeypatch) -> None: + patch_profile(monkeypatch, version=(16, 2)) + sql = await emit_lib(lib_query(filters=["num_txt > 100"]), dialect="postgres") + assert "PG_INPUT_IS_VALID(" in sql.upper(), sql + + @pytest.mark.parametrize("version", [(15, 4), None]) + async def test_older_or_unknown_postgres_gets_a_plain_cast(self, monkeypatch, version) -> None: + patch_profile(monkeypatch, version=version) + sql = await emit_lib(lib_query(filters=["num_txt > 100"]), dialect="postgres") + assert "PG_INPUT_IS_VALID(" not in sql.upper(), sql + assert list(_where(sql, dialect="postgres").find_all(exp.Cast)), sql + + async def test_profile_probed_for_coercion(self, monkeypatch) -> None: + calls = patch_profile(monkeypatch, version=(16, 2)) + await emit_lib(lib_query(filters=["qty > 1"]), dialect="postgres") + assert calls == [] + await emit_lib(lib_query(filters=["num_txt > 1"]), dialect="postgres") + assert calls == [1] + + @pytest.mark.parametrize("filt", ["num_txt BETWEEN 1 AND 10", "num_txt IS DISTINCT FROM 99", "greatest(num_txt, 5) > 6"]) + async def test_every_position_coerces(self, filt: str) -> None: + sql = await emit_lib(lib_query(filters=[filt]), dialect="duckdb") + assert list(_where(sql, dialect="duckdb").find_all(exp.TryCast)), sql diff --git a/tests/test_dev2120_date_trunc.py b/tests/test_dev2120_date_trunc.py new file mode 100644 index 000000000..093e1327b --- /dev/null +++ b/tests/test_dev2120_date_trunc.py @@ -0,0 +1,99 @@ +"""``date_trunc(unit, x)`` is the granularity call ``(x)`` (spec: queries/date-functions).""" + +from __future__ import annotations + +from typing import Any + +import pydantic +import pytest + +from slayer.core.errors import UnknownFunctionError, UnknownGranularityError +from slayer.core.models import Aggregation +from slayer.core.query import SlayerQuery +from slayer.core.syntax import parse_expr +from slayer.engine.query_engine import SlayerQueryEngine +from tests._dev2120_fixtures import EXEC_BACKENDS, emit_lib, lib_engine, lib_ids, lib_query, lib_values + + +@pytest.fixture(params=EXEC_BACKENDS) +async def engine(request): + async with lib_engine(request.param) as e: + yield e + + +def _q(**kw: Any) -> SlayerQuery: + return SlayerQuery.model_validate({"source_model": "lib", **kw}) + + +class TestParse: + @pytest.mark.parametrize("unit", ["second", "minute", "hour", "day", "week", "week_sunday", "month", "quarter", "year"]) + def test_is_the_granularity_call(self, unit: str) -> None: + assert parse_expr(f"date_trunc('{unit}', ts)") == parse_expr(f"{unit}(ts)") + + def test_unit_case_insensitive(self) -> None: + assert parse_expr("DATE_TRUNC('MONTH', ts)") == parse_expr("month(ts)") + + @pytest.mark.parametrize("text", ["date_trunc(word, ts)", "date_trunc('month')", "date_trunc('month', ts, 1)", + "date_trunc(1, ts)"]) + def test_malformed_rejected(self, text: str) -> None: + with pytest.raises(ValueError): + parse_expr(text) + + def test_reserved(self) -> None: + with pytest.raises(pydantic.ValidationError, match="scalar"): + Aggregation(name="date_trunc", formula="SUM({value})") + + +class TestPositions: + async def test_row_value_filter(self, engine: SlayerQueryEngine) -> None: + trunc = lib_ids(await engine.execute(lib_query(filters=["date_trunc('month', ts) = '2025-03'"]))) + gran = lib_ids(await engine.execute(lib_query(filters=["month(ts) = '2025-03'"]))) + assert trunc == gran == {1, 2, 7, 10} + + async def test_time_dimension(self, engine: SlayerQueryEngine) -> None: + trunc = await engine.execute(_q(dimensions=["date_trunc('month', ts)"])) + gran = await engine.execute(_q(dimensions=["month(ts)"])) + assert trunc.columns == gran.columns + assert trunc.sql == gran.sql + assert sorted(map(repr, trunc.data)) == sorted(map(repr, gran.data)) # DuckDB GROUP BY order is arbitrary + + async def test_order_key(self, engine: SlayerQueryEngine) -> None: + order = [{"column": "date_trunc('month', ts)", "direction": "desc"}] + trunc = await engine.execute(_q(dimensions=["month(ts)"], order=order)) + gran = await engine.execute(_q(dimensions=["month(ts)"], order=[{"column": "month(ts)", "direction": "desc"}])) + assert trunc.sql == gran.sql + + async def test_aggregation_source(self, engine: SlayerQueryEngine) -> None: + resp = await engine.execute(_q(measures=[{"formula": "max(date_trunc('month', ts))", "name": "v"}])) + assert str(resp.data[0]["lib.v"])[:10] == "2025-06-01" + + async def test_arithmetic(self, engine: SlayerQueryEngine) -> None: + values = lib_values(await engine.execute(lib_query("date_diff('day', date_trunc('month', ts), ts)", + filters=["id IN (1, 2)"]))) + assert {k: int(v) for k, v in values.items()} == {1: 4, 2: 30} + + async def test_same_sql_as_the_granularity_call(self) -> None: + trunc = await emit_lib(lib_query("date_trunc('quarter', ts)"), dialect="postgres") + gran = await emit_lib(lib_query("quarter(ts)"), dialect="postgres") + assert trunc == gran + + +class TestUnknownUnit: + async def test_dimension_entry(self, engine: SlayerQueryEngine) -> None: + query = _q(dimensions=["date_trunc('fortnight', ts)"]) + with pytest.raises(UnknownGranularityError): + await engine.execute(query) + + @pytest.mark.parametrize("unit", ["doy", "dow", "weekday", "dayofweek", "isodow"]) + def test_date_part_names_are_not_units(self, unit: str) -> None: + with pytest.raises(ValueError, match="unknown date_trunc"): + parse_expr(f"date_trunc('{unit}', ts)") + + async def test_expression_raises_the_granularity_calls_error(self, engine: SlayerQueryEngine) -> None: + query = lib_query("date_trunc('fortnight', ts)") + with pytest.raises(UnknownFunctionError) as trunc: + await engine.execute(query) + query = lib_query("fortnight(ts)") + with pytest.raises(UnknownFunctionError) as gran: + await engine.execute(query) + assert isinstance(trunc.value, (UnknownGranularityError, type(gran.value))), trunc.value diff --git a/tests/test_dev2120_json.py b/tests/test_dev2120_json.py new file mode 100644 index 000000000..fd33ae404 --- /dev/null +++ b/tests/test_dev2120_json.py @@ -0,0 +1,284 @@ +"""``json_value``, its spellings, the path subset, RETURNING and JSON inputs (spec: queries/json).""" + +from __future__ import annotations + +import contextlib +import os +import tempfile +from typing import Any, Optional + +import pytest +import sqlalchemy as sa +from sqlalchemy.dialects import mysql, postgresql + +from slayer.core.enums import DataType +from slayer.core.errors import SlayerError +from slayer.core.json_path import JsonPathError, parse_json_path +from slayer.core.keys import CastKey +from slayer.core.models import Column, DatasourceConfig, SlayerModel +from slayer.core.query import SlayerQuery +from slayer.core.scope import ModelScope +from slayer.core.syntax import parse_expr +from slayer.engine.binding import bind_expr +from slayer.engine.ingestion import _introspected_column, ingest_datasource +from slayer.engine.query_engine import SlayerQueryEngine +from slayer.ir.source_bundle import ResolvedSourceBundle +from slayer.sql import engine_factory +from tests._dev2120_fixtures import ( + DOCS_ROWS, + EXEC_BACKENDS, + TIER1, + check_native_json, + emit_lib, + lib_engine, + lib_model, + lib_query, + lib_values, + patch_profile, +) +from tests._engine_helpers import build_exec_engine + + +def same(a: str, b: str) -> None: + assert parse_expr(a) == parse_expr(b), (a, b) + + +@pytest.fixture(params=EXEC_BACKENDS) +async def engine(request): + async with lib_engine(request.param) as e: + yield e + + +async def _rejected(engine: SlayerQueryEngine, expr: str, *, any_of: tuple[str, ...] = (), **kw: Any) -> str: + query = lib_query(expr, **kw) + with pytest.raises(SlayerError) as info: + await engine.execute(query) + msg = str(info.value) + if any_of: + assert any(n.lower() in msg.lower() for n in any_of), msg + return msg + + +class TestSpellings: + @pytest.mark.parametrize(("spelling", "canonical"), [ + ("payload ->> 'a'", "json_value(payload, '$.a')"), + ("payload -> 'a' -> 0 ->> 'b'", "json_value(payload, '$.a[0].b')"), + ("payload ->> '$.a.b'", "json_value(payload, '$.a.b')"), + ("payload ->> 'unit price'", "json_value(payload, '$.\"unit price\"')"), + ("json_extract(payload, '$.a.b')", "json_value(payload, '$.a.b')"), + ("json_extract_scalar(payload, '$.a.b')", "json_value(payload, '$.a.b')"), + ("json_extract_path_text(payload, 'a', 'b')", "json_value(payload, '$.a.b')"), + ("jsonb_extract_path_text(payload, 'a', 'b')", "json_value(payload, '$.a.b')"), + ("JSON_VALUE(payload, '$.a')", "json_value(payload, '$.a')"), + ("json_value(payload, '$.a' RETURNING INT)", "TRY_CAST(json_value(payload, '$.a') AS INT)"), + ("json_value(payload, '$.a' returning double)", "TRY_CAST(json_value(payload, '$.a') AS DOUBLE)"), + ]) + def test_collapses_to_json_value(self, spelling: str, canonical: str) -> None: + same(spelling, canonical) + + @pytest.mark.parametrize(("text", "explicit"), [ + ("payload ->> 'n' || 'x'", "(payload ->> 'n') || 'x'"), + ("payload ->> 'a' = 'x'", "(payload ->> 'a') = 'x'"), + ("payload ->> 'a' LIKE 'x%'", "(payload ->> 'a') LIKE 'x%'"), + ("'x' || payload ->> 'a'", "('x' || payload) ->> 'a'"), + ]) + def test_arrows_bind_at_the_concat_level(self, text: str, explicit: str) -> None: + same(text, explicit) + + @pytest.mark.parametrize("text", ["payload -> 'a'", "payload -> 'a' -> 0", "payload ->> 'a' -> 'b'"]) + def test_bare_arrow_hints_double_arrow(self, text: str) -> None: + with pytest.raises(ValueError, match="->>"): + parse_expr(text) + + @pytest.mark.parametrize("text", ["payload ->> word", "payload ->> ('a' || 'b')", "payload -> word ->> 'a'"]) + def test_non_literal_arrow_operand_rejected(self, text: str) -> None: + with pytest.raises(ValueError): + parse_expr(text) + + @pytest.mark.parametrize("text", [ + "json_extract(payload, '$.a' RETURNING INT)", "json_extract(payload, '$.a', '$.b')", + "json_extract_scalar(payload)", "json_value(payload)", "json_value(payload, '$.a' RETURNING JSON)", + ]) + async def test_malformed_call_rejected(self, engine: SlayerQueryEngine, text: str) -> None: + query = lib_query(text) + with pytest.raises(ValueError): + await engine.execute(query) + + +class TestReturningIsTryCast: + def test_returning_binds_to_a_try_cast_key(self) -> None: + model = lib_model() + bundle = ResolvedSourceBundle(dialect="postgres", source_model=model, referenced_models=[]) + key = bind_expr(parse_expr("json_value(payload, '$.qty' RETURNING INT)"), scope=ModelScope(source_model=model), + bundle=bundle, allow_measures=True).value_key + assert isinstance(key, CastKey), key + assert key.try_ is True + assert key.data_type is DataType.INT + + +class TestPathSubset: + @pytest.mark.parametrize(("path", "names"), [ + ("$.items[*].sku", ("wildcard", "*")), + ("$.*", ("wildcard", "*")), + ("$..a", ("recursive", "..")), + ("$.a[-1]", ("negative", "-1")), + ("$.a[?(@.b)]", ("filter", "?")), + ("a.b", ("$",)), + ("$['a']", ("[",)), + ("$.a[1.5]", ("index", "1.5")), + ("$.a[last]", ("last", "index")), + ("lax $.a", ("lax",)), + ("$.\"a", ("quote", '"')), + ]) + async def test_unsupported_path_named(self, engine: SlayerQueryEngine, path: str, names: tuple[str, ...]) -> None: + quoted = path.replace("'", "''") + await _rejected(engine, f"json_value(payload, '{quoted}')", any_of=names) + + @pytest.mark.parametrize("key", ["a\nb", "a\tb", "a\x00b", "a\x7fb"]) + def test_control_character_key_rejected(self, key: str) -> None: + with pytest.raises(JsonPathError, match="control character"): + parse_json_path(f'$."{key}"') + + def test_control_character_arrow_key_rejected(self) -> None: + with pytest.raises(ValueError, match="control character"): + parse_expr("payload ->> 'a\tb'") + + async def test_non_literal_path_rejected(self, engine: SlayerQueryEngine) -> None: + await _rejected(engine, "json_value(payload, prefix)", any_of=("path",)) + + async def test_variable_path(self, engine: SlayerQueryEngine) -> None: + resp = await engine.execute(lib_query("json_value(payload, {p})", filters=["id = 1"], variables={"p": "$.a.b"})) + assert lib_values(resp) == {1: "x"} + + async def test_bad_variable_path_rejected(self, engine: SlayerQueryEngine) -> None: + await _rejected(engine, "json_value(payload, {p})", any_of=("wildcard", "*"), variables={"p": "$.a[*]"}) + + +def _measure_query(formula: str, **kw: Any) -> SlayerQuery: + return SlayerQuery.model_validate({"source_model": "lib", "measures": [{"formula": formula, "name": "v"}], **kw}) + + +class TestTyping: + async def test_typed_sum(self, engine: SlayerQueryEngine) -> None: + resp = await engine.execute(_measure_query("sum(json_value(payload, '$.qty' RETURNING INT))", + filters=["id IN (1, 2, 3, 8)"])) + assert float(resp.data[0]["lib.v"]) == 5 + + async def test_text_result_keeps_the_numeric_aggregation_error(self, engine: SlayerQueryEngine) -> None: + query = _measure_query("sum(json_value(payload, '$.qty'))") + with pytest.raises(SlayerError, match="TRY_CAST"): + await engine.execute(query) + + @pytest.mark.parametrize("expr", ["json_value(qty, '$.a')", "json_value(ts, '$.a')", "qty ->> 'a'"]) + async def test_non_text_input_rejected(self, engine: SlayerQueryEngine, expr: str) -> None: + await _rejected(engine, expr, any_of=("json",)) + + +def _json_model(*, db_type: Optional[str], type_: DataType = DataType.TEXT) -> SlayerModel: + base = lib_model() + columns = [c for c in base.columns if c.name != "payload"] + columns.append(Column(name="payload", type=type_, db_type=db_type)) + return base.model_copy(update={"columns": columns}) + + +JSON_VALUE_Q = lib_query("json_value(payload, '$.a')") + + +class TestInputForms: + async def test_postgres_reads_every_input_as_jsonb(self) -> None: + for db_type in ("jsonb", "json", None): + sql = await emit_lib(JSON_VALUE_Q, dialect="postgres", models=[_json_model(db_type=db_type)]) + assert "JSONB" in sql.upper(), (db_type, sql) + + async def test_snowflake_variant_read_directly(self) -> None: + native = await emit_lib(JSON_VALUE_Q, dialect="snowflake", models=[_json_model(db_type="VARIANT")]) + text = await emit_lib(JSON_VALUE_Q, dialect="snowflake", models=[_json_model(db_type=None)]) + assert "TRY_PARSE_JSON" not in native.upper(), native + assert "TRY_PARSE_JSON" in text.upper(), text + + async def test_clickhouse_json_column_differs_from_string(self) -> None: + native = await emit_lib(JSON_VALUE_Q, dialect="clickhouse", models=[_json_model(db_type="JSON")]) + text = await emit_lib(JSON_VALUE_Q, dialect="clickhouse", models=[_json_model(db_type=None)]) + assert native != text + + @pytest.mark.parametrize(("dialect", "db_type"), [ + ("postgres", "jsonb"), ("postgres", "json"), ("mysql", "JSON"), ("duckdb", "JSON"), ("bigquery", "JSON"), + ("snowflake", "VARIANT"), ("snowflake", "OBJECT"), ("snowflake", "ARRAY"), ("clickhouse", "JSON"), + ]) + async def test_native_json_column_emits(self, dialect: str, db_type: str) -> None: + for type_ in (DataType.TEXT, DataType.UNKNOWN): + await emit_lib(lib_query("json_value(payload, '$.a' RETURNING INT)"), dialect=dialect, + models=[_json_model(db_type=db_type, type_=type_)]) + + async def test_opaque_non_json_column_rejected(self) -> None: + models = [_json_model(db_type="bytea", type_=DataType.UNKNOWN)] + with pytest.raises(SlayerError): + await emit_lib(JSON_VALUE_Q, dialect="postgres", models=models) + + @pytest.mark.parametrize("dialect", TIER1) + async def test_returning_types_emit(self, dialect: str) -> None: + for target in ("INT", "DOUBLE", "BOOLEAN", "DATE", "TIMESTAMP", "TEXT"): + await emit_lib(lib_query(f"json_value(payload, '$.a' RETURNING {target})"), dialect=dialect) + + +class TestPostgresVersion: + async def test_postgres_16_guards_malformed_text(self, monkeypatch) -> None: + patch_profile(monkeypatch, version=(16, 2)) + sql = await emit_lib(JSON_VALUE_Q, dialect="postgres") + assert "PG_INPUT_IS_VALID(" in sql.upper(), sql + + async def test_validity_check_reads_text(self, monkeypatch) -> None: + # A jsonb column declared TEXT has no implicit cast to pg_input_is_valid's text argument. + patch_profile(monkeypatch, version=(16, 2)) + sql = await emit_lib(JSON_VALUE_Q, dialect="postgres") + assert "PG_INPUT_IS_VALID(CAST(" in sql.upper(), sql + + @pytest.mark.parametrize("version", [(15, 4), None]) + async def test_older_or_unknown_server_follows_the_cast_contract(self, monkeypatch, version) -> None: + patch_profile(monkeypatch, version=version) + sql = await emit_lib(JSON_VALUE_Q, dialect="postgres") + assert "PG_INPUT_IS_VALID(" not in sql.upper(), sql + + async def test_profile_probed_for_json_value(self, monkeypatch) -> None: + calls = patch_profile(monkeypatch, version=(16, 2)) + await emit_lib(lib_query("lower(word)"), dialect="postgres") + assert calls == [] + await emit_lib(JSON_VALUE_Q, dialect="postgres") + assert calls == [1] + + +def _db_type(sa_type: sa.types.TypeEngine) -> Optional[str]: + return _introspected_column({"type": sa_type}, name="payload", primary_key=False).db_type + + +class TestIngestionKeepsJsonDbType: + @pytest.mark.parametrize(("sa_type", "expected"), [ + (postgresql.JSONB(), "JSONB"), (postgresql.JSON(), "JSON"), (mysql.JSON(), "JSON"), (sa.JSON(), "JSON"), + ]) + def test_sqlalchemy_json_types(self, sa_type: sa.types.TypeEngine, expected: str) -> None: + assert (_db_type(sa_type) or "").upper() == expected + + @pytest.mark.parametrize("name", ["VARIANT", "OBJECT", "ARRAY"]) + def test_snowflake_semi_structured_types(self, name: str) -> None: + sf = pytest.importorskip("snowflake.sqlalchemy") + assert (_db_type(getattr(sf, name)()) or "").upper().startswith(name) + + async def test_duckdb_json_column_ingested_and_read(self) -> None: + duckdb = pytest.importorskip("duckdb") + with tempfile.TemporaryDirectory() as tmp: + db_path = os.path.join(tmp, "docs.duckdb") + with contextlib.closing(duckdb.connect(db_path)) as con: + con.execute("CREATE TABLE docs (id INTEGER PRIMARY KEY, payload JSON)") + con.executemany("INSERT INTO docs VALUES (?, ?)", DOCS_ROWS) + ds = DatasourceConfig(name="test", type="duckdb", database=db_path) + try: + models = ingest_datasource(datasource=ds, include_tables=["docs"]) + payload = next(c for c in models[0].columns if c.name == "payload") + assert (payload.db_type or "").upper() == "JSON" + engine = await build_exec_engine(db_path, dialect="duckdb", models=models) + try: + await check_native_json(engine) + finally: + engine.close() + finally: + engine_factory.invalidate_engine(ds) diff --git a/tests/test_dev2120_library_matrix.py b/tests/test_dev2120_library_matrix.py new file mode 100644 index 000000000..d7d7ffe5b --- /dev/null +++ b/tests/test_dev2120_library_matrix.py @@ -0,0 +1,54 @@ +"""Every Mode-B library function and operator has executed cases with one meaning (spec: queries/scalar-functions › One meaning on every Tier-1 dialect).""" + +from __future__ import annotations + +import pytest + +from slayer.core.keys import SCALAR_SPECS +from tests._dev2120_fixtures import ( + EXEC_BACKENDS, + NEW_FUNCTIONS, + TIER1, + Case, + emit_lib, + lib_engine, + library_cases, + required_names, + run_case, +) + +CASES = library_cases() +CASE_IDS = [c.case_id for c in CASES] + + +class TestRegistry: + def test_case_ids_are_unique(self) -> None: + assert len(set(CASE_IDS)) == len(CASE_IDS) + + def test_new_functions_are_registered(self) -> None: + assert sorted(NEW_FUNCTIONS - set(SCALAR_SPECS)) == [] + + @pytest.mark.parametrize("name", sorted(required_names())) + def test_every_function_and_operator_has_cases(self, name: str) -> None: + assert any(name in c.covers for c in CASES), f"no matrix case covers {name!r}" + + def test_every_registered_scalar_has_cases(self) -> None: + covered = {n for c in CASES for n in c.covers} + assert sorted(set(SCALAR_SPECS) - covered) == [] + + +@pytest.fixture(scope="module", params=EXEC_BACKENDS) +async def engine(request): + async with lib_engine(request.param) as e: + yield e + + +@pytest.mark.parametrize("case", CASES, ids=CASE_IDS) +async def test_executes(engine, case: Case) -> None: + await run_case(engine, case) + + +@pytest.mark.parametrize("dialect", TIER1) +@pytest.mark.parametrize("case", CASES, ids=CASE_IDS) +async def test_emits(case: Case, dialect: str) -> None: + await emit_lib(case.query(), dialect=dialect) diff --git a/tests/test_dev2120_regex.py b/tests/test_dev2120_regex.py new file mode 100644 index 000000000..098162877 --- /dev/null +++ b/tests/test_dev2120_regex.py @@ -0,0 +1,266 @@ +"""Regex functions, operators, the portable pattern subset and replacements (spec: queries/regex).""" + +from __future__ import annotations + +from typing import Any + +import pytest + +from slayer.core.errors import SlayerError +from slayer.core.syntax import bind_variables, parse_expr +from slayer.engine.query_engine import SlayerQueryEngine +from tests._dev2120_fixtures import ( + EXEC_BACKENDS, + TIER1, + emit_lib, + lib_engine, + lib_ids, + lib_query, + lib_values, + patch_profile, +) + + +def same(a: str, b: str) -> None: + assert parse_expr(a) == parse_expr(b), (a, b) + + +@pytest.fixture(params=EXEC_BACKENDS) +async def engine(request): + async with lib_engine(request.param) as e: + yield e + + +async def _rejected(engine: SlayerQueryEngine, *needles: str, any_of: tuple[str, ...] = (), **kw: Any) -> str: + query = lib_query(**kw) + with pytest.raises(SlayerError) as info: + await engine.execute(query) + msg = str(info.value) + for needle in needles: + assert needle.lower() in msg.lower(), msg + if any_of: + assert any(n.lower() in msg.lower() for n in any_of), msg + return msg + + +class TestOperators: + @pytest.mark.parametrize(("op", "call"), [ + ("name ~ '^ad'", "regexp_like(name, '^ad')"), + ("name ~* '^ad'", "regexp_like(name, '^ad', 'i')"), + ("name !~ '^ad'", "NOT regexp_like(name, '^ad')"), + ("name !~* '^ad'", "NOT regexp_like(name, '^ad', 'i')"), + ]) + def test_operator_is_the_function(self, op: str, call: str) -> None: + same(op, call) + + @pytest.mark.parametrize(("text", "explicit"), [ + ("a ~ 'x' AND b ~ 'y'", "(a ~ 'x') AND (b ~ 'y')"), + ("NOT a ~ 'x'", "NOT (a ~ 'x')"), + ("a || 'b' ~ 'c'", "(a || 'b') ~ 'c'"), + ]) + def test_binds_like_a_comparison(self, text: str, explicit: str) -> None: + same(text, explicit) + + async def test_operator_keeps_the_function_rows(self, engine: SlayerQueryEngine) -> None: + op = lib_ids(await engine.execute(lib_query(filters=["word ~* '^ad'"]))) + fn = lib_ids(await engine.execute(lib_query(filters=["regexp_like(word, '^ad', 'i')"]))) + assert op == fn == {3, 4, 8, 9} + + +class TestPatternSource: + async def test_variable_pattern(self, engine: SlayerQueryEngine) -> None: + resp = await engine.execute(lib_query(filters=["regexp_like(s, {p})"], variables={"p": "^a.c$"})) + assert lib_ids(resp) == {9} + + @pytest.mark.parametrize("pattern", ["prefix", "'^' || prefix", "lower(prefix)"]) + async def test_non_literal_pattern_rejected(self, engine: SlayerQueryEngine, pattern: str) -> None: + await _rejected(engine, "pattern", filters=[f"regexp_like(word, {pattern})"]) + + async def test_non_literal_replacement_rejected(self, engine: SlayerQueryEngine) -> None: + await _rejected(engine, "replacement", dimensions=["id", {"expression": "regexp_replace(word, 'a', p)", + "name": "v"}]) + + @pytest.mark.parametrize("text", [ + "regexp_like(name, {v}) AND name = {v}", + "name = {v} AND regexp_like(name, {v})", + ]) + def test_text_slot_quotes_only_its_own_occurrence(self, text: str) -> None: + with pytest.raises(ValueError, match="number or boolean slot"): + bind_variables(text, {"v": "abc"}) + + def test_every_text_slot_occurrence_quoted(self) -> None: + bound = bind_variables("regexp_like(a, {v}) OR regexp_like(b, {v}, 'i')", {"v": "x"}) + assert bound == "regexp_like(a, 'x') OR regexp_like(b, 'x', 'i')" + + +UNSUPPORTED = [ + ("(?=a)b", ("lookahead", "(?=")), + ("(?!a)b", ("lookahead", "(?!")), + ("(?<=a)b", ("lookbehind", "(?<=")), + ("(a)\\1", ("backreference", "\\1")), + ("a+?", ("lazy", "+?")), + ("a*?", ("lazy", "*?")), + ("a{1,2}?", ("lazy", "?")), + ("(?i)a", ("(?",)), + ("(?:a)", ("(?",)), + ("\\bword", ("\\b",)), + ("\\Bword", ("\\B",)), + ("\\p{L}", ("\\p",)), + ("[[:alpha:]]", ("[:alpha:]", "POSIX")), + ("\\Aab", ("\\A",)), + ("ab\\z", ("\\z",)), + ("\\x41", ("\\x",)), + ("\\u0041", ("\\u",)), + ("a\\", ("\\",)), + ("(ab", ("(", "parenthes", "group")), + ("[ab", ("[", "bracket")), +] + + +class TestPortableSubset: + @pytest.mark.parametrize(("pattern", "names"), UNSUPPORTED, ids=[p for p, _ in UNSUPPORTED]) + async def test_unsupported_construct_named(self, engine: SlayerQueryEngine, pattern: str, + names: tuple[str, ...]) -> None: + await _rejected(engine, any_of=names, filters=[f"regexp_like(word, '{pattern}')"]) + + async def test_unsupported_construct_in_a_variable_names_it(self, engine: SlayerQueryEngine) -> None: + msg = await _rejected(engine, "\\b", filters=["regexp_like(word, {p})"], variables={"p": "\\bword"}) + assert "'p'" in msg or "{p}" in msg or "variable p" in msg.lower(), msg + + @pytest.mark.parametrize("pattern", [ + "a\\tb", "a\\rb", "a\\nb", "x{2}", "x{2,}", "x{2,3}", "[^a-z]", "[a-c0-9_]", "\\.", "\\$", "\\^", "\\|", + "\\\\", "\\{", "\\}", "\\(", "\\)", "\\[", "\\]", "\\*", "\\+", "\\?", "\\D", "\\W", "\\S", "a|b|c", + "(a|b)+", "^$", "[\\s\\d]", + ]) + async def test_subset_construct_accepted(self, engine: SlayerQueryEngine, pattern: str) -> None: + await engine.execute(lib_query(filters=[f"regexp_like(word, '{pattern}')"])) + + @pytest.mark.parametrize("dialect", TIER1) + async def test_classes_emit_as_ascii(self, dialect: str) -> None: + sql = await emit_lib(lib_query(filters=["regexp_like(word, '^\\d+$')"]), dialect=dialect) + assert "0-9" in sql, sql + assert "\\d" not in sql, sql + + +class TestFunctionArguments: + @pytest.mark.parametrize("expr", [ + "regexp_extract(tag, '@(.+)$', 2)", "regexp_extract(tag, '@(.+)$', -1)", + "regexp_extract(tag, '@(.+)$', n)", "regexp_extract(tag, '@.+$', 1)", + ]) + async def test_bad_group_rejected(self, engine: SlayerQueryEngine, expr: str) -> None: + await _rejected(engine, "group", dimensions=["id", {"expression": expr, "name": "v"}]) + + @pytest.mark.parametrize("flags", ["'g'", "'c'", "'im'", "word"]) + async def test_only_the_i_flag(self, engine: SlayerQueryEngine, flags: str) -> None: + await _rejected(engine, "flag", filters=[f"regexp_like(word, 'a', {flags})"]) + + async def test_null_input_yields_null(self, engine: SlayerQueryEngine) -> None: + values = lib_values(await engine.execute(lib_query("regexp_replace(word, 'a', 'b')", filters=["id = 5"]))) + assert values == {5: None} + + +class TestReplacement: + @pytest.mark.parametrize("replacement", ["\\q", "\\0", "\\3", "\\", "\\n"]) + async def test_bad_escape_or_group_rejected(self, engine: SlayerQueryEngine, replacement: str) -> None: + expr = f"regexp_replace(s, '(\\w+) (\\w+)', '{replacement}')" + await _rejected(engine, "replacement", dimensions=["id", {"expression": expr, "name": "v"}]) + + async def test_variable_replacement(self, engine: SlayerQueryEngine) -> None: + resp = await engine.execute(lib_query("regexp_replace(s, '(\\w+) (\\w+)', {r})", filters=["id = 6"], + variables={"r": "\\2 $1"})) + assert lib_values(resp) == {6: "Lovelace $1"} + + +def _assert_marker(sql: str, *markers: str, absent: tuple[str, ...] = ()) -> None: + upper = sql.upper() + for marker in markers: + assert marker.upper() in upper, sql + for marker in absent: + assert marker.upper() not in upper, sql + + +class TestLowerings: + async def test_snowflake_like_via_instr(self) -> None: + _assert_marker(await emit_lib(lib_query(filters=["regexp_like(word, 'a')"]), dialect="snowflake"), + "REGEXP_INSTR(") + + async def test_postgres_replace_is_global(self) -> None: + sql = await emit_lib(lib_query("regexp_replace(word, 'a', 'b')"), dialect="postgres") + _assert_marker(sql, "REGEXP_REPLACE(", "'g'") + + async def test_sqlite_uses_registered_functions(self) -> None: + sql = await emit_lib(lib_query("regexp_extract(word, 'a')", filters=["regexp_like(word, 'a')"]), + dialect="sqlite") + _assert_marker(sql, "SLAYER_REGEXP_LIKE(", "SLAYER_REGEXP_EXTRACT(") + + async def test_sqlite_replace_uses_registered_function(self) -> None: + _assert_marker(await emit_lib(lib_query("regexp_replace(word, 'a', 'b')"), dialect="sqlite"), + "SLAYER_REGEXP_REPLACE(") + + @pytest.mark.parametrize("dialect", ["mysql", "trino"]) + async def test_group_references_rewritten(self, dialect: str) -> None: + sql = await emit_lib(lib_query("regexp_replace(s, '(\\w+) (\\w+)', '\\2, \\1')"), dialect=dialect) + _assert_marker(sql, "$2", "$1") + + async def test_mysql_is_case_sensitive_without_the_flag(self) -> None: + sql = await emit_lib(lib_query(filters=["regexp_like(word, '^paid$')"]), dialect="mysql") + _assert_marker(sql, "'c'") + + async def test_trino_anchors_the_whole_string(self) -> None: + sql = await emit_lib(lib_query(filters=["regexp_like(code, '^ab$')"]), dialect="trino") + _assert_marker(sql, "\\z") + + +class TestSqlServerVersion: + @pytest.mark.parametrize("expr", ["regexp_like(code, '^a')", "code ~ '^a'"]) + async def test_sql_server_2022_fails_closed(self, monkeypatch, expr: str) -> None: + patch_profile(monkeypatch, version=(16, 0)) + query = lib_query(filters=[expr]) + with pytest.raises(SlayerError) as info: + await emit_lib(query, dialect="tsql") + assert "2025" in str(info.value), str(info.value) + + @pytest.mark.parametrize("expr", ["regexp_extract(code, 'a')", "regexp_replace(code, 'a', 'b')"]) + async def test_every_regex_function_is_gated(self, monkeypatch, expr: str) -> None: + patch_profile(monkeypatch, version=(16, 0)) + query = lib_query(expr) + with pytest.raises(SlayerError, match="2025"): + await emit_lib(query, dialect="tsql") + + async def test_sql_server_2025_lowers_via_instr(self, monkeypatch) -> None: + patch_profile(monkeypatch, version=(17, 0)) + sql = await emit_lib(lib_query(filters=["regexp_like(code, '^a')"]), dialect="tsql") + _assert_marker(sql, "REGEXP_INSTR(", absent=("REGEXP_LIKE(",)) + + async def test_unknown_version_emits(self, monkeypatch) -> None: + patch_profile(monkeypatch, version=None) + await emit_lib(lib_query(filters=["regexp_like(code, '^a')"]), dialect="tsql") + + async def test_profile_probed_for_regex(self, monkeypatch) -> None: + calls = patch_profile(monkeypatch, version=(17, 0)) + await emit_lib(lib_query(filters=["code LIKE 'a%'"]), dialect="tsql") + assert calls == [] + await emit_lib(lib_query(filters=["code ~ 'a'"]), dialect="tsql") + assert calls == [1] + + +class TestBracesInStringLiterals: + @pytest.mark.parametrize("variables", [None, {"unused": 1}]) + async def test_quantifier_braces_are_text(self, engine: SlayerQueryEngine, variables) -> None: + resp = await engine.execute(lib_query(filters=["regexp_like(code, '^[a-z]{1,2}[0-9]{2,}$')"], + variables=variables)) + assert lib_ids(resp) == {1, 2} + + @pytest.mark.parametrize("variables", [None, {"unused": 1}]) + @pytest.mark.parametrize(("literal", "text"), [("{1, 2, 3}", "{1, 2, 3}"), ("{}", "{}"), ("{3}", "{3}")]) + async def test_digit_and_comma_braces_are_text(self, engine: SlayerQueryEngine, variables, literal: str, + text: str) -> None: + resp = await engine.execute(lib_query(f"'{literal}' || code", filters=["id = 7"], variables=variables)) + assert lib_values(resp) == {7: f"{text}a1"} + + async def test_name_shaped_braces_in_a_pattern_hint_escaping(self, engine: SlayerQueryEngine) -> None: + query = lib_query(filters=["regexp_like(word, '\\p{L}')"]) + with pytest.raises(ValueError, match="Undefined variable 'L'") as info: + await engine.execute(query) + assert "{{" in str(info.value), str(info.value) + assert "}}" in str(info.value), str(info.value) diff --git a/tests/test_dev2120_scalar_functions.py b/tests/test_dev2120_scalar_functions.py new file mode 100644 index 000000000..456ce5d4a --- /dev/null +++ b/tests/test_dev2120_scalar_functions.py @@ -0,0 +1,271 @@ +"""The scalar library's rules: Postgres edge cases, out-of-domain NULL, version gating, exclusions (spec: queries/scalar-functions).""" + +from __future__ import annotations + +import pytest + +from slayer.core.errors import SlayerError, UnknownFunctionError +from slayer.engine.query_engine import SlayerQueryEngine +from slayer.sql.dialects import get_dialect +from slayer.sql.dialects.base import ServerProfile +from tests._dev2120_fixtures import ( + EXEC_BACKENDS, + TIER1, + emit_lib, + lib_engine, + lib_ids, + lib_query, + lib_values, + patch_profile, +) + + +@pytest.fixture(params=EXEC_BACKENDS) +async def engine(request): + async with lib_engine(request.param) as e: + yield e + + +async def _value(engine: SlayerQueryEngine, expr: str, *, row: int = 1): + return lib_values(await engine.execute(lib_query(expr, filters=[f"id = {row}"])))[row] + + +async def _rejected(engine: SlayerQueryEngine, expr: str, *needles: str) -> str: + query = lib_query(expr) + with pytest.raises(SlayerError) as info: + await engine.execute(query) + msg = str(info.value) + for needle in needles: + assert needle.lower() in msg.lower(), msg + return msg + + +class TestPostgresMeaning: + async def test_negative_left(self, engine: SlayerQueryEngine) -> None: + assert await _value(engine, "left(s, -2)") == "ABC" + + async def test_non_ascii_characters(self, engine: SlayerQueryEngine) -> None: + resp = await engine.execute(lib_query({"expression": "reverse(s)", "name": "v1"}, + {"expression": "ascii(s)", "name": "v2"}, + {"expression": "left(s, 1)", "name": "v3"}, filters=["id = 2"])) + row = resp.data[0] + assert (row["lib.v1"], int(row["lib.v2"]), row["lib.v3"]) == ("é€", 8364, "€") + + async def test_astral_code_point(self, engine: SlayerQueryEngine) -> None: + assert await _value(engine, "chr(128512)") == "\U0001F600" + + async def test_split_part_index(self, engine: SlayerQueryEngine) -> None: + resp = await engine.execute(lib_query({"expression": "split_part(s, '/', 2)", "name": "v1"}, + {"expression": "split_part(s, '/', -1)", "name": "v2"}, + {"expression": "split_part(s, '/', 9)", "name": "v3"}, + filters=["id = 3"])) + row = resp.data[0] + assert (row["lib.v1"], row["lib.v2"], row["lib.v3"]) == ("b", "c", "") + + async def test_lpad_truncates(self, engine: SlayerQueryEngine) -> None: + values = lib_values(await engine.execute(lib_query("lpad(s, 3, '0')", filters=["id IN (1, 8)"]))) + assert values == {1: "ABC", 8: "0ab"} + + async def test_concat_ws_skips_nulls(self, engine: SlayerQueryEngine) -> None: + assert await _value(engine, "concat_ws('-', 'x', p, 'z')", row=10) == "x-z" + + async def test_plain_text_containment(self, engine: SlayerQueryEngine) -> None: + assert lib_ids(await engine.execute(lib_query(filters=["contains(tag, '5%')"]))) == {6} + + @pytest.mark.parametrize(("expr", "expected"), [ + ("div(7, 2)", 3), ("div(-7, 2)", -3), ("div(7, -2)", -3), ("div(-7, -2)", 3), + ]) + async def test_div_truncates_toward_zero(self, engine: SlayerQueryEngine, expr: str, expected: int) -> None: + assert int(await _value(engine, expr)) == expected + + async def test_cbrt_of_a_negative_number(self, engine: SlayerQueryEngine) -> None: + assert float(await _value(engine, "cbrt(x)", row=6)) == pytest.approx(-2.0) + + async def test_division_by_zero_column(self, engine: SlayerQueryEngine) -> None: + assert await _value(engine, "div(i, m)", row=3) is None + + async def test_asin_column_out_of_domain(self, engine: SlayerQueryEngine) -> None: + values = lib_values(await engine.execute(lib_query("asin(x)", filters=["id IN (1, 2)"]))) + assert values[2] is None + assert float(values[1]) == pytest.approx(0.5235987755982989) + + async def test_greatest_ignores_nulls_in_any_position(self, engine: SlayerQueryEngine) -> None: + values = lib_values(await engine.execute(lib_query("greatest(a, b, c)", filters=["id IN (1, 2, 3, 4)"]))) + assert {k: (None if v is None else int(v)) for k, v in values.items()} == {1: 2, 2: 3, 3: 2, 4: None} + + +class TestLiteralOutOfDomain: + @pytest.mark.parametrize(("expr", "function", "argument"), [ + ("asin(2)", "asin", "2"), + ("asin(-1.5)", "asin", "-1.5"), + ("acos(2)", "acos", "2"), + ("acos(-1.5)", "acos", "-1.5"), + ("div(i, 0)", "div", "0"), + ("div(7, 0)", "div", "0"), + ("chr(0)", "chr", "0"), + ("chr(55296)", "chr", "55296"), + ("chr(57343)", "chr", "57343"), + ("chr(1114112)", "chr", "1114112"), + ]) + async def test_rejected_at_plan_time(self, engine: SlayerQueryEngine, expr: str, function: str, + argument: str) -> None: + await _rejected(engine, expr, function, argument) + + @pytest.mark.parametrize("expr", ["asin(1)", "asin(-1)", "acos(1)", "acos(-1)", "chr(1114111)", "div(0, 3)"]) + async def test_boundary_literal_accepted(self, engine: SlayerQueryEngine, expr: str) -> None: + await engine.execute(lib_query(expr)) + + @pytest.mark.parametrize("dialect", TIER1) + async def test_rejected_before_emission(self, dialect: str) -> None: + query = lib_query("asin(2)") + with pytest.raises(SlayerError, match="asin"): + await emit_lib(query, dialect=dialect) + + +class TestSplitPartEmptyDelimiter: + @pytest.mark.parametrize(("index", "expected"), [(1, "a/b/c"), (2, ""), (-1, "a/b/c"), (-2, "")]) + async def test_whole_value_is_the_one_field(self, engine: SlayerQueryEngine, index: int, expected: str) -> None: + assert await _value(engine, f"split_part(s, '', {index})", row=3) == expected + + @pytest.mark.parametrize(("index", "expected"), [(2, "b"), (-1, "c")]) + async def test_space_delimiter_is_not_empty(self, engine: SlayerQueryEngine, index: int, expected: str) -> None: + assert await _value(engine, f"split_part('a b c', ' ', {index})") == expected + + async def test_tsql_space_has_length_one(self) -> None: + sql = await emit_lib(lib_query("split_part(word, ' ', -1)"), dialect="tsql") + assert "LEN(CAST(' ' AS NVARCHAR(MAX)) + 'x') - 1" in " ".join(sql.split()), sql + + @pytest.mark.parametrize("dialect", ["tsql", "mysql"]) + async def test_field_count_never_divides_by_zero(self, dialect: str) -> None: + sql = await emit_lib(lib_query("split_part(word, tag, -1)"), dialect=dialect) + assert "NULLIF(" in sql.upper(), sql + + +class TestSplitPartIndex: + @pytest.mark.parametrize("expr", [ + "split_part(s, '/', n)", "split_part(s, '/', 0)", "split_part(s, '/', 1.5)", "split_part(s, '/', 1 + 1)", + ]) + async def test_non_literal_or_zero_index_rejected(self, engine: SlayerQueryEngine, expr: str) -> None: + await _rejected(engine, expr, "split_part") + + +class TestVersionGating: + def test_sql_server_profile_probe(self) -> None: + probe = get_dialect("tsql").server_profile_sql() + assert probe is not None + assert "SERVERPROPERTY('ProductMajorVersion')" in probe + + @pytest.mark.parametrize(("row", "version"), [ + (("16",), (16, 0)), (("17",), (17, 0)), ((15,), (15, 0)), (("garbage",), None), ((None,), None), + ]) + def test_sql_server_profile_parse(self, row: tuple, version) -> None: + assert get_dialect("tsql").parse_server_profile(base_row=row).version == version + + def test_sql_server_profile_parse_tolerates_no_row(self) -> None: + assert get_dialect("tsql").parse_server_profile(base_row=None) == ServerProfile() + + @pytest.mark.parametrize("function", ["greatest", "least"]) + async def test_old_sql_server_fails_closed(self, monkeypatch, function: str) -> None: + patch_profile(monkeypatch, version=(15, 0)) + query = lib_query(f"{function}(a, b)") + with pytest.raises(SlayerError) as info: + await emit_lib(query, dialect="tsql") + msg = str(info.value) + assert function in msg.lower(), msg + assert "2022" in msg, msg + + @pytest.mark.parametrize("version", [(16, 0), (17, 0), None]) + async def test_supported_or_unknown_version_emits(self, monkeypatch, version) -> None: + patch_profile(monkeypatch, version=version) + sql = await emit_lib(lib_query("greatest(a, b)"), dialect="tsql") + assert "GREATEST(" in sql.upper(), sql + + async def test_failed_probe_emits(self, monkeypatch) -> None: + patch_profile(monkeypatch, fail=True) + await emit_lib(lib_query("least(a, b)"), dialect="tsql") + + async def test_profile_probed_only_when_rendering_reads_it(self, monkeypatch) -> None: + calls = patch_profile(monkeypatch, version=(16, 0)) + await emit_lib(lib_query("abs(a)"), dialect="tsql") + assert calls == [] + await emit_lib(lib_query("greatest(a, b)"), dialect="tsql") + assert calls == [1] + + +class TestGreatestLeastLowering: + @pytest.mark.parametrize("dialect", ["sqlite", "mysql", "bigquery"]) + async def test_null_propagating_engines_coalesce(self, dialect: str) -> None: + sql = await emit_lib(lib_query("greatest(a, b, c)"), dialect=dialect) + assert "COALESCE(" in sql.upper(), sql + + async def test_snowflake_ignores_nulls_natively(self) -> None: + sql = await emit_lib(lib_query("greatest(a, b, c)"), dialect="snowflake") + assert "GREATEST_IGNORE_NULLS(" in sql.upper(), sql + + +class TestLogLowering: + @pytest.mark.parametrize("dialect", TIER1) + async def test_one_argument_log_is_base_ten(self, dialect: str) -> None: + sql = (await emit_lib(lib_query("log(x)"), dialect=dialect)).upper() + assert "LOG10(" in sql, sql + assert "LN(" not in sql, sql + + async def test_bigquery_log2_takes_the_base_argument(self) -> None: + sql = (await emit_lib(lib_query("log2(x)"), dialect="bigquery")).upper() + assert "LOG2(" not in sql, sql + assert "LOG(LIB.X, 2)" in sql, sql + + +class TestTrimLowering: + @pytest.mark.parametrize("dialect", ["bigquery", "trino"]) + @pytest.mark.parametrize("fn", ["trim", "ltrim", "rtrim"]) + async def test_whitespace_trimming_engines_trim_spaces_only(self, dialect: str, fn: str) -> None: + sql = await emit_lib(lib_query(f"{fn}(code)"), dialect=dialect) + assert f"{fn.upper()}(LIB.CODE, ' ')" in sql.upper(), sql + + +_TEXT_MATCHES = ["starts_with(word, 'ad')", "ends_with(word, 'ad')", "contains(word, 'ad')", "strpos(word, 'ad')", + "instr(word, 'ad')", "POSITION('ad' IN word)"] + + +class TestTextMatchingIgnoresCollation: + @pytest.mark.parametrize(("dialect", "marker"), [("mysql", "COLLATE UTF8MB4_BIN"), + ("tsql", "COLLATE LATIN1_GENERAL_100_BIN2")]) + @pytest.mark.parametrize("expr", _TEXT_MATCHES) + async def test_insensitive_default_engines_compare_binary(self, dialect: str, marker: str, expr: str) -> None: + sql = (await emit_lib(lib_query(expr), dialect=dialect)).upper() + assert sql.count(marker) >= 2, sql + + @pytest.mark.parametrize("expr", ["replace(word, 'a', 'x')", "split_part(word, 'a', 2)", "split_part(word, 'a', -1)"]) + async def test_tsql_replace_and_split_part_compare_binary(self, expr: str) -> None: + sql = (await emit_lib(lib_query(expr), dialect="tsql")).upper() + assert sql.count("COLLATE LATIN1_GENERAL_100_BIN2") >= 2, sql + + async def test_tsql_collates_a_compound_operand_whole(self) -> None: + sql = await emit_lib(lib_query("contains(word || 'x', 'ad')"), dialect="tsql") + assert "( lib.word + 'x' ) COLLATE" in " ".join(sql.split()), sql + + @pytest.mark.parametrize("dialect", [d for d in TIER1 if d not in ("mysql", "tsql")]) + async def test_other_engines_compare_as_written(self, dialect: str) -> None: + sql = (await emit_lib(lib_query("starts_with(word, 'ad')"), dialect=dialect)).upper() + assert "COLLATE" not in sql, sql + + +class TestExcludedFunctions: + @pytest.mark.parametrize("expr", [ + "initcap(word)", "random()", "to_date(word, 'YYYY')", "strftime(word, '%Y')", + "json_object('a', word)", "json_array(word)", "json_each(payload)", + ]) + async def test_unknown_function(self, engine: SlayerQueryEngine, expr: str) -> None: + query = lib_query(expr) + with pytest.raises(UnknownFunctionError): + await engine.execute(query) + + +class TestFloorDivisionHint: + async def test_hint_names_a_working_function(self, engine: SlayerQueryEngine) -> None: + query = lib_query("i // m") + with pytest.raises(ValueError, match=r"div\(a, b\)"): + await engine.execute(query) + values = lib_values(await engine.execute(lib_query("div(i, m)", filters=["id = 1"]))) + assert int(values[1]) == 3 diff --git a/tests/test_dev2120_string_matching.py b/tests/test_dev2120_string_matching.py new file mode 100644 index 000000000..92467044a --- /dev/null +++ b/tests/test_dev2120_string_matching.py @@ -0,0 +1,131 @@ +"""Collation, the one LIKE pattern language, SQLite LIKE case (spec: queries/string-matching).""" + +from __future__ import annotations + +import pytest + +from slayer.core.enums import DataType +from slayer.core.models import Column, SlayerModel +from slayer.core.query import SlayerQuery +from slayer.engine.query_engine import SlayerQueryEngine +from slayer.storage.sqlite_conn import transaction +from tests._dev2120_fixtures import ( + EXEC_BACKENDS, + TIER1, + emit_lib, + lib_engine, + lib_ids, + lib_model, + lib_query, + lib_values, +) +from tests._engine_helpers import seeded_exec_engine + + +@pytest.fixture(params=EXEC_BACKENDS) +async def engine(request): + async with lib_engine(request.param) as e: + yield e + + +@pytest.fixture +async def sqlite_engine(): + async with lib_engine("sqlite") as e: + yield e + + +def _mode_a_model() -> SlayerModel: + base = lib_model() + return base.model_copy(update={"columns": [ + *base.columns, Column(name="is_ada", sql="word LIKE 'ada%'", type=DataType.BOOLEAN), + ]}) + + +def _nocase_seed(db_path: str) -> None: + with transaction(db_path) as con: + con.execute("CREATE TABLE people (id INTEGER PRIMARY KEY, name TEXT COLLATE NOCASE)") + con.executemany("INSERT INTO people VALUES (?, ?)", [(1, "ada"), (2, "Ada"), (3, "bob")]) + + +def _people_model() -> SlayerModel: + return SlayerModel(name="people", sql_table="people", data_source="test", columns=[ + Column(name="id", type=DataType.INT, primary_key=True), Column(name="name", type=DataType.TEXT), + ]) + + +class TestCaseSensitivity: + async def test_sqlite_like_is_case_sensitive(self, sqlite_engine: SlayerQueryEngine) -> None: + assert lib_ids(await sqlite_engine.execute(lib_query(filters=["word LIKE 'ada%'"]))) == {3} + + async def test_sqlite_like_ignores_a_nocase_column(self) -> None: + async with seeded_exec_engine(dialect="sqlite", seed=_nocase_seed, models=[_people_model()]) as (engine, _): + resp = await engine.execute(SlayerQuery.model_validate({ + "source_model": "people", "dimensions": ["id"], "filters": ["name LIKE 'ada%'"]})) + assert {int(r["people.id"]) for r in resp.data} == {1} + + async def test_ilike_is_case_insensitive(self, engine: SlayerQueryEngine) -> None: + assert lib_ids(await engine.execute(lib_query(filters=["word ILIKE 'ADA%'"]))) == {3, 4} + + async def test_mode_a_like_on_sqlite_unchanged(self) -> None: + async with lib_engine("sqlite", models=[_mode_a_model()]) as engine: + values = lib_values(await engine.execute(lib_query({"expression": "is_ada", "name": "v"}, + filters=["id IN (3, 4)"]))) + assert {k: bool(v) for k, v in values.items()} == {3: True, 4: True} + + +class TestPatternLanguage: + @pytest.mark.parametrize(("filt", "expected"), [ + (r"code LIKE 'a\_%'", {3}), + ("code LIKE '[ab]%'", {6}), + (r"word LIKE 'c:\x%'", {10}), + ("code LIKE prefix || '%'", {1, 3, 4, 6, 7, 8, 10}), + ("code LIKE 'a*?%'", {8}), + ("notes LIKE 'paid%late'", {1, 4}), + ]) + async def test_spec_patterns(self, engine: SlayerQueryEngine, filt: str, expected: set[int]) -> None: + assert lib_ids(await engine.execute(lib_query(filters=[filt]))) == expected + + async def test_variable_pattern(self, engine: SlayerQueryEngine) -> None: + resp = await engine.execute(lib_query(filters=["code LIKE '{p}'"], variables={"p": "a\\_%"})) + assert lib_ids(resp) == {3} + + +class TestEmission: + @pytest.mark.parametrize("dialect", ["postgres", "mysql", "duckdb", "snowflake", "trino", "tsql"]) + async def test_escape_clause(self, dialect: str) -> None: + sql = await emit_lib(lib_query(filters=["code LIKE 'a%'"]), dialect=dialect) + assert "ESCAPE" in sql.upper(), sql + + @pytest.mark.parametrize("dialect", ["clickhouse", "bigquery"]) + async def test_native_backslash_escaping(self, dialect: str) -> None: + sql = await emit_lib(lib_query(filters=["code LIKE 'a%'"]), dialect=dialect) + assert "ESCAPE" not in sql.upper(), sql + + async def test_sqlite_like_is_glob(self) -> None: + sql = await emit_lib(lib_query(filters=["code LIKE 'a%'"]), dialect="sqlite") + assert "GLOB" in sql.upper(), sql + assert "SLAYER_LIKE_GLOB(" in sql.upper(), sql + + async def test_sqlite_ilike_is_native_like(self) -> None: + sql = await emit_lib(lib_query(filters=["code ILIKE 'a%'"]), dialect="sqlite") + assert " LIKE " in sql.upper(), sql + assert "GLOB" not in sql.upper(), sql + + async def test_sqlite_mode_a_like_not_rewritten(self) -> None: + sql = await emit_lib(lib_query({"expression": "is_ada", "name": "v"}), dialect="sqlite", + models=[_mode_a_model()]) + assert "GLOB" not in sql.upper(), sql + + async def test_sql_server_brackets_a_literal_bracket(self) -> None: + sql = await emit_lib(lib_query(filters=["code LIKE '[ab]%'"]), dialect="tsql") + assert "[[]" in sql, sql + + async def test_sql_server_brackets_a_column_pattern(self) -> None: + sql = await emit_lib(lib_query(filters=["code LIKE prefix || '%'"]), dialect="tsql") + assert "REPLACE(" in sql.upper(), sql + assert "[[]" in sql, sql + + @pytest.mark.parametrize("dialect", TIER1) + async def test_every_pattern_form_emits(self, dialect: str) -> None: + await emit_lib(lib_query(filters=[r"code LIKE 'a\_%'", "code NOT LIKE '[ab]%'", r"word ILIKE 'c:\x%'", + "code LIKE prefix || '%'"]), dialect=dialect) diff --git a/tests/test_notebook_network_guard.py b/tests/test_notebook_network_guard.py index 9514be78a..5a1a505df 100644 --- a/tests/test_notebook_network_guard.py +++ b/tests/test_notebook_network_guard.py @@ -24,6 +24,8 @@ f"HTTP Error: HTTP GET error on '{_URL}' (HTTP 503 Service Unavailable)", f"IO Error: Could not resolve host: {_HOST}", "curl: (22) The requested URL returned error: 403 install.duckdb.org", + f'HTTP Error: ETag on reading file "{_URL}" was initially W/"a" and now it returned W/"b", ' + "this likely means the remote file has changed.", ], ) def test_external_host_outage_is_transient(text): @@ -55,6 +57,7 @@ def test_hostless_httpfs_transport_error_is_transient(text): "curl: (22) The requested URL returned error: 404 install.duckdb.org", # A transient status but no external host named — not a classifiable outage. "HTTP Error: HTTP GET error on 'https://example.internal/x' (HTTP 503)", + "IO Error: this likely means the remote file has changed (no external host named)", ], ) def test_real_bugs_are_not_transient(text): diff --git a/tests/test_query_backed_declared_join_boundaries.py b/tests/test_query_backed_declared_join_boundaries.py new file mode 100644 index 000000000..aeb6b0aec --- /dev/null +++ b/tests/test_query_backed_declared_join_boundaries.py @@ -0,0 +1,119 @@ +"""Saved relation joins survive consumption without leaking into ordinary stages.""" + +from __future__ import annotations + +import pytest + +from slayer.core.errors import UnrelatedDatasetError +from slayer.core.models import ModelJoin + +from tests._dev1902_fixtures import ( + AMOUNT_BY_CUSTOMER, + _seed_duckdb, + _seed_sqlite, + cells, + customers_model, + orders_model, + renamed_graph, +) +from tests._engine_helpers import seeded_exec_engine +from tests.test_dev1902_join_key_spelling import _customer_totals, _query + + +@pytest.fixture(params=["sqlite", "duckdb"]) +async def engine(request): + seed = _seed_duckdb if request.param == "duckdb" else _seed_sqlite + async with seeded_exec_engine( + dialect=request.param, seed=seed, models=renamed_graph() + ) as (query_engine, _db): + yield query_engine + + +async def test_join_target_keeps_its_onward_relationship(engine): + await engine.save_model(_customer_totals()) + consumer = orders_model().model_copy(update={ + "name": "consumer", + "joins": [ModelJoin(target_model="customer_totals", join_pairs=[["customer_id", "customer_id"]])], + }) + await engine.save_model(consumer) + + response = await engine.execute(_query( + source_model="consumer", + dimensions=["customer_totals.customers.name"], + measures=[{"formula": "sum(amount)", "name": "total"}], + )) + + assert cells(response, dim_suffix="customers.name", measure="total") == AMOUNT_BY_CUSTOMER + + +async def test_saved_relation_without_outgoing_joins_can_use_incoming_edge(engine): + await engine.save_model(_customer_totals().model_copy(update={"joins": []})) + customers = customers_model() + await engine.save_model(customers.model_copy(update={"joins": [ + *customers.joins, + ModelJoin(target_model="customer_totals", join_pairs=[["id", "customer_id"]], name="totals"), + ]})) + + response = await engine.execute(_query( + source_model="customer_totals", + dimensions=["customers.name"], + measures=[{"formula": "sum(amt)", "name": "total"}], + )) + + assert cells(response, dim_suffix="name", measure="total") == AMOUNT_BY_CUSTOMER + + +async def test_extension_keeps_distinct_named_stored_and_added_joins(engine): + totals = _customer_totals() + await engine.save_model(totals.model_copy(update={ + "joins": [totals.joins[0].model_copy(update={"name": "owner"})], + })) + + response = await engine.execute(_query( + source_model={"source_name": "customer_totals", "joins": [{ + "target_model": "customers", "join_pairs": [["customer_id", "id"]], "name": "reviewer", + }]}, + dimensions=["owner.name", "reviewer.tier"], + measures=[{"formula": "sum(amt)", "name": "total"}], + )) + + assert { + row["customer_totals.owner.name"]: ( + row["customer_totals.reviewer.tier"], row["customer_totals.total"] + ) + for row in response.data + } == {"Ann": ("gold", 30.0), "Bob": ("silver", 30.0), "Cid": ("gold", 90.0)} + + +async def test_ordinary_stage_does_not_inherit_backing_source_joins(engine): + stage = _query( + name="s", source_model="orders", dimensions=["customer_id"], + measures=[{"formula": "sum(amount)", "name": "amt"}], + ) + consumer = _query( + source_model="s", dimensions=["customers.name"], + measures=[{"formula": "sum(amt)", "name": "total"}], + ) + + with pytest.raises(UnrelatedDatasetError): + await engine.execute([stage, consumer]) + + +async def test_legal_stage_named_join_target_is_not_a_synthetic_self_join(engine): + await engine.save_model(customers_model().model_copy(update={"name": "_stage"})) + totals = _customer_totals() + await engine.save_model(totals.model_copy(update={ + "joins": [totals.joins[0].model_copy(update={"target_model": "_stage"})], + })) + + unjoined = await engine.execute(_query( + source_model="customer_totals", + measures=[{"formula": "sum(amt)", "name": "total"}], + )) + assert unjoined.data == [{"customer_totals.total": 150.0}] + + joined = await engine.execute(_query( + source_model="customer_totals", dimensions=["_stage.name"], + measures=[{"formula": "sum(amt)", "name": "total"}], + )) + assert cells(joined, dim_suffix="_stage.name", measure="total") == AMOUNT_BY_CUSTOMER diff --git a/tests/test_query_backed_declared_joins.py b/tests/test_query_backed_declared_joins.py new file mode 100644 index 000000000..94de7d720 --- /dev/null +++ b/tests/test_query_backed_declared_joins.py @@ -0,0 +1,82 @@ +"""Saved query-backed models retain their declared relationship graph.""" + +from __future__ import annotations + +import pytest + +from slayer.core.errors import AmbiguousJoinPathError + +from tests._dev1902_fixtures import ( + AMOUNT_BY_CUSTOMER, + cells, + make_exec_engine, + orders_model, + renamed_graph, +) +from tests.test_dev1902_join_key_spelling import _customer_totals, _query + + +@pytest.fixture(params=["sqlite", "duckdb"]) +async def saved_totals_engine(request): + async for engine in make_exec_engine(request, models=renamed_graph()): + await engine.save_model(_customer_totals()) + yield engine + + +async def test_saved_query_backed_join_filters_population(saved_totals_engine): + response = await saved_totals_engine.execute(_query( + source_model="customer_totals", + measures=[{"formula": "sum(amt)", "name": "total"}], + filters=["customers.tier = 'gold'"], + )) + assert response.data == [{"customer_totals.total": 120.0}] + + +async def test_saved_query_backed_join_traverses_multihop_for_aggregate(saved_totals_engine): + response = await saved_totals_engine.execute(_query( + source_model="customer_totals", + dimensions=["customers.regions.name"], + measures=[{"formula": "sum(customers.credit)", "name": "credit"}], + )) + assert cells(response, dim_suffix="regions.name", measure="credit") == { + "North": 300.0, + "South": 300.0, + } + + +async def test_repeating_saved_join_in_extension_is_still_usable(saved_totals_engine): + model = _customer_totals() + response = await saved_totals_engine.execute(_query( + source_model={ + "source_name": "customer_totals", + "joins": [join.model_dump() for join in model.joins], + }, + dimensions=["customers.name"], + measures=[{"formula": "sum(amt)", "name": "total"}], + )) + assert cells(response, dim_suffix="customers.name", measure="total") == { + "Ann": 30.0, + "Bob": 30.0, + "Cid": 90.0, + } + + +async def test_repeating_stored_join_in_table_model_extension_is_that_edge(saved_totals_engine): + response = await saved_totals_engine.execute(_query( + source_model={"source_name": "orders", "joins": [ + orders_model().joins[0].model_copy(update={"description": "repeated"}).model_dump()]}, + dimensions=["customers.name"], + measures=[{"formula": "sum(amount)", "name": "total"}], + )) + assert cells(response, dim_suffix="customers.name", measure="total") == AMOUNT_BY_CUSTOMER + + +async def test_extension_join_differing_from_stored_one_stays_a_parallel_edge(saved_totals_engine): + query = _query( + source_model={"source_name": "orders", "joins": [ + {"target_model": "customers", "join_pairs": [["id", "id"]]}]}, + dimensions=["customers.name"], + measures=[{"formula": "sum(amount)", "name": "total"}], + ) + with pytest.raises(AmbiguousJoinPathError): + await saved_totals_engine.execute(query) diff --git a/tests/test_reference_semantics.py b/tests/test_reference_semantics.py index 71d2b3acf..d61834e2b 100644 --- a/tests/test_reference_semantics.py +++ b/tests/test_reference_semantics.py @@ -1,4 +1,4 @@ -"""Tests for the two-mode reference semantics introduced by DEV-1369. +"""Tests for the two-mode reference semantics. Mode A — SQL expression: Column.sql, Column.filter, SlayerModel.filters. Free SQL via sqlglot. Bare names = underlying-table columns; ``__``-paths @@ -141,10 +141,10 @@ def test_model_filter_accepts_is_null(self) -> None: class TestSqlModeRuntime: - """DEV-1378: Mode A SQL filters (``Column.filter`` / + """Mode A SQL filters (``Column.filter`` / ``SlayerModel.filters``) must not just construct cleanly — they have to flow through enrichment without the DSL parser rejecting - arbitrary SQL function calls. Before DEV-1378 the construction + arbitrary SQL function calls. Before the fix the construction tests passed but the engine failed at first query against any such model. """ @@ -164,7 +164,7 @@ async def test_model_filter_with_json_extract_enriches(self) -> None: source_model="m", measures=[ModelMeasure(formula="amount:sum")], ) - # Bug under DEV-1378: this raised "Unknown filter function + # Bug: this raised "Unknown filter function # 'json_extract'" at enrichment time. Post-fix, it renders — the # Mode A model filter survives into the emitted WHERE clause. sql = await _engine_generate(query=query, model=model) @@ -271,40 +271,37 @@ def test_column_filter_rejects_transform_call(self) -> None: ) def test_model_filter_rejects_aggregation_colon(self) -> None: + columns = [Column(name="id", sql="id", type=DataType.INT, primary_key=True)] with pytest.raises(ValueError, match="(?i)aggregat|colon|measure|DSL"): SlayerModel( name="m", sql_table="t", data_source="test", filters=["revenue:sum > 100"], - columns=[ - Column(name="id", sql="id", type=DataType.INT, primary_key=True) - ], + columns=columns, ) def test_model_filter_rejects_transform_call(self) -> None: + columns = [Column(name="id", sql="id", type=DataType.INT, primary_key=True)] with pytest.raises(ValueError, match="(?i)transform|cumsum|DSL"): SlayerModel( name="m", sql_table="t", data_source="test", filters=["cumsum(revenue:sum) > 0"], - columns=[ - Column(name="id", sql="id", type=DataType.INT, primary_key=True) - ], + columns=columns, ) def test_model_filter_rejects_raw_over(self) -> None: """Raw OVER (...) in a model filter is rejected (existing behavior preserved).""" + columns = [Column(name="id", sql="id", type=DataType.INT, primary_key=True)] with pytest.raises(ValueError, match="(?i)window function|OVER"): SlayerModel( name="m", sql_table="t", data_source="test", filters=["row_number() over (order by mass desc) <= 3"], - columns=[ - Column(name="id", sql="id", type=DataType.INT, primary_key=True) - ], + columns=columns, ) def test_column_filter_rejects_raw_over(self) -> None: @@ -377,10 +374,9 @@ class TestDslModeRejection: """ async def test_query_filter_rejects_raw_sql_function_at_enrichment(self) -> None: - """If a user needs json_extract/coalesce/etc. they must define a Column - on the model and reference it from the DSL. The rejection fires at - enrichment time, where the DSL parser has full custom-aggregation - context and can produce an accurate ``Unknown filter function`` error. + """A function outside the Mode-B library (``initcap``) must be a Column on the model, + referenced from the DSL. The rejection fires at enrichment time, where the DSL parser has + full custom-aggregation context and can produce an accurate ``Unknown filter function`` error. """ model = SlayerModel( name="orders", @@ -394,9 +390,9 @@ async def test_query_filter_rejects_raw_sql_function_at_enrichment(self) -> None query = SlayerQuery( source_model="orders", dimensions=["id"], - filters=["json_extract(data, '$.x') > 5"], + filters=["initcap(data) = 'X'"], ) - with pytest.raises(Exception, match="(?i)function|json_extract|raw SQL|unknown|transform"): + with pytest.raises(Exception, match="(?i)function|initcap|raw SQL|unknown|transform"): await _engine_generate(query=query, model=model) async def test_query_filter_rejects_unknown_double_underscore_at_enrichment(self) -> None: @@ -494,7 +490,7 @@ async def test_unknown_canonical_agg_shaped_typo_raises_at_enrichment(self) -> N await _engine_generate(query=query, model=model) async def test_filter_referencing_unjoined_model_raises(self) -> None: - """DEV-1367: a filter like ``transportation_assets.total_vehicles >= 3`` + """A filter like ``transportation_assets.total_vehicles >= 3`` where ``transportation_assets`` is **not** in the source model's ``joins`` used to silently render SQL with an unbound table reference in the WHERE clause and fail at execution with a cryptic database @@ -515,7 +511,7 @@ async def test_filter_referencing_unjoined_model_raises(self) -> None: dimensions=["housenum"], filters=["transportation_assets.total_vehicles >= 3"], ) - # DEV-1856: an unreachable short form is route-aware-rejected (a ValueError) — still a loud raise, never silent unbound SQL (the DEV-1367 contract). + # An unreachable short form is route-aware-rejected (a ValueError) — still a loud raise, never silent unbound SQL. with pytest.raises( ValueError, match=( @@ -526,7 +522,7 @@ async def test_filter_referencing_unjoined_model_raises(self) -> None: ): await _engine_generate(query=query, model=households) - # DEV-1484 Stage C: the two former lenient-drop tests moved to producer filter + # The two former lenient-drop tests moved to producer filter # inheritance (tests/test_dev1836_filter_inheritance, test_dev1747_reroot_filter_routing). async def test_known_filter_name_passes(self) -> None: @@ -550,7 +546,7 @@ async def test_known_filter_name_passes(self) -> None: # --------------------------------------------------------------------------- -# Predicate-promotion drop (DEV-1336 reversal) +# Predicate-promotion drop # --------------------------------------------------------------------------- diff --git a/tests/test_schema_drift_typed.py b/tests/test_schema_drift_typed.py index 4e285458a..bddda35a6 100644 --- a/tests/test_schema_drift_typed.py +++ b/tests/test_schema_drift_typed.py @@ -30,6 +30,7 @@ _build_stage_graph, _filter_refs_dsl, _measure_formula_refs, + _ref_stored_edges, ) from slayer.core.syntax import ( AggCall, @@ -110,6 +111,19 @@ def test_parallel_extension_targets_unaddressable_by_bare_name(self) -> None: ref="customers.name", base_name="customers", graph=graph, ) is None + def test_extension_repeating_a_stored_join_is_that_stored_edge(self) -> None: + join = ModelJoin(target_model="customers", join_pairs=[["customer_id", "id"]]) + models = _ext_models() + models["orders"] = models["orders"].model_copy(update={"joins": [join]}) + graph = _build_stage_graph( + stage=SlayerQuery(source_model=ModelExtension(source_name="orders", joins=[join])), + stage_source_name="orders", models_by_name=models, + ) + assert _attribute_ref_to_base( + ref="customers.name", base_name="customers", graph=graph, + ) == "name" + assert [e.target_model for e in _ref_stored_edges(ref="customers.name", graph=graph)] == ["customers"] + class TestWalkParsedRefs: """The shared reference-node yielder over a ``ParsedExpr`` tree.""" diff --git a/tests/test_sql_expr.py b/tests/test_sql_expr.py index 4e3ae5ab2..cf10b1474 100644 --- a/tests/test_sql_expr.py +++ b/tests/test_sql_expr.py @@ -1,4 +1,4 @@ -"""Stage 7a.4 (DEV-1450) — Mode-A sqlglot wrapper tests. +"""Stage 7a.4 — Mode-A sqlglot wrapper tests. The public surface in ``slayer.sql.sql_expr``: @@ -100,18 +100,18 @@ def test_json_extract_other_dialects_unchanged(self): # Golden canonical output for ``log(, revenue)`` under the single-source -# DEV-1784 log-alias policy. The rewrite to a native single-arg LOG10/LOG2 only +# log-alias policy. The rewrite to a native single-arg LOG10/LOG2 only # fires where sqlglot parses the base as a literal in the ``this`` position AND # the dialect supports the native alias (SqlDialect.should_use_native_log); # elsewhere the generic 2-arg form is preserved — Presto/ClickHouse reorder to # ``LOG(revenue, )``, T-SQL/BigQuery/Oracle keep ``LOG(, revenue)``, -# and Snowflake/Redshift have LOG10 but no native LOG2. Pinned so a policy or +# and Postgres/Snowflake/Redshift have LOG10 but no native LOG2. Pinned so a policy or # sqlglot change cannot silently drift any dialect's rendering. _LOG_GOLDEN = { ('sqlite', 10): 'LOG10(revenue)', ('sqlite', 2): 'LOG2(revenue)', ('postgres', 10): 'LOG10(revenue)', - ('postgres', 2): 'LOG2(revenue)', + ('postgres', 2): 'LOG(2, revenue)', ('duckdb', 10): 'LOG10(revenue)', ('duckdb', 2): 'LOG2(revenue)', ('mysql', 10): 'LOG10(revenue)', @@ -146,9 +146,10 @@ def test_log10_preserved_on_sqlite(self): # Not rewritten to the 2-arg form. assert "log(10," not in canonical.lower().replace(" ", "") - def test_log2_preserved_on_postgres(self): + def test_log2_is_based_log_on_postgres(self): + # Postgres has no log2: the based form is the one it runs. canonical = canonicalize_sql("log2(revenue) > 1", dialect="postgres") - assert "log2" in canonical.lower() + assert "log(2," in canonical.lower().replace(" ", "") def test_explicit_2arg_log_left_alone(self): # `log(3, x)` is not a `log10`/`log2` alias — leave canonical. @@ -159,7 +160,7 @@ def test_explicit_2arg_log_left_alone(self): @pytest.mark.parametrize(("dialect", "base"), sorted(_LOG_GOLDEN)) def test_log_alias_canonical_per_dialect(self, dialect, base): """Pin ``log(, revenue)``'s canonical form for every dialect under - the single-source log-alias policy (DEV-1784), so a policy or sqlglot + the single-source log-alias policy, so a policy or sqlglot change that alters any dialect's rendering is caught.""" canonical = canonicalize_sql(f"log({base}, revenue)", dialect=dialect) assert canonical == _LOG_GOLDEN[(dialect, base)] @@ -172,7 +173,7 @@ def test_log_alias_skipped_without_a_dialect(self): def test_unregistered_sqlglot_dialect_does_not_raise(self): # canonicalize_sql is total over any sqlglot-parseable dialect: a name # outside SLayer's registry ("hive") skips the log-alias policy rather - # than raising, leaving the generic 2-arg form (DEV-1784 — Codex). + # than raising, leaving the generic 2-arg form. canonical = canonicalize_sql("log(10, revenue)", dialect="hive") assert "log(10," in canonical.lower().replace(" ", "") diff --git a/tests/test_sql_generator.py b/tests/test_sql_generator.py index d703104b6..9d0bc45a3 100644 --- a/tests/test_sql_generator.py +++ b/tests/test_sql_generator.py @@ -279,7 +279,7 @@ async def test_order_by(self, generator: SQLGenerator, orders_model: SlayerModel async def test_order_by_shorthand_descending_reaches_sql( self, generator: SQLGenerator, orders_model: SlayerModel ) -> None: - # DEV-1575: shorthand {col: "descending"} heals + normalizes and emits DESC. + # Shorthand {col: "descending"} heals + normalizes and emits DESC. query = SlayerQuery( source_model="orders", measures=[ModelMeasure(formula="*:count")], @@ -293,7 +293,7 @@ async def test_order_by_shorthand_descending_reaches_sql( async def test_order_by_ascending_synonym_not_descending( self, generator: SQLGenerator, orders_model: SlayerModel ) -> None: - # DEV-1575 regression: a canonical "ASCENDING" must normalize to asc so the generator's strict ``direction == "asc"`` check does NOT fall through to DESC. + # Regression: a canonical "ASCENDING" must normalize to asc so the generator's strict ``direction == "asc"`` check does NOT fall through to DESC. query = SlayerQuery( source_model="orders", measures=[ModelMeasure(formula="*:count")], @@ -644,7 +644,7 @@ async def test_cumsum(self, generator: SQLGenerator, orders_model: SlayerModel) async def test_cumsum_over_week_sunday_time_dim( self, generator: SQLGenerator, orders_model: SlayerModel ) -> None: - """DEV-1572 (full enum wiring): a transform over a WEEK_SUNDAY time dimension must generate valid SQL — the granularity must be wired into the interval helpers, not crash with a KeyError on the 9th enum value.""" + """Full enum wiring: a transform over a WEEK_SUNDAY time dimension must generate valid SQL — the granularity must be wired into the interval helpers, not crash with a KeyError on the 9th enum value.""" orders_model.default_time_dimension = "created_at" query = SlayerQuery( source_model="orders", @@ -761,7 +761,7 @@ async def test_windowed_sum_uses_range_join_primitive(self, generator: SQLGenera ) sql = await _generate(generator=generator, query=query, model=orders_model) norm = _norm(sql) - # DEV-1835: windowed measures now emit the unified ``_cm_`` producer CTE named after the canonical aggregate alias (``revenue_sum_window_90d``), while the surfaced output column keeps the user ``name`` (revenue_90d). + # Windowed measures now emit the unified ``_cm_`` producer CTE named after the canonical aggregate alias (``revenue_sum_window_90d``), while the surfaced output column keeps the user ``name`` (revenue_90d). assert "_cm_orders__revenue_sum_window_90d" in norm assert "LEFT JOIN" in norm assert "_src._w_time >=" in norm @@ -924,7 +924,7 @@ async def test_filter_on_windowed_measure_is_post_filter( ) sql = await _generate(generator=generator, query=query, model=orders_model) norm = _norm(sql) - # DEV-1443: the colon-syntax filter resolves to the renamed user alias. CodeRabbit nitpick: target the post-filter WHERE clause specifically — the alias surfaces in the projection too, so a generic ``in norm`` check could pass even on regression. + # The colon-syntax filter resolves to the renamed user alias. CodeRabbit nitpick: target the post-filter WHERE clause specifically — the alias surfaces in the projection too, so a generic ``in norm`` check could pass even on regression. where_clause = norm.split(" WHERE ", 1)[1] if " WHERE " in norm else "" assert '"orders.revenue_90d"' in where_clause, ( f"Filter must reference the renamed windowed measure's alias in WHERE.\nsql:\n{sql}" @@ -1032,7 +1032,7 @@ async def test_windowed_source_column_filter_wraps_case_in_src( async def test_windowed_source_column_filter_crossing_join_kept_in_src( self, generator: SQLGenerator, ) -> None: - """DEV-1714 (Codex C3): a windowed measure whose source ``Column.filter`` crosses a join must pull that join INTO ``_src`` (predicate-carrier join discovery via the resolver's filter path, not just a local CASE).""" + """A windowed measure whose source ``Column.filter`` crosses a join must pull that join INTO ``_src`` (predicate-carrier join discovery via the resolver's filter path, not just a local CASE).""" customers = SlayerModel( name="customers", sql_table="customers", data_source="test", columns=[ @@ -1066,7 +1066,7 @@ async def test_windowed_source_column_filter_crossing_join_kept_in_src( async def test_windowed_model_filter_crossing_join_kept_in_src( self, generator: SQLGenerator, ) -> None: - """DEV-1714 (Codex C3): a model-level ``SlayerModel.filters`` entry that crosses a join must pull that join INTO ``_src`` (the Mode-A filter-text carrier path, distinct from the query-filter path already pinned).""" + """A model-level ``SlayerModel.filters`` entry that crosses a join must pull that join INTO ``_src`` (the Mode-A filter-text carrier path, distinct from the query-filter path already pinned).""" customers = SlayerModel( name="customers", sql_table="customers", data_source="test", columns=[ @@ -1170,7 +1170,7 @@ async def test_windowed_date_range_not_applied_inside_src( async def test_windowed_explicit_time_filter_does_not_truncate_src( self, generator: SQLGenerator, orders_model: SlayerModel, ) -> None: - """DEV-1732: an EXPLICIT relational bound on the raw window time column is a FRAME bound, not a population filter — so it bounds ``_base`` and is stripped from ``_src``, exactly like the ``date_range`` spelling of the same intent.""" + """An EXPLICIT relational bound on the raw window time column is a FRAME bound, not a population filter — so it bounds ``_base`` and is stripped from ``_src``, exactly like the ``date_range`` spelling of the same intent.""" query = SlayerQuery( source_model="orders", time_dimensions=[TimeDimension(dimension=ColumnRef(name="created_at"), granularity=TimeGranularity.MONTH)], @@ -1181,7 +1181,7 @@ async def test_windowed_explicit_time_filter_does_not_truncate_src( assert "_cm_" in sql, sql src_body = _extract_src_body(sql) assert "2024-06-01" not in src_body, ( - f"DEV-1732: an explicit raw-time-column frame bound must be stripped " + f"An explicit raw-time-column frame bound must be stripped " f"from _src.\nsrc:\n{src_body}" ) # …but it must still bound the host grain. @@ -1573,7 +1573,7 @@ async def test_quarter_date_shift(self, generator: SQLGenerator, orders_model: S async def test_multiple_time_shifts_in_arithmetic_unique_ctes( self, generator: SQLGenerator, orders_model: SlayerModel ) -> None: - """DEV-1692: two arithmetic-wrapped time_shifts must not share a CTE name; + """Two arithmetic-wrapped time_shifts must not share a CTE name; their shared input's shifted relation is computed once.""" orders_model.default_time_dimension = "created_at" query = SlayerQuery( @@ -1596,7 +1596,7 @@ async def test_multiple_time_shifts_in_arithmetic_unique_ctes( async def test_multiple_time_shifts_resolve_to_distinct_aliases( self, generator: SQLGenerator, orders_model: SlayerModel ) -> None: - """DEV-1692: each shift keeps its own offset — no silent alias sharing.""" + """Each shift keeps its own offset — no silent alias sharing.""" orders_model.default_time_dimension = "created_at" query = SlayerQuery( source_model="orders", @@ -1645,7 +1645,7 @@ async def test_multiple_time_shifts_resolve_to_distinct_aliases( async def test_hidden_transform_name_avoids_user_measure_collision( self, generator: SQLGenerator, orders_model: SlayerModel ) -> None: - """DEV-1692: a hoisted transform must not land on a user measure's name.""" + """A hoisted transform must not land on a user measure's name.""" orders_model.default_time_dimension = "created_at" query = SlayerQuery( source_model="orders", @@ -1679,7 +1679,7 @@ async def test_hidden_transform_name_avoids_user_measure_collision( async def test_hidden_transform_name_avoids_dimension_collision( self, generator: SQLGenerator, orders_model: SlayerModel ) -> None: - """DEV-1692: dimensions alias as `.` too, so they're reserved.""" + """Dimensions alias as `.` too, so they're reserved.""" orders_model.default_time_dimension = "created_at" orders_model.columns.append( Column(name="_t0_growth", sql="customer_id", type=DataType.DOUBLE) @@ -1713,7 +1713,7 @@ async def test_hidden_transform_name_avoids_dimension_collision( async def test_dev_1692_repro_shape( self, generator: SQLGenerator, orders_model: SlayerModel ) -> None: - """DEV-1692: the reported four-measure period-over-period shape.""" + """The reported four-measure period-over-period shape.""" orders_model.default_time_dimension = "created_at" query = SlayerQuery( source_model="orders", @@ -2005,7 +2005,7 @@ async def test_dense_rank_in_filter_top_5_distinct( async def test_ntile_with_n_kwarg_in_filter( self, generator: SQLGenerator, orders_model: SlayerModel ) -> None: - """DEV-1492: ``ntile(, n=4) <= 1`` end-to-end.""" + """``ntile(, n=4) <= 1`` end-to-end.""" query = SlayerQuery( source_model="orders", dimensions=[ColumnRef(name="customer_id")], @@ -2234,7 +2234,7 @@ async def test_mixed_arithmetic_with_transform(self, generator: SQLGenerator, or async def test_emitted_sql_has_no_agg_placeholder( self, generator: SQLGenerator, orders_model: SlayerModel ) -> None: - """DEV-1341: aggregated refs nested inside non-transform calls (``nullif``) must be fully resolved — no ``__aggN__`` placeholder may leak through.""" + """Aggregated refs nested inside non-transform calls (``nullif``) must be fully resolved — no ``__aggN__`` placeholder may leak through.""" query = SlayerQuery( source_model="orders", measures=[ @@ -2534,7 +2534,7 @@ async def test_two_arg_stat_agg_generation( async def test_dev1501_two_last_diff_time_cols_multi_dialect( self, dialect: str, ) -> None: - """DEV-1501 cross-dialect: ``ORDER BY revenue:last(created_at) DESC, revenue:last(updated_at) ASC`` must materialise two distinct ranked aggregates per Tier-1 dialect, with dotted quoted aliases rendered correctly in the outer ORDER BY (no qualified-identifier misparse).""" + """Cross-dialect: ``ORDER BY revenue:last(created_at) DESC, revenue:last(updated_at) ASC`` must materialise two distinct ranked aggregates per Tier-1 dialect, with dotted quoted aliases rendered correctly in the outer ORDER BY (no qualified-identifier misparse).""" m = SlayerModel( name="orders", sql_table="public.orders", data_source="test", columns=[ @@ -2767,7 +2767,7 @@ async def test_time_dimension_sql_with_path_alias_infers_joins(self, storage) -> async def test_measure_sql_with_path_alias_infers_joins( self, engine: SlayerQueryEngine, chained_model: SlayerModel ) -> None: - """DEV-1502: measure SQL like ``customers__regions.population`` infers joins for both intermediate hops (symmetric to the dimension and time-dimension cases above).""" + """Measure SQL like ``customers__regions.population`` infers joins for both intermediate hops (symmetric to the dimension and time-dimension cases above).""" chained_model.columns.append( Column(name="region_pop_sum", sql="customers.regions.population", type=DataType.DOUBLE) ) @@ -2780,12 +2780,12 @@ async def test_measure_sql_with_path_alias_infers_joins( join_aliases = _join_aliases(sql) assert "customers" in join_aliases assert "customers__regions" in join_aliases - # The aggregate body must reference the path-aliased ref — not the bare `region_pop_sum` (which would refer to a non-existent column on `orders`). Mirrors the DEV-1494 strengthening pattern. + # The aggregate body must reference the path-aliased ref — not the bare `region_pop_sum` (which would refer to a non-existent column on `orders`). assert "SUM(customers__regions.population)" in sql class TestMeasureSourceSqlJoinInference: - """DEV-1502 → DEV-1709 (Stage 5): an AGGREGATE slot whose source ``Column.sql`` contains a ``__``-delimited join-path alias (or a sibling derived ref whose own sql does) ISOLATES into a host-rooted ``_cm_*`` CTE that pulls the implied LEFT JOINs inside its own scope (widened Law-3 trigger, D1) — so a measure-pulled join can never multiply the host rows seen by sibling measures. Row-level carriers (dimensions / WHERE filters) keep base-pulling their joins into the host ``_base`` (DEV-1484 / DEV-1494 — Law-1 territory).""" + """An AGGREGATE slot whose source ``Column.sql`` contains a ``__``-delimited join-path alias (or a sibling derived ref whose own sql does) ISOLATES into a host-rooted ``_cm_*`` CTE that pulls the implied LEFT JOINs inside its own scope (widened Law-3 trigger, D1) — so a measure-pulled join can never multiply the host rows seen by sibling measures. Row-level carriers (dimensions / WHERE filters) keep base-pulling their joins into the host ``_base`` (Law-1 territory).""" @pytest.fixture async def storage(self, tmp_path): @@ -2842,20 +2842,20 @@ def _assert_ref_only_in_val(sql: str, ref: str) -> None: norm = _norm(sql) first_proj = _re.search(rf"{_re.escape(ref)} AS _val_\d+", norm) assert first_proj is not None, ( - f"DEV-1531: expected a materialised `{ref} AS _val_` " + f"Expected a materialised `{ref} AS _val_` " f"projection inside the ranked subquery:\n{norm}" ) first_subquery = norm.find("FROM (") assert first_subquery != -1, ( - f"DEV-1531: no ranked subquery found at all in:\n{norm}" + f"No ranked subquery found at all in:\n{norm}" ) assert first_proj.start() > first_subquery, ( - f"DEV-1531: `_val` projection of `{ref}` is not inside the ranked " + f"`_val` projection of `{ref}` is not inside the ranked " f"subquery:\n{norm}" ) stripped = _re.sub(rf"{_re.escape(ref)} AS _val_\d+", "", norm) assert ref not in stripped, ( - f"DEV-1531: `{ref}` leaked outside the ranked subquery's _val " + f"`{ref}` leaked outside the ranked subquery's _val " f"projection (would fail with `no such column`):\n{norm}" ) @@ -2872,7 +2872,7 @@ async def test_local_last_with_path_aliased_derived_source( measures=[ModelMeasure(formula="region_payment:last(orders.created_at)")], ) sql = (await engine.execute(query, dry_run=True)).sql - # The crossing source isolates. It is the RANKED route (DEV-1748): a first/last isolates because it ranks, which subsumes the crossing trigger this test was written for — the verdict is the same one. + # The crossing source isolates. It is the RANKED route: a first/last isolates because it ranks, which subsumes the crossing trigger this test was written for — the verdict is the same one. assert "_cm_" in sql, f"expected an isolation CTE:\n{sql}" cm_body = _extract_cte_body(sql, r"_cm_\w+") assert "LEFT JOIN customers" in cm_body, cm_body @@ -2924,7 +2924,7 @@ async def test_filtered_last_cross_join_value_materialized( assert sql is not None norm = _norm(sql) assert "_cm_" in sql, f"expected an isolation CTE:\n{sql}" - # DEV-1832: the Column.filter MASKS the materialised value (it is not a + # The Column.filter MASKS the materialised value (it is not a # WHERE), so the crossing ref lives only inside a CASE-masked ``_val``. assert ( "CASE WHEN orders.amount > 100 THEN " @@ -2940,7 +2940,7 @@ async def test_filtered_last_cross_join_value_materialized( async def test_two_last_sharing_value_dedupe( self, engine: SlayerQueryEngine ) -> None: - """Two measures over the SAME crossing sql but DISTINCT derived columns intern to distinct ``AggregateKey``s (identity carries the column name), so each isolates into its OWN host-rooted CTE with its own ``_val`` materialisation — per-slot isolation, no CTE merging (DEV-1709 interview decision; merging is DEV-1688 / ``may_inline`` territory). Dedupe is therefore per-CTE.""" + """Two measures over the SAME crossing sql but DISTINCT derived columns intern to distinct ``AggregateKey``s (identity carries the column name), so each isolates into its OWN host-rooted CTE with its own ``_val`` materialisation — per-slot isolation, no CTE merging (merging is ``may_inline`` territory). Dedupe is therefore per-CTE.""" model = self._orders_model(extra_columns=[ Column(name="region_payment_a", sql="customers.regions.payment_amount", type=DataType.DOUBLE), @@ -3025,7 +3025,7 @@ async def test_composite_last_cross_join_source( async def test_having_last_cross_join_source( self, engine: SlayerQueryEngine ) -> None: - """An aggregate-phase query filter referencing the isolated first/last routes to the OUTER WHERE on the combined SELECT (DEV-1503 rule; HAVING-into-the-CTE would surface host rows as NULL instead of dropping them).""" + """An aggregate-phase query filter referencing the isolated first/last routes to the OUTER WHERE on the combined SELECT (HAVING-into-the-CTE would surface host rows as NULL instead of dropping them).""" model = self._orders_model(extra_columns=[ Column(name="region_payment", sql="customers.regions.payment_amount", type=DataType.DOUBLE), @@ -3273,7 +3273,7 @@ async def test_post_transform_wrapping_path_aliased_measure( async def test_multiple_aggregate_sources_sharing_join_dedupe( self, engine: SlayerQueryEngine ) -> None: - """Two DISTINCT crossing aggregates isolate into two separate host-rooted CTEs (per-AggregateKey-slot isolation), each pulling its own scope-local join set — so each hop's LEFT JOIN appears exactly once PER CTE and never in the host scope. Cross-CTE join sharing is optimizer territory (DEV-1688 / ``may_inline``).""" + """Two DISTINCT crossing aggregates isolate into two separate host-rooted CTEs (per-AggregateKey-slot isolation), each pulling its own scope-local join set — so each hop's LEFT JOIN appears exactly once PER CTE and never in the host scope. Cross-CTE join sharing is optimizer territory (``may_inline``).""" model = self._orders_model(extra_columns=[ Column( name="region_pop_sum", @@ -3343,7 +3343,7 @@ async def test_filter_and_source_cross_different_joins( name="region_pop_sum", sql="customers.regions.population", type=DataType.DOUBLE, - # Filter crosses only the customers hop — does NOT touch customers__regions. Without DEV-1502 the regions join is missing entirely. + # Filter crosses only the customers hop — does NOT touch customers__regions. Without multi-hop join inference the regions join is missing entirely. filter="customers.region_id IS NOT NULL", ), ]) @@ -3472,7 +3472,7 @@ async def test_agg_param_derived_column_path_alias_xfail( class TestDev1709WidenedIsolationShapes: - """DEV-1709 (Stage 5) — generator shapes for the widened Law-3 trigger: co-occurrence with a local first/last (DEV-1702-B1), crossing explicit time args (D2 / DEV-1501 shape update), F4 host-filter inheritance into host-rooted CTEs, and the deferred implicit-time pin.""" + """Generator shapes for the widened Law-3 trigger: co-occurrence with a local first/last, crossing explicit time args (D2 shape update), F4 host-filter inheritance into host-rooted CTEs, and the deferred implicit-time pin.""" @staticmethod def _regions_model() -> SlayerModel: @@ -3525,7 +3525,7 @@ async def _sql(self, query: SlayerQuery, orders: SlayerModel) -> str: ) async def test_crossing_sum_coexists_with_local_last(self) -> None: - """DEV-1702-B1: a regular crossing aggregate next to a local first/last isolates — it never renders in the ranked outer scope.""" + """A regular crossing aggregate next to a local first/last isolates — it never renders in the ranked outer scope.""" orders = self._orders_model(extra_columns=[ Column(name="region_pop_sum", sql="customers.regions.population", type=DataType.DOUBLE), @@ -3541,7 +3541,7 @@ async def test_crossing_sum_coexists_with_local_last(self) -> None: assert "_cm_" in sql, f"expected a crossing-input isolation CTE:\n{sql}" cm_body = _extract_cte_body(sql, r"_cm_\w+") assert "SUM(customers__regions.population)" in cm_body, sql - # Each aggregate owns a scope: the crossing SUM its own ``_cm_``, the first/last its own ``_cm_`` (DEV-1835 unified naming). Neither ref appears in the other's, and ``_base`` — which now holds nothing at all — pulls no join. + # Each aggregate owns a scope: the crossing SUM its own ``_cm_``, the first/last its own ``_cm_``. Neither ref appears in the other's, and ``_base`` — which now holds nothing at all — pulls no join. rk_body = _extract_cte_body(sql, r"_cm_\w*amount_last\w*") assert "customers__regions.population" not in rk_body, sql assert "THEN _val" in _norm(rk_body), sql @@ -3575,7 +3575,7 @@ async def test_crossing_kwarg_coexists_with_local_last(self) -> None: ) async def test_local_source_crossing_time_arg_isolates(self) -> None: - """D2: ``amount:last(customers.signup_at)`` — a local source with a crossing explicit time arg isolates; the arg's join and ORDER BY ref live inside the CTE's ranked subquery (DEV-1501 shape update).""" + """D2: ``amount:last(customers.signup_at)`` — a local source with a crossing explicit time arg isolates; the arg's join and ORDER BY ref live inside the CTE's ranked subquery.""" orders = self._orders_model() query = SlayerQuery( source_model="orders", @@ -3721,7 +3721,7 @@ async def test_filter_only_composite_with_crossing_leaf(self) -> None: ) async def test_ranked_isolation_survives_the_recursion_guard(self) -> None: - """Two same-sql, different-CAST-type crossing first/lasts get a ranked producer scope EACH, and each materialises its own type-distinct value (DEV-1838 D4: the kernel form of the DEV-1709 type-distinctness pin).""" + """Two same-sql, different-CAST-type crossing first/lasts get a ranked producer scope EACH, and each materialises its own type-distinct value (the kernel form of the type-distinctness pin).""" orders = self._orders_model(extra_columns=[ Column(name="region_pay_d", sql="customers.regions.population * 2", type=DataType.DOUBLE), @@ -3757,7 +3757,7 @@ async def test_ranked_isolation_survives_the_recursion_guard(self) -> None: async def test_a_ranked_sibling_no_longer_drags_a_kwarg_into_its_scope( self, ) -> None: - """A crossing KWARG next to a first/last: the ranking has its own producer scope (DEV-1838 D4), so the crossing kwarg lives in ITS OWN producer and the ranked producer neither sees it nor is affected.""" + """A crossing KWARG next to a first/last: the ranking has its own producer scope, so the crossing kwarg lives in ITS OWN producer and the ranked producer neither sees it nor is affected.""" orders = self._orders_model(extra_columns=[ Column(name="region_weight", sql="customers.regions.weight", type=DataType.DOUBLE), @@ -3787,7 +3787,7 @@ async def test_a_ranked_sibling_no_longer_drags_a_kwarg_into_its_scope( assert "customers__regions.weight" in wa_body, sql assert "LEFT JOIN regions AS customers__regions" in wa_body, sql - # DEV-1835: local first/last desugar to the unified _cm_ producer and isolate universally; the crossing default-time first/last (formerly strict-xfail) now isolates. + # Local first/last desugar to the unified _cm_ producer and isolate universally; the crossing default-time first/last (formerly strict-xfail) now isolates. async def test_implicit_crossing_default_time_isolates_xfail(self) -> None: orders = self._orders_model( extra_columns=[ @@ -3910,7 +3910,7 @@ async def test_filtered_custom_agg_does_not_case_wrap_literal_param( measures=[ModelMeasure(formula="active_revenue:scaled_sum")], ) sql = await _generate(generator=gen, query=query, model=agg_model) - # Literal 100 must not be inside CASE WHEN; the value column must be. status is undeclared, so the Mode-A door qualifies it to the scope root (DEV-1745 W1). + # Literal 100 must not be inside CASE WHEN; the value column must be. status is undeclared, so the Mode-A door qualifies it to the scope root. assert "CASE WHEN sales.status = 'active' THEN 100" not in sql assert "/ 100" in sql assert "CASE WHEN sales.status = 'active' THEN" in sql @@ -3918,7 +3918,7 @@ async def test_filtered_custom_agg_does_not_case_wrap_literal_param( async def test_filtered_weighted_avg_does_not_mask_the_weight( self, gen: SQLGenerator, agg_model: SlayerModel, ) -> None: - """DEV-1832: a Column.filter masks only its own column's value. The + """A Column.filter masks only its own column's value. The ``active_price`` value is masked, but ``weight=quantity`` is NOT — a param is masked solely by its own column's filter, never the source's.""" agg_model.columns.append( @@ -3938,7 +3938,7 @@ async def test_filtered_weighted_avg_does_not_mask_the_weight( sql = await _generate(generator=gen, query=query, model=agg_model) # The mask wraps only the value — read twice (numerator, non-NULL test); # the weight rides bare. (``status`` is undeclared, so the door qualifies it - # to the root — DEV-1745 W1.) + # to the root.) assert sql.count("CASE WHEN sales.status = 'active'") == 2 assert "'active' THEN sales.quantity" not in sql @@ -3986,7 +3986,7 @@ async def test_unfiltered_measure_no_case(self, generator: SQLGenerator, orders_ async def test_filtered_weighted_avg_masks_only_the_value( self, generator: SQLGenerator, orders_model: SlayerModel, ) -> None: - """DEV-1832 reverses CodeRabbit #10: a Column.filter masks only its own + """A Column.filter masks only its own value, never a parameter. So ``active_revenue:weighted_avg(weight=quantity)`` masks the numerator's value but the denominator is the bare ``SUM(quantity)`` — the weight is masked only if ITS column carries a filter.""" @@ -4022,7 +4022,7 @@ async def test_mixed_filtered_and_unfiltered(self, generator: SQLGenerator, orde async def test_filtered_last_masks_the_value_over_full_ranking( self, generator: SQLGenerator, orders_model: SlayerModel, ) -> None: - """DEV-1832: a filtered ``last`` MASKS the picked value; it does NOT + """A filtered ``last`` MASKS the picked value; it does NOT restrict the ranked rows. The ranking spans every row (no filter WHERE) and the value column is CASE-masked, so a non-matching newest row picks NULL. A row restriction belongs in a query filter, not the column.""" @@ -4050,7 +4050,7 @@ async def test_filtered_first_masks_the_value_over_full_ranking( self, generator: SQLGenerator, orders_model: SlayerModel, ) -> None: """The same for ``first``: no WHERE; the value is masked and the ranking - runs ascending over every row (DEV-1832).""" + runs ascending over every row.""" orders_model.default_time_dimension = "created_at" orders_model.columns.append( Column(name="completed_balance", sql="amount", filter="status = 'completed'", type=DataType.DOUBLE) @@ -4092,7 +4092,7 @@ async def test_mixed_filtered_and_unfiltered_last( self, generator: SQLGenerator, orders_model: SlayerModel, ) -> None: """A filtered and an unfiltered ``last`` are two aggregates, so two CTEs — - both ranking over the full row set (DEV-1832: a Column.filter masks the + both ranking over the full row set (a Column.filter masks the value, it is not a WHERE), the filtered one carrying its CASE mask.""" orders_model.default_time_dimension = "created_at" orders_model.columns.append(Column(name="balance", sql="amount", type=DataType.DOUBLE)) @@ -4244,7 +4244,7 @@ async def test_two_filtered_lasts_same_source_different_filters_dont_collide( ) -> None: """Two filtered ``last`` measures over the same base column but DIFFERENT filtered columns each get their own ranked CTE — distinct source - ColumnSqlKeys never collide (DEV-1832). Each carries its own CASE mask; + ColumnSqlKeys never collide. Each carries its own CASE mask; neither restricts the ranking with a WHERE.""" orders_model.default_time_dimension = "created_at" orders_model.columns.append( @@ -4311,7 +4311,7 @@ async def test_union_select_rejected(self, orders_model: SlayerModel) -> None: await _generate(generator=generator, query=query, model=orders_model) def test_block_comment_passes_through_safely(self, orders_model: SlayerModel) -> None: - """``/* ... */`` block comments survive ``Column`` construction — DEV-1369's SQL-mode validator does not parse them, only checks for DSL constructs (aggregation colon syntax, transform calls, ``OVER``).""" + """``/* ... */`` block comments survive ``Column`` construction — the SQL-mode validator does not parse them, only checks for DSL constructs (aggregation colon syntax, transform calls, ``OVER``).""" col = Column( name="benign", sql="amount", @@ -4619,11 +4619,13 @@ async def test_local_filter_on_constant_dimension(self, generator: SQLGenerator) ) sql = await _generate(generator, query, model) assert "premium.1" not in sql, f"Constant SQL '1' was table-qualified: {sql}" - # The constant should appear unqualified in WHERE. DEV-1361 wraps a non-bare ``Column.sql`` (literal ``1``) in CAST when ``type`` is set. + # The constant appears unqualified in WHERE: a non-bare ``Column.sql`` (literal ``1``) is CAST to its ``type``, + # and the TEXT literal beside that number converts to one. assert ( "1 = '1'" in sql or "1 = 1" in sql or "CAST(1 AS DOUBLE PRECISION) = '1'" in sql + or "CAST(1 AS DOUBLE PRECISION) = 1" in sql ) async def test_cross_model_filter_on_constant_dimension(self, generator: SQLGenerator) -> None: @@ -4656,11 +4658,13 @@ async def test_cross_model_filter_on_constant_dimension(self, generator: SQLGene ) sql = await _generate(generator, query, policy_amount, extra_models=[premium_model]) assert "premium.1" not in sql, f"Constant SQL '1' was table-qualified: {sql}" - # The constant should appear unqualified in WHERE. DEV-1361 wraps a non-bare ``Column.sql`` (literal ``1``) in CAST when ``type`` is set. + # The constant appears unqualified in WHERE: a non-bare ``Column.sql`` (literal ``1``) is CAST to its ``type``, + # and the TEXT literal beside that number converts to one. assert ( "1 = '1'" in sql or "1 = 1" in sql or "CAST(1 AS DOUBLE PRECISION) = '1'" in sql + or "CAST(1 AS DOUBLE PRECISION) = 1" in sql ) async def test_local_filter_on_expression_dimension(self, generator: SQLGenerator) -> None: @@ -5066,7 +5070,7 @@ class TestParameterizedAggCanonicalDistinct: async def test_order_by_two_last_with_different_time_cols( self, generator: SQLGenerator ) -> None: - """DEV-1501: two ORDER BY entries `revenue:last(created_at)` and `revenue:last(updated_at)` must produce DISTINCT ranked aggregates and not collapse onto one. The hidden materialised aggregates must be absent from the public projection (the result keys stay ``orders.status`` + ``orders._count``).""" + """Two ORDER BY entries `revenue:last(created_at)` and `revenue:last(updated_at)` must produce DISTINCT ranked aggregates and not collapse onto one. The hidden materialised aggregates must be absent from the public projection (the result keys stay ``orders.status`` + ``orders._count``).""" m = SlayerModel( name="orders", sql_table="orders", data_source="test", @@ -5196,7 +5200,7 @@ async def _persist_and_engine( ds_name: str = "test", ds_type: str = "postgres", ): - """Yield a ``SlayerQueryEngine`` with the given models persisted to a throwaway ``YAMLStorage``. Replaces the per-test ``tempfile + YAMLStorage + save_datasource + save_model + SlayerQueryEngine`` boilerplate that DEV-1501 repeated 16+ times — same shape, but one line at the call site. ``ds_name`` / ``ds_type`` follow the repo-wide convention (``data_source="test"`` everywhere).""" + """Yield a ``SlayerQueryEngine`` with the given models persisted to a throwaway ``YAMLStorage``. Replaces the per-test ``tempfile + YAMLStorage + save_datasource + save_model + SlayerQueryEngine`` boilerplate that was repeated 16+ times — same shape, but one line at the call site. ``ds_name`` / ``ds_type`` follow the repo-wide convention (``data_source="test"`` everywhere).""" with tempfile.TemporaryDirectory() as tmp: storage = YAMLStorage(base_dir=tmp) await storage.save_datasource( @@ -5208,7 +5212,7 @@ async def _persist_and_engine( def _orders_with_paid_amount_model() -> SlayerModel: - """DEV-1501 fixture-style helper — an ``orders`` model with a FILTERED ``paid_amount`` column (only ``status='paid'`` rows participate). Used by the filtered-first/last test suite (3+ tests share this exact model).""" + """Fixture-style helper — an ``orders`` model with a FILTERED ``paid_amount`` column (only ``status='paid'`` rows participate). Used by the filtered-first/last test suite (3+ tests share this exact model).""" return SlayerModel( name="orders", sql_table="orders", data_source="test", columns=[ @@ -5225,7 +5229,7 @@ def _orders_with_paid_amount_model() -> SlayerModel: def _orders_two_ts_model(*, default_td: "str | None" = None) -> SlayerModel: - """DEV-1501 fixture-style helper — an ``orders`` model with TWO timestamp columns so first/last with different explicit time args can be exercised. ``default_td`` optionally sets ``default_time_dimension`` to test the "no explicit arg, fall back to default" path.""" + """Fixture-style helper — an ``orders`` model with TWO timestamp columns so first/last with different explicit time args can be exercised. ``default_td`` optionally sets ``default_time_dimension`` to test the "no explicit arg, fall back to default" path.""" return SlayerModel( name="orders", sql_table="orders", data_source="test", default_time_dimension=default_td, @@ -5240,7 +5244,7 @@ def _orders_two_ts_model(*, default_td: "str | None" = None) -> SlayerModel: class TestDev1501HiddenFirstLastRender: - """DEV-1501 — first/last aggregates reached only through ORDER BY, HAVING or a composite must still be materialised, must not collapse onto one another, and must not surface in the public projection.""" + """First/last aggregates reached only through ORDER BY, HAVING or a composite must still be materialised, must not collapse onto one another, and must not surface in the public projection.""" @staticmethod def _ranked_ctes(sql: str) -> "list[str]": @@ -5510,7 +5514,7 @@ async def test_filtered_first_last_in_having_uses_filtered_rn( self, generator: SQLGenerator ) -> None: """A FILTERED ``last(time_col)`` (``Column.filter`` set) referenced from a - filter MASKS its value over the full ranking (DEV-1832) — no WHERE + filter MASKS its value over the full ranking — no WHERE restricts the ranked rows; the value column is CASE-masked.""" async with _persist_and_engine(_orders_with_paid_amount_model()) as engine: query = SlayerQuery( @@ -5562,7 +5566,7 @@ async def test_filtered_first_last_in_nested_having_uses_filtered_rn( async def test_composite_only_first_last_triggers_ranked_subquery( self, generator: SQLGenerator ) -> None: - """A query whose ONLY first/last reference is INSIDE a composite aggregate (no direct first/last sibling) must still materialise each operand. Codex review of DEV-1501 PR #159 round 4.""" + """A query whose ONLY first/last reference is INSIDE a composite aggregate (no direct first/last sibling) must still materialise each operand. Codex review of PR #159 round 4.""" async with _persist_and_engine(_orders_two_ts_model()) as engine: query = SlayerQuery( source_model="orders", @@ -5594,7 +5598,7 @@ async def test_composite_only_first_last_triggers_ranked_subquery( async def test_composite_first_last_without_default_time_dim_raises( self, generator: SQLGenerator ) -> None: - """A composite measure containing a first/last operand without explicit time arg AND no model ``default_time_dimension`` must raise the "first/last requires a ranking time column" error. Without composite-aware validation in ``_build_first_last_base_select``, the query bypasses the check and ``_build_unfiltered_rn_columns`` emits ``ORDER BY None``. Codex review of DEV-1501 PR #159 round 5.""" + """A composite measure containing a first/last operand without explicit time arg AND no model ``default_time_dimension`` must raise the "first/last requires a ranking time column" error. Without composite-aware validation in ``_build_first_last_base_select``, the query bypasses the check and ``_build_unfiltered_rn_columns`` emits ``ORDER BY None``. Codex review of PR #159 round 5.""" # ``_orders_two_ts_model()`` has no ``default_time_dimension``. async with _persist_and_engine(_orders_two_ts_model()) as engine: query = SlayerQuery( @@ -5611,7 +5615,7 @@ async def test_composite_first_last_without_default_time_dim_raises( async def test_composite_first_last_with_joined_time_arg_adds_join( self, generator: SQLGenerator ) -> None: - """A composite measure containing a first/last operand with a JOINED explicit time arg (``revenue:last(customers.signed_up_at) + 1``) must pull the ``customers`` join into the FROM so the ranked subquery's ORDER BY can reference ``customers.signed_up_at``. Without composite-aware path discovery in ``_collect_joined_paths_for_base``, the join is missing and the SQL references an unjoined alias. Codex review of DEV-1501 PR #159 round 5.""" + """A composite measure containing a first/last operand with a JOINED explicit time arg (``revenue:last(customers.signed_up_at) + 1``) must pull the ``customers`` join into the FROM so the ranked subquery's ORDER BY can reference ``customers.signed_up_at``. Without composite-aware path discovery in ``_collect_joined_paths_for_base``, the join is missing and the SQL references an unjoined alias. Codex review of PR #159 round 5.""" customers = SlayerModel( name="customers", sql_table="customers", data_source="test", columns=[ @@ -5655,7 +5659,7 @@ async def test_filtered_composite_first_last_uses_filtered_rn( ) -> None: """A FILTERED first/last operand inside a composite projection (``paid_amount:last(created_at) + 1``) MASKS its value over the full - ranking (DEV-1832) — no WHERE restricts the ranked rows.""" + ranking — no WHERE restricts the ranked rows.""" async with _persist_and_engine(_orders_with_paid_amount_model()) as engine: query = SlayerQuery( source_model="orders", @@ -5758,7 +5762,7 @@ async def test_cross_model_query_with_local_first_last_having_filter( ) sql = (await engine.execute(query, dry_run=True)).sql _assert_valid_sql(sql, dialect=generator.dialect) - # Three scopes, each owning one thing: ``_base`` the grain, the cross-model SUM's ``_cm_`` CTE, and the ranking's own ``_cm_`` CTE (DEV-1835 unified naming; the ranked one carries ``_last``). + # Three scopes, each owning one thing: ``_base`` the grain, the cross-model SUM's ``_cm_`` CTE, and the ranking's own ``_cm_`` CTE (the ranked one carries ``_last``). base_sql = _extract_cte_body(sql, r"_base") assert "ROW_NUMBER" not in base_sql, base_sql assert "_cm_" in sql, sql @@ -5775,7 +5779,7 @@ async def test_cross_model_filtered_last_in_having( ) -> None: """A FILTERED cross-model ``last()`` (``Column.filter`` set on the joined model's column) referenced from a query filter MASKS its value over the - full ranking of the target's rows (DEV-1832) — no WHERE narrows them; the + full ranking of the target's rows — no WHERE narrows them; the outer predicate applies where the masked value is readable.""" customers = SlayerModel( name="customers", sql_table="customers", data_source="test", @@ -5830,7 +5834,7 @@ async def test_cross_model_filtered_last_in_having( async def test_derived_time_arg_pulls_in_referenced_join( self, generator: SQLGenerator, ) -> None: - """DEV-1501 (Codex round 8): a DERIVED first/last time arg whose ``Column.sql`` references a joined column must pull that join into the base FROM. Join discovery (``_resolve_agg_inputs_via_scope`` via ``_explicit_time_arg_of``) registers it, and the ranked plan expands ``net_signed_at.sql = "customers.signed_up_at"`` so the ranked subquery's ``ORDER BY`` emits ``customers.signed_up_at``; without a corresponding ``LEFT JOIN customers`` the SQL is broken. Previously ``_collect_joined_paths_for_base`` only walked ``ColumnKey`` args; ``ColumnSqlKey`` derived time args were invisible to join discovery.""" + """A DERIVED first/last time arg whose ``Column.sql`` references a joined column must pull that join into the base FROM. Join discovery (``_resolve_agg_inputs_via_scope`` via ``_explicit_time_arg_of``) registers it, and the ranked plan expands ``net_signed_at.sql = "customers.signed_up_at"`` so the ranked subquery's ``ORDER BY`` emits ``customers.signed_up_at``; without a corresponding ``LEFT JOIN customers`` the SQL is broken. Previously ``_collect_joined_paths_for_base`` only walked ``ColumnKey`` args; ``ColumnSqlKey`` derived time args were invisible to join discovery.""" customers = SlayerModel( name="customers", sql_table="customers", data_source="test", columns=[ @@ -5875,7 +5879,7 @@ async def test_derived_time_arg_pulls_in_referenced_join( assert "customers.signed_up_at" in sql, ( f"Expected expanded customers.signed_up_at ranking expression in SQL:\n{sql}" ) - # The customers join must be present in the base FROM. Without the DEV-1501 fix, ``_collect_joined_paths_for_base`` skipped the ColumnSqlKey arg and the join was missing → broken SQL. + # The customers join must be present in the base FROM. Without the fix, ``_collect_joined_paths_for_base`` skipped the ColumnSqlKey arg and the join was missing → broken SQL. assert _re.search( r"LEFT JOIN\s+customers\b", sql, _re.IGNORECASE, ) is not None, ( @@ -5885,7 +5889,7 @@ async def test_derived_time_arg_pulls_in_referenced_join( class TestDev1501BroadTriggerAndGuards: - """DEV-1501 — broad-trigger materialise+trim behaviour and the guards Codex flagged: the wrap is conditional, hidden ROW order targets must not be materialised (cardinality preserved), composite hidden order is explicitly NotImplementedError, dim-only-dedup grain is preserved.""" + """Broad-trigger materialise+trim behaviour and the guards Codex flagged: the wrap is conditional, hidden ROW order targets must not be materialised (cardinality preserved), composite hidden order is explicitly NotImplementedError, dim-only-dedup grain is preserved.""" async def test_outer_wrap_only_when_hidden_present( self, generator: SQLGenerator @@ -6084,7 +6088,7 @@ async def test_order_by_with_limit_offset_on_outer_wrap( async def test_c13_duplicate_aliases_with_outer_wrap( self, generator: SQLGenerator ) -> None: - """DEV-1450 C13 — two declared measures with the same structural key but different ``name``s intern to ONE slot carrying TWO ``public_aliases``. Under the new outer trim wrap, BOTH aliases must appear in the outer projection (mirroring the transform path's ``outer_alias_index``).""" + """Two declared measures with the same structural key but different ``name``s intern to ONE slot carrying TWO ``public_aliases``. Under the new outer trim wrap, BOTH aliases must appear in the outer projection (mirroring the transform path's ``outer_alias_index``).""" m = _orders_two_ts_model(default_td="created_at") async with _persist_and_engine(m) as engine: query = SlayerQuery( @@ -6173,7 +6177,7 @@ async def test_composite_filter_materialises_aggregate_leaves( def test_hidden_composite_order_accepted_at_input_validation( self, generator: SQLGenerator ) -> None: - """DEV-1733 INVERTED this contract.""" + """This contract was INVERTED.""" for text in ("revenue:sum - cost:sum", "revenue - cost"): item = OrderItem.model_validate({"column": text, "direction": "desc"}) assert item.column.name == "_expr_pending" @@ -6346,7 +6350,7 @@ def _models(self): Column(name="total_policy_amount", sql="policy_amount", type=DataType.DOUBLE)], joins=[ # No reverse edge onto policy: the policy → policy_amount - # declaration traverses both ways (DEV-1853). + # declaration traverses both ways. ModelJoin(target_model="premium", join_pairs=[["policy_amount_identifier", "policy_amount_identifier"]], join_type="inner"), ModelJoin(target_model="agreement_party_role", join_pairs=[["policy_identifier", "agreement_identifier"]], join_type="inner"), ], @@ -6379,7 +6383,7 @@ async def _setup_engine(self, *models): yield SlayerQueryEngine(storage=storage) async def test_rerooted_cte_includes_reachable_and_sibling_filters(self, generator, _models): - """DEV-1836 D3: the re-rooted producer includes filters REACHABLE from the target root — the target-path filter (``policy_amount.premium.has_premium``) AND the host-sibling filter (``agreement_party_role``): the root's own provably to-one join reaches the sibling, so it inherits instead of dropping (the Q9 shape). Nothing warns.""" + """The re-rooted producer includes filters REACHABLE from the target root — the target-path filter (``policy_amount.premium.has_premium``) AND the host-sibling filter (``agreement_party_role``): the root's own provably to-one join reaches the sibling, so it inherits instead of dropping (the Q9 shape). Nothing warns.""" policy, policy_amount, premium, agreement_party_role = _models async with self._setup_engine(policy, policy_amount, premium, agreement_party_role) as engine: query = SlayerQuery( @@ -6426,7 +6430,7 @@ async def test_rerooted_cte_without_filters(self, generator, _models): async def test_rerooted_unreachable_dims_and_filters_dropped(self, generator): """Unattributable dims broadcast; the host-branch filter pushes into the - CTE as a correlated EXISTS (DEV-1840). CTE produces scalar CROSS JOIN.""" + CTE as a correlated EXISTS. CTE produces scalar CROSS JOIN.""" # orders → customers join, but customers has NO join back to orders. Dimension 'status' is on orders (unreachable from customers). Filter on 'warehouse' reaches the CTE root only across the inverted orders hop. orders = SlayerModel( name="orders", sql_table="orders", data_source="test", @@ -6467,7 +6471,7 @@ async def test_rerooted_unreachable_dims_and_filters_dropped(self, generator): _assert_valid_sql(sql) # CTE: FROM customers, no GROUP BY (status unreachable); the - # warehouse filter restricts the population via EXISTS (DEV-1840). + # warehouse filter restricts the population via EXISTS. cm_cte_start = sql.find("_cm_") cte_section = sql[cm_cte_start:sql.find(")\nSELECT", cm_cte_start)] assert "FROM customers" in cte_section or "FROM\n customers" in cte_section @@ -6563,7 +6567,7 @@ async def test_rerooted_custom_agg_in_filter(self, generator): Column(name="id", type=DataType.DOUBLE, primary_key=True), Column(name="name", type=DataType.TEXT), Column(name="lifetime_value", sql="lifetime_value", type=DataType.DOUBLE)], - # No reverse edge: orders → customers traverses both ways (DEV-1853). + # No reverse edge: orders → customers traverses both ways. ) async with self._setup_engine(orders, customers) as engine: query = SlayerQuery( @@ -6581,7 +6585,7 @@ class TestOrderByCustomFieldName: """ORDER BY must work when fields have custom names via {"formula": ..., "name": ...}.""" async def test_order_by_custom_name(self, generator: SQLGenerator) -> None: - """Field with custom name 'num_customers' is the surfaced alias and ORDER BY references it directly (DEV-1335 — user ``name`` overrides the canonical ``customer_id_count_distinct`` form).""" + """Field with custom name 'num_customers' is the surfaced alias and ORDER BY references it directly (user ``name`` overrides the canonical ``customer_id_count_distinct`` form).""" model = SlayerModel( name="orders", sql_table="orders", @@ -6661,7 +6665,7 @@ async def test_order_by_custom_name_in_computed_query(self, generator: SQLGenera sql = await _generate(generator, query, model) assert "ORDER BY" in sql order_clause = sql.split("ORDER BY", 1)[1] - # User name is the ORDER BY column (DEV-1335 — user ``name`` overrides the canonical form). + # User name is the ORDER BY column (user ``name`` overrides the canonical form). assert '"orders.num_customers"' in order_clause, ( f"user alias must surface in ORDER BY for computed query path:\n{sql}" ) @@ -7085,15 +7089,15 @@ async def test_formula_over_isolated_measures( assert len(cm_cte_names) >= 2, ( f"Expected ≥ 2 _cm_ CTEs, got {len(cm_cte_names)}: {cm_cte_names}\n{sql}" ) - # Both filter-target INNER joins must live INSIDE the per-measure ``_cm_*`` CTEs, NEVER in the host ``_base`` body. Inline rendering of the composite would re-introduce them and the intersection bug DEV-1503 set out to eliminate. + # Both filter-target INNER joins must live INSIDE the per-measure ``_cm_*`` CTEs, NEVER in the host ``_base`` body. Inline rendering of the composite would re-introduce them and the intersection bug. base_body = _extract_cte_body(sql, r"_base") assert "Loss_Payment" not in base_body, ( f"Composite over isolated aggregates leaked Loss_Payment join " - f"into _base — DEV-1503 isolation regressed:\n{base_body}" + f"into _base — isolation regressed:\n{base_body}" ) assert "Loss_Reserve" not in base_body, ( f"Composite over isolated aggregates leaked Loss_Reserve join " - f"into _base — DEV-1503 isolation regressed:\n{base_body}" + f"into _base — isolation regressed:\n{base_body}" ) # The composite alias must appear in the OUTER combined SELECT (after all CTEs), referencing both ``_cm_*`` joined-back columns. last_cte_close = sql.rfind("\n)") @@ -7258,7 +7262,7 @@ async def test_cm_cte_skips_filters_on_unavailable_tables(self, generator: SQLGe sql = await _generate(generator, query, orders, extra_models=[customers, warehouse]) # The _cm_ CTE reaches "warehouse" only inside the correlated EXISTS - # (DEV-1840) — never as a cardinality-changing join of the CTE body. + # — never as a cardinality-changing join of the CTE body. cm_start = sql.index("_cm_") cm_end = sql.index("\n)", cm_start) cm_body = sql[cm_start:cm_end] @@ -7451,7 +7455,7 @@ async def test_mixed_isolated_and_local_first_last( assert "ROW_NUMBER" in cm_body, ( f"{pattern} must carry its own ranking:\n{cm_body}" ) - # DEV-1832: the filtered one MASKS its value rather than narrowing rows — + # The filtered one MASKS its value rather than narrowing rows — # neither ranked CTE carries a WHERE; only the filtered one has a CASE. payment_body = _extract_cte_body(sql, r"_cm_\w*latest_payment\w*") assert "WHERE" not in _extract_cte_body(sql, r"_cm_\w*total_amount\w*"), sql @@ -7670,7 +7674,7 @@ async def test_mixed_operand_aggregate_filter_promotes_hidden_operand( sql = await self._sql(claim_amount_model, related_models, query) assert "1000" in sql assert "10" in sql - # DEV-1838 D5: each conjunct routes to its own scope — the local operand stays a HAVING on _base (value-identical to the old outer-WHERE), the isolated aggregate's goes to the outer combined WHERE. + # Each conjunct routes to its own scope — the local operand stays a HAVING on _base (value-identical to the old outer-WHERE), the isolated aggregate's goes to the outer combined WHERE. base_body = _extract_cte_body(sql, r"_base") assert _re.search(r"SUM\(\s*claim_amount\.amount\s*\)\s*>\s*10", base_body), ( f"Expected HAVING SUM(claim_amount.amount) > 10 for the local " @@ -7963,7 +7967,7 @@ async def test_aggregate_filter_with_date_range_routes_correctly( async def test_order_by_projected_composite_over_isolated_resolves_at_combined( self, generator: SQLGenerator, claim_amount_model, related_models, ) -> None: - """A query whose ORDER BY references a PROJECTED composite over isolated filtered-local aggregates must resolve the order alias at the combined SELECT level — NOT ``_base.""`` (the alias is no longer materialised in ``_base`` after DEV-1503 routing).""" + """A query whose ORDER BY references a PROJECTED composite over isolated filtered-local aggregates must resolve the order alias at the combined SELECT level — NOT ``_base.""`` (the alias is no longer materialised in ``_base`` after isolation routing).""" query = SlayerQuery( source_model="claim_amount", measures=[ @@ -8054,7 +8058,7 @@ async def test_local_first_last_with_routed_cross_model_filter( sql = await self._sql( claim_amount_model_with_time, related_models, query, ) - # DEV-1836: the routed cross-model aggregate-phase filter lands as an OUTER WHERE on the producer's attached value — once, and never inside the host ``_base`` ranked subquery (double-application bug). + # The routed cross-model aggregate-phase filter lands as an OUTER WHERE on the producer's attached value — once, and never inside the host ``_base`` ranked subquery (double-application bug). norm = _norm(sql) tail = norm[norm.rfind("WHERE"):] assert tail.startswith("WHERE"), norm @@ -8202,7 +8206,7 @@ async def test_filtered_local_in_source_queries_smoke( # Filtered measure isolated into its own _cm_ CTE; the subquery FROM for the host renders inside it. assert "_cm_" in sql assert "loss_payment_amt" in sql - # Host's sql=... subquery renders inside the _cm_ CTE (sqlglot may pretty-print, so check whitespace-tolerantly); the mixed-case table Claim_Amount is quoted on emit (DEV-1645). + # Host's sql=... subquery renders inside the _cm_ CTE (sqlglot may pretty-print, so check whitespace-tolerantly); the mixed-case table Claim_Amount is quoted on emit. sql_collapsed = _re.sub(r"\s+", " ", sql) assert 'SELECT * FROM "Claim_Amount"' in sql_collapsed, ( f"host subquery FROM should render inside the _cm_ CTE:\n{sql}" @@ -8254,7 +8258,7 @@ async def capture_sql(sql): # Expression measure must NOT be corrupted: "orders.COALESCE(amount, 0)" is invalid assert "orders.COALESCE" not in sql, f"Expression measure corrupted:\n{sql}" assert "orders.amount" in sql - # Bare ``amount`` inside the expression now qualifies to the model's alias (``orders.amount``) — derived-ref expansion (DEV-1333) makes every base-column reference unambiguous. + # Bare ``amount`` inside the expression now qualifies to the model's alias (``orders.amount``) — derived-ref expansion makes every base-column reference unambiguous. assert "COALESCE(orders.amount, 0)" in sql async def test_cross_model_measures_probed_via_engine(self) -> None: @@ -8286,7 +8290,7 @@ async def test_cross_model_measures_probed_via_engine(self) -> None: mock_ds.get_connection_string.return_value = "sqlite://" mock_ds.type = "sqlite" - # Real attribute, not an auto-Mock: it feeds the cache key's credential digest (DEV-1755), which hashes it. + # Real attribute, not an auto-Mock: it feeds the cache key's credential digest, which hashes it. mock_ds.credentials_json = None with patch.object(engine, "_resolve_datasource", new_callable=AsyncMock, return_value=mock_ds): async def capture_types(sql): @@ -8332,20 +8336,20 @@ def test_explicit_empty_allowed_aggregations_skips_probe(self) -> None: ) -# DEV-1337: per-alias allowlists for "natively supports single-arg log10/log2" rendering. Outside these sets the current 2-arg LOG(base, x) form is kept. Mirrored in slayer/sql/generator.py — keep in sync. +# Per-alias allowlists for "natively supports single-arg log10/log2" rendering. Outside these sets the current 2-arg LOG(base, x) form is kept. Mirrored in slayer/sql/generator.py — keep in sync. _LOG10_NATIVE_DIALECTS = frozenset({ "sqlite", "postgres", "duckdb", "mysql", "clickhouse", "snowflake", "bigquery", "redshift", "trino", "presto", "databricks", "spark", "tsql", }) _LOG2_NATIVE_DIALECTS = frozenset({ - "sqlite", "postgres", "duckdb", "mysql", "clickhouse", - "bigquery", "trino", "presto", "databricks", "spark", + "sqlite", "duckdb", "mysql", "clickhouse", + "trino", "presto", "databricks", "spark", }) class TestLogAliasPreservation: - """DEV-1337 — user-written ``log10(x)`` / ``log2(x)`` must round-trip verbatim in emitted SQL on dialects that natively support those single-arg aliases. sqlglot's default behaviour normalises both into a generic ``Log(this=Literal(base), expression=arg)`` AST node and re-emits as ``LOG(base, x)`` for almost every dialect, which makes generated SQL diverge from the recipe formula text and (on dialects that lack 2-arg ``LOG``) can break a previously working call.""" + """User-written ``log10(x)`` / ``log2(x)`` must round-trip verbatim in emitted SQL on dialects that natively support those single-arg aliases. sqlglot's default behaviour normalises both into a generic ``Log(this=Literal(base), expression=arg)`` AST node and re-emits as ``LOG(base, x)`` for almost every dialect, which makes generated SQL diverge from the recipe formula text and (on dialects that lack 2-arg ``LOG``) can break a previously working call.""" @pytest.fixture def log_model(self) -> SlayerModel: @@ -8417,8 +8421,10 @@ async def test_log2_in_column_sql_is_preserved( f"{dialect}: should not canonicalise to LOG(amount, 2):\n{sql}" ) else: - # Fallback for tsql / oracle / redshift / snowflake (no native LOG2). - assert "LOG(2,ORDERS.AMOUNT)" in upper_no_ws or "LOG(ORDERS.AMOUNT,2)" in upper_no_ws, ( + # Fallback for postgres / tsql / oracle / redshift / snowflake (no native LOG2); Postgres's + # LOG(b, x) takes NUMERIC only. + assert ("LOG(2,ORDERS.AMOUNT)" in upper_no_ws or "LOG(ORDERS.AMOUNT,2)" in upper_no_ws + or "LOG(2,CAST(ORDERS.AMOUNTASDECIMAL))" in upper_no_ws), ( f"{dialect}: expected fallback LOG(base,x) form, got:\n{sql}" ) @@ -8493,7 +8499,8 @@ async def test_log_with_non_alias_base_unchanged( f"{dialect}: must not invent LOG3() — only base 10 and 2 are aliased:\n{sql}" ) # The 2-arg form must remain in some arg order. - assert "LOG(3,ORDERS.AMOUNT)" in upper_no_ws or "LOG(ORDERS.AMOUNT,3)" in upper_no_ws, ( + assert ("LOG(3,ORDERS.AMOUNT)" in upper_no_ws or "LOG(ORDERS.AMOUNT,3)" in upper_no_ws + or "LOG(3,CAST(ORDERS.AMOUNTASDECIMAL))" in upper_no_ws), ( f"{dialect}: expected 2-arg LOG(3, amount) preserved, got:\n{sql}" ) @@ -8513,7 +8520,7 @@ async def test_ln_unchanged( assert "LN2(" not in sql.upper() -# DEV-1336 — window functions in filters (single-stage) +# Window functions in filters (single-stage) @pytest.fixture @@ -8537,7 +8544,7 @@ def planets_model() -> SlayerModel: class TestWindowFunctionInFilter: - """DEV-1369 (reverses DEV-1336): a query filter that references a ``Column`` whose ``sql`` contains a window function (``OVER (...)``) no longer auto-promotes to a post-aggregation outer WHERE. The rank-family transforms (``rank`` / ``percent_rank`` / ``dense_rank`` / ``ntile``) cover top-N filtering in pure DSL, so the escape hatch is redundant. The engine raises a clear error directing the user to those transforms or to a multi-stage source_queries model.""" + """A query filter that references a ``Column`` whose ``sql`` contains a window function (``OVER (...)``) no longer auto-promotes to a post-aggregation outer WHERE. The rank-family transforms (``rank`` / ``percent_rank`` / ``dense_rank`` / ``ntile``) cover top-N filtering in pure DSL, so the escape hatch is redundant. The engine raises a clear error directing the user to those transforms or to a multi-stage source_queries model.""" async def test_filter_on_windowed_column_raises( self, generator: SQLGenerator, planets_model: SlayerModel, @@ -8571,7 +8578,7 @@ async def test_select_only_on_windowed_column_unchanged( ) -# DEV-1361: Type-aware CAST emission driven by Column.type / ModelMeasure.type. +# Type-aware CAST emission driven by Column.type / ModelMeasure.type. class TestCastEmissionColumn: @@ -8768,7 +8775,7 @@ async def test_opaque_column_emits_no_cast_when_projected(self) -> None: assert "UNKNOWN" not in sql.upper() async def test_opaque_column_allowed_as_raw_row_projection(self) -> None: - """Raw-row mode (``distinct_dimension_values=False``, no measures, DEV-1543) emits no top-level GROUP BY, so projecting an opaque column as a "dimension" is legal — only grouping is refused. Regression guard: the opaque-dimension check must NOT fire when the query doesn't group.""" + """Raw-row mode (``distinct_dimension_values=False``, no measures) emits no top-level GROUP BY, so projecting an opaque column as a "dimension" is legal — only grouping is refused. Regression guard: the opaque-dimension check must NOT fire when the query doesn't group.""" model = SlayerModel( name="places", sql_table="public.places", @@ -8847,7 +8854,7 @@ async def test_measure_type_double_on_ratio(self, orders_model) -> None: class TestCastEmissionNonBasePaths: - """DEV-1361 follow-up: ``ModelMeasure.type`` and ``Column.type`` must wrap aggregation expressions in CAST across every emission path — not just the base ``_generate_base()`` path. Covers windowed CTEs, isolated filtered measure CTEs, percentile/median/stat-agg/weighted-avg builders.""" + """``ModelMeasure.type`` and ``Column.type`` must wrap aggregation expressions in CAST across every emission path — not just the base ``_generate_base()`` path. Covers windowed CTEs, isolated filtered measure CTEs, percentile/median/stat-agg/weighted-avg builders.""" @pytest.fixture def orders_model_for_window(self) -> SlayerModel: @@ -8886,7 +8893,7 @@ async def test_windowed_sum_with_measure_type_wraps_in_cast( ) orders_model_for_window.name = "orders_for_window" sql = await _generate(gen, query, orders_model_for_window) - # The windowed CTE itself must contain the CAST around SUM(_src._w_value). DEV-1835: unified ``_cm_`` prefix, named after the canonical aggregate. + # The windowed CTE itself must contain the CAST around SUM(_src._w_value). Unified ``_cm_`` prefix, named after the canonical aggregate. assert "_cm_orders_for_window__revenue_sum_window_90d" in sql # CAST(SUM(...) AS DOUBLE) shape inside the windowed CTE. norm = _norm(sql).upper() @@ -8896,7 +8903,7 @@ async def test_windowed_sum_with_measure_type_wraps_in_cast( async def test_windowed_sum_no_measure_type_casts_inferred_type( self, orders_model_for_window: SlayerModel, ) -> None: - """DEV-1714 decision: with no EXPLICIT measure type, the windowed aggregation still CASTs on the type inferred from the source column (``revenue`` is ``DOUBLE``) — exactly as a plain aggregate does in the base path (DEV-1361). A windowed sum and a plain sum of the same no-type measure must emit identical CAST behavior; the legacy explicit-only distinction no longer exists on the typed pipeline.""" + """With no EXPLICIT measure type, the windowed aggregation still CASTs on the type inferred from the source column (``revenue`` is ``DOUBLE``) — exactly as a plain aggregate does in the base path. A windowed sum and a plain sum of the same no-type measure must emit identical CAST behavior; the legacy explicit-only distinction no longer exists on the typed pipeline.""" gen = SQLGenerator(dialect="postgres") query = SlayerQuery( source_model="orders_for_window2", @@ -8978,7 +8985,7 @@ async def test_weighted_avg_uses_column_type_for_inner_cast(self) -> None: class TestStringHygieneDialectTranslation: - """DEV-1378: lowercase string-hygiene operators are pass-through to the emitted SQL string, then re-parsed by sqlglot under the target dialect at WHERE-assembly. sqlglot's per-dialect emitter chooses each dialect's preferred spelling. These tests pin the actual emitted SQL across SQLite / Postgres / MySQL / DuckDB / ClickHouse so a future sqlglot upgrade that changes the spelling is caught.""" + """Lowercase string-hygiene operators are pass-through to the emitted SQL string, then re-parsed by sqlglot under the target dialect at WHERE-assembly. sqlglot's per-dialect emitter chooses each dialect's preferred spelling. These tests pin the actual emitted SQL across SQLite / Postgres / MySQL / DuckDB / ClickHouse so a future sqlglot upgrade that changes the spelling is caught.""" @pytest.mark.parametrize( "dialect,expected", @@ -8987,7 +8994,7 @@ class TestStringHygieneDialectTranslation: ("postgres", "LOWER(orders.status) = 'active'"), ("mysql", "LOWER(orders.status) = 'active'"), ("duckdb", "LOWER(orders.status) = 'active'"), - ("clickhouse", "LOWER(orders.status) = 'active'"), + ("clickhouse", "lowerUTF8(orders.status) = 'active'"), ], ) async def test_lower(self, orders_model: SlayerModel, dialect: str, expected: str) -> None: @@ -9008,9 +9015,10 @@ async def test_lower(self, orders_model: SlayerModel, dialect: str, expected: st [ ("sqlite", "INSTR(orders.status, ',')"), ("postgres", "POSITION(',' IN orders.status)"), - ("mysql", "LOCATE(',', orders.status)"), + ("mysql", "LOCATE(\n CAST(',' AS CHAR CHARACTER SET utf8mb4) COLLATE utf8mb4_bin,\n" + " CAST(orders.status AS CHAR CHARACTER SET utf8mb4) COLLATE utf8mb4_bin\n )"), ("duckdb", "STRPOS(orders.status, ',')"), - ("clickhouse", "POSITION(orders.status, ',')"), + ("clickhouse", "positionUTF8(orders.status, ',')"), ], ) async def test_instr_translates_per_dialect( @@ -9035,7 +9043,7 @@ async def test_instr_translates_per_dialect( ("postgres", "SUBSTRING(orders.status FROM 1 FOR 5)"), ("mysql", "SUBSTRING(orders.status, 1, 5)"), ("duckdb", "SUBSTRING(orders.status, 1, 5)"), - ("clickhouse", "SUBSTRING(orders.status, 1, 5)"), + ("clickhouse", "substringUTF8(orders.status, 1, 5)"), ], ) async def test_substr_translates_per_dialect( @@ -9081,7 +9089,7 @@ async def test_concat_via_pipe_pipe_translates_per_dialect( class TestReplaceFunctionInPredicate: - """DEV-1378: pin the ``replace(...)``-as-Command parsing trap.""" + """Pin the ``replace(...)``-as-Command parsing trap.""" @pytest.mark.parametrize("dialect", ["sqlite", "mysql"]) async def test_replace_in_query_filter( @@ -9128,7 +9136,7 @@ async def test_replace_in_column_filter( def _build_score_model_dev1539(*, name: str = "m", score_sql: str) -> SlayerModel: - """DEV-1539 test helper: build a minimal model with four numeric columns (``a, b, c, d``) and a derived ``score`` column whose ``sql`` is the multi-term expression under test. Used by both the local- branch positive test and the SQLite integration test so the model setup boilerplate isn't duplicated across files (Sonar ``new_duplicated_lines_density``).""" + """Test helper: build a minimal model with four numeric columns (``a, b, c, d``) and a derived ``score`` column whose ``sql`` is the multi-term expression under test. Used by both the local- branch positive test and the SQLite integration test so the model setup boilerplate isn't duplicated across files (Sonar ``new_duplicated_lines_density``).""" return SlayerModel( name=name, sql_table=f"public.{name}", @@ -9145,7 +9153,7 @@ def _build_score_model_dev1539(*, name: str = "m", score_sql: str) -> SlayerMode def _build_backslash_risk_model_dev1539(*, name: str = "m") -> tuple[SlayerModel, str]: - """DEV-1539 test helper: build a model with a ``risk`` column whose ``sql`` contains a literal double-backslash inside a string literal. Returns ``(model, double_backslash_literal)``. Used by both the WHERE-side and HAVING-side backslash-safety tests.""" + """Test helper: build a model with a ``risk`` column whose ``sql`` contains a literal double-backslash inside a string literal. Returns ``(model, double_backslash_literal)``. Used by both the WHERE-side and HAVING-side backslash-safety tests.""" backslash = chr(92) double_bs = backslash * 2 # SQL literal `'\\'` (two backslashes) model = SlayerModel( @@ -9168,7 +9176,7 @@ def _build_backslash_risk_model_dev1539(*, name: str = "m") -> tuple[SlayerModel async def _build_joined_customers_orders_engine_dev1539( *, tmp_path, customers_score_sql: str, ) -> SlayerQueryEngine: - """DEV-1539 test helper: spin up a storage-backed engine with an ``orders`` model joined to a ``customers`` model whose ``score`` / derived column carries ``customers_score_sql``. Used by the dotted joined-column wrap test and the dotted-branch backslash-safety test so the storage + join boilerplate isn't duplicated.""" + """Test helper: spin up a storage-backed engine with an ``orders`` model joined to a ``customers`` model whose ``score`` / derived column carries ``customers_score_sql``. Used by the dotted joined-column wrap test and the dotted-branch backslash-safety test so the storage + join boilerplate isn't duplicated.""" storage = YAMLStorage(base_dir=str(tmp_path)) await storage.save_datasource(DatasourceConfig(name="test", type="postgres")) await storage.save_model(SlayerModel( @@ -9197,7 +9205,7 @@ async def _build_joined_customers_orders_engine_dev1539( class TestFilterOuterParenWrapDev1539: - """DEV-1539: defensive outer-paren wrapping at every site where a multi-term expression gets plopped into a filter context.""" + """Defensive outer-paren wrapping at every site where a multi-term expression gets plopped into a filter context.""" async def test_filter_inlines_multiterm_local_column_with_outer_parens( self, generator: SQLGenerator, @@ -9836,7 +9844,7 @@ async def test_rewrite_mangles_the_final_public_projection( class TestCrossModelAggregateSourceSqlJoinInference: - """DEV-1526 harvest (Stage 1): a CROSS-MODEL aggregate whose TARGET column's ``Column.sql`` crosses a FURTHER join must pull the implied LEFT JOINs into the per-plan ``_cm_*`` CTE body. The fix lands Stage 4 (Law-1 inside the CTE ScopeFrame); the discovery tests are pinned strict-xfail until then. ``test_bare_target_column_no_spurious_join_in_cte`` stays green (a bare cross-model aggregate already works). Chain: ``orders_x → customers_v2 → regions → countries``.""" + """A CROSS-MODEL aggregate whose TARGET column's ``Column.sql`` crosses a FURTHER join must pull the implied LEFT JOINs into the per-plan ``_cm_*`` CTE body. The fix lands Stage 4 (Law-1 inside the CTE ScopeFrame); the discovery tests are pinned strict-xfail until then. ``test_bare_target_column_no_spurious_join_in_cte`` stays green (a bare cross-model aggregate already works). Chain: ``orders_x → customers_v2 → regions → countries``.""" @pytest.fixture async def storage(self, tmp_path): @@ -10083,7 +10091,7 @@ async def test_deeper_join_only_in_cte_not_host_base(self, storage) -> None: class TestWindowedMeasureGuards: - """DEV-1496 harvest (Stage 1): windowed measures must emit a ``_wm_`` range-join CTE and RAISE loudly on shapes the primitive does not support, rather than silently degrade to a plain grouped aggregate. Today the typed pipeline drops ``window=`` silently, so every guard is pinned strict-xfail to Stage 10 (DEV-1714). The composite/hidden/mixed guards are DEV-1504.""" + """Windowed measures must emit a ``_wm_`` range-join CTE and RAISE loudly on shapes the primitive does not support, rather than silently degrade to a plain grouped aggregate. Today the typed pipeline drops ``window=`` silently, so every guard is pinned strict-xfail to Stage 10.""" @pytest.fixture def orders_model(self) -> SlayerModel: @@ -10103,7 +10111,7 @@ async def test_windowed_non_sum_avg_raises(self, orders_model: SlayerModel) -> N time_dimensions=[TimeDimension(dimension=ColumnRef(name="created_at"), granularity=TimeGranularity.MONTH)], measures=[{"formula": "revenue:min(window='30d')", "name": "rev_w"}], ) - # DEV-1915 lift: window= is no longer restricted to sum/avg; min renders. + # window= is no longer restricted to sum/avg; min renders. sql = await _engine_generate(query=query, model=orders_model) assert_scope_closed(sql, dialect="postgres") assert "__regroup__" not in sql @@ -10143,7 +10151,7 @@ async def test_windowed_cross_model_raises(self, tmp_path) -> None: time_dimensions=[TimeDimension(dimension=ColumnRef(name="created_at"), granularity=TimeGranularity.MONTH)], measures=[{"formula": "customers.revenue:sum(window='30d')", "name": "rev_w"}], ) - # DEV-1836: fails closed with a precise attributability ValueError (the active time dimension is a host column, unreachable from customers). + # Fails closed with a precise attributability ValueError (the active time dimension is a host column, unreachable from customers). with pytest.raises(ValueError, match="attributable from"): await engine.execute(query, dry_run=True) @@ -10157,7 +10165,7 @@ async def test_windowed_with_transform_raises(self, orders_model: SlayerModel) - {"formula": "time_shift(revenue:sum, -1)", "name": "rev_prev"}, ], ) - # DEV-1835: a windowed measure coexisting with a transform sibling now renders; the SQL must be scope-closed with __regroup__ lowered away. + # A windowed measure coexisting with a transform sibling now renders; the SQL must be scope-closed with __regroup__ lowered away. sql = await _engine_generate(query=query, model=orders_model) assert_scope_closed(sql, dialect="postgres") assert "__regroup__" not in sql @@ -10169,7 +10177,7 @@ async def test_windowed_as_transform_input_raises(self, orders_model: SlayerMode time_dimensions=[TimeDimension(dimension=ColumnRef(name="created_at"), granularity=TimeGranularity.MONTH)], measures=[{"formula": "cumsum(revenue:sum(window='90d'))", "name": "cum_w"}], ) - # DEV-1835 lift: a windowed aggregate feeding a transform now renders instead of raising; the emitted SQL must be scope-closed and fully lowered (no ``__regroup__`` sentinel). + # A windowed aggregate feeding a transform now renders instead of raising; the emitted SQL must be scope-closed and fully lowered (no ``__regroup__`` sentinel). sql = await _engine_generate(query=query, model=orders_model) assert_scope_closed(sql, dialect="postgres") assert "__regroup__" not in sql @@ -10180,7 +10188,7 @@ async def test_windowed_in_arithmetic_raises(self, orders_model: SlayerModel) -> time_dimensions=[TimeDimension(dimension=ColumnRef(name="created_at"), granularity=TimeGranularity.MONTH)], measures=[{"formula": "revenue:sum(window='90d') / 2", "name": "half_w"}], ) - # DEV-1835 lift: a windowed aggregate inside scalar arithmetic now renders instead of raising; scope-closed and fully lowered. + # A windowed aggregate inside scalar arithmetic now renders instead of raising; scope-closed and fully lowered. sql = await _engine_generate(query=query, model=orders_model) assert_scope_closed(sql, dialect="postgres") assert "__regroup__" not in sql @@ -10192,7 +10200,7 @@ async def test_windowed_filter_only_hidden_raises(self, orders_model: SlayerMode measures=[{"formula": "revenue:sum", "name": "rev"}], filters=["revenue:sum(window='90d') > 100"], ) - # DEV-1835 lift: a filter-only (hidden) windowed aggregate now renders instead of raising; scope-closed and fully lowered. + # A filter-only (hidden) windowed aggregate now renders instead of raising; scope-closed and fully lowered. sql = await _engine_generate(query=query, model=orders_model) assert_scope_closed(sql, dialect="postgres") assert "__regroup__" not in sql @@ -10204,7 +10212,7 @@ async def test_windowed_mixed_aggregate_filter_raises(self, orders_model: Slayer measures=[{"formula": "revenue:sum(window='90d')", "name": "rev_w"}], filters=["revenue:sum(window='90d') > 100 and revenue:sum > 50"], ) - # DEV-1835 lift: a filter mixing a windowed and a plain aggregate now renders instead of raising; scope-closed and fully lowered. + # A filter mixing a windowed and a plain aggregate now renders instead of raising; scope-closed and fully lowered. sql = await _engine_generate(query=query, model=orders_model) assert_scope_closed(sql, dialect="postgres") assert "__regroup__" not in sql @@ -10244,7 +10252,7 @@ async def test_windowed_non_string_duration_raises(self, orders_model: SlayerMod await _engine_generate(query=query, model=orders_model) async def test_custom_aggregation_with_window_raises(self) -> None: - """DEV-1915: a custom model-level aggregation accepts ``window=`` like any + """A custom model-level aggregation accepts ``window=`` like any built-in; its formula renders over the trailing interval's rows.""" model = SlayerModel( name="orders", sql_table="public.orders", data_source="test", @@ -10274,7 +10282,7 @@ async def test_windowed_transform_input_precedence_not_selected( time_dimensions=[TimeDimension(dimension=ColumnRef(name="created_at"), granularity=TimeGranularity.MONTH)], measures=[{"formula": "cumsum(revenue:sum(window='90d'))", "name": "cum_w"}], ) - # DEV-1835: the G4/G6 guards are gone — a windowed aggregate nested in a transform now renders; the SQL must be scope-closed and fully lowered. + # The G4/G6 guards are gone — a windowed aggregate nested in a transform now renders; the SQL must be scope-closed and fully lowered. sql = await _engine_generate(query=query, model=orders_model) assert_scope_closed(sql, dialect="postgres") assert "__regroup__" not in sql @@ -10307,7 +10315,7 @@ def _bundle(model: SlayerModel, referenced=None) -> ResolvedSourceBundle: return ResolvedSourceBundle(dialect="postgres", source_model=model, referenced_models=referenced or []) if case == "g1_non_sum_avg": - # DEV-1915 lift: window= is no longer sum/avg-only — min plans cleanly. + # window= is no longer sum/avg-only — min plans cleanly. q = SlayerQuery(source_model="orders", time_dimensions=td, measures=[{"formula": "revenue:min(window='30d')", "name": "rev_w"}]) bundle, exc, match = _bundle(_plain()), None, None @@ -10334,7 +10342,7 @@ def _bundle(model: SlayerModel, referenced=None) -> ResolvedSourceBundle: ) q = SlayerQuery(source_model="orders", time_dimensions=td, measures=[{"formula": "customers.revenue:sum(window='30d')", "name": "rev_w"}]) - # DEV-1836: windowed cross-model with an unattributable TD → ValueError. + # Windowed cross-model with an unattributable TD → ValueError. bundle, exc, match = _bundle(orders, [customers]), ValueError, "attributable from" elif case == "g4_transform": model = _plain() @@ -10343,24 +10351,24 @@ def _bundle(model: SlayerModel, referenced=None) -> ResolvedSourceBundle: {"formula": "revenue:sum(window='90d')", "name": "rev_w"}, {"formula": "time_shift(revenue:sum, -1)", "name": "rev_prev"}, ]) - # DEV-1835 lift: G4 dissolved — this now plans instead of raising. + # G4 dissolved — this now plans instead of raising. bundle, exc, match = _bundle(model), None, None elif case == "g5_arithmetic": q = SlayerQuery(source_model="orders", time_dimensions=td, measures=[{"formula": "revenue:sum(window='90d') / 2", "name": "half_w"}]) - # DEV-1835 lift: G5 dissolved — this now plans instead of raising. + # G5 dissolved — this now plans instead of raising. bundle, exc, match = _bundle(_plain()), None, None elif case == "g6_hidden": q = SlayerQuery(source_model="orders", time_dimensions=td, measures=[{"formula": "revenue:sum", "name": "rev"}], filters=["revenue:sum(window='90d') > 100"]) - # DEV-1835 lift: G6 dissolved — this now plans instead of raising. + # G6 dissolved — this now plans instead of raising. bundle, exc, match = _bundle(_plain()), None, None elif case == "g7_mixed": q = SlayerQuery(source_model="orders", time_dimensions=td, measures=[{"formula": "revenue:sum(window='90d')", "name": "rev_w"}], filters=["revenue:sum(window='90d') > 100 and revenue:sum > 50"]) - # DEV-1835 lift: G7 dissolved — this now plans instead of raising. + # G7 dissolved — this now plans instead of raising. bundle, exc, match = _bundle(_plain()), None, None else: # g8_malformed q = SlayerQuery(source_model="orders", time_dimensions=td, @@ -10368,7 +10376,7 @@ def _bundle(model: SlayerModel, referenced=None) -> ResolvedSourceBundle: bundle, exc, match = _bundle(_plain()), ValueError, "Use syntax like" if exc is None: - # DEV-1835 lift: the dissolved guards (g4–g7) now plan without error. + # The dissolved guards (g4–g7) now plan without error. planned = plan_query(query=q, bundle=bundle) assert planned is not None else: @@ -10401,7 +10409,7 @@ async def test_windowed_mixed_row_filter_raises(self, orders_model: SlayerModel) measures=[{"formula": "revenue:sum(window='90d')", "name": "rev_w"}], filters=["revenue:sum(window='90d') > 100 and status = 'active'"], ) - # DEV-1835 lift: a filter mixing a windowed aggregate with a row predicate now renders instead of raising; scope-closed and fully lowered. + # A filter mixing a windowed aggregate with a row predicate now renders instead of raising; scope-closed and fully lowered. sql = await _engine_generate(query=query, model=orders_model) assert_scope_closed(sql, dialect="postgres") assert "__regroup__" not in sql