Merge remote-tracking branch 'github/main' into feat/d272-obligations

Author: kvlonge

README.md

@@ -107,7 +107,7 @@ A `VALUES` list of more than 1,000 rows is refused for now.
 session parameters yet and convert under `utc-v1`.
 
 `convert`, `function`, `census` and `index` read `sqlquack.toml` (or `--policy`); without one they
-exit 2 unless `--builtin-policy` asks for the built-in default, which refuses every known divergence.
+use the built-in policy, which refuses every known divergence, as `--builtin-policy` asks for.
 They share the policy flags (`--policy`, `--builtin-policy`, `--strict`, `--utc-session`,
 `--confirm-declared-offsets`, `--python-runtime` and `--loud-divergences-only`, which relies only
 on divergences whose converted SQL raises rather than returns another value). Every command with a report takes

cases/relational/unaliased_round_current.toml

@@ -0,0 +1,92 @@
+# The names Snowflake gives unaliased ROUND and current-time items, as a playground query writes them.
+# The recorded column names are the receipts for naming them.
+category = "relational"
+construct = "node:alias"
+session_profile = "utc-v1"
+
+[[case]]
+id = "unaliased_round"
+description = "Unaliased ROUND with one and two arguments, in upper and lower case and with inner spaces, over a NULL, a half and a negative."
+columns = [{ name = "n", type = "NUMBER(10,2)" }]
+rows = [
+  ["1.25"],
+  ["1.25"],
+  ["-2.55"],
+  ["NULL"],
+]
+query = "SELECT ROUND(n, 1), ROUND(n), round( n, 0 ) FROM input"
+order = "ordered"
+tags = ["null", "boundary", "duplicates"]
+
+[[case]]
+id = "unaliased_round_no_rows"
+description = "Unaliased ROUND over no rows still names its columns."
+columns = [{ name = "n", type = "NUMBER(10,2)" }]
+rows = [
+  ["1.00"],
+]
+query = "SELECT ROUND(n, 1), ROUND(n) FROM input WHERE n > 5"
+order = "ordered"
+tags = ["empty-input"]
+
+[[case]]
+id = "unaliased_current_time"
+description = "Unaliased CURRENT_DATE(), CURRENT_DATE and CURRENT_TIMESTAMP(): only the column names and types are the receipt; the values read the clock, so it is typing evidence."
+evidence = "typing"
+columns = [{ name = "n", type = "NUMBER(10,2)" }]
+rows = [
+  ["1.00"],
+]
+query = "SELECT CURRENT_DATE(), CURRENT_DATE, CURRENT_TIMESTAMP() FROM input"
+order = "ordered"
+tags = ["boundary"]
+
+[[case]]
+id = "unaliased_distinct_aggregates"
+description = "Unaliased SUM, MAX and AVG over DISTINCT, over a duplicate and a NULL. The aggregates are one query and the row expressions another, since one select list cannot hold both without GROUP BY; each item is written as given."
+columns = [{ name = "n", type = "NUMBER(10,2)" }, { name = "g", type = "VARCHAR" }]
+rows = [
+  ["1.50", "'12'"],
+  ["1.50", "'12'"],
+  ["NULL", "NULL"],
+  ["-2.25", "'-3'"],
+]
+query = "SELECT SUM(DISTINCT n), MAX(DISTINCT n), AVG(DISTINCT n) FROM input"
+order = "ordered"
+tags = ["null", "duplicates"]
+
+[[case]]
+id = "unaliased_distinct_aggregates_no_rows"
+description = "The unaliased DISTINCT aggregates over no rows still name their columns."
+columns = [{ name = "n", type = "NUMBER(10,2)" }, { name = "g", type = "VARCHAR" }]
+rows = [
+  ["1.00", "'1'"],
+]
+query = "SELECT SUM(DISTINCT n), MAX(DISTINCT n), AVG(DISTINCT n) FROM input WHERE n > 5"
+order = "ordered"
+tags = ["empty-input"]
+
+[[case]]
+id = "unaliased_row_expressions"
+description = "Unaliased COALESCE with a column and with literals only, CAST of numeric text to INTEGER, and lower with a space before its closing parenthesis, over a duplicate and a NULL."
+columns = [{ name = "n", type = "NUMBER(10,2)" }, { name = "g", type = "VARCHAR" }]
+rows = [
+  ["1.50", "'12'"],
+  ["1.50", "'12'"],
+  ["NULL", "NULL"],
+  ["-2.25", "'-3'"],
+]
+query = "SELECT COALESCE(n, 0, 1), COALESCE(1, 2), CAST(g AS INTEGER), lower(g ) FROM input"
+order = "bag"
+tags = ["null", "duplicates"]
+
+[[case]]
+id = "unaliased_row_expressions_no_rows"
+description = "The unaliased row expressions over no rows still name their columns."
+columns = [{ name = "n", type = "NUMBER(10,2)" }, { name = "g", type = "VARCHAR" }]
+rows = [
+  ["1.00", "'1'"],
+]
+query = "SELECT COALESCE(n, 0, 1), COALESCE(1, 2), CAST(g AS INTEGER), lower(g ) FROM input WHERE n > 5"
+order = "bag"
+tags = ["empty-input"]

