@lark-base-open/base-database-cli 1.3.8 → 1.3.9

package/skills/lark-base-database/references/base-sql-errors.generated.md

@@ -5,15 +5,92 @@ Use names and types from catalog.json. Refresh the Catalog when the schema chang
 
 ## Verified SQL forms
 
+### FIRST_VALUE over a full partition
+
+<a id="shared-wording-1"></a>
+Rank by the intended order using ROW_NUMBER() in a subquery; then MAX(CASE WHEN rn=1 THEN value END) OVER (PARTITION BY k).
+
+<a id="shared-wording-2"></a>
+Preconditions: Full-partition semantics only; INT, DOUBLE or TEXT values supported by MAX; arrays and other types are excluded. Use a unique total ordering key and preserve explicit NULL ordering; N is a query-constant positive integer (literal or parameter). Reverse both directions and NULL ordering for LAST_VALUE.
+
+<a id="shared-wording-3"></a>
+Validation kind: `equivalent`. Error code: `SQL_FUNCTION_NOT_FOUND`.
+
+<a id="shared-wording-4"></a>
+The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+
+```sql
+WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders), ranked AS (SELECT id, group_key, value, ROW_NUMBER() OVER (PARTITION BY group_key ORDER BY sort_key ASC NULLS LAST, id ASC) AS rn FROM source) SELECT id, MAX(CASE WHEN rn = 1 THEN value END) OVER (PARTITION BY group_key) AS value FROM ranked ORDER BY id;
+```
+
+### LAST_VALUE over a full partition
+
+Reverse the order directions and NULL ordering for ROW_NUMBER(); then MAX(CASE WHEN rn=1 THEN value END) OVER (PARTITION BY k).
+
+Preconditions for LAST_VALUE over a full partition: [shared wording](#shared-wording-2).
+
+Validation kind for LAST_VALUE over a full partition: [shared wording](#shared-wording-3).
+
+Example names for LAST_VALUE over a full partition: [shared wording](#shared-wording-4).
+
+```sql
+WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders), ranked AS (SELECT id, group_key, value, ROW_NUMBER() OVER (PARTITION BY group_key ORDER BY sort_key DESC NULLS FIRST, id DESC) AS rn FROM source) SELECT id, MAX(CASE WHEN rn = 1 THEN value END) OVER (PARTITION BY group_key) AS value FROM ranked ORDER BY id;
+```
+
+### NTH_VALUE over a full partition
+
+<a id="shared-wording-5"></a>
+Rank by the intended order using ROW_NUMBER() in a subquery; then MAX(CASE WHEN rn=N THEN value END) OVER (PARTITION BY k), with fixed positive N.
+
+Preconditions for NTH_VALUE over a full partition: [shared wording](#shared-wording-2).
+
+Validation kind for NTH_VALUE over a full partition: [shared wording](#shared-wording-3).
+
+Example names for NTH_VALUE over a full partition: [shared wording](#shared-wording-4).
+
+```sql
+WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders), ranked AS (SELECT id, group_key, value, ROW_NUMBER() OVER (PARTITION BY group_key ORDER BY sort_key ASC NULLS LAST, id ASC) AS rn FROM source) SELECT id, MAX(CASE WHEN rn = 2 THEN value END) OVER (PARTITION BY group_key) AS value FROM ranked ORDER BY id;
+```
+
+### NTH_VALUE with a short partition
+
+Guidance for NTH_VALUE with a short partition: [shared wording](#shared-wording-5).
+
+Preconditions for NTH_VALUE with a short partition: [shared wording](#shared-wording-2).
+
+Validation kind for NTH_VALUE with a short partition: [shared wording](#shared-wording-3).
+
+Example names for NTH_VALUE with a short partition: [shared wording](#shared-wording-4).
+
+```sql
+WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders), ranked AS (SELECT id, group_key, value, ROW_NUMBER() OVER (PARTITION BY group_key ORDER BY sort_key ASC NULLS LAST, id ASC) AS rn FROM source) SELECT id, MAX(CASE WHEN rn = 100 THEN value END) OVER (PARTITION BY group_key) AS value FROM ranked ORDER BY id;
+```
+
+### FIRST_VALUE with empty input
+
+Guidance for FIRST_VALUE with empty input: [shared wording](#shared-wording-1).
+
+Preconditions for FIRST_VALUE with empty input: [shared wording](#shared-wording-2).
+
+Validation kind for FIRST_VALUE with empty input: [shared wording](#shared-wording-3).
+
+Example names for FIRST_VALUE with empty input: [shared wording](#shared-wording-4).
+
+```sql
+WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders WHERE FALSE), ranked AS (SELECT id, group_key, value, ROW_NUMBER() OVER (PARTITION BY group_key ORDER BY sort_key ASC NULLS LAST, id ASC) AS rn FROM source) SELECT id, MAX(CASE WHEN rn = 1 THEN value END) OVER (PARTITION BY group_key) AS value FROM ranked ORDER BY id;
+```
+
 ### Division with a zero divisor
 
+<a id="shared-wording-6"></a>
 Use NULLIF(divisor, 0) as the divisor if a NULL result is acceptable.
 
 Preconditions: The caller accepts NULL instead of a division-by-zero error.
 
+<a id="shared-wording-7"></a>
 Validation kind: `guard`. Error code: `SQL_DIVISION_BY_ZERO`.
 
-The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+Example names for Division with a zero divisor: [shared wording](#shared-wording-4).
 
 ```sql
 WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT id, 1::bigint / NULLIF(0::bigint, 0::bigint) AS value FROM source ORDER BY id;
@@ -21,13 +98,13 @@ WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM
 
 ### Division with a nonzero divisor
 
-Use NULLIF(divisor, 0) as the divisor if a NULL result is acceptable.
+Guidance for Division with a nonzero divisor: [shared wording](#shared-wording-6).
 
 Preconditions: For a nonzero divisor the value must be unchanged.
 
-Validation kind: `guard`. Error code: `SQL_DIVISION_BY_ZERO`.
+Validation kind for Division with a nonzero divisor: [shared wording](#shared-wording-7).
 
-The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+Example names for Division with a nonzero divisor: [shared wording](#shared-wording-4).
 
 ```sql
 WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT id, 7::bigint / NULLIF(2::bigint, 0::bigint) AS value FROM source ORDER BY id;
@@ -41,7 +118,7 @@ Preconditions: Move the window output into a subquery before filtering; this cor
 
 Validation kind: `author`. Error code: `SQL_WINDOW_NOT_ALLOWED`.
 
-The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+Example names for Filter a window output in a subquery: [shared wording](#shared-wording-4).
 
 ```sql
 WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders), ranked AS (SELECT id, ROW_NUMBER() OVER (ORDER BY sort_key, id) AS rn FROM source) SELECT id FROM ranked WHERE rn = 1 ORDER BY id;
@@ -55,7 +132,7 @@ Preconditions: Choose the intended PostgreSQL format; this example uses the full
 
 Validation kind: `author`. Error code: `SQL_UNSUPPORTED_SYNTAX`.
 
-The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+Example names for Use the PostgreSQL TO_CHAR spelling: [shared wording](#shared-wording-4).
 
 ```sql
 WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT id, TO_CHAR(TIMESTAMP '2026-09-26 12:34:56', 'YYYY-MM-DD HH24:MI:SS') AS value FROM source ORDER BY id;
@@ -69,7 +146,7 @@ Preconditions: Choose the intended public type; the example chooses TEXT.
 
 Validation kind: `author`. Error code: `SQL_UNTYPED_NULL`.
 
-The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+Example names for Give NULL an explicit public type: [shared wording](#shared-wording-4).
 
 ```sql
 WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT id, CAST(NULL AS TEXT) AS value FROM source ORDER BY id;
@@ -81,9 +158,10 @@ For an equality comparison to a grouped MAX, aggregate by the correlation key in
 
 Preconditions: Equality to a correlated MAX grouped by the correlation key; preserve NULL keys and empty groups.
 
+<a id="shared-wording-8"></a>
 Validation kind: `equivalent`. Error code: `SQL_UNSUPPORTED_SYNTAX`.
 
-The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+Example names for Correlated max join: [shared wording](#shared-wording-4).
 
 ```sql
 WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT s.id, s.value FROM source s JOIN (SELECT group_key AS k, MAX(value) AS m FROM source GROUP BY group_key) g ON s.group_key = g.k WHERE s.value = g.m ORDER BY s.id;
@@ -93,11 +171,11 @@ WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM
 
 STRLEN is not supported. For byte counts, use OCTET_LENGTH(text). Byte counts and character counts can differ; character counting has no verified SQL equivalent.
 
-Preconditions: The intent is byte count, not character count. The fixture includes non-ASCII text and NULL values.
+Preconditions: The intent is byte count, not character count. Applies to non-ASCII text and NULL inputs.
 
-Validation kind: `equivalent`. Error code: `SQL_FUNCTION_NOT_FOUND`.
+Validation kind for Octet length bytes: [shared wording](#shared-wording-3).
 
-The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+Example names for Octet length bytes: [shared wording](#shared-wording-4).
 
 ```sql
 WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT id, OCTET_LENGTH(text_value) AS value FROM source ORDER BY id;
@@ -105,13 +183,16 @@ WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM
 
 ### Array scalar containment
 
+<a id="shared-wording-9"></a>
 Both operands must be arrays of compatible element types. For single-value containment, wrap the scalar in a one-element array.
 
+<a id="shared-wording-10"></a>
 Preconditions: Single-value array containment is intended; include NULL input and unmatched elements.
 
+<a id="shared-wording-11"></a>
 Validation kind: `equivalent`. Error code: `SQL_OPERATOR_TYPE_MISMATCH`.
 
-The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+Example names for Array scalar containment: [shared wording](#shared-wording-4).
 
 ```sql
 WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT id, ARRAY[group_key] <@ ARRAY['g1','g2'] AS value FROM source ORDER BY id;
@@ -119,13 +200,13 @@ WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM
 
 ### Array scalar contains
 
-Both operands must be arrays of compatible element types. For single-value containment, wrap the scalar in a one-element array.
+Guidance for Array scalar contains: [shared wording](#shared-wording-9).
 
-Preconditions: Single-value array containment is intended; include NULL input and unmatched elements.
+Preconditions for Array scalar contains: [shared wording](#shared-wording-10).
 
-Validation kind: `equivalent`. Error code: `SQL_OPERATOR_TYPE_MISMATCH`.
+Validation kind for Array scalar contains: [shared wording](#shared-wording-11).
 
-The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+Example names for Array scalar contains: [shared wording](#shared-wording-4).
 
 ```sql
 WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT id, ARRAY['g1','g2'] @> ARRAY[group_key] AS value FROM source ORDER BY id;
@@ -137,9 +218,10 @@ Use a BOOL condition. If the intent is to exclude zero, compare the numeric expr
 
 Preconditions: The explicitly selected intent is to exclude numeric zero and NULL.
 
+<a id="shared-wording-12"></a>
 Validation kind: `author`. Error code: `SQL_WHERE_TYPE_MISMATCH`.
 
-The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+Example names for Numeric predicate: [shared wording](#shared-wording-4).
 
 ```sql
 WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT id FROM source WHERE value <> 0 ORDER BY id;
@@ -151,9 +233,9 @@ Use a BOOL condition. If the intent is to exclude empty text, compare the text e
 
 Preconditions: The explicitly selected intent is to exclude empty text and NULL.
 
-Validation kind: `author`. Error code: `SQL_WHERE_TYPE_MISMATCH`.
+Validation kind for Text predicate: [shared wording](#shared-wording-12).
 
-The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+Example names for Text predicate: [shared wording](#shared-wording-4).
 
 ```sql
 WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT id FROM source WHERE text_value <> '' ORDER BY id;
@@ -161,13 +243,14 @@ WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM
 
 ### Remainder nullif
 
+<a id="shared-wording-13"></a>
 Use NULLIF(divisor, 0) as the remainder divisor if a NULL result is acceptable.
 
 Preconditions: Returning NULL instead of an error for a zero remainder divisor is acceptable.
 
-Validation kind: `guard`. Error code: `SQL_DIVISION_BY_ZERO`.
+Validation kind for Remainder nullif: [shared wording](#shared-wording-7).
 
-The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+Example names for Remainder nullif: [shared wording](#shared-wording-4).
 
 ```sql
 WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT id, CAST(sort_key AS BIGINT) % NULLIF(CAST(0 AS BIGINT), CAST(0 AS BIGINT)) AS value FROM source ORDER BY id;
@@ -175,13 +258,13 @@ WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM
 
 ### Remainder nullif nonzero
 
-Use NULLIF(divisor, 0) as the remainder divisor if a NULL result is acceptable.
+Guidance for Remainder nullif nonzero: [shared wording](#shared-wording-13).
 
 Preconditions: Integer-valued sort keys; verify that the guard preserves a nonzero divisor.
 
-Validation kind: `guard`. Error code: `SQL_DIVISION_BY_ZERO`.
+Validation kind for Remainder nullif nonzero: [shared wording](#shared-wording-7).
 
-The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+Example names for Remainder nullif nonzero: [shared wording](#shared-wording-4).
 
 ```sql
 WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT id, CAST(sort_key AS BIGINT) % NULLIF(CAST(2 AS BIGINT), CAST(0 AS BIGINT)) AS value FROM source ORDER BY id;
@@ -193,9 +276,10 @@ Use an optional sign and decimal digits for INT input, for example '123'. Supply
 
 Preconditions: The caller explicitly supplies the value 123; this example must not replace an unknown intended value.
 
+<a id="shared-wording-14"></a>
 Validation kind: `author`. Error code: `SQL_INVALID_CAST`.
 
-The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+Example names for Cast int format: [shared wording](#shared-wording-4).
 
 ```sql
 WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT CAST('123' AS INT) AS value FROM source LIMIT 1;
@@ -207,9 +291,9 @@ Use a finite decimal number for DOUBLE input, for example '1.25'. Supply the int
 
 Preconditions: The caller explicitly supplies the finite decimal value 1.25.
 
-Validation kind: `author`. Error code: `SQL_INVALID_CAST`.
+Validation kind for Cast double format: [shared wording](#shared-wording-14).
 
-The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+Example names for Cast double format: [shared wording](#shared-wording-4).
 
 ```sql
 WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT CAST('1.25' AS DOUBLE PRECISION) AS value FROM source LIMIT 1;
@@ -221,26 +305,362 @@ Compute OPTION.name in a derived table first, then construct ARRAY from that pro
 
 Preconditions: Project OPTION.name before constructing the array. This case preserves an INNER JOIN with condition TRUE, NULL values, duplicates and row count; retain other original predicates.
 
-Validation kind: `equivalent`. Error code: `SQL_UNSUPPORTED_SYNTAX`.
+Validation kind for Materialize option names before array construction: [shared wording](#shared-wording-8).
 
-The example uses an `orders` table with `group_key`, `sort_key`, `value`, and `text_value` columns. Replace these with exact Catalog names.
+Example names for Materialize option names before array construction: [shared wording](#shared-wording-4).
 
 ```sql
 SELECT q.id, v AS value FROM (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) q CROSS JOIN UNNEST(ARRAY[q.text_value]) v ORDER BY q.id;
 ```
 
-## Unsupported diagnostics
+### First value int
+
+Guidance for First value int: [shared wording](#shared-wording-1).
+
+Preconditions for First value int: [shared wording](#shared-wording-2).
+
+Validation kind for First value int: [shared wording](#shared-wording-3).
+
+Example names for First value int: [shared wording](#shared-wording-4).
+
+```sql
+WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders), ranked AS (SELECT id, group_key, CAST(sort_key AS BIGINT) AS value, ROW_NUMBER() OVER (PARTITION BY group_key ORDER BY sort_key ASC NULLS LAST, id ASC) AS rn FROM source) SELECT id, MAX(CASE WHEN rn = 1 THEN value END) OVER (PARTITION BY group_key) AS value FROM ranked ORDER BY id;
+```
+
+### First value text
+
+Guidance for First value text: [shared wording](#shared-wording-1).
+
+Preconditions for First value text: [shared wording](#shared-wording-2).
+
+Validation kind for First value text: [shared wording](#shared-wording-3).
+
+Example names for First value text: [shared wording](#shared-wording-4).
+
+```sql
+WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders), ranked AS (SELECT id, group_key, text_value AS value, ROW_NUMBER() OVER (PARTITION BY group_key ORDER BY sort_key ASC NULLS LAST, id ASC) AS rn FROM source) SELECT id, MAX(CASE WHEN rn = 1 THEN value END) OVER (PARTITION BY group_key) AS value FROM ranked ORDER BY id;
+```
+
+### In null where
+
+<a id="shared-wording-15"></a>
+Direct WHERE/HAVING/JOIN ON: remove NULL items; use FALSE if empty. Adding OR x IS NULL changes intent to include NULL rows. Not equivalent under NOT or in projection.
+
+<a id="shared-wording-16"></a>
+Preconditions: Use directly as a WHERE/HAVING/JOIN ON predicate, not under NOT or truth-value inspection. WHERE, HAVING or JOIN ON filtering only; remove only explicit NULL list items. No equivalence is claimed for projection or an intent to include NULL rows.
+
+<a id="shared-wording-17"></a>
+Validation kind: `equivalent`. Error code: `SQL_UNSUPPORTED_SYNTAX_NULL_IN_LIST`.
+
+Example names for In null where: [shared wording](#shared-wording-4).
+
+```sql
+WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT id FROM source WHERE value IN (2.5, 0.0) ORDER BY id;
+```
+
+### In null having
+
+Direct WHERE/HAVING/JOIN ON for In null having: [shared wording](#shared-wording-15).
+
+Preconditions for In null having: [shared wording](#shared-wording-16).
+
+Validation kind for In null having: [shared wording](#shared-wording-17).
+
+Example names for In null having: [shared wording](#shared-wording-4).
+
+```sql
+WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT group_key, MAX(value) AS value FROM source GROUP BY group_key HAVING MAX(value) IN (2.5, 0.0) ORDER BY group_key NULLS LAST;
+```
+
+### In null join
+
+Direct WHERE/HAVING/JOIN ON for In null join: [shared wording](#shared-wording-15).
+
+Preconditions for In null join: [shared wording](#shared-wording-16).
+
+Validation kind for In null join: [shared wording](#shared-wording-17).
+
+Example names for In null join: [shared wording](#shared-wording-4).
+
+```sql
+WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT a.id, b.id AS other_id FROM source a JOIN source b ON a.id = b.id AND a.value IN (2.5, 0.0) ORDER BY a.id, b.id;
+```
+
+### In null left join
+
+Direct WHERE/HAVING/JOIN ON for In null left join: [shared wording](#shared-wording-15).
+
+Preconditions for In null left join: [shared wording](#shared-wording-16).
+
+Validation kind for In null left join: [shared wording](#shared-wording-17).
+
+Example names for In null left join: [shared wording](#shared-wording-4).
+
+```sql
+WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT a.id, b.id AS other_id FROM source a LEFT JOIN source b ON a.id = b.id AND a.value IN (2.5, 0.0) ORDER BY a.id, b.id;
+```
+
+### In null include null intent
+
+Direct WHERE/HAVING/JOIN ON for In null include null intent: [shared wording](#shared-wording-15).
+
+Preconditions: Use directly as a WHERE/HAVING/JOIN ON predicate, not under NOT or truth-value inspection. Only if the requested intent explicitly includes NULL rows.
+
+<a id="shared-wording-18"></a>
+Validation kind: `author`. Error code: `SQL_UNSUPPORTED_SYNTAX_NULL_IN_LIST`.
+
+Example names for In null include null intent: [shared wording](#shared-wording-4).
+
+```sql
+WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT id FROM source WHERE value IN (2.5, 0.0) OR value IS NULL ORDER BY id;
+```
+
+### Not in null filter
+
+<a id="shared-wording-19"></a>
+Direct filters: FALSE preserves no matches. To change intent, use x NOT IN (...) AND x IS NOT NULL, or x IS NOT NULL for an empty remaining list. Neither works under NOT or in projection.
+
+Preconditions: Use directly as a WHERE/HAVING/JOIN ON predicate, not under NOT or truth-value inspection. Filtering context only. FALSE preserves the original empty match set; excluding listed values and NULL rows is an intent change, not an equivalent replacement.
+
+Validation kind for Not in null filter: [shared wording](#shared-wording-17).
+
+Example names for Not in null filter: [shared wording](#shared-wording-4).
+
+```sql
+WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT id FROM source WHERE FALSE ORDER BY id;
+```
+
+### Not in null intent
+
+Direct filters for Not in null intent: [shared wording](#shared-wording-19).
+
+Preconditions: Use directly as a WHERE/HAVING/JOIN ON predicate, not under NOT or truth-value inspection. Only if excluding listed values and NULL rows is the explicitly selected intent.
+
+Validation kind for Not in null intent: [shared wording](#shared-wording-18).
+
+Example names for Not in null intent: [shared wording](#shared-wording-4).
+
+```sql
+WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT id FROM source WHERE value NOT IN (2.5, 0.0) AND value IS NOT NULL ORDER BY id;
+```
+
+### In null only filter
+
+Direct WHERE/HAVING/JOIN ON for In null only filter: [shared wording](#shared-wording-15).
+
+Preconditions: Use directly as a WHERE/HAVING/JOIN ON predicate, not under NOT or truth-value inspection. Filtering context only; an all-NULL list has no matching rows. Projection requires preserving its three-valued result.
+
+Validation kind for In null only filter: [shared wording](#shared-wording-17).
+
+Example names for In null only filter: [shared wording](#shared-wording-4).
+
+```sql
+WITH source AS (SELECT rec_id AS id, group_key, sort_key, value, text_value FROM orders) SELECT id FROM source WHERE FALSE ORDER BY id;
+```
+
+### OPTION member comparison: equal
+
+<a id="shared-wording-20"></a>
+Compare .name for labels or .id for option IDs, using matching TEXT operands.
+
+<a id="shared-wording-21"></a>
+Preconditions: Author correction only: choose .name for option labels or .id for option IDs and supply matching text operands. This Base must support the member operation and the chosen predicate; target-capability rejection remains unchanged on older Bases.
+
+<a id="shared-wording-22"></a>
+Validation kind: `author`. Error code: `SQL_OPERATOR_TYPE_MISMATCH`.
+
+Example names for OPTION member comparison: equal: [shared wording](#shared-wording-4).
+
+```sql
+SELECT COUNT(*) AS n FROM "perf_orders_10k" WHERE ("状态").name = '状态1';
+```
+
+### OPTION member comparison: in
+
+Guidance for OPTION member comparison: in: [shared wording](#shared-wording-20).
+
+Preconditions for OPTION member comparison: in: [shared wording](#shared-wording-21).
+
+Validation kind for OPTION member comparison: in: [shared wording](#shared-wording-22).
+
+Example names for OPTION member comparison: in: [shared wording](#shared-wording-4).
+
+```sql
+SELECT COUNT(*) AS n FROM "perf_orders_10k" WHERE ("状态").name IN ('状态1','状态2');
+```
+
+### OPTION member comparison: not in
+
+Guidance for OPTION member comparison: not in: [shared wording](#shared-wording-20).
+
+Preconditions for OPTION member comparison: not in: [shared wording](#shared-wording-21).
+
+Validation kind for OPTION member comparison: not in: [shared wording](#shared-wording-22).
+
+Example names for OPTION member comparison: not in: [shared wording](#shared-wording-4).
+
+```sql
+SELECT COUNT(*) AS n FROM "perf_orders_10k" WHERE ("状态").name NOT IN ('状态1','状态2');
+```
+
+### OPTION member comparison: any
+
+Guidance for OPTION member comparison: any: [shared wording](#shared-wording-20).
+
+Preconditions for OPTION member comparison: any: [shared wording](#shared-wording-21).
+
+Validation kind for OPTION member comparison: any: [shared wording](#shared-wording-22).
+
+Example names for OPTION member comparison: any: [shared wording](#shared-wording-4).
+
+```sql
+SELECT COUNT(*) AS n FROM "perf_orders_10k" WHERE ("状态").name = ANY(ARRAY['状态1','状态2']);
+```
+
+### OPTION member comparison: unnest equal
+
+Guidance for OPTION member comparison: unnest equal: [shared wording](#shared-wording-20).
+
+Preconditions for OPTION member comparison: unnest equal: [shared wording](#shared-wording-21).
+
+Validation kind for OPTION member comparison: unnest equal: [shared wording](#shared-wording-22).
+
+Example names for OPTION member comparison: unnest equal: [shared wording](#shared-wording-4).
+
+```sql
+SELECT COUNT(*) AS n FROM "perf_orders_10k", UNNEST("标签") AS u WHERE u.name = '标签1';
+```
+
+### OPTION member comparison: parameter equal
+
+Guidance for OPTION member comparison: parameter equal: [shared wording](#shared-wording-20).
+
+Preconditions for OPTION member comparison: parameter equal: [shared wording](#shared-wording-21).
+
+<a id="shared-wording-23"></a>
+Validation kind: `author`. Error code: `SQL_PARAMETER_TYPE_MISMATCH`.
+
+Example names for OPTION member comparison: parameter equal: [shared wording](#shared-wording-4).
+
+```sql
+SELECT COUNT(*) AS n FROM "perf_orders_10k" WHERE ("状态").name = $1;
+```
+
+### OPTION member comparison: any parameter
+
+Guidance for OPTION member comparison: any parameter: [shared wording](#shared-wording-20).
+
+Preconditions for OPTION member comparison: any parameter: [shared wording](#shared-wording-21).
+
+Validation kind: `author`. Error code: `SQL_FUNCTION_ARG_TYPE_MISMATCH`.
+
+Example names for OPTION member comparison: any parameter: [shared wording](#shared-wording-4).
+
+```sql
+SELECT COUNT(*) AS n FROM "perf_orders_10k" WHERE ("状态").name = ANY($1);
+```
+
+### OPTION member comparison: parameter id
+
+Guidance for OPTION member comparison: parameter id: [shared wording](#shared-wording-20).
+
+Preconditions for OPTION member comparison: parameter id: [shared wording](#shared-wording-21).
+
+Validation kind for OPTION member comparison: parameter id: [shared wording](#shared-wording-23).
+
+Example names for OPTION member comparison: parameter id: [shared wording](#shared-wording-4).
+
+```sql
+SELECT COUNT(*) AS n FROM "perf_orders_10k" WHERE ("状态").id = $1;
+```
+
+### OPTION member comparison: collection contains
+
+<a id="shared-wording-24"></a>
+Where supported by this Base, project .name for labels or .id for option IDs with ARRAY_AGG over UNNEST, then compare the resulting TEXT[].
+
+<a id="shared-wording-25"></a>
+Preconditions: Author correction only: choose .name for option labels or .id for option IDs and supply matching text operands. This Base must support the member operation and the chosen predicate; target-capability rejection remains unchanged on older Bases. Group member values by record ID and join one projected row per source record. Preserve NULL collections separately from empty collections. ARRAY_REMOVE of a constant singleton constructs an empty TEXT array.
+
+Validation kind for OPTION member comparison: collection contains: [shared wording](#shared-wording-22).
+
+Example names for OPTION member comparison: collection contains: [shared wording](#shared-wording-4).
+
+```sql
+WITH option_names AS (SELECT option_source.rec_id AS option_names_record_id, array_agg(option_item.name) AS option_names_members FROM perf_orders_10k option_source, unnest(option_source."标签") option_item GROUP BY option_source.rec_id) SELECT count(*) AS n FROM perf_orders_10k LEFT JOIN option_names ON perf_orders_10k.rec_id = option_names.option_names_record_id WHERE CASE WHEN perf_orders_10k."标签" IS NULL THEN NULL ELSE COALESCE(option_names.option_names_members, array_remove(ARRAY[''], '')) END @> ARRAY['标签1', '标签2'];
+```
+
+### OPTION member comparison: collection overlaps
+
+Guidance for OPTION member comparison: collection overlaps: [shared wording](#shared-wording-24).
+
+Preconditions for OPTION member comparison: collection overlaps: [shared wording](#shared-wording-25).
+
+Validation kind for OPTION member comparison: collection overlaps: [shared wording](#shared-wording-22).
+
+Example names for OPTION member comparison: collection overlaps: [shared wording](#shared-wording-4).
+
+```sql
+WITH option_names AS (SELECT option_source.rec_id AS option_names_record_id, array_agg(option_item.name) AS option_names_members FROM perf_orders_10k option_source, unnest(option_source."标签") option_item GROUP BY option_source.rec_id) SELECT count(*) AS n FROM perf_orders_10k LEFT JOIN option_names ON perf_orders_10k.rec_id = option_names.option_names_record_id WHERE CASE WHEN perf_orders_10k."标签" IS NULL THEN NULL ELSE COALESCE(option_names.option_names_members, array_remove(ARRAY[''], '')) END && ARRAY['标签1', '标签2'];
+```
+
+### OPTION member comparison: collection contained
+
+Guidance for OPTION member comparison: collection contained: [shared wording](#shared-wording-24).
+
+Preconditions for OPTION member comparison: collection contained: [shared wording](#shared-wording-25).
+
+Validation kind for OPTION member comparison: collection contained: [shared wording](#shared-wording-22).
+
+Example names for OPTION member comparison: collection contained: [shared wording](#shared-wording-4).
+
+```sql
+WITH option_names AS (SELECT option_source.rec_id AS option_names_record_id, array_agg(option_item.name) AS option_names_members FROM perf_orders_10k option_source, unnest(option_source."标签") option_item GROUP BY option_source.rec_id) SELECT count(*) AS n FROM perf_orders_10k LEFT JOIN option_names ON perf_orders_10k.rec_id = option_names.option_names_record_id WHERE CASE WHEN perf_orders_10k."标签" IS NULL THEN NULL ELSE COALESCE(option_names.option_names_members, array_remove(ARRAY[''], '')) END <@ ARRAY['标签1', '标签2'];
+```
+
+### OPTION member comparison: collection contains parameter
+
+Guidance for OPTION member comparison: collection contains parameter: [shared wording](#shared-wording-24).
+
+Preconditions for OPTION member comparison: collection contains parameter: [shared wording](#shared-wording-25).
+
+Validation kind for OPTION member comparison: collection contains parameter: [shared wording](#shared-wording-23).
+
+Example names for OPTION member comparison: collection contains parameter: [shared wording](#shared-wording-4).
+
+```sql
+WITH option_names AS (SELECT option_source.rec_id AS option_names_record_id, array_agg(option_item.name) AS option_names_members FROM perf_orders_10k option_source, unnest(option_source."标签") option_item GROUP BY option_source.rec_id) SELECT count(*) AS n FROM perf_orders_10k LEFT JOIN option_names ON perf_orders_10k.rec_id = option_names.option_names_record_id WHERE CASE WHEN perf_orders_10k."标签" IS NULL THEN NULL ELSE COALESCE(option_names.option_names_members, array_remove(ARRAY[''], '')) END @> $1;
+```
+
+### OPTION member comparison: collection overlaps parameter
+
+Guidance for OPTION member comparison: collection overlaps parameter: [shared wording](#shared-wording-24).
+
+Preconditions for OPTION member comparison: collection overlaps parameter: [shared wording](#shared-wording-25).
+
+Validation kind for OPTION member comparison: collection overlaps parameter: [shared wording](#shared-wording-23).
+
+Example names for OPTION member comparison: collection overlaps parameter: [shared wording](#shared-wording-4).
+
+```sql
+WITH option_names AS (SELECT option_source.rec_id AS option_names_record_id, array_agg(option_item.name) AS option_names_members FROM perf_orders_10k option_source, unnest(option_source."标签") option_item GROUP BY option_source.rec_id) SELECT count(*) AS n FROM perf_orders_10k LEFT JOIN option_names ON perf_orders_10k.rec_id = option_names.option_names_record_id WHERE CASE WHEN perf_orders_10k."标签" IS NULL THEN NULL ELSE COALESCE(option_names.option_names_members, array_remove(ARRAY[''], '')) END && $1;
+```
+
+## Placeholder reference
 
 Placeholders denote the names and types reported in the error. Use the concrete restriction reported in the error; placeholders do not declare every possible value unsupported.
 
 | Code / variant | Reason | Repair |
 |---|---|---|
 | `SQL_CAST_TYPE_MISMATCH` / `unsupported_conversion` | Conversion from {SourceType} to {TargetType} is not supported. | Choose a column or parameter already having the required type. An equivalent conversion has not been verified. [outside_sql] |
-| `SQL_FUNCTION_NOT_FOUND` / `known_unavailable` | Function {Function} is not supported. | {Alternative} [outside_sql] |
+| `SQL_FUNCTION_NOT_FOUND` / `known_unavailable` | Function {Function} is not supported. | With INT/DOUBLE/TEXT values, a full partition and unique order: {Alternative} |
 | `SQL_FUNCTION_NOT_FOUND` / `unsupported_function` | Function {Function} is not supported. | [outside_sql] |
 | `SQL_INTERVAL_LITERAL_CALENDAR_UNIT_NOT_SUPPORTED` / `interval_calendar_unit` | Calendar interval unit {Unit} is not supported. | A fixed day count is not equivalent. [outside_sql] |
 | `SQL_INTERVAL_LITERAL_FRACTIONAL_MILLISECONDS` / `interval_precision` | The interval must be an exact whole number of milliseconds. | Whole milliseconds are supported; higher precision cannot be preserved by rounding. [outside_sql] |
 | `SQL_INTERVAL_LITERAL_UNIT_NOT_SUPPORTED` / `interval_unit` | Interval unit {Unit} is not supported. | Use day, hour, minute, second, or millisecond units. |
+| `SQL_TARGET_CAPABILITY_UNAVAILABLE` / `engine_version_required` | This SQL syntax is not supported for this Base yet. | Do not rewrite or retry the SQL; it becomes available after this Base is upgraded. |
+| `SQL_TARGET_CAPABILITY_UNAVAILABLE` / `target_rewrite_available` | "{Capability}" is not supported for this Base yet. | {Rewrite} |
+| `SQL_TARGET_CAPABILITY_UNAVAILABLE` / `target_upgrade_required` | "{Capability}" is not supported for this Base yet. | Do not rewrite or retry the SQL; it becomes available after this Base is upgraded. |
 | `SQL_UNSUPPORTED_COLUMN_TYPE` / `column_representation` | Column {Column} has type {BaseType}; {Representation}. | A supported column is required for an equivalent SQL operation. [outside_sql] |
 | `SQL_UNSUPPORTED_OPERATOR` / `unavailable_operation` | This {Operation} is not supported. | [outside_sql] |
 | `SQL_UNSUPPORTED_OPERATOR` / `unsupported_field_operator` | Column {Column} has type {ActualType}, which does not support {Operator}. | [outside_sql] |
@@ -251,6 +671,7 @@ Placeholders denote the names and types reported in the error. Use the concrete
 | `SQL_UNSUPPORTED_SYNTAX` / `array_subquery_shape` | This ARRAY subquery shape is not supported. | Only a direct single-column UNNEST projection is supported here. [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX` / `binary_operator` | Unsupported binary operator: {Operator}. | [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX` / `capability_budget` | The supported limit was exceeded: {Dimension}. | Reduce this query dimension or split the operation into separate queries. |
+| `SQL_UNSUPPORTED_SYNTAX` / `cast_target_name` | CAST target type {Target} is not supported. | [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX` / `correlated_exists` | Correlated EXISTS does not support {Predicate}. | Only supported equality correlations can be expressed in SQL. [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX` / `correlated_option_array` | Correlated OPTION.name expressions inside ARRAY require a materialized input. | Compute OPTION.name in a derived table first, then construct ARRAY from that projected column. Preserve the original joins, filters, and NULL behavior. |
 | `SQL_UNSUPPORTED_SYNTAX` / `date_trunc_context` | DATE_TRUNC output cannot be used in {Context}. | [outside_sql] |
@@ -263,9 +684,15 @@ Placeholders denote the names and types reported in the error. Use the concrete
 | `SQL_UNSUPPORTED_SYNTAX` / `named_window_reference` | Window definition {Window} is missing or duplicated. | Use a unique WINDOW definition and reference its declared name. |
 | `SQL_UNSUPPORTED_SYNTAX` / `nested_cte` | A nested CTE is not supported in {Context}. | [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX` / `null_ordering` | Explicit NULLS ordering requires {Constraint}. | [outside_sql] |
+| `SQL_UNSUPPORTED_SYNTAX` / `nullable_array_elements` | Arrays mixing column expressions and NULL require deterministic TEXT, INT, DOUBLE, BOOL, TIMESTAMP, or INTERVAL values. | [outside_sql] |
+| `SQL_UNSUPPORTED_SYNTAX` / `nullable_array_predicate` | A predicate comparing column-based arrays containing NULL requires a search input with known non-null elements. | [outside_sql] |
+| `SQL_UNSUPPORTED_SYNTAX` / `object_array_column_alias` | UNNEST column aliases support a single scalar array, not composite values or record references. | [outside_sql] |
+| `SQL_UNSUPPORTED_SYNTAX` / `object_array_ordinality` | WITH ORDINALITY is not supported for arrays of composite values or record references. | [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX` / `option_member_context` | OPTION[].name cannot be used in {Context}. | An equivalent SQL rewrite preserving row multiplicity has not been verified. [outside_sql] |
+| `SQL_UNSUPPORTED_SYNTAX` / `ordered_set_function` | Function {Function} does not support WITHIN GROUP. | [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX` / `protocol_shape` | Invalid compiled structure: {Shape} is not supported. | Recompile the query using the current supported contract. |
 | `SQL_UNSUPPORTED_SYNTAX` / `route_table_required` | The query must reference a table for execution routing. | Adding an arbitrary table can change row count. [outside_sql] |
+| `SQL_UNSUPPORTED_SYNTAX` / `series_shape` | GENERATE_SERIES supports constant integer bounds and a nonzero step, with at most 10000 values in the exact numeric range. | [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX` / `subquery_constraint` | {Construct} requires {Constraint}. | The subquery must satisfy the stated constraint for a supported SQL rewrite. [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX` / `syntax_feature` | SQL feature {Feature} is not supported. | [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX` / `syntax_restriction` | {Restriction}. | [outside_sql] |
@@ -273,12 +700,12 @@ Placeholders denote the names and types reported in the error. Use the concrete
 | `SQL_UNSUPPORTED_SYNTAX` / `unary_operator` | Unsupported unary operator: {Operator}. | [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX` / `unavailable_function_syntax` | Function {Function} is not supported. | [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX` / `window_capability` | Window function {Function} requires {Requirement}. | [outside_sql] |
-| `SQL_UNSUPPORTED_SYNTAX_DISTINCT_FROM` / `distinct_comparison` | IS DISTINCT FROM and IS NOT DISTINCT FROM are not supported. | [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX_EXCEPT` / `except_set` | EXCEPT {Quantifier} is not supported. | Duplicate and NULL behavior must be preserved. [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX_INTERSECT` / `intersect_set` | INTERSECT {Quantifier} is not supported. | Duplicate and NULL behavior must be preserved. [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX_LAG_LEAD` / `lag_lead_argument` | Argument {Argument} of {Function} has an unsupported form; expected {Form}. | Argument {Argument} requires {Form}. [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX_LATERAL` / `lateral_correlation` | LATERAL with {Correlation} is not supported. | [outside_sql] |
-| `SQL_UNSUPPORTED_SYNTAX_NULL_IN_LIST` / `null_in_list` | An explicit NULL element in an IN or NOT IN list is not supported. | Removing NULL can change the result. [outside_sql] |
+| `SQL_UNSUPPORTED_SYNTAX_NULL_IN_LIST` / `null_in_list` | An explicit NULL element in an IN list is not supported. | Direct WHERE/HAVING/JOIN ON: remove NULL items; use FALSE if empty. Adding OR x IS NULL changes intent to include NULL rows. Not equivalent under NOT or in projection. |
+| `SQL_UNSUPPORTED_SYNTAX_NULL_IN_LIST` / `null_not_in_list` | An explicit NULL element in a NOT IN list is not supported. | Direct filters: FALSE preserves no matches. To change intent, use x NOT IN (...) AND x IS NOT NULL, or x IS NOT NULL for an empty remaining list. Neither works under NOT or in projection. |
 | `SQL_UNSUPPORTED_SYNTAX_RECURSIVE_CTE` / `recursive_cte` | Recursive CTE {CTE} is not supported. | [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX_REGEXP_REPLACE` / `regexp_replacement` | The requested replacement mode is not supported: {Mode}. | [outside_sql] |
 | `SQL_UNSUPPORTED_SYNTAX_WINDOW_FRAME` / `window_frame` | The window specification is not supported: {Frame}. | Changing the frame can change the result. [outside_sql] |
@@ -293,6 +720,7 @@ Placeholders denote the names and types reported in the error. Use the concrete
 | `ArrayConstructor` | `outside_sql` | This ANY operand requires an ARRAY constructor | [outside_sql] |
 | `ArrayDimension` | `outside_sql` | ARRAY_LENGTH requires literal 1 as the dimension | [outside_sql] |
 | `ArrayLengthArity` | `outside_sql` | Use ARRAY_LENGTH(array, 1) or CARDINALITY(array) | [outside_sql] |
+| `ArraySortDomain` | `outside_sql` | ARRAY_SORT requires a one-dimensional literal array constructor or native collection field with proven non-NULL scalar elements, or a typed NULL array; parameters and derived array carriers are not supported | [outside_sql] |
 | `ArraySubquery` | `outside_sql` | ANY array operands and elements cannot contain subqueries | [outside_sql] |
 | `ArrayTypeModifier` | `outside_sql` | An empty ANY array requires an unmodified supported scalar array type | [outside_sql] |
 | `BetweenBounds` | `outside_sql` | BETWEEN requires two bounds | [outside_sql] |
@@ -308,10 +736,12 @@ Placeholders denote the names and types reported in the error. Use the concrete
 | `ColumnReference` | `outside_sql` | This column reference form is not supported | [outside_sql] |
 | `ConstantMembership` | `outside_sql` | Constant membership requires literal SELECT or UNION leaves and literal boolean filters, without ordering or pagination | [outside_sql] |
 | `ConstantMembershipKey` | `outside_sql` | This constant membership key has no supported equivalent rewrite | [outside_sql] |
+| `CorrelatedExtremaShape` | `outside_sql` | Correlated scalar MIN/MAX requires an ungrouped outer query, one inner table, one aggregated column and a single equality between scalar columns in the current scopes; extra clauses are not supported | [outside_sql] |
 | `CorrelatedMembership` | `outside_sql` | Correlated membership requires equality column predicates between one inner source and current outer sources | [outside_sql] |
 | `CorrelatedScalar` | `conditional_pattern` | Correlated scalar subqueries are not supported; aggregate the inner source and JOIN the grouped result | For an equality comparison to a grouped MAX, aggregate by the correlation key in a subquery and JOIN that result. Preserve NULL and empty-group behavior. Other correlated forms have no verified SQL rewrite. |
+| `CovarianceExactness` | `outside_sql` | Covariance and correlation are unavailable because equivalent floating-point results cannot be guaranteed | [outside_sql] |
 | `CurrentDate` | `outside_sql` | CURRENT_DATE is not supported; use a TIMESTAMP value or CURRENT_TIMESTAMP when equivalent | [outside_sql] |
-| `DistinctGrouping` | `outside_sql` | GROUP BY DISTINCT grouping sets require one source, unambiguous field keys, and an aggregate for the empty grouping set | [outside_sql] |
+| `DistinctGrouping` | `outside_sql` | GROUP BY DISTINCT grouping sets require one source, direct unambiguous field keys, and an aggregate for the empty grouping set | [outside_sql] |
 | `DistinctOnNullOrdering` | `outside_sql` | DISTINCT ON with explicit NULLS ordering is not supported | [outside_sql] |
 | `DistinctOnPrefix` | `outside_sql` | DISTINCT ON expressions must match the leftmost ORDER BY expressions | [outside_sql] |
 | `DistinctWithGroupingSets` | `outside_sql` | SELECT DISTINCT with GROUPING SETS is not supported | [outside_sql] |
@@ -322,6 +752,7 @@ Placeholders denote the names and types reported in the error. Use the concrete
 | `ExpressionOperator` | `outside_sql` | This expression operator is not supported | [outside_sql] |
 | `ExtractForm` | `outside_sql` | Use EXTRACT(field FROM expression) | [outside_sql] |
 | `ExtremaOperator` | `outside_sql` | This LEAST or GREATEST operation is not supported | [outside_sql] |
+| `FetchTiesShape` | `outside_sql` | FETCH WITH TIES requires ORDER BY and nonnegative constant row counts with explicit output columns | [outside_sql] |
 | `FromFunction` | `outside_sql` | FROM table functions require exactly one UNNEST call | [outside_sql] |
 | `FromItem` | `outside_sql` | This FROM item is not supported | [outside_sql] |
 | `FullJoinUsing` | `outside_sql` | FULL JOIN USING is not supported; use FULL JOIN ON and project COALESCE(left_key, right_key) | [outside_sql] |
@@ -329,12 +760,13 @@ Placeholders denote the names and types reported in the error. Use the concrete
 | `FunctionQualification` | `outside_sql` | Schema-qualified function names are not supported | [outside_sql] |
 | `GroupingField` | `outside_sql` | Grouping-set keys must be direct field references | [outside_sql] |
 | `GroupingKeyType` | `outside_sql` | DISTINCT grouping-set keys must be TEXT or DOUBLE fields | [outside_sql] |
+| `GroupingMaskShape` | `outside_sql` | GROUPING requires direct mask projections, 1 to 31 direct grouping keys, an aggregate projection and at most 32 grouping branches; HAVING and DISTINCT are not supported | [outside_sql] |
 | `HavingAggregateMath` | `outside_sql` | Math over aggregates in HAVING requires a grouped subquery; compute the aggregate then filter its output with WHERE | [outside_sql] |
 | `HavingRewrite` | `outside_sql` | This HAVING expression has no supported equivalent subquery rewrite | [outside_sql] |
 | `HavingSubquery` | `outside_sql` | HAVING subqueries require ordinary GROUP BY, no CTE or window, and output-name or ordinal ordering | [outside_sql] |
 | `JoinAliases` | `outside_sql` | JOIN aliases, NATURAL JOIN, and JOIN USING aliases are not supported | [outside_sql] |
 | `JoinKind` | `outside_sql` | Only INNER, LEFT, RIGHT, FULL, and CROSS JOIN are supported | [outside_sql] |
-| `JoinMembership` | `outside_sql` | JOIN membership requires inner-only joins or a two-source LEFT JOIN with qualified side-local predicates | [outside_sql] |
+| `JoinMembership` | `outside_sql` | JOIN membership requires inner-only joins or a two-source LEFT JOIN with qualified side-local predicates; LEFT JOIN also requires explicit column references without wildcards or scalar subqueries | [outside_sql] |
 | `JoinNesting` | `outside_sql` | Right-nested or aliased JOIN groups are not supported | [outside_sql] |
 | `JoinUsingName` | `outside_sql` | JOIN USING requires valid column names | [outside_sql] |
 | `LiteralKind` | `outside_sql` | This literal form is not supported | [outside_sql] |
@@ -345,21 +777,31 @@ Placeholders denote the names and types reported in the error. Use the concrete
 | `MembershipOperand` | `outside_sql` | A membership operand must be a column, literal, or parameter | [outside_sql] |
 | `MembershipSource` | `outside_sql` | This membership source requires a FROM relation | [outside_sql] |
 | `MixedOuterJoin` | `outside_sql` | RIGHT or FULL JOIN cannot be mixed with comma-separated FROM groups; use one explicit JOIN chain | [outside_sql] |
+| `NaturalInnerShape` | `outside_sql` | NATURAL INNER JOIN requires exactly two physical tables with unique common scalar column names and matching types | [outside_sql] |
 | `NestedMembership` | `outside_sql` | A membership operand cannot contain nested subqueries | [outside_sql] |
 | `NestedScalar` | `outside_sql` | Nested scalar subquery operands are not supported | [outside_sql] |
+| `NestedWindowShape` | `outside_sql` | Aggregate windows require a single grouping level and aggregate or grouping-column inputs | [outside_sql] |
 | `NotArity` | `outside_sql` | NOT requires one operand | [outside_sql] |
 | `NthValueArity` | `outside_sql` | NTH_VALUE requires two arguments | [outside_sql] |
 | `NthValueShape` | `outside_sql` | NTH_VALUE requires a direct projection over one table, a positive literal index, numeric or TEXT values, and stable ordering including rec_id | [outside_sql] |
+| `NumericTextDomain` | `outside_sql` | Numeric to TEXT conversion requires an integer literal with an optional sign in the range [-999999999999999, 999999999999999] | [outside_sql] |
 | `ObjectMember` | `outside_sql` | Object member access requires exactly one field in the form (expression).field | [outside_sql] |
 | `ObjectSubscript` | `outside_sql` | Array subscripts and empty object member names are not supported | [outside_sql] |
 | `OperatorMissing` | `outside_sql` | An operator name is required | [outside_sql] |
 | `OrderItem` | `outside_sql` | This ORDER BY item is not supported | [outside_sql] |
 | `OrderUsing` | `outside_sql` | ORDER BY USING is not supported | [outside_sql] |
+| `OrderedArrayDomain` | `outside_sql` | Ordered ARRAY_AGG requires a provably non-NULL TEXT or numeric input, direct sort keys and a direct aggregate projection; DISTINCT, FILTER, windows and grouping sets are not supported | [outside_sql] |
+| `OrderedStringAggregateShape` | `outside_sql` | Ordered STRING_AGG supports direct aggregate projections and grouping columns, TEXT input, a literal non-NULL separator and at most 32 direct sort keys; HAVING, DISTINCT, FILTER, windows and grouping sets are not supported | [outside_sql] |
+| `PercentileDomain` | `outside_sql` | PERCENTILE_CONT requires a constant fraction between 0 and 1 and one numeric ordering expression; DISTINCT, FILTER and windows are not supported | [outside_sql] |
+| `PowerExactDomain` | `outside_sql` | POWER requires a safe integer double precision literal of zero or a signed power of two, an integer exponent from -16 to 16, and safe integer products; negative exponents require a nonzero base | [outside_sql] |
 | `RecursiveShape` | `outside_sql` | A recursive CTE requires UNION or UNION ALL between its anchor and recursive term | [outside_sql] |
+| `RegexLiteralForm` | `outside_sql` | Regular expressions require a nonempty literal pattern without metacharacters and a literal global replacement, or a literal SIMILAR TO prefix | [outside_sql] |
+| `RowEqualityShape` | `outside_sql` | Row equality requires matching rows of 2 to 8 scalar elements and at most 32 IN alternatives; only columns, parameters, literals and deterministic arithmetic are supported | [outside_sql] |
 | `RowKeyType` | `outside_sql` | Row IN requires TEXT or DOUBLE keys; NOT IN also requires non-null keys on both sides | [outside_sql] |
 | `RowLock` | `outside_sql` | SELECT row locking is not supported | [outside_sql] |
 | `RowMembership` | `outside_sql` | Row membership requires an uncorrelated simple source and a top-level WHERE conjunct; nullable row NOT IN is not supported | [outside_sql] |
 | `ScalarAggregateOperand` | `outside_sql` | Scalar subquery operands require a single uncorrelated COUNT, SUM, AVG, MIN, or MAX in a non-grouped context | [outside_sql] |
+| `ScalarLateralShape` | `outside_sql` | Scalar LATERAL requires a CROSS JOIN with deterministic single-row projections and no source, filter, grouping, ordering or row limit | [outside_sql] |
 | `SelectClause` | `outside_sql` | This SELECT clause is not supported | [outside_sql] |
 | `SelectOnly` | `outside_sql` | Only SELECT statements are supported | [outside_sql] |
 | `SelectRelation` | `outside_sql` | A CTE or derived relation must contain SELECT | [outside_sql] |
@@ -371,6 +813,8 @@ Placeholders denote the names and types reported in the error. Use the concrete
 | `StarJoinUsing` | `outside_sql` | SELECT * with JOIN USING requires explicit columns or a qualified alias.* | [outside_sql] |
 | `StarQualification` | `outside_sql` | Use * or table_alias.* for a star projection | [outside_sql] |
 | `StarUnnest` | `outside_sql` | Select the UNNEST alias explicitly instead of a star projection | [outside_sql] |
+| `StaticAllForm` | `outside_sql` | ALL requires at most 32 same-type integer, text or Boolean literals, optional NULL elements, and a column or literal left operand | [outside_sql] |
+| `StaticArrayForm` | `outside_sql` | Array operations require matching integer, text or Boolean literal arrays of at most 32 elements, without NULL elements, and literal indexes | [outside_sql] |
 | `StringAggregationForm` | `outside_sql` | STRING_AGG requires a literal separator without DISTINCT, FILTER, or OVER | An equivalent SQL form preserving ordering, filtering, and duplicate behavior has not been verified. [outside_sql] |
 | `StringAggregationSeparator` | `outside_sql` | STRING_AGG requires an ASCII separator without a zero byte | Replacing the requested separator would change the result. [outside_sql] |
 | `SubqueryForm` | `outside_sql` | This subquery form is not supported | [outside_sql] |
@@ -379,16 +823,17 @@ Placeholders denote the names and types reported in the error. Use the concrete
 | `TableQualification` | `outside_sql` | Schema-qualified table names are not supported | [outside_sql] |
 | `TemporalLiteral` | `outside_sql` | Only TIMESTAMP and INTERVAL typed literals are supported | [outside_sql] |
 | `TextPosition` | `outside_sql` | Character-based text position functions are not supported | [outside_sql] |
+| `TranslateLiteralMap` | `outside_sql` | TRANSLATE requires literal equal-length Unicode mappings without duplicate or overlapping characters | [outside_sql] |
 | `TrimCharacters` | `outside_sql` | TRIM with PostgreSQL character semantics is not supported | Changing the trim spelling does not enable this operation. [outside_sql] |
+| `TruncFiniteDomain` | `outside_sql` | TRUNC requires a finite double precision literal with magnitude at most 9007199254740991, excluding negative zero and values between -1 and 0 | [outside_sql] |
 | `TypeName` | `outside_sql` | This type name is not supported | [outside_sql] |
 | `UnnestArity` | `outside_sql` | UNNEST requires exactly one argument | [outside_sql] |
-| `UnnestForm` | `outside_sql` | UNNEST WITH ORDINALITY, ROWS FROM, and column definitions are not supported | [outside_sql] |
+| `UnnestForm` | `outside_sql` | UNNEST ROWS FROM, column definitions, and excess column aliases are not supported | [outside_sql] |
 | `ValueFunction` | `outside_sql` | This SQL value function is not supported | [outside_sql] |
 | `ValueMemberKey` | `outside_sql` | Value membership requires TEXT or DOUBLE keys; computed INT keys are not supported | [outside_sql] |
 | `ValueSubqueryType` | `outside_sql` | Value subqueries require scalar numeric or TEXT operands without outer aggregates or windows | [outside_sql] |
 | `WindowInheritance` | `outside_sql` | A window cannot copy a frame or override inherited PARTITION BY or ORDER BY | [outside_sql] |
 | `WindowName` | `outside_sql` | A WINDOW definition must have a name | [outside_sql] |
-| `WithTies` | `outside_sql` | FETCH FIRST WITH TIES is not supported | [outside_sql] |
 
 ## Rewrites that must not be substituted
 
@@ -398,6 +843,3 @@ Placeholders denote the names and types reported in the error. Use the concrete
 - `SQL_UNSUPPORTED_SYNTAX`: An unqualified UNNEST recommendation can change row multiplicity; no general equivalent is proved. An equivalent SQL rewrite preserving row multiplicity has not been verified.
 - `SQL_UNSUPPORTED_SYNTAX`: Adding an arbitrary FROM relation changes row count, including on empty input. Adding an arbitrary table can change row count.
 - `SQL_INVALID_CAST`: The formatted timestamp differs by eight hours between Base SQL execution and the PostgreSQL query; do not recommend this SQL as equivalent. Calendar fields and the intended timezone must be validated before conversion; no equivalent SQL format has been verified.
-- `SQL_FUNCTION_NOT_FOUND`: Base SQL does not accept IS NOT DISTINCT FROM, which this rewrite needs to match NULL partition keys; no equivalent SQL rewrite has been verified. Preserve the first value under the intended ordering and NULL semantics.
-- `SQL_FUNCTION_NOT_FOUND`: Base SQL does not accept IS NOT DISTINCT FROM, which this rewrite needs to match NULL partition keys; no equivalent SQL rewrite has been verified. Preserve the last value under the intended ordering and NULL semantics.
-- `SQL_FUNCTION_NOT_FOUND`: Base SQL does not accept IS NOT DISTINCT FROM, which this rewrite needs to match NULL partition keys; no equivalent SQL rewrite has been verified. Preserve the requested position and return NULL for short partitions.