1// Code generated by smithy-go-codegen DO NOT EDIT. 2 3package rdsdata 4 5import ( 6 "bytes" 7 "context" 8 "encoding/base64" 9 "encoding/json" 10 "fmt" 11 "github.com/aws/aws-sdk-go-v2/aws/protocol/restjson" 12 "github.com/aws/aws-sdk-go-v2/service/rdsdata/types" 13 smithy "github.com/aws/smithy-go" 14 smithyio "github.com/aws/smithy-go/io" 15 "github.com/aws/smithy-go/middleware" 16 "github.com/aws/smithy-go/ptr" 17 smithyhttp "github.com/aws/smithy-go/transport/http" 18 "io" 19 "strings" 20) 21 22type awsRestjson1_deserializeOpBatchExecuteStatement struct { 23} 24 25func (*awsRestjson1_deserializeOpBatchExecuteStatement) ID() string { 26 return "OperationDeserializer" 27} 28 29func (m *awsRestjson1_deserializeOpBatchExecuteStatement) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 30 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 31) { 32 out, metadata, err = next.HandleDeserialize(ctx, in) 33 if err != nil { 34 return out, metadata, err 35 } 36 37 response, ok := out.RawResponse.(*smithyhttp.Response) 38 if !ok { 39 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 40 } 41 42 if response.StatusCode < 200 || response.StatusCode >= 300 { 43 return out, metadata, awsRestjson1_deserializeOpErrorBatchExecuteStatement(response, &metadata) 44 } 45 output := &BatchExecuteStatementOutput{} 46 out.Result = output 47 48 var buff [1024]byte 49 ringBuffer := smithyio.NewRingBuffer(buff[:]) 50 51 body := io.TeeReader(response.Body, ringBuffer) 52 53 decoder := json.NewDecoder(body) 54 decoder.UseNumber() 55 var shape interface{} 56 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 57 var snapshot bytes.Buffer 58 io.Copy(&snapshot, ringBuffer) 59 err = &smithy.DeserializationError{ 60 Err: fmt.Errorf("failed to decode response body, %w", err), 61 Snapshot: snapshot.Bytes(), 62 } 63 return out, metadata, err 64 } 65 66 err = awsRestjson1_deserializeOpDocumentBatchExecuteStatementOutput(&output, shape) 67 if err != nil { 68 var snapshot bytes.Buffer 69 io.Copy(&snapshot, ringBuffer) 70 return out, metadata, &smithy.DeserializationError{ 71 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 72 Snapshot: snapshot.Bytes(), 73 } 74 } 75 76 return out, metadata, err 77} 78 79func awsRestjson1_deserializeOpErrorBatchExecuteStatement(response *smithyhttp.Response, metadata *middleware.Metadata) error { 80 var errorBuffer bytes.Buffer 81 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 82 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 83 } 84 errorBody := bytes.NewReader(errorBuffer.Bytes()) 85 86 errorCode := "UnknownError" 87 errorMessage := errorCode 88 89 code := response.Header.Get("X-Amzn-ErrorType") 90 if len(code) != 0 { 91 errorCode = restjson.SanitizeErrorCode(code) 92 } 93 94 var buff [1024]byte 95 ringBuffer := smithyio.NewRingBuffer(buff[:]) 96 97 body := io.TeeReader(errorBody, ringBuffer) 98 decoder := json.NewDecoder(body) 99 decoder.UseNumber() 100 code, message, err := restjson.GetErrorInfo(decoder) 101 if err != nil { 102 var snapshot bytes.Buffer 103 io.Copy(&snapshot, ringBuffer) 104 err = &smithy.DeserializationError{ 105 Err: fmt.Errorf("failed to decode response body, %w", err), 106 Snapshot: snapshot.Bytes(), 107 } 108 return err 109 } 110 111 errorBody.Seek(0, io.SeekStart) 112 if len(code) != 0 { 113 errorCode = restjson.SanitizeErrorCode(code) 114 } 115 if len(message) != 0 { 116 errorMessage = message 117 } 118 119 switch { 120 case strings.EqualFold("BadRequestException", errorCode): 121 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 122 123 case strings.EqualFold("ForbiddenException", errorCode): 124 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 125 126 case strings.EqualFold("InternalServerErrorException", errorCode): 127 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 128 129 case strings.EqualFold("ServiceUnavailableError", errorCode): 130 return awsRestjson1_deserializeErrorServiceUnavailableError(response, errorBody) 131 132 case strings.EqualFold("StatementTimeoutException", errorCode): 133 return awsRestjson1_deserializeErrorStatementTimeoutException(response, errorBody) 134 135 default: 136 genericError := &smithy.GenericAPIError{ 137 Code: errorCode, 138 Message: errorMessage, 139 } 140 return genericError 141 142 } 143} 144 145func awsRestjson1_deserializeOpDocumentBatchExecuteStatementOutput(v **BatchExecuteStatementOutput, value interface{}) error { 146 if v == nil { 147 return fmt.Errorf("unexpected nil of type %T", v) 148 } 149 if value == nil { 150 return nil 151 } 152 153 shape, ok := value.(map[string]interface{}) 154 if !ok { 155 return fmt.Errorf("unexpected JSON type %v", value) 156 } 157 158 var sv *BatchExecuteStatementOutput 159 if *v == nil { 160 sv = &BatchExecuteStatementOutput{} 161 } else { 162 sv = *v 163 } 164 165 for key, value := range shape { 166 switch key { 167 case "updateResults": 168 if err := awsRestjson1_deserializeDocumentUpdateResults(&sv.UpdateResults, value); err != nil { 169 return err 170 } 171 172 default: 173 _, _ = key, value 174 175 } 176 } 177 *v = sv 178 return nil 179} 180 181type awsRestjson1_deserializeOpBeginTransaction struct { 182} 183 184func (*awsRestjson1_deserializeOpBeginTransaction) ID() string { 185 return "OperationDeserializer" 186} 187 188func (m *awsRestjson1_deserializeOpBeginTransaction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 189 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 190) { 191 out, metadata, err = next.HandleDeserialize(ctx, in) 192 if err != nil { 193 return out, metadata, err 194 } 195 196 response, ok := out.RawResponse.(*smithyhttp.Response) 197 if !ok { 198 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 199 } 200 201 if response.StatusCode < 200 || response.StatusCode >= 300 { 202 return out, metadata, awsRestjson1_deserializeOpErrorBeginTransaction(response, &metadata) 203 } 204 output := &BeginTransactionOutput{} 205 out.Result = output 206 207 var buff [1024]byte 208 ringBuffer := smithyio.NewRingBuffer(buff[:]) 209 210 body := io.TeeReader(response.Body, ringBuffer) 211 212 decoder := json.NewDecoder(body) 213 decoder.UseNumber() 214 var shape interface{} 215 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 216 var snapshot bytes.Buffer 217 io.Copy(&snapshot, ringBuffer) 218 err = &smithy.DeserializationError{ 219 Err: fmt.Errorf("failed to decode response body, %w", err), 220 Snapshot: snapshot.Bytes(), 221 } 222 return out, metadata, err 223 } 224 225 err = awsRestjson1_deserializeOpDocumentBeginTransactionOutput(&output, shape) 226 if err != nil { 227 var snapshot bytes.Buffer 228 io.Copy(&snapshot, ringBuffer) 229 return out, metadata, &smithy.DeserializationError{ 230 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 231 Snapshot: snapshot.Bytes(), 232 } 233 } 234 235 return out, metadata, err 236} 237 238func awsRestjson1_deserializeOpErrorBeginTransaction(response *smithyhttp.Response, metadata *middleware.Metadata) error { 239 var errorBuffer bytes.Buffer 240 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 241 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 242 } 243 errorBody := bytes.NewReader(errorBuffer.Bytes()) 244 245 errorCode := "UnknownError" 246 errorMessage := errorCode 247 248 code := response.Header.Get("X-Amzn-ErrorType") 249 if len(code) != 0 { 250 errorCode = restjson.SanitizeErrorCode(code) 251 } 252 253 var buff [1024]byte 254 ringBuffer := smithyio.NewRingBuffer(buff[:]) 255 256 body := io.TeeReader(errorBody, ringBuffer) 257 decoder := json.NewDecoder(body) 258 decoder.UseNumber() 259 code, message, err := restjson.GetErrorInfo(decoder) 260 if err != nil { 261 var snapshot bytes.Buffer 262 io.Copy(&snapshot, ringBuffer) 263 err = &smithy.DeserializationError{ 264 Err: fmt.Errorf("failed to decode response body, %w", err), 265 Snapshot: snapshot.Bytes(), 266 } 267 return err 268 } 269 270 errorBody.Seek(0, io.SeekStart) 271 if len(code) != 0 { 272 errorCode = restjson.SanitizeErrorCode(code) 273 } 274 if len(message) != 0 { 275 errorMessage = message 276 } 277 278 switch { 279 case strings.EqualFold("BadRequestException", errorCode): 280 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 281 282 case strings.EqualFold("ForbiddenException", errorCode): 283 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 284 285 case strings.EqualFold("InternalServerErrorException", errorCode): 286 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 287 288 case strings.EqualFold("ServiceUnavailableError", errorCode): 289 return awsRestjson1_deserializeErrorServiceUnavailableError(response, errorBody) 290 291 case strings.EqualFold("StatementTimeoutException", errorCode): 292 return awsRestjson1_deserializeErrorStatementTimeoutException(response, errorBody) 293 294 default: 295 genericError := &smithy.GenericAPIError{ 296 Code: errorCode, 297 Message: errorMessage, 298 } 299 return genericError 300 301 } 302} 303 304func awsRestjson1_deserializeOpDocumentBeginTransactionOutput(v **BeginTransactionOutput, value interface{}) error { 305 if v == nil { 306 return fmt.Errorf("unexpected nil of type %T", v) 307 } 308 if value == nil { 309 return nil 310 } 311 312 shape, ok := value.(map[string]interface{}) 313 if !ok { 314 return fmt.Errorf("unexpected JSON type %v", value) 315 } 316 317 var sv *BeginTransactionOutput 318 if *v == nil { 319 sv = &BeginTransactionOutput{} 320 } else { 321 sv = *v 322 } 323 324 for key, value := range shape { 325 switch key { 326 case "transactionId": 327 if value != nil { 328 jtv, ok := value.(string) 329 if !ok { 330 return fmt.Errorf("expected Id to be of type string, got %T instead", value) 331 } 332 sv.TransactionId = ptr.String(jtv) 333 } 334 335 default: 336 _, _ = key, value 337 338 } 339 } 340 *v = sv 341 return nil 342} 343 344type awsRestjson1_deserializeOpCommitTransaction struct { 345} 346 347func (*awsRestjson1_deserializeOpCommitTransaction) ID() string { 348 return "OperationDeserializer" 349} 350 351func (m *awsRestjson1_deserializeOpCommitTransaction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 352 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 353) { 354 out, metadata, err = next.HandleDeserialize(ctx, in) 355 if err != nil { 356 return out, metadata, err 357 } 358 359 response, ok := out.RawResponse.(*smithyhttp.Response) 360 if !ok { 361 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 362 } 363 364 if response.StatusCode < 200 || response.StatusCode >= 300 { 365 return out, metadata, awsRestjson1_deserializeOpErrorCommitTransaction(response, &metadata) 366 } 367 output := &CommitTransactionOutput{} 368 out.Result = output 369 370 var buff [1024]byte 371 ringBuffer := smithyio.NewRingBuffer(buff[:]) 372 373 body := io.TeeReader(response.Body, ringBuffer) 374 375 decoder := json.NewDecoder(body) 376 decoder.UseNumber() 377 var shape interface{} 378 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 379 var snapshot bytes.Buffer 380 io.Copy(&snapshot, ringBuffer) 381 err = &smithy.DeserializationError{ 382 Err: fmt.Errorf("failed to decode response body, %w", err), 383 Snapshot: snapshot.Bytes(), 384 } 385 return out, metadata, err 386 } 387 388 err = awsRestjson1_deserializeOpDocumentCommitTransactionOutput(&output, shape) 389 if err != nil { 390 var snapshot bytes.Buffer 391 io.Copy(&snapshot, ringBuffer) 392 return out, metadata, &smithy.DeserializationError{ 393 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 394 Snapshot: snapshot.Bytes(), 395 } 396 } 397 398 return out, metadata, err 399} 400 401func awsRestjson1_deserializeOpErrorCommitTransaction(response *smithyhttp.Response, metadata *middleware.Metadata) error { 402 var errorBuffer bytes.Buffer 403 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 404 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 405 } 406 errorBody := bytes.NewReader(errorBuffer.Bytes()) 407 408 errorCode := "UnknownError" 409 errorMessage := errorCode 410 411 code := response.Header.Get("X-Amzn-ErrorType") 412 if len(code) != 0 { 413 errorCode = restjson.SanitizeErrorCode(code) 414 } 415 416 var buff [1024]byte 417 ringBuffer := smithyio.NewRingBuffer(buff[:]) 418 419 body := io.TeeReader(errorBody, ringBuffer) 420 decoder := json.NewDecoder(body) 421 decoder.UseNumber() 422 code, message, err := restjson.GetErrorInfo(decoder) 423 if err != nil { 424 var snapshot bytes.Buffer 425 io.Copy(&snapshot, ringBuffer) 426 err = &smithy.DeserializationError{ 427 Err: fmt.Errorf("failed to decode response body, %w", err), 428 Snapshot: snapshot.Bytes(), 429 } 430 return err 431 } 432 433 errorBody.Seek(0, io.SeekStart) 434 if len(code) != 0 { 435 errorCode = restjson.SanitizeErrorCode(code) 436 } 437 if len(message) != 0 { 438 errorMessage = message 439 } 440 441 switch { 442 case strings.EqualFold("BadRequestException", errorCode): 443 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 444 445 case strings.EqualFold("ForbiddenException", errorCode): 446 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 447 448 case strings.EqualFold("InternalServerErrorException", errorCode): 449 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 450 451 case strings.EqualFold("NotFoundException", errorCode): 452 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 453 454 case strings.EqualFold("ServiceUnavailableError", errorCode): 455 return awsRestjson1_deserializeErrorServiceUnavailableError(response, errorBody) 456 457 case strings.EqualFold("StatementTimeoutException", errorCode): 458 return awsRestjson1_deserializeErrorStatementTimeoutException(response, errorBody) 459 460 default: 461 genericError := &smithy.GenericAPIError{ 462 Code: errorCode, 463 Message: errorMessage, 464 } 465 return genericError 466 467 } 468} 469 470func awsRestjson1_deserializeOpDocumentCommitTransactionOutput(v **CommitTransactionOutput, value interface{}) error { 471 if v == nil { 472 return fmt.Errorf("unexpected nil of type %T", v) 473 } 474 if value == nil { 475 return nil 476 } 477 478 shape, ok := value.(map[string]interface{}) 479 if !ok { 480 return fmt.Errorf("unexpected JSON type %v", value) 481 } 482 483 var sv *CommitTransactionOutput 484 if *v == nil { 485 sv = &CommitTransactionOutput{} 486 } else { 487 sv = *v 488 } 489 490 for key, value := range shape { 491 switch key { 492 case "transactionStatus": 493 if value != nil { 494 jtv, ok := value.(string) 495 if !ok { 496 return fmt.Errorf("expected TransactionStatus to be of type string, got %T instead", value) 497 } 498 sv.TransactionStatus = ptr.String(jtv) 499 } 500 501 default: 502 _, _ = key, value 503 504 } 505 } 506 *v = sv 507 return nil 508} 509 510type awsRestjson1_deserializeOpExecuteSql struct { 511} 512 513func (*awsRestjson1_deserializeOpExecuteSql) ID() string { 514 return "OperationDeserializer" 515} 516 517func (m *awsRestjson1_deserializeOpExecuteSql) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 518 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 519) { 520 out, metadata, err = next.HandleDeserialize(ctx, in) 521 if err != nil { 522 return out, metadata, err 523 } 524 525 response, ok := out.RawResponse.(*smithyhttp.Response) 526 if !ok { 527 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 528 } 529 530 if response.StatusCode < 200 || response.StatusCode >= 300 { 531 return out, metadata, awsRestjson1_deserializeOpErrorExecuteSql(response, &metadata) 532 } 533 output := &ExecuteSqlOutput{} 534 out.Result = output 535 536 var buff [1024]byte 537 ringBuffer := smithyio.NewRingBuffer(buff[:]) 538 539 body := io.TeeReader(response.Body, ringBuffer) 540 541 decoder := json.NewDecoder(body) 542 decoder.UseNumber() 543 var shape interface{} 544 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 545 var snapshot bytes.Buffer 546 io.Copy(&snapshot, ringBuffer) 547 err = &smithy.DeserializationError{ 548 Err: fmt.Errorf("failed to decode response body, %w", err), 549 Snapshot: snapshot.Bytes(), 550 } 551 return out, metadata, err 552 } 553 554 err = awsRestjson1_deserializeOpDocumentExecuteSqlOutput(&output, shape) 555 if err != nil { 556 var snapshot bytes.Buffer 557 io.Copy(&snapshot, ringBuffer) 558 return out, metadata, &smithy.DeserializationError{ 559 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 560 Snapshot: snapshot.Bytes(), 561 } 562 } 563 564 return out, metadata, err 565} 566 567func awsRestjson1_deserializeOpErrorExecuteSql(response *smithyhttp.Response, metadata *middleware.Metadata) error { 568 var errorBuffer bytes.Buffer 569 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 570 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 571 } 572 errorBody := bytes.NewReader(errorBuffer.Bytes()) 573 574 errorCode := "UnknownError" 575 errorMessage := errorCode 576 577 code := response.Header.Get("X-Amzn-ErrorType") 578 if len(code) != 0 { 579 errorCode = restjson.SanitizeErrorCode(code) 580 } 581 582 var buff [1024]byte 583 ringBuffer := smithyio.NewRingBuffer(buff[:]) 584 585 body := io.TeeReader(errorBody, ringBuffer) 586 decoder := json.NewDecoder(body) 587 decoder.UseNumber() 588 code, message, err := restjson.GetErrorInfo(decoder) 589 if err != nil { 590 var snapshot bytes.Buffer 591 io.Copy(&snapshot, ringBuffer) 592 err = &smithy.DeserializationError{ 593 Err: fmt.Errorf("failed to decode response body, %w", err), 594 Snapshot: snapshot.Bytes(), 595 } 596 return err 597 } 598 599 errorBody.Seek(0, io.SeekStart) 600 if len(code) != 0 { 601 errorCode = restjson.SanitizeErrorCode(code) 602 } 603 if len(message) != 0 { 604 errorMessage = message 605 } 606 607 switch { 608 case strings.EqualFold("BadRequestException", errorCode): 609 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 610 611 case strings.EqualFold("ForbiddenException", errorCode): 612 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 613 614 case strings.EqualFold("InternalServerErrorException", errorCode): 615 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 616 617 case strings.EqualFold("ServiceUnavailableError", errorCode): 618 return awsRestjson1_deserializeErrorServiceUnavailableError(response, errorBody) 619 620 default: 621 genericError := &smithy.GenericAPIError{ 622 Code: errorCode, 623 Message: errorMessage, 624 } 625 return genericError 626 627 } 628} 629 630func awsRestjson1_deserializeOpDocumentExecuteSqlOutput(v **ExecuteSqlOutput, value interface{}) error { 631 if v == nil { 632 return fmt.Errorf("unexpected nil of type %T", v) 633 } 634 if value == nil { 635 return nil 636 } 637 638 shape, ok := value.(map[string]interface{}) 639 if !ok { 640 return fmt.Errorf("unexpected JSON type %v", value) 641 } 642 643 var sv *ExecuteSqlOutput 644 if *v == nil { 645 sv = &ExecuteSqlOutput{} 646 } else { 647 sv = *v 648 } 649 650 for key, value := range shape { 651 switch key { 652 case "sqlStatementResults": 653 if err := awsRestjson1_deserializeDocumentSqlStatementResults(&sv.SqlStatementResults, value); err != nil { 654 return err 655 } 656 657 default: 658 _, _ = key, value 659 660 } 661 } 662 *v = sv 663 return nil 664} 665 666type awsRestjson1_deserializeOpExecuteStatement struct { 667} 668 669func (*awsRestjson1_deserializeOpExecuteStatement) ID() string { 670 return "OperationDeserializer" 671} 672 673func (m *awsRestjson1_deserializeOpExecuteStatement) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 674 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 675) { 676 out, metadata, err = next.HandleDeserialize(ctx, in) 677 if err != nil { 678 return out, metadata, err 679 } 680 681 response, ok := out.RawResponse.(*smithyhttp.Response) 682 if !ok { 683 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 684 } 685 686 if response.StatusCode < 200 || response.StatusCode >= 300 { 687 return out, metadata, awsRestjson1_deserializeOpErrorExecuteStatement(response, &metadata) 688 } 689 output := &ExecuteStatementOutput{} 690 out.Result = output 691 692 var buff [1024]byte 693 ringBuffer := smithyio.NewRingBuffer(buff[:]) 694 695 body := io.TeeReader(response.Body, ringBuffer) 696 697 decoder := json.NewDecoder(body) 698 decoder.UseNumber() 699 var shape interface{} 700 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 701 var snapshot bytes.Buffer 702 io.Copy(&snapshot, ringBuffer) 703 err = &smithy.DeserializationError{ 704 Err: fmt.Errorf("failed to decode response body, %w", err), 705 Snapshot: snapshot.Bytes(), 706 } 707 return out, metadata, err 708 } 709 710 err = awsRestjson1_deserializeOpDocumentExecuteStatementOutput(&output, shape) 711 if err != nil { 712 var snapshot bytes.Buffer 713 io.Copy(&snapshot, ringBuffer) 714 return out, metadata, &smithy.DeserializationError{ 715 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 716 Snapshot: snapshot.Bytes(), 717 } 718 } 719 720 return out, metadata, err 721} 722 723func awsRestjson1_deserializeOpErrorExecuteStatement(response *smithyhttp.Response, metadata *middleware.Metadata) error { 724 var errorBuffer bytes.Buffer 725 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 726 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 727 } 728 errorBody := bytes.NewReader(errorBuffer.Bytes()) 729 730 errorCode := "UnknownError" 731 errorMessage := errorCode 732 733 code := response.Header.Get("X-Amzn-ErrorType") 734 if len(code) != 0 { 735 errorCode = restjson.SanitizeErrorCode(code) 736 } 737 738 var buff [1024]byte 739 ringBuffer := smithyio.NewRingBuffer(buff[:]) 740 741 body := io.TeeReader(errorBody, ringBuffer) 742 decoder := json.NewDecoder(body) 743 decoder.UseNumber() 744 code, message, err := restjson.GetErrorInfo(decoder) 745 if err != nil { 746 var snapshot bytes.Buffer 747 io.Copy(&snapshot, ringBuffer) 748 err = &smithy.DeserializationError{ 749 Err: fmt.Errorf("failed to decode response body, %w", err), 750 Snapshot: snapshot.Bytes(), 751 } 752 return err 753 } 754 755 errorBody.Seek(0, io.SeekStart) 756 if len(code) != 0 { 757 errorCode = restjson.SanitizeErrorCode(code) 758 } 759 if len(message) != 0 { 760 errorMessage = message 761 } 762 763 switch { 764 case strings.EqualFold("BadRequestException", errorCode): 765 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 766 767 case strings.EqualFold("ForbiddenException", errorCode): 768 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 769 770 case strings.EqualFold("InternalServerErrorException", errorCode): 771 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 772 773 case strings.EqualFold("ServiceUnavailableError", errorCode): 774 return awsRestjson1_deserializeErrorServiceUnavailableError(response, errorBody) 775 776 case strings.EqualFold("StatementTimeoutException", errorCode): 777 return awsRestjson1_deserializeErrorStatementTimeoutException(response, errorBody) 778 779 default: 780 genericError := &smithy.GenericAPIError{ 781 Code: errorCode, 782 Message: errorMessage, 783 } 784 return genericError 785 786 } 787} 788 789func awsRestjson1_deserializeOpDocumentExecuteStatementOutput(v **ExecuteStatementOutput, value interface{}) error { 790 if v == nil { 791 return fmt.Errorf("unexpected nil of type %T", v) 792 } 793 if value == nil { 794 return nil 795 } 796 797 shape, ok := value.(map[string]interface{}) 798 if !ok { 799 return fmt.Errorf("unexpected JSON type %v", value) 800 } 801 802 var sv *ExecuteStatementOutput 803 if *v == nil { 804 sv = &ExecuteStatementOutput{} 805 } else { 806 sv = *v 807 } 808 809 for key, value := range shape { 810 switch key { 811 case "columnMetadata": 812 if err := awsRestjson1_deserializeDocumentMetadata(&sv.ColumnMetadata, value); err != nil { 813 return err 814 } 815 816 case "generatedFields": 817 if err := awsRestjson1_deserializeDocumentFieldList(&sv.GeneratedFields, value); err != nil { 818 return err 819 } 820 821 case "numberOfRecordsUpdated": 822 if value != nil { 823 jtv, ok := value.(json.Number) 824 if !ok { 825 return fmt.Errorf("expected RecordsUpdated to be json.Number, got %T instead", value) 826 } 827 i64, err := jtv.Int64() 828 if err != nil { 829 return err 830 } 831 sv.NumberOfRecordsUpdated = i64 832 } 833 834 case "records": 835 if err := awsRestjson1_deserializeDocumentSqlRecords(&sv.Records, value); err != nil { 836 return err 837 } 838 839 default: 840 _, _ = key, value 841 842 } 843 } 844 *v = sv 845 return nil 846} 847 848type awsRestjson1_deserializeOpRollbackTransaction struct { 849} 850 851func (*awsRestjson1_deserializeOpRollbackTransaction) ID() string { 852 return "OperationDeserializer" 853} 854 855func (m *awsRestjson1_deserializeOpRollbackTransaction) HandleDeserialize(ctx context.Context, in middleware.DeserializeInput, next middleware.DeserializeHandler) ( 856 out middleware.DeserializeOutput, metadata middleware.Metadata, err error, 857) { 858 out, metadata, err = next.HandleDeserialize(ctx, in) 859 if err != nil { 860 return out, metadata, err 861 } 862 863 response, ok := out.RawResponse.(*smithyhttp.Response) 864 if !ok { 865 return out, metadata, &smithy.DeserializationError{Err: fmt.Errorf("unknown transport type %T", out.RawResponse)} 866 } 867 868 if response.StatusCode < 200 || response.StatusCode >= 300 { 869 return out, metadata, awsRestjson1_deserializeOpErrorRollbackTransaction(response, &metadata) 870 } 871 output := &RollbackTransactionOutput{} 872 out.Result = output 873 874 var buff [1024]byte 875 ringBuffer := smithyio.NewRingBuffer(buff[:]) 876 877 body := io.TeeReader(response.Body, ringBuffer) 878 879 decoder := json.NewDecoder(body) 880 decoder.UseNumber() 881 var shape interface{} 882 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 883 var snapshot bytes.Buffer 884 io.Copy(&snapshot, ringBuffer) 885 err = &smithy.DeserializationError{ 886 Err: fmt.Errorf("failed to decode response body, %w", err), 887 Snapshot: snapshot.Bytes(), 888 } 889 return out, metadata, err 890 } 891 892 err = awsRestjson1_deserializeOpDocumentRollbackTransactionOutput(&output, shape) 893 if err != nil { 894 var snapshot bytes.Buffer 895 io.Copy(&snapshot, ringBuffer) 896 return out, metadata, &smithy.DeserializationError{ 897 Err: fmt.Errorf("failed to decode response body with invalid JSON, %w", err), 898 Snapshot: snapshot.Bytes(), 899 } 900 } 901 902 return out, metadata, err 903} 904 905func awsRestjson1_deserializeOpErrorRollbackTransaction(response *smithyhttp.Response, metadata *middleware.Metadata) error { 906 var errorBuffer bytes.Buffer 907 if _, err := io.Copy(&errorBuffer, response.Body); err != nil { 908 return &smithy.DeserializationError{Err: fmt.Errorf("failed to copy error response body, %w", err)} 909 } 910 errorBody := bytes.NewReader(errorBuffer.Bytes()) 911 912 errorCode := "UnknownError" 913 errorMessage := errorCode 914 915 code := response.Header.Get("X-Amzn-ErrorType") 916 if len(code) != 0 { 917 errorCode = restjson.SanitizeErrorCode(code) 918 } 919 920 var buff [1024]byte 921 ringBuffer := smithyio.NewRingBuffer(buff[:]) 922 923 body := io.TeeReader(errorBody, ringBuffer) 924 decoder := json.NewDecoder(body) 925 decoder.UseNumber() 926 code, message, err := restjson.GetErrorInfo(decoder) 927 if err != nil { 928 var snapshot bytes.Buffer 929 io.Copy(&snapshot, ringBuffer) 930 err = &smithy.DeserializationError{ 931 Err: fmt.Errorf("failed to decode response body, %w", err), 932 Snapshot: snapshot.Bytes(), 933 } 934 return err 935 } 936 937 errorBody.Seek(0, io.SeekStart) 938 if len(code) != 0 { 939 errorCode = restjson.SanitizeErrorCode(code) 940 } 941 if len(message) != 0 { 942 errorMessage = message 943 } 944 945 switch { 946 case strings.EqualFold("BadRequestException", errorCode): 947 return awsRestjson1_deserializeErrorBadRequestException(response, errorBody) 948 949 case strings.EqualFold("ForbiddenException", errorCode): 950 return awsRestjson1_deserializeErrorForbiddenException(response, errorBody) 951 952 case strings.EqualFold("InternalServerErrorException", errorCode): 953 return awsRestjson1_deserializeErrorInternalServerErrorException(response, errorBody) 954 955 case strings.EqualFold("NotFoundException", errorCode): 956 return awsRestjson1_deserializeErrorNotFoundException(response, errorBody) 957 958 case strings.EqualFold("ServiceUnavailableError", errorCode): 959 return awsRestjson1_deserializeErrorServiceUnavailableError(response, errorBody) 960 961 case strings.EqualFold("StatementTimeoutException", errorCode): 962 return awsRestjson1_deserializeErrorStatementTimeoutException(response, errorBody) 963 964 default: 965 genericError := &smithy.GenericAPIError{ 966 Code: errorCode, 967 Message: errorMessage, 968 } 969 return genericError 970 971 } 972} 973 974func awsRestjson1_deserializeOpDocumentRollbackTransactionOutput(v **RollbackTransactionOutput, value interface{}) error { 975 if v == nil { 976 return fmt.Errorf("unexpected nil of type %T", v) 977 } 978 if value == nil { 979 return nil 980 } 981 982 shape, ok := value.(map[string]interface{}) 983 if !ok { 984 return fmt.Errorf("unexpected JSON type %v", value) 985 } 986 987 var sv *RollbackTransactionOutput 988 if *v == nil { 989 sv = &RollbackTransactionOutput{} 990 } else { 991 sv = *v 992 } 993 994 for key, value := range shape { 995 switch key { 996 case "transactionStatus": 997 if value != nil { 998 jtv, ok := value.(string) 999 if !ok { 1000 return fmt.Errorf("expected TransactionStatus to be of type string, got %T instead", value) 1001 } 1002 sv.TransactionStatus = ptr.String(jtv) 1003 } 1004 1005 default: 1006 _, _ = key, value 1007 1008 } 1009 } 1010 *v = sv 1011 return nil 1012} 1013 1014func awsRestjson1_deserializeErrorBadRequestException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1015 output := &types.BadRequestException{} 1016 var buff [1024]byte 1017 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1018 1019 body := io.TeeReader(errorBody, ringBuffer) 1020 decoder := json.NewDecoder(body) 1021 decoder.UseNumber() 1022 var shape interface{} 1023 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1024 var snapshot bytes.Buffer 1025 io.Copy(&snapshot, ringBuffer) 1026 err = &smithy.DeserializationError{ 1027 Err: fmt.Errorf("failed to decode response body, %w", err), 1028 Snapshot: snapshot.Bytes(), 1029 } 1030 return err 1031 } 1032 1033 err := awsRestjson1_deserializeDocumentBadRequestException(&output, shape) 1034 1035 if err != nil { 1036 var snapshot bytes.Buffer 1037 io.Copy(&snapshot, ringBuffer) 1038 err = &smithy.DeserializationError{ 1039 Err: fmt.Errorf("failed to decode response body, %w", err), 1040 Snapshot: snapshot.Bytes(), 1041 } 1042 return err 1043 } 1044 1045 errorBody.Seek(0, io.SeekStart) 1046 1047 return output 1048} 1049 1050func awsRestjson1_deserializeErrorForbiddenException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1051 output := &types.ForbiddenException{} 1052 var buff [1024]byte 1053 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1054 1055 body := io.TeeReader(errorBody, ringBuffer) 1056 decoder := json.NewDecoder(body) 1057 decoder.UseNumber() 1058 var shape interface{} 1059 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1060 var snapshot bytes.Buffer 1061 io.Copy(&snapshot, ringBuffer) 1062 err = &smithy.DeserializationError{ 1063 Err: fmt.Errorf("failed to decode response body, %w", err), 1064 Snapshot: snapshot.Bytes(), 1065 } 1066 return err 1067 } 1068 1069 err := awsRestjson1_deserializeDocumentForbiddenException(&output, shape) 1070 1071 if err != nil { 1072 var snapshot bytes.Buffer 1073 io.Copy(&snapshot, ringBuffer) 1074 err = &smithy.DeserializationError{ 1075 Err: fmt.Errorf("failed to decode response body, %w", err), 1076 Snapshot: snapshot.Bytes(), 1077 } 1078 return err 1079 } 1080 1081 errorBody.Seek(0, io.SeekStart) 1082 1083 return output 1084} 1085 1086func awsRestjson1_deserializeErrorInternalServerErrorException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1087 output := &types.InternalServerErrorException{} 1088 return output 1089} 1090 1091func awsRestjson1_deserializeErrorNotFoundException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1092 output := &types.NotFoundException{} 1093 var buff [1024]byte 1094 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1095 1096 body := io.TeeReader(errorBody, ringBuffer) 1097 decoder := json.NewDecoder(body) 1098 decoder.UseNumber() 1099 var shape interface{} 1100 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1101 var snapshot bytes.Buffer 1102 io.Copy(&snapshot, ringBuffer) 1103 err = &smithy.DeserializationError{ 1104 Err: fmt.Errorf("failed to decode response body, %w", err), 1105 Snapshot: snapshot.Bytes(), 1106 } 1107 return err 1108 } 1109 1110 err := awsRestjson1_deserializeDocumentNotFoundException(&output, shape) 1111 1112 if err != nil { 1113 var snapshot bytes.Buffer 1114 io.Copy(&snapshot, ringBuffer) 1115 err = &smithy.DeserializationError{ 1116 Err: fmt.Errorf("failed to decode response body, %w", err), 1117 Snapshot: snapshot.Bytes(), 1118 } 1119 return err 1120 } 1121 1122 errorBody.Seek(0, io.SeekStart) 1123 1124 return output 1125} 1126 1127func awsRestjson1_deserializeErrorServiceUnavailableError(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1128 output := &types.ServiceUnavailableError{} 1129 return output 1130} 1131 1132func awsRestjson1_deserializeErrorStatementTimeoutException(response *smithyhttp.Response, errorBody *bytes.Reader) error { 1133 output := &types.StatementTimeoutException{} 1134 var buff [1024]byte 1135 ringBuffer := smithyio.NewRingBuffer(buff[:]) 1136 1137 body := io.TeeReader(errorBody, ringBuffer) 1138 decoder := json.NewDecoder(body) 1139 decoder.UseNumber() 1140 var shape interface{} 1141 if err := decoder.Decode(&shape); err != nil && err != io.EOF { 1142 var snapshot bytes.Buffer 1143 io.Copy(&snapshot, ringBuffer) 1144 err = &smithy.DeserializationError{ 1145 Err: fmt.Errorf("failed to decode response body, %w", err), 1146 Snapshot: snapshot.Bytes(), 1147 } 1148 return err 1149 } 1150 1151 err := awsRestjson1_deserializeDocumentStatementTimeoutException(&output, shape) 1152 1153 if err != nil { 1154 var snapshot bytes.Buffer 1155 io.Copy(&snapshot, ringBuffer) 1156 err = &smithy.DeserializationError{ 1157 Err: fmt.Errorf("failed to decode response body, %w", err), 1158 Snapshot: snapshot.Bytes(), 1159 } 1160 return err 1161 } 1162 1163 errorBody.Seek(0, io.SeekStart) 1164 1165 return output 1166} 1167 1168func awsRestjson1_deserializeDocumentArrayOfArray(v *[]types.ArrayValue, value interface{}) error { 1169 if v == nil { 1170 return fmt.Errorf("unexpected nil of type %T", v) 1171 } 1172 if value == nil { 1173 return nil 1174 } 1175 1176 shape, ok := value.([]interface{}) 1177 if !ok { 1178 return fmt.Errorf("unexpected JSON type %v", value) 1179 } 1180 1181 var cv []types.ArrayValue 1182 if *v == nil { 1183 cv = []types.ArrayValue{} 1184 } else { 1185 cv = *v 1186 } 1187 1188 for _, value := range shape { 1189 var col types.ArrayValue 1190 if err := awsRestjson1_deserializeDocumentArrayValue(&col, value); err != nil { 1191 return err 1192 } 1193 cv = append(cv, col) 1194 1195 } 1196 *v = cv 1197 return nil 1198} 1199 1200func awsRestjson1_deserializeDocumentArrayValue(v *types.ArrayValue, value interface{}) error { 1201 if v == nil { 1202 return fmt.Errorf("unexpected nil of type %T", v) 1203 } 1204 if value == nil { 1205 return nil 1206 } 1207 1208 shape, ok := value.(map[string]interface{}) 1209 if !ok { 1210 return fmt.Errorf("unexpected JSON type %v", value) 1211 } 1212 1213 var uv types.ArrayValue 1214loop: 1215 for key, value := range shape { 1216 if value == nil { 1217 continue 1218 } 1219 switch key { 1220 case "arrayValues": 1221 var mv []types.ArrayValue 1222 if err := awsRestjson1_deserializeDocumentArrayOfArray(&mv, value); err != nil { 1223 return err 1224 } 1225 uv = &types.ArrayValueMemberArrayValues{Value: mv} 1226 break loop 1227 1228 case "booleanValues": 1229 var mv []bool 1230 if err := awsRestjson1_deserializeDocumentBooleanArray(&mv, value); err != nil { 1231 return err 1232 } 1233 uv = &types.ArrayValueMemberBooleanValues{Value: mv} 1234 break loop 1235 1236 case "doubleValues": 1237 var mv []float64 1238 if err := awsRestjson1_deserializeDocumentDoubleArray(&mv, value); err != nil { 1239 return err 1240 } 1241 uv = &types.ArrayValueMemberDoubleValues{Value: mv} 1242 break loop 1243 1244 case "longValues": 1245 var mv []int64 1246 if err := awsRestjson1_deserializeDocumentLongArray(&mv, value); err != nil { 1247 return err 1248 } 1249 uv = &types.ArrayValueMemberLongValues{Value: mv} 1250 break loop 1251 1252 case "stringValues": 1253 var mv []string 1254 if err := awsRestjson1_deserializeDocumentStringArray(&mv, value); err != nil { 1255 return err 1256 } 1257 uv = &types.ArrayValueMemberStringValues{Value: mv} 1258 break loop 1259 1260 default: 1261 uv = &types.UnknownUnionMember{Tag: key} 1262 break loop 1263 1264 } 1265 } 1266 *v = uv 1267 return nil 1268} 1269 1270func awsRestjson1_deserializeDocumentArrayValueList(v *[]types.Value, value interface{}) error { 1271 if v == nil { 1272 return fmt.Errorf("unexpected nil of type %T", v) 1273 } 1274 if value == nil { 1275 return nil 1276 } 1277 1278 shape, ok := value.([]interface{}) 1279 if !ok { 1280 return fmt.Errorf("unexpected JSON type %v", value) 1281 } 1282 1283 var cv []types.Value 1284 if *v == nil { 1285 cv = []types.Value{} 1286 } else { 1287 cv = *v 1288 } 1289 1290 for _, value := range shape { 1291 var col types.Value 1292 if err := awsRestjson1_deserializeDocumentValue(&col, value); err != nil { 1293 return err 1294 } 1295 cv = append(cv, col) 1296 1297 } 1298 *v = cv 1299 return nil 1300} 1301 1302func awsRestjson1_deserializeDocumentBadRequestException(v **types.BadRequestException, value interface{}) error { 1303 if v == nil { 1304 return fmt.Errorf("unexpected nil of type %T", v) 1305 } 1306 if value == nil { 1307 return nil 1308 } 1309 1310 shape, ok := value.(map[string]interface{}) 1311 if !ok { 1312 return fmt.Errorf("unexpected JSON type %v", value) 1313 } 1314 1315 var sv *types.BadRequestException 1316 if *v == nil { 1317 sv = &types.BadRequestException{} 1318 } else { 1319 sv = *v 1320 } 1321 1322 for key, value := range shape { 1323 switch key { 1324 case "message": 1325 if value != nil { 1326 jtv, ok := value.(string) 1327 if !ok { 1328 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 1329 } 1330 sv.Message = ptr.String(jtv) 1331 } 1332 1333 default: 1334 _, _ = key, value 1335 1336 } 1337 } 1338 *v = sv 1339 return nil 1340} 1341 1342func awsRestjson1_deserializeDocumentBooleanArray(v *[]bool, value interface{}) error { 1343 if v == nil { 1344 return fmt.Errorf("unexpected nil of type %T", v) 1345 } 1346 if value == nil { 1347 return nil 1348 } 1349 1350 shape, ok := value.([]interface{}) 1351 if !ok { 1352 return fmt.Errorf("unexpected JSON type %v", value) 1353 } 1354 1355 var cv []bool 1356 if *v == nil { 1357 cv = []bool{} 1358 } else { 1359 cv = *v 1360 } 1361 1362 for _, value := range shape { 1363 var col bool 1364 if value != nil { 1365 jtv, ok := value.(bool) 1366 if !ok { 1367 return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value) 1368 } 1369 col = jtv 1370 } 1371 cv = append(cv, col) 1372 1373 } 1374 *v = cv 1375 return nil 1376} 1377 1378func awsRestjson1_deserializeDocumentColumnMetadata(v **types.ColumnMetadata, value interface{}) error { 1379 if v == nil { 1380 return fmt.Errorf("unexpected nil of type %T", v) 1381 } 1382 if value == nil { 1383 return nil 1384 } 1385 1386 shape, ok := value.(map[string]interface{}) 1387 if !ok { 1388 return fmt.Errorf("unexpected JSON type %v", value) 1389 } 1390 1391 var sv *types.ColumnMetadata 1392 if *v == nil { 1393 sv = &types.ColumnMetadata{} 1394 } else { 1395 sv = *v 1396 } 1397 1398 for key, value := range shape { 1399 switch key { 1400 case "arrayBaseColumnType": 1401 if value != nil { 1402 jtv, ok := value.(json.Number) 1403 if !ok { 1404 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 1405 } 1406 i64, err := jtv.Int64() 1407 if err != nil { 1408 return err 1409 } 1410 sv.ArrayBaseColumnType = int32(i64) 1411 } 1412 1413 case "isAutoIncrement": 1414 if value != nil { 1415 jtv, ok := value.(bool) 1416 if !ok { 1417 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 1418 } 1419 sv.IsAutoIncrement = jtv 1420 } 1421 1422 case "isCaseSensitive": 1423 if value != nil { 1424 jtv, ok := value.(bool) 1425 if !ok { 1426 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 1427 } 1428 sv.IsCaseSensitive = jtv 1429 } 1430 1431 case "isCurrency": 1432 if value != nil { 1433 jtv, ok := value.(bool) 1434 if !ok { 1435 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 1436 } 1437 sv.IsCurrency = jtv 1438 } 1439 1440 case "isSigned": 1441 if value != nil { 1442 jtv, ok := value.(bool) 1443 if !ok { 1444 return fmt.Errorf("expected Boolean to be of type *bool, got %T instead", value) 1445 } 1446 sv.IsSigned = jtv 1447 } 1448 1449 case "label": 1450 if value != nil { 1451 jtv, ok := value.(string) 1452 if !ok { 1453 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1454 } 1455 sv.Label = ptr.String(jtv) 1456 } 1457 1458 case "name": 1459 if value != nil { 1460 jtv, ok := value.(string) 1461 if !ok { 1462 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1463 } 1464 sv.Name = ptr.String(jtv) 1465 } 1466 1467 case "nullable": 1468 if value != nil { 1469 jtv, ok := value.(json.Number) 1470 if !ok { 1471 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 1472 } 1473 i64, err := jtv.Int64() 1474 if err != nil { 1475 return err 1476 } 1477 sv.Nullable = int32(i64) 1478 } 1479 1480 case "precision": 1481 if value != nil { 1482 jtv, ok := value.(json.Number) 1483 if !ok { 1484 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 1485 } 1486 i64, err := jtv.Int64() 1487 if err != nil { 1488 return err 1489 } 1490 sv.Precision = int32(i64) 1491 } 1492 1493 case "scale": 1494 if value != nil { 1495 jtv, ok := value.(json.Number) 1496 if !ok { 1497 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 1498 } 1499 i64, err := jtv.Int64() 1500 if err != nil { 1501 return err 1502 } 1503 sv.Scale = int32(i64) 1504 } 1505 1506 case "schemaName": 1507 if value != nil { 1508 jtv, ok := value.(string) 1509 if !ok { 1510 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1511 } 1512 sv.SchemaName = ptr.String(jtv) 1513 } 1514 1515 case "tableName": 1516 if value != nil { 1517 jtv, ok := value.(string) 1518 if !ok { 1519 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1520 } 1521 sv.TableName = ptr.String(jtv) 1522 } 1523 1524 case "type": 1525 if value != nil { 1526 jtv, ok := value.(json.Number) 1527 if !ok { 1528 return fmt.Errorf("expected Integer to be json.Number, got %T instead", value) 1529 } 1530 i64, err := jtv.Int64() 1531 if err != nil { 1532 return err 1533 } 1534 sv.Type = int32(i64) 1535 } 1536 1537 case "typeName": 1538 if value != nil { 1539 jtv, ok := value.(string) 1540 if !ok { 1541 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1542 } 1543 sv.TypeName = ptr.String(jtv) 1544 } 1545 1546 default: 1547 _, _ = key, value 1548 1549 } 1550 } 1551 *v = sv 1552 return nil 1553} 1554 1555func awsRestjson1_deserializeDocumentDoubleArray(v *[]float64, value interface{}) error { 1556 if v == nil { 1557 return fmt.Errorf("unexpected nil of type %T", v) 1558 } 1559 if value == nil { 1560 return nil 1561 } 1562 1563 shape, ok := value.([]interface{}) 1564 if !ok { 1565 return fmt.Errorf("unexpected JSON type %v", value) 1566 } 1567 1568 var cv []float64 1569 if *v == nil { 1570 cv = []float64{} 1571 } else { 1572 cv = *v 1573 } 1574 1575 for _, value := range shape { 1576 var col float64 1577 if value != nil { 1578 jtv, ok := value.(json.Number) 1579 if !ok { 1580 return fmt.Errorf("expected BoxedDouble to be json.Number, got %T instead", value) 1581 } 1582 f64, err := jtv.Float64() 1583 if err != nil { 1584 return err 1585 } 1586 col = f64 1587 } 1588 cv = append(cv, col) 1589 1590 } 1591 *v = cv 1592 return nil 1593} 1594 1595func awsRestjson1_deserializeDocumentField(v *types.Field, value interface{}) error { 1596 if v == nil { 1597 return fmt.Errorf("unexpected nil of type %T", v) 1598 } 1599 if value == nil { 1600 return nil 1601 } 1602 1603 shape, ok := value.(map[string]interface{}) 1604 if !ok { 1605 return fmt.Errorf("unexpected JSON type %v", value) 1606 } 1607 1608 var uv types.Field 1609loop: 1610 for key, value := range shape { 1611 if value == nil { 1612 continue 1613 } 1614 switch key { 1615 case "arrayValue": 1616 var mv types.ArrayValue 1617 if err := awsRestjson1_deserializeDocumentArrayValue(&mv, value); err != nil { 1618 return err 1619 } 1620 uv = &types.FieldMemberArrayValue{Value: mv} 1621 break loop 1622 1623 case "blobValue": 1624 var mv []byte 1625 if value != nil { 1626 jtv, ok := value.(string) 1627 if !ok { 1628 return fmt.Errorf("expected Blob to be []byte, got %T instead", value) 1629 } 1630 dv, err := base64.StdEncoding.DecodeString(jtv) 1631 if err != nil { 1632 return fmt.Errorf("failed to base64 decode Blob, %w", err) 1633 } 1634 mv = dv 1635 } 1636 uv = &types.FieldMemberBlobValue{Value: mv} 1637 break loop 1638 1639 case "booleanValue": 1640 var mv bool 1641 if value != nil { 1642 jtv, ok := value.(bool) 1643 if !ok { 1644 return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value) 1645 } 1646 mv = jtv 1647 } 1648 uv = &types.FieldMemberBooleanValue{Value: mv} 1649 break loop 1650 1651 case "doubleValue": 1652 var mv float64 1653 if value != nil { 1654 jtv, ok := value.(json.Number) 1655 if !ok { 1656 return fmt.Errorf("expected BoxedDouble to be json.Number, got %T instead", value) 1657 } 1658 f64, err := jtv.Float64() 1659 if err != nil { 1660 return err 1661 } 1662 mv = f64 1663 } 1664 uv = &types.FieldMemberDoubleValue{Value: mv} 1665 break loop 1666 1667 case "isNull": 1668 var mv bool 1669 if value != nil { 1670 jtv, ok := value.(bool) 1671 if !ok { 1672 return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value) 1673 } 1674 mv = jtv 1675 } 1676 uv = &types.FieldMemberIsNull{Value: mv} 1677 break loop 1678 1679 case "longValue": 1680 var mv int64 1681 if value != nil { 1682 jtv, ok := value.(json.Number) 1683 if !ok { 1684 return fmt.Errorf("expected BoxedLong to be json.Number, got %T instead", value) 1685 } 1686 i64, err := jtv.Int64() 1687 if err != nil { 1688 return err 1689 } 1690 mv = i64 1691 } 1692 uv = &types.FieldMemberLongValue{Value: mv} 1693 break loop 1694 1695 case "stringValue": 1696 var mv string 1697 if value != nil { 1698 jtv, ok := value.(string) 1699 if !ok { 1700 return fmt.Errorf("expected String to be of type string, got %T instead", value) 1701 } 1702 mv = jtv 1703 } 1704 uv = &types.FieldMemberStringValue{Value: mv} 1705 break loop 1706 1707 default: 1708 uv = &types.UnknownUnionMember{Tag: key} 1709 break loop 1710 1711 } 1712 } 1713 *v = uv 1714 return nil 1715} 1716 1717func awsRestjson1_deserializeDocumentFieldList(v *[]types.Field, value interface{}) error { 1718 if v == nil { 1719 return fmt.Errorf("unexpected nil of type %T", v) 1720 } 1721 if value == nil { 1722 return nil 1723 } 1724 1725 shape, ok := value.([]interface{}) 1726 if !ok { 1727 return fmt.Errorf("unexpected JSON type %v", value) 1728 } 1729 1730 var cv []types.Field 1731 if *v == nil { 1732 cv = []types.Field{} 1733 } else { 1734 cv = *v 1735 } 1736 1737 for _, value := range shape { 1738 var col types.Field 1739 if err := awsRestjson1_deserializeDocumentField(&col, value); err != nil { 1740 return err 1741 } 1742 cv = append(cv, col) 1743 1744 } 1745 *v = cv 1746 return nil 1747} 1748 1749func awsRestjson1_deserializeDocumentForbiddenException(v **types.ForbiddenException, value interface{}) error { 1750 if v == nil { 1751 return fmt.Errorf("unexpected nil of type %T", v) 1752 } 1753 if value == nil { 1754 return nil 1755 } 1756 1757 shape, ok := value.(map[string]interface{}) 1758 if !ok { 1759 return fmt.Errorf("unexpected JSON type %v", value) 1760 } 1761 1762 var sv *types.ForbiddenException 1763 if *v == nil { 1764 sv = &types.ForbiddenException{} 1765 } else { 1766 sv = *v 1767 } 1768 1769 for key, value := range shape { 1770 switch key { 1771 case "message": 1772 if value != nil { 1773 jtv, ok := value.(string) 1774 if !ok { 1775 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 1776 } 1777 sv.Message = ptr.String(jtv) 1778 } 1779 1780 default: 1781 _, _ = key, value 1782 1783 } 1784 } 1785 *v = sv 1786 return nil 1787} 1788 1789func awsRestjson1_deserializeDocumentInternalServerErrorException(v **types.InternalServerErrorException, value interface{}) error { 1790 if v == nil { 1791 return fmt.Errorf("unexpected nil of type %T", v) 1792 } 1793 if value == nil { 1794 return nil 1795 } 1796 1797 shape, ok := value.(map[string]interface{}) 1798 if !ok { 1799 return fmt.Errorf("unexpected JSON type %v", value) 1800 } 1801 1802 var sv *types.InternalServerErrorException 1803 if *v == nil { 1804 sv = &types.InternalServerErrorException{} 1805 } else { 1806 sv = *v 1807 } 1808 1809 for key, value := range shape { 1810 switch key { 1811 default: 1812 _, _ = key, value 1813 1814 } 1815 } 1816 *v = sv 1817 return nil 1818} 1819 1820func awsRestjson1_deserializeDocumentLongArray(v *[]int64, value interface{}) error { 1821 if v == nil { 1822 return fmt.Errorf("unexpected nil of type %T", v) 1823 } 1824 if value == nil { 1825 return nil 1826 } 1827 1828 shape, ok := value.([]interface{}) 1829 if !ok { 1830 return fmt.Errorf("unexpected JSON type %v", value) 1831 } 1832 1833 var cv []int64 1834 if *v == nil { 1835 cv = []int64{} 1836 } else { 1837 cv = *v 1838 } 1839 1840 for _, value := range shape { 1841 var col int64 1842 if value != nil { 1843 jtv, ok := value.(json.Number) 1844 if !ok { 1845 return fmt.Errorf("expected BoxedLong to be json.Number, got %T instead", value) 1846 } 1847 i64, err := jtv.Int64() 1848 if err != nil { 1849 return err 1850 } 1851 col = i64 1852 } 1853 cv = append(cv, col) 1854 1855 } 1856 *v = cv 1857 return nil 1858} 1859 1860func awsRestjson1_deserializeDocumentMetadata(v *[]types.ColumnMetadata, value interface{}) error { 1861 if v == nil { 1862 return fmt.Errorf("unexpected nil of type %T", v) 1863 } 1864 if value == nil { 1865 return nil 1866 } 1867 1868 shape, ok := value.([]interface{}) 1869 if !ok { 1870 return fmt.Errorf("unexpected JSON type %v", value) 1871 } 1872 1873 var cv []types.ColumnMetadata 1874 if *v == nil { 1875 cv = []types.ColumnMetadata{} 1876 } else { 1877 cv = *v 1878 } 1879 1880 for _, value := range shape { 1881 var col types.ColumnMetadata 1882 destAddr := &col 1883 if err := awsRestjson1_deserializeDocumentColumnMetadata(&destAddr, value); err != nil { 1884 return err 1885 } 1886 col = *destAddr 1887 cv = append(cv, col) 1888 1889 } 1890 *v = cv 1891 return nil 1892} 1893 1894func awsRestjson1_deserializeDocumentNotFoundException(v **types.NotFoundException, value interface{}) error { 1895 if v == nil { 1896 return fmt.Errorf("unexpected nil of type %T", v) 1897 } 1898 if value == nil { 1899 return nil 1900 } 1901 1902 shape, ok := value.(map[string]interface{}) 1903 if !ok { 1904 return fmt.Errorf("unexpected JSON type %v", value) 1905 } 1906 1907 var sv *types.NotFoundException 1908 if *v == nil { 1909 sv = &types.NotFoundException{} 1910 } else { 1911 sv = *v 1912 } 1913 1914 for key, value := range shape { 1915 switch key { 1916 case "message": 1917 if value != nil { 1918 jtv, ok := value.(string) 1919 if !ok { 1920 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 1921 } 1922 sv.Message = ptr.String(jtv) 1923 } 1924 1925 default: 1926 _, _ = key, value 1927 1928 } 1929 } 1930 *v = sv 1931 return nil 1932} 1933 1934func awsRestjson1_deserializeDocumentRecord(v **types.Record, value interface{}) error { 1935 if v == nil { 1936 return fmt.Errorf("unexpected nil of type %T", v) 1937 } 1938 if value == nil { 1939 return nil 1940 } 1941 1942 shape, ok := value.(map[string]interface{}) 1943 if !ok { 1944 return fmt.Errorf("unexpected JSON type %v", value) 1945 } 1946 1947 var sv *types.Record 1948 if *v == nil { 1949 sv = &types.Record{} 1950 } else { 1951 sv = *v 1952 } 1953 1954 for key, value := range shape { 1955 switch key { 1956 case "values": 1957 if err := awsRestjson1_deserializeDocumentRow(&sv.Values, value); err != nil { 1958 return err 1959 } 1960 1961 default: 1962 _, _ = key, value 1963 1964 } 1965 } 1966 *v = sv 1967 return nil 1968} 1969 1970func awsRestjson1_deserializeDocumentRecords(v *[]types.Record, value interface{}) error { 1971 if v == nil { 1972 return fmt.Errorf("unexpected nil of type %T", v) 1973 } 1974 if value == nil { 1975 return nil 1976 } 1977 1978 shape, ok := value.([]interface{}) 1979 if !ok { 1980 return fmt.Errorf("unexpected JSON type %v", value) 1981 } 1982 1983 var cv []types.Record 1984 if *v == nil { 1985 cv = []types.Record{} 1986 } else { 1987 cv = *v 1988 } 1989 1990 for _, value := range shape { 1991 var col types.Record 1992 destAddr := &col 1993 if err := awsRestjson1_deserializeDocumentRecord(&destAddr, value); err != nil { 1994 return err 1995 } 1996 col = *destAddr 1997 cv = append(cv, col) 1998 1999 } 2000 *v = cv 2001 return nil 2002} 2003 2004func awsRestjson1_deserializeDocumentResultFrame(v **types.ResultFrame, value interface{}) error { 2005 if v == nil { 2006 return fmt.Errorf("unexpected nil of type %T", v) 2007 } 2008 if value == nil { 2009 return nil 2010 } 2011 2012 shape, ok := value.(map[string]interface{}) 2013 if !ok { 2014 return fmt.Errorf("unexpected JSON type %v", value) 2015 } 2016 2017 var sv *types.ResultFrame 2018 if *v == nil { 2019 sv = &types.ResultFrame{} 2020 } else { 2021 sv = *v 2022 } 2023 2024 for key, value := range shape { 2025 switch key { 2026 case "records": 2027 if err := awsRestjson1_deserializeDocumentRecords(&sv.Records, value); err != nil { 2028 return err 2029 } 2030 2031 case "resultSetMetadata": 2032 if err := awsRestjson1_deserializeDocumentResultSetMetadata(&sv.ResultSetMetadata, value); err != nil { 2033 return err 2034 } 2035 2036 default: 2037 _, _ = key, value 2038 2039 } 2040 } 2041 *v = sv 2042 return nil 2043} 2044 2045func awsRestjson1_deserializeDocumentResultSetMetadata(v **types.ResultSetMetadata, value interface{}) error { 2046 if v == nil { 2047 return fmt.Errorf("unexpected nil of type %T", v) 2048 } 2049 if value == nil { 2050 return nil 2051 } 2052 2053 shape, ok := value.(map[string]interface{}) 2054 if !ok { 2055 return fmt.Errorf("unexpected JSON type %v", value) 2056 } 2057 2058 var sv *types.ResultSetMetadata 2059 if *v == nil { 2060 sv = &types.ResultSetMetadata{} 2061 } else { 2062 sv = *v 2063 } 2064 2065 for key, value := range shape { 2066 switch key { 2067 case "columnCount": 2068 if value != nil { 2069 jtv, ok := value.(json.Number) 2070 if !ok { 2071 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 2072 } 2073 i64, err := jtv.Int64() 2074 if err != nil { 2075 return err 2076 } 2077 sv.ColumnCount = i64 2078 } 2079 2080 case "columnMetadata": 2081 if err := awsRestjson1_deserializeDocumentMetadata(&sv.ColumnMetadata, value); err != nil { 2082 return err 2083 } 2084 2085 default: 2086 _, _ = key, value 2087 2088 } 2089 } 2090 *v = sv 2091 return nil 2092} 2093 2094func awsRestjson1_deserializeDocumentRow(v *[]types.Value, value interface{}) error { 2095 if v == nil { 2096 return fmt.Errorf("unexpected nil of type %T", v) 2097 } 2098 if value == nil { 2099 return nil 2100 } 2101 2102 shape, ok := value.([]interface{}) 2103 if !ok { 2104 return fmt.Errorf("unexpected JSON type %v", value) 2105 } 2106 2107 var cv []types.Value 2108 if *v == nil { 2109 cv = []types.Value{} 2110 } else { 2111 cv = *v 2112 } 2113 2114 for _, value := range shape { 2115 var col types.Value 2116 if err := awsRestjson1_deserializeDocumentValue(&col, value); err != nil { 2117 return err 2118 } 2119 cv = append(cv, col) 2120 2121 } 2122 *v = cv 2123 return nil 2124} 2125 2126func awsRestjson1_deserializeDocumentServiceUnavailableError(v **types.ServiceUnavailableError, value interface{}) error { 2127 if v == nil { 2128 return fmt.Errorf("unexpected nil of type %T", v) 2129 } 2130 if value == nil { 2131 return nil 2132 } 2133 2134 shape, ok := value.(map[string]interface{}) 2135 if !ok { 2136 return fmt.Errorf("unexpected JSON type %v", value) 2137 } 2138 2139 var sv *types.ServiceUnavailableError 2140 if *v == nil { 2141 sv = &types.ServiceUnavailableError{} 2142 } else { 2143 sv = *v 2144 } 2145 2146 for key, value := range shape { 2147 switch key { 2148 default: 2149 _, _ = key, value 2150 2151 } 2152 } 2153 *v = sv 2154 return nil 2155} 2156 2157func awsRestjson1_deserializeDocumentSqlRecords(v *[][]types.Field, value interface{}) error { 2158 if v == nil { 2159 return fmt.Errorf("unexpected nil of type %T", v) 2160 } 2161 if value == nil { 2162 return nil 2163 } 2164 2165 shape, ok := value.([]interface{}) 2166 if !ok { 2167 return fmt.Errorf("unexpected JSON type %v", value) 2168 } 2169 2170 var cv [][]types.Field 2171 if *v == nil { 2172 cv = [][]types.Field{} 2173 } else { 2174 cv = *v 2175 } 2176 2177 for _, value := range shape { 2178 var col []types.Field 2179 if err := awsRestjson1_deserializeDocumentFieldList(&col, value); err != nil { 2180 return err 2181 } 2182 cv = append(cv, col) 2183 2184 } 2185 *v = cv 2186 return nil 2187} 2188 2189func awsRestjson1_deserializeDocumentSqlStatementResult(v **types.SqlStatementResult, value interface{}) error { 2190 if v == nil { 2191 return fmt.Errorf("unexpected nil of type %T", v) 2192 } 2193 if value == nil { 2194 return nil 2195 } 2196 2197 shape, ok := value.(map[string]interface{}) 2198 if !ok { 2199 return fmt.Errorf("unexpected JSON type %v", value) 2200 } 2201 2202 var sv *types.SqlStatementResult 2203 if *v == nil { 2204 sv = &types.SqlStatementResult{} 2205 } else { 2206 sv = *v 2207 } 2208 2209 for key, value := range shape { 2210 switch key { 2211 case "numberOfRecordsUpdated": 2212 if value != nil { 2213 jtv, ok := value.(json.Number) 2214 if !ok { 2215 return fmt.Errorf("expected RecordsUpdated to be json.Number, got %T instead", value) 2216 } 2217 i64, err := jtv.Int64() 2218 if err != nil { 2219 return err 2220 } 2221 sv.NumberOfRecordsUpdated = i64 2222 } 2223 2224 case "resultFrame": 2225 if err := awsRestjson1_deserializeDocumentResultFrame(&sv.ResultFrame, value); err != nil { 2226 return err 2227 } 2228 2229 default: 2230 _, _ = key, value 2231 2232 } 2233 } 2234 *v = sv 2235 return nil 2236} 2237 2238func awsRestjson1_deserializeDocumentSqlStatementResults(v *[]types.SqlStatementResult, value interface{}) error { 2239 if v == nil { 2240 return fmt.Errorf("unexpected nil of type %T", v) 2241 } 2242 if value == nil { 2243 return nil 2244 } 2245 2246 shape, ok := value.([]interface{}) 2247 if !ok { 2248 return fmt.Errorf("unexpected JSON type %v", value) 2249 } 2250 2251 var cv []types.SqlStatementResult 2252 if *v == nil { 2253 cv = []types.SqlStatementResult{} 2254 } else { 2255 cv = *v 2256 } 2257 2258 for _, value := range shape { 2259 var col types.SqlStatementResult 2260 destAddr := &col 2261 if err := awsRestjson1_deserializeDocumentSqlStatementResult(&destAddr, value); err != nil { 2262 return err 2263 } 2264 col = *destAddr 2265 cv = append(cv, col) 2266 2267 } 2268 *v = cv 2269 return nil 2270} 2271 2272func awsRestjson1_deserializeDocumentStatementTimeoutException(v **types.StatementTimeoutException, value interface{}) error { 2273 if v == nil { 2274 return fmt.Errorf("unexpected nil of type %T", v) 2275 } 2276 if value == nil { 2277 return nil 2278 } 2279 2280 shape, ok := value.(map[string]interface{}) 2281 if !ok { 2282 return fmt.Errorf("unexpected JSON type %v", value) 2283 } 2284 2285 var sv *types.StatementTimeoutException 2286 if *v == nil { 2287 sv = &types.StatementTimeoutException{} 2288 } else { 2289 sv = *v 2290 } 2291 2292 for key, value := range shape { 2293 switch key { 2294 case "dbConnectionId": 2295 if value != nil { 2296 jtv, ok := value.(json.Number) 2297 if !ok { 2298 return fmt.Errorf("expected Long to be json.Number, got %T instead", value) 2299 } 2300 i64, err := jtv.Int64() 2301 if err != nil { 2302 return err 2303 } 2304 sv.DbConnectionId = i64 2305 } 2306 2307 case "message": 2308 if value != nil { 2309 jtv, ok := value.(string) 2310 if !ok { 2311 return fmt.Errorf("expected ErrorMessage to be of type string, got %T instead", value) 2312 } 2313 sv.Message = ptr.String(jtv) 2314 } 2315 2316 default: 2317 _, _ = key, value 2318 2319 } 2320 } 2321 *v = sv 2322 return nil 2323} 2324 2325func awsRestjson1_deserializeDocumentStringArray(v *[]string, value interface{}) error { 2326 if v == nil { 2327 return fmt.Errorf("unexpected nil of type %T", v) 2328 } 2329 if value == nil { 2330 return nil 2331 } 2332 2333 shape, ok := value.([]interface{}) 2334 if !ok { 2335 return fmt.Errorf("unexpected JSON type %v", value) 2336 } 2337 2338 var cv []string 2339 if *v == nil { 2340 cv = []string{} 2341 } else { 2342 cv = *v 2343 } 2344 2345 for _, value := range shape { 2346 var col string 2347 if value != nil { 2348 jtv, ok := value.(string) 2349 if !ok { 2350 return fmt.Errorf("expected String to be of type string, got %T instead", value) 2351 } 2352 col = jtv 2353 } 2354 cv = append(cv, col) 2355 2356 } 2357 *v = cv 2358 return nil 2359} 2360 2361func awsRestjson1_deserializeDocumentStructValue(v **types.StructValue, value interface{}) error { 2362 if v == nil { 2363 return fmt.Errorf("unexpected nil of type %T", v) 2364 } 2365 if value == nil { 2366 return nil 2367 } 2368 2369 shape, ok := value.(map[string]interface{}) 2370 if !ok { 2371 return fmt.Errorf("unexpected JSON type %v", value) 2372 } 2373 2374 var sv *types.StructValue 2375 if *v == nil { 2376 sv = &types.StructValue{} 2377 } else { 2378 sv = *v 2379 } 2380 2381 for key, value := range shape { 2382 switch key { 2383 case "attributes": 2384 if err := awsRestjson1_deserializeDocumentArrayValueList(&sv.Attributes, value); err != nil { 2385 return err 2386 } 2387 2388 default: 2389 _, _ = key, value 2390 2391 } 2392 } 2393 *v = sv 2394 return nil 2395} 2396 2397func awsRestjson1_deserializeDocumentUpdateResult(v **types.UpdateResult, value interface{}) error { 2398 if v == nil { 2399 return fmt.Errorf("unexpected nil of type %T", v) 2400 } 2401 if value == nil { 2402 return nil 2403 } 2404 2405 shape, ok := value.(map[string]interface{}) 2406 if !ok { 2407 return fmt.Errorf("unexpected JSON type %v", value) 2408 } 2409 2410 var sv *types.UpdateResult 2411 if *v == nil { 2412 sv = &types.UpdateResult{} 2413 } else { 2414 sv = *v 2415 } 2416 2417 for key, value := range shape { 2418 switch key { 2419 case "generatedFields": 2420 if err := awsRestjson1_deserializeDocumentFieldList(&sv.GeneratedFields, value); err != nil { 2421 return err 2422 } 2423 2424 default: 2425 _, _ = key, value 2426 2427 } 2428 } 2429 *v = sv 2430 return nil 2431} 2432 2433func awsRestjson1_deserializeDocumentUpdateResults(v *[]types.UpdateResult, value interface{}) error { 2434 if v == nil { 2435 return fmt.Errorf("unexpected nil of type %T", v) 2436 } 2437 if value == nil { 2438 return nil 2439 } 2440 2441 shape, ok := value.([]interface{}) 2442 if !ok { 2443 return fmt.Errorf("unexpected JSON type %v", value) 2444 } 2445 2446 var cv []types.UpdateResult 2447 if *v == nil { 2448 cv = []types.UpdateResult{} 2449 } else { 2450 cv = *v 2451 } 2452 2453 for _, value := range shape { 2454 var col types.UpdateResult 2455 destAddr := &col 2456 if err := awsRestjson1_deserializeDocumentUpdateResult(&destAddr, value); err != nil { 2457 return err 2458 } 2459 col = *destAddr 2460 cv = append(cv, col) 2461 2462 } 2463 *v = cv 2464 return nil 2465} 2466 2467func awsRestjson1_deserializeDocumentValue(v *types.Value, value interface{}) error { 2468 if v == nil { 2469 return fmt.Errorf("unexpected nil of type %T", v) 2470 } 2471 if value == nil { 2472 return nil 2473 } 2474 2475 shape, ok := value.(map[string]interface{}) 2476 if !ok { 2477 return fmt.Errorf("unexpected JSON type %v", value) 2478 } 2479 2480 var uv types.Value 2481loop: 2482 for key, value := range shape { 2483 if value == nil { 2484 continue 2485 } 2486 switch key { 2487 case "arrayValues": 2488 var mv []types.Value 2489 if err := awsRestjson1_deserializeDocumentArrayValueList(&mv, value); err != nil { 2490 return err 2491 } 2492 uv = &types.ValueMemberArrayValues{Value: mv} 2493 break loop 2494 2495 case "bigIntValue": 2496 var mv int64 2497 if value != nil { 2498 jtv, ok := value.(json.Number) 2499 if !ok { 2500 return fmt.Errorf("expected BoxedLong to be json.Number, got %T instead", value) 2501 } 2502 i64, err := jtv.Int64() 2503 if err != nil { 2504 return err 2505 } 2506 mv = i64 2507 } 2508 uv = &types.ValueMemberBigIntValue{Value: mv} 2509 break loop 2510 2511 case "bitValue": 2512 var mv bool 2513 if value != nil { 2514 jtv, ok := value.(bool) 2515 if !ok { 2516 return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value) 2517 } 2518 mv = jtv 2519 } 2520 uv = &types.ValueMemberBitValue{Value: mv} 2521 break loop 2522 2523 case "blobValue": 2524 var mv []byte 2525 if value != nil { 2526 jtv, ok := value.(string) 2527 if !ok { 2528 return fmt.Errorf("expected Blob to be []byte, got %T instead", value) 2529 } 2530 dv, err := base64.StdEncoding.DecodeString(jtv) 2531 if err != nil { 2532 return fmt.Errorf("failed to base64 decode Blob, %w", err) 2533 } 2534 mv = dv 2535 } 2536 uv = &types.ValueMemberBlobValue{Value: mv} 2537 break loop 2538 2539 case "doubleValue": 2540 var mv float64 2541 if value != nil { 2542 jtv, ok := value.(json.Number) 2543 if !ok { 2544 return fmt.Errorf("expected BoxedDouble to be json.Number, got %T instead", value) 2545 } 2546 f64, err := jtv.Float64() 2547 if err != nil { 2548 return err 2549 } 2550 mv = f64 2551 } 2552 uv = &types.ValueMemberDoubleValue{Value: mv} 2553 break loop 2554 2555 case "intValue": 2556 var mv int32 2557 if value != nil { 2558 jtv, ok := value.(json.Number) 2559 if !ok { 2560 return fmt.Errorf("expected BoxedInteger to be json.Number, got %T instead", value) 2561 } 2562 i64, err := jtv.Int64() 2563 if err != nil { 2564 return err 2565 } 2566 mv = int32(i64) 2567 } 2568 uv = &types.ValueMemberIntValue{Value: mv} 2569 break loop 2570 2571 case "isNull": 2572 var mv bool 2573 if value != nil { 2574 jtv, ok := value.(bool) 2575 if !ok { 2576 return fmt.Errorf("expected BoxedBoolean to be of type *bool, got %T instead", value) 2577 } 2578 mv = jtv 2579 } 2580 uv = &types.ValueMemberIsNull{Value: mv} 2581 break loop 2582 2583 case "realValue": 2584 var mv float32 2585 if value != nil { 2586 jtv, ok := value.(json.Number) 2587 if !ok { 2588 return fmt.Errorf("expected BoxedFloat to be json.Number, got %T instead", value) 2589 } 2590 f64, err := jtv.Float64() 2591 if err != nil { 2592 return err 2593 } 2594 mv = float32(f64) 2595 } 2596 uv = &types.ValueMemberRealValue{Value: mv} 2597 break loop 2598 2599 case "stringValue": 2600 var mv string 2601 if value != nil { 2602 jtv, ok := value.(string) 2603 if !ok { 2604 return fmt.Errorf("expected String to be of type string, got %T instead", value) 2605 } 2606 mv = jtv 2607 } 2608 uv = &types.ValueMemberStringValue{Value: mv} 2609 break loop 2610 2611 case "structValue": 2612 var mv types.StructValue 2613 destAddr := &mv 2614 if err := awsRestjson1_deserializeDocumentStructValue(&destAddr, value); err != nil { 2615 return err 2616 } 2617 mv = *destAddr 2618 uv = &types.ValueMemberStructValue{Value: mv} 2619 break loop 2620 2621 default: 2622 uv = &types.UnknownUnionMember{Tag: key} 2623 break loop 2624 2625 } 2626 } 2627 *v = uv 2628 return nil 2629} 2630