001package gudusoft.gsqlparser.ir.semantic; 002 003/** 004 * Stable identifier for a SemanticIR rejection class. One enum value 005 * per logical reject; multiple throw sites in 006 * {@code SemanticIRBuilder} may share a code when they reject the 007 * same shape from different call sites (e.g. ON/USING/etc. JOIN-side 008 * checks). 009 * 010 * <p>External callers should pattern-match on {@code DiagnosticCode} 011 * rather than parse {@link Diagnostic#getMessage()} substrings. 012 * Message text remains user-visible English and may change without 013 * notice; the enum values are the public contract. 014 * 015 * <p>Slice 67 introduces 181 values, one per row in the slice-67 016 * audit ({@code /tmp/slice67-audit.tsv} at implementation time; 017 * archived in repo history). Subsequent slices may add codes when 018 * new reject sites land; existing codes are not renamed or removed 019 * without a deprecation window. 020 * 021 * <p>Slice 77 adds one WARN-severity code 022 * ({@code RELATION_NOT_FOUND_IN_CATALOG}) emitted by 023 * {@code SqlSemanticAnalyzer.analyze(sql, vendor, Catalog)} when the 024 * supplied DTO catalog is missing a FROM relation referenced by the 025 * resolved IR. It is the first non-ERROR diagnostic; the IR is still 026 * built and {@link Diagnostic#getSeverity()} stays {@code WARN} so 027 * {@code isSuccessful()} continues to return {@code true}. 028 * 029 * <p>Slice 77 deliberately does NOT add a corresponding 030 * {@code COLUMN_NOT_FOUND_IN_CATALOG} code: when a catalog declares 031 * the relation but not a referenced column, the 032 * {@link gudusoft.gsqlparser.resolver2 TSQLResolver2} pipeline already 033 * rejects the build with {@link #COLUMN_BINDING_NON_EXACT} (a NOT_FOUND 034 * status surfaces as that ERROR). Callers needing catalog-miss column 035 * diagnostics can pattern-match on {@code COLUMN_BINDING_NON_EXACT} 036 * when a non-null {@code Catalog} was supplied. A later slice may 037 * lift the column-miss path to a dedicated WARN if customer feedback 038 * shows the ERROR-vs-WARN asymmetry is confusing. 039 * 040 * <p>Slice 78 adds four ERROR-severity codes lifting 041 * {@code INSERT INTO target SELECT ...} into the analyzer pipeline: 042 * {@link #INSERT_SOURCE_NOT_SUPPORTED} (non-subquery sources like 043 * VALUES / DEFAULT VALUES / EXECUTE), {@link #INSERT_MULTI_TABLE_NOT_SUPPORTED} 044 * (Oracle INSERT ALL / INSERT FIRST and Hive multi-insert), 045 * {@link #INSERT_COLUMN_COUNT_MISMATCH} (explicit column list arity does 046 * not match the source SELECT's output count), and 047 * {@link #INSERT_TARGET_MISSING} (defensive — INSERT without a resolvable 048 * target table). DELETE / MERGE / CREATE INDEX / CREATE PROCEDURE etc. 049 * remain rejected via {@link #STATEMENT_KIND_NOT_SUPPORTED}. 050 * 051 * <p>Slice 80 adds nine ERROR-severity codes lifting 052 * {@code UPDATE target SET c = expr [WHERE pred]} into the analyzer 053 * pipeline: {@link #UPDATE_TARGET_MISSING} (defensive), 054 * {@link #UPDATE_CTE_NOT_SUPPORTED} (top-level WITH on UPDATE), 055 * {@link #UPDATE_JOINED_NOT_SUPPORTED} 056 * (FROM / JOIN clause on UPDATE — PG / SQL Server cross-table UPDATE), 057 * {@link #UPDATE_RETURNING_CLAUSE_NOT_SUPPORTED} 058 * (PG / Oracle RETURNING projections), 059 * {@link #UPDATE_OUTPUT_CLAUSE_NOT_SUPPORTED} 060 * (SQL Server OUTPUT clause), 061 * {@link #UPDATE_ORDER_BY_OR_LIMIT_NOT_SUPPORTED} 062 * (MySQL / Couchbase ordering + row-limit on UPDATE), 063 * {@link #UPDATE_NO_SET_CLAUSE} (defensive — also covers Couchbase 064 * UNSET-only updates), {@link #UPDATE_TUPLE_ASSIGNMENT_NOT_SUPPORTED} 065 * (Oracle {@code SET (a, b) = (...)} tuple assignment), and 066 * {@link #UPDATE_SET_HAS_SUBQUERY_NOT_SUPPORTED} (scalar subquery on 067 * the right-hand side of a SET assignment). Window functions in SET 068 * RHS reuse the existing {@link #CLAUSE_WINDOW_FUNCTION_LEAK} code 069 * via the shared {@code rejectWindowFunctionInScope} helper. 070 * 071 * <p>Slice 82 lifts the slice-80 {@link #UPDATE_JOINED_NOT_SUPPORTED} 072 * reject for the common PG / MSSQL / BigQuery / Snowflake / Redshift 073 * FROM-side joined UPDATE shapes (single FROM table, comma-FROM, 074 * explicit JOIN ON, CROSS JOIN). Four new ERROR-severity codes pin the 075 * sub-shapes still deferred to a future slice: 076 * {@link #UPDATE_FROM_SUBQUERY_NOT_SUPPORTED} (subquery as a FROM 077 * source), {@link #UPDATE_FROM_JOIN_USING_NOT_SUPPORTED} (USING in any 078 * FROM-side join item), {@link #UPDATE_FROM_JOIN_NATURAL_NOT_SUPPORTED} 079 * (NATURAL JOIN in any FROM-side join item), 080 * {@link #UPDATE_FROM_NESTED_JOIN_NOT_SUPPORTED} (defensive: FROM-side 081 * TTable wraps a TJoin — distinct from the subquery case per the 082 * slice-80 message-text-discrimination contract), and 083 * {@link #UPDATE_JOIN_ON_HAS_SUBQUERY_NOT_SUPPORTED} (subquery in any 084 * ON condition). Window functions in ON reuse the existing 085 * {@link #CLAUSE_WINDOW_FUNCTION_LEAK} via 086 * {@code rejectWindowFunctionInScope}. {@link #UPDATE_JOINED_NOT_SUPPORTED} 087 * is retained declared-but-unreached for API stability (slice-71/72 088 * retain-for-documentation precedent — the residual join-form-target 089 * shape {@code UPDATE (a JOIN b) SET ...} does not parse in any 090 * supported dialect). 091 * 092 * <p>Group naming convention (clause-prefix): 093 * <ul> 094 * <li>CTE / WITH: {@code DUPLICATE_CTE_NAME}, 095 * {@code CTE_FORWARD_REFERENCE}, 096 * {@code CTE_WITH_RECURSIVE_NOT_SUPPORTED}, 097 * {@code NESTED_WITH_NOT_SUPPORTED}, {@code CTE_BODY_MISSING}</li> 098 * <li>FROM-clause subquery: {@code FROM_SUBQUERY_*}</li> 099 * <li>Scalar subquery projection: {@code SCALAR_SUBQUERY_*}, 100 * {@code CORRELATED_SCALAR_SUBQUERY_*}, 101 * {@code NESTED_SCALAR_SUBQUERY_*}</li> 102 * <li>Set-op: {@code SET_OP_*}, 103 * {@code SET_OPERATION_*}, {@code MIXED_SET_OPERATORS_*}, 104 * {@code MALFORMED_SET_OP_AST}, 105 * {@code BRANCH_COLUMN_REF_UNKNOWN_RELATION}</li> 106 * <li>ORDER BY: {@code ORDER_BY_*}, 107 * {@code ORDER_SIBLINGS_BY_*}</li> 108 * <li>SELECT row filter / limit: {@code SELECT_ROW_FILTER_*}, 109 * {@code DISTINCT_ON_NOT_SUPPORTED}, {@code ROW_LIMIT_*}</li> 110 * <li>GROUP BY / HAVING / WHERE / QUALIFY: 111 * {@code *_HAS_SUBQUERY_NOT_SUPPORTED}, {@code HAVING_*}, 112 * {@code QUALIFY_NOT_SUPPORTED}</li> 113 * <li>FROM / JOIN shape: {@code SELECT_NO_FROM_SOURCE}, 114 * {@code COMMA_FROM_*}, {@code CROSS_JOIN_*}, {@code USING_*}, 115 * {@code NATURAL_*}, {@code JOIN_*}, 116 * {@code TABLE_BINDING_UNRESOLVED}</li> 117 * <li>Merged-key (USING / NATURAL): 118 * {@code USING_KEY_NOT_DECLARED}, 119 * {@code MERGED_JOIN_AGAINST_CTE_WITH_EXPLICIT_COLUMN_LIST}, 120 * {@code UNQUALIFIED_MERGED_KEY_IN_JOIN_ON}</li> 121 * <li>JOIN ON predicate subquery: {@code JOIN_ON_*}</li> 122 * <li>Window function: {@code WINDOW_*}, 123 * {@code CLAUSE_WINDOW_FUNCTION_LEAK}</li> 124 * <li>Result column: {@code RESULT_COLUMN_*}, 125 * {@code SELECT_NO_PROJECTED_COLUMNS}</li> 126 * <li>Star expansion: {@code STAR_EXPANSION_*}</li> 127 * <li>Binding / ambiguity: {@code COLUMN_BINDING_NON_EXACT}, 128 * {@code UNQUALIFIED_COLUMN_AMBIGUOUS}, 129 * {@code OUTPUT_REFERENCES_UNKNOWN_RELATION}, 130 * {@code OUTPUT_REFERENCES_UNSUPPORTED_BINDING_KIND}</li> 131 * </ul> 132 */ 133public enum DiagnosticCode { 134 BRANCH_COLUMN_REF_UNKNOWN_RELATION, 135 CLAUSE_WINDOW_FUNCTION_LEAK, 136 COLUMN_BINDING_NON_EXACT, 137 COMMA_FROM_IN_BODY_NOT_SUPPORTED, 138 CORRELATED_SCALAR_SUBQUERY_UNKNOWN_OUTER_BINDING, 139 CREATE_AS_COLUMN_COUNT_MISMATCH, 140 CREATE_AS_NO_SOURCE_SELECT, 141 CREATE_AS_TARGET_MISSING, 142 CROSS_JOIN_IN_BODY_NOT_SUPPORTED, 143 CROSS_WITH_ON, 144 CROSS_WITH_USING, 145 CTE_BODY_MISSING, 146 /** 147 * Slice 103 — {@code WITH cte(a, b, c) AS (SELECT x, y FROM t) SELECT ...} 148 * — explicit CTE column list arity does not match the body's projection 149 * count, in a SELECT-side WITH clause. Slice 103 lifts the SELECT-side 150 * {@link StarExpansionKind#EXPLICIT_CTE_COLUMN_LIST_DEFERRED} family by 151 * routing the slice-102 rename helper through the SELECT-side CTE 152 * walker; the rename requires a 1-to-1 ordinal mapping, so both 153 * under- and over-specified lists reject with this code. 154 * 155 * <p>The parallel MERGE-side code is 156 * {@link #MERGE_CTE_EXPLICIT_COLUMN_LIST_ARITY_MISMATCH} (slice 102); 157 * the slice-103 helper carries a {@code dmlKind} discriminator and 158 * picks the right code per call site. 159 */ 160 CTE_EXPLICIT_COLUMN_LIST_ARITY_MISMATCH, 161 CTE_FORWARD_REFERENCE, 162 CTE_WITH_RECURSIVE_NOT_SUPPORTED, 163 DELETE_CTE_NOT_SUPPORTED, 164 DELETE_FROM_JOIN_NATURAL_NOT_SUPPORTED, 165 DELETE_FROM_JOIN_USING_NOT_SUPPORTED, 166 DELETE_FROM_NESTED_JOIN_NOT_SUPPORTED, 167 DELETE_JOINED_NOT_SUPPORTED, 168 DELETE_JOIN_ON_HAS_SUBQUERY_NOT_SUPPORTED, 169 DELETE_ORDER_BY_OR_LIMIT_NOT_SUPPORTED, 170 DELETE_OUTPUT_CLAUSE_NOT_SUPPORTED, 171 DELETE_RETURNING_CLAUSE_NOT_SUPPORTED, 172 DELETE_TARGET_MISSING, 173 /** 174 * Slice 111 — DELETE WHERE-side {@code EXISTS (SELECT 1 FROM r WHERE …)} 175 * was admitted by the slice-23+ predicate-subquery walker but the 176 * inner relation is missing (cannot resolve a producer for any column 177 * referenced inside the EXISTS body). Parallel to slice-110 178 * {@link #UPDATE_WHERE_EXISTS_BODY_MISSING}. 179 */ 180 DELETE_WHERE_EXISTS_BODY_MISSING, 181 /** 182 * Slice 111 — DELETE WHERE-side correlated {@code EXISTS} body 183 * references an outer alias the walker cannot resolve in the 184 * DELETE's scope. Parallel to slice-110 185 * {@link #UPDATE_WHERE_EXISTS_CORRELATED_UNKNOWN_OUTER_ALIAS}. 186 */ 187 DELETE_WHERE_EXISTS_CORRELATED_UNKNOWN_OUTER_ALIAS, 188 /** 189 * Slice 111 — DELETE WHERE-side {@code EXISTS} body has a relation 190 * the walker cannot resolve (no producer for the inner SELECT's 191 * FROM-list). Parallel to slice-110 192 * {@link #UPDATE_WHERE_EXISTS_INNER_RELATION_UNKNOWN}. 193 */ 194 DELETE_WHERE_EXISTS_INNER_RELATION_UNKNOWN, 195 /** 196 * Slice 111 — DELETE WHERE-side predicate has an outer-shape the 197 * walker cannot lift to an uncorrelated body extraction 198 * (e.g., tuple LHS in IN-SELECT, mixed operands). Parallel to 199 * slice-110 {@link #UPDATE_WHERE_OUTER_SHAPE_REJECTED}. 200 */ 201 DELETE_WHERE_OUTER_SHAPE_REJECTED, 202 /** 203 * Slice 111 — DELETE WHERE-side predicate-subquery shape is not 204 * supported by the slice-23+ walker (generic catch-all when no more 205 * specific code applies). Parallel to slice-110 206 * {@link #UPDATE_WHERE_PREDICATE_GENERIC_NOT_SUPPORTED}. 207 */ 208 DELETE_WHERE_PREDICATE_GENERIC_NOT_SUPPORTED, 209 /** 210 * Slice 111 — DELETE WHERE-side predicate has a subquery on the 211 * LHS (not the RHS), which is not liftable in the slice-23+ 212 * walker's canonical form. Parallel to slice-110 213 * {@link #UPDATE_WHERE_PREDICATE_NOT_LIFTABLE}. 214 */ 215 DELETE_WHERE_PREDICATE_NOT_LIFTABLE, 216 /** 217 * Slice 111 — DELETE WHERE-side {@code NOT (subq-wrapper)} where 218 * the inner is not an EXISTS — the slice-23+ walker only admits 219 * NOT EXISTS. Parallel to slice-110 220 * {@link #UPDATE_WHERE_PREDICATE_NOT_NOT_SUPPORTED}. 221 */ 222 DELETE_WHERE_PREDICATE_NOT_NOT_SUPPORTED, 223 /** 224 * Slice 111 — DELETE WHERE-side scalar comparison 225 * {@code col <op> (SELECT …)} where both sides are subqueries (the 226 * walker only admits a scalar comparison with a single subquery 227 * operand). Parallel to slice-110 228 * {@link #UPDATE_WHERE_PREDICATE_SCALAR_COMPARISON_NOT_LIFTABLE}. 229 */ 230 DELETE_WHERE_PREDICATE_SCALAR_COMPARISON_NOT_LIFTABLE, 231 DISTINCT_ON_EMPTY_COLUMN_LIST, 232 DISTINCT_ON_HAS_SUBQUERY_NOT_SUPPORTED, 233 DISTINCT_ON_NOT_SUPPORTED, 234 DUPLICATE_CTE_NAME, 235 DUPLICATE_FROM_SUBQUERY_ALIAS, 236 DUPLICATE_OUTPUT_NAME, 237 DUPLICATE_RELATION_ALIAS, 238 FROM_SOURCE_NO_TABLE, 239 FROM_SUBQUERY_ALIAS_REQUIRED, 240 FROM_SUBQUERY_BINDING_UNRESOLVED, 241 FROM_SUBQUERY_INNER_SUBQUERY_IN_GROUP_BY, 242 FROM_SUBQUERY_INNER_SUBQUERY_IN_JOIN_ON, 243 FROM_SUBQUERY_INNER_SUBQUERY_IN_WHERE, 244 FROM_SUBQUERY_IN_BODY_CONTEXT_NOT_SUPPORTED, 245 FROM_SUBQUERY_IN_SET_OP_BRANCH_FROM, 246 FROM_SUBQUERY_NO_INNER_SELECT, 247 FROM_SUBQUERY_ON_JOIN_SIDE_IN_SET_OP_BRANCH, 248 GROUP_BY_HAS_SUBQUERY_NOT_SUPPORTED, 249 HAVING_HAS_SUBQUERY_NOT_SUPPORTED, 250 HAVING_SUBQUERY_NOT_SUPPORTED, 251 HAVING_WINDOW_FUNCTION_NOT_SUPPORTED, 252 INSERT_COLUMN_COUNT_MISMATCH, 253 INSERT_MIXED_OUTER_AND_INNER_WITH_NOT_SUPPORTED, 254 INSERT_MULTI_TABLE_NOT_SUPPORTED, 255 INSERT_OUTER_WITH_ON_HIVE_MULTI_INSERT_NOT_SUPPORTED, 256 INSERT_SOURCE_NOT_SUPPORTED, 257 INSERT_TARGET_MISSING, 258 JOIN_ITEM_NO_TABLE, 259 JOIN_MISSING_ON_OR_USING, 260 JOIN_ON_EXISTS_BODY_MISSING, 261 JOIN_ON_EXISTS_CORRELATED_UNKNOWN_OUTER_ALIAS, 262 JOIN_ON_EXISTS_INNER_COLUMN_COUNT, 263 JOIN_ON_EXISTS_INNER_COMMA_FROM, 264 JOIN_ON_EXISTS_INNER_CROSS_JOIN, 265 JOIN_ON_EXISTS_INNER_FROM_SUBQUERY, 266 JOIN_ON_EXISTS_INNER_FROM_SUBQUERY_ON_JOIN, 267 JOIN_ON_EXISTS_INNER_IS_SET_OP, 268 JOIN_ON_EXISTS_INNER_MISSING_FROM, 269 JOIN_ON_EXISTS_INNER_NATURAL, 270 JOIN_ON_EXISTS_INNER_NON_CONSTANT_PROJECTION, 271 JOIN_ON_EXISTS_INNER_RELATION_UNKNOWN, 272 JOIN_ON_EXISTS_INNER_ROW_LIMIT, 273 JOIN_ON_EXISTS_INNER_SUBQUERY_IN_GROUP_BY, 274 JOIN_ON_EXISTS_INNER_SUBQUERY_IN_JOIN_ON, 275 JOIN_ON_EXISTS_INNER_SUBQUERY_IN_WHERE, 276 JOIN_ON_EXISTS_INNER_USING, 277 JOIN_ON_EXISTS_INNER_WITH, 278 JOIN_ON_EXISTS_WITHIN_GROUP_AGGREGATE, 279 JOIN_ON_EXISTS_WITHIN_GROUP_NON_WHITELISTED, 280 JOIN_ON_OUTER_SHAPE_REJECTED, 281 JOIN_ON_PREDICATE_GENERIC_NOT_SUPPORTED, 282 JOIN_ON_PREDICATE_NOT_LIFTABLE, 283 JOIN_ON_PREDICATE_NOT_NOT_SUPPORTED, 284 JOIN_ON_PREDICATE_SCALAR_COMPARISON_NOT_LIFTABLE, 285 JOIN_ON_TOP_LEVEL_SUBQUERY_NOT_SUPPORTED, 286 JOIN_WITH_BOTH_ON_AND_USING, 287 MALFORMED_SET_OP_AST, 288 MERGED_JOIN_AGAINST_CTE_WITH_EXPLICIT_COLUMN_LIST, 289 /** 290 * Slice 102 — {@code WITH cte(a, b, c) AS (SELECT x, y FROM t) MERGE ...} 291 * — explicit CTE column list arity does not match the body's projection 292 * count. Slice 102 lifts {@link #MERGE_CTE_EXPLICIT_COLUMN_LIST_NOT_SUPPORTED} 293 * by renaming the body's output column names to the explicit list, but 294 * the rename requires a 1-to-1 ordinal mapping. Both under- and 295 * over-specified lists reject with this code. 296 */ 297 MERGE_CTE_EXPLICIT_COLUMN_LIST_ARITY_MISMATCH, 298 /** 299 * Slice 101 — {@code WITH cte(a, b) AS (...) MERGE ...} (CTE has an 300 * explicit column list) is not supported. PostgreSQL and SQL Server 301 * parsers admit this shape, but slice 101 defers because the inner CTE 302 * body's output columns are named by the inner SELECT (e.g. 303 * {@code id, name}), while the user-visible CTE columns are renamed 304 * ({@code a, b}). Slice 102 lifts this reject by rebuilding the CTE 305 * body's {@link StatementGraph} with the explicit-list names and 306 * rewriting outgoing {@link LineageRef.Kind#STATEMENT_OUTPUT} refs; 307 * the code stays declared for API stability and as a fallback for 308 * shapes the rename helper still cannot handle (none today). 309 */ 310 MERGE_CTE_EXPLICIT_COLUMN_LIST_NOT_SUPPORTED, 311 MERGE_CTE_NOT_SUPPORTED, 312 MERGE_DO_NOTHING_NOT_SUPPORTED, 313 MERGE_ERROR_LOGGING_NOT_SUPPORTED, 314 MERGE_INSERT_DEFAULT_VALUES_NOT_SUPPORTED, 315 MERGE_INSERT_VALUES_HAS_SUBQUERY_NOT_SUPPORTED, 316 MERGE_LIMIT_NOT_SUPPORTED, 317 /** 318 * Slice 97 — {@code WHEN NOT MATCHED BY SOURCE THEN INSERT (...) VALUES (...)} 319 * is parser-admitted by the MSSQL grammar even though SQL Server 320 * rejects it semantically (a row absent from source cannot 321 * INSERT into source). Semantic IR rejects to surface the 322 * SQL Server semantic invariant rather than silently producing 323 * lineage for an impossible action. 324 */ 325 MERGE_NOT_MATCHED_BY_SOURCE_INSERT_NOT_VALID, 326 /** 327 * Slice 97 — {@code WHEN NOT MATCHED BY SOURCE} branches must not 328 * reference source columns: there is no matching source row. 329 * Fires when SET RHS, per-WHEN AND condition, or a nested 330 * expression contains a column ref whose alias matches the 331 * USING source alias / qualified name. 332 */ 333 MERGE_NOT_MATCHED_BY_SOURCE_REFERENCES_SOURCE, 334 MERGE_ON_CONDITION_MISSING, 335 MERGE_RETURNING_CLAUSE_NOT_SUPPORTED, 336 MERGE_SOURCE_NOT_SUPPORTED, 337 MERGE_TARGET_MISSING, 338 MERGE_UPDATE_DELETE_WHERE_NOT_SUPPORTED, 339 MERGE_USING_SOURCE_MISSING, 340 MERGE_WHEN_CONDITION_HAS_SUBQUERY_NOT_SUPPORTED, 341 MERGE_WHEN_NOT_MATCHED_BY_SOURCE_NOT_SUPPORTED, 342 MERGE_WHEN_NO_ACTION, 343 MIXED_SET_OPERATORS_NOT_SUPPORTED, 344 MULTIPLE_STATEMENTS_NOT_SUPPORTED, 345 NATURAL_CATALOG_REQUIRED, 346 NATURAL_IN_BODY_NOT_SUPPORTED, 347 NATURAL_WITH_ON, 348 NATURAL_WITH_USING, 349 /** 350 * A {@code NATURAL} join or a {@code JOIN ... USING (...)} whose right 351 * operand is a parenthesized / nested {@code <joined_table>} rather than a 352 * single table, e.g. {@code a NATURAL JOIN (b JOIN c ON …)} or 353 * {@code a JOIN (b JOIN c ON …) USING (id)}. Merged-key inference needs a 354 * single right table to key against; computing it over a nested join's 355 * combined row type is not supported yet. Plain {@code ON} / {@code CROSS} 356 * joins over a nested operand ARE supported. 357 */ 358 NESTED_JOIN_MERGED_KEY_NOT_SUPPORTED, 359 NESTED_SCALAR_SUBQUERY_IN_PROJECTION, 360 NESTED_WITH_NOT_SUPPORTED, 361 ORDER_BY_CONSTANT_NOT_SUPPORTED, 362 ORDER_BY_FETCH_FIRST_NOT_SUPPORTED, 363 ORDER_BY_HAS_SUBQUERY_NOT_SUPPORTED, 364 ORDER_BY_NAME_NOT_MATCHED_IN_SET_OP_OUTPUT, 365 ORDER_BY_NO_PHYSICAL_COLUMN_REFS, 366 ORDER_BY_OBJECT_REFERENCE_NO_USABLE_NAME, 367 ORDER_BY_OBJECT_REFERENCE_UNSUPPORTED, 368 ORDER_BY_OFFSET_NOT_SUPPORTED, 369 ORDER_BY_ORDINAL_NOT_SUPPORTED, 370 ORDER_BY_ORDINAL_OUT_OF_RANGE, 371 ORDER_BY_PROJECTION_ALIAS_NOT_SUPPORTED, 372 ORDER_BY_QUALIFIED_REFERENCE_NOT_SUPPORTED, 373 ORDER_BY_RESET_WHEN_NOT_SUPPORTED, 374 ORDER_BY_SUBQUERY_NOT_SUPPORTED, 375 ORDER_BY_UNSUPPORTED_SORT_KEY_SHAPE, 376 ORDER_BY_WINDOW_FUNCTION_NOT_SUPPORTED, 377 ORDER_SIBLINGS_BY_NOT_SUPPORTED, 378 OUTPUT_DELETED_ON_INSERT_NOT_SUPPORTED, 379 OUTPUT_INSERTED_ON_DELETE_NOT_SUPPORTED, 380 OUTPUT_INTO_NOT_SUPPORTED, 381 OUTPUT_REFERENCES_UNKNOWN_RELATION, 382 OUTPUT_REFERENCES_UNSUPPORTED_BINDING_KIND, 383 PARSE_FAILED, 384 // Slice 129 — PIVOT sub-slice (a) deferrals. The builder admits a PIVOT 385 // over a base-table source with an explicit (non-*) projection and no 386 // other query clauses; everything else defers with one of these. 387 PIVOT_MULTIPLE_CLAUSES_NOT_SUPPORTED, 388 // Slice 133 — PIVOT sub-slice (b2-pivot): bare SELECT * over a 389 // lineage-enabled (single-agg / static-IN) PIVOT is now expanded from the 390 // source table's catalog column list. This code fires when that catalog 391 // metadata is absent (no Catalog supplied to SqlSemanticAnalyzer); supply 392 // one via SqlSemanticAnalyzer.analyze(sql, vendor, catalog). Mirrors 393 // RETURNING_STAR_CATALOG_REQUIRED (slice 90). 394 PIVOT_STAR_CATALOG_REQUIRED, 395 PIVOT_STAR_NOT_SUPPORTED, 396 PIVOT_SUBQUERY_SOURCE_NOT_SUPPORTED, 397 PIVOT_UNPIVOT_NOT_SUPPORTED, 398 PIVOT_WITH_QUERY_CLAUSE_NOT_SUPPORTED, 399 QUALIFY_NOT_SUPPORTED, 400 RELATION_NOT_FOUND_IN_CATALOG, 401 RESULT_COLUMN_NO_COLUMN_REFS, 402 RESULT_COLUMN_NO_NAME, 403 RESULT_COLUMN_NULL_EXPRESSION, 404 RESULT_COLUMN_SCALAR_SUBQUERY_EMBEDDED, 405 RETURNING_EMPTY_PROJECTION, 406 RETURNING_HAS_AGGREGATE_NOT_SUPPORTED, 407 RETURNING_HAS_SUBQUERY_NOT_SUPPORTED, 408 RETURNING_INTO_NOT_SUPPORTED, 409 RETURNING_STAR_CATALOG_REQUIRED, 410 RETURNING_STAR_NOT_SUPPORTED, 411 RETURNING_STAR_QUALIFIER_UNKNOWN, 412 ROW_LIMIT_COUNT_UNRESOLVED, 413 ROW_LIMIT_FETCH_FIRST_NOT_SUPPORTED, 414 ROW_LIMIT_HIVE_LIMIT_GRAMMAR_QUIRK, 415 ROW_LIMIT_LIMIT_NOT_SUPPORTED, 416 ROW_LIMIT_OFFSET_NOT_SUPPORTED, 417 ROW_LIMIT_TOP_NOT_SUPPORTED, 418 ROW_LIMIT_TOP_PERCENT_NOT_SUPPORTED, 419 ROW_LIMIT_TOP_WITH_TIES_NOT_SUPPORTED, 420 SCALAR_SUBQUERY_ALIAS_REQUIRED, 421 SCALAR_SUBQUERY_COLUMN_COUNT, 422 SCALAR_SUBQUERY_INNER_PROJECTION_UNNAMED, 423 SCALAR_SUBQUERY_INNER_SUBQUERY_IN_GROUP_BY, 424 SCALAR_SUBQUERY_INNER_SUBQUERY_IN_JOIN_ON, 425 SCALAR_SUBQUERY_INNER_SUBQUERY_IN_WHERE, 426 SCALAR_SUBQUERY_NO_INNER_SELECT, 427 SCALAR_SUBQUERY_UNKNOWN_RELATION_ALIAS, 428 SELECT_NO_FROM_SOURCE, 429 SELECT_NO_PROJECTED_COLUMNS, 430 SELECT_ROW_FILTER_NOT_SUPPORTED, 431 SELECT_ROW_FILTER_NULL, 432 SELECT_ROW_FILTER_UNKNOWN, 433 /** 434 * Slice 112 — top-level SELECT WHERE-side {@code EXISTS} body is 435 * empty (parser-level shape with no inner SELECT). Parallel to 436 * slice-110 {@link #UPDATE_WHERE_EXISTS_BODY_MISSING} / 437 * slice-111 {@link #DELETE_WHERE_EXISTS_BODY_MISSING}. 438 */ 439 SELECT_WHERE_EXISTS_BODY_MISSING, 440 /** 441 * Slice 112 — top-level SELECT WHERE-side correlated {@code EXISTS} 442 * body references an outer alias the walker cannot resolve in the 443 * SELECT's scope. Parallel to slice-110 444 * {@link #UPDATE_WHERE_EXISTS_CORRELATED_UNKNOWN_OUTER_ALIAS} / 445 * slice-111 {@link #DELETE_WHERE_EXISTS_CORRELATED_UNKNOWN_OUTER_ALIAS}. 446 */ 447 SELECT_WHERE_EXISTS_CORRELATED_UNKNOWN_OUTER_ALIAS, 448 /** 449 * Slice 112 — top-level SELECT WHERE-side {@code EXISTS} body has 450 * a relation the walker cannot resolve (no producer for the inner 451 * SELECT's FROM-list). Parallel to slice-110 452 * {@link #UPDATE_WHERE_EXISTS_INNER_RELATION_UNKNOWN} / 453 * slice-111 {@link #DELETE_WHERE_EXISTS_INNER_RELATION_UNKNOWN}. 454 */ 455 SELECT_WHERE_EXISTS_INNER_RELATION_UNKNOWN, 456 /** 457 * Slice 112 — top-level SELECT WHERE-side predicate has an 458 * outer-shape the walker cannot lift to an uncorrelated body 459 * extraction (e.g., tuple LHS in IN-SELECT, mixed operands). 460 * Parallel to slice-110 {@link #UPDATE_WHERE_OUTER_SHAPE_REJECTED} 461 * / slice-111 {@link #DELETE_WHERE_OUTER_SHAPE_REJECTED}. 462 */ 463 SELECT_WHERE_OUTER_SHAPE_REJECTED, 464 /** 465 * Slice 112 — top-level SELECT WHERE-side predicate-subquery 466 * shape is not supported by the slice-23+ walker (generic 467 * catch-all when no more specific code applies). Parallel to 468 * slice-110 {@link #UPDATE_WHERE_PREDICATE_GENERIC_NOT_SUPPORTED} 469 * / slice-111 {@link #DELETE_WHERE_PREDICATE_GENERIC_NOT_SUPPORTED}. 470 */ 471 SELECT_WHERE_PREDICATE_GENERIC_NOT_SUPPORTED, 472 /** 473 * Slice 112 — top-level SELECT WHERE-side predicate has a 474 * subquery on the LHS (not the RHS), which is not liftable in the 475 * slice-23+ walker's canonical form. Parallel to slice-110 476 * {@link #UPDATE_WHERE_PREDICATE_NOT_LIFTABLE} / slice-111 477 * {@link #DELETE_WHERE_PREDICATE_NOT_LIFTABLE}. 478 */ 479 SELECT_WHERE_PREDICATE_NOT_LIFTABLE, 480 /** 481 * Slice 112 — top-level SELECT WHERE-side 482 * {@code NOT (subq-wrapper)} where the inner is not an EXISTS — 483 * the slice-23+ walker only admits NOT EXISTS. Parallel to 484 * slice-110 {@link #UPDATE_WHERE_PREDICATE_NOT_NOT_SUPPORTED} / 485 * slice-111 {@link #DELETE_WHERE_PREDICATE_NOT_NOT_SUPPORTED}. 486 */ 487 SELECT_WHERE_PREDICATE_NOT_NOT_SUPPORTED, 488 /** 489 * Slice 112 — top-level SELECT WHERE-side scalar comparison 490 * {@code col <op> (SELECT …)} where both sides are subqueries 491 * (the walker only admits a scalar comparison with a single 492 * subquery operand). Parallel to slice-110 493 * {@link #UPDATE_WHERE_PREDICATE_SCALAR_COMPARISON_NOT_LIFTABLE} 494 * / slice-111 495 * {@link #DELETE_WHERE_PREDICATE_SCALAR_COMPARISON_NOT_LIFTABLE}. 496 */ 497 SELECT_WHERE_PREDICATE_SCALAR_COMPARISON_NOT_LIFTABLE, 498 SET_OPERATION_NOT_SUPPORTED_IN_CONTEXT, 499 SET_OP_BRANCH_COLUMN_COUNT_MISMATCH, 500 SET_OP_BRANCH_COUNT_TOO_FEW, 501 SET_OP_BRANCH_DUPLICATE_OUTPUT_NAME, 502 SET_OP_BRANCH_IS_SET_OP, 503 SET_OP_BRANCH_OUTPUT_NAME_UNUSABLE, 504 SET_OP_DUPLICATE_OUTER_OUTPUT_NAME, 505 SET_OP_NON_ROOT_ORDER_BY_NOT_SUPPORTED, 506 SET_OP_ORDER_BY_BRANCH_OUTPUT_NO_SOURCES, 507 SET_OP_OUTER_ORDER_BY_NO_PHYSICAL_COLUMN_REFS, 508 SET_OP_ROOT_TYPE_NONE, 509 SET_OP_ROOT_TYPE_NULL, 510 SET_OP_ROW_LIMIT_NOT_SUPPORTED, 511 SET_OP_UNKNOWN_OPERATOR_TYPE, 512 STAR_EXPANSION_EXPLICIT_CTE_COLUMN_LIST, 513 STAR_EXPANSION_MULTI_RELATION_FROM, 514 STAR_EXPANSION_NON_BASE_TABLE, 515 STAR_EXPANSION_NO_CATALOG, 516 STAR_EXPANSION_NO_INSCOPE_RELATION_COLUMNS, 517 STAR_EXPANSION_PREDICATE_BODY, 518 STAR_EXPANSION_QUALIFIER_AMBIGUOUS, 519 STAR_EXPANSION_QUALIFIER_NOT_FOUND, 520 STAR_EXPANSION_SYNTHETIC_BODY, 521 STAR_EXPANSION_UNHANDLED_KIND, 522 STATEMENT_KIND_NOT_SUPPORTED, 523 TABLE_BINDING_UNRESOLVED, 524 UNQUALIFIED_COLUMN_AMBIGUOUS, 525 UNQUALIFIED_MERGED_KEY_IN_JOIN_ON, 526 UNSUPPORTED_JOIN_TYPE, 527 UPDATE_CTE_NOT_SUPPORTED, 528 UPDATE_FROM_JOIN_NATURAL_NOT_SUPPORTED, 529 UPDATE_FROM_JOIN_USING_NOT_SUPPORTED, 530 UPDATE_FROM_NESTED_JOIN_NOT_SUPPORTED, 531 UPDATE_FROM_SUBQUERY_NOT_SUPPORTED, 532 UPDATE_JOINED_NOT_SUPPORTED, 533 UPDATE_JOIN_ON_HAS_SUBQUERY_NOT_SUPPORTED, 534 UPDATE_NO_SET_CLAUSE, 535 UPDATE_ORDER_BY_OR_LIMIT_NOT_SUPPORTED, 536 UPDATE_OUTPUT_CLAUSE_NOT_SUPPORTED, 537 UPDATE_RETURNING_CLAUSE_NOT_SUPPORTED, 538 UPDATE_SET_HAS_SUBQUERY_NOT_SUPPORTED, 539 UPDATE_TARGET_MISSING, 540 UPDATE_TUPLE_ASSIGNMENT_NOT_SUPPORTED, 541 UPDATE_WHERE_EXISTS_BODY_MISSING, 542 UPDATE_WHERE_EXISTS_CORRELATED_UNKNOWN_OUTER_ALIAS, 543 UPDATE_WHERE_EXISTS_INNER_RELATION_UNKNOWN, 544 UPDATE_WHERE_OUTER_SHAPE_REJECTED, 545 UPDATE_WHERE_PREDICATE_GENERIC_NOT_SUPPORTED, 546 UPDATE_WHERE_PREDICATE_NOT_LIFTABLE, 547 UPDATE_WHERE_PREDICATE_NOT_NOT_SUPPORTED, 548 UPDATE_WHERE_PREDICATE_SCALAR_COMPARISON_NOT_LIFTABLE, 549 USING_IN_BODY_NOT_SUPPORTED, 550 USING_KEY_NOT_DECLARED, 551 WHERE_HAS_SUBQUERY_NOT_SUPPORTED, 552 WINDOW_CLUSTER_BY_NOT_SUPPORTED, 553 WINDOW_DISTRIBUTE_BY_NOT_SUPPORTED, 554 WINDOW_EMPTY_OVER_NOT_SUPPORTED, 555 WINDOW_FILTER_NOT_SUPPORTED, 556 WINDOW_FRAME_EXCLUDE_NOT_SUPPORTED, 557 WINDOW_FRAME_NULL_BOUNDARY_TYPE, 558 WINDOW_FRAME_NULL_LIMIT_ROW_TYPE, 559 WINDOW_FRAME_NULL_START_BOUNDARY, 560 WINDOW_FRAME_OFFSET_NON_CONSTANT, 561 WINDOW_FRAME_UNEXPECTED_OFFSET, 562 WINDOW_FRAME_UNSUPPORTED_BOUNDARY_TYPE, 563 WINDOW_FRAME_UNSUPPORTED_LIMIT_ROW_TYPE, 564 WINDOW_FUNCTION_AS_PROJECTION_NOT_SUPPORTED, 565 WINDOW_FUNCTION_EMBEDDED_NOT_SUPPORTED, 566 WINDOW_FUNCTION_LEVEL_ORDER_BY_NOT_SUPPORTED, 567 WINDOW_FUNCTION_LEVEL_SORT_NOT_SUPPORTED, 568 WINDOW_FUNCTION_UNSUPPORTED, 569 WINDOW_FUNCTION_USED_NOT_SUPPORTED, 570 WINDOW_KEEP_DENSE_RANK_NOT_SUPPORTED, 571 WINDOW_NAMED_WINDOW_DECLARATION_NOT_SUPPORTED, 572 WINDOW_NAMED_WINDOW_REFERENCE_NOT_SUPPORTED, 573 WINDOW_OVER_ORDER_BY_AGGREGATE, 574 WINDOW_OVER_ORDER_BY_CALCULATED_ALIAS, 575 WINDOW_OVER_ORDER_BY_ITEM_UNUSABLE, 576 WINDOW_OVER_ORDER_BY_LITERAL, 577 WINDOW_OVER_ORDER_BY_NULL_SORT_KEY, 578 WINDOW_OVER_ORDER_BY_RESET_WHEN_NOT_SUPPORTED, 579 WINDOW_OVER_ORDER_BY_SIBLINGS_NOT_SUPPORTED, 580 WINDOW_OVER_ORDER_BY_SUBQUERY, 581 WINDOW_OVER_ORDER_BY_UNKNOWN_REFERENCE, 582 WINDOW_OVER_ORDER_BY_WINDOW_FUNCTION, 583 WINDOW_PARTITION_BY_AGGREGATE, 584 WINDOW_PARTITION_BY_CALCULATED_ALIAS, 585 WINDOW_PARTITION_BY_ITEM_UNUSABLE, 586 WINDOW_PARTITION_BY_LITERAL, 587 WINDOW_PARTITION_BY_PROJECTION_ALIAS, 588 WINDOW_PARTITION_BY_SORT_NOT_SUPPORTED, 589 WINDOW_PARTITION_BY_SUBQUERY, 590 WINDOW_PARTITION_BY_UNKNOWN_REFERENCE, 591 WINDOW_SORT_BY_NOT_SUPPORTED, 592 WINDOW_WITHIN_GROUP_INSIDE_PROJECTION_NOT_SUPPORTED, 593 WINDOW_WITHIN_GROUP_NOT_SUPPORTED 594}