diff --git a/services-custom/dynamodb-mapper/src/main/java/software/amazon/awssdk/mapper/dynamodb/StandardModelFactories.java b/services-custom/dynamodb-mapper/src/main/java/software/amazon/awssdk/mapper/dynamodb/StandardModelFactories.java index 2887b22d2500..0ea42bf9bc32 100644 --- a/services-custom/dynamodb-mapper/src/main/java/software/amazon/awssdk/mapper/dynamodb/StandardModelFactories.java +++ b/services-custom/dynamodb-mapper/src/main/java/software/amazon/awssdk/mapper/dynamodb/StandardModelFactories.java @@ -259,7 +259,7 @@ public String get(AttributeValue value) { } @Override public AttributeValue build(String o) { - return AttributeValue.builder().s(o).build(); + return AttributeValue.createS(o); } @Override public AttributeValue convert(String o) { @@ -288,7 +288,7 @@ public String get(AttributeValue value) { } @Override public AttributeValue build(String o) { - return AttributeValue.builder().n(o).build(); + return AttributeValue.createN(o); } } @@ -314,7 +314,7 @@ public Long get(AttributeValue value) { } @Override public AttributeValue build(Long o) { - return AttributeValue.builder().n(String.valueOf(o)).build(); + return AttributeValue.createN(String.valueOf(o)); } } @@ -339,7 +339,7 @@ public ByteBuffer get(AttributeValue value) { } @Override public AttributeValue build(ByteBuffer o) { - return AttributeValue.builder().b(SdkBytes.fromByteBuffer(o)).build(); + return AttributeValue.createB(SdkBytes.fromByteBuffer(o)); } } @@ -364,7 +364,7 @@ public List get(AttributeValue value) { } @Override public AttributeValue build(List o) { - return AttributeValue.builder().ss(o).build(); + return AttributeValue.createSs(o); } } @@ -389,7 +389,7 @@ public List get(AttributeValue value) { } @Override public AttributeValue build(List o) { - return AttributeValue.builder().ns(o).build(); + return AttributeValue.createNs(o); } } @@ -426,7 +426,7 @@ public AttributeValue build(List o) { for (ByteBuffer bb : o) { sdkBytes.add(SdkBytes.fromByteBuffer(bb)); } - return AttributeValue.builder().bs(sdkBytes).build(); + return AttributeValue.createBs(sdkBytes); } } @@ -474,7 +474,7 @@ public Boolean get(AttributeValue o) { } @Override public AttributeValue build(Boolean value) { - return AttributeValue.builder().bool(value).build(); + return AttributeValue.createBool(value); } @Override public Boolean unconvert(AttributeValue o) { @@ -522,7 +522,7 @@ public String get(AttributeValue o) { */ @Override public AttributeValue build(String value) { - return AttributeValue.builder().n(value).build(); + return AttributeValue.createN(value); } } @@ -547,7 +547,7 @@ public List get(AttributeValue value) { } @Override public AttributeValue build(List o) { - return AttributeValue.builder().l(o).build(); + return AttributeValue.createL(o); } } @@ -592,7 +592,7 @@ public List get(AttributeValue value) { } @Override public AttributeValue build(List o) { - return AttributeValue.builder().l(o).build(); + return AttributeValue.createL(o); } } @@ -620,7 +620,7 @@ public Map get(AttributeValue value) { } @Override public AttributeValue build(Map o) { - return AttributeValue.builder().m(o).build(); + return AttributeValue.createM(o); } } @@ -656,7 +656,7 @@ public Map get(AttributeValue value) { } @Override public AttributeValue build(Map o) { - return AttributeValue.builder().m(o).build(); + return AttributeValue.createM(o); } } @@ -695,7 +695,7 @@ private DynamoDBTypeConverter getConverter(Class sourceType, Convert private DynamoDBTypeConverter getConverter(ConvertibleType type) { return new DelegateConverter(getRule(type).newConverter(type)) { public final AttributeValue convert(T o) { - return o == null ? AttributeValue.builder().nul(true).build() : super.convert(o); + return o == null ? AttributeValue.createNul(true) : super.convert(o); } }; } diff --git a/test/sdk-benchmarks/pom.xml b/test/sdk-benchmarks/pom.xml index d356ec2b21fc..74e2d7755572 100644 --- a/test/sdk-benchmarks/pom.xml +++ b/test/sdk-benchmarks/pom.xml @@ -82,6 +82,12 @@ ${awsjavasdk.version} + + software.amazon.awssdk + dynamodb-mapper + ${awsjavasdk.version} + + com.amazonaws aws-java-sdk-ec2 diff --git a/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientDeleteV1MapperComparisonBenchmark.java b/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientDeleteV1MapperComparisonBenchmark.java index 063b78bffd0a..be922c5986cf 100644 --- a/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientDeleteV1MapperComparisonBenchmark.java +++ b/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientDeleteV1MapperComparisonBenchmark.java @@ -40,6 +40,8 @@ @Fork(2) @State(Scope.Benchmark) public class EnhancedClientDeleteV1MapperComparisonBenchmark { + private static final V2MapperItemFactory V2_MAPPER_ITEM_FACTORY = new V2MapperItemFactory(); + @Benchmark public void v2Delete(TestState s) { s.v2Table.deleteItem(s.key); @@ -50,6 +52,11 @@ public void v1Delete(TestState s) { s.v1DdbMapper.delete(s.testItem.v1Key); } + @Benchmark + public void v2MapperDelete(TestState s) { + s.v2DdbMapper.delete(s.testItem.v2MapperKey); + } + private static DynamoDbClient getV2Client(Blackhole bh) { return new V2TestDynamoDbDeleteItemClient(bh); } @@ -67,15 +74,17 @@ public static class TestState { private DynamoDbTable v2Table; private DynamoDBMapper v1DdbMapper; - + private software.amazon.awssdk.mapper.dynamodb.DynamoDBMapper v2DdbMapper; @Setup public void setup(Blackhole bh) { + DynamoDbClient v2Client = getV2Client(bh); DynamoDbEnhancedClient v2DdbEnh = DynamoDbEnhancedClient.builder() - .dynamoDbClient(getV2Client(bh)) + .dynamoDbClient(v2Client) .build(); v2Table = v2DdbEnh.table(testItem.name(), testItem.schema); + v2DdbMapper = new software.amazon.awssdk.mapper.dynamodb.DynamoDBMapper(v2Client); v1DdbMapper = new DynamoDBMapper(getV1Client(bh)); } @@ -83,35 +92,43 @@ public void setup(Blackhole bh) { public enum TestItem { TINY( V2ItemFactory.TINY_BEAN_TABLE_SCHEMA, + V2_MAPPER_ITEM_FACTORY.v2MapperTinyBean(), new V1ItemFactory.V1TinyBean("hashKey") ), SMALL( V2ItemFactory.SMALL_BEAN_TABLE_SCHEMA, + V2_MAPPER_ITEM_FACTORY.v2MapperSmallBean(), new V1ItemFactory.V1SmallBean("hashKey") ), HUGE( V2ItemFactory.HUGE_BEAN_TABLE_SCHEMA, + V2_MAPPER_ITEM_FACTORY.v2MapperHugeBean(), new V1ItemFactory.V1HugeBean("hashKey") ), HUGE_FLAT( V2ItemFactory.HUGE_BEAN_FLAT_TABLE_SCHEMA, + V2_MAPPER_ITEM_FACTORY.v2MapperHugeBeanFlat(), new V1ItemFactory.V1HugeBeanFlat("hashKey") ), ; - // V2 + // Enhanced Client private TableSchema schema; + // Mapper v2 + private Object v2MapperKey; // V1 private Object v1Key; TestItem(TableSchema schema, - Object v1Key) { + Object v2MapperKey, + Object v1Key) { this.schema = schema; + this.v2MapperKey = v2MapperKey; this.v1Key = v1Key; } diff --git a/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientGetV1MapperComparisonBenchmark.java b/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientGetV1MapperComparisonBenchmark.java index 12bc62d18454..2db1a2884b92 100644 --- a/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientGetV1MapperComparisonBenchmark.java +++ b/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientGetV1MapperComparisonBenchmark.java @@ -43,6 +43,7 @@ @State(Scope.Benchmark) public class EnhancedClientGetV1MapperComparisonBenchmark { private static final V2ItemFactory V2_ITEM_FACTORY = new V2ItemFactory(); + private static final V2MapperItemFactory V2_MAPPER_ITEM_FACTORY = new V2MapperItemFactory(); private static final V1ItemFactory V1_ITEM_FACTORY = new V1ItemFactory(); @Benchmark @@ -55,6 +56,11 @@ public Object v1Get(TestState s) { return s.v1DdbMapper.load(s.testItem.v1Key); } + @Benchmark + public Object v2MapperGet(TestState s) { + return s.v2DdbMapper.load(s.testItem.v2MapperKey.getClass(), "hashKey"); + } + private static DynamoDbClient getV2Client(Blackhole bh, GetItemResponse getItemResponse) { return new V2TestDynamoDbGetItemClient(bh, getItemResponse); } @@ -72,15 +78,17 @@ public static class TestState { private DynamoDbTable v2Table; private DynamoDBMapper v1DdbMapper; - + private software.amazon.awssdk.mapper.dynamodb.DynamoDBMapper v2DdbMapper; @Setup public void setup(Blackhole bh) { + DynamoDbClient v2Client = getV2Client(bh, testItem.v2Response); DynamoDbEnhancedClient v2DdbEnh = DynamoDbEnhancedClient.builder() - .dynamoDbClient(getV2Client(bh, testItem.v2Response)) + .dynamoDbClient(v2Client) .build(); v2Table = v2DdbEnh.table(testItem.name(), testItem.schema); + v2DdbMapper = new software.amazon.awssdk.mapper.dynamodb.DynamoDBMapper(v2Client); v1DdbMapper = new DynamoDBMapper(getV1Client(bh, testItem.v1Response)); } @@ -89,6 +97,7 @@ public enum TestItem { TINY( V2ItemFactory.TINY_BEAN_TABLE_SCHEMA, GetItemResponse.builder().item(V2_ITEM_FACTORY.tiny()).build(), + V2_MAPPER_ITEM_FACTORY.v2MapperTinyBean(), new V1ItemFactory.V1TinyBean("hashKey"), new GetItemResult().withItem(V1_ITEM_FACTORY.tiny()) @@ -97,6 +106,7 @@ public enum TestItem { SMALL( V2ItemFactory.SMALL_BEAN_TABLE_SCHEMA, GetItemResponse.builder().item(V2_ITEM_FACTORY.small()).build(), + V2_MAPPER_ITEM_FACTORY.v2MapperSmallBean(), new V1ItemFactory.V1SmallBean("hashKey"), new GetItemResult().withItem(V1_ITEM_FACTORY.small()) @@ -105,6 +115,7 @@ public enum TestItem { HUGE( V2ItemFactory.HUGE_BEAN_TABLE_SCHEMA, GetItemResponse.builder().item(V2_ITEM_FACTORY.huge()).build(), + V2_MAPPER_ITEM_FACTORY.v2MapperHugeBean(), new V1ItemFactory.V1HugeBean("hashKey"), new GetItemResult().withItem(V1_ITEM_FACTORY.huge()) @@ -113,27 +124,33 @@ public enum TestItem { HUGE_FLAT( V2ItemFactory.HUGE_BEAN_FLAT_TABLE_SCHEMA, GetItemResponse.builder().item(V2_ITEM_FACTORY.hugeFlat()).build(), + V2_MAPPER_ITEM_FACTORY.v2MapperHugeBeanFlat(), new V1ItemFactory.V1HugeBeanFlat("hashKey"), new GetItemResult().withItem(V1_ITEM_FACTORY.hugeFlat()) ), ; - // V2 + // Enhanced Client private TableSchema schema; private GetItemResponse v2Response; + // Mapper v2 + private Object v2MapperKey; + // V1 private Object v1Key; private GetItemResult v1Response; TestItem(TableSchema schema, - GetItemResponse v2Response, + GetItemResponse v2Response, + Object v2MapperKey, - Object v1Key, - GetItemResult v1Response) { + Object v1Key, + GetItemResult v1Response) { this.schema = schema; this.v2Response = v2Response; + this.v2MapperKey = v2MapperKey; this.v1Key = v1Key; this.v1Response = v1Response; diff --git a/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientPutV1MapperComparisonBenchmark.java b/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientPutV1MapperComparisonBenchmark.java index cd233506b282..e9c8495c0e5d 100644 --- a/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientPutV1MapperComparisonBenchmark.java +++ b/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientPutV1MapperComparisonBenchmark.java @@ -41,11 +41,16 @@ @State(Scope.Benchmark) public class EnhancedClientPutV1MapperComparisonBenchmark { private static final V2ItemFactory V2_ITEM_FACTORY = new V2ItemFactory(); + private static final V2MapperItemFactory V2_MAPPER_ITEM_FACTORY = new V2MapperItemFactory(); private static final V1ItemFactory V1_ITEM_FACTORY = new V1ItemFactory(); private static final DynamoDBMapperConfig MAPPER_CONFIG = DynamoDBMapperConfig.builder() .withSaveBehavior(DynamoDBMapperConfig.SaveBehavior.PUT) .build(); + private static final software.amazon.awssdk.mapper.dynamodb.DynamoDBMapperConfig V2_MAPPER_CONFIG = + software.amazon.awssdk.mapper.dynamodb.DynamoDBMapperConfig.builder() + .withSaveBehavior(software.amazon.awssdk.mapper.dynamodb.DynamoDBMapperConfig.SaveBehavior.PUT) + .build(); @Benchmark public void v2Put(TestState s) { @@ -57,6 +62,11 @@ public void v1Put(TestState s) { s.v1DdbMapper.save(s.testItem.v1Bean); } + @Benchmark + public void v2MapperPut(TestState s) { + s.v2DdbMapper.save(s.testItem.v2MapperBean); + } + private static DynamoDbClient getV2Client(Blackhole bh) { return new V2TestDynamoDbPutItemClient(bh); } @@ -72,15 +82,17 @@ public static class TestState { private DynamoDbTable v2Table; private DynamoDBMapper v1DdbMapper; - + private software.amazon.awssdk.mapper.dynamodb.DynamoDBMapper v2DdbMapper; @Setup public void setup(Blackhole bh) { + DynamoDbClient v2Client = getV2Client(bh); DynamoDbEnhancedClient v2DdbEnh = DynamoDbEnhancedClient.builder() - .dynamoDbClient(getV2Client(bh)) + .dynamoDbClient(v2Client) .build(); v2Table = v2DdbEnh.table(testItem.name(), testItem.schema); + v2DdbMapper = new software.amazon.awssdk.mapper.dynamodb.DynamoDBMapper(v2Client, V2_MAPPER_CONFIG); v1DdbMapper = new DynamoDBMapper(getV1Client(bh), MAPPER_CONFIG); } @@ -89,6 +101,7 @@ public enum TestItem { TINY( V2ItemFactory.TINY_BEAN_TABLE_SCHEMA, V2_ITEM_FACTORY.tinyBean(), + V2_MAPPER_ITEM_FACTORY.v2MapperTinyBean(), V1_ITEM_FACTORY.v1TinyBean() ), @@ -96,6 +109,7 @@ public enum TestItem { SMALL( V2ItemFactory.SMALL_BEAN_TABLE_SCHEMA, V2_ITEM_FACTORY.smallBean(), + V2_MAPPER_ITEM_FACTORY.v2MapperSmallBean(), V1_ITEM_FACTORY.v1SmallBean() ), @@ -103,6 +117,7 @@ public enum TestItem { HUGE( V2ItemFactory.HUGE_BEAN_TABLE_SCHEMA, V2_ITEM_FACTORY.hugeBean(), + V2_MAPPER_ITEM_FACTORY.v2MapperHugeBean(), V1_ITEM_FACTORY.v1hugeBean() ), @@ -110,24 +125,30 @@ public enum TestItem { HUGE_FLAT( V2ItemFactory.HUGE_BEAN_FLAT_TABLE_SCHEMA, V2_ITEM_FACTORY.hugeBeanFlat(), + V2_MAPPER_ITEM_FACTORY.v2MapperHugeBeanFlat(), V1_ITEM_FACTORY.v1HugeBeanFlat() ), ; - // V2 + // Enhanced Client private TableSchema schema; private Object v2Bean; + // Mapper v2 + private Object v2MapperBean; + // V1 private Object v1Bean; TestItem(TableSchema schema, - Object v2Bean, + Object v2Bean, + Object v2MapperBean, - Object v1Bean) { + Object v1Bean) { this.schema = schema; this.v2Bean = v2Bean; + this.v2MapperBean = v2MapperBean; this.v1Bean = v1Bean; } diff --git a/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientQueryV1MapperComparisonBenchmark.java b/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientQueryV1MapperComparisonBenchmark.java index b25b560dbdc6..585d3d0b4d88 100644 --- a/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientQueryV1MapperComparisonBenchmark.java +++ b/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientQueryV1MapperComparisonBenchmark.java @@ -46,6 +46,7 @@ @State(Scope.Benchmark) public class EnhancedClientQueryV1MapperComparisonBenchmark { private static final V2ItemFactory V2_ITEM_FACTORY = new V2ItemFactory(); + private static final V2MapperItemFactory V2_MAPPER_ITEM_FACTORY = new V2MapperItemFactory(); private static final V1ItemFactory V1_ITEM_FACTORY = new V1ItemFactory(); @Benchmark @@ -58,6 +59,11 @@ public Object v1Query(TestState s) { return s.v1DdbMapper.query(s.testItem.getV1BeanClass(), s.testItem.v1QueryExpression).iterator().next(); } + @Benchmark + public Object v2MapperQuery(TestState s) { + return s.v2DdbMapper.query(s.testItem.getV2MapperBeanClass(), s.v2MapperQueryExpression).iterator().next(); + } + private static DynamoDbClient getV2Client(Blackhole bh, QueryResponse queryResponse) { return new V2TestDynamoDbQueryClient(bh, queryResponse); } @@ -73,16 +79,22 @@ public static class TestState { private DynamoDbTable v2Table; private DynamoDBMapper v1DdbMapper; + private software.amazon.awssdk.mapper.dynamodb.DynamoDBMapper v2DdbMapper; + private software.amazon.awssdk.mapper.dynamodb.DynamoDBQueryExpression v2MapperQueryExpression; private final Key key = Key.builder().partitionValue("key").build(); @Setup public void setup(Blackhole bh) { + DynamoDbClient v2Client = getV2Client(bh, testItem.v2Response); DynamoDbEnhancedClient v2DdbEnh = DynamoDbEnhancedClient.builder() - .dynamoDbClient(getV2Client(bh, testItem.v2Response)) + .dynamoDbClient(v2Client) .build(); v2Table = v2DdbEnh.table(testItem.name(), testItem.schema); + v2DdbMapper = new software.amazon.awssdk.mapper.dynamodb.DynamoDBMapper(v2Client); + v2MapperQueryExpression = new software.amazon.awssdk.mapper.dynamodb.DynamoDBQueryExpression() + .withHashKeyValues(testItem.v2MapperKey); v1DdbMapper = new DynamoDBMapper(getV1Client(bh, testItem.v1Response)); } @@ -95,6 +107,8 @@ public enum TestItem { V2_ITEM_FACTORY.tiny(), V2_ITEM_FACTORY.tiny())) .build(), + V2MapperItemFactory.V2MapperTinyBean.class, + V2_MAPPER_ITEM_FACTORY.v2MapperTinyBean(), V1ItemFactory.V1TinyBean.class, new DynamoDBQueryExpression().withHashKeyValues(new V1ItemFactory.V1TinyBean("hashKey")), @@ -108,6 +122,8 @@ public enum TestItem { V2_ITEM_FACTORY.small(), V2_ITEM_FACTORY.small())) .build(), + V2MapperItemFactory.V2MapperSmallBean.class, + V2_MAPPER_ITEM_FACTORY.v2MapperSmallBean(), V1ItemFactory.V1SmallBean.class, new DynamoDBQueryExpression().withHashKeyValues(new V1ItemFactory.V1SmallBean("hashKey")), @@ -122,6 +138,8 @@ public enum TestItem { V2_ITEM_FACTORY.huge(), V2_ITEM_FACTORY.huge())) .build(), + V2MapperItemFactory.V2MapperHugeBean.class, + V2_MAPPER_ITEM_FACTORY.v2MapperHugeBean(), V1ItemFactory.V1HugeBean.class, new DynamoDBQueryExpression().withHashKeyValues(new V1ItemFactory.V1HugeBean("hashKey")), @@ -136,6 +154,8 @@ public enum TestItem { V2_ITEM_FACTORY.hugeFlat(), V2_ITEM_FACTORY.hugeFlat())) .build(), + V2MapperItemFactory.V2MapperHugeBeanFlat.class, + V2_MAPPER_ITEM_FACTORY.v2MapperHugeBeanFlat(), V1ItemFactory.V1HugeBeanFlat.class, new DynamoDBQueryExpression().withHashKeyValues(new V1ItemFactory.V1HugeBeanFlat("hashKey")), @@ -144,10 +164,14 @@ public enum TestItem { ), ; - // V2 + // Enhanced Client private TableSchema schema; private QueryResponse v2Response; + // Mapper v2 + private Class v2MapperBeanClass; + private Object v2MapperKey; + // V1 private Class v1BeanClass; private DynamoDBQueryExpression v1QueryExpression; @@ -155,12 +179,16 @@ public enum TestItem { TestItem(TableSchema schema, QueryResponse v2Response, + Class v2MapperBeanClass, + Object v2MapperKey, Class v1BeanClass, DynamoDBQueryExpression v1QueryExpression, QueryResult v1Response) { this.schema = schema; this.v2Response = v2Response; + this.v2MapperBeanClass = v2MapperBeanClass; + this.v2MapperKey = v2MapperKey; this.v1BeanClass = v1BeanClass; this.v1QueryExpression = v1QueryExpression; @@ -170,6 +198,11 @@ public enum TestItem { public Class getV1BeanClass() { return v1BeanClass; } + + public Class getV2MapperBeanClass() { + return v2MapperBeanClass; + } + } } } diff --git a/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientScanV1MapperComparisonBenchmark.java b/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientScanV1MapperComparisonBenchmark.java index f1875255adc2..8d763ffe4b4e 100644 --- a/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientScanV1MapperComparisonBenchmark.java +++ b/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientScanV1MapperComparisonBenchmark.java @@ -44,8 +44,11 @@ @State(Scope.Benchmark) public class EnhancedClientScanV1MapperComparisonBenchmark { private static final V2ItemFactory V2_ITEM_FACTORY = new V2ItemFactory(); + private static final V2MapperItemFactory V2_MAPPER_ITEM_FACTORY = new V2MapperItemFactory(); private static final V1ItemFactory V1_ITEM_FACTORY = new V1ItemFactory(); private static final DynamoDBScanExpression V1_SCAN_EXPRESSION = new DynamoDBScanExpression(); + private static final software.amazon.awssdk.mapper.dynamodb.DynamoDBScanExpression V2_MAPPER_SCAN_EXPRESSION = + new software.amazon.awssdk.mapper.dynamodb.DynamoDBScanExpression(); @Benchmark public Object v2Scan(TestState s) { @@ -57,6 +60,11 @@ public Object v1Scan(TestState s) { return s.v1DdbMapper.scan(s.testItem.getV1BeanClass(), V1_SCAN_EXPRESSION).iterator().next(); } + @Benchmark + public Object v2MapperScan(TestState s) { + return s.v2DdbMapper.scan(s.testItem.getV2MapperBeanClass(), V2_MAPPER_SCAN_EXPRESSION).iterator().next(); + } + private static DynamoDbClient getV2Client(Blackhole bh, ScanResponse scanResponse) { return new V2TestDynamoDbScanClient(bh, scanResponse); } @@ -72,15 +80,17 @@ public static class TestState { private DynamoDbTable v2Table; private DynamoDBMapper v1DdbMapper; - + private software.amazon.awssdk.mapper.dynamodb.DynamoDBMapper v2DdbMapper; @Setup public void setup(Blackhole bh) { + DynamoDbClient v2Client = getV2Client(bh, testItem.v2Response); DynamoDbEnhancedClient v2DdbEnh = DynamoDbEnhancedClient.builder() - .dynamoDbClient(getV2Client(bh, testItem.v2Response)) + .dynamoDbClient(v2Client) .build(); v2Table = v2DdbEnh.table(testItem.name(), testItem.schema); + v2DdbMapper = new software.amazon.awssdk.mapper.dynamodb.DynamoDBMapper(v2Client); v1DdbMapper = new DynamoDBMapper(getV1Client(bh, testItem.v1Response)); } @@ -93,6 +103,7 @@ public enum TestItem { V2_ITEM_FACTORY.tiny(), V2_ITEM_FACTORY.tiny())) .build(), + V2MapperItemFactory.V2MapperTinyBean.class, V1ItemFactory.V1TinyBean.class, new ScanResult().withItems( @@ -105,6 +116,7 @@ public enum TestItem { V2_ITEM_FACTORY.small(), V2_ITEM_FACTORY.small())) .build(), + V2MapperItemFactory.V2MapperSmallBean.class, V1ItemFactory.V1SmallBean.class, new ScanResult().withItems( @@ -118,6 +130,7 @@ public enum TestItem { V2_ITEM_FACTORY.huge(), V2_ITEM_FACTORY.huge())) .build(), + V2MapperItemFactory.V2MapperHugeBean.class, V1ItemFactory.V1HugeBean.class, new ScanResult().withItems( @@ -131,6 +144,7 @@ public enum TestItem { V2_ITEM_FACTORY.hugeFlat(), V2_ITEM_FACTORY.hugeFlat())) .build(), + V2MapperItemFactory.V2MapperHugeBeanFlat.class, V1ItemFactory.V1HugeBeanFlat.class, new ScanResult().withItems( @@ -138,21 +152,26 @@ public enum TestItem { ), ; - // V2 + // Enhanced Client private TableSchema schema; private ScanResponse v2Response; + // Mapper v2 + private Class v2MapperBeanClass; + // V1 private Class v1BeanClass; private ScanResult v1Response; TestItem(TableSchema schema, ScanResponse v2Response, + Class v2MapperBeanClass, Class v1BeanClass, ScanResult v1Response) { this.schema = schema; this.v2Response = v2Response; + this.v2MapperBeanClass = v2MapperBeanClass; this.v1BeanClass = v1BeanClass; this.v1Response = v1Response; @@ -161,6 +180,11 @@ public enum TestItem { public Class getV1BeanClass() { return v1BeanClass; } + + public Class getV2MapperBeanClass() { + return v2MapperBeanClass; + } + } } } diff --git a/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientUpdateV1MapperComparisonBenchmark.java b/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientUpdateV1MapperComparisonBenchmark.java index a538526b6470..2ae377ff6a89 100644 --- a/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientUpdateV1MapperComparisonBenchmark.java +++ b/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/EnhancedClientUpdateV1MapperComparisonBenchmark.java @@ -43,11 +43,16 @@ @State(Scope.Benchmark) public class EnhancedClientUpdateV1MapperComparisonBenchmark { private static final V2ItemFactory V2_ITEM_FACTORY = new V2ItemFactory(); + private static final V2MapperItemFactory V2_MAPPER_ITEM_FACTORY = new V2MapperItemFactory(); private static final V1ItemFactory V1_ITEM_FACTORY = new V1ItemFactory(); private static final DynamoDBMapperConfig MAPPER_CONFIG = DynamoDBMapperConfig.builder() .withSaveBehavior(DynamoDBMapperConfig.SaveBehavior.UPDATE) .build(); + private static final software.amazon.awssdk.mapper.dynamodb.DynamoDBMapperConfig V2_MAPPER_CONFIG = + software.amazon.awssdk.mapper.dynamodb.DynamoDBMapperConfig.builder() + .withSaveBehavior(software.amazon.awssdk.mapper.dynamodb.DynamoDBMapperConfig.SaveBehavior.UPDATE) + .build(); @Benchmark public void v2Update(TestState s) { @@ -59,6 +64,11 @@ public void v1Update(TestState s) { s.v1DdbMapper.save(s.testItem.v1Bean); } + @Benchmark + public void v2MapperUpdate(TestState s) { + s.v2DdbMapper.save(s.testItem.v2MapperBean); + } + private static DynamoDbClient getV2Client(Blackhole bh, UpdateItemResponse updateItemResponse) { return new V2TestDynamoDbUpdateItemClient(bh, updateItemResponse); } @@ -74,15 +84,17 @@ public static class TestState { private DynamoDbTable v2Table; private DynamoDBMapper v1DdbMapper; - + private software.amazon.awssdk.mapper.dynamodb.DynamoDBMapper v2DdbMapper; @Setup public void setup(Blackhole bh) { + DynamoDbClient v2Client = getV2Client(bh, testItem.v2UpdateItemResponse); DynamoDbEnhancedClient v2DdbEnh = DynamoDbEnhancedClient.builder() - .dynamoDbClient(getV2Client(bh, testItem.v2UpdateItemResponse)) + .dynamoDbClient(v2Client) .build(); v2Table = v2DdbEnh.table(testItem.name(), testItem.schema); + v2DdbMapper = new software.amazon.awssdk.mapper.dynamodb.DynamoDBMapper(v2Client, V2_MAPPER_CONFIG); v1DdbMapper = new DynamoDBMapper(getV1Client(bh, testItem.v1UpdateItemResult), MAPPER_CONFIG); } @@ -92,6 +104,7 @@ public enum TestItem { V2ItemFactory.TINY_BEAN_TABLE_SCHEMA, V2_ITEM_FACTORY.tinyBean(), UpdateItemResponse.builder().attributes(V2_ITEM_FACTORY.tiny()).build(), + V2_MAPPER_ITEM_FACTORY.v2MapperTinyBean(), V1_ITEM_FACTORY.v1TinyBean(), new UpdateItemResult().withAttributes(V1_ITEM_FACTORY.tiny()) @@ -101,6 +114,7 @@ public enum TestItem { V2ItemFactory.SMALL_BEAN_TABLE_SCHEMA, V2_ITEM_FACTORY.smallBean(), UpdateItemResponse.builder().attributes(V2_ITEM_FACTORY.small()).build(), + V2_MAPPER_ITEM_FACTORY.v2MapperSmallBean(), V1_ITEM_FACTORY.v1SmallBean(), new UpdateItemResult().withAttributes(V1_ITEM_FACTORY.small()) @@ -110,6 +124,7 @@ public enum TestItem { V2ItemFactory.HUGE_BEAN_TABLE_SCHEMA, V2_ITEM_FACTORY.hugeBean(), UpdateItemResponse.builder().attributes(V2_ITEM_FACTORY.huge()).build(), + V2_MAPPER_ITEM_FACTORY.v2MapperHugeBean(), V1_ITEM_FACTORY.v1hugeBean(), new UpdateItemResult().withAttributes(V1_ITEM_FACTORY.huge()) @@ -119,30 +134,36 @@ public enum TestItem { V2ItemFactory.HUGE_BEAN_FLAT_TABLE_SCHEMA, V2_ITEM_FACTORY.hugeBeanFlat(), UpdateItemResponse.builder().attributes(V2_ITEM_FACTORY.hugeFlat()).build(), + V2_MAPPER_ITEM_FACTORY.v2MapperHugeBeanFlat(), V1_ITEM_FACTORY.v1HugeBeanFlat(), new UpdateItemResult().withAttributes(V1_ITEM_FACTORY.hugeFlat()) ), ; - // V2 + // Enhanced Client private TableSchema schema; private Object v2Bean; private UpdateItemResponse v2UpdateItemResponse; + // Mapper v2 + private Object v2MapperBean; + // V1 private Object v1Bean; private UpdateItemResult v1UpdateItemResult; TestItem(TableSchema schema, - Object v2Bean, - UpdateItemResponse v2UpdateItemResponse, + Object v2Bean, + UpdateItemResponse v2UpdateItemResponse, + Object v2MapperBean, - Object v1Bean, + Object v1Bean, UpdateItemResult v1UpdateItemResult) { this.schema = schema; this.v2Bean = v2Bean; this.v2UpdateItemResponse = v2UpdateItemResponse; + this.v2MapperBean = v2MapperBean; this.v1Bean = v1Bean; this.v1UpdateItemResult = v1UpdateItemResult; diff --git a/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/V2MapperItemFactory.java b/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/V2MapperItemFactory.java new file mode 100644 index 000000000000..04d1b4b755be --- /dev/null +++ b/test/sdk-benchmarks/src/main/java/software/amazon/awssdk/benchmark/enhanced/dynamodb/V2MapperItemFactory.java @@ -0,0 +1,699 @@ +/* + * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. + * + * Licensed under the Apache License, Version 2.0 (the "License"). + * You may not use this file except in compliance with the License. + * A copy of the License is located at + * + * http://aws.amazon.com/apache2.0 + * + * or in the "license" file accompanying this file. This file is distributed + * on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either + * express or implied. See the License for the specific language governing + * permissions and limitations under the License. + */ + +package software.amazon.awssdk.benchmark.enhanced.dynamodb; + +import com.amazonaws.util.ImmutableMapParameter; +import java.lang.reflect.Method; +import java.nio.ByteBuffer; +import java.util.List; +import java.util.Map; +import java.util.stream.Collectors; +import software.amazon.awssdk.core.SdkBytes; +import software.amazon.awssdk.mapper.dynamodb.DynamoDBAttribute; +import software.amazon.awssdk.mapper.dynamodb.DynamoDBHashKey; +import software.amazon.awssdk.mapper.dynamodb.DynamoDBTable; +import software.amazon.awssdk.services.dynamodb.model.AttributeValue; + +public final class V2MapperItemFactory extends ItemFactory { + public V2MapperHugeBean v2MapperHugeBean() { + return V2MapperHugeBean.fromHugeBean(super.hugeBean()); + } + + public V2MapperTinyBean v2MapperTinyBean() { + return V2MapperTinyBean.fromTinyBean(super.tinyBean()); + } + + public V2MapperSmallBean v2MapperSmallBean() { + return V2MapperSmallBean.fromSmallBean(super.smallBean()); + } + + public V2MapperHugeBeanFlat v2MapperHugeBeanFlat() { + return V2MapperHugeBeanFlat.fromHugeBeanFlat(super.hugeBeanFlat()); + } + + @Override + protected Map asItem(TinyBean b) { + ImmutableMapParameter.Builder builder = ImmutableMapParameter.builder(); + + builder.put("stringAttr", av(b.getStringAttr())); + + return builder.build(); + } + + @Override + protected Map asItem(SmallBean b) { + ImmutableMapParameter.Builder builder = ImmutableMapParameter.builder(); + + builder.put("stringAttr", av(b.getStringAttr())); + builder.put("binaryAttr", av(b.getBinaryAttr())); + + List listAttr = b.getListAttr().stream().map(this::av).collect(Collectors.toList()); + + builder.put("listAttr", av(listAttr)); + + return builder.build(); + } + + @Override + protected Map asItem(HugeBean b) { + ImmutableMapParameter.Builder builder = ImmutableMapParameter.builder(); + + builder.put("hashKey", av(b.getHashKey())); + builder.put("stringAttr", av(b.getStringAttr())); + builder.put("binaryAttr", av(b.getBinaryAttr())); + + List listAttr = b.getListAttr().stream().map(this::av).collect(Collectors.toList()); + + builder.put("listAttr", av(listAttr)); + + Map mapAttr1 = b.getMapAttr1().entrySet().stream().collect( + Collectors.toMap(Map.Entry::getKey, + e -> av(e.getValue()))); + + builder.put("mapAttr1", av(mapAttr1)); + + + Map mapAttr2 = b.getMapAttr2().entrySet().stream().collect( + Collectors.toMap(Map.Entry::getKey, + e -> av(e.getValue().stream().map(this::av).collect(Collectors.toList())))); + + builder.put("mapAttr2", av(mapAttr2)); + + Map mapAttr3 = b.getMapAttr3().entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, + e -> { + List>> value = e.getValue(); + AttributeValue valueAv = av(value.stream().map(m -> av(m.entrySet().stream() + .collect(Collectors.toMap(Map.Entry::getKey, + ee -> av(ee.getValue().stream().map(this::av).collect(Collectors.toList())))))) + .collect(Collectors.toList())); + return valueAv; + })); + + builder.put("mapAttr3", av(mapAttr3)); + + return builder.build(); + } + + @Override + protected AttributeValue av(String val) { + return AttributeValue.builder().s(val).build(); + } + + @Override + protected AttributeValue av(List val) { + return AttributeValue.builder().l(val).build(); + } + + @Override + protected AttributeValue av(Map val) { + return AttributeValue.builder().m(val).build(); + } + + @Override + protected AttributeValue av(SdkBytes val) { + return AttributeValue.builder().b(val).build(); + } + + @DynamoDBTable(tableName = "V2MapperTinyBean") + public static class V2MapperTinyBean extends ItemFactory.TinyBean { + public V2MapperTinyBean() { + } + + public V2MapperTinyBean(String stringAttr) { + super.setStringAttr(stringAttr); + } + + @DynamoDBHashKey + @Override + public String getStringAttr() { + return super.getStringAttr(); + } + + private static V2MapperTinyBean fromTinyBean(TinyBean tb) { + V2MapperTinyBean b = new V2MapperTinyBean(); + b.setStringAttr(tb.getStringAttr()); + return b; + } + } + + @DynamoDBTable(tableName = "V2MapperSmallBean") + public static class V2MapperSmallBean extends ItemFactory.SmallBean { + private ByteBuffer binaryAttr; + + public V2MapperSmallBean() { + } + + public V2MapperSmallBean(String stringAttr) { + super.setStringAttr(stringAttr); + } + + @DynamoDBHashKey + @Override + public String getStringAttr() { + return super.getStringAttr(); + } + + @DynamoDBAttribute(attributeName = "binaryAttr") + public ByteBuffer getBinaryAttrV2Mapper() { + return binaryAttr; + } + + @DynamoDBAttribute(attributeName = "binaryAttr") + public void setBinaryAttrV2Mapper(ByteBuffer binaryAttr) { + this.binaryAttr = binaryAttr; + } + + @DynamoDBAttribute + @Override + public List getListAttr() { + return super.getListAttr(); + } + + private static V2MapperSmallBean fromSmallBean(SmallBean sb) { + V2MapperSmallBean b = new V2MapperSmallBean(); + b.setStringAttr(sb.getStringAttr()); + b.setBinaryAttrV2Mapper(sb.getBinaryAttr().asByteBuffer()); + b.setListAttr(sb.getListAttr()); + return b; + } + } + + @DynamoDBTable(tableName = "V2MapperHugeBean") + public static class V2MapperHugeBean extends ItemFactory.HugeBean { + private ByteBuffer binaryAttr; + private Map mapAttr1; + private Map> mapAttr2; + private Map>>> mapAttr3; + + public V2MapperHugeBean() { + } + + public V2MapperHugeBean(String stringAttr) { + super.setStringAttr(stringAttr); + } + + @DynamoDBHashKey + @Override + public String getStringAttr() { + return super.getStringAttr(); + } + + @DynamoDBAttribute + @Override + public String getHashKey() { + return super.getHashKey(); + } + + @DynamoDBAttribute(attributeName = "binaryAttr") + public ByteBuffer getBinaryAttrV2Mapper() { + return binaryAttr; + } + + @DynamoDBAttribute(attributeName = "binaryAttr") + public void setBinaryAttrV2Mapper(ByteBuffer binaryAttr) { + this.binaryAttr = binaryAttr; + } + + @DynamoDBAttribute + @Override + public List getListAttr() { + return super.getListAttr(); + } + + @DynamoDBAttribute(attributeName = "mapAttr1") + public Map getMapAttr1V2Mapper() { + return mapAttr1; + } + + @DynamoDBAttribute(attributeName = "mapAttr1") + public void setMapAttr1V2Mapper(Map mapAttr1) { + this.mapAttr1 = mapAttr1; + } + + @DynamoDBAttribute(attributeName = "mapAttr2") + public Map> getMapAttr2V2Mapper() { + return mapAttr2; + } + + @DynamoDBAttribute(attributeName = "mapAttr2") + public void setMapAttr2V2Mapper(Map> mapAttr2) { + this.mapAttr2 = mapAttr2; + } + + @DynamoDBAttribute(attributeName = "mapAttr3") + public Map>>> getMapAttr3V2Mapper() { + return mapAttr3; + } + + @DynamoDBAttribute(attributeName = "mapAttr3") + public void setMapAttr3V2Mapper(Map>>> mapAttr3) { + this.mapAttr3 = mapAttr3; + } + + private static V2MapperHugeBean fromHugeBean(HugeBean hb) { + V2MapperHugeBean b = new V2MapperHugeBean(); + b.setHashKey(hb.getHashKey()); + b.setStringAttr(hb.getStringAttr()); + b.setBinaryAttrV2Mapper(hb.getBinaryAttr().asByteBuffer()); + b.setListAttr(hb.getListAttr()); + + b.setMapAttr1V2Mapper(hb.getMapAttr1() + .entrySet().stream() + .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().asByteBuffer()))); + + b.setMapAttr2V2Mapper(hb.getMapAttr2() + .entrySet().stream() + .collect(Collectors.toMap(Map.Entry::getKey, + e -> e.getValue().stream().map(SdkBytes::asByteBuffer).collect(Collectors.toList())))); + + Map>>> mapAttr3V2Mapper = hb.getMapAttr3() + .entrySet().stream() + .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().stream() + .map(m -> m.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, ee -> + ee.getValue().stream().map(SdkBytes::asByteBuffer).collect(Collectors.toList()) + ))) + .collect(Collectors.toList()))); + + b.setMapAttr3V2Mapper(mapAttr3V2Mapper); + + return b; + } + } + + @DynamoDBTable(tableName = "V2MapperHugeBeanFlat") + public static class V2MapperHugeBeanFlat extends HugeBeanFlat { + public V2MapperHugeBeanFlat() { + } + + public V2MapperHugeBeanFlat(String stringAttr) { + this.setStringAttr1(stringAttr); + } + + @DynamoDBAttribute(attributeName = "stringAttr1") + @DynamoDBHashKey + @Override + public String getStringAttr1() { + return super.getStringAttr1(); + } + + @DynamoDBAttribute(attributeName = "stringAttr2") + @Override + public String getStringAttr2() { + return super.getStringAttr2(); + } + + @DynamoDBAttribute(attributeName = "stringAttr3") + @Override + public String getStringAttr3() { + return super.getStringAttr3(); + } + + @DynamoDBAttribute(attributeName = "stringAttr4") + @Override + public String getStringAttr4() { + return super.getStringAttr4(); + } + + @DynamoDBAttribute(attributeName = "stringAttr5") + @Override + public String getStringAttr5() { + return super.getStringAttr5(); + } + + @DynamoDBAttribute(attributeName = "stringAttr6") + @Override + public String getStringAttr6() { + return super.getStringAttr6(); + } + + @DynamoDBAttribute(attributeName = "stringAttr7") + @Override + public String getStringAttr7() { + return super.getStringAttr7(); + } + + @DynamoDBAttribute(attributeName = "stringAttr8") + @Override + public String getStringAttr8() { + return super.getStringAttr8(); + } + + @DynamoDBAttribute(attributeName = "stringAttr9") + @Override + public String getStringAttr9() { + return super.getStringAttr9(); + } + + @DynamoDBAttribute(attributeName = "stringAttr10") + @Override + public String getStringAttr10() { + return super.getStringAttr10(); + } + + @DynamoDBAttribute(attributeName = "stringAttr11") + @Override + public String getStringAttr11() { + return super.getStringAttr11(); + } + + @DynamoDBAttribute(attributeName = "stringAttr12") + @Override + public String getStringAttr12() { + return super.getStringAttr12(); + } + + @DynamoDBAttribute(attributeName = "stringAttr13") + @Override + public String getStringAttr13() { + return super.getStringAttr13(); + } + + @DynamoDBAttribute(attributeName = "stringAttr14") + @Override + public String getStringAttr14() { + return super.getStringAttr14(); + } + + @DynamoDBAttribute(attributeName = "stringAttr15") + @Override + public String getStringAttr15() { + return super.getStringAttr15(); + } + + @DynamoDBAttribute(attributeName = "stringAttr16") + @Override + public String getStringAttr16() { + return super.getStringAttr16(); + } + + @DynamoDBAttribute(attributeName = "stringAttr17") + @Override + public String getStringAttr17() { + return super.getStringAttr17(); + } + + @DynamoDBAttribute(attributeName = "stringAttr18") + @Override + public String getStringAttr18() { + return super.getStringAttr18(); + } + + @DynamoDBAttribute(attributeName = "stringAttr19") + @Override + public String getStringAttr19() { + return super.getStringAttr19(); + } + + @DynamoDBAttribute(attributeName = "stringAttr20") + @Override + public String getStringAttr20() { + return super.getStringAttr20(); + } + + @DynamoDBAttribute(attributeName = "stringAttr21") + @Override + public String getStringAttr21() { + return super.getStringAttr21(); + } + + @DynamoDBAttribute(attributeName = "stringAttr22") + @Override + public String getStringAttr22() { + return super.getStringAttr22(); + } + + @DynamoDBAttribute(attributeName = "stringAttr23") + @Override + public String getStringAttr23() { + return super.getStringAttr23(); + } + + @DynamoDBAttribute(attributeName = "stringAttr24") + @Override + public String getStringAttr24() { + return super.getStringAttr24(); + } + + @DynamoDBAttribute(attributeName = "stringAttr25") + @Override + public String getStringAttr25() { + return super.getStringAttr25(); + } + + @DynamoDBAttribute(attributeName = "stringAttr26") + @Override + public String getStringAttr26() { + return super.getStringAttr26(); + } + + @DynamoDBAttribute(attributeName = "stringAttr27") + @Override + public String getStringAttr27() { + return super.getStringAttr27(); + } + + @DynamoDBAttribute(attributeName = "stringAttr28") + @Override + public String getStringAttr28() { + return super.getStringAttr28(); + } + + @DynamoDBAttribute(attributeName = "stringAttr29") + @Override + public String getStringAttr29() { + return super.getStringAttr29(); + } + + @DynamoDBAttribute(attributeName = "stringAttr30") + @Override + public String getStringAttr30() { + return super.getStringAttr30(); + } + + @DynamoDBAttribute(attributeName = "stringAttr31") + @Override + public String getStringAttr31() { + return super.getStringAttr31(); + } + + @DynamoDBAttribute(attributeName = "stringAttr32") + @Override + public String getStringAttr32() { + return super.getStringAttr32(); + } + + @DynamoDBAttribute(attributeName = "stringAttr33") + @Override + public String getStringAttr33() { + return super.getStringAttr33(); + } + + @DynamoDBAttribute(attributeName = "stringAttr34") + @Override + public String getStringAttr34() { + return super.getStringAttr34(); + } + + @DynamoDBAttribute(attributeName = "stringAttr35") + @Override + public String getStringAttr35() { + return super.getStringAttr35(); + } + + @DynamoDBAttribute(attributeName = "stringAttr36") + @Override + public String getStringAttr36() { + return super.getStringAttr36(); + } + + @DynamoDBAttribute(attributeName = "stringAttr37") + @Override + public String getStringAttr37() { + return super.getStringAttr37(); + } + + @DynamoDBAttribute(attributeName = "stringAttr38") + @Override + public String getStringAttr38() { + return super.getStringAttr38(); + } + + @DynamoDBAttribute(attributeName = "stringAttr39") + @Override + public String getStringAttr39() { + return super.getStringAttr39(); + } + + @DynamoDBAttribute(attributeName = "stringAttr40") + @Override + public String getStringAttr40() { + return super.getStringAttr40(); + } + + @DynamoDBAttribute(attributeName = "stringAttr41") + @Override + public String getStringAttr41() { + return super.getStringAttr41(); + } + + @DynamoDBAttribute(attributeName = "stringAttr42") + @Override + public String getStringAttr42() { + return super.getStringAttr42(); + } + + @DynamoDBAttribute(attributeName = "stringAttr43") + @Override + public String getStringAttr43() { + return super.getStringAttr43(); + } + + @DynamoDBAttribute(attributeName = "stringAttr44") + @Override + public String getStringAttr44() { + return super.getStringAttr44(); + } + + @DynamoDBAttribute(attributeName = "stringAttr45") + @Override + public String getStringAttr45() { + return super.getStringAttr45(); + } + + @DynamoDBAttribute(attributeName = "stringAttr46") + @Override + public String getStringAttr46() { + return super.getStringAttr46(); + } + + @DynamoDBAttribute(attributeName = "stringAttr47") + @Override + public String getStringAttr47() { + return super.getStringAttr47(); + } + + @DynamoDBAttribute(attributeName = "stringAttr48") + @Override + public String getStringAttr48() { + return super.getStringAttr48(); + } + + @DynamoDBAttribute(attributeName = "stringAttr49") + @Override + public String getStringAttr49() { + return super.getStringAttr49(); + } + + @DynamoDBAttribute(attributeName = "stringAttr50") + @Override + public String getStringAttr50() { + return super.getStringAttr50(); + } + + @DynamoDBAttribute(attributeName = "stringAttr51") + @Override + public String getStringAttr51() { + return super.getStringAttr51(); + } + + @DynamoDBAttribute(attributeName = "stringAttr52") + @Override + public String getStringAttr52() { + return super.getStringAttr52(); + } + + @DynamoDBAttribute(attributeName = "stringAttr53") + @Override + public String getStringAttr53() { + return super.getStringAttr53(); + } + + @Override + @DynamoDBAttribute(attributeName = "stringAttr54") + public String getStringAttr54() { + return super.getStringAttr54(); + } + + @DynamoDBAttribute(attributeName = "stringAttr55") + @Override + public String getStringAttr55() { + return super.getStringAttr55(); + } + + @DynamoDBAttribute(attributeName = "stringAttr56") + @Override + public String getStringAttr56() { + return super.getStringAttr56(); + } + + @DynamoDBAttribute(attributeName = "stringAttr57") + @Override + public String getStringAttr57() { + return super.getStringAttr57(); + } + + @DynamoDBAttribute(attributeName = "stringAttr58") + @Override + public String getStringAttr58() { + return super.getStringAttr58(); + } + + @DynamoDBAttribute(attributeName = "stringAttr59") + @Override + public String getStringAttr59() { + return super.getStringAttr59(); + } + + @DynamoDBAttribute(attributeName = "stringAttr60") + @Override + public String getStringAttr60() { + return super.getStringAttr60(); + } + + @DynamoDBAttribute(attributeName = "stringAttr61") + @Override + public String getStringAttr61() { + return super.getStringAttr61(); + } + + @DynamoDBAttribute(attributeName = "stringAttr62") + @Override + public String getStringAttr62() { + return super.getStringAttr62(); + } + + @DynamoDBAttribute(attributeName = "stringAttr63") + @Override + public String getStringAttr63() { + return super.getStringAttr63(); + } + + public static V2MapperHugeBeanFlat fromHugeBeanFlat(HugeBeanFlat b) { + V2MapperHugeBeanFlat bean = new V2MapperHugeBeanFlat(); + for (int i = 1; i <= 63; ++i) { + try { + Method setter = V2MapperHugeBeanFlat.class.getMethod("setStringAttr" + i, String.class); + Method getter = HugeBeanFlat.class.getMethod("getStringAttr" + i); + setter.setAccessible(true); + setter.invoke(bean, getter.invoke(b)); + } catch (Throwable t) { + throw new RuntimeException(t); + } + } + return bean; + } + } +}