1 /* 2 * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"). 5 * You may not use this file except in compliance with the License. 6 * A copy of the License is located at 7 * 8 * http://aws.amazon.com/apache2.0 9 * 10 * or in the "license" file accompanying this file. This file is distributed 11 * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either 12 * express or implied. See the License for the specific language governing 13 * permissions and limitations under the License. 14 */ 15 16 package software.amazon.awssdk.enhanced.dynamodb; 17 18 import java.util.List; 19 import java.util.function.Consumer; 20 import software.amazon.awssdk.annotations.NotThreadSafe; 21 import software.amazon.awssdk.annotations.SdkPublicApi; 22 import software.amazon.awssdk.annotations.ThreadSafe; 23 import software.amazon.awssdk.core.pagination.sync.SdkIterable; 24 import software.amazon.awssdk.enhanced.dynamodb.internal.client.DefaultDynamoDbEnhancedClient; 25 import software.amazon.awssdk.enhanced.dynamodb.model.BatchGetItemEnhancedRequest; 26 import software.amazon.awssdk.enhanced.dynamodb.model.BatchGetResultPage; 27 import software.amazon.awssdk.enhanced.dynamodb.model.BatchGetResultPageIterable; 28 import software.amazon.awssdk.enhanced.dynamodb.model.BatchWriteItemEnhancedRequest; 29 import software.amazon.awssdk.enhanced.dynamodb.model.BatchWriteResult; 30 import software.amazon.awssdk.enhanced.dynamodb.model.ConditionCheck; 31 import software.amazon.awssdk.enhanced.dynamodb.model.DeleteItemEnhancedRequest; 32 import software.amazon.awssdk.enhanced.dynamodb.model.GetItemEnhancedRequest; 33 import software.amazon.awssdk.enhanced.dynamodb.model.PutItemEnhancedRequest; 34 import software.amazon.awssdk.enhanced.dynamodb.model.TransactGetItemsEnhancedRequest; 35 import software.amazon.awssdk.enhanced.dynamodb.model.TransactWriteItemsEnhancedRequest; 36 import software.amazon.awssdk.enhanced.dynamodb.model.UpdateItemEnhancedRequest; 37 import software.amazon.awssdk.services.dynamodb.DynamoDbClient; 38 import software.amazon.awssdk.services.dynamodb.model.BatchGetItemRequest; 39 40 /** 41 * Synchronous interface for running commands against a DynamoDb database. 42 * <p> 43 * By default, all command methods throw an {@link UnsupportedOperationException} to prevent interface extensions from breaking 44 * implementing classes. 45 */ 46 @SdkPublicApi 47 @ThreadSafe 48 public interface DynamoDbEnhancedClient extends DynamoDbEnhancedResource { 49 50 /** 51 * Returns a mapped table that can be used to execute commands that work with mapped items against that table. 52 * 53 * @param tableName The name of the physical table persisted by DynamoDb. 54 * @param tableSchema A {@link TableSchema} that maps the table to a modelled object. 55 * @return A {@link DynamoDbTable} object that can be used to execute table operations against. 56 * @param <T> The modelled object type being mapped to this table. 57 */ table(String tableName, TableSchema<T> tableSchema)58 <T> DynamoDbTable<T> table(String tableName, TableSchema<T> tableSchema); 59 60 /** 61 * Retrieves items from one or more tables by their primary keys, see {@link Key}. BatchGetItem is a composite operation 62 * where the request contains one batch of {@link GetItemEnhancedRequest} per targeted table. 63 * The operation makes several calls to the database; each time you iterate over the result to retrieve a page, 64 * a call is made for the items on that page. 65 * <p> 66 * The additional configuration parameters that the enhanced client supports are defined 67 * in the {@link BatchGetItemEnhancedRequest}. 68 * <p> 69 * <b>Partial results</b>. A single call to DynamoDb has restraints on how much data can be retrieved. 70 * If those limits are exceeded, the call yields a partial result. This may also be the case if 71 * provisional throughput is exceeded or there is an internal DynamoDb processing failure. The operation automatically 72 * retries any unprocessed keys returned from DynamoDb in subsequent calls for pages. 73 * <p> 74 * This operation calls the low-level {@link DynamoDbClient#batchGetItemPaginator} operation. Consult the BatchGetItem 75 * documentation for further details and constraints as well as current limits of data retrieval. 76 * <p> 77 * Example: 78 * <pre> 79 * {@code 80 * 81 * BatchGetResultPageIterable batchResults = enhancedClient.batchGetItem( 82 * BatchGetItemEnhancedRequest.builder() 83 * .readBatches(ReadBatch.builder(FirstItem.class) 84 * .mappedTableResource(firstItemTable) 85 * .addGetItem(GetItemEnhancedRequest.builder().key(key1).build()) 86 * .addGetItem(GetItemEnhancedRequest.builder().key(key2).build()) 87 * .build(), 88 * ReadBatch.builder(SecondItem.class) 89 * .mappedTableResource(secondItemTable) 90 * .addGetItem(GetItemEnhancedRequest.builder().key(key3).build()) 91 * .build()) 92 * .build()); 93 * } 94 * </pre> 95 * 96 * <p> 97 * The result can be accessed either through iterable {@link BatchGetResultPage}s or flattened results belonging to the 98 * supplied table across all pages. 99 * 100 * <p> 101 * 1) Iterating through pages 102 * <pre> 103 * {@code 104 * batchResults.forEach(page -> { 105 * page.resultsForTable(firstItemTable).forEach(item -> System.out.println(item)); 106 * page.resultsForTable(secondItemTable).forEach(item -> System.out.println(item)); 107 * }); 108 * } 109 * </pre> 110 * 111 * <p> 112 * 2) Iterating through results across all pages 113 * <pre> 114 * {@code 115 * results.resultsForTable(firstItemTable).forEach(item -> System.out.println(item)); 116 * results.resultsForTable(secondItemTable).forEach(item -> System.out.println(item)); 117 * } 118 * </pre> 119 * 120 * @param request A {@link BatchGetItemEnhancedRequest} containing keys grouped by tables. 121 * @return an iterator of type {@link SdkIterable} with paginated results of type {@link BatchGetResultPage}. 122 * @see #batchGetItem(Consumer) 123 * @see DynamoDbClient#batchGetItemPaginator 124 */ batchGetItem(BatchGetItemEnhancedRequest request)125 default BatchGetResultPageIterable batchGetItem(BatchGetItemEnhancedRequest request) { 126 throw new UnsupportedOperationException(); 127 } 128 129 /** 130 * Retrieves items from one or more tables by their primary keys, see {@link Key}. BatchGetItem is a composite operation 131 * where the request contains one batch of {@link GetItemEnhancedRequest} per targeted table. 132 * The operation makes several calls to the database; each time you iterate over the result to retrieve a page, 133 * a call is made for the items on that page. 134 * <p> 135 * <b>Note:</b> This is a convenience method that creates an instance of the request builder avoiding the need to create one 136 * manually via {@link BatchGetItemEnhancedRequest#builder()}. 137 * <p> 138 * Example: 139 * <pre> 140 * {@code 141 * 142 * BatchGetResultPageIterable batchResults = enhancedClient.batchGetItem(r -> r.addReadBatches( 143 * ReadBatch.builder(FirstItem.class) 144 * .mappedTableResource(firstItemTable) 145 * .addGetItem(i -> i.key(key1)) 146 * .addGetItem(i -> i.key(key2)) 147 * .build(), 148 * ReadBatch.builder(SecondItem.class) 149 * .mappedTableResource(secondItemTable) 150 * .addGetItem(i -> i.key(key3)) 151 * .build())); 152 * } 153 * </pre> 154 * 155 * @param requestConsumer a {@link Consumer} of {@link BatchGetItemEnhancedRequest.Builder} containing keys grouped by tables. 156 * @return an iterator of type {@link SdkIterable} with paginated results of type {@link BatchGetResultPage}. 157 * @see #batchGetItem(BatchGetItemEnhancedRequest) 158 * @see DynamoDbClient#batchGetItemPaginator(BatchGetItemRequest) 159 */ batchGetItem(Consumer<BatchGetItemEnhancedRequest.Builder> requestConsumer)160 default BatchGetResultPageIterable batchGetItem(Consumer<BatchGetItemEnhancedRequest.Builder> requestConsumer) { 161 throw new UnsupportedOperationException(); 162 } 163 164 /** 165 * Puts and/or deletes multiple items in one or more tables. BatchWriteItem is a composite operation where the request 166 * contains one batch of (a mix of) {@link PutItemEnhancedRequest} and {@link DeleteItemEnhancedRequest} per targeted table. 167 * <p> 168 * The additional configuration parameters that the enhanced client supports are defined 169 * in the {@link BatchWriteItemEnhancedRequest}. 170 * <p> 171 * A single call to BatchWriteItem has the same limit of items as the low-level DynamoDB API BatchWriteItem operation, 172 * considering all items across all WriteBatches. 173 * <p> 174 * <b>Note: </b> BatchWriteItem cannot update items. Instead, use the individual updateItem operation 175 * {@link DynamoDbTable#updateItem(UpdateItemEnhancedRequest)}. 176 * <p> 177 * <b>Partial updates</b><br>Each delete or put call is atomic, but the operation as a whole is not. 178 * If individual operations fail due to exceeded provisional throughput internal DynamoDb processing failures, 179 * the failed requests can be retrieved through the result, see {@link BatchWriteResult}. 180 * <p> 181 * There are some conditions that cause the whole batch operation to fail. These include non-existing tables, erroneously 182 * defined primary key attributes, attempting to put and delete the same item as well as referring more than once to the same 183 * hash and range (sort) key. 184 * <p> 185 * This operation calls the low-level DynamoDB API BatchWriteItem operation. Consult the BatchWriteItem documentation for 186 * further details and constraints, current limits of data to write and/or delete, how to handle partial updates and retries 187 * and under which conditions the operation will fail. 188 * <p> 189 * Example: 190 * <pre> 191 * {@code 192 * 193 * BatchWriteResult batchResult = enhancedClient.batchWriteItem( 194 * BatchWriteItemEnhancedRequest.builder() 195 * .writeBatches(WriteBatch.builder(FirstItem.class) 196 * .mappedTableResource(firstItemTable) 197 * .addPutItem(PutItemEnhancedRequest.builder().item(item1).build()) 198 * .addDeleteItem(DeleteItemEnhancedRequest.builder() 199 * .key(key2) 200 * .build()) 201 * .build(), 202 * WriteBatch.builder(SecondItem.class) 203 * .mappedTableResource(secondItemTable) 204 * .addPutItem(PutItemEnhancedRequest.builder().item(item3).build()) 205 * .build()) 206 * .build()); 207 * } 208 * </pre> 209 * 210 * @param request A {@link BatchWriteItemEnhancedRequest} containing keys and items grouped by tables. 211 * @return a {@link BatchWriteResult} containing any unprocessed requests. 212 */ batchWriteItem(BatchWriteItemEnhancedRequest request)213 default BatchWriteResult batchWriteItem(BatchWriteItemEnhancedRequest request) { 214 throw new UnsupportedOperationException(); 215 } 216 217 /** 218 * Puts and/or deletes multiple items in one or more tables. BatchWriteItem is a composite operation where the request 219 * contains one batch of (a mix of) {@link PutItemEnhancedRequest} and {@link DeleteItemEnhancedRequest} per targeted table. 220 * <p> 221 * The additional configuration parameters that the enhanced client supports are defined 222 * in the {@link BatchWriteItemEnhancedRequest}. 223 * <p> 224 * A single call to BatchWriteItem has the same limit of items as the low-level DynamoDB API BatchWriteItem operation, 225 * considering all items across all WriteBatches. 226 * <p> 227 * <b>Note: </b> BatchWriteItem cannot update items. Instead, use the individual updateItem operation 228 * {@link DynamoDbTable#updateItem(UpdateItemEnhancedRequest)}. 229 * <p> 230 * <b>Partial updates</b><br>Each delete or put call is atomic, but the operation as a whole is not. 231 * If individual operations fail due to exceeded provisional throughput internal DynamoDb processing failures, 232 * the failed requests can be retrieved through the result, see {@link BatchWriteResult}. 233 * <p> 234 * There are some conditions that cause the whole batch operation to fail. These include non-existing tables, erroneously 235 * defined primary key attributes, attempting to put and delete the same item as well as referring more than once to the same 236 * hash and range (sort) key. 237 * <p> 238 * This operation calls the low-level DynamoDB API BatchWriteItem operation. Consult the BatchWriteItem documentation for 239 * further details and constraints, current limits of data to write and/or delete, how to handle partial updates and retries 240 * and under which conditions the operation will fail. 241 * <p> 242 * <b>Note:</b> This is a convenience method that creates an instance of the request builder avoiding the need to create one 243 * manually via {@link BatchWriteItemEnhancedRequest#builder()}. 244 * <p> 245 * Example: 246 * <pre> 247 * {@code 248 * 249 * BatchWriteResult batchResult = enhancedClient.batchWriteItem(r -> r.writeBatches( 250 * WriteBatch.builder(FirstItem.class) 251 * .mappedTableResource(firstItemTable) 252 * .addPutItem(i -> i.item(item1)) 253 * .addDeleteItem(i -> i.key(key2)) 254 * .build(), 255 * WriteBatch.builder(SecondItem.class) 256 * .mappedTableResource(secondItemTable) 257 * .addPutItem(i -> i.item(item3)) 258 * .build())); 259 * } 260 * </pre> 261 * 262 * @param requestConsumer a {@link Consumer} of {@link BatchWriteItemEnhancedRequest} containing keys and items grouped by 263 * tables. 264 * @return a {@link BatchWriteResult} containing any unprocessed requests. 265 */ batchWriteItem(Consumer<BatchWriteItemEnhancedRequest.Builder> requestConsumer)266 default BatchWriteResult batchWriteItem(Consumer<BatchWriteItemEnhancedRequest.Builder> requestConsumer) { 267 throw new UnsupportedOperationException(); 268 } 269 270 /** 271 * Retrieves multiple items from one or more tables in a single atomic transaction. TransactGetItem is a composite operation 272 * where the request contains a set of get requests, each containing a table reference and a 273 * {@link GetItemEnhancedRequest}. The list of results correspond to the ordering of the request definitions; for example 274 * the third addGetItem() call on the request builder will match the third result (index 2) of the result. 275 * <p> 276 * The additional configuration parameters that the enhanced client supports are defined 277 * in the {@link TransactGetItemsEnhancedRequest}. 278 * <p> 279 * DynamoDb will reject a call to TransactGetItems if the call exceeds limits such as provisioned throughput or allowed size 280 * of items, if the request contains errors or if there are conflicting operations accessing the same item, for instance 281 * updating and reading at the same time. 282 * <p> 283 * This operation calls the low-level DynamoDB API TransactGetItems operation. Consult the TransactGetItems documentation for 284 * further details and constraints. 285 * <p> 286 * Examples: 287 * <pre> 288 * {@code 289 * 290 * List<TransactGetResultPage> results = enhancedClient.transactGetItems( 291 * TransactGetItemsEnhancedRequest.builder() 292 * .addGetItem(firstItemTable, GetItemEnhancedRequest.builder().key(key1).build()) 293 * .addGetItem(firstItemTable, GetItemEnhancedRequest.builder().key(key2).build()) 294 * .addGetItem(firstItemTable, GetItemEnhancedRequest.builder().key(key3).build()) 295 * .addGetItem(secondItemTable, GetItemEnhancedRequest.builder().key(key4).build()) 296 * .build()); 297 * MyItem item = results.get(3).getItem(secondItemTable); 298 * } 299 * </pre> 300 * See {@link DynamoDbClient#transactGetItems(Consumer)} to learn more about {@code TransactGetItems}. 301 * 302 * @param request A {@link TransactGetItemsEnhancedRequest} containing keys with table references. 303 * @return a list of {@link Document} with the results. 304 */ transactGetItems(TransactGetItemsEnhancedRequest request)305 default List<Document> transactGetItems(TransactGetItemsEnhancedRequest request) { 306 throw new UnsupportedOperationException(); 307 } 308 309 /** 310 * Retrieves multiple items from one or more tables in a single atomic transaction. TransactGetItem is a composite operation 311 * where the request contains a set of get requests, each containing a table reference and a 312 * {@link GetItemEnhancedRequest}. The list of results correspond to the ordering of the request definitions; for example 313 * the third addGetItem() call on the request builder will match the third result (index 2) of the result. 314 * <p> 315 * The additional configuration parameters that the enhanced client supports are defined 316 * in the {@link TransactGetItemsEnhancedRequest}. 317 * <p> 318 * DynamoDb will reject a call to TransactGetItems if the call exceeds limits such as provisioned throughput or allowed size 319 * of items, if the request contains errors or if there are conflicting operations accessing the same item, for instance 320 * updating and reading at the same time. 321 * <p> 322 * This operation calls the low-level DynamoDB API TransactGetItems operation. Consult the TransactGetItems documentation for 323 * further details and constraints. 324 * <p> 325 * <b>Note:</b> This is a convenience method that creates an instance of the request builder avoiding the need to create one 326 * manually via {@link TransactGetItemsEnhancedRequest#builder()}. 327 * <p> 328 * Examples: 329 * <pre> 330 * {@code 331 * 332 * List<TransactGetResultPage> results = enhancedClient.transactGetItems( 333 * r -> r.addGetItem(firstItemTable, i -> i.key(k -> k.partitionValue(0))) 334 * .addGetItem(firstItemTable, i -> i.key(k -> k.partitionValue(1))) 335 * .addGetItem(firstItemTable, i -> i.key(k -> k.partitionValue(2))) 336 * .addGetItem(secondItemTable, i -> i.key(k -> k.partitionValue(0)))); 337 * MyItem item = results.get(3).getItem(secondItemTable); 338 * } 339 * </pre> 340 * <p> 341 * See {@link DynamoDbClient#transactGetItems(Consumer)} to learn more about {@code TransactGetItems}. 342 * 343 * @param requestConsumer a {@link Consumer} of {@link TransactGetItemsEnhancedRequest} containing keys with table references. 344 * @return a list of {@link Document} with the results. 345 * 346 */ transactGetItems(Consumer<TransactGetItemsEnhancedRequest.Builder> requestConsumer)347 default List<Document> transactGetItems(Consumer<TransactGetItemsEnhancedRequest.Builder> requestConsumer) { 348 throw new UnsupportedOperationException(); 349 } 350 351 /** 352 * Writes and/or modifies multiple items from one or more tables in a single atomic transaction. TransactGetItem is a 353 * composite operation where the request contains a set of action requests, each containing a table reference and 354 * one of the following requests: 355 * <ul> 356 * <li>Condition check of item - {@link ConditionCheck}</li> 357 * <li>Delete item - {@link DeleteItemEnhancedRequest}</li> 358 * <li>Put item - {@link PutItemEnhancedRequest}</li> 359 * <li>Update item - {@link UpdateItemEnhancedRequest}</li> 360 * </ul> 361 * <p> 362 * The additional configuration parameters that the enhanced client supports are defined 363 * in the {@link TransactWriteItemsEnhancedRequest}. 364 * <p> 365 * DynamoDb will reject a call to TransactWriteItems if the call exceeds limits such as provisioned throughput or allowed size 366 * of items, if the request contains errors or if there are conflicting operations accessing the same item. If the request 367 * contains condition checks that aren't met, this will also cause rejection. 368 * <p> 369 * This operation calls the low-level DynamoDB API TransactWriteItems operation. Consult the TransactWriteItems documentation 370 * for further details and constraints, current limits of data to write and/or delete and under which conditions the operation 371 * will fail. 372 * <p> 373 * Example: 374 * <pre> 375 * {@code 376 * 377 * result = enhancedClient.transactWriteItems( 378 * TransactWriteItemsEnhancedRequest.builder() 379 * .addPutItem(firstItemTable, PutItemEnhancedRequest.builder().item(item1).build()) 380 * .addDeleteItem(firstItemTable, DeleteItemEnhancedRequest.builder().key(key2).build()) 381 * .addConditionCheck(firstItemTable, 382 * ConditionCheck.builder() 383 * .key(key3) 384 * .conditionExpression(conditionExpression) 385 * .build()) 386 * .addUpdateItem(secondItemTable, 387 * UpdateItemEnhancedRequest.builder().item(item4).build()) 388 * .build()); 389 * } 390 * </pre> 391 * See {@link DynamoDbClient#transactWriteItems(Consumer)} to learn more about {@code TransactWriteItems}. 392 * 393 * @param request A {@link BatchWriteItemEnhancedRequest} containing keys grouped by tables. 394 */ transactWriteItems(TransactWriteItemsEnhancedRequest request)395 default Void transactWriteItems(TransactWriteItemsEnhancedRequest request) { 396 throw new UnsupportedOperationException(); 397 } 398 399 /** 400 * Writes and/or modifies multiple items from one or more tables in a single atomic transaction. TransactGetItem is a 401 * composite operation where the request contains a set of action requests, each containing a table reference and 402 * one of the following requests: 403 * <ul> 404 * <li>Condition check of item - {@link ConditionCheck}</li> 405 * <li>Delete item - {@link DeleteItemEnhancedRequest}</li> 406 * <li>Put item - {@link PutItemEnhancedRequest}</li> 407 * <li>Update item - {@link UpdateItemEnhancedRequest}</li> 408 * </ul> 409 * <p> 410 * The additional configuration parameters that the enhanced client supports are defined 411 * in the {@link TransactWriteItemsEnhancedRequest}. 412 * <p> 413 * DynamoDb will reject a call to TransactWriteItems if the call exceeds limits such as provisioned throughput or allowed size 414 * of items, if the request contains errors or if there are conflicting operations accessing the same item. If the request 415 * contains condition checks that aren't met, this will also cause rejection. 416 * <p> 417 * This operation calls the low-level DynamoDB API TransactWriteItems operation. Consult the TransactWriteItems documentation 418 * for further details and constraints, current limits of data to write and/or delete and under which conditions the operation 419 * will fail. 420 * <p> 421 * <b>Note:</b> This is a convenience method that creates an instance of the request builder avoiding the need to create one 422 * manually via {@link TransactWriteItemsEnhancedRequest#builder()}. 423 * <p> 424 * Example: 425 * <pre> 426 * {@code 427 * 428 * result = enhancedClient.transactWriteItems(r -> r.addPutItem(firstItemTable, i -> i.item(item1)) 429 * .addDeleteItem(firstItemTable, i -> i.key(k -> k.partitionValue(2))) 430 * .addConditionCheck(firstItemTable, 431 * i -> i.key(key3).conditionExpression(conditionExpression)) 432 * .addUpdateItem(secondItemTable, i -> i.item(item4))); 433 * } 434 * </pre> 435 * See {@link DynamoDbClient#transactWriteItems(Consumer)} to learn more about {@code TransactWriteItems}. 436 * 437 * @param requestConsumer a {@link Consumer} of {@link TransactWriteItemsEnhancedRequest} containing keys and items grouped 438 * by tables. 439 */ transactWriteItems(Consumer<TransactWriteItemsEnhancedRequest.Builder> requestConsumer)440 default Void transactWriteItems(Consumer<TransactWriteItemsEnhancedRequest.Builder> requestConsumer) { 441 throw new UnsupportedOperationException(); 442 } 443 444 /** 445 * Creates a default builder for {@link DynamoDbEnhancedClient}. 446 */ builder()447 static Builder builder() { 448 return DefaultDynamoDbEnhancedClient.builder(); 449 } 450 451 /** 452 * Creates a {@link DynamoDbEnhancedClient} with a default {@link DynamoDbClient} 453 */ create()454 static DynamoDbEnhancedClient create() { 455 return builder().build(); 456 } 457 458 /** 459 * The builder definition for a {@link DynamoDbEnhancedClient}. 460 */ 461 @NotThreadSafe 462 interface Builder extends DynamoDbEnhancedResource.Builder { 463 /** 464 * The regular low-level SDK client to use with the enhanced client. 465 * @param dynamoDbClient an initialized {@link DynamoDbClient} 466 */ dynamoDbClient(DynamoDbClient dynamoDbClient)467 Builder dynamoDbClient(DynamoDbClient dynamoDbClient); 468 469 @Override extensions(DynamoDbEnhancedClientExtension... dynamoDbEnhancedClientExtensions)470 Builder extensions(DynamoDbEnhancedClientExtension... dynamoDbEnhancedClientExtensions); 471 472 @Override extensions(List<DynamoDbEnhancedClientExtension> dynamoDbEnhancedClientExtensions)473 Builder extensions(List<DynamoDbEnhancedClientExtension> dynamoDbEnhancedClientExtensions); 474 475 /** 476 * Builds an enhanced client based on the settings supplied to this builder 477 * @return An initialized {@link DynamoDbEnhancedClient} 478 */ build()479 DynamoDbEnhancedClient build(); 480 } 481 } 482