Merge remote-tracking branch 'origin/main' into fix/layout-fallback

Author: kvlonge

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"]

cases/translation/expressions/data-types-semistructured.array-index-access.toml

@@ -0,0 +1,39 @@
+category = "translation"
+construct = "sf.expressions.data-types-semistructured.array-index-access"
+session_profile = "utc-v1"
+
+[[case]]
+id = "t001_zero_based"
+description = "The page: indexes are 0-based, and arrays nest, so a[0][0] is the first element of the first element. Catches: a 1-based index, or the nested access refused"
+columns = [{ name = "j", type = "VARCHAR" }]
+rows = [
+  ["'[[10, 11], \"b\", \"c\"]'"],
+  ["'[[0], 1, 2]'"],
+]
+query = "SELECT ordinal, PARSE_JSON(j)[0] AS e0, PARSE_JSON(j)[2] AS e2, PARSE_JSON(j)[0][0] AS e00 FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["type-combination"]
+
+[[case]]
+id = "t002_past_end"
+description = "The page: accessing an element beyond the end of an array returns NULL. Catches: an error, or the last element returned"
+columns = [{ name = "j", type = "VARCHAR" }]
+rows = [
+  ["'[1, 2, 3]'"],
+  ["'[]'"],
+]
+query = "SELECT ordinal, PARSE_JSON(j)[3] AS r FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["boundary"]
+
+[[case]]
+id = "t003_null"
+description = "A NULL array beside a set one; indexing NULL gives NULL. Catches: a value read from NULL, or an error"
+columns = [{ name = "j", type = "VARCHAR" }]
+rows = [
+  ["NULL"],
+  ["'[5]'"],
+]
+query = "SELECT ordinal, PARSE_JSON(j)[0] AS r FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["null"]

cases/translation/expressions/data-types-semistructured.array.toml

@@ -0,0 +1,27 @@
+category = "translation"
+construct = "sf.expressions.data-types-semistructured.array"
+session_profile = "utc-v1"
+
+[[case]]
+id = "t001_from_variant"
+description = "A JSON array cast to ARRAY keeps its elements, nested and mixed-type ones included. Catches: the array flattened, or its elements turned to text"
+columns = [{ name = "j", type = "VARCHAR" }]
+rows = [
+  ["'[1, \"a\", [2, 3], null]'"],
+  ["'[]'"],
+]
+query = "SELECT ordinal, CAST(PARSE_JSON(j) AS ARRAY) AS r, ARRAY_SIZE(CAST(PARSE_JSON(j) AS ARRAY)) AS n FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["type-combination"]
+
+[[case]]
+id = "t002_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 = "j", type = "VARCHAR" }]
+rows = [
+  ["NULL"],
+  ["'[1]'"],
+]
+query = "SELECT ordinal, CAST(PARSE_JSON(j) AS ARRAY) AS r FROM input ORDER BY ordinal"
+order = "ordered"
+tags = ["null"]