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