cases/translation/expressions/data-types-datetime.time.toml

@@ -0,0 +1,39 @@
+category = "translation"
+construct = "sf.expressions.data-types-datetime.time"
+session_profile = "utc-v1"
+
+[[case]]
+id = "t001_precision"
+description = "TIME keeps all nine fractional digits by default; TIME(3) keeps three and TIME(0) none, read here as the nanosecond part, since the connector carries TIME only to microseconds. Whether the cut rounds or truncates is not on the page, so the recording decides. Catches: the default read as 6 digits or 0, or the precision ignored"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["'13:45:10.123456789'"],
+  ["'00:00:01.9996'"],
+]
+query = "SELECT ordinal, DATE_PART(nanosecond, CAST(a AS TIME)) AS ns9, DATE_PART(nanosecond, CAST(a AS TIME(3))) AS ns3, DATE_PART(second, CAST(a AS TIME(0))) AS s0, DATE_PART(nanosecond, CAST(a AS TIME(0))) AS ns0 FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["type-combination"]
+
+[[case]]
+id = "t002_range_edges"
+description = "The page: TIME values lie between 00:00:00 and 23:59:59.999999999; both ends cast unchanged, read here as hour, second and nanosecond parts. Catches: the last nanosecond rounded to the next day, or cut to microseconds"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["'00:00:00'"],
+  ["'23:59:59.999999999'"],
+]
+query = "SELECT ordinal, DATE_PART(hour, CAST(a AS TIME)) AS h, DATE_PART(second, CAST(a AS TIME)) AS s, DATE_PART(nanosecond, CAST(a AS TIME)) AS ns FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["boundary"]
+
+[[case]]
+id = "t003_null"
+description = "NULL beside a set row, cast to the type; the page gives no special rule, so standard NULL handling applies. Catches: NULL replaced by a value, or the cast raising for NULL"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["NULL"],
+  ["'12:00:00'"],
+]
+query = "SELECT ordinal, CAST(a AS TIME) AS r FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["null"]

cases/translation/expressions/data-types-datetime.timestamp.toml

@@ -0,0 +1,38 @@
+category = "translation"
+construct = "sf.expressions.data-types-datetime.timestamp"
+session_profile = "utc-v1"
+
+[[case]]
+id = "t001_alias_ntz"
+description = "The page: TIMESTAMP is TIMESTAMP_NTZ by default, so the wall-clock time is kept and equals the NTZ cast. Catches: TIMESTAMP read as a zoned type, so an offset is applied or the session zone attached"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["'2024-03-10 02:30:00'"],
+  ["'1999-12-31 23:59:59.123456789'"],
+]
+query = "SELECT ordinal, CAST(a AS TIMESTAMP) AS r, CAST(a AS TIMESTAMP) = CAST(a AS TIMESTAMP_NTZ) AS same FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["type-combination"]
+
+[[case]]
+id = "t002_precision"
+description = "The page: the precision is 0 to 9 fractional digits, 9 by default; whether the cut rounds or truncates is not on the page, so the recording decides. Catches: the precision ignored, or the default read as 6"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["'2024-01-01 10:00:00.987654321'"],
+]
+query = "SELECT ordinal, CAST(a AS TIMESTAMP) AS t9, CAST(a AS TIMESTAMP(3)) AS t3, CAST(a AS TIMESTAMP(0)) AS t0 FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["type-combination"]
+
+[[case]]
+id = "t003_null"
+description = "NULL beside a set row, cast to the type; the page gives no special rule, so standard NULL handling applies. Catches: NULL replaced by a value, or the cast raising for NULL"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["NULL"],
+  ["'2024-01-01 00:00:00'"],
+]
+query = "SELECT ordinal, CAST(a AS TIMESTAMP) AS r FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["null"]

