diff --git a/benchmarks/duckshop/README.md b/benchmarks/duckshop/README.md index 00872da018..912a28a15a 100644 --- a/benchmarks/duckshop/README.md +++ b/benchmarks/duckshop/README.md @@ -119,10 +119,13 @@ project and does not change it: - raw `edge__*` sources in `sources/edge_cases.yml`, loaded by `python/loaders/edge_cases.py` from fixed rows that `data_scale` does not change, so core data and core expectations stay the same; - Python functions in `functions/python/edge_*.py`, tagged `edge_case`, and their tests in - `tests/unit/functions/python/test_edge_*.sql`. + `tests/unit/functions/python/test_edge_*.sql`; +- a SQL table function, `functions/sql/edge_basket_lines_for.sql`, and a JavaScript function, + `edge_running_peaks`, that a pre-hook of `int_edge_basket_running_peaks` creates + (`models/intermediate/edge_cases/_sqlbuild/_hooks/sql/`) and SQLBuild does not declare. -It has 72 models (12 staging, 50 intermediate, 10 marts), 5 Python functions, 97 unit tests and 4 -scenarios, in eight groups: +It has 160 models (13 staging, 133 intermediate, 14 marts), 5 Python functions, a SQL table +function, a hook-created JavaScript function, 185 unit tests and 4 scenarios, in nine groups: | Group | Covers | |-------|--------| @@ -134,6 +137,7 @@ scenarios, in eight groups: | Lineage and analysis | clauses whose columns decide rows without being output (`WHERE`, `QUALIFY`, `GROUP BY` by position and `ALL`, `ORDER BY` under `LIMIT`, `EXISTS`, a `FLATTEN` input, `ROLLUP` by position, `EXCEPT` under `LIMIT`); `RIGHT JOIN ... USING`, `NATURAL JOIN`, a `USING` key under a later outer join, and unmatched `ASOF JOIN` rows; `CONNECT BY` beside a column named `level`; a recursive CTE without `RECURSIVE` whose columns shift per iteration; `LAST_DAY` with a date part; positional columns and the names Snowflake gives unaliased expressions; `TEXT(5)` and widened `COUNT` contracts | | Python functions | volatile tokens and numbers from a column, a constant and no argument, and `DIV0` of a volatile call beside look-alike names, checked by assertions that hold for any values; a handler answering NULL input without `STRICT`; Python `None` as JSON null, and datetimes, Decimals and integers past 2^53 handed to `VARIANT` and `FLOAT` results | | Scenarios and lifecycle | typed values across model boundaries; `VARIANT` expected output; a star under a lower-case contract and a quoted camelCase export; a snapshot keyed and compared on quoted camelCase columns; a cursor-window incremental model over far-apart fixture loads; a change log merged across two loads, checked against a full rebuild | +| Translation refusals | one model per construct that translation tools refuse or guard, most putting a construct refused only under strict checking before one refused by default, so a model shows both: `FLOAT` values through sums, averages, running totals, arrays, objects, `HASH`, `TO_CHAR` and `::NUMBER(38, 10)`; `VARIANT` dates, decimals and XML; `ARRAY_AGG` without `WITHIN GROUP`, sparse arrays and `ARRAY(NUMBER)` casts; `REDUCE`, `FILTER` and `TRANSFORM` lambdas; patterns and `REGEXP_REPLACE` replacements built from columns, and lazy patterns; `TRY_TO_DATE` with a format from a column; zoned literals, `CONVERT_TIMEZONE` from `CURRENT_TIMESTAMP`, `SEQ8`, `GENERATOR` with an expression `ROWCOUNT`; `PIVOT`, `ANY_VALUE`, `IGNORE NULLS` around `IFF`, unaliased columns read by Snowflake's name, `UNION` branches whose column is always NULL; `TO_NUMBER`, `TO_DECIMAL` and `TRY_BASE64_DECODE_BINARY`; an open (uncontracted) source `edge__supplier_notes`, the table function and the hook-created function. `rpt_edge_case_model_keys` and `rpt_edge_case_array_model_keys` read every model in the group, so a refusal there also refuses a downstream model | Unit-test expectations in the edge-case area are captured on Snowflake under the `edge` target's pinned session, rather than derived by hand; scenario expectations, and the assertions in tests @@ -158,6 +162,10 @@ earlier ones: same results on every run: added SKUs are sorted, the weekday average utilisation is an exact decimal sum over a count, the busiest slot of equally busy ones is the earliest, and the top exception code of equally frequent ones is the first in alphabetical order. +- The mocks of `stg_wishlist_items`, `stg_purchase_order_lines` and `int_loyalty_tier_changes` in + three unit tests list their columns in the models' declared order, which unit-test planning + requires for a `SELECT *` reader. Only compiled tests change; compiled models are the same, so + model benchmarks stay comparable. ## Status @@ -200,7 +208,7 @@ The edge-case area, verified on Snowflake with SQLBuild built after 0.185.0 on t | Step | Result | |------|--------| | `sqb build --select tag:edge_case` | Passes; the disabled model is skipped | -| `sqb test --select tag:edge_case` | 62 of 62 pass | +| `sqb test --select tag:edge_case` | 62 of 62 pass; with SQLBuild 0.187.0, 185 of 185 pass | | `sqb scenario test --select edge_cases` | 4 of 4 pass | | Two-load replay of the delivery change log | The merged status equals the full rebuild after each load | diff --git a/benchmarks/duckshop/RUNBOOK.md b/benchmarks/duckshop/RUNBOOK.md index 2c78605335..c766ae9abe 100644 --- a/benchmarks/duckshop/RUNBOOK.md +++ b/benchmarks/duckshop/RUNBOOK.md @@ -182,6 +182,12 @@ the area's Python functions (`functions/python/edge_*.py`, tagged `edge_case`), models and runs their tests and audits. `fct_edge_delivery_events` is disabled and reports `skip: disabled` (see [Pending acceptance cases](#pending-acceptance-cases)). +`int_edge_basket_running_peaks` calls `edge_running_peaks`, a JavaScript function its pre-hook +creates in the target schema. SQLBuild does not declare it, so the model's unit test needs a build +of that model first, and the model calls the function without a schema: set `database` and +`schema` on the edge connection as well as on the target, so that the session's current schema is +the target schema. `relations.py drop` drops the function too. + `int_edge_ticket_tokens` calls volatile Python functions, so its values change on every run; its test compares only the deterministic columns and asserts facts that hold for any values, such as every token being distinct. diff --git a/benchmarks/duckshop/project/functions/sql/edge_basket_lines_for.sql b/benchmarks/duckshop/project/functions/sql/edge_basket_lines_for.sql new file mode 100644 index 0000000000..b2905062a5 --- /dev/null +++ b/benchmarks/duckshop/project/functions/sql/edge_basket_lines_for.sql @@ -0,0 +1,29 @@ +FUNCTION ( + description "Lines of one basket with their SKU and tag, for the edge-case table-function reader", + tags [edge_case], + arguments (p_basket_id VARCHAR), + returns table ( + line_id VARCHAR, + line_no INT, + sku VARCHAR, + tag VARCHAR + ) +); + +WITH lines AS ( + SELECT * + FROM __ref("stg_edge_basket_lines") +), + +final AS ( + SELECT + l.line_id, + l.line_no, + l.sku, + l.tag + FROM lines AS l + WHERE l.basket_id = p_basket_id +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/_sqlbuild/_hooks/sql/create_edge_running_peaks.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/_sqlbuild/_hooks/sql/create_edge_running_peaks.sql new file mode 100644 index 0000000000..747d176f3a --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/_sqlbuild/_hooks/sql/create_edge_running_peaks.sql @@ -0,0 +1,24 @@ +HOOK ( + description """ + Create the edge-case JavaScript function edge_running_peaks, which turns a list of numbers into + the running maximum at each position. SQLBuild does not declare functions a hook creates. + """, +); + +CREATE OR REPLACE FUNCTION @@CTX:destination.database.@@CTX:destination.schema.edge_running_peaks( + line_numbers ARRAY +) +RETURNS ARRAY +LANGUAGE JAVASCRIPT +AS $$ + var peaks = []; + var peak = null; + for (var i = 0; i < LINE_NUMBERS.length; i++) { + var value = LINE_NUMBERS[i]; + if (value !== null && (peak === null || value > peak)) { + peak = value; + } + peaks.push(peak); + } + return peaks; +$$ diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_amount_percent_texts.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_amount_percent_texts.sql new file mode 100644 index 0000000000..d2fec03578 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_amount_percent_texts.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per reconciliation check with a third of its amount as a percentage written with a + number format of four whole digits + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + amount_percent (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + a.check_id, + TO_VARCHAR(ROUND(a.amount * 100 / 3, 1), 'FM9990.0') || '%' AS amount_percent + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_basket_distinct_tags.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_basket_distinct_tags.sql new file mode 100644 index 0000000000..c9c716f5dc --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_basket_distinct_tags.sql @@ -0,0 +1,23 @@ +MODEL ( + description """ + One row per distinct tag of the basket lines, held as VARIANT and read back as text + """, + tags [edge_case], + columns ( + tag_text (type VARCHAR, nullable false, audits [not_null, unique]), + ), +); + +WITH distinct_tags AS ( + SELECT DISTINCT TO_VARIANT(l.tag) AS tag_value + FROM __ref("stg_edge_basket_lines") AS l +), + +final AS ( + SELECT d.tag_value::VARCHAR AS tag_text + FROM distinct_tags AS d + WHERE d.tag_value IS NOT NULL +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_basket_line_lookups.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_basket_line_lookups.sql new file mode 100644 index 0000000000..58c5747e88 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_basket_line_lookups.sql @@ -0,0 +1,22 @@ +MODEL ( + description """ + One row per line of one fixed basket, read through the edge-case table function + """, + tags [edge_case], + columns ( + line_id (type VARCHAR, nullable false, audits [not_null, unique]), + line_no (type INT), + sku (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + l.line_id, + l.line_no, + l.sku + FROM __table_fn("edge_basket_lines_for")('B-1') AS l +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_basket_running_peaks.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_basket_running_peaks.sql new file mode 100644 index 0000000000..60821b3ef3 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_basket_running_peaks.sql @@ -0,0 +1,33 @@ +MODEL ( + description """ + One row per basket with the last running peak of its line numbers, from a JavaScript + function that a pre-hook creates and SQLBuild does not declare + """, + tags [edge_case], + pre_hooks [sql("create_edge_running_peaks")], + columns ( + basket_id (type VARCHAR, nullable false, audits [not_null, unique]), + peak_count (type NUMBER(38, 0)), + last_peak (type NUMBER(38, 0)), + ), +); + +WITH peaks AS ( + SELECT + l.basket_id, + edge_running_peaks(ARRAY_AGG(l.line_no) WITHIN GROUP (ORDER BY l.line_no)) AS peaks + FROM __ref("stg_edge_basket_lines") AS l + GROUP BY + l.basket_id +), + +final AS ( + SELECT + p.basket_id, + ARRAY_SIZE(p.peaks)::NUMBER(38, 0) AS peak_count, + p.peaks[ARRAY_SIZE(p.peaks) - 1]::NUMBER(38, 0) AS last_peak + FROM peaks AS p +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_basket_sku_part_filters.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_basket_sku_part_filters.sql new file mode 100644 index 0000000000..a56b86960c --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_basket_sku_part_filters.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per basket line with the number of parts of its SKU longer than one character, kept + by FILTER + """, + tags [edge_case], + columns ( + line_id (type VARCHAR, nullable false, audits [not_null, unique]), + long_part_count (type NUMBER(38, 0)), + ), +); + +WITH final AS ( + SELECT + l.line_id, + ARRAY_SIZE(FILTER(SPLIT(l.sku, '-'), part -> LENGTH(part) > 1))::NUMBER(38, 0) AS long_part_count + FROM __ref("stg_edge_basket_lines") AS l +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_basket_tag_list_reads.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_basket_tag_list_reads.sql new file mode 100644 index 0000000000..a727a5c5e0 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_basket_tag_list_reads.sql @@ -0,0 +1,43 @@ +MODEL ( + description """ + One row per basket with reads of its tags in line order: overlap with a fixed list, distinct + tags, the position and count of one tag, the tags upper-cased, a time read from the basket + id and the size of a bracket array literal + """, + tags [edge_case], + columns ( + basket_id (type VARCHAR, nullable false, audits [not_null, unique]), + has_colour (type BOOLEAN), + distinct_tag_count (type NUMBER(38, 0)), + red_position (type NUMBER(38, 0)), + non_red_count (type NUMBER(38, 0)), + upper_tags (type VARCHAR), + basket_time (type TIME), + pair_size (type NUMBER(38, 0)), + ), +); + +WITH tag_lists AS ( + SELECT + l.basket_id, + ARRAY_AGG(l.tag) WITHIN GROUP (ORDER BY l.line_no) AS tags + FROM __ref("stg_edge_basket_lines") AS l + GROUP BY + l.basket_id +), + +final AS ( + SELECT + t.basket_id, + ARRAYS_OVERLAP(t.tags, ['red', 'blue'])::BOOLEAN AS has_colour, + ARRAY_SIZE(ARRAY_DISTINCT(t.tags))::NUMBER(38, 0) AS distinct_tag_count, + ARRAY_POSITION('red'::VARIANT, t.tags)::NUMBER(38, 0) AS red_position, + ARRAY_SIZE(ARRAY_REMOVE(t.tags, 'red'::VARIANT))::NUMBER(38, 0) AS non_red_count, + ARRAY_TO_STRING(TRANSFORM(t.tags, tag -> UPPER(tag)), ',')::VARCHAR AS upper_tags, + TRY_TO_TIME(t.basket_id)::TIME AS basket_time, + ARRAY_SIZE([t.basket_id, ARRAY_SIZE(t.tags)])::NUMBER(38, 0) AS pair_size + FROM tag_lists AS t +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_clock_times.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_clock_times.sql new file mode 100644 index 0000000000..0097ed9e9f --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_clock_times.sql @@ -0,0 +1,23 @@ +MODEL ( + description """ + One row per gateway callback with its free text read as a date, and the time of day of the + text read as a zoned timestamp + """, + tags [edge_case], + columns ( + callback_id (type VARCHAR, nullable false, audits [not_null, unique]), + text_date (type DATE), + text_time (type TIME), + ), +); + +WITH final AS ( + SELECT + g.callback_id, + TO_DATE(CAST(g.business_date AS VARCHAR)) AS text_date, + TO_TIME(TRY_TO_TIMESTAMP_TZ(g.event_time_text))::TIME AS text_time + FROM __ref("stg_edge_gateway_callbacks") AS g +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_date_lists.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_date_lists.sql new file mode 100644 index 0000000000..570903c22d --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_date_lists.sql @@ -0,0 +1,22 @@ +MODEL ( + description """ + One row per merchant zone with the distinct business dates of its callbacks, held as VARIANT + """, + tags [edge_case], + columns ( + merchant_zone (type VARCHAR, nullable false, audits [not_null, unique]), + date_count (type NUMBER(38, 0)), + ), +); + +WITH final AS ( + SELECT + g.merchant_zone, + ARRAY_SIZE(ARRAY_AGG(DISTINCT TO_VARIANT(g.business_date)))::NUMBER(38, 0) AS date_count + FROM __ref("stg_edge_gateway_callbacks") AS g + GROUP BY + g.merchant_zone +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_day_documents.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_day_documents.sql new file mode 100644 index 0000000000..68ed654f55 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_day_documents.sql @@ -0,0 +1,30 @@ +MODEL ( + description """ + One row per merchant zone with the number of day documents, objects holding a DATE, + aggregated from its callbacks + """, + tags [edge_case], + columns ( + merchant_zone (type VARCHAR, nullable false, audits [not_null, unique]), + document_count (type NUMBER(38, 0)), + ), +); + +WITH day_documents AS ( + SELECT + g.merchant_zone, + ARRAY_AGG(OBJECT_CONSTRUCT_KEEP_NULL('id', g.callback_id, 'day', g.business_date)) AS documents + FROM __ref("stg_edge_gateway_callbacks") AS g + GROUP BY + g.merchant_zone +), + +final AS ( + SELECT + d.merchant_zone, + ARRAY_SIZE(d.documents)::NUMBER(38, 0) AS document_count + FROM day_documents AS d +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_day_starts.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_day_starts.sql new file mode 100644 index 0000000000..8029e3a5e2 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_day_starts.sql @@ -0,0 +1,20 @@ +MODEL ( + description """ + One row per gateway callback with the start of the day of its zoned time + """, + tags [edge_case], + columns ( + callback_id (type VARCHAR, nullable false, audits [not_null, unique]), + day_start (type TIMESTAMP_TZ), + ), +); + +WITH final AS ( + SELECT + g.callback_id, + DATE_TRUNC('day', g.event_at) AS day_start + FROM __ref("stg_edge_gateway_callbacks") AS g +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_epoch_parts.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_epoch_parts.sql new file mode 100644 index 0000000000..d43e00a24f --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_epoch_parts.sql @@ -0,0 +1,23 @@ +MODEL ( + description """ + One row per gateway callback with a nanosecond timestamp built from its wall time in + microseconds, and the wall time's epoch microseconds + """, + tags [edge_case], + columns ( + callback_id (type VARCHAR, nullable false, audits [not_null, unique]), + wall_time_ns (type TIMESTAMP_NTZ(9)), + epoch_microsecond (type NUMBER(38, 0)), + ), +); + +WITH final AS ( + SELECT + g.callback_id, + TO_TIMESTAMP_NTZ(DATE_PART(EPOCH_SECOND, g.local_wall_time), 0)::TIMESTAMP_NTZ(9) AS wall_time_ns, + DATE_PART(EPOCH_MICROSECOND, g.local_wall_time)::NUMBER(38, 0) AS epoch_microsecond + FROM __ref("stg_edge_gateway_callbacks") AS g +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_epoch_reads.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_epoch_reads.sql new file mode 100644 index 0000000000..01e058a29d --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_epoch_reads.sql @@ -0,0 +1,37 @@ +MODEL ( + description """ + One row per reconciliation check with its wide key read as epoch milliseconds, and whether a + zoned gateway time falls before date text + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + key_as_time (type TIMESTAMP_NTZ), + has_early_callback (type BOOLEAN), + ), +); + +WITH keys AS ( + SELECT + a.check_id, + TO_TIMESTAMP(a.wide_key, 3)::TIMESTAMP_NTZ AS key_as_time + FROM __ref("stg_edge_amount_checks") AS a +), + +early AS ( + SELECT COUNT(*) AS early_count + FROM __ref("stg_edge_gateway_callbacks") AS g + WHERE g.event_at < '2026-03-01' +), + +final AS ( + SELECT + k.check_id, + k.key_as_time, + (e.early_count > 0)::BOOLEAN AS has_early_callback + FROM keys AS k + CROSS JOIN early AS e +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_last_day.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_last_day.sql new file mode 100644 index 0000000000..a124c238eb --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_last_day.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per gateway callback whose zoned time falls within the 24 hours before the current + time + """, + tags [edge_case], + columns ( + callback_id (type VARCHAR, nullable false, audits [not_null, unique]), + is_recent (type BOOLEAN), + ), +); + +WITH final AS ( + SELECT + g.callback_id, + (g.event_at >= DATEADD(hour, -24, CURRENT_TIMESTAMP()))::BOOLEAN AS is_recent + FROM __ref("stg_edge_gateway_callbacks") AS g +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_latest_dates.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_latest_dates.sql new file mode 100644 index 0000000000..c667b735e1 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_latest_dates.sql @@ -0,0 +1,22 @@ +MODEL ( + description """ + One row per merchant zone with the business date, held as VARIANT, of its latest callback + """, + tags [edge_case], + columns ( + merchant_zone (type VARCHAR, nullable false, audits [not_null, unique]), + latest_date_text (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + g.merchant_zone, + MAX_BY(TO_VARIANT(g.business_date), g.callback_id)::VARCHAR AS latest_date_text + FROM __ref("stg_edge_gateway_callbacks") AS g + GROUP BY + g.merchant_zone +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_london_times.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_london_times.sql new file mode 100644 index 0000000000..84bf96002f --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_london_times.sql @@ -0,0 +1,22 @@ +MODEL ( + description """ + One row per gateway callback with whether the current time, converted from UTC to London + wall time, is known: a fact that holds on any day + """, + tags [edge_case], + columns ( + callback_id (type VARCHAR, nullable false, audits [not_null, unique]), + london_now_is_known (type BOOLEAN), + ), +); + +WITH final AS ( + SELECT + g.callback_id, + (CONVERT_TIMEZONE('UTC', 'Europe/London', CURRENT_TIMESTAMP())::TIMESTAMP_NTZ IS NOT NULL)::BOOLEAN + AS london_now_is_known + FROM __ref("stg_edge_gateway_callbacks") AS g +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_recent_offsets.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_recent_offsets.sql new file mode 100644 index 0000000000..5549440b10 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_recent_offsets.sql @@ -0,0 +1,24 @@ +MODEL ( + description """ + One row per gateway callback on a business date up to today and after 1 March 2026, the + zoned time compared with date text + """, + tags [edge_case], + columns ( + callback_id (type VARCHAR, nullable false, audits [not_null, unique]), + event_at (type TIMESTAMP_TZ), + ), +); + +WITH final AS ( + SELECT + g.callback_id, + g.event_at + FROM __ref("stg_edge_gateway_callbacks") AS g + WHERE + g.business_date <= CURRENT_DATE() + AND g.event_at >= '2026-03-01' +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_row_numbers.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_row_numbers.sql new file mode 100644 index 0000000000..0016194384 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_row_numbers.sql @@ -0,0 +1,23 @@ +MODEL ( + description """ + One row per gateway callback with its wall time as text and a SEQ8 number unique in the + result + """, + tags [edge_case], + columns ( + callback_id (type VARCHAR, nullable false, audits [not_null, unique]), + wall_time_text (type VARCHAR), + has_row_number (type BOOLEAN), + ), +); + +WITH final AS ( + SELECT + g.callback_id, + CAST(g.local_wall_time AS VARCHAR) AS wall_time_text, + (SEQ8() IS NOT NULL)::BOOLEAN AS has_row_number + FROM __ref("stg_edge_gateway_callbacks") AS g +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_safe_dates.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_safe_dates.sql new file mode 100644 index 0000000000..d72c6da724 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_safe_dates.sql @@ -0,0 +1,31 @@ +MODEL ( + description """ + One row per gateway callback with its zone and year in an object that keeps NULL values, and + its business date passed through TRY_CAST to DATE + """, + tags [edge_case], + columns ( + callback_id (type VARCHAR, nullable false, audits [not_null, unique]), + callback_json (type VARCHAR), + business_date_again (type DATE), + ), +); + +WITH callback_objects AS ( + SELECT + g.callback_id, + OBJECT_CONSTRUCT_KEEP_NULL('zone', g.merchant_zone, 'year', YEAR(g.business_date)) AS callback_object, + g.business_date + FROM __ref("stg_edge_gateway_callbacks") AS g +), + +final AS ( + SELECT + o.callback_id, + TO_JSON(o.callback_object) AS callback_json, + TRY_CAST(o.business_date AS DATE) AS business_date_again + FROM callback_objects AS o +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_start_fallbacks.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_start_fallbacks.sql new file mode 100644 index 0000000000..99711d086d --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_start_fallbacks.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per gateway callback with its nanosecond time, or its free text when that is + missing, as a start time + """, + tags [edge_case], + columns ( + callback_id (type VARCHAR, nullable false, audits [not_null, unique]), + start_at (type TIMESTAMP_NTZ(9)), + ), +); + +WITH final AS ( + SELECT + g.callback_id, + COALESCE(g.event_at_ns, g.event_time_text)::TIMESTAMP_NTZ(9) AS start_at + FROM __ref("stg_edge_gateway_callbacks") AS g +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_text_dates.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_text_dates.sql new file mode 100644 index 0000000000..534e2af35f --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_text_dates.sql @@ -0,0 +1,23 @@ +MODEL ( + description """ + One row per gateway callback with its free text read as a date when it can be, and its zoned + time in an object + """, + tags [edge_case], + columns ( + callback_id (type VARCHAR, nullable false, audits [not_null, unique]), + text_date (type DATE), + event_json (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + g.callback_id, + TRY_CAST(g.event_time_text AS DATE) AS text_date, + TO_JSON(OBJECT_CONSTRUCT('at', g.event_at)) AS event_json + FROM __ref("stg_edge_gateway_callbacks") AS g +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_wall_time_lists.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_wall_time_lists.sql new file mode 100644 index 0000000000..7ec73485ff --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_wall_time_lists.sql @@ -0,0 +1,24 @@ +MODEL ( + description """ + One row per merchant zone with its callbacks' wall times in callback order, a NULL for each + callback without one + """, + tags [edge_case], + columns ( + merchant_zone (type VARCHAR, nullable false, audits [not_null, unique]), + wall_times (type ARRAY), + ), +); + +WITH final AS ( + SELECT + g.merchant_zone, + ARRAY_AGG(IFF(g.callback_id IS NOT NULL, g.local_wall_time, NULL)) + WITHIN GROUP (ORDER BY g.callback_id)::ARRAY AS wall_times + FROM __ref("stg_edge_gateway_callbacks") AS g + GROUP BY + g.merchant_zone +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_zone_words.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_zone_words.sql new file mode 100644 index 0000000000..911daae5ac --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_zone_words.sql @@ -0,0 +1,25 @@ +MODEL ( + description """ + One row per gateway callback with the words its zone shares with a fixed list, and its zoned + time kept in an object that keeps NULL values + """, + tags [edge_case], + columns ( + callback_id (type VARCHAR, nullable false, audits [not_null, unique]), + shared_word_count (type NUMBER(38, 0)), + event_json (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + g.callback_id, + ARRAY_SIZE( + ARRAY_INTERSECTION(SPLIT(UPPER(REPLACE(g.merchant_zone, '/', ' ')), ' '), ['EUROPE', 'ASIA']) + )::NUMBER(38, 0) AS shared_word_count, + TO_JSON(OBJECT_CONSTRUCT_KEEP_NULL('at', g.event_at, 'zone', g.merchant_zone)) AS event_json + FROM __ref("stg_edge_gateway_callbacks") AS g +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_zoned_dates.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_zoned_dates.sql new file mode 100644 index 0000000000..408dca3d46 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_callback_zoned_dates.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per gateway callback whose zoned time falls on or after 1 March 2026 as a date + """, + tags [edge_case], + columns ( + callback_id (type VARCHAR, nullable false, audits [not_null, unique]), + event_date (type DATE), + ), +); + +WITH final AS ( + SELECT + g.callback_id, + TO_DATE(g.event_at) AS event_date + FROM __ref("stg_edge_gateway_callbacks") AS g + WHERE TO_DATE(g.event_at) >= '2026-03-01'::DATE +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_amount_spreads.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_amount_spreads.sql new file mode 100644 index 0000000000..2a12cb0ac4 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_amount_spreads.sql @@ -0,0 +1,33 @@ +MODEL ( + description """ + One row per check group with the median of its amounts, and per group the product of an + exact decimal rate with one less the rate + """, + tags [edge_case], + columns ( + group_code (type VARCHAR, nullable false, audits [not_null, unique]), + median_amount (type NUMBER(18, 3)), + rate_spread (type NUMBER(38, 12)), + ), +); + +WITH rates AS ( + SELECT + a.group_code, + a.amount, + a.amount / NULLIF(a.wide_key, 0) AS rate + FROM __ref("stg_edge_amount_checks") AS a +), + +final AS ( + SELECT + r.group_code, + MEDIAN(r.amount)::NUMBER(18, 3) AS median_amount, + MAX(r.rate * (1 - r.rate))::NUMBER(38, 12) AS rate_spread + FROM rates AS r + GROUP BY + r.group_code +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_any_amounts.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_any_amounts.sql new file mode 100644 index 0000000000..c56974099f --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_any_amounts.sql @@ -0,0 +1,23 @@ +MODEL ( + description """ + One row per check group with any one of its amounts, and whether all amounts in the group + agree + """, + tags [edge_case], + columns ( + group_code (type VARCHAR, nullable false, audits [not_null, unique]), + amounts_agree (type BOOLEAN), + ), +); + +WITH final AS ( + SELECT + a.group_code, + (COUNT(DISTINCT a.amount) <= 1 OR ANY_VALUE(a.amount) IS NOT NULL)::BOOLEAN AS amounts_agree + FROM __ref("stg_edge_amount_checks") AS a + GROUP BY + a.group_code +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_bracket_strips.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_bracket_strips.sql new file mode 100644 index 0000000000..1b0cfe94b5 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_bracket_strips.sql @@ -0,0 +1,20 @@ +MODEL ( + description """ + One row per reconciliation check with bracketed text removed from its key by a lazy pattern + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + stripped_key (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + a.check_id, + TRIM(REGEXP_REPLACE(a.key_text, '\\(.*?\\)', '')) AS stripped_key + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_complete_pairs.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_complete_pairs.sql new file mode 100644 index 0000000000..73a4c32ec4 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_complete_pairs.sql @@ -0,0 +1,23 @@ +MODEL ( + description """ + One row per check group counting the checks whose id and key text are both present, with + COUNT over two arguments + """, + tags [edge_case], + columns ( + group_code (type VARCHAR, nullable false, audits [not_null, unique]), + complete_pair_count (type NUMBER(38, 0)), + ), +); + +WITH final AS ( + SELECT + a.group_code, + COUNT(a.check_id, a.key_text)::NUMBER(38, 0) AS complete_pair_count + FROM __ref("stg_edge_amount_checks") AS a + GROUP BY + a.group_code +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_decoded_keys.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_decoded_keys.sql new file mode 100644 index 0000000000..47a590c70e --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_decoded_keys.sql @@ -0,0 +1,28 @@ +MODEL ( + description """ + One row per reconciliation check with its key text decoded from Base64 as binary, and the + bytes written back as hex + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + decoded_key_hex (type VARCHAR), + ), +); + +WITH decoded AS ( + SELECT + a.check_id, + TRY_BASE64_DECODE_BINARY(a.key_text) AS decoded_key + FROM __ref("stg_edge_amount_checks") AS a +), + +final AS ( + SELECT + d.check_id, + HEX_ENCODE(d.decoded_key)::VARCHAR AS decoded_key_hex + FROM decoded AS d +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_distinct_tuples.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_distinct_tuples.sql new file mode 100644 index 0000000000..13c9f4e74f --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_distinct_tuples.sql @@ -0,0 +1,22 @@ +MODEL ( + description """ + One row per check group with the number of distinct (key text, ratio) arrays in it + """, + tags [edge_case], + columns ( + group_code (type VARCHAR, nullable false, audits [not_null, unique]), + distinct_tuples (type NUMBER(38, 0)), + ), +); + +WITH final AS ( + SELECT + a.group_code, + COUNT(DISTINCT ARRAY_CONSTRUCT(a.key_text, a.ratio::DOUBLE))::NUMBER(38, 0) AS distinct_tuples + FROM __ref("stg_edge_amount_checks") AS a + GROUP BY + a.group_code +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_formatted_dates.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_formatted_dates.sql new file mode 100644 index 0000000000..e28381dd9d --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_formatted_dates.sql @@ -0,0 +1,27 @@ +MODEL ( + description """ + One row per reconciliation check with its key text read as a date in a format taken from a + column + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + key_date (type DATE), + ), +); + +WITH formats AS ( + SELECT v.date_format + FROM VALUES ('YYYY-MM-DD') AS v(date_format) +), + +final AS ( + SELECT + a.check_id, + TRY_TO_DATE(a.key_text, f.date_format) AS key_date + FROM __ref("stg_edge_amount_checks") AS a + CROSS JOIN formats AS f +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_generated_rows.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_generated_rows.sql new file mode 100644 index 0000000000..6a12b1c5cc --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_generated_rows.sql @@ -0,0 +1,33 @@ +MODEL ( + description """ + One row counting the rows a generator makes from a ROWCOUNT written as an expression, with + whether every SEQ4 number is non-negative and every draw from UNIFORM over a range of one + value is one + """, + tags [edge_case], + columns ( + summary_id (type VARCHAR, nullable false, audits [not_null, unique]), + generated_count (type NUMBER(38, 0)), + numbers_are_valid (type BOOLEAN), + draws_are_one (type BOOLEAN), + ), +); + +WITH generated AS ( + SELECT + SEQ4() AS row_seq, + UNIFORM(1, 1, RANDOM()) AS draw + FROM TABLE(GENERATOR(ROWCOUNT => (2 + 2))) +), + +final AS ( + SELECT + 'all' AS summary_id, + COUNT(*)::NUMBER(38, 0) AS generated_count, + BOOLAND_AGG(r.row_seq >= 0)::BOOLEAN AS numbers_are_valid, + BOOLAND_AGG(r.draw = 1)::BOOLEAN AS draws_are_one + FROM generated AS r +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_group_flags.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_group_flags.sql new file mode 100644 index 0000000000..e3f86ab5ca --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_group_flags.sql @@ -0,0 +1,29 @@ +MODEL ( + description """ + One row per reconciliation check flagging a group code outside the groups with a positive + amount + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + is_unpaid_group (type BOOLEAN), + ), +); + +WITH paid_groups AS ( + SELECT DISTINCT b.group_code + FROM __ref("stg_edge_amount_checks") AS b + WHERE b.amount > 0 AND b.group_code IS NOT NULL +), + +final AS ( + SELECT + a.check_id, + (a.group_code NOT IN ( + SELECT p.group_code FROM paid_groups AS p + ))::BOOLEAN AS is_unpaid_group + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_group_key_lists.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_group_key_lists.sql new file mode 100644 index 0000000000..2241c63a64 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_group_key_lists.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per reconciliation check with the number of key texts in its group, from a windowed + ARRAY_AGG + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + group_key_count (type NUMBER(38, 0)), + ), +); + +WITH final AS ( + SELECT + a.check_id, + ARRAY_SIZE(ARRAY_AGG(a.key_text) OVER (PARTITION BY a.group_code))::NUMBER(38, 0) AS group_key_count + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_group_pivots.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_group_pivots.sql new file mode 100644 index 0000000000..aefc531928 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_group_pivots.sql @@ -0,0 +1,34 @@ +MODEL ( + description """ + One row per reconciliation check with its amount pivoted into one column per check group + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + first_group_amount (type NUMBER(38, 2)), + second_group_amount (type NUMBER(38, 2)), + ), +); + +WITH amounts AS ( + SELECT a.check_id, a.group_code, a.amount + FROM __ref("stg_edge_amount_checks") AS a +), + +pivoted AS ( + SELECT * + FROM amounts + PIVOT(SUM(amount) FOR group_code IN ('G-1', 'G-2')) + AS pv (check_id, first_group_amount, second_group_amount) +), + +final AS ( + SELECT + p.check_id::VARCHAR AS check_id, + p.first_group_amount::NUMBER(38, 2) AS first_group_amount, + p.second_group_amount::NUMBER(38, 2) AS second_group_amount + FROM pivoted AS p +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_key_list_edits.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_key_list_edits.sql new file mode 100644 index 0000000000..d24bcf3cc7 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_key_list_edits.sql @@ -0,0 +1,25 @@ +MODEL ( + description """ + One row per reconciliation check with its key parts less a fixed part, with its narrow key + appended, and an object of its narrow key with the ratio inserted + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + kept_part_count (type NUMBER(38, 0)), + appended_part_count (type NUMBER(38, 0)), + check_json (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + a.check_id, + ARRAY_SIZE(ARRAY_EXCEPT(SPLIT(a.key_text, ','), ['7']))::NUMBER(38, 0) AS kept_part_count, + ARRAY_SIZE(ARRAY_APPEND(SPLIT(a.key_text, ','), a.narrow_key))::NUMBER(38, 0) AS appended_part_count, + TO_JSON(OBJECT_INSERT(OBJECT_CONSTRUCT('k', a.narrow_key), 'r', a.ratio)) AS check_json + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_key_parts.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_key_parts.sql new file mode 100644 index 0000000000..7b124aff1b --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_key_parts.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per reconciliation check with the number of parts of its key text, split on commas + and read as numbers through a typed lambda + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + key_number_count (type NUMBER(38, 0)), + ), +); + +WITH final AS ( + SELECT + a.check_id, + ARRAY_SIZE(TRANSFORM(STRTOK_TO_ARRAY(a.key_text, ','), part VARCHAR -> TRY_TO_NUMBER(part)))::NUMBER(38, 0) AS key_number_count + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_key_rewrites.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_key_rewrites.sql new file mode 100644 index 0000000000..ef8987b951 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_key_rewrites.sql @@ -0,0 +1,25 @@ +MODEL ( + description """ + One row per reconciliation check with numbers of three or more digits in its key text + replaced by its group's parts + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + rewritten_key (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + a.check_id, + REGEXP_REPLACE( + a.key_text, + '\\d{3,}(,\\d{3,})*', + ARRAY_TO_STRING(SPLIT(a.group_code, '-'), ',') + ) AS rewritten_key + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_label_lookups.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_label_lookups.sql new file mode 100644 index 0000000000..1afabe24e4 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_label_lookups.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per reconciliation check with a label looked up in an object by the first part of + its key text + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + key_label (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + a.check_id, + OBJECT_CONSTRUCT('7', 'seven', '101', 'one hundred and one')[SPLIT(a.key_text, ',')[0]]::VARCHAR AS key_label + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_last_known_keys.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_last_known_keys.sql new file mode 100644 index 0000000000..319af35b2b --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_last_known_keys.sql @@ -0,0 +1,27 @@ +MODEL ( + description """ + One row per reconciliation check with the last earlier key text of its group that holds a + comma, read with IFF inside LAST_VALUE ... IGNORE NULLS + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + last_listed_key (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + a.check_id, + LAST_VALUE( + IFF(CONTAINS(a.key_text, ','), a.key_text, NULL) IGNORE NULLS + ) OVER ( + PARTITION BY a.group_code + ORDER BY a.check_id + ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW + )::VARCHAR AS last_listed_key + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_local_times.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_local_times.sql new file mode 100644 index 0000000000..1dc0d4a19b --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_local_times.sql @@ -0,0 +1,27 @@ +MODEL ( + description """ + One row per reconciliation check with a fixed local time written as text and cast to + TIMESTAMP_LTZ + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + noted_at (type TIMESTAMP_LTZ), + ), +); + +WITH noted AS ( + SELECT v.noted_text + FROM VALUES ('2026-03-04 12:00:00') AS v(noted_text) +), + +final AS ( + SELECT + a.check_id, + CAST(c.noted_text AS TIMESTAMP_LTZ) AS noted_at + FROM __ref("stg_edge_amount_checks") AS a + CROSS JOIN noted AS c +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_minute_times.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_minute_times.sql new file mode 100644 index 0000000000..a2cb3b4613 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_minute_times.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per reconciliation check with a fixed time written without seconds and cast to + TIMESTAMP_NTZ + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + opened_at (type TIMESTAMP_NTZ), + ), +); + +WITH final AS ( + SELECT + a.check_id, + CAST('2024-05-01 15:00' AS TIMESTAMP_NTZ) AS opened_at + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_month_starts.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_month_starts.sql new file mode 100644 index 0000000000..ce28c137a3 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_month_starts.sql @@ -0,0 +1,27 @@ +MODEL ( + description """ + One row per fixed period, the first of last month beside text in one VALUES column + """, + tags [edge_case], + columns ( + period_id (type VARCHAR, nullable false, audits [not_null, unique]), + period_start (type VARCHAR), + ), +); + +WITH periods AS ( + SELECT v.period_id, v.period_start + FROM VALUES + ('P-1', DATEADD('month', -1, DATE_TRUNC('month', '2026-03-15'::DATE))), + ('P-2', '2026-01-01') AS v(period_id, period_start) +), + +final AS ( + SELECT + p.period_id, + p.period_start::VARCHAR AS period_start + FROM periods AS p +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_note_unions.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_note_unions.sql new file mode 100644 index 0000000000..3e83e36c73 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_note_unions.sql @@ -0,0 +1,29 @@ +MODEL ( + description """ + One row per reconciliation check and source, with a note column that is NULL in every branch + of a UNION ALL BY NAME + """, + tags [edge_case], + columns ( + note_row_id (type VARCHAR, nullable false, audits [not_null, unique]), + note (type VARCHAR), + ), +); + +WITH notes AS ( + SELECT a.check_id || '~left' AS note_row_id, NULL AS note + FROM __ref("stg_edge_amount_checks") AS a + UNION ALL BY NAME + SELECT a.check_id || '~right' AS note_row_id, NULL AS note + FROM __ref("stg_edge_amount_checks") AS a +), + +final AS ( + SELECT + u.note_row_id, + u.note::VARCHAR AS note + FROM notes AS u +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_number_arrays.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_number_arrays.sql new file mode 100644 index 0000000000..d2e09655d2 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_number_arrays.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per reconciliation check with the size of an array holding its amount, cast through + the structured type ARRAY(NUMBER(38, 10)) + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + amount_count (type NUMBER(38, 0)), + ), +); + +WITH final AS ( + SELECT + a.check_id, + ARRAY_SIZE(CAST(CAST(ARRAY_CONSTRUCT(a.amount) AS ARRAY(NUMBER(38, 10))) AS ARRAY))::NUMBER(38, 0) AS amount_count + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_number_labels.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_number_labels.sql new file mode 100644 index 0000000000..462b8a50d6 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_number_labels.sql @@ -0,0 +1,20 @@ +MODEL ( + description """ + One row per reconciliation check with a fixed number cast to text as a label + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + cluster_label (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + a.check_id, + CAST(501 AS VARCHAR) AS cluster_label + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_pair_filters.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_pair_filters.sql new file mode 100644 index 0000000000..e27d5f3421 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_pair_filters.sql @@ -0,0 +1,22 @@ +MODEL ( + description """ + One row per reconciliation check whose key text holds a listed number, kept only for listed + (check, group) pairs + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + has_seven (type BOOLEAN), + ), +); + +WITH final AS ( + SELECT + a.check_id, + ARRAY_CONTAINS('7'::VARIANT, SPLIT(a.key_text, ','))::BOOLEAN AS has_seven + FROM __ref("stg_edge_amount_checks") AS a + WHERE (a.check_id, a.group_code) IN (('AC-01', 'G-1'), ('AC-03', 'G-2')) +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_pattern_matches.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_pattern_matches.sql new file mode 100644 index 0000000000..b499317b2b --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_pattern_matches.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per reconciliation check with whether its key text matches its group code read as a + pattern + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + matches_group (type BOOLEAN), + ), +); + +WITH final AS ( + SELECT + a.check_id, + REGEXP_LIKE(a.key_text, a.group_code)::BOOLEAN AS matches_group + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_reduced_keys.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_reduced_keys.sql new file mode 100644 index 0000000000..dbc906643a --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_reduced_keys.sql @@ -0,0 +1,20 @@ +MODEL ( + description """ + One row per reconciliation check with the parts of its key text folded onto its group code + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + folded_key (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + a.check_id, + REDUCE(SPLIT(a.key_text, ','), a.group_code, (acc, part) -> acc || '/' || part)::VARCHAR AS folded_key + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_sparse_arrays.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_sparse_arrays.sql new file mode 100644 index 0000000000..2d50665bd8 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_sparse_arrays.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per reconciliation check with its key text and group code in an array, read back as + text, where a missing key leaves a hole + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + pair_text (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + a.check_id, + ARRAY_CONSTRUCT(a.key_text, a.group_code)::VARCHAR AS pair_text + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_text_arrays.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_text_arrays.sql new file mode 100644 index 0000000000..7e938a83a8 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_text_arrays.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per reconciliation check with the number of parts of its key text, split into an + array cast through the structured type ARRAY(VARCHAR) + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + key_part_count (type NUMBER(38, 0)), + ), +); + +WITH final AS ( + SELECT + a.check_id, + ARRAY_SIZE(CAST(CAST(SPLIT(a.key_text, ',') AS ARRAY(VARCHAR)) AS ARRAY))::NUMBER(38, 0) AS key_part_count + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_unnamed_labels.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_unnamed_labels.sql new file mode 100644 index 0000000000..18659ec227 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_unnamed_labels.sql @@ -0,0 +1,29 @@ +MODEL ( + description """ + One row per reconciliation check with a fixed label left unaliased, read back by the name + Snowflake gives it + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + label (type VARCHAR), + ), +); + +WITH unnamed AS ( + -- No alias: Snowflake names this column 'FIXED', quotes included. + SELECT + a.check_id, + 'fixed' + FROM __ref("stg_edge_amount_checks") AS a +), + +final AS ( + SELECT + u.check_id, + u."'FIXED'"::VARCHAR AS label + FROM unnamed AS u +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_variant_branches.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_variant_branches.sql new file mode 100644 index 0000000000..3a026b86e5 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_variant_branches.sql @@ -0,0 +1,37 @@ +MODEL ( + description """ + One row per reconciliation check with a branch on a path of its JSON text, whether two + arrays holding a DATE differ, and the group's largest ratio held as VARIANT + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + ratio_branch (type NUMBER(38, 0)), + dates_differ (type BOOLEAN), + largest_ratio_text (type VARCHAR), + ), +); + +WITH largest AS ( + SELECT + a.group_code, + MAX(TO_VARIANT(a.ratio)) AS largest_ratio + FROM __ref("stg_edge_amount_checks") AS a + GROUP BY + a.group_code +), + +final AS ( + SELECT + a.check_id, + CASE PARSE_JSON(a.json_text):r WHEN 0.1 THEN 1 ELSE 2 END AS ratio_branch, + (ARRAY_CONSTRUCT(a.check_id, TO_DATE('2026-01-01')) <> ARRAY_CONSTRUCT(a.check_id, TO_DATE('2026-01-02')))::BOOLEAN + AS dates_differ, + m.largest_ratio::VARCHAR AS largest_ratio_text + FROM __ref("stg_edge_amount_checks") AS a + INNER JOIN largest AS m + ON a.group_code = m.group_code +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_wide_sums.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_wide_sums.sql new file mode 100644 index 0000000000..6b01712f2f --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_wide_sums.sql @@ -0,0 +1,26 @@ +MODEL ( + description """ + One row per reconciliation check and value kind, the amount plus one beside the wide key in + one UNION ALL column + """, + tags [edge_case], + columns ( + key_row_id (type VARCHAR, nullable false, audits [not_null, unique]), + key_value (type NUMBER(38, 2)), + ), +); + +WITH final AS ( + SELECT + a.check_id || '~amount' AS key_row_id, + a.amount + 1 AS key_value + FROM __ref("stg_edge_amount_checks") AS a + UNION ALL + SELECT + a.check_id || '~wide' AS key_row_id, + a.wide_key AS key_value + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_xml_checks.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_xml_checks.sql new file mode 100644 index 0000000000..a11045a25a --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_xml_checks.sql @@ -0,0 +1,23 @@ +MODEL ( + description """ + One row per reconciliation check with its key text stripped of its group code read as a + pattern, and CHECK_XML of the key text + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + stripped_key (type VARCHAR), + xml_error (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + a.check_id, + REGEXP_REPLACE(a.key_text, a.group_code, '') AS stripped_key, + CHECK_XML(a.key_text)::VARCHAR AS xml_error + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_zoned_literals.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_zoned_literals.sql new file mode 100644 index 0000000000..0801218153 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_check_zoned_literals.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per reconciliation check with a fixed zoned time written in ISO form with a T and + +00:00 + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + cutover_at (type TIMESTAMP_TZ), + ), +); + +WITH final AS ( + SELECT + a.check_id, + CAST('2026-03-04T12:00:02+00:00' AS TIMESTAMPTZ) AS cutover_at + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_key_number_reads.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_key_number_reads.sql new file mode 100644 index 0000000000..35eaab706a --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_key_number_reads.sql @@ -0,0 +1,20 @@ +MODEL ( + description """ + One row per reconciliation check with its wide key read back with TO_NUMBER + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + wide_key_number (type NUMBER(38, 0)), + ), +); + +WITH final AS ( + SELECT + a.check_id, + TO_NUMBER(a.wide_key)::NUMBER(38, 0) AS wide_key_number + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_key_rank_offsets.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_key_rank_offsets.sql new file mode 100644 index 0000000000..a8de6652c0 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_key_rank_offsets.sql @@ -0,0 +1,23 @@ +MODEL ( + description """ + One row per reconciliation check with a rank one past its wide key or a fallback, and its + wide key read back with TRY_TO_NUMBER + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + candidate_rank (type INT), + wide_key_number (type NUMBER(38, 0)), + ), +); + +WITH final AS ( + SELECT + a.check_id, + 1 + COALESCE(a.wide_key, 999) AS candidate_rank, + TRY_TO_NUMBER(a.wide_key)::NUMBER(38, 0) AS wide_key_number + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ledger_paid_quantities.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ledger_paid_quantities.sql new file mode 100644 index 0000000000..261fe4d1b7 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ledger_paid_quantities.sql @@ -0,0 +1,41 @@ +MODEL ( + description """ + One row per order with the count of its paid quantities, read from text as FLOAT and listed + in change order + """, + tags [edge_case], + columns ( + order_ref (type VARCHAR, nullable false, audits [not_null, unique]), + paid_quantity_count (type NUMBER(38, 0)), + ), +); + +WITH quantities AS ( + SELECT + l.order_ref, + l.status, + TRY_TO_DOUBLE(l.quantity_text) AS quantity, + l.changed_at + FROM __ref("stg_edge_ledger_entries") AS l +), + +quantity_lists AS ( + SELECT + q.order_ref, + ARRAY_COMPACT( + ARRAY_AGG(IFF(q.status = 'paid', q.quantity, NULL)) WITHIN GROUP (ORDER BY q.changed_at) + ) AS paid_quantities + FROM quantities AS q + GROUP BY + q.order_ref +), + +final AS ( + SELECT + q.order_ref, + ARRAY_SIZE(q.paid_quantities)::NUMBER(38, 0) AS paid_quantity_count + FROM quantity_lists AS q +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ledger_quantity_steps.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ledger_quantity_steps.sql new file mode 100644 index 0000000000..62bdfa9078 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ledger_quantity_steps.sql @@ -0,0 +1,22 @@ +MODEL ( + description """ + One row per order with its largest quantity text, read as a number, less one + """, + tags [edge_case], + columns ( + order_ref (type VARCHAR, nullable false, audits [not_null, unique]), + quantity_less_one (type NUMBER(38, 6)), + ), +); + +WITH final AS ( + SELECT + l.order_ref, + (MAX(l.quantity_text) - 1)::NUMBER(38, 6) AS quantity_less_one + FROM __ref("stg_edge_ledger_entries") AS l + GROUP BY + l.order_ref +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_array_bounds.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_array_bounds.sql new file mode 100644 index 0000000000..0c36a9b06d --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_array_bounds.sql @@ -0,0 +1,29 @@ +MODEL ( + description """ + One row per check group with bounds read from the array of its FLOAT ratios + """, + tags [edge_case], + columns ( + group_code (type VARCHAR, nullable false, audits [not_null, unique]), + lower_bound (type FLOAT), + ), +); + +WITH ratio_arrays AS ( + SELECT + a.group_code, + ARRAY_AGG(a.ratio) WITHIN GROUP (ORDER BY a.check_id) AS ratios + FROM __ref("stg_edge_amount_checks") AS a + GROUP BY + a.group_code +), + +final AS ( + SELECT + r.group_code, + (-ARRAY_MAX(r.ratios) - 10.0)::FLOAT AS lower_bound + FROM ratio_arrays AS r +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_array_casts.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_array_casts.sql new file mode 100644 index 0000000000..570bd9ddb9 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_array_casts.sql @@ -0,0 +1,20 @@ +MODEL ( + description """ + One row per reconciliation check with its FLOAT ratio in an array cast to ARRAY + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + ratio_count (type NUMBER(38, 0)), + ), +); + +WITH final AS ( + SELECT + a.check_id, + ARRAY_SIZE(CAST(ARRAY_CONSTRUCT(a.ratio) AS ARRAY))::NUMBER(38, 0) AS ratio_count + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_array_positions.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_array_positions.sql new file mode 100644 index 0000000000..e906aeaa88 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_array_positions.sql @@ -0,0 +1,31 @@ +MODEL ( + description """ + One row per check group with the last FLOAT ratio of the group read by position from an + ordered array + """, + tags [edge_case], + columns ( + group_code (type VARCHAR, nullable false, audits [not_null, unique]), + last_ratio (type FLOAT), + ), +); + +WITH ratio_arrays AS ( + SELECT + a.group_code, + ARRAY_AGG(a.ratio) WITHIN GROUP (ORDER BY a.check_id) AS ratios, + COUNT(a.ratio) AS ratio_count + FROM __ref("stg_edge_amount_checks") AS a + GROUP BY + a.group_code +), + +final AS ( + SELECT + r.group_code, + r.ratios[r.ratio_count - 1]::FLOAT AS last_ratio + FROM ratio_arrays AS r +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_averages.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_averages.sql new file mode 100644 index 0000000000..fb95716a5a --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_averages.sql @@ -0,0 +1,23 @@ +MODEL ( + description """ + One row per check group with the average of its FLOAT ratios, whose summation order the + engines do not share + """, + tags [edge_case], + columns ( + group_code (type VARCHAR, nullable false, audits [not_null, unique]), + average_ratio (type FLOAT), + ), +); + +WITH final AS ( + SELECT + a.group_code, + AVG(a.ratio)::FLOAT AS average_ratio + FROM __ref("stg_edge_amount_checks") AS a + GROUP BY + a.group_code +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_fixed_scales.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_fixed_scales.sql new file mode 100644 index 0000000000..3618a2f9d2 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_fixed_scales.sql @@ -0,0 +1,20 @@ +MODEL ( + description """ + One row per reconciliation check with its FLOAT ratio cast to NUMBER(38, 10) + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + ratio_fixed (type NUMBER(38, 10)), + ), +); + +WITH final AS ( + SELECT + a.check_id, + CAST(a.ratio AS NUMBER(38, 10)) AS ratio_fixed + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_group_objects.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_group_objects.sql new file mode 100644 index 0000000000..8fda3db42c --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_group_objects.sql @@ -0,0 +1,25 @@ +MODEL ( + description """ + One row per check group with its FLOAT ratios in an object keyed by check, and the number of + distinct ratios held as VARIANT + """, + tags [edge_case], + columns ( + group_code (type VARCHAR, nullable false, audits [not_null, unique]), + ratio_json (type VARCHAR), + distinct_ratio_count (type NUMBER(38, 0)), + ), +); + +WITH final AS ( + SELECT + a.group_code, + TO_JSON(OBJECT_AGG(a.check_id, a.ratio)) AS ratio_json, + COUNT(DISTINCT TO_VARIANT(a.ratio))::NUMBER(38, 0) AS distinct_ratio_count + FROM __ref("stg_edge_amount_checks") AS a + GROUP BY + a.group_code +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_hashes.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_hashes.sql new file mode 100644 index 0000000000..352df789d2 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_hashes.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per reconciliation check with whether its FLOAT ratio hashes like itself read back + from text + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + hash_is_stable (type BOOLEAN), + ), +); + +WITH final AS ( + SELECT + a.check_id, + (HASH(a.ratio) = HASH(a.ratio::VARCHAR::FLOAT))::BOOLEAN AS hash_is_stable + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_identity_objects.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_identity_objects.sql new file mode 100644 index 0000000000..10b81641a3 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_identity_objects.sql @@ -0,0 +1,28 @@ +MODEL ( + description """ + One row per reconciliation check with a positive ratio, read back from an object built over + an array holding the FLOAT ratio + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + identity_kind (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + a.check_id, + f.value:kind::VARCHAR AS identity_kind + FROM __ref("stg_edge_amount_checks") AS a, + LATERAL FLATTEN(INPUT => ARRAY_CONSTRUCT_COMPACT( + IFF( + a.ratio > 0, + OBJECT_CONSTRUCT('kind', 'ratio', 'identity', ARRAY_CONSTRUCT(a.check_id, a.ratio)), + NULL + ) + )) AS f +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_ignore_case_reads.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_ignore_case_reads.sql new file mode 100644 index 0000000000..38f4e3001f --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_ignore_case_reads.sql @@ -0,0 +1,26 @@ +MODEL ( + description """ + One row per reconciliation check with its FLOAT ratio read back from an object by + GET_IGNORE_CASE + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + ratio_again (type FLOAT), + ), +); + +WITH ratio_objects AS ( + SELECT a.check_id, OBJECT_CONSTRUCT('Ratio', a.ratio) AS ratio_object + FROM __ref("stg_edge_amount_checks") AS a +), + +final AS ( + SELECT + r.check_id, + GET_IGNORE_CASE(r.ratio_object, 'ratio')::FLOAT AS ratio_again + FROM ratio_objects AS r +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_object_differences.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_object_differences.sql new file mode 100644 index 0000000000..9089f9445a --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_object_differences.sql @@ -0,0 +1,27 @@ +MODEL ( + description """ + One row per reconciliation check whose ratio object differs from a fixed ratio object + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + check_json (type VARCHAR), + ), +); + +WITH differences AS ( + SELECT a.check_id, OBJECT_CONSTRUCT('r', a.ratio) AS ratio_object + FROM __ref("stg_edge_amount_checks") AS a + EXCEPT + SELECT 'AC-01' AS check_id, OBJECT_CONSTRUCT('r', 0.1::FLOAT) AS ratio_object +), + +final AS ( + SELECT + d.check_id, + TO_JSON(d.ratio_object) AS check_json + FROM differences AS d +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_object_flags.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_object_flags.sql new file mode 100644 index 0000000000..fc8fb77609 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_object_flags.sql @@ -0,0 +1,26 @@ +MODEL ( + description """ + One row per reconciliation check with a positive-ratio flag read back as a BOOLEAN from an + object that also holds the FLOAT ratio + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + ratio_flag (type BOOLEAN), + ), +); + +WITH ratio_objects AS ( + SELECT a.check_id, OBJECT_CONSTRUCT('r', a.ratio, 'is_positive', a.ratio > 0) AS ratio_object + FROM __ref("stg_edge_amount_checks") AS a +), + +final AS ( + SELECT + r.check_id, + r.ratio_object:is_positive::BOOLEAN AS ratio_flag + FROM ratio_objects AS r +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_object_inserts.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_object_inserts.sql new file mode 100644 index 0000000000..4ad3cd9834 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_object_inserts.sql @@ -0,0 +1,26 @@ +MODEL ( + description """ + One row per reconciliation check with a key added to the first object of an array holding + its FLOAT ratio + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + check_json (type VARCHAR), + ), +); + +WITH ratio_arrays AS ( + SELECT a.check_id, ARRAY_CONSTRUCT(OBJECT_CONSTRUCT('r', a.ratio)) AS ratio_objects + FROM __ref("stg_edge_amount_checks") AS a +), + +final AS ( + SELECT + r.check_id, + TO_JSON(OBJECT_INSERT(r.ratio_objects[0]::OBJECT, 'check', r.check_id)) AS check_json + FROM ratio_arrays AS r +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_object_reads.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_object_reads.sql new file mode 100644 index 0000000000..dbf99a6e26 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_object_reads.sql @@ -0,0 +1,25 @@ +MODEL ( + description """ + One row per reconciliation check with its FLOAT ratio read back from an object as an INTEGER + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + ratio_integer (type INT), + ), +); + +WITH ratio_objects AS ( + SELECT a.check_id, OBJECT_CONSTRUCT('r', a.ratio) AS ratio_object + FROM __ref("stg_edge_amount_checks") AS a +), + +final AS ( + SELECT + r.check_id, + r.ratio_object:r::INTEGER AS ratio_integer + FROM ratio_objects AS r +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_path_checks.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_path_checks.sql new file mode 100644 index 0000000000..ca55c82630 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_path_checks.sql @@ -0,0 +1,30 @@ +MODEL ( + description """ + One row per reconciliation check whose key span is known and whose FLOAT ratio, read back by + path from an object, is missing + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + key_span (type NUMBER(38, 0)), + ), +); + +WITH ratio_objects AS ( + SELECT + a.check_id, + a.wide_key - a.narrow_key AS key_span, + OBJECT_CONSTRUCT('r', a.ratio) AS ratio_object + FROM __ref("stg_edge_amount_checks") AS a +), + +final AS ( + SELECT + r.check_id, + r.key_span::NUMBER(38, 0) AS key_span + FROM ratio_objects AS r + WHERE r.ratio_object:r IS NULL +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_percent_texts.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_percent_texts.sql new file mode 100644 index 0000000000..4f5d08687d --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_percent_texts.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per reconciliation check with its FLOAT ratio as a percentage written with a number + format + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + ratio_percent (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + a.check_id, + TO_VARCHAR(ROUND(a.ratio * 100, 1), 'FM9990.0') || '%' AS ratio_percent + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_running_totals.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_running_totals.sql new file mode 100644 index 0000000000..c7bd31dfa6 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_running_totals.sql @@ -0,0 +1,25 @@ +MODEL ( + description """ + One row per reconciliation check with a running total of its FLOAT ratio within its group, a + sum whose last bits depend on the order of addition + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + running_ratio (type FLOAT), + ), +); + +WITH final AS ( + SELECT + a.check_id, + SUM(a.ratio) OVER ( + PARTITION BY a.group_code + ORDER BY a.check_id + ROWS BETWEEN UNBOUNDED PRECEDING AND CURRENT ROW + )::FLOAT AS running_ratio + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_safe_casts.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_safe_casts.sql new file mode 100644 index 0000000000..606c5b5f04 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_safe_casts.sql @@ -0,0 +1,31 @@ +MODEL ( + description """ + One row per reconciliation check with its key and narrow key in an object literal, and its + FLOAT ratio passed through TRY_CAST to FLOAT + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + check_json (type VARCHAR), + ratio_again (type FLOAT), + ), +); + +WITH check_objects AS ( + SELECT + a.check_id, + {'key': a.key_text, 'keys': {'narrow': a.narrow_key}} AS check_object, + a.ratio + FROM __ref("stg_edge_amount_checks") AS a +), + +final AS ( + SELECT + o.check_id, + TO_JSON(o.check_object) AS check_json, + TRY_CAST(o.ratio AS FLOAT) AS ratio_again + FROM check_objects AS o +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_text_forms.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_text_forms.sql new file mode 100644 index 0000000000..7bd8c5aac7 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_text_forms.sql @@ -0,0 +1,25 @@ +MODEL ( + description """ + One row per reconciliation check with its FLOAT ratio written by TO_CHAR with a format and + as a run of stars as long as ten times the ratio, and the exponential of its narrow key + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + ratio_text (type VARCHAR), + ratio_stars (type VARCHAR), + narrow_key_exp (type FLOAT), + ), +); + +WITH final AS ( + SELECT + a.check_id, + TO_CHAR(a.ratio, '990.99') AS ratio_text, + REPEAT('*', a.ratio * 10)::VARCHAR AS ratio_stars, + EXP(a.narrow_key)::FLOAT AS narrow_key_exp + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_text_replaces.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_text_replaces.sql new file mode 100644 index 0000000000..88f6ed3ebd --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_text_replaces.sql @@ -0,0 +1,23 @@ +MODEL ( + description """ + One row per reconciliation check with its key text read as a timestamp, and its FLOAT ratio + written with a comma by REPLACE + """, + tags [edge_case], + columns ( + check_id (type VARCHAR, nullable false, audits [not_null, unique]), + key_time (type TIMESTAMP_NTZ), + ratio_text (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + a.check_id, + TRY_CAST(a.key_text AS TIMESTAMP) AS key_time, + REPLACE(a.ratio, '.', ',') AS ratio_text + FROM __ref("stg_edge_amount_checks") AS a +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_variant_unions.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_variant_unions.sql new file mode 100644 index 0000000000..47e51c5d83 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_ratio_variant_unions.sql @@ -0,0 +1,37 @@ +MODEL ( + description """ + One row per reconciliation check and value kind, a FLOAT ratio and its key text both held as + VARIANT in one UNION ALL column + """, + tags [edge_case], + columns ( + value_row_id (type VARCHAR, nullable false, audits [not_null, unique]), + value_text (type VARCHAR), + ), +); + +WITH ratios AS ( + SELECT a.check_id || '~ratio' AS value_row_id, TO_VARIANT(a.ratio) AS held_value + FROM __ref("stg_edge_amount_checks") AS a +), + +keys AS ( + SELECT a.check_id || '~key' AS value_row_id, TO_VARIANT(a.key_text) AS held_value + FROM __ref("stg_edge_amount_checks") AS a +), + +held AS ( + SELECT r.value_row_id, r.held_value FROM ratios AS r + UNION ALL + SELECT k.value_row_id, k.held_value FROM keys AS k +), + +final AS ( + SELECT + u.value_row_id, + u.held_value::VARCHAR AS value_text + FROM held AS u +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_variant_decimal_reads.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_variant_decimal_reads.sql new file mode 100644 index 0000000000..0bcb9ea91b --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_variant_decimal_reads.sql @@ -0,0 +1,21 @@ +MODEL ( + description """ + One row per attribute value with the value read as a NUMBER(10, 4) by TO_DECIMAL + """, + tags [edge_case], + columns ( + value_id (type VARCHAR, nullable false, audits [not_null, unique]), + decimal_value (type NUMBER(10, 4)), + ), +); + +WITH final AS ( + SELECT + v.value_id, + TO_DECIMAL(v.attribute_value, 10, 4)::NUMBER(10, 4) AS decimal_value + FROM __ref("stg_edge_variant_values") AS v + WHERE IS_DECIMAL(v.attribute_value) OR IS_INTEGER(v.attribute_value) +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_variant_element_counts.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_variant_element_counts.sql new file mode 100644 index 0000000000..75d81a50a0 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_variant_element_counts.sql @@ -0,0 +1,24 @@ +MODEL ( + description """ + One row per value group counting the elements of its attribute values, flattened without an + alias + """, + tags [edge_case], + columns ( + group_code (type VARCHAR, nullable false, audits [not_null, unique]), + element_count (type NUMBER(38, 0)), + ), +); + +WITH final AS ( + SELECT + v.group_code, + COUNT(*)::NUMBER(38, 0) AS element_count + FROM __ref("stg_edge_variant_values") AS v, + LATERAL FLATTEN(INPUT => v.attribute_value) + GROUP BY + v.group_code +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_variant_expected_values.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_variant_expected_values.sql new file mode 100644 index 0000000000..94bda07f08 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_variant_expected_values.sql @@ -0,0 +1,22 @@ +MODEL ( + description """ + One row per attribute value that differs from the value expected for its group, compared + with EQUAL_NULL + """, + tags [edge_case], + columns ( + value_id (type VARCHAR, nullable false, audits [not_null, unique]), + ), +); + +WITH final AS ( + SELECT v.value_id + FROM __ref("stg_edge_variant_values") AS v + WHERE NOT EQUAL_NULL( + v.attribute_value, + CASE v.group_code WHEN 'V-1' THEN PARSE_JSON('1.5') END + ) +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_variant_xml_elements.sql b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_variant_xml_elements.sql new file mode 100644 index 0000000000..83a3298400 --- /dev/null +++ b/benchmarks/duckshop/project/models/intermediate/edge_cases/int_edge_variant_xml_elements.sql @@ -0,0 +1,20 @@ +MODEL ( + description """ + One row per attribute value holding an XML document, with its sku element read by XMLGET + """, + tags [edge_case], + columns ( + value_id (type VARCHAR, nullable false, audits [not_null, unique]), + sku_text (type VARCHAR), + ), +); + +WITH final AS ( + SELECT + v.value_id, + XMLGET(v.attribute_value, 'sku'):"$"::VARCHAR AS sku_text + FROM __ref("stg_edge_variant_values") AS v +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/marts/edge_cases/rpt_edge_case_array_model_keys.sql b/benchmarks/duckshop/project/models/marts/edge_cases/rpt_edge_case_array_model_keys.sql new file mode 100644 index 0000000000..8241de05b6 --- /dev/null +++ b/benchmarks/duckshop/project/models/marts/edge_cases/rpt_edge_case_array_model_keys.sql @@ -0,0 +1,28 @@ +MODEL ( + description """ + One row per key of each edge-case model with an ARRAY, OBJECT or VARIANT output that reads a + construct translation tools refuse, so that every such model has a downstream reader + """, + tags [edge_case], + columns ( + model_key_id (type VARCHAR, nullable false, audits [not_null, unique]), + model_name (type VARCHAR), + model_key (type VARCHAR), + ), +); + +WITH model_keys AS ( + SELECT 'int_edge_callback_wall_time_lists' AS model_name, r.merchant_zone::VARCHAR AS model_key + FROM __ref("int_edge_callback_wall_time_lists") AS r +), + +final AS ( + SELECT + k.model_name || '~' || k.model_key AS model_key_id, + k.model_name, + k.model_key + FROM model_keys AS k +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/marts/edge_cases/rpt_edge_case_model_keys.sql b/benchmarks/duckshop/project/models/marts/edge_cases/rpt_edge_case_model_keys.sql new file mode 100644 index 0000000000..60144f301b --- /dev/null +++ b/benchmarks/duckshop/project/models/marts/edge_cases/rpt_edge_case_model_keys.sql @@ -0,0 +1,298 @@ +MODEL ( + description """ + One row per key of each edge-case model that reads a construct translation tools refuse, so + that every such model has a downstream reader whose own SQL translates + """, + tags [edge_case], + columns ( + model_key_id (type VARCHAR, nullable false, audits [not_null, unique]), + model_name (type VARCHAR), + model_key (type VARCHAR), + ), +); + +WITH model_keys AS ( + SELECT 'int_edge_ratio_running_totals' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_ratio_running_totals") AS r + UNION ALL + SELECT 'int_edge_ratio_averages' AS model_name, r.group_code::VARCHAR AS model_key + FROM __ref("int_edge_ratio_averages") AS r + UNION ALL + SELECT 'int_edge_callback_recent_offsets' AS model_name, r.callback_id::VARCHAR AS model_key + FROM __ref("int_edge_callback_recent_offsets") AS r + UNION ALL + SELECT 'int_edge_callback_epoch_reads' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_callback_epoch_reads") AS r + UNION ALL + SELECT 'int_edge_callback_zone_words' AS model_name, r.callback_id::VARCHAR AS model_key + FROM __ref("int_edge_callback_zone_words") AS r + UNION ALL + SELECT 'int_edge_callback_text_dates' AS model_name, r.callback_id::VARCHAR AS model_key + FROM __ref("int_edge_callback_text_dates") AS r + UNION ALL + SELECT 'int_edge_key_rank_offsets' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_key_rank_offsets") AS r + UNION ALL + SELECT 'int_edge_key_number_reads' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_key_number_reads") AS r + UNION ALL + SELECT 'int_edge_callback_epoch_parts' AS model_name, r.callback_id::VARCHAR AS model_key + FROM __ref("int_edge_callback_epoch_parts") AS r + UNION ALL + SELECT 'int_edge_check_pair_filters' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_pair_filters") AS r + UNION ALL + SELECT 'int_edge_check_wide_sums' AS model_name, r.key_row_id::VARCHAR AS model_key + FROM __ref("int_edge_check_wide_sums") AS r + UNION ALL + SELECT 'int_edge_ratio_variant_unions' AS model_name, r.value_row_id::VARCHAR AS model_key + FROM __ref("int_edge_ratio_variant_unions") AS r + UNION ALL + SELECT 'int_edge_check_note_unions' AS model_name, r.note_row_id::VARCHAR AS model_key + FROM __ref("int_edge_check_note_unions") AS r + UNION ALL + SELECT 'int_edge_ratio_array_bounds' AS model_name, r.group_code::VARCHAR AS model_key + FROM __ref("int_edge_ratio_array_bounds") AS r + UNION ALL + SELECT 'int_edge_check_zoned_literals' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_zoned_literals") AS r + UNION ALL + SELECT 'int_edge_callback_day_starts' AS model_name, r.callback_id::VARCHAR AS model_key + FROM __ref("int_edge_callback_day_starts") AS r + UNION ALL + SELECT 'int_edge_callback_clock_times' AS model_name, r.callback_id::VARCHAR AS model_key + FROM __ref("int_edge_callback_clock_times") AS r + UNION ALL + SELECT 'int_edge_check_number_arrays' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_number_arrays") AS r + UNION ALL + SELECT 'int_edge_check_text_arrays' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_text_arrays") AS r + UNION ALL + SELECT 'int_edge_check_key_rewrites' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_key_rewrites") AS r + UNION ALL + SELECT 'int_edge_variant_decimal_reads' AS model_name, r.value_id::VARCHAR AS model_key + FROM __ref("int_edge_variant_decimal_reads") AS r + UNION ALL + SELECT 'int_edge_ratio_safe_casts' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_ratio_safe_casts") AS r + UNION ALL + SELECT 'int_edge_callback_safe_dates' AS model_name, r.callback_id::VARCHAR AS model_key + FROM __ref("int_edge_callback_safe_dates") AS r + UNION ALL + SELECT 'int_edge_ratio_percent_texts' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_ratio_percent_texts") AS r + UNION ALL + SELECT 'int_edge_callback_row_numbers' AS model_name, r.callback_id::VARCHAR AS model_key + FROM __ref("int_edge_callback_row_numbers") AS r + UNION ALL + SELECT 'int_edge_check_xml_checks' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_xml_checks") AS r + UNION ALL + SELECT 'int_edge_variant_xml_elements' AS model_name, r.value_id::VARCHAR AS model_key + FROM __ref("int_edge_variant_xml_elements") AS r + UNION ALL + SELECT 'int_edge_callback_latest_dates' AS model_name, r.merchant_zone::VARCHAR AS model_key + FROM __ref("int_edge_callback_latest_dates") AS r + UNION ALL + SELECT 'int_edge_check_group_key_lists' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_group_key_lists") AS r + UNION ALL + SELECT 'int_edge_ratio_array_casts' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_ratio_array_casts") AS r + UNION ALL + SELECT 'int_edge_ratio_text_replaces' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_ratio_text_replaces") AS r + UNION ALL + SELECT 'int_edge_ratio_object_reads' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_ratio_object_reads") AS r + UNION ALL + SELECT 'int_edge_ratio_object_flags' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_ratio_object_flags") AS r + UNION ALL + SELECT 'int_edge_ratio_identity_objects' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_ratio_identity_objects") AS r + UNION ALL + SELECT 'int_edge_ratio_array_positions' AS model_name, r.group_code::VARCHAR AS model_key + FROM __ref("int_edge_ratio_array_positions") AS r + UNION ALL + SELECT 'int_edge_check_local_times' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_local_times") AS r + UNION ALL + SELECT 'int_edge_ratio_ignore_case_reads' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_ratio_ignore_case_reads") AS r + UNION ALL + SELECT 'int_edge_callback_zoned_dates' AS model_name, r.callback_id::VARCHAR AS model_key + FROM __ref("int_edge_callback_zoned_dates") AS r + UNION ALL + SELECT 'int_edge_ratio_object_inserts' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_ratio_object_inserts") AS r + UNION ALL + SELECT 'int_edge_callback_date_lists' AS model_name, r.merchant_zone::VARCHAR AS model_key + FROM __ref("int_edge_callback_date_lists") AS r + UNION ALL + SELECT 'int_edge_check_bracket_strips' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_bracket_strips") AS r + UNION ALL + SELECT 'int_edge_ratio_path_checks' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_ratio_path_checks") AS r + UNION ALL + SELECT 'int_edge_ratio_fixed_scales' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_ratio_fixed_scales") AS r + UNION ALL + SELECT 'int_edge_check_formatted_dates' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_formatted_dates") AS r + UNION ALL + SELECT 'int_edge_callback_last_day' AS model_name, r.callback_id::VARCHAR AS model_key + FROM __ref("int_edge_callback_last_day") AS r + UNION ALL + SELECT 'int_edge_check_month_starts' AS model_name, r.period_id::VARCHAR AS model_key + FROM __ref("int_edge_check_month_starts") AS r + UNION ALL + SELECT 'int_edge_check_key_parts' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_key_parts") AS r + UNION ALL + SELECT 'int_edge_variant_expected_values' AS model_name, r.value_id::VARCHAR AS model_key + FROM __ref("int_edge_variant_expected_values") AS r + UNION ALL + SELECT 'int_edge_check_reduced_keys' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_reduced_keys") AS r + UNION ALL + SELECT 'int_edge_ratio_hashes' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_ratio_hashes") AS r + UNION ALL + SELECT 'int_edge_ratio_object_differences' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_ratio_object_differences") AS r + UNION ALL + SELECT 'int_edge_check_group_flags' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_group_flags") AS r + UNION ALL + SELECT 'int_edge_check_label_lookups' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_label_lookups") AS r + UNION ALL + SELECT 'int_edge_check_distinct_tuples' AS model_name, r.group_code::VARCHAR AS model_key + FROM __ref("int_edge_check_distinct_tuples") AS r + UNION ALL + SELECT 'int_edge_callback_start_fallbacks' AS model_name, r.callback_id::VARCHAR AS model_key + FROM __ref("int_edge_callback_start_fallbacks") AS r + UNION ALL + SELECT 'int_edge_amount_percent_texts' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_amount_percent_texts") AS r + UNION ALL + SELECT 'int_edge_check_minute_times' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_minute_times") AS r + UNION ALL + SELECT 'int_edge_check_number_labels' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_number_labels") AS r + UNION ALL + SELECT 'int_edge_check_decoded_keys' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_decoded_keys") AS r + UNION ALL + SELECT 'int_edge_callback_london_times' AS model_name, r.callback_id::VARCHAR AS model_key + FROM __ref("int_edge_callback_london_times") AS r + UNION ALL + SELECT 'int_edge_check_pattern_matches' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_pattern_matches") AS r + UNION ALL + SELECT 'int_edge_check_any_amounts' AS model_name, r.group_code::VARCHAR AS model_key + FROM __ref("int_edge_check_any_amounts") AS r + UNION ALL + SELECT 'int_edge_check_sparse_arrays' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_sparse_arrays") AS r + UNION ALL + SELECT 'int_edge_check_last_known_keys' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_last_known_keys") AS r + UNION ALL + SELECT 'int_edge_callback_day_documents' AS model_name, r.merchant_zone::VARCHAR AS model_key + FROM __ref("int_edge_callback_day_documents") AS r + UNION ALL + SELECT 'int_edge_check_key_list_edits' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_key_list_edits") AS r + UNION ALL + SELECT 'int_edge_ratio_group_objects' AS model_name, r.group_code::VARCHAR AS model_key + FROM __ref("int_edge_ratio_group_objects") AS r + UNION ALL + SELECT 'int_edge_ratio_text_forms' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_ratio_text_forms") AS r + UNION ALL + SELECT 'int_edge_check_variant_branches' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_variant_branches") AS r + UNION ALL + SELECT 'int_edge_ledger_quantity_steps' AS model_name, r.order_ref::VARCHAR AS model_key + FROM __ref("int_edge_ledger_quantity_steps") AS r + UNION ALL + SELECT 'int_edge_check_generated_rows' AS model_name, r.summary_id::VARCHAR AS model_key + FROM __ref("int_edge_check_generated_rows") AS r + UNION ALL + SELECT 'int_edge_check_unnamed_labels' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_unnamed_labels") AS r + UNION ALL + SELECT 'int_edge_basket_tag_list_reads' AS model_name, r.basket_id::VARCHAR AS model_key + FROM __ref("int_edge_basket_tag_list_reads") AS r + UNION ALL + SELECT 'int_edge_basket_sku_part_filters' AS model_name, r.line_id::VARCHAR AS model_key + FROM __ref("int_edge_basket_sku_part_filters") AS r + UNION ALL + SELECT 'int_edge_basket_distinct_tags' AS model_name, r.tag_text::VARCHAR AS model_key + FROM __ref("int_edge_basket_distinct_tags") AS r + UNION ALL + SELECT 'int_edge_check_amount_spreads' AS model_name, r.group_code::VARCHAR AS model_key + FROM __ref("int_edge_check_amount_spreads") AS r + UNION ALL + SELECT 'int_edge_check_group_pivots' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_check_group_pivots") AS r + UNION ALL + SELECT 'int_edge_check_complete_pairs' AS model_name, r.group_code::VARCHAR AS model_key + FROM __ref("int_edge_check_complete_pairs") AS r + UNION ALL + SELECT 'int_edge_ledger_paid_quantities' AS model_name, r.order_ref::VARCHAR AS model_key + FROM __ref("int_edge_ledger_paid_quantities") AS r + UNION ALL + SELECT 'int_edge_variant_element_counts' AS model_name, r.group_code::VARCHAR AS model_key + FROM __ref("int_edge_variant_element_counts") AS r + UNION ALL + SELECT 'int_edge_basket_line_lookups' AS model_name, r.line_id::VARCHAR AS model_key + FROM __ref("int_edge_basket_line_lookups") AS r + UNION ALL + SELECT 'int_edge_basket_running_peaks' AS model_name, r.basket_id::VARCHAR AS model_key + FROM __ref("int_edge_basket_running_peaks") AS r + UNION ALL + SELECT 'stg_edge_supplier_notes' AS model_name, r.note_id::VARCHAR AS model_key + FROM __ref("stg_edge_supplier_notes") AS r + UNION ALL + SELECT 'int_edge_clock_text_reads' AS model_name, r.text_id::VARCHAR AS model_key + FROM __ref("int_edge_clock_text_reads") AS r + UNION ALL + SELECT 'int_edge_amount_bit_reads' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_amount_bit_reads") AS r + UNION ALL + SELECT 'int_edge_note_patterns' AS model_name, r.note_id::VARCHAR AS model_key + FROM __ref("int_edge_note_patterns") AS r + UNION ALL + SELECT 'int_edge_ticket_tokens' AS model_name, r.line_id::VARCHAR AS model_key + FROM __ref("int_edge_ticket_tokens") AS r + UNION ALL + SELECT 'int_edge_basket_xml_reads' AS model_name, r.line_id::VARCHAR AS model_key + FROM __ref("int_edge_basket_xml_reads") AS r + UNION ALL + SELECT 'int_edge_join_keys' AS model_name, r.row_key::VARCHAR AS model_key + FROM __ref("int_edge_join_keys") AS r + UNION ALL + SELECT 'int_edge_json_numbers' AS model_name, r.check_id::VARCHAR AS model_key + FROM __ref("int_edge_json_numbers") AS r + UNION ALL + SELECT 'int_edge_quantity_checks' AS model_name, r.entry_id::VARCHAR AS model_key + FROM __ref("int_edge_quantity_checks") AS r +), + +final AS ( + SELECT + k.model_name || '~' || k.model_key AS model_key_id, + k.model_name, + k.model_key + FROM model_keys AS k +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/models/staging/edge_cases/stg_edge_supplier_notes.sql b/benchmarks/duckshop/project/models/staging/edge_cases/stg_edge_supplier_notes.sql new file mode 100644 index 0000000000..a02d79df7b --- /dev/null +++ b/benchmarks/duckshop/project/models/staging/edge_cases/stg_edge_supplier_notes.sql @@ -0,0 +1,28 @@ +MODEL ( + description """ + One row per supplier note from a source whose contract is not enforced, with the note upper- + cased + """, + tags [edge_case], + columns ( + note_id (type VARCHAR, nullable false, audits [not_null, unique]), + supplier_code (type VARCHAR), + note_upper (type VARCHAR), + ), +); + +WITH src AS ( + SELECT * + FROM __source("edge__supplier_notes") +), + +final AS ( + SELECT + s.note_id, + s.supplier_code, + UPPER(s.note_text) AS note_upper + FROM src AS s +) + +SELECT * +FROM final diff --git a/benchmarks/duckshop/project/python/loaders/_edge_cases.py b/benchmarks/duckshop/project/python/loaders/_edge_cases.py index 0c42460042..2f0b81a9f5 100644 --- a/benchmarks/duckshop/project/python/loaders/_edge_cases.py +++ b/benchmarks/duckshop/project/python/loaders/_edge_cases.py @@ -704,6 +704,23 @@ def category_links() -> Rows: ] +def supplier_notes() -> Rows: + notes = [ + ("SN-1", "SUP-PINTAIL", "Restock teal decoys before April"), + ("SN-2", "SUP-EIDER", None), + ("SN-3", None, "Bath ducks ship in pairs"), + ] + return [ + { + "note_id": note, + "supplier_code": supplier, + "note_text": text, + "_loaded_at": _at("2026-03-06 00:00:00"), + } + for note, supplier, text in notes + ] + + DELIVERY_BATCH_VAR = "edge_delivery_batch" """Project variable naming the last delivery-update load to include; "2" (all loads) by default.""" @@ -762,4 +779,5 @@ def delivery_updates(batch: int = 2) -> Rows: "edge__amount_checks": amount_checks(), "edge__variant_values": variant_values(), "edge__category_links": category_links(), + "edge__supplier_notes": supplier_notes(), } diff --git a/benchmarks/duckshop/project/python/loaders/edge_cases.py b/benchmarks/duckshop/project/python/loaders/edge_cases.py index 522dd0b37f..9cbbf862b9 100644 --- a/benchmarks/duckshop/project/python/loaders/edge_cases.py +++ b/benchmarks/duckshop/project/python/loaders/edge_cases.py @@ -78,6 +78,11 @@ def edge__category_links(ctx: LoaderContext) -> object: return _load(ctx, "edge__category_links") +@loader +def edge__supplier_notes(ctx: LoaderContext) -> object: + return _load(ctx, "edge__supplier_notes") + + @loader def edge__delivery_updates(ctx: LoaderContext) -> object: batch = int(ctx.vars.get(DELIVERY_BATCH_VAR, 2)) # type: ignore[call-overload] diff --git a/benchmarks/duckshop/project/sources/edge_cases.yml b/benchmarks/duckshop/project/sources/edge_cases.yml index 738e9b0f2a..ea73c90c66 100644 --- a/benchmarks/duckshop/project/sources/edge_cases.yml +++ b/benchmarks/duckshop/project/sources/edge_cases.yml @@ -411,3 +411,24 @@ sources: nullable: false audits: - not_null + - name: edge__supplier_notes + description: >- + Supplier notes whose columns are declared but whose contract is not enforced, so readers see + an open source + managed: true + columns: + - name: note_id + type: VARCHAR + nullable: false + audits: + - not_null + - unique + - name: supplier_code + type: VARCHAR + - name: note_text + type: VARCHAR + - name: _loaded_at + type: TIMESTAMP_NTZ + nullable: false + audits: + - not_null diff --git a/benchmarks/duckshop/project/sqlbuild_local.toml.example b/benchmarks/duckshop/project/sqlbuild_local.toml.example index 468e2d2702..ff96f9c7e6 100644 --- a/benchmarks/duckshop/project/sqlbuild_local.toml.example +++ b/benchmarks/duckshop/project/sqlbuild_local.toml.example @@ -15,12 +15,15 @@ database = "" schema = "" # The edge-case area's target (RUNBOOK.md, step 7). Use a different schema from targets.dev. +# database and schema repeat the target's, so the session's current schema is the target schema. [connections.edge] account = "" user = "" authenticator = "" role = "" warehouse = "" +database = "" +schema = "" [targets.edge] connection = "edge" diff --git a/benchmarks/duckshop/project/sqlbuild_project.toml b/benchmarks/duckshop/project/sqlbuild_project.toml index 80bed24c30..43a99dbcc3 100644 --- a/benchmarks/duckshop/project/sqlbuild_project.toml +++ b/benchmarks/duckshop/project/sqlbuild_project.toml @@ -315,6 +315,20 @@ The edge case leaves two calculated columns unaliased on purpose, and reads them Snowflake gives them. """ +[[rules.rule_ignores]] +rules = ["SQLCLEAN022"] +paths = ["models/intermediate/edge_cases/int_edge_check_unnamed_labels.sql"] +reason = """ +The edge case leaves a literal unaliased on purpose, and reads it by the name Snowflake gives it. +""" + +[[rules.rule_ignores]] +rules = ["SQLCLEAN044"] +paths = ["models/intermediate/edge_cases/_sqlbuild/_hooks/sql/create_edge_running_peaks.sql"] +reason = """ +The hook creates a JavaScript function, whose body Snowflake takes as one dollar-quoted string. +""" + [[rules.rule_ignores]] rules = ["SQLCLEAN040"] paths = ["models/intermediate/edge_cases/int_edge_amount_bit_reads.sql"] diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/customers/test_int_wishlist_demand__counts_purchases_made_after_wishlisting.sql b/benchmarks/duckshop/project/tests/unit/intermediate/customers/test_int_wishlist_demand__counts_purchases_made_after_wishlisting.sql index 5d192bc22f..698f2bb7d7 100644 --- a/benchmarks/duckshop/project/tests/unit/intermediate/customers/test_int_wishlist_demand__counts_purchases_made_after_wishlisting.sql +++ b/benchmarks/duckshop/project/tests/unit/intermediate/customers/test_int_wishlist_demand__counts_purchases_made_after_wishlisting.sql @@ -2,25 +2,25 @@ TEST (name "int_wishlist_demand__counts_purchases_made_after_wishlisting"); WITH __ref__stg_wishlist_items AS ( SELECT + 'W1#1' AS wishlist_item_key, 'W1' AS wishlist_id, 'C1' AS customer_id, - 'W1#1' AS wishlist_item_key, 'DUCK-1' AS sku, '2026-03-01 00:00:00 +00:00'::TIMESTAMPTZ AS added_at, NULL AS item_position UNION ALL SELECT + 'W2#1', 'W2', 'C1', - 'W2#1', 'DUCK-1', '2026-03-02 00:00:00 +00:00'::TIMESTAMPTZ, NULL UNION ALL SELECT + 'W3#1', 'W3', 'C2', - 'W3#1', 'DUCK-1', '2026-03-05 00:00:00 +00:00'::TIMESTAMPTZ, NULL diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_amount_percent_texts.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_amount_percent_texts.sql new file mode 100644 index 0000000000..59c67f5a4d --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_amount_percent_texts.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_amount_percent_texts__formats_amount_percentages"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_amount_percent_texts AS ( + SELECT + 'AC-01' AS check_id, + '335.0%' AS amount_percent + UNION ALL + SELECT + 'AC-02' AS check_id, + '-18.3%' AS amount_percent + UNION ALL + SELECT + 'AC-03' AS check_id, + '0.0%' AS amount_percent + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS VARCHAR) AS amount_percent +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_basket_distinct_tags.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_basket_distinct_tags.sql new file mode 100644 index 0000000000..e1e5b054dd --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_basket_distinct_tags.sql @@ -0,0 +1,23 @@ +TEST (name "int_edge_basket_distinct_tags__lists_distinct_tags"); + +WITH __ref__stg_edge_basket_lines AS ( + SELECT + v.line_id::VARCHAR AS line_id, + v.basket_id::VARCHAR AS basket_id, + v.line_no::NUMBER(38, 0) AS line_no, + v.sku::VARCHAR AS sku, + v.tag::VARCHAR AS tag + FROM VALUES + ('BL-01', 'B-1', 1, 'DK-RED-01', 'red'), + ('BL-02', 'B-1', 2, 'DK-BLUE-02', 'blue'), + ('BL-03', 'B-1', 3, 'DK-RED-03', 'red'), + ('BL-04', 'B-2', 1, 'TL-GREEN-01', NULL) AS v(line_id, basket_id, line_no, sku, tag) +), + +__expected__int_edge_basket_distinct_tags AS ( + SELECT + 'blue' AS tag_text + UNION ALL + SELECT + 'red' AS tag_text +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_basket_line_lookups.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_basket_line_lookups.sql new file mode 100644 index 0000000000..98b2798105 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_basket_line_lookups.sql @@ -0,0 +1,24 @@ +TEST (name "int_edge_basket_line_lookups__reads_one_basket_through_the_table_function"); + +WITH __table_fn__edge_basket_lines_for AS ( + SELECT + v.line_id::VARCHAR AS line_id, + v.line_no::INT AS line_no, + v.sku::VARCHAR AS sku, + v.tag::VARCHAR AS tag + FROM VALUES + ('BL-01', 1, 'DK-RED-01', 'red'), + ('BL-02', 2, 'DK-BLUE-02', NULL) AS v(line_id, line_no, sku, tag) +), + +__expected__int_edge_basket_line_lookups AS ( + SELECT + 'BL-01' AS line_id, + 1 AS line_no, + 'DK-RED-01' AS sku + UNION ALL + SELECT + 'BL-02' AS line_id, + 2 AS line_no, + 'DK-BLUE-02' AS sku +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_basket_running_peaks.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_basket_running_peaks.sql new file mode 100644 index 0000000000..da5af9bf63 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_basket_running_peaks.sql @@ -0,0 +1,27 @@ +TEST (name "int_edge_basket_running_peaks__computes_running_peaks_per_basket"); + +WITH __ref__stg_edge_basket_lines AS ( + SELECT + v.line_id::VARCHAR AS line_id, + v.basket_id::VARCHAR AS basket_id, + v.line_no::NUMBER(38, 0) AS line_no, + v.sku::VARCHAR AS sku, + v.tag::VARCHAR AS tag + FROM VALUES + ('BL-01', 'B-1', 1, 'DK-RED-01', 'red'), + ('BL-02', 'B-1', 2, 'DK-BLUE-02', 'blue'), + ('BL-03', 'B-1', 3, 'DK-RED-03', 'red'), + ('BL-04', 'B-2', 1, 'TL-GREEN-01', NULL) AS v(line_id, basket_id, line_no, sku, tag) +), + +__expected__int_edge_basket_running_peaks AS ( + SELECT + 'B-1' AS basket_id, + 3 AS peak_count, + 3 AS last_peak + UNION ALL + SELECT + 'B-2' AS basket_id, + 1 AS peak_count, + 1 AS last_peak +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_basket_sku_part_filters.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_basket_sku_part_filters.sql new file mode 100644 index 0000000000..93e95389b1 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_basket_sku_part_filters.sql @@ -0,0 +1,33 @@ +TEST (name "int_edge_basket_sku_part_filters__counts_long_sku_parts"); + +WITH __ref__stg_edge_basket_lines AS ( + SELECT + v.line_id::VARCHAR AS line_id, + v.basket_id::VARCHAR AS basket_id, + v.line_no::NUMBER(38, 0) AS line_no, + v.sku::VARCHAR AS sku, + v.tag::VARCHAR AS tag + FROM VALUES + ('BL-01', 'B-1', 1, 'DK-RED-01', 'red'), + ('BL-02', 'B-1', 2, 'DK-BLUE-02', 'blue'), + ('BL-03', 'B-1', 3, 'DK-RED-03', 'red'), + ('BL-04', 'B-2', 1, 'TL-GREEN-01', NULL) AS v(line_id, basket_id, line_no, sku, tag) +), + +__expected__int_edge_basket_sku_part_filters AS ( + SELECT + 'BL-01' AS line_id, + 3 AS long_part_count + UNION ALL + SELECT + 'BL-02' AS line_id, + 3 AS long_part_count + UNION ALL + SELECT + 'BL-03' AS line_id, + 3 AS long_part_count + UNION ALL + SELECT + 'BL-04' AS line_id, + 3 AS long_part_count +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_basket_tag_list_reads.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_basket_tag_list_reads.sql new file mode 100644 index 0000000000..55b9461182 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_basket_tag_list_reads.sql @@ -0,0 +1,37 @@ +TEST (name "int_edge_basket_tag_list_reads__reads_tag_lists"); + +WITH __ref__stg_edge_basket_lines AS ( + SELECT + v.line_id::VARCHAR AS line_id, + v.basket_id::VARCHAR AS basket_id, + v.line_no::NUMBER(38, 0) AS line_no, + v.sku::VARCHAR AS sku, + v.tag::VARCHAR AS tag + FROM VALUES + ('BL-01', 'B-1', 1, 'DK-RED-01', 'red'), + ('BL-02', 'B-1', 2, 'DK-BLUE-02', 'blue'), + ('BL-03', 'B-1', 3, 'DK-RED-03', 'red'), + ('BL-04', 'B-2', 1, 'TL-GREEN-01', NULL) AS v(line_id, basket_id, line_no, sku, tag) +), + +__expected__int_edge_basket_tag_list_reads AS ( + SELECT + 'B-1' AS basket_id, + TRUE AS has_colour, + 2 AS distinct_tag_count, + 0 AS red_position, + 1 AS non_red_count, + 'RED,BLUE,RED' AS upper_tags, + CAST(NULL AS TIME(9)) AS basket_time, + 2 AS pair_size + UNION ALL + SELECT + 'B-2' AS basket_id, + FALSE AS has_colour, + 0 AS distinct_tag_count, + CAST(NULL AS NUMBER(38,0)) AS red_position, + 0 AS non_red_count, + '' AS upper_tags, + CAST(NULL AS TIME(9)) AS basket_time, + 2 AS pair_size +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_clock_times.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_clock_times.sql new file mode 100644 index 0000000000..ba524b2738 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_clock_times.sql @@ -0,0 +1,33 @@ +TEST (name "int_edge_callback_clock_times__reads_dates_and_times_from_text"); + +WITH __ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_clock_times AS ( + SELECT + 'GC-01' AS callback_id, + '2026-03-28'::DATE AS text_date, + '23:30:00'::TIME(9) AS text_time + UNION ALL + SELECT + 'GC-02' AS callback_id, + '2026-03-08'::DATE AS text_date, + '01:15:00'::TIME(9) AS text_time + UNION ALL + SELECT + 'GC-03' AS callback_id, + '2026-02-28'::DATE AS text_date, + '00:00:00'::TIME(9) AS text_time +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_date_lists.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_date_lists.sql new file mode 100644 index 0000000000..e551378e1a --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_date_lists.sql @@ -0,0 +1,30 @@ +TEST (name "int_edge_callback_date_lists__counts_distinct_dates_per_zone"); + +WITH __ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_date_lists AS ( + SELECT + 'America/New_York' AS merchant_zone, + 1 AS date_count + UNION ALL + SELECT + 'Asia/Kolkata' AS merchant_zone, + 1 AS date_count + UNION ALL + SELECT + 'Europe/London' AS merchant_zone, + 1 AS date_count +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_day_documents.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_day_documents.sql new file mode 100644 index 0000000000..c6cee545bc --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_day_documents.sql @@ -0,0 +1,30 @@ +TEST (name "int_edge_callback_day_documents__counts_day_documents_per_zone"); + +WITH __ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_day_documents AS ( + SELECT + 'America/New_York' AS merchant_zone, + 1 AS document_count + UNION ALL + SELECT + 'Asia/Kolkata' AS merchant_zone, + 1 AS document_count + UNION ALL + SELECT + 'Europe/London' AS merchant_zone, + 1 AS document_count +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_day_starts.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_day_starts.sql new file mode 100644 index 0000000000..737ab63b20 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_day_starts.sql @@ -0,0 +1,30 @@ +TEST (name "int_edge_callback_day_starts__truncates_zoned_times_to_days"); + +WITH __ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_day_starts AS ( + SELECT + 'GC-01' AS callback_id, + '2026-03-28 00:00:00 Z'::TIMESTAMP_TZ(9) AS day_start + UNION ALL + SELECT + 'GC-02' AS callback_id, + '2026-03-08 00:00:00 -05:00'::TIMESTAMP_TZ(9) AS day_start + UNION ALL + SELECT + 'GC-03' AS callback_id, + '2026-02-28 00:00:00 +05:30'::TIMESTAMP_TZ(9) AS day_start +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_epoch_parts.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_epoch_parts.sql new file mode 100644 index 0000000000..42ada2677c --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_epoch_parts.sql @@ -0,0 +1,33 @@ +TEST (name "int_edge_callback_epoch_parts__reads_epoch_parts_of_wall_times"); + +WITH __ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_epoch_parts AS ( + SELECT + 'GC-01' AS callback_id, + '2026-03-28 23:30:00'::TIMESTAMP_NTZ(9) AS wall_time_ns, + 1774740600000000 AS epoch_microsecond + UNION ALL + SELECT + 'GC-02' AS callback_id, + '2026-03-08 01:15:00'::TIMESTAMP_NTZ(9) AS wall_time_ns, + 1772932500000000 AS epoch_microsecond + UNION ALL + SELECT + 'GC-03' AS callback_id, + '2026-02-28 18:45:30'::TIMESTAMP_NTZ(9) AS wall_time_ns, + 1772304330000000 AS epoch_microsecond +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_epoch_reads.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_epoch_reads.sql new file mode 100644 index 0000000000..28e612340c --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_epoch_reads.sql @@ -0,0 +1,54 @@ +TEST (name "int_edge_callback_epoch_reads__reads_keys_as_epoch_milliseconds"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_epoch_reads AS ( + SELECT + 'AC-01' AS check_id, + '1970-01-01 00:00:00.007'::TIMESTAMP_NTZ(9) AS key_as_time, + TRUE AS has_early_callback + UNION ALL + SELECT + 'AC-02' AS check_id, + '1970-01-01 00:00:00.012'::TIMESTAMP_NTZ(9) AS key_as_time, + TRUE AS has_early_callback + UNION ALL + SELECT + 'AC-03' AS check_id, + CAST(NULL AS TIMESTAMP_NTZ(9)) AS key_as_time, + TRUE AS has_early_callback + UNION ALL + SELECT + 'AC-04' AS check_id, + '1970-01-01 00:00:00.04'::TIMESTAMP_NTZ(9) AS key_as_time, + TRUE AS has_early_callback +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_last_day.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_last_day.sql new file mode 100644 index 0000000000..93bf9f0fe7 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_last_day.sql @@ -0,0 +1,30 @@ +TEST (name "int_edge_callback_last_day__flags_callbacks_from_the_last_day"); + +WITH __ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_last_day AS ( + SELECT + 'GC-01' AS callback_id, + FALSE AS is_recent + UNION ALL + SELECT + 'GC-02' AS callback_id, + FALSE AS is_recent + UNION ALL + SELECT + 'GC-03' AS callback_id, + FALSE AS is_recent +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_latest_dates.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_latest_dates.sql new file mode 100644 index 0000000000..5340ade7d3 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_latest_dates.sql @@ -0,0 +1,30 @@ +TEST (name "int_edge_callback_latest_dates__picks_the_latest_date_per_zone"); + +WITH __ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_latest_dates AS ( + SELECT + 'America/New_York' AS merchant_zone, + '2026-03-08' AS latest_date_text + UNION ALL + SELECT + 'Asia/Kolkata' AS merchant_zone, + '2026-02-28' AS latest_date_text + UNION ALL + SELECT + 'Europe/London' AS merchant_zone, + '2026-03-28' AS latest_date_text +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_london_times.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_london_times.sql new file mode 100644 index 0000000000..47be08bf4e --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_london_times.sql @@ -0,0 +1,30 @@ +TEST (name "int_edge_callback_london_times__converts_the_current_time_to_london"); + +WITH __ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_london_times AS ( + SELECT + 'GC-01' AS callback_id, + TRUE AS london_now_is_known + UNION ALL + SELECT + 'GC-02' AS callback_id, + TRUE AS london_now_is_known + UNION ALL + SELECT + 'GC-03' AS callback_id, + TRUE AS london_now_is_known +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_recent_offsets.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_recent_offsets.sql new file mode 100644 index 0000000000..88412acf0b --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_recent_offsets.sql @@ -0,0 +1,26 @@ +TEST (name "int_edge_callback_recent_offsets__keeps_callbacks_from_march_by_their_zoned_time"); + +WITH __ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_recent_offsets AS ( + SELECT + 'GC-01' AS callback_id, + '2026-03-28 23:30:00 Z'::TIMESTAMP_TZ(9) AS event_at + UNION ALL + SELECT + 'GC-02' AS callback_id, + '2026-03-08 01:15:00 -05:00'::TIMESTAMP_TZ(9) AS event_at +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_row_numbers.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_row_numbers.sql new file mode 100644 index 0000000000..67d5246437 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_row_numbers.sql @@ -0,0 +1,33 @@ +TEST (name "int_edge_callback_row_numbers__numbers_rows_with_seq8"); + +WITH __ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_row_numbers AS ( + SELECT + 'GC-01' AS callback_id, + '2026-03-28 23:30:00.000' AS wall_time_text, + TRUE AS has_row_number + UNION ALL + SELECT + 'GC-02' AS callback_id, + '2026-03-08 01:15:00.000' AS wall_time_text, + TRUE AS has_row_number + UNION ALL + SELECT + 'GC-03' AS callback_id, + '2026-02-28 18:45:30.000' AS wall_time_text, + TRUE AS has_row_number +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_safe_dates.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_safe_dates.sql new file mode 100644 index 0000000000..3ee29e235e --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_safe_dates.sql @@ -0,0 +1,33 @@ +TEST (name "int_edge_callback_safe_dates__reads_dates_through_try_cast"); + +WITH __ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_safe_dates AS ( + SELECT + 'GC-01' AS callback_id, + '{"year":2026,"zone":"Europe/London"}' AS callback_json, + '2026-03-28'::DATE AS business_date_again + UNION ALL + SELECT + 'GC-02' AS callback_id, + '{"year":2026,"zone":"America/New_York"}' AS callback_json, + '2026-03-08'::DATE AS business_date_again + UNION ALL + SELECT + 'GC-03' AS callback_id, + '{"year":2026,"zone":"Asia/Kolkata"}' AS callback_json, + '2026-02-28'::DATE AS business_date_again +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_start_fallbacks.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_start_fallbacks.sql new file mode 100644 index 0000000000..1d4b070013 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_start_fallbacks.sql @@ -0,0 +1,30 @@ +TEST (name "int_edge_callback_start_fallbacks__falls_back_to_text_times"); + +WITH __ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_start_fallbacks AS ( + SELECT + 'GC-01' AS callback_id, + '2026-03-28 23:30:00.123456789'::TIMESTAMP_NTZ(9) AS start_at + UNION ALL + SELECT + 'GC-02' AS callback_id, + '2026-03-08 01:15:00.5'::TIMESTAMP_NTZ(9) AS start_at + UNION ALL + SELECT + 'GC-03' AS callback_id, + '2026-02-28 00:00:00'::TIMESTAMP_NTZ(9) AS start_at +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_text_dates.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_text_dates.sql new file mode 100644 index 0000000000..b42684eae8 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_text_dates.sql @@ -0,0 +1,33 @@ +TEST (name "int_edge_callback_text_dates__reads_text_dates_and_zoned_objects"); + +WITH __ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_text_dates AS ( + SELECT + 'GC-01' AS callback_id, + '2026-03-28'::DATE AS text_date, + '{"at":"2026-03-28 23:30:00.000 Z"}' AS event_json + UNION ALL + SELECT + 'GC-02' AS callback_id, + '2026-03-08'::DATE AS text_date, + '{"at":"2026-03-08 01:15:00.000 -0500"}' AS event_json + UNION ALL + SELECT + 'GC-03' AS callback_id, + '2026-02-28'::DATE AS text_date, + '{"at":"2026-02-28 18:45:30.000 +0530"}' AS event_json +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_wall_time_lists.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_wall_time_lists.sql new file mode 100644 index 0000000000..8513b36b83 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_wall_time_lists.sql @@ -0,0 +1,30 @@ +TEST (name "int_edge_callback_wall_time_lists__lists_wall_times_per_zone"); + +WITH __ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_wall_time_lists AS ( + SELECT + 'America/New_York' AS merchant_zone, + PARSE_JSON('["2026-03-08 01:15:00.000"]')::ARRAY AS wall_times + UNION ALL + SELECT + 'Asia/Kolkata' AS merchant_zone, + PARSE_JSON('["2026-02-28 18:45:30.000"]')::ARRAY AS wall_times + UNION ALL + SELECT + 'Europe/London' AS merchant_zone, + PARSE_JSON('["2026-03-28 23:30:00.000"]')::ARRAY AS wall_times +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_zone_words.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_zone_words.sql new file mode 100644 index 0000000000..7e927ca3eb --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_zone_words.sql @@ -0,0 +1,33 @@ +TEST (name "int_edge_callback_zone_words__counts_shared_words_and_keeps_zoned_times"); + +WITH __ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_zone_words AS ( + SELECT + 'GC-01' AS callback_id, + 1 AS shared_word_count, + '{"at":"2026-03-28 23:30:00.000 Z","zone":"Europe/London"}' AS event_json + UNION ALL + SELECT + 'GC-02' AS callback_id, + 0 AS shared_word_count, + '{"at":"2026-03-08 01:15:00.000 -0500","zone":"America/New_York"}' AS event_json + UNION ALL + SELECT + 'GC-03' AS callback_id, + 1 AS shared_word_count, + '{"at":"2026-02-28 18:45:30.000 +0530","zone":"Asia/Kolkata"}' AS event_json +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_zoned_dates.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_zoned_dates.sql new file mode 100644 index 0000000000..ee81029353 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_callback_zoned_dates.sql @@ -0,0 +1,26 @@ +TEST (name "int_edge_callback_zoned_dates__keeps_callbacks_by_zoned_date"); + +WITH __ref__stg_edge_gateway_callbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id, + v.merchant_zone::VARCHAR AS merchant_zone, + v.local_wall_time::TIMESTAMP_NTZ AS local_wall_time, + v.event_at::TIMESTAMP_TZ AS event_at, + v.event_at_ns::TIMESTAMP_NTZ(9) AS event_at_ns, + v.event_time_text::VARCHAR AS event_time_text, + v.business_date::DATE AS business_date + FROM VALUES + ('GC-01', 'Europe/London', '2026-03-28 23:30:00', '2026-03-28 23:30:00 +00:00', '2026-03-28 23:30:00.123456789', '2026-03-28T23:30:00+00:00', '2026-03-28'), + ('GC-02', 'America/New_York', '2026-03-08 01:15:00', '2026-03-08 01:15:00 -05:00', '2026-03-08 01:15:00.5', '2026-03-08T01:15:00-05:00', '2026-03-08'), + ('GC-03', 'Asia/Kolkata', '2026-02-28 18:45:30', '2026-02-28 18:45:30 +05:30', NULL, '2026-02-28', '2026-02-28') AS v(callback_id, merchant_zone, local_wall_time, event_at, event_at_ns, event_time_text, business_date) +), + +__expected__int_edge_callback_zoned_dates AS ( + SELECT + 'GC-01' AS callback_id, + '2026-03-28'::DATE AS event_date + UNION ALL + SELECT + 'GC-02' AS callback_id, + '2026-03-08'::DATE AS event_date +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_amount_spreads.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_amount_spreads.sql new file mode 100644 index 0000000000..0c9b682d92 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_amount_spreads.sql @@ -0,0 +1,29 @@ +TEST (name "int_edge_check_amount_spreads__computes_medians_and_rate_spreads"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_amount_spreads AS ( + SELECT + 'G-1' AS group_code, + 4.750::NUMBER(18,3) AS median_amount, + -0.047934024139::NUMBER(38,12) AS rate_spread + UNION ALL + SELECT + 'G-2' AS group_code, + 0.000::NUMBER(18,3) AS median_amount, + CAST(NULL AS NUMBER(38,12)) AS rate_spread +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_any_amounts.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_any_amounts.sql new file mode 100644 index 0000000000..c2a3cabae7 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_any_amounts.sql @@ -0,0 +1,27 @@ +TEST (name "int_edge_check_any_amounts__reads_any_amount_per_group"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_any_amounts AS ( + SELECT + 'G-1' AS group_code, + TRUE AS amounts_agree + UNION ALL + SELECT + 'G-2' AS group_code, + TRUE AS amounts_agree +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_bracket_strips.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_bracket_strips.sql new file mode 100644 index 0000000000..3a7ae522bc --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_bracket_strips.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_bracket_strips__strips_bracketed_text"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_bracket_strips AS ( + SELECT + 'AC-01' AS check_id, + '101,7' AS stripped_key + UNION ALL + SELECT + 'AC-02' AS check_id, + '2026-03-04' AS stripped_key + UNION ALL + SELECT + 'AC-03' AS check_id, + '7' AS stripped_key + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS VARCHAR) AS stripped_key +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_complete_pairs.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_complete_pairs.sql new file mode 100644 index 0000000000..649db66525 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_complete_pairs.sql @@ -0,0 +1,27 @@ +TEST (name "int_edge_check_complete_pairs__counts_complete_pairs"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_complete_pairs AS ( + SELECT + 'G-1' AS group_code, + 2 AS complete_pair_count + UNION ALL + SELECT + 'G-2' AS group_code, + 1 AS complete_pair_count +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_decoded_keys.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_decoded_keys.sql new file mode 100644 index 0000000000..1e9762e069 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_decoded_keys.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_decoded_keys__decodes_keys_as_binary"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_decoded_keys AS ( + SELECT + 'AC-01' AS check_id, + CAST(NULL AS VARCHAR) AS decoded_key_hex + UNION ALL + SELECT + 'AC-02' AS check_id, + CAST(NULL AS VARCHAR) AS decoded_key_hex + UNION ALL + SELECT + 'AC-03' AS check_id, + CAST(NULL AS VARCHAR) AS decoded_key_hex + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS VARCHAR) AS decoded_key_hex +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_distinct_tuples.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_distinct_tuples.sql new file mode 100644 index 0000000000..a3c3b1fdac --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_distinct_tuples.sql @@ -0,0 +1,27 @@ +TEST (name "int_edge_check_distinct_tuples__counts_distinct_tuples_per_group"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_distinct_tuples AS ( + SELECT + 'G-1' AS group_code, + 2 AS distinct_tuples + UNION ALL + SELECT + 'G-2' AS group_code, + 2 AS distinct_tuples +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_formatted_dates.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_formatted_dates.sql new file mode 100644 index 0000000000..28620f03b9 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_formatted_dates.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_formatted_dates__reads_dates_in_a_format_from_a_column"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_formatted_dates AS ( + SELECT + 'AC-01' AS check_id, + CAST(NULL AS DATE) AS key_date + UNION ALL + SELECT + 'AC-02' AS check_id, + '2026-03-04'::DATE AS key_date + UNION ALL + SELECT + 'AC-03' AS check_id, + CAST(NULL AS DATE) AS key_date + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS DATE) AS key_date +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_generated_rows.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_generated_rows.sql new file mode 100644 index 0000000000..76f064100c --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_generated_rows.sql @@ -0,0 +1,25 @@ +TEST (name "int_edge_check_generated_rows__generates_one_row_per_check"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_generated_rows AS ( + SELECT + 'all' AS summary_id, + 4 AS generated_count, + TRUE AS numbers_are_valid, + TRUE AS draws_are_one +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_group_flags.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_group_flags.sql new file mode 100644 index 0000000000..d806746838 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_group_flags.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_group_flags__flags_groups_without_payments"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_group_flags AS ( + SELECT + 'AC-01' AS check_id, + FALSE AS is_unpaid_group + UNION ALL + SELECT + 'AC-02' AS check_id, + FALSE AS is_unpaid_group + UNION ALL + SELECT + 'AC-03' AS check_id, + TRUE AS is_unpaid_group + UNION ALL + SELECT + 'AC-04' AS check_id, + TRUE AS is_unpaid_group +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_group_key_lists.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_group_key_lists.sql new file mode 100644 index 0000000000..fac9978a33 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_group_key_lists.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_group_key_lists__counts_group_keys_with_a_window"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_group_key_lists AS ( + SELECT + 'AC-01' AS check_id, + 2 AS group_key_count + UNION ALL + SELECT + 'AC-02' AS check_id, + 2 AS group_key_count + UNION ALL + SELECT + 'AC-03' AS check_id, + 1 AS group_key_count + UNION ALL + SELECT + 'AC-04' AS check_id, + 1 AS group_key_count +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_group_pivots.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_group_pivots.sql new file mode 100644 index 0000000000..c9cc0451b9 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_group_pivots.sql @@ -0,0 +1,39 @@ +TEST (name "int_edge_check_group_pivots__pivots_amounts_by_group"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_group_pivots AS ( + SELECT + 'AC-01' AS check_id, + 10.05::NUMBER(38,2) AS first_group_amount, + CAST(NULL AS NUMBER(38,2)) AS second_group_amount + UNION ALL + SELECT + 'AC-02' AS check_id, + -0.55::NUMBER(38,2) AS first_group_amount, + CAST(NULL AS NUMBER(38,2)) AS second_group_amount + UNION ALL + SELECT + 'AC-03' AS check_id, + CAST(NULL AS NUMBER(38,2)) AS first_group_amount, + 0.00::NUMBER(38,2) AS second_group_amount + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS NUMBER(38,2)) AS first_group_amount, + CAST(NULL AS NUMBER(38,2)) AS second_group_amount +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_key_list_edits.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_key_list_edits.sql new file mode 100644 index 0000000000..45519fca04 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_key_list_edits.sql @@ -0,0 +1,43 @@ +TEST (name "int_edge_check_key_list_edits__edits_key_lists_and_objects"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_key_list_edits AS ( + SELECT + 'AC-01' AS check_id, + 1 AS kept_part_count, + 3 AS appended_part_count, + '{"k":7,"r":1.000000000000000e-01}' AS check_json + UNION ALL + SELECT + 'AC-02' AS check_id, + 1 AS kept_part_count, + 2 AS appended_part_count, + '{"k":12,"r":2.000000000000000e-01}' AS check_json + UNION ALL + SELECT + 'AC-03' AS check_id, + 0 AS kept_part_count, + 2 AS appended_part_count, + '{"k":3,"r":3.000000000000000e-01}' AS check_json + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS NUMBER(38,0)) AS kept_part_count, + CAST(NULL AS NUMBER(38,0)) AS appended_part_count, + '{}' AS check_json +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_key_parts.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_key_parts.sql new file mode 100644 index 0000000000..d0c94d654a --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_key_parts.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_key_parts__reads_key_parts_as_numbers"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_key_parts AS ( + SELECT + 'AC-01' AS check_id, + 2 AS key_number_count + UNION ALL + SELECT + 'AC-02' AS check_id, + 1 AS key_number_count + UNION ALL + SELECT + 'AC-03' AS check_id, + 1 AS key_number_count + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS NUMBER(38,0)) AS key_number_count +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_key_rewrites.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_key_rewrites.sql new file mode 100644 index 0000000000..fb049db07c --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_key_rewrites.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_key_rewrites__rewrites_long_numbers_from_group_parts"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_key_rewrites AS ( + SELECT + 'AC-01' AS check_id, + 'G,1,7' AS rewritten_key + UNION ALL + SELECT + 'AC-02' AS check_id, + 'G,1-03-04' AS rewritten_key + UNION ALL + SELECT + 'AC-03' AS check_id, + '7' AS rewritten_key + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS VARCHAR) AS rewritten_key +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_label_lookups.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_label_lookups.sql new file mode 100644 index 0000000000..003c08f82d --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_label_lookups.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_label_lookups__looks_labels_up_by_key_part"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_label_lookups AS ( + SELECT + 'AC-01' AS check_id, + 'one hundred and one' AS key_label + UNION ALL + SELECT + 'AC-02' AS check_id, + CAST(NULL AS VARCHAR) AS key_label + UNION ALL + SELECT + 'AC-03' AS check_id, + 'seven' AS key_label + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS VARCHAR) AS key_label +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_last_known_keys.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_last_known_keys.sql new file mode 100644 index 0000000000..f574fed5ef --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_last_known_keys.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_last_known_keys__carries_the_last_listed_key_forward"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_last_known_keys AS ( + SELECT + 'AC-01' AS check_id, + '101,7' AS last_listed_key + UNION ALL + SELECT + 'AC-02' AS check_id, + '101,7' AS last_listed_key + UNION ALL + SELECT + 'AC-03' AS check_id, + CAST(NULL AS VARCHAR) AS last_listed_key + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS VARCHAR) AS last_listed_key +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_local_times.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_local_times.sql new file mode 100644 index 0000000000..0c61322264 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_local_times.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_local_times__reads_local_time_text"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_local_times AS ( + SELECT + 'AC-01' AS check_id, + '2026-03-04 12:00:00 Z'::TIMESTAMP_LTZ(9) AS noted_at + UNION ALL + SELECT + 'AC-02' AS check_id, + '2026-03-04 12:00:00 Z'::TIMESTAMP_LTZ(9) AS noted_at + UNION ALL + SELECT + 'AC-03' AS check_id, + '2026-03-04 12:00:00 Z'::TIMESTAMP_LTZ(9) AS noted_at + UNION ALL + SELECT + 'AC-04' AS check_id, + '2026-03-04 12:00:00 Z'::TIMESTAMP_LTZ(9) AS noted_at +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_minute_times.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_minute_times.sql new file mode 100644 index 0000000000..02e8b999d1 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_minute_times.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_minute_times__reads_times_without_seconds"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_minute_times AS ( + SELECT + 'AC-01' AS check_id, + '2024-05-01 15:00:00'::TIMESTAMP_NTZ(9) AS opened_at + UNION ALL + SELECT + 'AC-02' AS check_id, + '2024-05-01 15:00:00'::TIMESTAMP_NTZ(9) AS opened_at + UNION ALL + SELECT + 'AC-03' AS check_id, + '2024-05-01 15:00:00'::TIMESTAMP_NTZ(9) AS opened_at + UNION ALL + SELECT + 'AC-04' AS check_id, + '2024-05-01 15:00:00'::TIMESTAMP_NTZ(9) AS opened_at +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_month_starts.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_month_starts.sql new file mode 100644 index 0000000000..66328853b4 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_month_starts.sql @@ -0,0 +1,27 @@ +TEST (name "int_edge_check_month_starts__mixes_dates_and_text_in_values"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_month_starts AS ( + SELECT + 'P-1' AS period_id, + '2026-02-01' AS period_start + UNION ALL + SELECT + 'P-2' AS period_id, + '2026-01-01' AS period_start +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_note_unions.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_note_unions.sql new file mode 100644 index 0000000000..1016a82a72 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_note_unions.sql @@ -0,0 +1,51 @@ +TEST (name "int_edge_check_note_unions__fills_all_null_notes"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_note_unions AS ( + SELECT + 'AC-01~left' AS note_row_id, + CAST(NULL AS VARCHAR) AS note + UNION ALL + SELECT + 'AC-01~right' AS note_row_id, + CAST(NULL AS VARCHAR) AS note + UNION ALL + SELECT + 'AC-02~left' AS note_row_id, + CAST(NULL AS VARCHAR) AS note + UNION ALL + SELECT + 'AC-02~right' AS note_row_id, + CAST(NULL AS VARCHAR) AS note + UNION ALL + SELECT + 'AC-03~left' AS note_row_id, + CAST(NULL AS VARCHAR) AS note + UNION ALL + SELECT + 'AC-03~right' AS note_row_id, + CAST(NULL AS VARCHAR) AS note + UNION ALL + SELECT + 'AC-04~left' AS note_row_id, + CAST(NULL AS VARCHAR) AS note + UNION ALL + SELECT + 'AC-04~right' AS note_row_id, + CAST(NULL AS VARCHAR) AS note +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_number_arrays.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_number_arrays.sql new file mode 100644 index 0000000000..d6e97fcb3c --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_number_arrays.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_number_arrays__casts_amount_arrays_through_a_structured_type"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_number_arrays AS ( + SELECT + 'AC-01' AS check_id, + 1 AS amount_count + UNION ALL + SELECT + 'AC-02' AS check_id, + 1 AS amount_count + UNION ALL + SELECT + 'AC-03' AS check_id, + 1 AS amount_count + UNION ALL + SELECT + 'AC-04' AS check_id, + 1 AS amount_count +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_number_labels.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_number_labels.sql new file mode 100644 index 0000000000..135f033b2e --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_number_labels.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_number_labels__labels_checks_with_number_text"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_number_labels AS ( + SELECT + 'AC-01' AS check_id, + '501' AS cluster_label + UNION ALL + SELECT + 'AC-02' AS check_id, + '501' AS cluster_label + UNION ALL + SELECT + 'AC-03' AS check_id, + '501' AS cluster_label + UNION ALL + SELECT + 'AC-04' AS check_id, + '501' AS cluster_label +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_pair_filters.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_pair_filters.sql new file mode 100644 index 0000000000..f0f80376a9 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_pair_filters.sql @@ -0,0 +1,27 @@ +TEST (name "int_edge_check_pair_filters__keeps_listed_pairs"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_pair_filters AS ( + SELECT + 'AC-01' AS check_id, + TRUE AS has_seven + UNION ALL + SELECT + 'AC-03' AS check_id, + TRUE AS has_seven +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_pattern_matches.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_pattern_matches.sql new file mode 100644 index 0000000000..cbe299ae10 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_pattern_matches.sql @@ -0,0 +1,26 @@ +TEST (name "int_edge_check_pattern_matches__matches_keys_against_group_patterns"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.key_text::VARCHAR AS key_text + FROM VALUES + ('AC-01', '[[:digit:]]{3}', '101,7'), + ('AC-02', '^7$', '7'), + ('AC-03', '[[:alpha:]]+', '7') AS v(check_id, group_code, key_text) +), + +__expected__int_edge_check_pattern_matches AS ( + SELECT + 'AC-01' AS check_id, + FALSE AS matches_group + UNION ALL + SELECT + 'AC-02' AS check_id, + TRUE AS matches_group + UNION ALL + SELECT + 'AC-03' AS check_id, + FALSE AS matches_group +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_reduced_keys.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_reduced_keys.sql new file mode 100644 index 0000000000..06f1c124ae --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_reduced_keys.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_reduced_keys__folds_key_parts_onto_groups"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_reduced_keys AS ( + SELECT + 'AC-01' AS check_id, + 'G-1/101/7' AS folded_key + UNION ALL + SELECT + 'AC-02' AS check_id, + 'G-1/2026-03-04' AS folded_key + UNION ALL + SELECT + 'AC-03' AS check_id, + 'G-2/7' AS folded_key + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS VARCHAR) AS folded_key +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_sparse_arrays.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_sparse_arrays.sql new file mode 100644 index 0000000000..47c5a2306a --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_sparse_arrays.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_sparse_arrays__writes_arrays_with_holes"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_sparse_arrays AS ( + SELECT + 'AC-01' AS check_id, + '["101,7","G-1"]' AS pair_text + UNION ALL + SELECT + 'AC-02' AS check_id, + '["2026-03-04","G-1"]' AS pair_text + UNION ALL + SELECT + 'AC-03' AS check_id, + '["7","G-2"]' AS pair_text + UNION ALL + SELECT + 'AC-04' AS check_id, + '[undefined,"G-2"]' AS pair_text +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_text_arrays.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_text_arrays.sql new file mode 100644 index 0000000000..c218dd9527 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_text_arrays.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_text_arrays__casts_text_arrays_through_a_structured_type"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_text_arrays AS ( + SELECT + 'AC-01' AS check_id, + 2 AS key_part_count + UNION ALL + SELECT + 'AC-02' AS check_id, + 1 AS key_part_count + UNION ALL + SELECT + 'AC-03' AS check_id, + 1 AS key_part_count + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS NUMBER(38,0)) AS key_part_count +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_unnamed_labels.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_unnamed_labels.sql new file mode 100644 index 0000000000..144a6ff69d --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_unnamed_labels.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_unnamed_labels__reads_unaliased_labels"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_unnamed_labels AS ( + SELECT + 'AC-01' AS check_id, + 'fixed' AS label + UNION ALL + SELECT + 'AC-02' AS check_id, + 'fixed' AS label + UNION ALL + SELECT + 'AC-03' AS check_id, + 'fixed' AS label + UNION ALL + SELECT + 'AC-04' AS check_id, + 'fixed' AS label +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_variant_branches.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_variant_branches.sql new file mode 100644 index 0000000000..fa17b14462 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_variant_branches.sql @@ -0,0 +1,44 @@ +TEST (name "int_edge_check_variant_branches__branches_on_variant_paths"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio, + v.json_text::VARCHAR AS json_text + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1, '{"r": 0.1}'), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2, '{"r": 2}'), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3, NULL), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL, '{}') AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio, json_text) +), + +__expected__int_edge_check_variant_branches AS ( + SELECT + 'AC-01' AS check_id, + 1 AS ratio_branch, + TRUE AS dates_differ, + '0.2' AS largest_ratio_text + UNION ALL + SELECT + 'AC-02' AS check_id, + 2 AS ratio_branch, + TRUE AS dates_differ, + '0.2' AS largest_ratio_text + UNION ALL + SELECT + 'AC-03' AS check_id, + 2 AS ratio_branch, + TRUE AS dates_differ, + '0.3' AS largest_ratio_text + UNION ALL + SELECT + 'AC-04' AS check_id, + 2 AS ratio_branch, + TRUE AS dates_differ, + '0.3' AS largest_ratio_text +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_wide_sums.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_wide_sums.sql new file mode 100644 index 0000000000..9b736df874 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_wide_sums.sql @@ -0,0 +1,51 @@ +TEST (name "int_edge_check_wide_sums__stacks_narrow_and_wide_keys"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_wide_sums AS ( + SELECT + 'AC-01~amount' AS key_row_id, + 11.05::NUMBER(38,2) AS key_value + UNION ALL + SELECT + 'AC-01~wide' AS key_row_id, + 7.00::NUMBER(38,2) AS key_value + UNION ALL + SELECT + 'AC-02~amount' AS key_row_id, + 0.45::NUMBER(38,2) AS key_value + UNION ALL + SELECT + 'AC-02~wide' AS key_row_id, + 12.00::NUMBER(38,2) AS key_value + UNION ALL + SELECT + 'AC-03~amount' AS key_row_id, + 1.00::NUMBER(38,2) AS key_value + UNION ALL + SELECT + 'AC-03~wide' AS key_row_id, + CAST(NULL AS NUMBER(38,2)) AS key_value + UNION ALL + SELECT + 'AC-04~amount' AS key_row_id, + CAST(NULL AS NUMBER(38,2)) AS key_value + UNION ALL + SELECT + 'AC-04~wide' AS key_row_id, + 40.00::NUMBER(38,2) AS key_value +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_xml_checks.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_xml_checks.sql new file mode 100644 index 0000000000..fc4411a687 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_xml_checks.sql @@ -0,0 +1,39 @@ +TEST (name "int_edge_check_xml_checks__checks_key_text_as_xml"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_xml_checks AS ( + SELECT + 'AC-01' AS check_id, + '101,7' AS stripped_key, + 'not an XML element, pos 1' AS xml_error + UNION ALL + SELECT + 'AC-02' AS check_id, + '2026-03-04' AS stripped_key, + 'not an XML element, pos 1' AS xml_error + UNION ALL + SELECT + 'AC-03' AS check_id, + '7' AS stripped_key, + 'not an XML element, pos 1' AS xml_error + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS VARCHAR) AS stripped_key, + CAST(NULL AS VARCHAR) AS xml_error +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_zoned_literals.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_zoned_literals.sql new file mode 100644 index 0000000000..3dd81219b3 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_check_zoned_literals.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_check_zoned_literals__reads_iso_zoned_literals"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_check_zoned_literals AS ( + SELECT + 'AC-01' AS check_id, + '2026-03-04 12:00:02 Z'::TIMESTAMP_TZ(9) AS cutover_at + UNION ALL + SELECT + 'AC-02' AS check_id, + '2026-03-04 12:00:02 Z'::TIMESTAMP_TZ(9) AS cutover_at + UNION ALL + SELECT + 'AC-03' AS check_id, + '2026-03-04 12:00:02 Z'::TIMESTAMP_TZ(9) AS cutover_at + UNION ALL + SELECT + 'AC-04' AS check_id, + '2026-03-04 12:00:02 Z'::TIMESTAMP_TZ(9) AS cutover_at +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_key_number_reads.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_key_number_reads.sql new file mode 100644 index 0000000000..212a8d9f0e --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_key_number_reads.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_key_number_reads__reads_wide_keys_back_as_numbers"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_key_number_reads AS ( + SELECT + 'AC-01' AS check_id, + 7 AS wide_key_number + UNION ALL + SELECT + 'AC-02' AS check_id, + 12 AS wide_key_number + UNION ALL + SELECT + 'AC-03' AS check_id, + CAST(NULL AS NUMBER(38,0)) AS wide_key_number + UNION ALL + SELECT + 'AC-04' AS check_id, + 40 AS wide_key_number +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_key_rank_offsets.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_key_rank_offsets.sql new file mode 100644 index 0000000000..d5597e056f --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_key_rank_offsets.sql @@ -0,0 +1,39 @@ +TEST (name "int_edge_key_rank_offsets__adds_one_to_keys_and_reads_numbers_back"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_key_rank_offsets AS ( + SELECT + 'AC-01' AS check_id, + 8 AS candidate_rank, + 7 AS wide_key_number + UNION ALL + SELECT + 'AC-02' AS check_id, + 13 AS candidate_rank, + 12 AS wide_key_number + UNION ALL + SELECT + 'AC-03' AS check_id, + 1000 AS candidate_rank, + CAST(NULL AS NUMBER(38,0)) AS wide_key_number + UNION ALL + SELECT + 'AC-04' AS check_id, + 41 AS candidate_rank, + 40 AS wide_key_number +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ledger_paid_quantities.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ledger_paid_quantities.sql new file mode 100644 index 0000000000..b3b90aa107 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ledger_paid_quantities.sql @@ -0,0 +1,24 @@ +TEST (name "int_edge_ledger_paid_quantities__lists_paid_quantities_in_change_order"); + +WITH __ref__stg_edge_ledger_entries AS ( + SELECT + v.entry_id::VARCHAR AS entry_id, + v.order_ref::VARCHAR AS order_ref, + v.quantity_text::VARCHAR AS quantity_text, + v.status::VARCHAR AS status, + v.changed_at::TIMESTAMP_NTZ AS changed_at + FROM VALUES + ('LE-01', 'DS-O-1', '2', 'paid', '2026-03-01 10:00:00'), + ('LE-02', 'DS-O-1', '3.5', 'open', '2026-03-01 11:00:00'), + ('LE-03', 'DS-O-2', NULL, 'paid', '2026-03-02 09:00:00') AS v(entry_id, order_ref, quantity_text, status, changed_at) +), + +__expected__int_edge_ledger_paid_quantities AS ( + SELECT + 'DS-O-1' AS order_ref, + 1 AS paid_quantity_count + UNION ALL + SELECT + 'DS-O-2' AS order_ref, + 0 AS paid_quantity_count +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ledger_quantity_steps.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ledger_quantity_steps.sql new file mode 100644 index 0000000000..901093afe2 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ledger_quantity_steps.sql @@ -0,0 +1,23 @@ +TEST (name "int_edge_ledger_quantity_steps__subtracts_one_from_quantity_text"); + +WITH __ref__stg_edge_ledger_entries AS ( + SELECT + v.entry_id::VARCHAR AS entry_id, + v.order_ref::VARCHAR AS order_ref, + v.quantity_text::VARCHAR AS quantity_text, + v.status::VARCHAR AS status + FROM VALUES + ('LE-01', 'DS-O-1', '2', 'paid'), + ('LE-02', 'DS-O-1', '3.5', 'open'), + ('LE-03', 'DS-O-2', NULL, 'paid') AS v(entry_id, order_ref, quantity_text, status) +), + +__expected__int_edge_ledger_quantity_steps AS ( + SELECT + 'DS-O-1' AS order_ref, + 2.500000::NUMBER(38,6) AS quantity_less_one + UNION ALL + SELECT + 'DS-O-2' AS order_ref, + CAST(NULL AS NUMBER(38,6)) AS quantity_less_one +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_array_bounds.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_array_bounds.sql new file mode 100644 index 0000000000..cc75684ff0 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_array_bounds.sql @@ -0,0 +1,27 @@ +TEST (name "int_edge_ratio_array_bounds__reads_bounds_from_ratio_arrays"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_array_bounds AS ( + SELECT + 'G-1' AS group_code, + '-10.2'::FLOAT AS lower_bound + UNION ALL + SELECT + 'G-2' AS group_code, + '-10.3'::FLOAT AS lower_bound +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_array_casts.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_array_casts.sql new file mode 100644 index 0000000000..15342745b3 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_array_casts.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_ratio_array_casts__casts_ratio_arrays"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_array_casts AS ( + SELECT + 'AC-01' AS check_id, + 1 AS ratio_count + UNION ALL + SELECT + 'AC-02' AS check_id, + 1 AS ratio_count + UNION ALL + SELECT + 'AC-03' AS check_id, + 1 AS ratio_count + UNION ALL + SELECT + 'AC-04' AS check_id, + 1 AS ratio_count +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_array_positions.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_array_positions.sql new file mode 100644 index 0000000000..890b94d828 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_array_positions.sql @@ -0,0 +1,27 @@ +TEST (name "int_edge_ratio_array_positions__reads_the_last_ratio_by_position"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_array_positions AS ( + SELECT + 'G-1' AS group_code, + '0.2'::FLOAT AS last_ratio + UNION ALL + SELECT + 'G-2' AS group_code, + '0.3'::FLOAT AS last_ratio +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_averages.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_averages.sql new file mode 100644 index 0000000000..26fb47d705 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_averages.sql @@ -0,0 +1,27 @@ +TEST (name "int_edge_ratio_averages__averages_float_ratios_per_group"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_averages AS ( + SELECT + 'G-1' AS group_code, + '0.15000000000000002'::FLOAT AS average_ratio + UNION ALL + SELECT + 'G-2' AS group_code, + '0.3'::FLOAT AS average_ratio +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_fixed_scales.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_fixed_scales.sql new file mode 100644 index 0000000000..432ba16477 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_fixed_scales.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_ratio_fixed_scales__casts_ratios_to_a_fixed_scale"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_fixed_scales AS ( + SELECT + 'AC-01' AS check_id, + 0.1000000000::NUMBER(38,10) AS ratio_fixed + UNION ALL + SELECT + 'AC-02' AS check_id, + 0.2000000000::NUMBER(38,10) AS ratio_fixed + UNION ALL + SELECT + 'AC-03' AS check_id, + 0.3000000000::NUMBER(38,10) AS ratio_fixed + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS NUMBER(38,10)) AS ratio_fixed +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_group_objects.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_group_objects.sql new file mode 100644 index 0000000000..d026055888 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_group_objects.sql @@ -0,0 +1,29 @@ +TEST (name "int_edge_ratio_group_objects__collects_ratios_per_group"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_group_objects AS ( + SELECT + 'G-1' AS group_code, + '{"AC-01":1.000000000000000e-01,"AC-02":2.000000000000000e-01}' AS ratio_json, + 2 AS distinct_ratio_count + UNION ALL + SELECT + 'G-2' AS group_code, + '{"AC-03":3.000000000000000e-01}' AS ratio_json, + 1 AS distinct_ratio_count +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_hashes.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_hashes.sql new file mode 100644 index 0000000000..339feee51a --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_hashes.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_ratio_hashes__hashes_ratios"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_hashes AS ( + SELECT + 'AC-01' AS check_id, + TRUE AS hash_is_stable + UNION ALL + SELECT + 'AC-02' AS check_id, + TRUE AS hash_is_stable + UNION ALL + SELECT + 'AC-03' AS check_id, + TRUE AS hash_is_stable + UNION ALL + SELECT + 'AC-04' AS check_id, + TRUE AS hash_is_stable +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_identity_objects.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_identity_objects.sql new file mode 100644 index 0000000000..15eeec8b67 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_identity_objects.sql @@ -0,0 +1,31 @@ +TEST (name "int_edge_ratio_identity_objects__reads_kinds_of_ratio_identities"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_identity_objects AS ( + SELECT + 'AC-01' AS check_id, + 'ratio' AS identity_kind + UNION ALL + SELECT + 'AC-02' AS check_id, + 'ratio' AS identity_kind + UNION ALL + SELECT + 'AC-03' AS check_id, + 'ratio' AS identity_kind +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_ignore_case_reads.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_ignore_case_reads.sql new file mode 100644 index 0000000000..4e207cd509 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_ignore_case_reads.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_ratio_ignore_case_reads__reads_ratios_by_key_in_any_case"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_ignore_case_reads AS ( + SELECT + 'AC-01' AS check_id, + '0.1'::FLOAT AS ratio_again + UNION ALL + SELECT + 'AC-02' AS check_id, + '0.2'::FLOAT AS ratio_again + UNION ALL + SELECT + 'AC-03' AS check_id, + '0.3'::FLOAT AS ratio_again + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS FLOAT) AS ratio_again +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_object_differences.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_object_differences.sql new file mode 100644 index 0000000000..086f80bc49 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_object_differences.sql @@ -0,0 +1,31 @@ +TEST (name "int_edge_ratio_object_differences__keeps_ratio_objects_not_in_the_fixed_list"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_object_differences AS ( + SELECT + 'AC-02' AS check_id, + '{"r":2.000000000000000e-01}' AS check_json + UNION ALL + SELECT + 'AC-03' AS check_id, + '{"r":3.000000000000000e-01}' AS check_json + UNION ALL + SELECT + 'AC-04' AS check_id, + '{}' AS check_json +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_object_flags.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_object_flags.sql new file mode 100644 index 0000000000..105734bf2c --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_object_flags.sql @@ -0,0 +1,25 @@ +TEST (name "int_edge_ratio_object_flags__reads_flags_back_as_booleans"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 0.1), + ('AC-02', -0.5), + ('AC-03', NULL) AS v(check_id, ratio) +), + +__expected__int_edge_ratio_object_flags AS ( + SELECT + 'AC-01' AS check_id, + TRUE AS ratio_flag + UNION ALL + SELECT + 'AC-02' AS check_id, + FALSE AS ratio_flag + UNION ALL + SELECT + 'AC-03' AS check_id, + CAST(NULL AS BOOLEAN) AS ratio_flag +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_object_inserts.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_object_inserts.sql new file mode 100644 index 0000000000..932f6baad9 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_object_inserts.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_ratio_object_inserts__adds_keys_to_ratio_objects"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_object_inserts AS ( + SELECT + 'AC-01' AS check_id, + '{"check":"AC-01","r":1.000000000000000e-01}' AS check_json + UNION ALL + SELECT + 'AC-02' AS check_id, + '{"check":"AC-02","r":2.000000000000000e-01}' AS check_json + UNION ALL + SELECT + 'AC-03' AS check_id, + '{"check":"AC-03","r":3.000000000000000e-01}' AS check_json + UNION ALL + SELECT + 'AC-04' AS check_id, + '{"check":"AC-04"}' AS check_json +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_object_reads.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_object_reads.sql new file mode 100644 index 0000000000..d21255a4b3 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_object_reads.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_ratio_object_reads__reads_ratios_back_as_integers"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_object_reads AS ( + SELECT + 'AC-01' AS check_id, + 0 AS ratio_integer + UNION ALL + SELECT + 'AC-02' AS check_id, + 0 AS ratio_integer + UNION ALL + SELECT + 'AC-03' AS check_id, + 0 AS ratio_integer + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS NUMBER(38,0)) AS ratio_integer +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_path_checks.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_path_checks.sql new file mode 100644 index 0000000000..1c8e8eb01d --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_path_checks.sql @@ -0,0 +1,23 @@ +TEST (name "int_edge_ratio_path_checks__keeps_checks_without_a_ratio"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_path_checks AS ( + SELECT + 'AC-04' AS check_id, + CAST(NULL AS NUMBER(38,0)) AS key_span +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_percent_texts.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_percent_texts.sql new file mode 100644 index 0000000000..d1c91848a2 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_percent_texts.sql @@ -0,0 +1,35 @@ +TEST (name "int_edge_ratio_percent_texts__formats_float_ratios_as_percentages"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_percent_texts AS ( + SELECT + 'AC-01' AS check_id, + '10.0%' AS ratio_percent + UNION ALL + SELECT + 'AC-02' AS check_id, + '20.0%' AS ratio_percent + UNION ALL + SELECT + 'AC-03' AS check_id, + '30.0%' AS ratio_percent + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS VARCHAR) AS ratio_percent +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_running_totals.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_running_totals.sql new file mode 100644 index 0000000000..25a2ba4b40 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_running_totals.sql @@ -0,0 +1,31 @@ +TEST (name "int_edge_ratio_running_totals__sums_float_ratios_in_check_order"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 0.1), + ('AC-02', 'G-1', 0.2), + ('AC-03', 'G-1', 0.3), + ('AC-04', 'G-2', 1.5) AS v(check_id, group_code, ratio) +), + +__expected__int_edge_ratio_running_totals AS ( + SELECT + 'AC-01' AS check_id, + '0.1'::FLOAT AS running_ratio + UNION ALL + SELECT + 'AC-02' AS check_id, + '0.30000000000000004'::FLOAT AS running_ratio + UNION ALL + SELECT + 'AC-03' AS check_id, + '0.6'::FLOAT AS running_ratio + UNION ALL + SELECT + 'AC-04' AS check_id, + '1.5'::FLOAT AS running_ratio +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_safe_casts.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_safe_casts.sql new file mode 100644 index 0000000000..ea820af81f --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_safe_casts.sql @@ -0,0 +1,39 @@ +TEST (name "int_edge_ratio_safe_casts__reads_ratios_through_try_cast"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_safe_casts AS ( + SELECT + 'AC-01' AS check_id, + '{"key":"101,7","keys":{"narrow":7}}' AS check_json, + '0.1'::FLOAT AS ratio_again + UNION ALL + SELECT + 'AC-02' AS check_id, + '{"key":"2026-03-04","keys":{"narrow":12}}' AS check_json, + '0.2'::FLOAT AS ratio_again + UNION ALL + SELECT + 'AC-03' AS check_id, + '{"key":"7","keys":{"narrow":3}}' AS check_json, + '0.3'::FLOAT AS ratio_again + UNION ALL + SELECT + 'AC-04' AS check_id, + '{"keys":{}}' AS check_json, + CAST(NULL AS FLOAT) AS ratio_again +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_text_forms.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_text_forms.sql new file mode 100644 index 0000000000..a584eb6ab7 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_text_forms.sql @@ -0,0 +1,43 @@ +TEST (name "int_edge_ratio_text_forms__writes_ratios_as_text"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_text_forms AS ( + SELECT + 'AC-01' AS check_id, + ' 0.1 ' AS ratio_text, + '*' AS ratio_stars, + '1096.6331584284585'::FLOAT AS narrow_key_exp + UNION ALL + SELECT + 'AC-02' AS check_id, + ' 0.2 ' AS ratio_text, + '**' AS ratio_stars, + '162754.79141900392'::FLOAT AS narrow_key_exp + UNION ALL + SELECT + 'AC-03' AS check_id, + ' 0.3 ' AS ratio_text, + '***' AS ratio_stars, + '20.085536923187668'::FLOAT AS narrow_key_exp + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS VARCHAR) AS ratio_text, + CAST(NULL AS VARCHAR) AS ratio_stars, + CAST(NULL AS FLOAT) AS narrow_key_exp +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_text_replaces.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_text_replaces.sql new file mode 100644 index 0000000000..f2262db504 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_text_replaces.sql @@ -0,0 +1,39 @@ +TEST (name "int_edge_ratio_text_replaces__writes_ratios_with_commas"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_text_replaces AS ( + SELECT + 'AC-01' AS check_id, + CAST(NULL AS TIMESTAMP_NTZ(9)) AS key_time, + '0,1' AS ratio_text + UNION ALL + SELECT + 'AC-02' AS check_id, + '2026-03-04 00:00:00'::TIMESTAMP_NTZ(9) AS key_time, + '0,2' AS ratio_text + UNION ALL + SELECT + 'AC-03' AS check_id, + '1970-01-01 00:00:07'::TIMESTAMP_NTZ(9) AS key_time, + '0,3' AS ratio_text + UNION ALL + SELECT + 'AC-04' AS check_id, + CAST(NULL AS TIMESTAMP_NTZ(9)) AS key_time, + CAST(NULL AS VARCHAR) AS ratio_text +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_variant_unions.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_variant_unions.sql new file mode 100644 index 0000000000..cc414725e4 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_ratio_variant_unions.sql @@ -0,0 +1,51 @@ +TEST (name "int_edge_ratio_variant_unions__stacks_float_and_text_variants"); + +WITH __ref__stg_edge_amount_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id, + v.group_code::VARCHAR AS group_code, + v.narrow_key::NUMBER(18, 0) AS narrow_key, + v.wide_key::NUMBER(38, 0) AS wide_key, + v.key_text::VARCHAR AS key_text, + v.amount::NUMBER(18, 2) AS amount, + v.ratio::FLOAT AS ratio + FROM VALUES + ('AC-01', 'G-1', 7, 7, '101,7', 10.05, 0.1), + ('AC-02', 'G-1', 12, 12, '2026-03-04', -0.55, 0.2), + ('AC-03', 'G-2', 3, NULL, '7', 0.00, 0.3), + ('AC-04', 'G-2', NULL, 40, NULL, NULL, NULL) AS v(check_id, group_code, narrow_key, wide_key, key_text, amount, ratio) +), + +__expected__int_edge_ratio_variant_unions AS ( + SELECT + 'AC-01~key' AS value_row_id, + '101,7' AS value_text + UNION ALL + SELECT + 'AC-01~ratio' AS value_row_id, + '0.1' AS value_text + UNION ALL + SELECT + 'AC-02~key' AS value_row_id, + '2026-03-04' AS value_text + UNION ALL + SELECT + 'AC-02~ratio' AS value_row_id, + '0.2' AS value_text + UNION ALL + SELECT + 'AC-03~key' AS value_row_id, + '7' AS value_text + UNION ALL + SELECT + 'AC-03~ratio' AS value_row_id, + '0.3' AS value_text + UNION ALL + SELECT + 'AC-04~key' AS value_row_id, + CAST(NULL AS VARCHAR) AS value_text + UNION ALL + SELECT + 'AC-04~ratio' AS value_row_id, + CAST(NULL AS VARCHAR) AS value_text +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_variant_decimal_reads.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_variant_decimal_reads.sql new file mode 100644 index 0000000000..e901f47b77 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_variant_decimal_reads.sql @@ -0,0 +1,21 @@ +TEST (name "int_edge_variant_decimal_reads__reads_numeric_variants_as_decimals"); + +WITH __ref__stg_edge_variant_values AS ( + SELECT + v.value_id::VARCHAR AS value_id, + v.group_code::VARCHAR AS group_code, + v.sort_key::NUMBER(38, 0) AS sort_key, + PARSE_JSON(v.attribute_value) AS attribute_value, + v.value_text::VARCHAR AS value_text + FROM VALUES + ('VV-01', 'V-1', 1, '{"sku": "DK-1", "qty": 2}', 'DK-1'), + ('VV-02', 'V-1', 2, '1.5', '1.5'), + ('VV-03', 'V-2', 1, '"2026-03-01"', '2026-03-01'), + ('VV-04', 'V-2', 2, 'null', NULL) AS v(value_id, group_code, sort_key, attribute_value, value_text) +), + +__expected__int_edge_variant_decimal_reads AS ( + SELECT + 'VV-02' AS value_id, + 1.5000::NUMBER(10,4) AS decimal_value +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_variant_element_counts.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_variant_element_counts.sql new file mode 100644 index 0000000000..5ee677911f --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_variant_element_counts.sql @@ -0,0 +1,21 @@ +TEST (name "int_edge_variant_element_counts__counts_flattened_elements"); + +WITH __ref__stg_edge_variant_values AS ( + SELECT + v.value_id::VARCHAR AS value_id, + v.group_code::VARCHAR AS group_code, + v.sort_key::NUMBER(38, 0) AS sort_key, + PARSE_JSON(v.attribute_value) AS attribute_value, + v.value_text::VARCHAR AS value_text + FROM VALUES + ('VV-01', 'V-1', 1, '{"sku": "DK-1", "qty": 2}', 'DK-1'), + ('VV-02', 'V-1', 2, '1.5', '1.5'), + ('VV-03', 'V-2', 1, '"2026-03-01"', '2026-03-01'), + ('VV-04', 'V-2', 2, 'null', NULL) AS v(value_id, group_code, sort_key, attribute_value, value_text) +), + +__expected__int_edge_variant_element_counts AS ( + SELECT + 'V-1' AS group_code, + 2 AS element_count +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_variant_expected_values.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_variant_expected_values.sql new file mode 100644 index 0000000000..5310124a21 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_variant_expected_values.sql @@ -0,0 +1,26 @@ +TEST (name "int_edge_variant_expected_values__compares_values_with_expected_ones"); + +WITH __ref__stg_edge_variant_values AS ( + SELECT + v.value_id::VARCHAR AS value_id, + v.group_code::VARCHAR AS group_code, + v.sort_key::NUMBER(38, 0) AS sort_key, + PARSE_JSON(v.attribute_value) AS attribute_value, + v.value_text::VARCHAR AS value_text + FROM VALUES + ('VV-01', 'V-1', 1, '{"sku": "DK-1", "qty": 2}', 'DK-1'), + ('VV-02', 'V-1', 2, '1.5', '1.5'), + ('VV-03', 'V-2', 1, '"2026-03-01"', '2026-03-01'), + ('VV-04', 'V-2', 2, 'null', NULL) AS v(value_id, group_code, sort_key, attribute_value, value_text) +), + +__expected__int_edge_variant_expected_values AS ( + SELECT + 'VV-01' AS value_id + UNION ALL + SELECT + 'VV-03' AS value_id + UNION ALL + SELECT + 'VV-04' AS value_id +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_variant_xml_elements.sql b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_variant_xml_elements.sql new file mode 100644 index 0000000000..caa3d5c8bf --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/intermediate/edge_cases/test_int_edge_variant_xml_elements.sql @@ -0,0 +1,23 @@ +TEST (name "int_edge_variant_xml_elements__reads_sku_elements"); + +WITH __ref__stg_edge_variant_values AS ( + SELECT + v.value_id::VARCHAR AS value_id, + v.group_code::VARCHAR AS group_code, + v.sort_key::NUMBER(38, 0) AS sort_key, + PARSE_XML(v.attribute_value) AS attribute_value, + v.value_text::VARCHAR AS value_text + FROM VALUES + ('VX-01', 'X-1', 1, 'DK-1', NULL), + ('VX-02', 'X-1', 2, '2', NULL) AS v(value_id, group_code, sort_key, attribute_value, value_text) +), + +__expected__int_edge_variant_xml_elements AS ( + SELECT + 'VX-01' AS value_id, + 'DK-1' AS sku_text + UNION ALL + SELECT + 'VX-02' AS value_id, + CAST(NULL AS VARCHAR) AS sku_text +) diff --git a/benchmarks/duckshop/project/tests/unit/intermediate/inventory/test_int_purchase_order_lines_received__measures_fill_and_lateness_in_warehouse_time.sql b/benchmarks/duckshop/project/tests/unit/intermediate/inventory/test_int_purchase_order_lines_received__measures_fill_and_lateness_in_warehouse_time.sql index 8b9a1d32fe..241a8d0724 100644 --- a/benchmarks/duckshop/project/tests/unit/intermediate/inventory/test_int_purchase_order_lines_received__measures_fill_and_lateness_in_warehouse_time.sql +++ b/benchmarks/duckshop/project/tests/unit/intermediate/inventory/test_int_purchase_order_lines_received__measures_fill_and_lateness_in_warehouse_time.sql @@ -32,19 +32,19 @@ WITH __ref__stg_po_receipts AS ( __ref__stg_purchase_order_lines AS ( SELECT - 'PO1' AS po_id, - NULL AS currency_code, 'PO1#1' AS po_line_key, + 'PO1' AS po_id, 'DUCK-1' AS sku, 10 AS ordered_qty, - NULL AS unit_cost_minor + NULL AS unit_cost_minor, + NULL AS currency_code UNION ALL SELECT - 'PO1', - NULL, 'PO1#2', + 'PO1', 'DUCK-2', 5, + NULL, NULL ), diff --git a/benchmarks/duckshop/project/tests/unit/marts/core/test_dim_customers__combines_profile_value_consent_and_loyalty.sql b/benchmarks/duckshop/project/tests/unit/marts/core/test_dim_customers__combines_profile_value_consent_and_loyalty.sql index c3019535ba..5e6b165e20 100644 --- a/benchmarks/duckshop/project/tests/unit/marts/core/test_dim_customers__combines_profile_value_consent_and_loyalty.sql +++ b/benchmarks/duckshop/project/tests/unit/marts/core/test_dim_customers__combines_profile_value_consent_and_loyalty.sql @@ -115,23 +115,23 @@ __ref__int_customer_consent_state AS ( __ref__int_loyalty_tier_changes AS ( SELECT + 'LA1:1' AS tier_change_key, NULL AS loyalty_account_id, 'C1' AS customer_id, + 1 AS change_sequence, 'DUCKLING' AS tier_code, NULL AS previous_tier_code, - 'LA1:1' AS tier_change_key, - 1 AS change_sequence, NULL AS changed_at, NULL AS direction, NULL AS days_in_previous_tier UNION ALL SELECT + 'LA1:2', NULL, 'C1', + 2, 'GOLDEN_DUCK', NULL, - 'LA1:2', - 2, NULL, NULL, NULL diff --git a/benchmarks/duckshop/project/tests/unit/marts/edge_cases/test_rpt_edge_case_array_model_keys.sql b/benchmarks/duckshop/project/tests/unit/marts/edge_cases/test_rpt_edge_case_array_model_keys.sql new file mode 100644 index 0000000000..4ddb18fe0b --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/marts/edge_cases/test_rpt_edge_case_array_model_keys.sql @@ -0,0 +1,15 @@ +TEST (name "rpt_edge_case_array_model_keys__lists_one_key_per_array_model"); + +WITH __ref__int_edge_callback_wall_time_lists AS ( + SELECT + v.merchant_zone::VARCHAR AS merchant_zone + FROM VALUES + ('callback_wal-1') AS v(merchant_zone) +), + +__expected__rpt_edge_case_array_model_keys AS ( + SELECT + 'int_edge_callback_wall_time_lists~callback_wal-1' AS model_key_id, + 'int_edge_callback_wall_time_lists' AS model_name, + 'callback_wal-1' AS model_key +) diff --git a/benchmarks/duckshop/project/tests/unit/marts/edge_cases/test_rpt_edge_case_model_keys.sql b/benchmarks/duckshop/project/tests/unit/marts/edge_cases/test_rpt_edge_case_model_keys.sql new file mode 100644 index 0000000000..ce02527e16 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/marts/edge_cases/test_rpt_edge_case_model_keys.sql @@ -0,0 +1,1095 @@ +TEST (name "rpt_edge_case_model_keys__lists_one_key_per_model"); + +WITH __ref__int_edge_ratio_running_totals AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('ratio_runnin-1') AS v(check_id) +), + +__ref__int_edge_ratio_averages AS ( + SELECT + v.group_code::VARCHAR AS group_code + FROM VALUES + ('ratio_averag-1') AS v(group_code) +), + +__ref__int_edge_callback_recent_offsets AS ( + SELECT + v.callback_id::VARCHAR AS callback_id + FROM VALUES + ('callback_rec-1') AS v(callback_id) +), + +__ref__int_edge_callback_epoch_reads AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('callback_epo-1') AS v(check_id) +), + +__ref__int_edge_callback_zone_words AS ( + SELECT + v.callback_id::VARCHAR AS callback_id + FROM VALUES + ('callback_zon-1') AS v(callback_id) +), + +__ref__int_edge_callback_text_dates AS ( + SELECT + v.callback_id::VARCHAR AS callback_id + FROM VALUES + ('callback_tex-1') AS v(callback_id) +), + +__ref__int_edge_key_rank_offsets AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('key_rank_off-1') AS v(check_id) +), + +__ref__int_edge_key_number_reads AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('key_number_r-1') AS v(check_id) +), + +__ref__int_edge_callback_epoch_parts AS ( + SELECT + v.callback_id::VARCHAR AS callback_id + FROM VALUES + ('callback_epo-1') AS v(callback_id) +), + +__ref__int_edge_check_pair_filters AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_pair_f-1') AS v(check_id) +), + +__ref__int_edge_check_wide_sums AS ( + SELECT + v.key_row_id::VARCHAR AS key_row_id + FROM VALUES + ('check_wide_s-1') AS v(key_row_id) +), + +__ref__int_edge_ratio_variant_unions AS ( + SELECT + v.value_row_id::VARCHAR AS value_row_id + FROM VALUES + ('ratio_varian-1') AS v(value_row_id) +), + +__ref__int_edge_check_note_unions AS ( + SELECT + v.note_row_id::VARCHAR AS note_row_id + FROM VALUES + ('check_note_u-1') AS v(note_row_id) +), + +__ref__int_edge_ratio_array_bounds AS ( + SELECT + v.group_code::VARCHAR AS group_code + FROM VALUES + ('ratio_array_-1') AS v(group_code) +), + +__ref__int_edge_check_zoned_literals AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_zoned_-1') AS v(check_id) +), + +__ref__int_edge_callback_day_starts AS ( + SELECT + v.callback_id::VARCHAR AS callback_id + FROM VALUES + ('callback_day-1') AS v(callback_id) +), + +__ref__int_edge_callback_clock_times AS ( + SELECT + v.callback_id::VARCHAR AS callback_id + FROM VALUES + ('callback_clo-1') AS v(callback_id) +), + +__ref__int_edge_check_number_arrays AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_number-1') AS v(check_id) +), + +__ref__int_edge_check_text_arrays AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_text_a-1') AS v(check_id) +), + +__ref__int_edge_check_key_rewrites AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_key_re-1') AS v(check_id) +), + +__ref__int_edge_variant_decimal_reads AS ( + SELECT + v.value_id::VARCHAR AS value_id + FROM VALUES + ('variant_deci-1') AS v(value_id) +), + +__ref__int_edge_ratio_safe_casts AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('ratio_safe_c-1') AS v(check_id) +), + +__ref__int_edge_callback_safe_dates AS ( + SELECT + v.callback_id::VARCHAR AS callback_id + FROM VALUES + ('callback_saf-1') AS v(callback_id) +), + +__ref__int_edge_ratio_percent_texts AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('ratio_percen-1') AS v(check_id) +), + +__ref__int_edge_callback_row_numbers AS ( + SELECT + v.callback_id::VARCHAR AS callback_id + FROM VALUES + ('callback_row-1') AS v(callback_id) +), + +__ref__int_edge_check_xml_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_xml_ch-1') AS v(check_id) +), + +__ref__int_edge_variant_xml_elements AS ( + SELECT + v.value_id::VARCHAR AS value_id + FROM VALUES + ('variant_xml_-1') AS v(value_id) +), + +__ref__int_edge_callback_latest_dates AS ( + SELECT + v.merchant_zone::VARCHAR AS merchant_zone + FROM VALUES + ('callback_lat-1') AS v(merchant_zone) +), + +__ref__int_edge_check_group_key_lists AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_group_-1') AS v(check_id) +), + +__ref__int_edge_ratio_array_casts AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('ratio_array_-1') AS v(check_id) +), + +__ref__int_edge_ratio_text_replaces AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('ratio_text_r-1') AS v(check_id) +), + +__ref__int_edge_ratio_object_reads AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('ratio_object-1') AS v(check_id) +), + +__ref__int_edge_ratio_object_flags AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('ratio_object-1') AS v(check_id) +), + +__ref__int_edge_ratio_identity_objects AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('ratio_identi-1') AS v(check_id) +), + +__ref__int_edge_ratio_array_positions AS ( + SELECT + v.group_code::VARCHAR AS group_code + FROM VALUES + ('ratio_array_-1') AS v(group_code) +), + +__ref__int_edge_check_local_times AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_local_-1') AS v(check_id) +), + +__ref__int_edge_ratio_ignore_case_reads AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('ratio_ignore-1') AS v(check_id) +), + +__ref__int_edge_callback_zoned_dates AS ( + SELECT + v.callback_id::VARCHAR AS callback_id + FROM VALUES + ('callback_zon-1') AS v(callback_id) +), + +__ref__int_edge_ratio_object_inserts AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('ratio_object-1') AS v(check_id) +), + +__ref__int_edge_callback_date_lists AS ( + SELECT + v.merchant_zone::VARCHAR AS merchant_zone + FROM VALUES + ('callback_dat-1') AS v(merchant_zone) +), + +__ref__int_edge_check_bracket_strips AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_bracke-1') AS v(check_id) +), + +__ref__int_edge_ratio_path_checks AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('ratio_path_c-1') AS v(check_id) +), + +__ref__int_edge_ratio_fixed_scales AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('ratio_fixed_-1') AS v(check_id) +), + +__ref__int_edge_check_formatted_dates AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_format-1') AS v(check_id) +), + +__ref__int_edge_callback_last_day AS ( + SELECT + v.callback_id::VARCHAR AS callback_id + FROM VALUES + ('callback_las-1') AS v(callback_id) +), + +__ref__int_edge_check_month_starts AS ( + SELECT + v.period_id::VARCHAR AS period_id + FROM VALUES + ('check_month_-1') AS v(period_id) +), + +__ref__int_edge_check_key_parts AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_key_pa-1') AS v(check_id) +), + +__ref__int_edge_variant_expected_values AS ( + SELECT + v.value_id::VARCHAR AS value_id + FROM VALUES + ('variant_expe-1') AS v(value_id) +), + +__ref__int_edge_check_reduced_keys AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_reduce-1') AS v(check_id) +), + +__ref__int_edge_ratio_hashes AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('ratio_hashes-1') AS v(check_id) +), + +__ref__int_edge_ratio_object_differences AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('ratio_object-1') AS v(check_id) +), + +__ref__int_edge_check_group_flags AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_group_-1') AS v(check_id) +), + +__ref__int_edge_check_label_lookups AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_label_-1') AS v(check_id) +), + +__ref__int_edge_check_distinct_tuples AS ( + SELECT + v.group_code::VARCHAR AS group_code + FROM VALUES + ('check_distin-1') AS v(group_code) +), + +__ref__int_edge_callback_start_fallbacks AS ( + SELECT + v.callback_id::VARCHAR AS callback_id + FROM VALUES + ('callback_sta-1') AS v(callback_id) +), + +__ref__int_edge_amount_percent_texts AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('amount_perce-1') AS v(check_id) +), + +__ref__int_edge_check_minute_times AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_minute-1') AS v(check_id) +), + +__ref__int_edge_check_number_labels AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_number-1') AS v(check_id) +), + +__ref__int_edge_check_decoded_keys AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_decode-1') AS v(check_id) +), + +__ref__int_edge_callback_london_times AS ( + SELECT + v.callback_id::VARCHAR AS callback_id + FROM VALUES + ('callback_lon-1') AS v(callback_id) +), + +__ref__int_edge_check_pattern_matches AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_patter-1') AS v(check_id) +), + +__ref__int_edge_check_any_amounts AS ( + SELECT + v.group_code::VARCHAR AS group_code + FROM VALUES + ('check_any_am-1') AS v(group_code) +), + +__ref__int_edge_check_sparse_arrays AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_sparse-1') AS v(check_id) +), + +__ref__int_edge_check_last_known_keys AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_last_k-1') AS v(check_id) +), + +__ref__int_edge_callback_day_documents AS ( + SELECT + v.merchant_zone::VARCHAR AS merchant_zone + FROM VALUES + ('callback_day-1') AS v(merchant_zone) +), + +__ref__int_edge_check_key_list_edits AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_key_li-1') AS v(check_id) +), + +__ref__int_edge_ratio_group_objects AS ( + SELECT + v.group_code::VARCHAR AS group_code + FROM VALUES + ('ratio_group_-1') AS v(group_code) +), + +__ref__int_edge_ratio_text_forms AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('ratio_text_f-1') AS v(check_id) +), + +__ref__int_edge_check_variant_branches AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_varian-1') AS v(check_id) +), + +__ref__int_edge_ledger_quantity_steps AS ( + SELECT + v.order_ref::VARCHAR AS order_ref + FROM VALUES + ('ledger_quant-1') AS v(order_ref) +), + +__ref__int_edge_check_generated_rows AS ( + SELECT + v.summary_id::VARCHAR AS summary_id + FROM VALUES + ('check_genera-1') AS v(summary_id) +), + +__ref__int_edge_check_unnamed_labels AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_unname-1') AS v(check_id) +), + +__ref__int_edge_basket_tag_list_reads AS ( + SELECT + v.basket_id::VARCHAR AS basket_id + FROM VALUES + ('basket_tag_l-1') AS v(basket_id) +), + +__ref__int_edge_basket_sku_part_filters AS ( + SELECT + v.line_id::VARCHAR AS line_id + FROM VALUES + ('basket_sku_p-1') AS v(line_id) +), + +__ref__int_edge_basket_distinct_tags AS ( + SELECT + v.tag_text::VARCHAR AS tag_text + FROM VALUES + ('basket_disti-1') AS v(tag_text) +), + +__ref__int_edge_check_amount_spreads AS ( + SELECT + v.group_code::VARCHAR AS group_code + FROM VALUES + ('check_amount-1') AS v(group_code) +), + +__ref__int_edge_check_group_pivots AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('check_group_-1') AS v(check_id) +), + +__ref__int_edge_check_complete_pairs AS ( + SELECT + v.group_code::VARCHAR AS group_code + FROM VALUES + ('check_comple-1') AS v(group_code) +), + +__ref__int_edge_ledger_paid_quantities AS ( + SELECT + v.order_ref::VARCHAR AS order_ref + FROM VALUES + ('ledger_paid_-1') AS v(order_ref) +), + +__ref__int_edge_variant_element_counts AS ( + SELECT + v.group_code::VARCHAR AS group_code + FROM VALUES + ('variant_elem-1') AS v(group_code) +), + +__ref__int_edge_basket_line_lookups AS ( + SELECT + v.line_id::VARCHAR AS line_id + FROM VALUES + ('basket_line_-1') AS v(line_id) +), + +__ref__int_edge_basket_running_peaks AS ( + SELECT + v.basket_id::VARCHAR AS basket_id + FROM VALUES + ('basket_runni-1') AS v(basket_id) +), + +__ref__stg_edge_supplier_notes AS ( + SELECT + v.note_id::VARCHAR AS note_id + FROM VALUES + ('supplier_not-1') AS v(note_id) +), + +__ref__int_edge_clock_text_reads AS ( + SELECT + v.text_id::VARCHAR AS text_id + FROM VALUES + ('clock_text_r-1') AS v(text_id) +), + +__ref__int_edge_amount_bit_reads AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('amount_bit_r-1') AS v(check_id) +), + +__ref__int_edge_note_patterns AS ( + SELECT + v.note_id::VARCHAR AS note_id + FROM VALUES + ('note_pattern-1') AS v(note_id) +), + +__ref__int_edge_ticket_tokens AS ( + SELECT + v.line_id::VARCHAR AS line_id + FROM VALUES + ('ticket_token-1') AS v(line_id) +), + +__ref__int_edge_basket_xml_reads AS ( + SELECT + v.line_id::VARCHAR AS line_id + FROM VALUES + ('basket_xml_r-1') AS v(line_id) +), + +__ref__int_edge_join_keys AS ( + SELECT + v.row_key::VARCHAR AS row_key + FROM VALUES + ('join_keys-1') AS v(row_key) +), + +__ref__int_edge_json_numbers AS ( + SELECT + v.check_id::VARCHAR AS check_id + FROM VALUES + ('json_numbers-1') AS v(check_id) +), + +__ref__int_edge_quantity_checks AS ( + SELECT + v.entry_id::VARCHAR AS entry_id + FROM VALUES + ('quantity_che-1') AS v(entry_id) +), + +__expected__rpt_edge_case_model_keys AS ( + SELECT + 'int_edge_amount_bit_reads~amount_bit_r-1' AS model_key_id, + 'int_edge_amount_bit_reads' AS model_name, + 'amount_bit_r-1' AS model_key + UNION ALL + SELECT + 'int_edge_amount_percent_texts~amount_perce-1' AS model_key_id, + 'int_edge_amount_percent_texts' AS model_name, + 'amount_perce-1' AS model_key + UNION ALL + SELECT + 'int_edge_basket_distinct_tags~basket_disti-1' AS model_key_id, + 'int_edge_basket_distinct_tags' AS model_name, + 'basket_disti-1' AS model_key + UNION ALL + SELECT + 'int_edge_basket_line_lookups~basket_line_-1' AS model_key_id, + 'int_edge_basket_line_lookups' AS model_name, + 'basket_line_-1' AS model_key + UNION ALL + SELECT + 'int_edge_basket_running_peaks~basket_runni-1' AS model_key_id, + 'int_edge_basket_running_peaks' AS model_name, + 'basket_runni-1' AS model_key + UNION ALL + SELECT + 'int_edge_basket_sku_part_filters~basket_sku_p-1' AS model_key_id, + 'int_edge_basket_sku_part_filters' AS model_name, + 'basket_sku_p-1' AS model_key + UNION ALL + SELECT + 'int_edge_basket_tag_list_reads~basket_tag_l-1' AS model_key_id, + 'int_edge_basket_tag_list_reads' AS model_name, + 'basket_tag_l-1' AS model_key + UNION ALL + SELECT + 'int_edge_basket_xml_reads~basket_xml_r-1' AS model_key_id, + 'int_edge_basket_xml_reads' AS model_name, + 'basket_xml_r-1' AS model_key + UNION ALL + SELECT + 'int_edge_callback_clock_times~callback_clo-1' AS model_key_id, + 'int_edge_callback_clock_times' AS model_name, + 'callback_clo-1' AS model_key + UNION ALL + SELECT + 'int_edge_callback_date_lists~callback_dat-1' AS model_key_id, + 'int_edge_callback_date_lists' AS model_name, + 'callback_dat-1' AS model_key + UNION ALL + SELECT + 'int_edge_callback_day_documents~callback_day-1' AS model_key_id, + 'int_edge_callback_day_documents' AS model_name, + 'callback_day-1' AS model_key + UNION ALL + SELECT + 'int_edge_callback_day_starts~callback_day-1' AS model_key_id, + 'int_edge_callback_day_starts' AS model_name, + 'callback_day-1' AS model_key + UNION ALL + SELECT + 'int_edge_callback_epoch_parts~callback_epo-1' AS model_key_id, + 'int_edge_callback_epoch_parts' AS model_name, + 'callback_epo-1' AS model_key + UNION ALL + SELECT + 'int_edge_callback_epoch_reads~callback_epo-1' AS model_key_id, + 'int_edge_callback_epoch_reads' AS model_name, + 'callback_epo-1' AS model_key + UNION ALL + SELECT + 'int_edge_callback_last_day~callback_las-1' AS model_key_id, + 'int_edge_callback_last_day' AS model_name, + 'callback_las-1' AS model_key + UNION ALL + SELECT + 'int_edge_callback_latest_dates~callback_lat-1' AS model_key_id, + 'int_edge_callback_latest_dates' AS model_name, + 'callback_lat-1' AS model_key + UNION ALL + SELECT + 'int_edge_callback_london_times~callback_lon-1' AS model_key_id, + 'int_edge_callback_london_times' AS model_name, + 'callback_lon-1' AS model_key + UNION ALL + SELECT + 'int_edge_callback_recent_offsets~callback_rec-1' AS model_key_id, + 'int_edge_callback_recent_offsets' AS model_name, + 'callback_rec-1' AS model_key + UNION ALL + SELECT + 'int_edge_callback_row_numbers~callback_row-1' AS model_key_id, + 'int_edge_callback_row_numbers' AS model_name, + 'callback_row-1' AS model_key + UNION ALL + SELECT + 'int_edge_callback_safe_dates~callback_saf-1' AS model_key_id, + 'int_edge_callback_safe_dates' AS model_name, + 'callback_saf-1' AS model_key + UNION ALL + SELECT + 'int_edge_callback_start_fallbacks~callback_sta-1' AS model_key_id, + 'int_edge_callback_start_fallbacks' AS model_name, + 'callback_sta-1' AS model_key + UNION ALL + SELECT + 'int_edge_callback_text_dates~callback_tex-1' AS model_key_id, + 'int_edge_callback_text_dates' AS model_name, + 'callback_tex-1' AS model_key + UNION ALL + SELECT + 'int_edge_callback_zone_words~callback_zon-1' AS model_key_id, + 'int_edge_callback_zone_words' AS model_name, + 'callback_zon-1' AS model_key + UNION ALL + SELECT + 'int_edge_callback_zoned_dates~callback_zon-1' AS model_key_id, + 'int_edge_callback_zoned_dates' AS model_name, + 'callback_zon-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_amount_spreads~check_amount-1' AS model_key_id, + 'int_edge_check_amount_spreads' AS model_name, + 'check_amount-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_any_amounts~check_any_am-1' AS model_key_id, + 'int_edge_check_any_amounts' AS model_name, + 'check_any_am-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_bracket_strips~check_bracke-1' AS model_key_id, + 'int_edge_check_bracket_strips' AS model_name, + 'check_bracke-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_complete_pairs~check_comple-1' AS model_key_id, + 'int_edge_check_complete_pairs' AS model_name, + 'check_comple-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_decoded_keys~check_decode-1' AS model_key_id, + 'int_edge_check_decoded_keys' AS model_name, + 'check_decode-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_distinct_tuples~check_distin-1' AS model_key_id, + 'int_edge_check_distinct_tuples' AS model_name, + 'check_distin-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_formatted_dates~check_format-1' AS model_key_id, + 'int_edge_check_formatted_dates' AS model_name, + 'check_format-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_generated_rows~check_genera-1' AS model_key_id, + 'int_edge_check_generated_rows' AS model_name, + 'check_genera-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_group_flags~check_group_-1' AS model_key_id, + 'int_edge_check_group_flags' AS model_name, + 'check_group_-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_group_key_lists~check_group_-1' AS model_key_id, + 'int_edge_check_group_key_lists' AS model_name, + 'check_group_-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_group_pivots~check_group_-1' AS model_key_id, + 'int_edge_check_group_pivots' AS model_name, + 'check_group_-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_key_list_edits~check_key_li-1' AS model_key_id, + 'int_edge_check_key_list_edits' AS model_name, + 'check_key_li-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_key_parts~check_key_pa-1' AS model_key_id, + 'int_edge_check_key_parts' AS model_name, + 'check_key_pa-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_key_rewrites~check_key_re-1' AS model_key_id, + 'int_edge_check_key_rewrites' AS model_name, + 'check_key_re-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_label_lookups~check_label_-1' AS model_key_id, + 'int_edge_check_label_lookups' AS model_name, + 'check_label_-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_last_known_keys~check_last_k-1' AS model_key_id, + 'int_edge_check_last_known_keys' AS model_name, + 'check_last_k-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_local_times~check_local_-1' AS model_key_id, + 'int_edge_check_local_times' AS model_name, + 'check_local_-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_minute_times~check_minute-1' AS model_key_id, + 'int_edge_check_minute_times' AS model_name, + 'check_minute-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_month_starts~check_month_-1' AS model_key_id, + 'int_edge_check_month_starts' AS model_name, + 'check_month_-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_note_unions~check_note_u-1' AS model_key_id, + 'int_edge_check_note_unions' AS model_name, + 'check_note_u-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_number_arrays~check_number-1' AS model_key_id, + 'int_edge_check_number_arrays' AS model_name, + 'check_number-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_number_labels~check_number-1' AS model_key_id, + 'int_edge_check_number_labels' AS model_name, + 'check_number-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_pair_filters~check_pair_f-1' AS model_key_id, + 'int_edge_check_pair_filters' AS model_name, + 'check_pair_f-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_pattern_matches~check_patter-1' AS model_key_id, + 'int_edge_check_pattern_matches' AS model_name, + 'check_patter-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_reduced_keys~check_reduce-1' AS model_key_id, + 'int_edge_check_reduced_keys' AS model_name, + 'check_reduce-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_sparse_arrays~check_sparse-1' AS model_key_id, + 'int_edge_check_sparse_arrays' AS model_name, + 'check_sparse-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_text_arrays~check_text_a-1' AS model_key_id, + 'int_edge_check_text_arrays' AS model_name, + 'check_text_a-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_unnamed_labels~check_unname-1' AS model_key_id, + 'int_edge_check_unnamed_labels' AS model_name, + 'check_unname-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_variant_branches~check_varian-1' AS model_key_id, + 'int_edge_check_variant_branches' AS model_name, + 'check_varian-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_wide_sums~check_wide_s-1' AS model_key_id, + 'int_edge_check_wide_sums' AS model_name, + 'check_wide_s-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_xml_checks~check_xml_ch-1' AS model_key_id, + 'int_edge_check_xml_checks' AS model_name, + 'check_xml_ch-1' AS model_key + UNION ALL + SELECT + 'int_edge_check_zoned_literals~check_zoned_-1' AS model_key_id, + 'int_edge_check_zoned_literals' AS model_name, + 'check_zoned_-1' AS model_key + UNION ALL + SELECT + 'int_edge_clock_text_reads~clock_text_r-1' AS model_key_id, + 'int_edge_clock_text_reads' AS model_name, + 'clock_text_r-1' AS model_key + UNION ALL + SELECT + 'int_edge_join_keys~join_keys-1' AS model_key_id, + 'int_edge_join_keys' AS model_name, + 'join_keys-1' AS model_key + UNION ALL + SELECT + 'int_edge_json_numbers~json_numbers-1' AS model_key_id, + 'int_edge_json_numbers' AS model_name, + 'json_numbers-1' AS model_key + UNION ALL + SELECT + 'int_edge_key_number_reads~key_number_r-1' AS model_key_id, + 'int_edge_key_number_reads' AS model_name, + 'key_number_r-1' AS model_key + UNION ALL + SELECT + 'int_edge_key_rank_offsets~key_rank_off-1' AS model_key_id, + 'int_edge_key_rank_offsets' AS model_name, + 'key_rank_off-1' AS model_key + UNION ALL + SELECT + 'int_edge_ledger_paid_quantities~ledger_paid_-1' AS model_key_id, + 'int_edge_ledger_paid_quantities' AS model_name, + 'ledger_paid_-1' AS model_key + UNION ALL + SELECT + 'int_edge_ledger_quantity_steps~ledger_quant-1' AS model_key_id, + 'int_edge_ledger_quantity_steps' AS model_name, + 'ledger_quant-1' AS model_key + UNION ALL + SELECT + 'int_edge_note_patterns~note_pattern-1' AS model_key_id, + 'int_edge_note_patterns' AS model_name, + 'note_pattern-1' AS model_key + UNION ALL + SELECT + 'int_edge_quantity_checks~quantity_che-1' AS model_key_id, + 'int_edge_quantity_checks' AS model_name, + 'quantity_che-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_array_bounds~ratio_array_-1' AS model_key_id, + 'int_edge_ratio_array_bounds' AS model_name, + 'ratio_array_-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_array_casts~ratio_array_-1' AS model_key_id, + 'int_edge_ratio_array_casts' AS model_name, + 'ratio_array_-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_array_positions~ratio_array_-1' AS model_key_id, + 'int_edge_ratio_array_positions' AS model_name, + 'ratio_array_-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_averages~ratio_averag-1' AS model_key_id, + 'int_edge_ratio_averages' AS model_name, + 'ratio_averag-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_fixed_scales~ratio_fixed_-1' AS model_key_id, + 'int_edge_ratio_fixed_scales' AS model_name, + 'ratio_fixed_-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_group_objects~ratio_group_-1' AS model_key_id, + 'int_edge_ratio_group_objects' AS model_name, + 'ratio_group_-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_hashes~ratio_hashes-1' AS model_key_id, + 'int_edge_ratio_hashes' AS model_name, + 'ratio_hashes-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_identity_objects~ratio_identi-1' AS model_key_id, + 'int_edge_ratio_identity_objects' AS model_name, + 'ratio_identi-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_ignore_case_reads~ratio_ignore-1' AS model_key_id, + 'int_edge_ratio_ignore_case_reads' AS model_name, + 'ratio_ignore-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_object_differences~ratio_object-1' AS model_key_id, + 'int_edge_ratio_object_differences' AS model_name, + 'ratio_object-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_object_flags~ratio_object-1' AS model_key_id, + 'int_edge_ratio_object_flags' AS model_name, + 'ratio_object-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_object_inserts~ratio_object-1' AS model_key_id, + 'int_edge_ratio_object_inserts' AS model_name, + 'ratio_object-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_object_reads~ratio_object-1' AS model_key_id, + 'int_edge_ratio_object_reads' AS model_name, + 'ratio_object-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_path_checks~ratio_path_c-1' AS model_key_id, + 'int_edge_ratio_path_checks' AS model_name, + 'ratio_path_c-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_percent_texts~ratio_percen-1' AS model_key_id, + 'int_edge_ratio_percent_texts' AS model_name, + 'ratio_percen-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_running_totals~ratio_runnin-1' AS model_key_id, + 'int_edge_ratio_running_totals' AS model_name, + 'ratio_runnin-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_safe_casts~ratio_safe_c-1' AS model_key_id, + 'int_edge_ratio_safe_casts' AS model_name, + 'ratio_safe_c-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_text_forms~ratio_text_f-1' AS model_key_id, + 'int_edge_ratio_text_forms' AS model_name, + 'ratio_text_f-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_text_replaces~ratio_text_r-1' AS model_key_id, + 'int_edge_ratio_text_replaces' AS model_name, + 'ratio_text_r-1' AS model_key + UNION ALL + SELECT + 'int_edge_ratio_variant_unions~ratio_varian-1' AS model_key_id, + 'int_edge_ratio_variant_unions' AS model_name, + 'ratio_varian-1' AS model_key + UNION ALL + SELECT + 'int_edge_ticket_tokens~ticket_token-1' AS model_key_id, + 'int_edge_ticket_tokens' AS model_name, + 'ticket_token-1' AS model_key + UNION ALL + SELECT + 'int_edge_variant_decimal_reads~variant_deci-1' AS model_key_id, + 'int_edge_variant_decimal_reads' AS model_name, + 'variant_deci-1' AS model_key + UNION ALL + SELECT + 'int_edge_variant_element_counts~variant_elem-1' AS model_key_id, + 'int_edge_variant_element_counts' AS model_name, + 'variant_elem-1' AS model_key + UNION ALL + SELECT + 'int_edge_variant_expected_values~variant_expe-1' AS model_key_id, + 'int_edge_variant_expected_values' AS model_name, + 'variant_expe-1' AS model_key + UNION ALL + SELECT + 'int_edge_variant_xml_elements~variant_xml_-1' AS model_key_id, + 'int_edge_variant_xml_elements' AS model_name, + 'variant_xml_-1' AS model_key + UNION ALL + SELECT + 'stg_edge_supplier_notes~supplier_not-1' AS model_key_id, + 'stg_edge_supplier_notes' AS model_name, + 'supplier_not-1' AS model_key +) diff --git a/benchmarks/duckshop/project/tests/unit/staging/edge_cases/test_stg_edge_supplier_notes.sql b/benchmarks/duckshop/project/tests/unit/staging/edge_cases/test_stg_edge_supplier_notes.sql new file mode 100644 index 0000000000..a7e6dac465 --- /dev/null +++ b/benchmarks/duckshop/project/tests/unit/staging/edge_cases/test_stg_edge_supplier_notes.sql @@ -0,0 +1,23 @@ +TEST (name "stg_edge_supplier_notes__upper_cases_supplier_notes"); + +WITH __source__edge__supplier_notes AS ( + SELECT + v.note_id::VARCHAR AS note_id, + v.supplier_code::VARCHAR AS supplier_code, + v.note_text::VARCHAR AS note_text + FROM VALUES + ('SN-1', 'SUP-PINTAIL', 'Restock teal decoys'), + ('SN-2', NULL, NULL) AS v(note_id, supplier_code, note_text) +), + +__expected__stg_edge_supplier_notes AS ( + SELECT + 'SN-1' AS note_id, + 'SUP-PINTAIL' AS supplier_code, + 'RESTOCK TEAL DECOYS' AS note_upper + UNION ALL + SELECT + 'SN-2' AS note_id, + CAST(NULL AS VARCHAR) AS supplier_code, + CAST(NULL AS VARCHAR) AS note_upper +) diff --git a/benchmarks/duckshop/scripts/relations.py b/benchmarks/duckshop/scripts/relations.py index 0892daf361..4eb00fa945 100644 --- a/benchmarks/duckshop/scripts/relations.py +++ b/benchmarks/duckshop/scripts/relations.py @@ -11,8 +11,9 @@ `check` lists tables, views and functions that already exist under a DuckShop name, and any SQLBuild state tables (`_sqlbuild_*`) already in the schema. `drop` is one Snowflake Scripting block that drops every model, snapshot, seed and source table and every function the project -creates. SQLBuild's own state tables (`_sqlbuild_*`) are left alone, since other projects in the -same schema may share them. +creates, including functions a SQL hook creates, which the compile output does not list. +SQLBuild's own state tables (`_sqlbuild_*`) are left alone, since other projects in the same schema +may share them. """ from __future__ import annotations @@ -48,6 +49,24 @@ def managed_sources() -> list[str]: return names +HOOK_FUNCTION = re.compile( + r"CREATE\s+OR\s+REPLACE\s+FUNCTION\s+\S*?\.(\w+)\s*\(([^)]*)\)", flags=re.IGNORECASE +) + + +def hook_functions() -> list[str]: + """`name(type, ...)` of each function a SQL hook creates; SQLBuild does not declare them.""" + + found: list[str] = [] + for path in sorted(PROJECT_DIR.glob("models/**/_hooks/sql/*.sql")): + for name, arguments in HOOK_FUNCTION.findall(path.read_text()): + types = [ + part.strip().split(None, 1)[1] for part in arguments.split(",") if part.strip() + ] + found.append(f"{name}({', '.join(types)})") + return found + + def objects(compile_json: dict[str, object]) -> tuple[str, list[tuple[str, str]]]: """The schema-qualified prefix and each (object kind, name or signature) the project creates.""" @@ -69,6 +88,8 @@ def objects(compile_json: dict[str, object]) -> tuple[str, list[tuple[str, str]] for function in functions: # type: ignore[union-attr] arguments = ", ".join(_function_arguments(function["relative_path"])) found.append(("FUNCTION", f"{function['name']}({arguments})")) + for signature in hook_functions(): + found.append(("FUNCTION", signature)) return f"{database}.{schema}", found diff --git a/benchmarks/duckshop/tests/test_synthetic_data.py b/benchmarks/duckshop/tests/test_synthetic_data.py index 1dd7bf07b7..b376ec2544 100644 --- a/benchmarks/duckshop/tests/test_synthetic_data.py +++ b/benchmarks/duckshop/tests/test_synthetic_data.py @@ -482,6 +482,7 @@ def test_given_any_data_scale_when_building_edge_rows_then_they_are_fixed(scale: "edge__amount_checks": _edge_cases.amount_checks(), "edge__variant_values": _edge_cases.variant_values(), "edge__category_links": _edge_cases.category_links(), + "edge__supplier_notes": _edge_cases.supplier_notes(), } assert {name: _digest(rows) for name, rows in rebuilt.items()} == { diff --git a/tests/e2e/src/sqlbuild/cli/commands/main/compile/_test_types.py b/tests/e2e/src/sqlbuild/cli/commands/main/compile/_test_types.py index 291727b67a..3aef15546a 100644 --- a/tests/e2e/src/sqlbuild/cli/commands/main/compile/_test_types.py +++ b/tests/e2e/src/sqlbuild/cli/commands/main/compile/_test_types.py @@ -1255,6 +1255,16 @@ class BenchmarkProjectCompileTestCase: expected_warnings: int +@dataclass(frozen=True) +class BenchmarkProjectTestPlanTestCase: + """A benchmark project whose unit tests must plan without a warehouse connection.""" + + description: str + project_dir: Path + expected_final_line_prefix: str + expected_final_line_suffix: str + + @dataclass(frozen=True) class BenchmarkCoreCopyCompileTestCase: """A script that copies a benchmark project without an area, and the copy's compiled output. diff --git a/tests/e2e/src/sqlbuild/cli/commands/main/compile/test_duckshop_benchmark_compile.py b/tests/e2e/src/sqlbuild/cli/commands/main/compile/test_duckshop_benchmark_compile.py index 1a545b3743..ed6b2309d4 100644 --- a/tests/e2e/src/sqlbuild/cli/commands/main/compile/test_duckshop_benchmark_compile.py +++ b/tests/e2e/src/sqlbuild/cli/commands/main/compile/test_duckshop_benchmark_compile.py @@ -14,6 +14,7 @@ from tests.e2e.src.sqlbuild.cli.commands.main.compile._test_types import ( BenchmarkCoreCopyCompileTestCase, BenchmarkProjectCompileTestCase, + BenchmarkProjectTestPlanTestCase, ) from tests.e2e.src.sqlbuild.cli.commands.shared.helpers import REPO_ROOT, run_sqb @@ -63,6 +64,40 @@ def test_given_benchmark_project_when_compiling_then_reports_no_errors_or_warnin assert summary["tests"] > 0 +@pytest.mark.parametrize( + "test_case", + [ + BenchmarkProjectTestPlanTestCase( + description="duckshop", + project_dir=REPO_ROOT / "benchmarks" / "duckshop" / "project", + expected_final_line_prefix="Test plan inspection complete: ", + expected_final_line_suffix=" selected, 0 errors.", + ) + ], + ids=lambda case: case.description, +) +def test_given_benchmark_project_when_inspecting_test_plan_then_every_unit_test_plans( + test_case: BenchmarkProjectTestPlanTestCase, tmp_path: Path +) -> None: + """Mock fixtures are checked against declared columns only when tests are planned.""" + project_dir: Path = tmp_path / test_case.description + shutil.copytree( + test_case.project_dir, + project_dir, + ignore=shutil.ignore_patterns(*_LOCAL_ONLY_PATHS), + ) + + result: subprocess.CompletedProcess[str] = run_sqb( + command=("--no-color", "test", "--inspect"), + project_dir=project_dir, + ) + + assert result.returncode == 0, result.stdout + result.stderr + final_line: str = result.stdout.strip().splitlines()[-1] + assert final_line.startswith(test_case.expected_final_line_prefix), result.stdout + assert final_line.endswith(test_case.expected_final_line_suffix), result.stdout + + @pytest.mark.parametrize( "test_case", [ @@ -73,7 +108,7 @@ def test_given_benchmark_project_when_compiling_then_reports_no_errors_or_warnin expected_errors=0, expected_warnings=0, expected_compiled_checksum=( - "1ff1d0955ea3839b3c969707fd47ca9a4d7d7216753759d23911836f6ea5879d" + "7661e2ad98b33b8230c9df9c6c780e959cb7e18398b14a2cef36e12d19bd0bb6" ), ) ],