func decodeBatchGetItemOutput()

in dax/internal/client/response.go [599:743]
137 lines of code
38 McCabe index (conditional complexity)

func decodeBatchGetItemOutput(ctx context.Context, reader *cbor.Reader, input *dynamodb.BatchGetItemInput, keySchemaCache *lru.Lru, attrNamesListToId *lru.Lru, output *dynamodb.BatchGetItemOutput) (*dynamodb.BatchGetItemOutput, error) {
	if consumed, err := consumeNil(reader); err != nil {
		return output, err
	} else if consumed {
		return output, nil
	}

	l, err := reader.ReadArrayLength()
	if err != nil {
		return output, err
	}
	if l != 2 {
		return output, &smithy.SerializationError{Err: fmt.Errorf("Unexpected number of objects %d in BatchGetItemOutput", l)}
	}

	projectionsByTable := make(map[string][]documentPath, len(input.RequestItems))
	for table, kaas := range input.RequestItems {
		if kaas.ProjectionExpression != nil {
			dp, err := buildProjectionOrdinals(kaas.ProjectionExpression, kaas.ExpressionAttributeNames)
			if err != nil {
				return output, err
			}
			projectionsByTable[table] = dp
		}
	}

	numTables, err := reader.ReadMapLength()
	if err != nil {
		return output, err
	}

	if output == nil {
		output = &dynamodb.BatchGetItemOutput{}
	}
	if numTables > 0 {
		output.Responses = make(map[string][]map[string]types.AttributeValue, numTables)
		for i := 0; i < numTables; i++ {
			table, err := reader.ReadString()
			if err != nil {
				return output, err
			}

			projections, hasProjections := projectionsByTable[table]
			if hasProjections {
				numItems, err := reader.ReadArrayLength()
				if err != nil {
					return output, err
				}
				items := make([]map[string]types.AttributeValue, numItems)
				for j := 0; j < numItems; j++ {
					if items[j], err = decodeNonKeyAttributes(ctx, reader, attrNamesListToId, projections); err != nil {
						return output, err
					}
				}
				output.Responses[table] = items
			} else {
				tableKeys, err := getKeySchema(ctx, keySchemaCache, table)
				if err != nil {
					return output, err
				}
				numObjs, err := reader.ReadArrayLength()
				if err != nil {
					return output, err
				}
				numItems := numObjs / 2
				items := make([]map[string]types.AttributeValue, numItems)
				for j := 0; j < numItems; j++ {
					keys, err := decodeKey(reader, tableKeys)
					if err != nil {
						return output, err
					}
					item, err := decodeNonKeyAttributes(ctx, reader, attrNamesListToId, projections)
					if err != nil {
						return output, err
					}
					for k, v := range keys {
						item[k] = v
					}
					items[j] = item
				}
				output.Responses[table] = items
			}
		}
	}

	numUnprocessed, err := reader.ReadMapLength()
	if err != nil {
		return output, err
	}
	if numUnprocessed > 0 {
		unprocessed := make(map[string]types.KeysAndAttributes, numUnprocessed)
		for i := 0; i < numUnprocessed; i++ {
			table, err := reader.ReadString()
			if err != nil {
				return output, err
			}
			tableKeys, err := getKeySchema(ctx, keySchemaCache, table)
			if err != nil {
				return output, err
			}
			numKeys, err := reader.ReadArrayLength()
			if err != nil {
				return output, err
			}
			if numKeys <= 0 {
				continue
			}
			keys := make([]map[string]types.AttributeValue, numKeys)
			for j := 0; j < numKeys; j++ {
				if keys[j], err = decodeKey(reader, tableKeys); err != nil {
					return output, err
				}
			}
			outKaas := types.KeysAndAttributes{Keys: keys}
			if inKaas, ok := input.RequestItems[table]; ok {
				outKaas.AttributesToGet = inKaas.AttributesToGet
				outKaas.ConsistentRead = inKaas.ConsistentRead
				outKaas.ExpressionAttributeNames = inKaas.ExpressionAttributeNames
				outKaas.Keys = keys
				outKaas.ProjectionExpression = inKaas.ProjectionExpression
			}
			unprocessed[table] = outKaas
		}
		if len(unprocessed) != 0 {
			output.UnprocessedKeys = unprocessed
		}
	}

	numCC, err := reader.ReadArrayLength()
	if err != nil {
		return output, err
	}
	if numCC > 0 {
		output.ConsumedCapacity = make([]types.ConsumedCapacity, numCC)
		for i := 0; i < numCC; i++ {
			capacity, err := decodeConsumedCapacity(reader)
			if err != nil {
				return output, err
			}
			output.ConsumedCapacity[i] = *capacity
		}
	}

	return output, nil
}