public UpdateItemRequest generateRequest()

in services-custom/dynamodb-enhanced/src/main/java/software/amazon/awssdk/enhanced/dynamodb/internal/operations/UpdateItemOperation.java [85:162]
61 lines of code
13 McCabe index (conditional complexity)

    public UpdateItemRequest generateRequest(TableSchema<T> tableSchema,
                                             OperationContext operationContext,
                                             DynamoDbEnhancedClientExtension extension) {
        if (!TableMetadata.primaryIndexName().equals(operationContext.indexName())) {
            throw new IllegalArgumentException("UpdateItem cannot be executed against a secondary index.");
        }

        T item = request.map(UpdateItemEnhancedRequest::item, TransactUpdateItemEnhancedRequest::item);
        Boolean ignoreNulls = request.map(r -> Optional.ofNullable(r.ignoreNulls()),
                                          r -> Optional.ofNullable(r.ignoreNulls()))
                                     .orElse(null);

        IgnoreNullsMode ignoreNullsMode = request.map(r -> Optional.ofNullable(r.ignoreNullsMode()),
                                                     r -> Optional.ofNullable(r.ignoreNullsMode()))
                                                        .orElse(IgnoreNullsMode.DEFAULT);

        if (ignoreNullsMode == IgnoreNullsMode.SCALAR_ONLY
            || ignoreNullsMode == IgnoreNullsMode.MAPS_ONLY) {
            ignoreNulls = true;
        }
        Map<String, AttributeValue> itemMapImmutable = tableSchema.itemToMap(item, Boolean.TRUE.equals(ignoreNulls));
        
        // If ignoreNulls is set to true, check for nested params to be updated
        // If needed, Transform itemMap for it to be able to handle them.

        Map<String, AttributeValue> itemMap = ignoreNullsMode == IgnoreNullsMode.SCALAR_ONLY ?
                                              transformItemToMapForUpdateExpression(itemMapImmutable) : itemMapImmutable;
        
        TableMetadata tableMetadata = tableSchema.tableMetadata();

        WriteModification transformation =
            extension != null
            ? extension.beforeWrite(DefaultDynamoDbExtensionContext.builder()
                                                                   .items(itemMap)
                                                                   .operationContext(operationContext)
                                                                   .tableMetadata(tableMetadata)
                                                                   .tableSchema(tableSchema)
                                                                   .operationName(operationName())
                                                                   .build())
            : null;

        if (transformation != null && transformation.transformedItem() != null) {
            itemMap = transformation.transformedItem();
        }

        Collection<String> primaryKeys = tableSchema.tableMetadata().primaryKeys();

        Map<String, AttributeValue> keyAttributes = filterMap(itemMap, entry -> primaryKeys.contains(entry.getKey()));
        Map<String, AttributeValue> nonKeyAttributes = filterMap(itemMap, entry -> !primaryKeys.contains(entry.getKey()));

        Expression updateExpression = generateUpdateExpressionIfExist(tableMetadata, transformation, nonKeyAttributes);
        Expression conditionExpression = generateConditionExpressionIfExist(transformation, request);

        Map<String, String> expressionNames = coalesceExpressionNames(updateExpression, conditionExpression);
        Map<String, AttributeValue> expressionValues = coalesceExpressionValues(updateExpression, conditionExpression);

        UpdateItemRequest.Builder requestBuilder = UpdateItemRequest.builder()
            .tableName(operationContext.tableName())
            .key(keyAttributes);

        if (request.left().isPresent()) {
            addPlainUpdateItemParameters(requestBuilder, request.left().get());
        }
        if (updateExpression != null) {
            requestBuilder.updateExpression(updateExpression.expression());
        }
        if (conditionExpression != null) {
            requestBuilder.conditionExpression(conditionExpression.expression());
        }
        if (CollectionUtils.isNotEmpty(expressionNames)) {
            requestBuilder = requestBuilder.expressionAttributeNames(expressionNames);
        }
        if (CollectionUtils.isNotEmpty(expressionValues)) {
            requestBuilder = requestBuilder.expressionAttributeValues(expressionValues);
        }

        return requestBuilder.build();
    }