cases/translation/expressions/data-types-logical.toml

@@ -0,0 +1,125 @@
+category = "translation"
+construct = "sf.expressions.data-types-logical"
+session_profile = "utc-v1"
+
+[[case]]
+id = "t001_from_text"
+description = "The page's twelve strings, in mixed case: the first six convert to TRUE and the last six to FALSE. Catches: only 'true' and 'false' accepted, or the match made case-sensitive"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["'true'"],
+  ["'T'"],
+  ["'Yes'"],
+  ["'y'"],
+  ["'ON'"],
+  ["'1'"],
+  ["'FALSE'"],
+  ["'f'"],
+  ["'no'"],
+  ["'N'"],
+  ["'Off'"],
+  ["'0'"],
+]
+query = "SELECT ordinal, CAST(a AS BOOLEAN) AS r FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["type-combination"]
+
+[[case]]
+id = "t002_from_number"
+description = "The page: zero converts to FALSE and any non-zero value, negative or fractional, to TRUE. Catches: only 1 read as TRUE, or a fraction truncated to 0 first"
+columns = [{ name = "n", type = "NUMBER(10,2)" }]
+rows = [
+  ["0"],
+  ["-2.5"],
+  ["-0.25"],
+  ["1"],
+]
+query = "SELECT ordinal, CAST(n AS BOOLEAN) AS b FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["type-combination"]
+
+[[case]]
+id = "t003_to_text_and_number"
+description = "The page: TRUE casts to 'true' and 1, FALSE to 'false' and 0. Catches: upper-case 'TRUE', or 't', or -1 for TRUE"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["'yes'"],
+  ["'no'"],
+]
+query = "SELECT ordinal, CAST(CAST(a AS BOOLEAN) AS VARCHAR) AS s, CAST(CAST(a AS BOOLEAN) AS NUMBER) AS n FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["type-combination"]
+
+[[case]]
+id = "t004_other_text"
+description = "The page: other text strings can't be converted to BOOLEAN, so the cast raises. Catches: the string read as FALSE or NULL"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["'maybe'"],
+]
+query = "SELECT ordinal, CAST(a AS BOOLEAN) AS r FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["error"]
+
+[[case]]
+id = "t005_implicit_from_text"
+description = "The page: implicitly, only 'true' and 'false' convert, case-insensitively, so a VARCHAR column in AND converts without a cast. Catches: the implicit conversion refused, or done case-sensitively"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["'true'"],
+  ["'FALSE'"],
+  ["'True'"],
+]
+query = "SELECT ordinal, a AND TRUE AS r, NOT a AS n FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["type-combination"]
+
+[[case]]
+id = "t006_implicit_from_number"
+description = "The page: implicitly, zero converts to FALSE and any other number to TRUE. Catches: the implicit conversion refused, or only 1 read as TRUE"
+columns = [{ name = "n", type = "NUMBER(38,0)" }]
+rows = [
+  ["0"],
+  ["1"],
+  ["-3"],
+]
+query = "SELECT ordinal, n AND TRUE AS r, NOT n AS x FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["type-combination"]
+
+[[case]]
+id = "t007_implicit_to_text"
+description = "The page: a BOOLEAN column or literal concatenated with || converts to 'true' or 'false'. Catches: upper-case TRUE, 't' or 1 in the text"
+columns = [{ name = "b", type = "BOOLEAN" }]
+rows = [
+  ["TRUE"],
+  ["FALSE"],
+]
+query = "SELECT ordinal, 'is ' || b AS col, 'lit ' || TRUE AS lit FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["type-combination"]
+
+[[case]]
+id = "t009_null"
+description = "NULL is the unknown BOOLEAN value, kept through the cast. Catches: NULL replaced by a value, or the cast raising for NULL"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["NULL"],
+  ["'on'"],
+]
+query = "SELECT ordinal, CAST(a AS BOOLEAN) AS r FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["null"]
+
+[[case]]
+id = "t010_from_float"
+compile_error = true
+description = "The page's numeric conversion does not exclude FLOAT, but Snowflake refuses a FLOAT argument at compile time (recorded as 1007/22023, invalid type for parameter 'TO_BOOLEAN'); this case keeps that behaviour. Catches: the FLOAT converted as a number"
+columns = [{ name = "f", type = "FLOAT" }]
+rows = [
+  ["0"],
+  ["0.001"],
+]
+query = "SELECT ordinal, CAST(f AS BOOLEAN) AS b FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["error"]

