1use std::fmt;
10
11#[derive(Clone, Copy, Eq, Hash, PartialEq)]
18pub enum DiagnosticCode {
19 QueryValidate,
20 QueryIntent,
21 QueryPlan,
22 QueryAccessRequirement,
23 QueryUnorderedPagination,
24 QueryInvalidContinuationCursor,
25 QueryNotFound,
26 QueryNotUnique,
27 QueryNumericOverflow,
28 QueryNumericNotRepresentable,
29 QueryUnknownAggregateTargetField,
30 QueryUnsupportedProjection,
31 QueryResultShapeMismatch,
32 QueryUnsupportedSqlFeature,
33 QuerySqlSurfaceMismatch,
34 QuerySqlWriteBoundary,
35 SchemaDdlAdmission,
36 StoreNotFound,
37 StoreCorruption,
38 StoreInvariantViolation,
39 RuntimeCorruption,
40 RuntimeIncompatiblePersistedFormat,
41 RuntimeInvariantViolation,
42 RuntimeConflict,
43 RuntimeNotFound,
44 RuntimeUnsupported,
45 RuntimeInternal,
46}
47
48impl DiagnosticCode {
49 #[must_use]
51 pub const fn class(self) -> ErrorClass {
52 match self {
53 Self::StoreCorruption | Self::RuntimeCorruption => ErrorClass::Corruption,
54 Self::RuntimeIncompatiblePersistedFormat => ErrorClass::IncompatiblePersistedFormat,
55 Self::QueryNotFound | Self::StoreNotFound | Self::RuntimeNotFound => {
56 ErrorClass::NotFound
57 }
58 Self::RuntimeConflict => ErrorClass::Conflict,
59 Self::QueryUnsupportedSqlFeature
60 | Self::QueryUnknownAggregateTargetField
61 | Self::QueryUnsupportedProjection
62 | Self::QueryResultShapeMismatch
63 | Self::QuerySqlSurfaceMismatch
64 | Self::QuerySqlWriteBoundary
65 | Self::RuntimeUnsupported => ErrorClass::Unsupported,
66 Self::StoreInvariantViolation | Self::RuntimeInvariantViolation => {
67 ErrorClass::InvariantViolation
68 }
69 Self::RuntimeInternal => ErrorClass::Internal,
70 Self::QueryValidate
71 | Self::QueryIntent
72 | Self::QueryPlan
73 | Self::QueryAccessRequirement
74 | Self::QueryUnorderedPagination
75 | Self::QueryInvalidContinuationCursor
76 | Self::QueryNotUnique
77 | Self::QueryNumericOverflow
78 | Self::QueryNumericNotRepresentable
79 | Self::SchemaDdlAdmission => ErrorClass::Query,
80 }
81 }
82
83 #[must_use]
85 pub const fn origin(self) -> ErrorOrigin {
86 match self {
87 Self::StoreNotFound | Self::StoreCorruption | Self::StoreInvariantViolation => {
88 ErrorOrigin::Store
89 }
90 Self::RuntimeCorruption
91 | Self::RuntimeIncompatiblePersistedFormat
92 | Self::RuntimeInvariantViolation
93 | Self::RuntimeConflict
94 | Self::RuntimeNotFound
95 | Self::RuntimeUnsupported
96 | Self::RuntimeInternal => ErrorOrigin::Runtime,
97 Self::QueryValidate
98 | Self::QueryIntent
99 | Self::QueryPlan
100 | Self::QueryAccessRequirement
101 | Self::QueryUnorderedPagination
102 | Self::QueryInvalidContinuationCursor
103 | Self::QueryNotFound
104 | Self::QueryNotUnique
105 | Self::QueryNumericOverflow
106 | Self::QueryNumericNotRepresentable
107 | Self::QueryUnknownAggregateTargetField
108 | Self::QueryUnsupportedProjection
109 | Self::QueryResultShapeMismatch
110 | Self::QueryUnsupportedSqlFeature
111 | Self::QuerySqlSurfaceMismatch
112 | Self::QuerySqlWriteBoundary
113 | Self::SchemaDdlAdmission => ErrorOrigin::Query,
114 }
115 }
116
117 #[must_use]
119 pub const fn error_code(self) -> ErrorCode {
120 match self {
121 Self::QueryValidate => ErrorCode::QUERY_VALIDATE,
122 Self::QueryIntent => ErrorCode::QUERY_INTENT,
123 Self::QueryPlan => ErrorCode::QUERY_PLAN,
124 Self::QueryAccessRequirement => ErrorCode::QUERY_ACCESS_REQUIREMENT,
125 Self::QueryUnorderedPagination => ErrorCode::QUERY_UNORDERED_PAGINATION,
126 Self::QueryInvalidContinuationCursor => ErrorCode::QUERY_INVALID_CONTINUATION_CURSOR,
127 Self::QueryNotFound => ErrorCode::QUERY_NOT_FOUND,
128 Self::QueryNotUnique => ErrorCode::QUERY_NOT_UNIQUE,
129 Self::QueryNumericOverflow => ErrorCode::QUERY_NUMERIC_OVERFLOW,
130 Self::QueryNumericNotRepresentable => ErrorCode::QUERY_NUMERIC_NOT_REPRESENTABLE,
131 Self::QueryUnknownAggregateTargetField => {
132 ErrorCode::QUERY_UNKNOWN_AGGREGATE_TARGET_FIELD
133 }
134 Self::QueryUnsupportedProjection => ErrorCode::QUERY_UNSUPPORTED_PROJECTION,
135 Self::QueryResultShapeMismatch => ErrorCode::QUERY_RESULT_SHAPE_MISMATCH,
136 Self::QueryUnsupportedSqlFeature => ErrorCode::QUERY_UNSUPPORTED_SQL_FEATURE,
137 Self::QuerySqlSurfaceMismatch => ErrorCode::QUERY_SQL_SURFACE_MISMATCH,
138 Self::QuerySqlWriteBoundary => ErrorCode::QUERY_SQL_WRITE_BOUNDARY,
139 Self::SchemaDdlAdmission => ErrorCode::SCHEMA_DDL_ADMISSION,
140 Self::StoreNotFound => ErrorCode::STORE_NOT_FOUND,
141 Self::StoreCorruption => ErrorCode::STORE_CORRUPTION,
142 Self::StoreInvariantViolation => ErrorCode::STORE_INVARIANT_VIOLATION,
143 Self::RuntimeCorruption => ErrorCode::RUNTIME_CORRUPTION,
144 Self::RuntimeIncompatiblePersistedFormat => {
145 ErrorCode::RUNTIME_INCOMPATIBLE_PERSISTED_FORMAT
146 }
147 Self::RuntimeInvariantViolation => ErrorCode::RUNTIME_INVARIANT_VIOLATION,
148 Self::RuntimeConflict => ErrorCode::RUNTIME_CONFLICT,
149 Self::RuntimeNotFound => ErrorCode::RUNTIME_NOT_FOUND,
150 Self::RuntimeUnsupported => ErrorCode::RUNTIME_UNSUPPORTED,
151 Self::RuntimeInternal => ErrorCode::RUNTIME_INTERNAL,
152 }
153 }
154}
155
156#[derive(Clone, Copy, Eq, Hash, PartialEq)]
168pub struct ErrorCode(u16);
169
170impl ErrorCode {
171 pub const QUERY_VALIDATE: Self = Self(1);
172 pub const QUERY_INTENT: Self = Self(2);
173 pub const QUERY_PLAN: Self = Self(3);
174 pub const QUERY_ACCESS_REQUIREMENT: Self = Self(4);
175 pub const QUERY_UNORDERED_PAGINATION: Self = Self(5);
176 pub const QUERY_INVALID_CONTINUATION_CURSOR: Self = Self(6);
177 pub const QUERY_NOT_FOUND: Self = Self(7);
178 pub const QUERY_NOT_UNIQUE: Self = Self(8);
179 pub const QUERY_NUMERIC_OVERFLOW: Self = Self(9);
180 pub const QUERY_NUMERIC_NOT_REPRESENTABLE: Self = Self(10);
181 pub const QUERY_UNKNOWN_AGGREGATE_TARGET_FIELD: Self = Self(11);
182 pub const QUERY_UNSUPPORTED_SQL_FEATURE: Self = Self(12);
183 pub const QUERY_SQL_SURFACE_MISMATCH: Self = Self(13);
184 pub const SCHEMA_DDL_ADMISSION: Self = Self(14);
185 pub const STORE_NOT_FOUND: Self = Self(15);
186 pub const STORE_CORRUPTION: Self = Self(16);
187 pub const STORE_INVARIANT_VIOLATION: Self = Self(17);
188 pub const RUNTIME_CORRUPTION: Self = Self(18);
189 pub const RUNTIME_INCOMPATIBLE_PERSISTED_FORMAT: Self = Self(19);
190 pub const RUNTIME_INVARIANT_VIOLATION: Self = Self(20);
191 pub const RUNTIME_CONFLICT: Self = Self(21);
192 pub const RUNTIME_NOT_FOUND: Self = Self(22);
193 pub const RUNTIME_UNSUPPORTED: Self = Self(23);
194 pub const RUNTIME_INTERNAL: Self = Self(24);
195
196 pub const RUNTIME_BOUNDARY_SQL_SURFACE_CONTROLLER_REQUIRED: Self = Self(25);
197 pub const RUNTIME_BOUNDARY_SCHEMA_SURFACE_CONTROLLER_REQUIRED: Self = Self(26);
198 pub const RUNTIME_BOUNDARY_SQL_QUERY_NO_CONFIGURED_ENTITIES: Self = Self(27);
199 pub const RUNTIME_BOUNDARY_SQL_QUERY_ENTITY_NOT_CONFIGURED: Self = Self(28);
200 pub const RUNTIME_BOUNDARY_SQL_DDL_TARGET_REQUIRED: Self = Self(29);
201 pub const RUNTIME_BOUNDARY_SQL_DDL_ENTITY_NOT_CONFIGURED: Self = Self(30);
202 pub const RUNTIME_BOUNDARY_QUERY_RESPONSE_ROWS_REQUIRED: Self = Self(31);
203 pub const RUNTIME_BOUNDARY_QUERY_RESPONSE_GROUPED_ROWS_REQUIRED: Self = Self(32);
204 pub const RUNTIME_BOUNDARY_MUTATION_RESULT_ENTITY_REQUIRED: Self = Self(33);
205 pub const RUNTIME_BOUNDARY_MUTATION_RESULT_ENTITIES_REQUIRED: Self = Self(34);
206 pub const RUNTIME_BOUNDARY_MUTATION_RESULT_ID_REQUIRED: Self = Self(35);
207 pub const RUNTIME_BOUNDARY_MUTATION_RESULT_IDS_REQUIRED: Self = Self(36);
208 pub const RUNTIME_BOUNDARY_ROW_PROJECTION_FIELD_NOT_CONFIGURED: Self = Self(37);
209
210 pub const SQL_FEATURE_AGGREGATE_FILTER_CLAUSE: Self = Self(38);
211 pub const SQL_FEATURE_ALTER_STATEMENT_BEYOND_ALTER_TABLE: Self = Self(39);
212 pub const SQL_FEATURE_ALTER_TABLE_ADD_COLUMN_DUPLICATE_DEFAULT: Self = Self(40);
213 pub const SQL_FEATURE_ALTER_TABLE_ADD_COLUMN_MODIFIERS: Self = Self(41);
214 pub const SQL_FEATURE_ALTER_TABLE_ADD_STATEMENT_BEYOND_ADD_COLUMN: Self = Self(42);
215 pub const SQL_FEATURE_ALTER_TABLE_ALTER_COLUMN_DROP_UNSUPPORTED_ACTION: Self = Self(43);
216 pub const SQL_FEATURE_ALTER_TABLE_ALTER_COLUMN_MODIFIERS: Self = Self(44);
217 pub const SQL_FEATURE_ALTER_TABLE_ALTER_COLUMN_SET_UNSUPPORTED_ACTION: Self = Self(45);
218 pub const SQL_FEATURE_ALTER_TABLE_ALTER_COLUMN_UNSUPPORTED_ACTION: Self = Self(46);
219 pub const SQL_FEATURE_ALTER_TABLE_ALTER_STATEMENT_BEYOND_ALTER_COLUMN: Self = Self(47);
220 pub const SQL_FEATURE_ALTER_TABLE_DROP_COLUMN_IF_EXISTS_SYNTAX: Self = Self(48);
221 pub const SQL_FEATURE_ALTER_TABLE_DROP_COLUMN_MODIFIERS: Self = Self(49);
222 pub const SQL_FEATURE_ALTER_TABLE_DROP_STATEMENT_BEYOND_DROP_COLUMN: Self = Self(50);
223 pub const SQL_FEATURE_ALTER_TABLE_RENAME_COLUMN_MISSING_TO: Self = Self(51);
224 pub const SQL_FEATURE_ALTER_TABLE_RENAME_COLUMN_MODIFIERS: Self = Self(52);
225 pub const SQL_FEATURE_ALTER_TABLE_RENAME_STATEMENT_BEYOND_RENAME_COLUMN: Self = Self(53);
226 pub const SQL_FEATURE_ALTER_TABLE_UNSUPPORTED_OPERATION: Self = Self(54);
227 pub const SQL_FEATURE_COLUMN_ALIAS: Self = Self(55);
228 pub const SQL_FEATURE_CREATE_INDEX_IF_NOT_EXISTS_SYNTAX: Self = Self(56);
229 pub const SQL_FEATURE_CREATE_INDEX_KEY_ORDERING_MODIFIERS: Self = Self(57);
230 pub const SQL_FEATURE_CREATE_INDEX_MODIFIERS: Self = Self(58);
231 pub const SQL_FEATURE_CREATE_STATEMENT_BEYOND_CREATE_INDEX: Self = Self(59);
232 pub const SQL_FEATURE_DESCRIBE_MODIFIER: Self = Self(60);
233 pub const SQL_FEATURE_DDL_SCHEMA_VERSION_DUPLICATE_EXPECTED_CLAUSE: Self = Self(61);
234 pub const SQL_FEATURE_DDL_SCHEMA_VERSION_DUPLICATE_SET_CLAUSE: Self = Self(62);
235 pub const SQL_FEATURE_DROP_INDEX_MODIFIERS: Self = Self(63);
236 pub const SQL_FEATURE_DROP_INDEX_IF_EXISTS_SYNTAX: Self = Self(64);
237 pub const SQL_FEATURE_DROP_STATEMENT_BEYOND_DROP_INDEX: Self = Self(65);
238 pub const SQL_FEATURE_EXPRESSION_INDEX_UNSUPPORTED_FUNCTION: Self = Self(66);
239 pub const SQL_FEATURE_HAVING: Self = Self(67);
240 pub const SQL_FEATURE_INSERT: Self = Self(68);
241 pub const SQL_FEATURE_JOIN: Self = Self(69);
242 pub const SQL_FEATURE_LIKE_PATTERN_BEYOND_TRAILING_PREFIX: Self = Self(70);
243 pub const SQL_FEATURE_LOWER_FIELD_PREDICATE_UNSUPPORTED: Self = Self(71);
244 pub const SQL_FEATURE_MULTI_STATEMENT_SQL: Self = Self(72);
245 pub const SQL_FEATURE_NESTED_AGGREGATE_INPUT: Self = Self(73);
246 pub const SQL_FEATURE_NESTED_PROJECTION_FUNCTION_IN_ARITHMETIC: Self = Self(74);
247 pub const SQL_FEATURE_ORDER_BY_UNSUPPORTED_FORM: Self = Self(75);
248 pub const SQL_FEATURE_OTHER: Self = Self(76);
249 pub const SQL_FEATURE_PARAMETER_BINDING: Self = Self(77);
250 pub const SQL_FEATURE_PARAMETERIZED_SCHEMA_VERSION: Self = Self(78);
251 pub const SQL_FEATURE_PREDICATE_STARTS_WITH_FIRST_ARGUMENT: Self = Self(79);
252 pub const SQL_FEATURE_QUOTED_IDENTIFIERS: Self = Self(80);
253 pub const SQL_FEATURE_RETURNING_UNSUPPORTED_SHAPE: Self = Self(81);
254 pub const SQL_FEATURE_SCALAR_FUNCTION_EXPRESSION_POSITION: Self = Self(82);
255 pub const SQL_FEATURE_SCALE_TAKING_NUMERIC_FUNCTION_EXPRESSION_POSITION: Self = Self(83);
256 pub const SQL_FEATURE_SEARCHED_CASE_GROUPED_ORDER_BY: Self = Self(84);
257 pub const SQL_FEATURE_SHOW_COLUMNS_MODIFIERS: Self = Self(85);
258 pub const SQL_FEATURE_SHOW_ENTITIES_MODIFIERS: Self = Self(86);
259 pub const SQL_FEATURE_SHOW_INDEXES_MODIFIERS: Self = Self(87);
260 pub const SQL_FEATURE_SHOW_MEMORY_MODIFIERS: Self = Self(88);
261 pub const SQL_FEATURE_SHOW_STORES_MODIFIERS: Self = Self(89);
262 pub const SQL_FEATURE_SHOW_UNSUPPORTED_COMMAND: Self = Self(90);
263 pub const SQL_FEATURE_SIMPLE_CASE_EXPRESSION: Self = Self(91);
264 pub const SQL_FEATURE_STANDALONE_LITERAL_PROJECTION_ITEM: Self = Self(92);
265 pub const SQL_FEATURE_SUPPORTED_GROUPED_ORDER_BY_EXPRESSION_FAMILY: Self = Self(93);
266 pub const SQL_FEATURE_SUPPORTED_ORDER_BY_EXPRESSION_FAMILY: Self = Self(94);
267 pub const SQL_FEATURE_UNION_INTERSECT_EXCEPT: Self = Self(95);
268 pub const SQL_FEATURE_UNSUPPORTED_FUNCTION_NAMESPACE: Self = Self(96);
269 pub const SQL_FEATURE_UPDATE: Self = Self(97);
270 pub const SQL_FEATURE_UPPER_FIELD_PREDICATE_UNSUPPORTED: Self = Self(98);
271 pub const SQL_FEATURE_WINDOW_FUNCTION: Self = Self(99);
272 pub const SQL_FEATURE_WITH: Self = Self(100);
273 pub const SQL_FEATURE_NUMERIC_SCALE_FUNCTION_ARGUMENTS: Self = Self(101);
274 pub const SQL_FEATURE_ORDER_BY_FIELD_NOT_ORDERABLE: Self = Self(102);
275
276 const SQL_FEATURE_DETAILS: [SqlFeatureCode; 65] = [
277 SqlFeatureCode::AggregateFilterClause,
278 SqlFeatureCode::AlterStatementBeyondAlterTable,
279 SqlFeatureCode::AlterTableAddColumnDuplicateDefault,
280 SqlFeatureCode::AlterTableAddColumnModifiers,
281 SqlFeatureCode::AlterTableAddStatementBeyondAddColumn,
282 SqlFeatureCode::AlterTableAlterColumnDropUnsupportedAction,
283 SqlFeatureCode::AlterTableAlterColumnModifiers,
284 SqlFeatureCode::AlterTableAlterColumnSetUnsupportedAction,
285 SqlFeatureCode::AlterTableAlterColumnUnsupportedAction,
286 SqlFeatureCode::AlterTableAlterStatementBeyondAlterColumn,
287 SqlFeatureCode::AlterTableDropColumnIfExistsSyntax,
288 SqlFeatureCode::AlterTableDropColumnModifiers,
289 SqlFeatureCode::AlterTableDropStatementBeyondDropColumn,
290 SqlFeatureCode::AlterTableRenameColumnMissingTo,
291 SqlFeatureCode::AlterTableRenameColumnModifiers,
292 SqlFeatureCode::AlterTableRenameStatementBeyondRenameColumn,
293 SqlFeatureCode::AlterTableUnsupportedOperation,
294 SqlFeatureCode::ColumnAlias,
295 SqlFeatureCode::CreateIndexIfNotExistsSyntax,
296 SqlFeatureCode::CreateIndexKeyOrderingModifiers,
297 SqlFeatureCode::CreateIndexModifiers,
298 SqlFeatureCode::CreateStatementBeyondCreateIndex,
299 SqlFeatureCode::DescribeModifier,
300 SqlFeatureCode::DdlSchemaVersionDuplicateExpectedClause,
301 SqlFeatureCode::DdlSchemaVersionDuplicateSetClause,
302 SqlFeatureCode::DropIndexModifiers,
303 SqlFeatureCode::DropIndexIfExistsSyntax,
304 SqlFeatureCode::DropStatementBeyondDropIndex,
305 SqlFeatureCode::ExpressionIndexUnsupportedFunction,
306 SqlFeatureCode::Having,
307 SqlFeatureCode::Insert,
308 SqlFeatureCode::Join,
309 SqlFeatureCode::LikePatternBeyondTrailingPrefix,
310 SqlFeatureCode::LowerFieldPredicateUnsupported,
311 SqlFeatureCode::MultiStatementSql,
312 SqlFeatureCode::NestedAggregateInput,
313 SqlFeatureCode::NestedProjectionFunctionInArithmetic,
314 SqlFeatureCode::OrderByUnsupportedForm,
315 SqlFeatureCode::Other,
316 SqlFeatureCode::ParameterBinding,
317 SqlFeatureCode::ParameterizedSchemaVersion,
318 SqlFeatureCode::PredicateStartsWithFirstArgument,
319 SqlFeatureCode::QuotedIdentifiers,
320 SqlFeatureCode::ReturningUnsupportedShape,
321 SqlFeatureCode::ScalarFunctionExpressionPosition,
322 SqlFeatureCode::ScaleTakingNumericFunctionExpressionPosition,
323 SqlFeatureCode::SearchedCaseGroupedOrderBy,
324 SqlFeatureCode::ShowColumnsModifiers,
325 SqlFeatureCode::ShowEntitiesModifiers,
326 SqlFeatureCode::ShowIndexesModifiers,
327 SqlFeatureCode::ShowMemoryModifiers,
328 SqlFeatureCode::ShowStoresModifiers,
329 SqlFeatureCode::ShowUnsupportedCommand,
330 SqlFeatureCode::SimpleCaseExpression,
331 SqlFeatureCode::StandaloneLiteralProjectionItem,
332 SqlFeatureCode::SupportedGroupedOrderByExpressionFamily,
333 SqlFeatureCode::SupportedOrderByExpressionFamily,
334 SqlFeatureCode::UnionIntersectExcept,
335 SqlFeatureCode::UnsupportedFunctionNamespace,
336 SqlFeatureCode::Update,
337 SqlFeatureCode::UpperFieldPredicateUnsupported,
338 SqlFeatureCode::WindowFunction,
339 SqlFeatureCode::With,
340 SqlFeatureCode::NumericScaleFunctionArguments,
341 SqlFeatureCode::OrderByFieldNotOrderable,
342 ];
343
344 pub const SQL_SURFACE_QUERY_REJECTS_INSERT: Self = Self(103);
345 pub const SQL_SURFACE_QUERY_REJECTS_UPDATE: Self = Self(104);
346 pub const SQL_SURFACE_QUERY_REJECTS_DELETE: Self = Self(105);
347 pub const SQL_SURFACE_UPDATE_REJECTS_SELECT: Self = Self(106);
348 pub const SQL_SURFACE_UPDATE_REJECTS_EXPLAIN: Self = Self(107);
349 pub const SQL_SURFACE_UPDATE_REJECTS_DESCRIBE: Self = Self(108);
350 pub const SQL_SURFACE_UPDATE_REJECTS_SHOW_INDEXES: Self = Self(109);
351 pub const SQL_SURFACE_UPDATE_REJECTS_SHOW_COLUMNS: Self = Self(110);
352 pub const SQL_SURFACE_UPDATE_REJECTS_SHOW_ENTITIES: Self = Self(111);
353 pub const SQL_SURFACE_UPDATE_REJECTS_SHOW_STORES: Self = Self(112);
354 pub const SQL_SURFACE_UPDATE_REJECTS_SHOW_MEMORY: Self = Self(113);
355
356 pub const SCHEMA_DDL_MISSING_EXPECTED_SCHEMA_VERSION: Self = Self(114);
357 pub const SCHEMA_DDL_MISSING_NEXT_SCHEMA_VERSION: Self = Self(115);
358 pub const SCHEMA_DDL_STALE_EXPECTED_SCHEMA_VERSION: Self = Self(116);
359 pub const SCHEMA_DDL_INVALID_EXPECTED_SCHEMA_VERSION: Self = Self(117);
360 pub const SCHEMA_DDL_INVALID_NEXT_SCHEMA_VERSION: Self = Self(118);
361 pub const SCHEMA_DDL_ACCEPTED_SCHEMA_CHANGE_WITHOUT_VERSION_BUMP: Self = Self(119);
362 pub const SCHEMA_DDL_EMPTY_VERSION_BUMP: Self = Self(120);
363 pub const SCHEMA_DDL_VERSION_GAP: Self = Self(121);
364 pub const SCHEMA_DDL_VERSION_ROLLBACK: Self = Self(122);
365 pub const SCHEMA_DDL_FINGERPRINT_METHOD_MISMATCH: Self = Self(123);
366 pub const SCHEMA_DDL_UNSUPPORTED_TRANSITION_CLASS: Self = Self(124);
367 pub const SCHEMA_DDL_PHYSICAL_RUNNER_MISSING: Self = Self(125);
368 pub const SCHEMA_DDL_VALIDATION_FAILED: Self = Self(126);
369 pub const SCHEMA_DDL_PUBLICATION_RACE_LOST: Self = Self(127);
370 pub const SCHEMA_DDL_INVALID_ADD_COLUMN_DEFAULT: Self = Self(128);
371 pub const SCHEMA_DDL_INVALID_ALTER_COLUMN_DEFAULT: Self = Self(129);
372 pub const SCHEMA_DDL_GENERATED_INDEX_DROP_REJECTED: Self = Self(130);
373 pub const SCHEMA_DDL_REQUIRED_DROP_DEFAULT_UNSUPPORTED: Self = Self(131);
374 pub const SCHEMA_DDL_GENERATED_FIELD_DEFAULT_CHANGE_REJECTED: Self = Self(132);
375 pub const SCHEMA_DDL_GENERATED_FIELD_NULLABILITY_CHANGE_REJECTED: Self = Self(133);
376 pub const SCHEMA_DDL_SET_NOT_NULL_VALIDATION_FAILED: Self = Self(134);
377 pub const QUERY_SQL_WRITE_BOUNDARY: Self = Self(135);
378 pub const SQL_WRITE_PRIMARY_KEY_LITERAL_SHAPE: Self = Self(136);
379 pub const SQL_WRITE_PRIMARY_KEY_LITERAL_INCOMPATIBLE: Self = Self(137);
380 pub const SQL_WRITE_MISSING_PRIMARY_KEY: Self = Self(138);
381 pub const SQL_WRITE_MISSING_REQUIRED_FIELDS: Self = Self(139);
382 pub const SQL_WRITE_EXPLICIT_MANAGED_FIELD: Self = Self(140);
383 pub const SQL_WRITE_EXPLICIT_GENERATED_FIELD: Self = Self(141);
384 pub const SQL_WRITE_INSERT_SELECT_REQUIRES_SCALAR: Self = Self(142);
385 pub const SQL_WRITE_INSERT_SELECT_AGGREGATE_PROJECTION: Self = Self(143);
386 pub const SQL_WRITE_INSERT_SELECT_WIDTH_MISMATCH: Self = Self(144);
387 pub const SQL_WRITE_UPDATE_PRIMARY_KEY_MUTATION: Self = Self(145);
388 pub const SQL_WRITE_INVALID_FIELD_LITERAL: Self = Self(146);
389 pub const SQL_WRITE_UNKNOWN_RETURNING_FIELD: Self = Self(147);
390 pub const SQL_WRITE_DUPLICATE_RETURNING_FIELD: Self = Self(148);
391 pub const SQL_WRITE_UPDATE_MISSING_WHERE_PREDICATE: Self = Self(149);
392 pub const SQL_WRITE_ORDER_BY_UNSUPPORTED_SHAPE: Self = Self(150);
393 pub const SQL_WRITE_RETURNING_RESPONSE_TOO_LARGE: Self = Self(183);
394 pub const SQL_WRITE_RETURNING_ROWS_TOO_MANY: Self = Self(184);
395 pub const QUERY_UNSUPPORTED_PROJECTION: Self = Self(151);
396 pub const QUERY_PROJECTION_NUMERIC_LITERAL_REQUIRED: Self = Self(152);
397 pub const QUERY_PROJECTION_NUMERIC_SCALE_ARGUMENTS: Self = Self(153);
398 pub const QUERY_PROJECTION_NESTED_FIELD_PATH_PREVIEW: Self = Self(154);
399 pub const QUERY_PROJECTION_CASE_CONDITION_BOOLEAN_REQUIRED: Self = Self(155);
400 pub const QUERY_PROJECTION_NUMERIC_INPUT_REQUIRED: Self = Self(156);
401 pub const QUERY_PROJECTION_TEXT_OR_BLOB_INPUT_REQUIRED: Self = Self(157);
402 pub const QUERY_PROJECTION_TEXT_INPUT_REQUIRED: Self = Self(158);
403 pub const QUERY_PROJECTION_TEXT_OR_NULL_ARGUMENT_REQUIRED: Self = Self(159);
404 pub const QUERY_PROJECTION_INTEGER_OR_NULL_ARGUMENT_REQUIRED: Self = Self(160);
405 pub const QUERY_PROJECTION_UNARY_OPERAND_INCOMPATIBLE: Self = Self(161);
406 pub const QUERY_PROJECTION_BINARY_OPERANDS_INCOMPATIBLE: Self = Self(162);
407 pub const QUERY_RESULT_SHAPE_MISMATCH: Self = Self(163);
408 pub const QUERY_RESULT_EXPECTED_ROWS: Self = Self(164);
409 pub const QUERY_RESULT_EXPECTED_GROUPED: Self = Self(165);
410 pub const SQL_LOWERING_ENTITY_MISMATCH: Self = Self(166);
411 pub const SQL_LOWERING_SELECT_PROJECTION_SHAPE: Self = Self(167);
412 pub const SQL_LOWERING_SELECT_DISTINCT: Self = Self(168);
413 pub const SQL_LOWERING_DISTINCT_ORDER_BY_PROJECTION: Self = Self(169);
414 pub const SQL_LOWERING_GLOBAL_AGGREGATE_PROJECTION: Self = Self(170);
415 pub const SQL_LOWERING_GLOBAL_AGGREGATE_GROUP_BY: Self = Self(171);
416 pub const SQL_LOWERING_SELECT_GROUP_BY_SHAPE: Self = Self(172);
417 pub const SQL_LOWERING_GROUPED_PROJECTION_EXPLICIT_LIST_REQUIRED: Self = Self(173);
418 pub const SQL_LOWERING_GROUPED_PROJECTION_AGGREGATE_REQUIRED: Self = Self(174);
419 pub const SQL_LOWERING_GROUPED_PROJECTION_NON_GROUP_FIELD: Self = Self(175);
420 pub const SQL_LOWERING_GROUPED_PROJECTION_SCALAR_AFTER_AGGREGATE: Self = Self(176);
421 pub const SQL_LOWERING_HAVING_REQUIRES_GROUP_BY: Self = Self(177);
422 pub const SQL_LOWERING_SELECT_HAVING_SHAPE: Self = Self(178);
423 pub const SQL_LOWERING_AGGREGATE_INPUT_EXPRESSIONS: Self = Self(179);
424 pub const SQL_LOWERING_WHERE_EXPRESSION_SHAPE: Self = Self(180);
425 pub const SQL_LOWERING_PARAMETER_PLACEMENT: Self = Self(181);
426 pub const SQL_LOWERING_SQL_DDL_EXECUTION_UNSUPPORTED: Self = Self(182);
427
428 #[must_use]
430 pub const fn from_raw(raw: u16) -> Self {
431 Self(raw)
432 }
433
434 #[must_use]
436 pub const fn raw(self) -> u16 {
437 self.0
438 }
439
440 #[must_use]
442 pub const fn from_parts(code: DiagnosticCode, detail: Option<DiagnosticDetail>) -> Self {
443 match detail {
444 Some(DiagnosticDetail::QueryKind { kind }) => Self::from_query_kind(kind),
445 Some(DiagnosticDetail::RuntimeKind { kind }) => Self::from_runtime_kind(kind),
446 Some(DiagnosticDetail::RuntimeBoundary { boundary }) => {
447 Self::from_runtime_boundary(boundary)
448 }
449 Some(DiagnosticDetail::SchemaDdlAdmission { reason }) => Self::from_schema_ddl(reason),
450 Some(DiagnosticDetail::UnsupportedSqlFeature { feature }) => {
451 Self::from_sql_feature(feature)
452 }
453 Some(DiagnosticDetail::SqlSurfaceMismatch { mismatch }) => {
454 Self::from_sql_surface_mismatch(mismatch)
455 }
456 Some(DiagnosticDetail::SqlWriteBoundary { boundary }) => {
457 Self::from_sql_write_boundary(boundary)
458 }
459 Some(DiagnosticDetail::QueryProjection { reason }) => {
460 Self::from_query_projection(reason)
461 }
462 Some(DiagnosticDetail::QueryResultShape { reason }) => {
463 Self::from_query_result_shape(reason)
464 }
465 Some(DiagnosticDetail::SqlLowering { reason }) => Self::from_sql_lowering(reason),
466 None => code.error_code(),
467 }
468 }
469
470 #[must_use]
472 pub const fn diagnostic_code(self) -> DiagnosticCode {
473 match self.raw() {
474 1 => DiagnosticCode::QueryValidate,
475 2 => DiagnosticCode::QueryIntent,
476 3 => DiagnosticCode::QueryPlan,
477 4 => DiagnosticCode::QueryAccessRequirement,
478 5 => DiagnosticCode::QueryUnorderedPagination,
479 6 => DiagnosticCode::QueryInvalidContinuationCursor,
480 7 => DiagnosticCode::QueryNotFound,
481 8 => DiagnosticCode::QueryNotUnique,
482 9 => DiagnosticCode::QueryNumericOverflow,
483 10 => DiagnosticCode::QueryNumericNotRepresentable,
484 11 => DiagnosticCode::QueryUnknownAggregateTargetField,
485 151..=162 => DiagnosticCode::QueryUnsupportedProjection,
486 163..=165 => DiagnosticCode::QueryResultShapeMismatch,
487 12 | 38..=102 | 166..=182 => DiagnosticCode::QueryUnsupportedSqlFeature,
488 13 | 103..=113 => DiagnosticCode::QuerySqlSurfaceMismatch,
489 14 | 114..=134 => DiagnosticCode::SchemaDdlAdmission,
490 135..=150 | 183..=184 => DiagnosticCode::QuerySqlWriteBoundary,
491 15 => DiagnosticCode::StoreNotFound,
492 16 => DiagnosticCode::StoreCorruption,
493 17 => DiagnosticCode::StoreInvariantViolation,
494 18 => DiagnosticCode::RuntimeCorruption,
495 19 => DiagnosticCode::RuntimeIncompatiblePersistedFormat,
496 20 => DiagnosticCode::RuntimeInvariantViolation,
497 21 => DiagnosticCode::RuntimeConflict,
498 22 => DiagnosticCode::RuntimeNotFound,
499 23 | 25..=37 => DiagnosticCode::RuntimeUnsupported,
500 _ => DiagnosticCode::RuntimeInternal,
501 }
502 }
503
504 #[must_use]
506 pub const fn class(self) -> ErrorClass {
507 self.diagnostic_code().class()
508 }
509
510 #[must_use]
512 pub const fn diagnostic_detail(self) -> Option<DiagnosticDetail> {
513 match self.raw() {
514 1..=8 => Self::query_kind_detail(self.raw()),
515 18..=24 => Self::runtime_kind_detail(self.raw()),
516 25..=37 => Self::runtime_boundary_detail(self.raw()),
517 38..=102 => Self::sql_feature_detail(self.raw()),
518 103..=113 => Self::sql_surface_detail(self.raw()),
519 114..=134 => Self::schema_ddl_detail(self.raw()),
520 136..=150 | 183..=184 => Self::sql_write_boundary_detail(self.raw()),
521 152..=162 => Self::query_projection_detail(self.raw()),
522 164..=165 => Self::query_result_shape_detail(self.raw()),
523 166..=182 => Self::sql_lowering_detail(self.raw()),
524 _ => None,
525 }
526 }
527
528 #[must_use]
530 pub const fn diagnostic(self, origin: ErrorOrigin) -> Diagnostic {
531 Diagnostic::new(self.diagnostic_code(), origin, self.diagnostic_detail())
532 }
533
534 const fn from_query_kind(kind: QueryErrorKind) -> Self {
535 match kind {
536 QueryErrorKind::Validate => Self::QUERY_VALIDATE,
537 QueryErrorKind::Intent => Self::QUERY_INTENT,
538 QueryErrorKind::Plan => Self::QUERY_PLAN,
539 QueryErrorKind::AccessRequirement => Self::QUERY_ACCESS_REQUIREMENT,
540 QueryErrorKind::UnorderedPagination => Self::QUERY_UNORDERED_PAGINATION,
541 QueryErrorKind::InvalidContinuationCursor => Self::QUERY_INVALID_CONTINUATION_CURSOR,
542 QueryErrorKind::NotFound => Self::QUERY_NOT_FOUND,
543 QueryErrorKind::NotUnique => Self::QUERY_NOT_UNIQUE,
544 }
545 }
546
547 const fn from_runtime_kind(kind: RuntimeErrorKind) -> Self {
548 match kind {
549 RuntimeErrorKind::Corruption => Self::RUNTIME_CORRUPTION,
550 RuntimeErrorKind::IncompatiblePersistedFormat => {
551 Self::RUNTIME_INCOMPATIBLE_PERSISTED_FORMAT
552 }
553 RuntimeErrorKind::InvariantViolation => Self::RUNTIME_INVARIANT_VIOLATION,
554 RuntimeErrorKind::Conflict => Self::RUNTIME_CONFLICT,
555 RuntimeErrorKind::NotFound => Self::RUNTIME_NOT_FOUND,
556 RuntimeErrorKind::Unsupported => Self::RUNTIME_UNSUPPORTED,
557 RuntimeErrorKind::Internal => Self::RUNTIME_INTERNAL,
558 }
559 }
560
561 const fn from_runtime_boundary(boundary: RuntimeBoundaryCode) -> Self {
562 Self(Self::RUNTIME_BOUNDARY_SQL_SURFACE_CONTROLLER_REQUIRED.raw() + boundary as u16)
563 }
564
565 const fn from_sql_feature(feature: SqlFeatureCode) -> Self {
566 Self(Self::SQL_FEATURE_AGGREGATE_FILTER_CLAUSE.raw() + feature as u16)
567 }
568
569 const fn from_sql_surface_mismatch(mismatch: SqlSurfaceMismatchCode) -> Self {
570 Self(Self::SQL_SURFACE_QUERY_REJECTS_INSERT.raw() + mismatch as u16)
571 }
572
573 const fn from_schema_ddl(reason: SchemaDdlAdmissionCode) -> Self {
574 Self(Self::SCHEMA_DDL_MISSING_EXPECTED_SCHEMA_VERSION.raw() + reason as u16)
575 }
576
577 const fn from_sql_write_boundary(boundary: SqlWriteBoundaryCode) -> Self {
578 match boundary {
579 SqlWriteBoundaryCode::ReturningResponseTooLarge => {
580 Self::SQL_WRITE_RETURNING_RESPONSE_TOO_LARGE
581 }
582 SqlWriteBoundaryCode::ReturningRowsTooMany => Self::SQL_WRITE_RETURNING_ROWS_TOO_MANY,
583 _ => Self(Self::SQL_WRITE_PRIMARY_KEY_LITERAL_SHAPE.raw() + boundary as u16),
584 }
585 }
586
587 const fn from_query_projection(reason: QueryProjectionCode) -> Self {
588 Self(Self::QUERY_PROJECTION_NUMERIC_LITERAL_REQUIRED.raw() + reason as u16)
589 }
590
591 const fn from_query_result_shape(reason: QueryResultShapeCode) -> Self {
592 Self(Self::QUERY_RESULT_EXPECTED_ROWS.raw() + reason as u16)
593 }
594
595 const fn from_sql_lowering(reason: SqlLoweringCode) -> Self {
596 Self(Self::SQL_LOWERING_ENTITY_MISMATCH.raw() + reason as u16)
597 }
598
599 const fn query_kind_detail(raw: u16) -> Option<DiagnosticDetail> {
600 match raw {
601 1 => Some(DiagnosticDetail::QueryKind {
602 kind: QueryErrorKind::Validate,
603 }),
604 2 => Some(DiagnosticDetail::QueryKind {
605 kind: QueryErrorKind::Intent,
606 }),
607 3 => Some(DiagnosticDetail::QueryKind {
608 kind: QueryErrorKind::Plan,
609 }),
610 4 => Some(DiagnosticDetail::QueryKind {
611 kind: QueryErrorKind::AccessRequirement,
612 }),
613 5 => Some(DiagnosticDetail::QueryKind {
614 kind: QueryErrorKind::UnorderedPagination,
615 }),
616 6 => Some(DiagnosticDetail::QueryKind {
617 kind: QueryErrorKind::InvalidContinuationCursor,
618 }),
619 7 => Some(DiagnosticDetail::QueryKind {
620 kind: QueryErrorKind::NotFound,
621 }),
622 8 => Some(DiagnosticDetail::QueryKind {
623 kind: QueryErrorKind::NotUnique,
624 }),
625 _ => None,
626 }
627 }
628
629 const fn runtime_kind_detail(raw: u16) -> Option<DiagnosticDetail> {
630 match raw {
631 18 => Some(DiagnosticDetail::RuntimeKind {
632 kind: RuntimeErrorKind::Corruption,
633 }),
634 19 => Some(DiagnosticDetail::RuntimeKind {
635 kind: RuntimeErrorKind::IncompatiblePersistedFormat,
636 }),
637 20 => Some(DiagnosticDetail::RuntimeKind {
638 kind: RuntimeErrorKind::InvariantViolation,
639 }),
640 21 => Some(DiagnosticDetail::RuntimeKind {
641 kind: RuntimeErrorKind::Conflict,
642 }),
643 22 => Some(DiagnosticDetail::RuntimeKind {
644 kind: RuntimeErrorKind::NotFound,
645 }),
646 23 => Some(DiagnosticDetail::RuntimeKind {
647 kind: RuntimeErrorKind::Unsupported,
648 }),
649 24 => Some(DiagnosticDetail::RuntimeKind {
650 kind: RuntimeErrorKind::Internal,
651 }),
652 _ => None,
653 }
654 }
655
656 const fn runtime_boundary_detail(raw: u16) -> Option<DiagnosticDetail> {
657 match raw {
658 25 => Some(DiagnosticDetail::RuntimeBoundary {
659 boundary: RuntimeBoundaryCode::SqlSurfaceControllerRequired,
660 }),
661 26 => Some(DiagnosticDetail::RuntimeBoundary {
662 boundary: RuntimeBoundaryCode::SchemaSurfaceControllerRequired,
663 }),
664 27 => Some(DiagnosticDetail::RuntimeBoundary {
665 boundary: RuntimeBoundaryCode::SqlQueryNoConfiguredEntities,
666 }),
667 28 => Some(DiagnosticDetail::RuntimeBoundary {
668 boundary: RuntimeBoundaryCode::SqlQueryEntityNotConfigured,
669 }),
670 29 => Some(DiagnosticDetail::RuntimeBoundary {
671 boundary: RuntimeBoundaryCode::SqlDdlTargetRequired,
672 }),
673 30 => Some(DiagnosticDetail::RuntimeBoundary {
674 boundary: RuntimeBoundaryCode::SqlDdlEntityNotConfigured,
675 }),
676 31 => Some(DiagnosticDetail::RuntimeBoundary {
677 boundary: RuntimeBoundaryCode::QueryResponseRowsRequired,
678 }),
679 32 => Some(DiagnosticDetail::RuntimeBoundary {
680 boundary: RuntimeBoundaryCode::QueryResponseGroupedRowsRequired,
681 }),
682 33 => Some(DiagnosticDetail::RuntimeBoundary {
683 boundary: RuntimeBoundaryCode::MutationResultEntityRequired,
684 }),
685 34 => Some(DiagnosticDetail::RuntimeBoundary {
686 boundary: RuntimeBoundaryCode::MutationResultEntitiesRequired,
687 }),
688 35 => Some(DiagnosticDetail::RuntimeBoundary {
689 boundary: RuntimeBoundaryCode::MutationResultIdRequired,
690 }),
691 36 => Some(DiagnosticDetail::RuntimeBoundary {
692 boundary: RuntimeBoundaryCode::MutationResultIdsRequired,
693 }),
694 37 => Some(DiagnosticDetail::RuntimeBoundary {
695 boundary: RuntimeBoundaryCode::RowProjectionFieldNotConfigured,
696 }),
697 _ => None,
698 }
699 }
700
701 const fn sql_feature_detail(raw: u16) -> Option<DiagnosticDetail> {
702 let base = Self::SQL_FEATURE_AGGREGATE_FILTER_CLAUSE.raw();
703 if raw < base {
704 return None;
705 }
706
707 let offset = (raw - base) as usize;
708 if offset < Self::SQL_FEATURE_DETAILS.len() {
709 Some(DiagnosticDetail::UnsupportedSqlFeature {
710 feature: Self::SQL_FEATURE_DETAILS[offset],
711 })
712 } else {
713 None
714 }
715 }
716
717 const fn sql_surface_detail(raw: u16) -> Option<DiagnosticDetail> {
718 match raw {
719 103 => Some(DiagnosticDetail::SqlSurfaceMismatch {
720 mismatch: SqlSurfaceMismatchCode::QueryRejectsInsert,
721 }),
722 104 => Some(DiagnosticDetail::SqlSurfaceMismatch {
723 mismatch: SqlSurfaceMismatchCode::QueryRejectsUpdate,
724 }),
725 105 => Some(DiagnosticDetail::SqlSurfaceMismatch {
726 mismatch: SqlSurfaceMismatchCode::QueryRejectsDelete,
727 }),
728 106 => Some(DiagnosticDetail::SqlSurfaceMismatch {
729 mismatch: SqlSurfaceMismatchCode::UpdateRejectsSelect,
730 }),
731 107 => Some(DiagnosticDetail::SqlSurfaceMismatch {
732 mismatch: SqlSurfaceMismatchCode::UpdateRejectsExplain,
733 }),
734 108 => Some(DiagnosticDetail::SqlSurfaceMismatch {
735 mismatch: SqlSurfaceMismatchCode::UpdateRejectsDescribe,
736 }),
737 109 => Some(DiagnosticDetail::SqlSurfaceMismatch {
738 mismatch: SqlSurfaceMismatchCode::UpdateRejectsShowIndexes,
739 }),
740 110 => Some(DiagnosticDetail::SqlSurfaceMismatch {
741 mismatch: SqlSurfaceMismatchCode::UpdateRejectsShowColumns,
742 }),
743 111 => Some(DiagnosticDetail::SqlSurfaceMismatch {
744 mismatch: SqlSurfaceMismatchCode::UpdateRejectsShowEntities,
745 }),
746 112 => Some(DiagnosticDetail::SqlSurfaceMismatch {
747 mismatch: SqlSurfaceMismatchCode::UpdateRejectsShowStores,
748 }),
749 113 => Some(DiagnosticDetail::SqlSurfaceMismatch {
750 mismatch: SqlSurfaceMismatchCode::UpdateRejectsShowMemory,
751 }),
752 _ => None,
753 }
754 }
755
756 const fn schema_ddl_detail(raw: u16) -> Option<DiagnosticDetail> {
757 match raw {
758 114 => Some(DiagnosticDetail::SchemaDdlAdmission {
759 reason: SchemaDdlAdmissionCode::MissingExpectedSchemaVersion,
760 }),
761 115 => Some(DiagnosticDetail::SchemaDdlAdmission {
762 reason: SchemaDdlAdmissionCode::MissingNextSchemaVersion,
763 }),
764 116 => Some(DiagnosticDetail::SchemaDdlAdmission {
765 reason: SchemaDdlAdmissionCode::StaleExpectedSchemaVersion,
766 }),
767 117 => Some(DiagnosticDetail::SchemaDdlAdmission {
768 reason: SchemaDdlAdmissionCode::InvalidExpectedSchemaVersion,
769 }),
770 118 => Some(DiagnosticDetail::SchemaDdlAdmission {
771 reason: SchemaDdlAdmissionCode::InvalidNextSchemaVersion,
772 }),
773 119 => Some(DiagnosticDetail::SchemaDdlAdmission {
774 reason: SchemaDdlAdmissionCode::AcceptedSchemaChangeWithoutVersionBump,
775 }),
776 120 => Some(DiagnosticDetail::SchemaDdlAdmission {
777 reason: SchemaDdlAdmissionCode::EmptyVersionBump,
778 }),
779 121 => Some(DiagnosticDetail::SchemaDdlAdmission {
780 reason: SchemaDdlAdmissionCode::VersionGap,
781 }),
782 122 => Some(DiagnosticDetail::SchemaDdlAdmission {
783 reason: SchemaDdlAdmissionCode::VersionRollback,
784 }),
785 123 => Some(DiagnosticDetail::SchemaDdlAdmission {
786 reason: SchemaDdlAdmissionCode::FingerprintMethodMismatch,
787 }),
788 124 => Some(DiagnosticDetail::SchemaDdlAdmission {
789 reason: SchemaDdlAdmissionCode::UnsupportedTransitionClass,
790 }),
791 125 => Some(DiagnosticDetail::SchemaDdlAdmission {
792 reason: SchemaDdlAdmissionCode::PhysicalRunnerMissing,
793 }),
794 126 => Some(DiagnosticDetail::SchemaDdlAdmission {
795 reason: SchemaDdlAdmissionCode::ValidationFailed,
796 }),
797 127 => Some(DiagnosticDetail::SchemaDdlAdmission {
798 reason: SchemaDdlAdmissionCode::PublicationRaceLost,
799 }),
800 128 => Some(DiagnosticDetail::SchemaDdlAdmission {
801 reason: SchemaDdlAdmissionCode::InvalidAddColumnDefault,
802 }),
803 129 => Some(DiagnosticDetail::SchemaDdlAdmission {
804 reason: SchemaDdlAdmissionCode::InvalidAlterColumnDefault,
805 }),
806 130 => Some(DiagnosticDetail::SchemaDdlAdmission {
807 reason: SchemaDdlAdmissionCode::GeneratedIndexDropRejected,
808 }),
809 131 => Some(DiagnosticDetail::SchemaDdlAdmission {
810 reason: SchemaDdlAdmissionCode::RequiredDropDefaultUnsupported,
811 }),
812 132 => Some(DiagnosticDetail::SchemaDdlAdmission {
813 reason: SchemaDdlAdmissionCode::GeneratedFieldDefaultChangeRejected,
814 }),
815 133 => Some(DiagnosticDetail::SchemaDdlAdmission {
816 reason: SchemaDdlAdmissionCode::GeneratedFieldNullabilityChangeRejected,
817 }),
818 134 => Some(DiagnosticDetail::SchemaDdlAdmission {
819 reason: SchemaDdlAdmissionCode::SetNotNullValidationFailed,
820 }),
821 _ => None,
822 }
823 }
824
825 const fn sql_write_boundary_detail(raw: u16) -> Option<DiagnosticDetail> {
826 match raw {
827 136 => Some(DiagnosticDetail::SqlWriteBoundary {
828 boundary: SqlWriteBoundaryCode::PrimaryKeyLiteralShape,
829 }),
830 137 => Some(DiagnosticDetail::SqlWriteBoundary {
831 boundary: SqlWriteBoundaryCode::PrimaryKeyLiteralIncompatible,
832 }),
833 138 => Some(DiagnosticDetail::SqlWriteBoundary {
834 boundary: SqlWriteBoundaryCode::MissingPrimaryKey,
835 }),
836 139 => Some(DiagnosticDetail::SqlWriteBoundary {
837 boundary: SqlWriteBoundaryCode::MissingRequiredFields,
838 }),
839 140 => Some(DiagnosticDetail::SqlWriteBoundary {
840 boundary: SqlWriteBoundaryCode::ExplicitManagedField,
841 }),
842 141 => Some(DiagnosticDetail::SqlWriteBoundary {
843 boundary: SqlWriteBoundaryCode::ExplicitGeneratedField,
844 }),
845 142 => Some(DiagnosticDetail::SqlWriteBoundary {
846 boundary: SqlWriteBoundaryCode::InsertSelectRequiresScalar,
847 }),
848 143 => Some(DiagnosticDetail::SqlWriteBoundary {
849 boundary: SqlWriteBoundaryCode::InsertSelectAggregateProjection,
850 }),
851 144 => Some(DiagnosticDetail::SqlWriteBoundary {
852 boundary: SqlWriteBoundaryCode::InsertSelectWidthMismatch,
853 }),
854 145 => Some(DiagnosticDetail::SqlWriteBoundary {
855 boundary: SqlWriteBoundaryCode::UpdatePrimaryKeyMutation,
856 }),
857 146 => Some(DiagnosticDetail::SqlWriteBoundary {
858 boundary: SqlWriteBoundaryCode::InvalidFieldLiteral,
859 }),
860 147 => Some(DiagnosticDetail::SqlWriteBoundary {
861 boundary: SqlWriteBoundaryCode::UnknownReturningField,
862 }),
863 148 => Some(DiagnosticDetail::SqlWriteBoundary {
864 boundary: SqlWriteBoundaryCode::DuplicateReturningField,
865 }),
866 149 => Some(DiagnosticDetail::SqlWriteBoundary {
867 boundary: SqlWriteBoundaryCode::UpdateMissingWherePredicate,
868 }),
869 150 => Some(DiagnosticDetail::SqlWriteBoundary {
870 boundary: SqlWriteBoundaryCode::WriteOrderByUnsupportedShape,
871 }),
872 183 => Some(DiagnosticDetail::SqlWriteBoundary {
873 boundary: SqlWriteBoundaryCode::ReturningResponseTooLarge,
874 }),
875 184 => Some(DiagnosticDetail::SqlWriteBoundary {
876 boundary: SqlWriteBoundaryCode::ReturningRowsTooMany,
877 }),
878 _ => None,
879 }
880 }
881
882 const fn query_projection_detail(raw: u16) -> Option<DiagnosticDetail> {
883 match raw {
884 152 => Some(DiagnosticDetail::QueryProjection {
885 reason: QueryProjectionCode::NumericLiteralRequired,
886 }),
887 153 => Some(DiagnosticDetail::QueryProjection {
888 reason: QueryProjectionCode::NumericScaleArguments,
889 }),
890 154 => Some(DiagnosticDetail::QueryProjection {
891 reason: QueryProjectionCode::NestedFieldPathPreview,
892 }),
893 155 => Some(DiagnosticDetail::QueryProjection {
894 reason: QueryProjectionCode::CaseConditionBooleanRequired,
895 }),
896 156 => Some(DiagnosticDetail::QueryProjection {
897 reason: QueryProjectionCode::NumericInputRequired,
898 }),
899 157 => Some(DiagnosticDetail::QueryProjection {
900 reason: QueryProjectionCode::TextOrBlobInputRequired,
901 }),
902 158 => Some(DiagnosticDetail::QueryProjection {
903 reason: QueryProjectionCode::TextInputRequired,
904 }),
905 159 => Some(DiagnosticDetail::QueryProjection {
906 reason: QueryProjectionCode::TextOrNullArgumentRequired,
907 }),
908 160 => Some(DiagnosticDetail::QueryProjection {
909 reason: QueryProjectionCode::IntegerOrNullArgumentRequired,
910 }),
911 161 => Some(DiagnosticDetail::QueryProjection {
912 reason: QueryProjectionCode::UnaryOperandIncompatible,
913 }),
914 162 => Some(DiagnosticDetail::QueryProjection {
915 reason: QueryProjectionCode::BinaryOperandsIncompatible,
916 }),
917 _ => None,
918 }
919 }
920
921 const fn query_result_shape_detail(raw: u16) -> Option<DiagnosticDetail> {
922 match raw {
923 164 => Some(DiagnosticDetail::QueryResultShape {
924 reason: QueryResultShapeCode::ExpectedRows,
925 }),
926 165 => Some(DiagnosticDetail::QueryResultShape {
927 reason: QueryResultShapeCode::ExpectedGroupedRows,
928 }),
929 _ => None,
930 }
931 }
932
933 const fn sql_lowering_detail(raw: u16) -> Option<DiagnosticDetail> {
934 match raw {
935 166 => Some(DiagnosticDetail::SqlLowering {
936 reason: SqlLoweringCode::EntityMismatch,
937 }),
938 167 => Some(DiagnosticDetail::SqlLowering {
939 reason: SqlLoweringCode::SelectProjectionShape,
940 }),
941 168 => Some(DiagnosticDetail::SqlLowering {
942 reason: SqlLoweringCode::SelectDistinct,
943 }),
944 169 => Some(DiagnosticDetail::SqlLowering {
945 reason: SqlLoweringCode::DistinctOrderByProjection,
946 }),
947 170 => Some(DiagnosticDetail::SqlLowering {
948 reason: SqlLoweringCode::GlobalAggregateProjection,
949 }),
950 171 => Some(DiagnosticDetail::SqlLowering {
951 reason: SqlLoweringCode::GlobalAggregateGroupBy,
952 }),
953 172 => Some(DiagnosticDetail::SqlLowering {
954 reason: SqlLoweringCode::SelectGroupByShape,
955 }),
956 173 => Some(DiagnosticDetail::SqlLowering {
957 reason: SqlLoweringCode::GroupedProjectionExplicitListRequired,
958 }),
959 174 => Some(DiagnosticDetail::SqlLowering {
960 reason: SqlLoweringCode::GroupedProjectionAggregateRequired,
961 }),
962 175 => Some(DiagnosticDetail::SqlLowering {
963 reason: SqlLoweringCode::GroupedProjectionNonGroupField,
964 }),
965 176 => Some(DiagnosticDetail::SqlLowering {
966 reason: SqlLoweringCode::GroupedProjectionScalarAfterAggregate,
967 }),
968 177 => Some(DiagnosticDetail::SqlLowering {
969 reason: SqlLoweringCode::HavingRequiresGroupBy,
970 }),
971 178 => Some(DiagnosticDetail::SqlLowering {
972 reason: SqlLoweringCode::SelectHavingShape,
973 }),
974 179 => Some(DiagnosticDetail::SqlLowering {
975 reason: SqlLoweringCode::AggregateInputExpressions,
976 }),
977 180 => Some(DiagnosticDetail::SqlLowering {
978 reason: SqlLoweringCode::WhereExpressionShape,
979 }),
980 181 => Some(DiagnosticDetail::SqlLowering {
981 reason: SqlLoweringCode::ParameterPlacement,
982 }),
983 182 => Some(DiagnosticDetail::SqlLowering {
984 reason: SqlLoweringCode::SqlDdlExecutionUnsupported,
985 }),
986 _ => None,
987 }
988 }
989}
990
991impl fmt::Debug for ErrorCode {
992 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
993 fmt_compact_code(f, self.raw())
994 }
995}
996
997#[repr(u16)]
1004#[derive(Clone, Copy, Eq, Hash, PartialEq)]
1005pub enum ErrorClass {
1006 Query,
1007 Corruption,
1008 IncompatiblePersistedFormat,
1009 NotFound,
1010 Internal,
1011 Conflict,
1012 Unsupported,
1013 InvariantViolation,
1014}
1015
1016#[repr(u16)]
1023#[derive(Clone, Copy, Eq, Hash, PartialEq)]
1024pub enum ErrorOrigin {
1025 Cursor,
1026 Executor,
1027 Identity,
1028 Index,
1029 Interface,
1030 Planner,
1031 Query,
1032 Recovery,
1033 Response,
1034 Runtime,
1035 Serialize,
1036 Store,
1037}
1038
1039#[repr(u16)]
1046#[derive(Clone, Copy, Eq, Hash, PartialEq)]
1047pub enum QueryErrorKind {
1048 Validate,
1049 Intent,
1050 Plan,
1051 AccessRequirement,
1052 UnorderedPagination,
1053 InvalidContinuationCursor,
1054 NotFound,
1055 NotUnique,
1056}
1057
1058#[repr(u16)]
1065#[derive(Clone, Copy, Eq, Hash, PartialEq)]
1066pub enum QueryProjectionCode {
1067 NumericLiteralRequired,
1068 NumericScaleArguments,
1069 NestedFieldPathPreview,
1070 CaseConditionBooleanRequired,
1071 NumericInputRequired,
1072 TextOrBlobInputRequired,
1073 TextInputRequired,
1074 TextOrNullArgumentRequired,
1075 IntegerOrNullArgumentRequired,
1076 UnaryOperandIncompatible,
1077 BinaryOperandsIncompatible,
1078}
1079
1080#[repr(u16)]
1087#[derive(Clone, Copy, Eq, Hash, PartialEq)]
1088pub enum QueryResultShapeCode {
1089 ExpectedRows,
1090 ExpectedGroupedRows,
1091}
1092
1093#[repr(u16)]
1100#[derive(Clone, Copy, Eq, Hash, PartialEq)]
1101pub enum RuntimeErrorKind {
1102 Corruption,
1103 IncompatiblePersistedFormat,
1104 InvariantViolation,
1105 Conflict,
1106 NotFound,
1107 Unsupported,
1108 Internal,
1109}
1110
1111#[repr(u16)]
1118#[derive(Clone, Copy, Eq, Hash, PartialEq)]
1119pub enum RuntimeBoundaryCode {
1120 SqlSurfaceControllerRequired,
1121 SchemaSurfaceControllerRequired,
1122 SqlQueryNoConfiguredEntities,
1123 SqlQueryEntityNotConfigured,
1124 SqlDdlTargetRequired,
1125 SqlDdlEntityNotConfigured,
1126 QueryResponseRowsRequired,
1127 QueryResponseGroupedRowsRequired,
1128 MutationResultEntityRequired,
1129 MutationResultEntitiesRequired,
1130 MutationResultIdRequired,
1131 MutationResultIdsRequired,
1132 RowProjectionFieldNotConfigured,
1133}
1134
1135#[repr(u16)]
1142#[derive(Clone, Copy, Eq, Hash, PartialEq)]
1143pub enum SqlFeatureCode {
1144 AggregateFilterClause,
1145 AlterStatementBeyondAlterTable,
1146 AlterTableAddColumnDuplicateDefault,
1147 AlterTableAddColumnModifiers,
1148 AlterTableAddStatementBeyondAddColumn,
1149 AlterTableAlterColumnDropUnsupportedAction,
1150 AlterTableAlterColumnModifiers,
1151 AlterTableAlterColumnSetUnsupportedAction,
1152 AlterTableAlterColumnUnsupportedAction,
1153 AlterTableAlterStatementBeyondAlterColumn,
1154 AlterTableDropColumnIfExistsSyntax,
1155 AlterTableDropColumnModifiers,
1156 AlterTableDropStatementBeyondDropColumn,
1157 AlterTableRenameColumnMissingTo,
1158 AlterTableRenameColumnModifiers,
1159 AlterTableRenameStatementBeyondRenameColumn,
1160 AlterTableUnsupportedOperation,
1161 ColumnAlias,
1162 CreateIndexIfNotExistsSyntax,
1163 CreateIndexKeyOrderingModifiers,
1164 CreateIndexModifiers,
1165 CreateStatementBeyondCreateIndex,
1166 DescribeModifier,
1167 DdlSchemaVersionDuplicateExpectedClause,
1168 DdlSchemaVersionDuplicateSetClause,
1169 DropIndexModifiers,
1170 DropIndexIfExistsSyntax,
1171 DropStatementBeyondDropIndex,
1172 ExpressionIndexUnsupportedFunction,
1173 Having,
1174 Insert,
1175 Join,
1176 LikePatternBeyondTrailingPrefix,
1177 LowerFieldPredicateUnsupported,
1178 MultiStatementSql,
1179 NestedAggregateInput,
1180 NestedProjectionFunctionInArithmetic,
1181 OrderByUnsupportedForm,
1182 Other,
1183 ParameterBinding,
1184 ParameterizedSchemaVersion,
1185 PredicateStartsWithFirstArgument,
1186 QuotedIdentifiers,
1187 ReturningUnsupportedShape,
1188 ScalarFunctionExpressionPosition,
1189 ScaleTakingNumericFunctionExpressionPosition,
1190 SearchedCaseGroupedOrderBy,
1191 ShowColumnsModifiers,
1192 ShowEntitiesModifiers,
1193 ShowIndexesModifiers,
1194 ShowMemoryModifiers,
1195 ShowStoresModifiers,
1196 ShowUnsupportedCommand,
1197 SimpleCaseExpression,
1198 StandaloneLiteralProjectionItem,
1199 SupportedGroupedOrderByExpressionFamily,
1200 SupportedOrderByExpressionFamily,
1201 UnionIntersectExcept,
1202 UnsupportedFunctionNamespace,
1203 Update,
1204 UpperFieldPredicateUnsupported,
1205 WindowFunction,
1206 With,
1207 NumericScaleFunctionArguments,
1208 OrderByFieldNotOrderable,
1209}
1210
1211#[repr(u16)]
1219#[derive(Clone, Copy, Eq, Hash, PartialEq)]
1220pub enum SqlLoweringCode {
1221 EntityMismatch,
1222 SelectProjectionShape,
1223 SelectDistinct,
1224 DistinctOrderByProjection,
1225 GlobalAggregateProjection,
1226 GlobalAggregateGroupBy,
1227 SelectGroupByShape,
1228 GroupedProjectionExplicitListRequired,
1229 GroupedProjectionAggregateRequired,
1230 GroupedProjectionNonGroupField,
1231 GroupedProjectionScalarAfterAggregate,
1232 HavingRequiresGroupBy,
1233 SelectHavingShape,
1234 AggregateInputExpressions,
1235 WhereExpressionShape,
1236 ParameterPlacement,
1237 SqlDdlExecutionUnsupported,
1238}
1239
1240#[repr(u16)]
1247#[derive(Clone, Copy, Eq, Hash, PartialEq)]
1248pub enum SqlSurfaceMismatchCode {
1249 QueryRejectsInsert,
1250 QueryRejectsUpdate,
1251 QueryRejectsDelete,
1252 UpdateRejectsSelect,
1253 UpdateRejectsExplain,
1254 UpdateRejectsDescribe,
1255 UpdateRejectsShowIndexes,
1256 UpdateRejectsShowColumns,
1257 UpdateRejectsShowEntities,
1258 UpdateRejectsShowStores,
1259 UpdateRejectsShowMemory,
1260}
1261
1262#[repr(u16)]
1269#[derive(Clone, Copy, Eq, Hash, PartialEq)]
1270pub enum SqlWriteBoundaryCode {
1271 PrimaryKeyLiteralShape,
1272 PrimaryKeyLiteralIncompatible,
1273 MissingPrimaryKey,
1274 MissingRequiredFields,
1275 ExplicitManagedField,
1276 ExplicitGeneratedField,
1277 InsertSelectRequiresScalar,
1278 InsertSelectAggregateProjection,
1279 InsertSelectWidthMismatch,
1280 UpdatePrimaryKeyMutation,
1281 InvalidFieldLiteral,
1282 UnknownReturningField,
1283 DuplicateReturningField,
1284 UpdateMissingWherePredicate,
1285 WriteOrderByUnsupportedShape,
1286 ReturningResponseTooLarge,
1287 ReturningRowsTooMany,
1288}
1289
1290#[repr(u16)]
1297#[derive(Clone, Copy, Eq, Hash, PartialEq)]
1298pub enum SchemaDdlAdmissionCode {
1299 MissingExpectedSchemaVersion,
1300 MissingNextSchemaVersion,
1301 StaleExpectedSchemaVersion,
1302 InvalidExpectedSchemaVersion,
1303 InvalidNextSchemaVersion,
1304 AcceptedSchemaChangeWithoutVersionBump,
1305 EmptyVersionBump,
1306 VersionGap,
1307 VersionRollback,
1308 FingerprintMethodMismatch,
1309 UnsupportedTransitionClass,
1310 PhysicalRunnerMissing,
1311 ValidationFailed,
1312 PublicationRaceLost,
1313 InvalidAddColumnDefault,
1314 InvalidAlterColumnDefault,
1315 GeneratedIndexDropRejected,
1316 RequiredDropDefaultUnsupported,
1317 GeneratedFieldDefaultChangeRejected,
1318 GeneratedFieldNullabilityChangeRejected,
1319 SetNotNullValidationFailed,
1320}
1321
1322#[derive(Clone, Copy, Eq, PartialEq)]
1329pub enum DiagnosticDetail {
1330 QueryKind { kind: QueryErrorKind },
1331 RuntimeKind { kind: RuntimeErrorKind },
1332 RuntimeBoundary { boundary: RuntimeBoundaryCode },
1333 SchemaDdlAdmission { reason: SchemaDdlAdmissionCode },
1334 UnsupportedSqlFeature { feature: SqlFeatureCode },
1335 SqlSurfaceMismatch { mismatch: SqlSurfaceMismatchCode },
1336 SqlWriteBoundary { boundary: SqlWriteBoundaryCode },
1337 QueryProjection { reason: QueryProjectionCode },
1338 QueryResultShape { reason: QueryResultShapeCode },
1339 SqlLowering { reason: SqlLoweringCode },
1340}
1341
1342#[derive(Clone, Eq, PartialEq)]
1349pub struct Diagnostic {
1350 code: DiagnosticCode,
1351 origin: ErrorOrigin,
1352 detail: Option<DiagnosticDetail>,
1353}
1354
1355impl Diagnostic {
1356 #[must_use]
1358 pub const fn new(
1359 code: DiagnosticCode,
1360 origin: ErrorOrigin,
1361 detail: Option<DiagnosticDetail>,
1362 ) -> Self {
1363 Self {
1364 code,
1365 origin,
1366 detail,
1367 }
1368 }
1369
1370 #[must_use]
1372 pub const fn from_code(code: DiagnosticCode) -> Self {
1373 Self::new(code, code.origin(), None)
1374 }
1375
1376 #[must_use]
1378 pub const fn code(&self) -> DiagnosticCode {
1379 self.code
1380 }
1381
1382 #[must_use]
1384 pub const fn class(&self) -> ErrorClass {
1385 self.code.class()
1386 }
1387
1388 #[must_use]
1390 pub const fn origin(&self) -> ErrorOrigin {
1391 self.origin
1392 }
1393
1394 #[must_use]
1396 pub const fn detail(&self) -> Option<&DiagnosticDetail> {
1397 self.detail.as_ref()
1398 }
1399
1400 #[must_use]
1402 pub const fn error_code(&self) -> ErrorCode {
1403 ErrorCode::from_parts(self.code, self.detail)
1404 }
1405}
1406
1407impl fmt::Debug for DiagnosticCode {
1408 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1409 fmt_compact_code(f, self.error_code().raw())
1410 }
1411}
1412
1413impl fmt::Debug for ErrorClass {
1414 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1415 fmt_compact_code(f, *self as u16)
1416 }
1417}
1418
1419impl fmt::Debug for ErrorOrigin {
1420 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1421 fmt_compact_code(f, *self as u16)
1422 }
1423}
1424
1425impl fmt::Debug for QueryErrorKind {
1426 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1427 fmt_compact_code(f, *self as u16)
1428 }
1429}
1430
1431impl fmt::Debug for QueryProjectionCode {
1432 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1433 fmt_compact_code(f, *self as u16)
1434 }
1435}
1436
1437impl fmt::Debug for QueryResultShapeCode {
1438 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1439 fmt_compact_code(f, *self as u16)
1440 }
1441}
1442
1443impl fmt::Debug for RuntimeErrorKind {
1444 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1445 fmt_compact_code(f, *self as u16)
1446 }
1447}
1448
1449impl fmt::Debug for RuntimeBoundaryCode {
1450 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1451 fmt_compact_code(f, *self as u16)
1452 }
1453}
1454
1455impl fmt::Debug for SqlFeatureCode {
1456 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1457 fmt_compact_code(f, *self as u16)
1458 }
1459}
1460
1461impl fmt::Debug for SqlLoweringCode {
1462 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1463 fmt_compact_code(f, *self as u16)
1464 }
1465}
1466
1467impl fmt::Debug for SqlSurfaceMismatchCode {
1468 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1469 fmt_compact_code(f, *self as u16)
1470 }
1471}
1472
1473impl fmt::Debug for SqlWriteBoundaryCode {
1474 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1475 fmt_compact_code(f, *self as u16)
1476 }
1477}
1478
1479impl fmt::Debug for SchemaDdlAdmissionCode {
1480 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1481 fmt_compact_code(f, *self as u16)
1482 }
1483}
1484
1485impl fmt::Debug for DiagnosticDetail {
1486 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1487 fmt_compact_code(
1488 f,
1489 ErrorCode::from_parts(DiagnosticCode::RuntimeInternal, Some(*self)).raw(),
1490 )
1491 }
1492}
1493
1494impl fmt::Debug for Diagnostic {
1495 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
1496 write!(f, "{}@{}", self.error_code().raw(), self.origin as u16)
1497 }
1498}
1499
1500fn fmt_compact_code(f: &mut fmt::Formatter<'_>, raw: u16) -> fmt::Result {
1501 write!(f, "{raw}")
1502}
1503
1504#[cfg(test)]
1505mod tests {
1506 use super::{
1507 Diagnostic, DiagnosticCode, DiagnosticDetail, ErrorClass, ErrorCode, ErrorOrigin,
1508 QueryProjectionCode, SqlFeatureCode, SqlLoweringCode, SqlWriteBoundaryCode,
1509 };
1510
1511 const ORDERED_ERROR_CODES: [ErrorCode; 184] = [
1512 ErrorCode::QUERY_VALIDATE,
1513 ErrorCode::QUERY_INTENT,
1514 ErrorCode::QUERY_PLAN,
1515 ErrorCode::QUERY_ACCESS_REQUIREMENT,
1516 ErrorCode::QUERY_UNORDERED_PAGINATION,
1517 ErrorCode::QUERY_INVALID_CONTINUATION_CURSOR,
1518 ErrorCode::QUERY_NOT_FOUND,
1519 ErrorCode::QUERY_NOT_UNIQUE,
1520 ErrorCode::QUERY_NUMERIC_OVERFLOW,
1521 ErrorCode::QUERY_NUMERIC_NOT_REPRESENTABLE,
1522 ErrorCode::QUERY_UNKNOWN_AGGREGATE_TARGET_FIELD,
1523 ErrorCode::QUERY_UNSUPPORTED_SQL_FEATURE,
1524 ErrorCode::QUERY_SQL_SURFACE_MISMATCH,
1525 ErrorCode::SCHEMA_DDL_ADMISSION,
1526 ErrorCode::STORE_NOT_FOUND,
1527 ErrorCode::STORE_CORRUPTION,
1528 ErrorCode::STORE_INVARIANT_VIOLATION,
1529 ErrorCode::RUNTIME_CORRUPTION,
1530 ErrorCode::RUNTIME_INCOMPATIBLE_PERSISTED_FORMAT,
1531 ErrorCode::RUNTIME_INVARIANT_VIOLATION,
1532 ErrorCode::RUNTIME_CONFLICT,
1533 ErrorCode::RUNTIME_NOT_FOUND,
1534 ErrorCode::RUNTIME_UNSUPPORTED,
1535 ErrorCode::RUNTIME_INTERNAL,
1536 ErrorCode::RUNTIME_BOUNDARY_SQL_SURFACE_CONTROLLER_REQUIRED,
1537 ErrorCode::RUNTIME_BOUNDARY_SCHEMA_SURFACE_CONTROLLER_REQUIRED,
1538 ErrorCode::RUNTIME_BOUNDARY_SQL_QUERY_NO_CONFIGURED_ENTITIES,
1539 ErrorCode::RUNTIME_BOUNDARY_SQL_QUERY_ENTITY_NOT_CONFIGURED,
1540 ErrorCode::RUNTIME_BOUNDARY_SQL_DDL_TARGET_REQUIRED,
1541 ErrorCode::RUNTIME_BOUNDARY_SQL_DDL_ENTITY_NOT_CONFIGURED,
1542 ErrorCode::RUNTIME_BOUNDARY_QUERY_RESPONSE_ROWS_REQUIRED,
1543 ErrorCode::RUNTIME_BOUNDARY_QUERY_RESPONSE_GROUPED_ROWS_REQUIRED,
1544 ErrorCode::RUNTIME_BOUNDARY_MUTATION_RESULT_ENTITY_REQUIRED,
1545 ErrorCode::RUNTIME_BOUNDARY_MUTATION_RESULT_ENTITIES_REQUIRED,
1546 ErrorCode::RUNTIME_BOUNDARY_MUTATION_RESULT_ID_REQUIRED,
1547 ErrorCode::RUNTIME_BOUNDARY_MUTATION_RESULT_IDS_REQUIRED,
1548 ErrorCode::RUNTIME_BOUNDARY_ROW_PROJECTION_FIELD_NOT_CONFIGURED,
1549 ErrorCode::SQL_FEATURE_AGGREGATE_FILTER_CLAUSE,
1550 ErrorCode::SQL_FEATURE_ALTER_STATEMENT_BEYOND_ALTER_TABLE,
1551 ErrorCode::SQL_FEATURE_ALTER_TABLE_ADD_COLUMN_DUPLICATE_DEFAULT,
1552 ErrorCode::SQL_FEATURE_ALTER_TABLE_ADD_COLUMN_MODIFIERS,
1553 ErrorCode::SQL_FEATURE_ALTER_TABLE_ADD_STATEMENT_BEYOND_ADD_COLUMN,
1554 ErrorCode::SQL_FEATURE_ALTER_TABLE_ALTER_COLUMN_DROP_UNSUPPORTED_ACTION,
1555 ErrorCode::SQL_FEATURE_ALTER_TABLE_ALTER_COLUMN_MODIFIERS,
1556 ErrorCode::SQL_FEATURE_ALTER_TABLE_ALTER_COLUMN_SET_UNSUPPORTED_ACTION,
1557 ErrorCode::SQL_FEATURE_ALTER_TABLE_ALTER_COLUMN_UNSUPPORTED_ACTION,
1558 ErrorCode::SQL_FEATURE_ALTER_TABLE_ALTER_STATEMENT_BEYOND_ALTER_COLUMN,
1559 ErrorCode::SQL_FEATURE_ALTER_TABLE_DROP_COLUMN_IF_EXISTS_SYNTAX,
1560 ErrorCode::SQL_FEATURE_ALTER_TABLE_DROP_COLUMN_MODIFIERS,
1561 ErrorCode::SQL_FEATURE_ALTER_TABLE_DROP_STATEMENT_BEYOND_DROP_COLUMN,
1562 ErrorCode::SQL_FEATURE_ALTER_TABLE_RENAME_COLUMN_MISSING_TO,
1563 ErrorCode::SQL_FEATURE_ALTER_TABLE_RENAME_COLUMN_MODIFIERS,
1564 ErrorCode::SQL_FEATURE_ALTER_TABLE_RENAME_STATEMENT_BEYOND_RENAME_COLUMN,
1565 ErrorCode::SQL_FEATURE_ALTER_TABLE_UNSUPPORTED_OPERATION,
1566 ErrorCode::SQL_FEATURE_COLUMN_ALIAS,
1567 ErrorCode::SQL_FEATURE_CREATE_INDEX_IF_NOT_EXISTS_SYNTAX,
1568 ErrorCode::SQL_FEATURE_CREATE_INDEX_KEY_ORDERING_MODIFIERS,
1569 ErrorCode::SQL_FEATURE_CREATE_INDEX_MODIFIERS,
1570 ErrorCode::SQL_FEATURE_CREATE_STATEMENT_BEYOND_CREATE_INDEX,
1571 ErrorCode::SQL_FEATURE_DESCRIBE_MODIFIER,
1572 ErrorCode::SQL_FEATURE_DDL_SCHEMA_VERSION_DUPLICATE_EXPECTED_CLAUSE,
1573 ErrorCode::SQL_FEATURE_DDL_SCHEMA_VERSION_DUPLICATE_SET_CLAUSE,
1574 ErrorCode::SQL_FEATURE_DROP_INDEX_MODIFIERS,
1575 ErrorCode::SQL_FEATURE_DROP_INDEX_IF_EXISTS_SYNTAX,
1576 ErrorCode::SQL_FEATURE_DROP_STATEMENT_BEYOND_DROP_INDEX,
1577 ErrorCode::SQL_FEATURE_EXPRESSION_INDEX_UNSUPPORTED_FUNCTION,
1578 ErrorCode::SQL_FEATURE_HAVING,
1579 ErrorCode::SQL_FEATURE_INSERT,
1580 ErrorCode::SQL_FEATURE_JOIN,
1581 ErrorCode::SQL_FEATURE_LIKE_PATTERN_BEYOND_TRAILING_PREFIX,
1582 ErrorCode::SQL_FEATURE_LOWER_FIELD_PREDICATE_UNSUPPORTED,
1583 ErrorCode::SQL_FEATURE_MULTI_STATEMENT_SQL,
1584 ErrorCode::SQL_FEATURE_NESTED_AGGREGATE_INPUT,
1585 ErrorCode::SQL_FEATURE_NESTED_PROJECTION_FUNCTION_IN_ARITHMETIC,
1586 ErrorCode::SQL_FEATURE_ORDER_BY_UNSUPPORTED_FORM,
1587 ErrorCode::SQL_FEATURE_OTHER,
1588 ErrorCode::SQL_FEATURE_PARAMETER_BINDING,
1589 ErrorCode::SQL_FEATURE_PARAMETERIZED_SCHEMA_VERSION,
1590 ErrorCode::SQL_FEATURE_PREDICATE_STARTS_WITH_FIRST_ARGUMENT,
1591 ErrorCode::SQL_FEATURE_QUOTED_IDENTIFIERS,
1592 ErrorCode::SQL_FEATURE_RETURNING_UNSUPPORTED_SHAPE,
1593 ErrorCode::SQL_FEATURE_SCALAR_FUNCTION_EXPRESSION_POSITION,
1594 ErrorCode::SQL_FEATURE_SCALE_TAKING_NUMERIC_FUNCTION_EXPRESSION_POSITION,
1595 ErrorCode::SQL_FEATURE_SEARCHED_CASE_GROUPED_ORDER_BY,
1596 ErrorCode::SQL_FEATURE_SHOW_COLUMNS_MODIFIERS,
1597 ErrorCode::SQL_FEATURE_SHOW_ENTITIES_MODIFIERS,
1598 ErrorCode::SQL_FEATURE_SHOW_INDEXES_MODIFIERS,
1599 ErrorCode::SQL_FEATURE_SHOW_MEMORY_MODIFIERS,
1600 ErrorCode::SQL_FEATURE_SHOW_STORES_MODIFIERS,
1601 ErrorCode::SQL_FEATURE_SHOW_UNSUPPORTED_COMMAND,
1602 ErrorCode::SQL_FEATURE_SIMPLE_CASE_EXPRESSION,
1603 ErrorCode::SQL_FEATURE_STANDALONE_LITERAL_PROJECTION_ITEM,
1604 ErrorCode::SQL_FEATURE_SUPPORTED_GROUPED_ORDER_BY_EXPRESSION_FAMILY,
1605 ErrorCode::SQL_FEATURE_SUPPORTED_ORDER_BY_EXPRESSION_FAMILY,
1606 ErrorCode::SQL_FEATURE_UNION_INTERSECT_EXCEPT,
1607 ErrorCode::SQL_FEATURE_UNSUPPORTED_FUNCTION_NAMESPACE,
1608 ErrorCode::SQL_FEATURE_UPDATE,
1609 ErrorCode::SQL_FEATURE_UPPER_FIELD_PREDICATE_UNSUPPORTED,
1610 ErrorCode::SQL_FEATURE_WINDOW_FUNCTION,
1611 ErrorCode::SQL_FEATURE_WITH,
1612 ErrorCode::SQL_FEATURE_NUMERIC_SCALE_FUNCTION_ARGUMENTS,
1613 ErrorCode::SQL_FEATURE_ORDER_BY_FIELD_NOT_ORDERABLE,
1614 ErrorCode::SQL_SURFACE_QUERY_REJECTS_INSERT,
1615 ErrorCode::SQL_SURFACE_QUERY_REJECTS_UPDATE,
1616 ErrorCode::SQL_SURFACE_QUERY_REJECTS_DELETE,
1617 ErrorCode::SQL_SURFACE_UPDATE_REJECTS_SELECT,
1618 ErrorCode::SQL_SURFACE_UPDATE_REJECTS_EXPLAIN,
1619 ErrorCode::SQL_SURFACE_UPDATE_REJECTS_DESCRIBE,
1620 ErrorCode::SQL_SURFACE_UPDATE_REJECTS_SHOW_INDEXES,
1621 ErrorCode::SQL_SURFACE_UPDATE_REJECTS_SHOW_COLUMNS,
1622 ErrorCode::SQL_SURFACE_UPDATE_REJECTS_SHOW_ENTITIES,
1623 ErrorCode::SQL_SURFACE_UPDATE_REJECTS_SHOW_STORES,
1624 ErrorCode::SQL_SURFACE_UPDATE_REJECTS_SHOW_MEMORY,
1625 ErrorCode::SCHEMA_DDL_MISSING_EXPECTED_SCHEMA_VERSION,
1626 ErrorCode::SCHEMA_DDL_MISSING_NEXT_SCHEMA_VERSION,
1627 ErrorCode::SCHEMA_DDL_STALE_EXPECTED_SCHEMA_VERSION,
1628 ErrorCode::SCHEMA_DDL_INVALID_EXPECTED_SCHEMA_VERSION,
1629 ErrorCode::SCHEMA_DDL_INVALID_NEXT_SCHEMA_VERSION,
1630 ErrorCode::SCHEMA_DDL_ACCEPTED_SCHEMA_CHANGE_WITHOUT_VERSION_BUMP,
1631 ErrorCode::SCHEMA_DDL_EMPTY_VERSION_BUMP,
1632 ErrorCode::SCHEMA_DDL_VERSION_GAP,
1633 ErrorCode::SCHEMA_DDL_VERSION_ROLLBACK,
1634 ErrorCode::SCHEMA_DDL_FINGERPRINT_METHOD_MISMATCH,
1635 ErrorCode::SCHEMA_DDL_UNSUPPORTED_TRANSITION_CLASS,
1636 ErrorCode::SCHEMA_DDL_PHYSICAL_RUNNER_MISSING,
1637 ErrorCode::SCHEMA_DDL_VALIDATION_FAILED,
1638 ErrorCode::SCHEMA_DDL_PUBLICATION_RACE_LOST,
1639 ErrorCode::SCHEMA_DDL_INVALID_ADD_COLUMN_DEFAULT,
1640 ErrorCode::SCHEMA_DDL_INVALID_ALTER_COLUMN_DEFAULT,
1641 ErrorCode::SCHEMA_DDL_GENERATED_INDEX_DROP_REJECTED,
1642 ErrorCode::SCHEMA_DDL_REQUIRED_DROP_DEFAULT_UNSUPPORTED,
1643 ErrorCode::SCHEMA_DDL_GENERATED_FIELD_DEFAULT_CHANGE_REJECTED,
1644 ErrorCode::SCHEMA_DDL_GENERATED_FIELD_NULLABILITY_CHANGE_REJECTED,
1645 ErrorCode::SCHEMA_DDL_SET_NOT_NULL_VALIDATION_FAILED,
1646 ErrorCode::QUERY_SQL_WRITE_BOUNDARY,
1647 ErrorCode::SQL_WRITE_PRIMARY_KEY_LITERAL_SHAPE,
1648 ErrorCode::SQL_WRITE_PRIMARY_KEY_LITERAL_INCOMPATIBLE,
1649 ErrorCode::SQL_WRITE_MISSING_PRIMARY_KEY,
1650 ErrorCode::SQL_WRITE_MISSING_REQUIRED_FIELDS,
1651 ErrorCode::SQL_WRITE_EXPLICIT_MANAGED_FIELD,
1652 ErrorCode::SQL_WRITE_EXPLICIT_GENERATED_FIELD,
1653 ErrorCode::SQL_WRITE_INSERT_SELECT_REQUIRES_SCALAR,
1654 ErrorCode::SQL_WRITE_INSERT_SELECT_AGGREGATE_PROJECTION,
1655 ErrorCode::SQL_WRITE_INSERT_SELECT_WIDTH_MISMATCH,
1656 ErrorCode::SQL_WRITE_UPDATE_PRIMARY_KEY_MUTATION,
1657 ErrorCode::SQL_WRITE_INVALID_FIELD_LITERAL,
1658 ErrorCode::SQL_WRITE_UNKNOWN_RETURNING_FIELD,
1659 ErrorCode::SQL_WRITE_DUPLICATE_RETURNING_FIELD,
1660 ErrorCode::SQL_WRITE_UPDATE_MISSING_WHERE_PREDICATE,
1661 ErrorCode::SQL_WRITE_ORDER_BY_UNSUPPORTED_SHAPE,
1662 ErrorCode::QUERY_UNSUPPORTED_PROJECTION,
1663 ErrorCode::QUERY_PROJECTION_NUMERIC_LITERAL_REQUIRED,
1664 ErrorCode::QUERY_PROJECTION_NUMERIC_SCALE_ARGUMENTS,
1665 ErrorCode::QUERY_PROJECTION_NESTED_FIELD_PATH_PREVIEW,
1666 ErrorCode::QUERY_PROJECTION_CASE_CONDITION_BOOLEAN_REQUIRED,
1667 ErrorCode::QUERY_PROJECTION_NUMERIC_INPUT_REQUIRED,
1668 ErrorCode::QUERY_PROJECTION_TEXT_OR_BLOB_INPUT_REQUIRED,
1669 ErrorCode::QUERY_PROJECTION_TEXT_INPUT_REQUIRED,
1670 ErrorCode::QUERY_PROJECTION_TEXT_OR_NULL_ARGUMENT_REQUIRED,
1671 ErrorCode::QUERY_PROJECTION_INTEGER_OR_NULL_ARGUMENT_REQUIRED,
1672 ErrorCode::QUERY_PROJECTION_UNARY_OPERAND_INCOMPATIBLE,
1673 ErrorCode::QUERY_PROJECTION_BINARY_OPERANDS_INCOMPATIBLE,
1674 ErrorCode::QUERY_RESULT_SHAPE_MISMATCH,
1675 ErrorCode::QUERY_RESULT_EXPECTED_ROWS,
1676 ErrorCode::QUERY_RESULT_EXPECTED_GROUPED,
1677 ErrorCode::SQL_LOWERING_ENTITY_MISMATCH,
1678 ErrorCode::SQL_LOWERING_SELECT_PROJECTION_SHAPE,
1679 ErrorCode::SQL_LOWERING_SELECT_DISTINCT,
1680 ErrorCode::SQL_LOWERING_DISTINCT_ORDER_BY_PROJECTION,
1681 ErrorCode::SQL_LOWERING_GLOBAL_AGGREGATE_PROJECTION,
1682 ErrorCode::SQL_LOWERING_GLOBAL_AGGREGATE_GROUP_BY,
1683 ErrorCode::SQL_LOWERING_SELECT_GROUP_BY_SHAPE,
1684 ErrorCode::SQL_LOWERING_GROUPED_PROJECTION_EXPLICIT_LIST_REQUIRED,
1685 ErrorCode::SQL_LOWERING_GROUPED_PROJECTION_AGGREGATE_REQUIRED,
1686 ErrorCode::SQL_LOWERING_GROUPED_PROJECTION_NON_GROUP_FIELD,
1687 ErrorCode::SQL_LOWERING_GROUPED_PROJECTION_SCALAR_AFTER_AGGREGATE,
1688 ErrorCode::SQL_LOWERING_HAVING_REQUIRES_GROUP_BY,
1689 ErrorCode::SQL_LOWERING_SELECT_HAVING_SHAPE,
1690 ErrorCode::SQL_LOWERING_AGGREGATE_INPUT_EXPRESSIONS,
1691 ErrorCode::SQL_LOWERING_WHERE_EXPRESSION_SHAPE,
1692 ErrorCode::SQL_LOWERING_PARAMETER_PLACEMENT,
1693 ErrorCode::SQL_LOWERING_SQL_DDL_EXECUTION_UNSUPPORTED,
1694 ErrorCode::SQL_WRITE_RETURNING_RESPONSE_TOO_LARGE,
1695 ErrorCode::SQL_WRITE_RETURNING_ROWS_TOO_MANY,
1696 ];
1697
1698 #[test]
1699 fn diagnostic_from_code_uses_default_origin() {
1700 let diagnostic = Diagnostic::from_code(DiagnosticCode::QueryPlan);
1701
1702 assert_eq!(diagnostic.code(), DiagnosticCode::QueryPlan);
1703 assert_eq!(diagnostic.origin(), ErrorOrigin::Query);
1704 }
1705
1706 #[test]
1707 fn diagnostic_code_reports_broad_class() {
1708 assert_eq!(
1709 DiagnosticCode::QueryUnsupportedSqlFeature.class(),
1710 ErrorClass::Unsupported
1711 );
1712 assert_eq!(
1713 DiagnosticCode::QuerySqlSurfaceMismatch.class(),
1714 ErrorClass::Unsupported
1715 );
1716 assert_eq!(DiagnosticCode::QueryPlan.class(), ErrorClass::Query);
1717 assert_eq!(
1718 DiagnosticCode::StoreCorruption.class(),
1719 ErrorClass::Corruption
1720 );
1721 }
1722
1723 #[test]
1724 fn public_error_codes_are_sequential() {
1725 for (index, code) in ORDERED_ERROR_CODES.iter().enumerate() {
1726 let expected = u16::try_from(index + 1).expect("test error-code index fits u16");
1727 assert_eq!(code.raw(), expected);
1728 }
1729 }
1730
1731 #[test]
1732 fn public_error_codes_reconstruct_shifted_details() {
1733 assert_eq!(
1734 ErrorCode::QUERY_UNKNOWN_AGGREGATE_TARGET_FIELD.diagnostic_code(),
1735 DiagnosticCode::QueryUnknownAggregateTargetField
1736 );
1737 assert_eq!(
1738 ErrorCode::SQL_FEATURE_JOIN.diagnostic_detail(),
1739 Some(DiagnosticDetail::UnsupportedSqlFeature {
1740 feature: SqlFeatureCode::Join,
1741 })
1742 );
1743 assert_eq!(
1744 ErrorCode::QUERY_PROJECTION_NUMERIC_LITERAL_REQUIRED.diagnostic_detail(),
1745 Some(DiagnosticDetail::QueryProjection {
1746 reason: QueryProjectionCode::NumericLiteralRequired,
1747 })
1748 );
1749 assert_eq!(
1750 ErrorCode::SQL_LOWERING_DISTINCT_ORDER_BY_PROJECTION.diagnostic_detail(),
1751 Some(DiagnosticDetail::SqlLowering {
1752 reason: SqlLoweringCode::DistinctOrderByProjection,
1753 })
1754 );
1755 assert_eq!(
1756 ErrorCode::SQL_WRITE_RETURNING_RESPONSE_TOO_LARGE.diagnostic_detail(),
1757 Some(DiagnosticDetail::SqlWriteBoundary {
1758 boundary: SqlWriteBoundaryCode::ReturningResponseTooLarge,
1759 })
1760 );
1761 assert_eq!(
1762 ErrorCode::SQL_WRITE_RETURNING_ROWS_TOO_MANY.diagnostic_detail(),
1763 Some(DiagnosticDetail::SqlWriteBoundary {
1764 boundary: SqlWriteBoundaryCode::ReturningRowsTooMany,
1765 })
1766 );
1767 }
1768}