cases/translation/expressions/data-types-numeric.double.toml

@@ -0,0 +1,41 @@
+category = "translation"
+construct = "sf.expressions.data-types-numeric.double"
+session_profile = "utc-v1"
+
+[[case]]
+id = "t001_synonyms"
+description = "The page: all three are FLOAT, so each equals the FLOAT cast of the same text, with full double precision. Catches: REAL read as a 32-bit float (0.1 losing digits), or a decimal type"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["'0.1'"],
+  ["'1e300'"],
+  ["'-2.5'"],
+]
+query = "SELECT ordinal, CAST(a AS DOUBLE) AS d, CAST(a AS DOUBLE PRECISION) = CAST(a AS FLOAT) AS dp_same, CAST(a AS REAL) = CAST(a AS FLOAT) AS real_same FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["type-combination"]
+
+[[case]]
+id = "t002_special_values"
+description = "The page: the quoted special values are case-insensitive; 'NaN' equals 'NaN' and is greater than infinity. Catches: NaN unequal to itself (IEEE), NaN smaller than infinity, or the mixed-case spellings rejected"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["'NaN'"],
+  ["'INF'"],
+  ["'-inf'"],
+]
+query = "SELECT ordinal, CAST(a AS DOUBLE) AS d, CAST(a AS DOUBLE) = CAST('nan' AS DOUBLE) AS eq_nan, CAST('NaN' AS DOUBLE) > CAST(a AS DOUBLE) AS nan_greater FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["type-combination"]
+
+[[case]]
+id = "t003_null"
+description = "NULL beside a set row, cast to the type; the page gives no special rule, so standard NULL handling applies. Catches: NULL replaced by a value, or the cast raising for NULL"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["NULL"],
+  ["'1.5'"],
+]
+query = "SELECT ordinal, CAST(a AS REAL) AS r FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["null"]

cases/translation/expressions/data-types-numeric.int.toml

@@ -0,0 +1,50 @@
+category = "translation"
+construct = "sf.expressions.data-types-numeric.int"
+session_profile = "utc-v1"
+
+[[case]]
+id = "t001_synonyms_wide"
+description = "A 21-digit integer cast to each spelling keeps every digit, since all are NUMBER(38, 0). Catches: BIGINT read as 64-bit, or SMALLINT, TINYINT or BYTEINT as 16 or 8 bits (overflow or wrap-around)"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["'123456789012345678901'"],
+  ["'-300'"],
+]
+query = "SELECT ordinal, CAST(a AS INT) AS i, CAST(a AS INTEGER) AS ig, CAST(a AS BIGINT) AS bi, CAST(a AS SMALLINT) AS si, CAST(a AS TINYINT) AS ti, CAST(a AS BYTEINT) AS byi FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["type-combination"]
+
+[[case]]
+id = "t002_thirty_eight_digits"
+description = "The page: the range of every integer type is -(10^38 - 1) to 10^38 - 1, so both ends cast unchanged. Catches: the value rejected or rounded through a float"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["'99999999999999999999999999999999999999'"],
+  ["'-99999999999999999999999999999999999999'"],
+]
+query = "SELECT ordinal, CAST(a AS INT) AS r FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["boundary"]
+
+[[case]]
+id = "t003_past_38_digits"
+description = "The page: the integer types hold at most 38 digits, so 10^38 is out of range and the cast raises. Catches: the value kept or rounded"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["'100000000000000000000000000000000000000'"],
+]
+query = "SELECT ordinal, CAST(a AS INT) AS r FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["error"]
+
+[[case]]
+id = "t004_null"
+description = "NULL beside a set row, cast to the type; the page gives no special rule, so standard NULL handling applies. Catches: NULL replaced by a value, or the cast raising for NULL"
+columns = [{ name = "a", type = "VARCHAR" }]
+rows = [
+  ["NULL"],
+  ["'7'"],
+]
+query = "SELECT ordinal, CAST(a AS SMALLINT) AS r FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["null"]