Merge pull request #98 from jeffgbutler/master

jeffgbutler · web-flow · commit e76d20139d6b · 2019-06-26T17:39:02.000-04:00
Misc. Optimizations
diff --git a/src/main/java/org/mybatis/dynamic/sql/SqlTable.java b/src/main/java/org/mybatis/dynamic/sql/SqlTable.java
@@ -52,12 +52,12 @@ protected SqlTable(Supplier<Optional<String>> catalogSupplier, Supplier<Optional
     private String compose(Supplier<Optional<String>> catalogSupplier, Supplier<Optional<String>> schemaSupplier,
             String tableName) {
         return catalogSupplier.get().map(c -> compose(c, schemaSupplier, tableName))
-                .orElse(compose(schemaSupplier, tableName));
+                .orElseGet(() -> compose(schemaSupplier, tableName));
     }
     
     private String compose(String catalog, Supplier<Optional<String>> schemaSupplier, String tableName) {
         return schemaSupplier.get().map(s -> composeCatalogSchemaAndAndTable(catalog, s, tableName))
-                .orElse(composeCatalogAndTable(catalog, tableName));
+                .orElseGet(() -> composeCatalogAndTable(catalog, tableName));
     }
 
     private String compose(Supplier<Optional<String>> schemaSupplier, String tableName) {
diff --git a/src/main/java/org/mybatis/dynamic/sql/render/GuaranteedTableAliasCalculator.java b/src/main/java/org/mybatis/dynamic/sql/render/GuaranteedTableAliasCalculator.java
@@ -37,7 +37,7 @@ private GuaranteedTableAliasCalculator(Map<SqlTable, String> aliases) {
     public Optional<String> aliasForColumn(SqlTable table) {
         return super.aliasForColumn(table)
                 .map(Optional::of)
-                .orElse(Optional.of(table.tableNameAtRuntime()));
+                .orElseGet(() -> Optional.of(table.tableNameAtRuntime()));
     }
     
     public static TableAliasCalculator of(Map<SqlTable, String> aliases) {
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/LimitAndOffsetPagingModel.java b/src/main/java/org/mybatis/dynamic/sql/select/LimitAndOffsetPagingModel.java
@@ -15,6 +15,7 @@
  */
 package org.mybatis.dynamic.sql.select;
 
+import java.util.Objects;
 import java.util.Optional;
 
 public class LimitAndOffsetPagingModel implements PagingModel {
@@ -23,12 +24,12 @@ public class LimitAndOffsetPagingModel implements PagingModel {
     private Long offset;
     
     private LimitAndOffsetPagingModel(Builder builder) {
-        this.limit = builder.limit;
+        this.limit = Objects.requireNonNull(builder.limit);
         this.offset = builder.offset;
     }
     
-    public Optional<Long> limit() {
-        return Optional.ofNullable(limit);
+    public Long limit() {
+        return limit;
     }
     
     public Optional<Long> offset() {
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/QueryExpressionModel.java b/src/main/java/org/mybatis/dynamic/sql/select/QueryExpressionModel.java
@@ -50,7 +50,7 @@ private QueryExpressionModel(Builder builder) {
         table = Objects.requireNonNull(builder.table);
         joinModel = builder.joinModel;
         tableAliasCalculator = joinModel().map(jm -> GuaranteedTableAliasCalculator.of(builder.tableAliases))
-                .orElse(TableAliasCalculator.of(builder.tableAliases));
+                .orElseGet(() -> TableAliasCalculator.of(builder.tableAliases));
         whereModel = builder.whereModel;
         groupByModel = builder.groupByModel;
     }
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/SelectDSL.java b/src/main/java/org/mybatis/dynamic/sql/select/SelectDSL.java
@@ -140,18 +140,15 @@ public R build() {
     }
 
     public class OffsetFinisher implements Buildable<R> {
-        private LimitAndOffsetPagingModel pagingModel;
-
         public OffsetFinisher(long limit, long offset) {
-            pagingModel = new LimitAndOffsetPagingModel.Builder()
+            SelectDSL.this.pagingModel = new LimitAndOffsetPagingModel.Builder()
                     .withLimit(limit)
                     .withOffset(offset)
                     .build();
         }
         
         @Override
         public R build() {
-            SelectDSL.this.pagingModel = pagingModel;
             return SelectDSL.this.build();
         }
     }
@@ -169,7 +166,7 @@ public FetchFirstFinisher fetchFirst(long fetchFirstRows) {
         
         @Override
         public R build() {
-            SelectDSL.this.pagingModel = new LimitAndOffsetPagingModel.Builder()
+            SelectDSL.this.pagingModel = new FetchFirstPagingModel.Builder()
                     .withOffset(offset)
                     .build();
             return SelectDSL.this.build();
@@ -196,7 +193,6 @@ public RowsOnlyFinisher rowsOnly() {
     }
     
     public class RowsOnlyFinisher implements Buildable<R> {
-        
         @Override
         public R build() {
             return SelectDSL.this.build();
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/render/FetchFirstPagingModelRenderer.java b/src/main/java/org/mybatis/dynamic/sql/select/render/FetchFirstPagingModelRenderer.java
@@ -36,13 +36,13 @@ public FetchFirstPagingModelRenderer(RenderingStrategy renderingStrategy,
     public Optional<FragmentAndParameters> render() {
         return pagingModel.offset()
                 .map(this::renderWithOffset)
-                .orElse(renderFetchFirstRowsOnly());
+                .orElseGet(this::renderFetchFirstRowsOnly);
     }
 
     private Optional<FragmentAndParameters> renderWithOffset(Long offset) {
         return pagingModel.fetchFirstRows()
                 .map(ffr -> renderOffsetAndFetchFirstRows(offset, ffr))
-                .orElse(renderOffsetOnly(offset));
+                .orElseGet(() -> renderOffsetOnly(offset));
     }
     
     private Optional<FragmentAndParameters> renderFetchFirstRowsOnly() {
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/render/LimitAndOffsetPagingModelRenderer.java b/src/main/java/org/mybatis/dynamic/sql/select/render/LimitAndOffsetPagingModelRenderer.java
@@ -34,38 +34,21 @@ public LimitAndOffsetPagingModelRenderer(RenderingStrategy renderingStrategy,
     }
     
     public Optional<FragmentAndParameters> render() {
-        return pagingModel.limit()
-                .map(this::renderWithLimit)
-                .orElse(renderOffsetOnly());
-    }
-
-    private Optional<FragmentAndParameters> renderWithLimit(Long limit) {
         return pagingModel.offset()
-                .map(o -> renderLimitAndOffset(limit, o))
-                .orElse(renderLimitOnly(limit));
-    }
-    
-    private Optional<FragmentAndParameters> renderOffsetOnly() {
-        return pagingModel.offset().flatMap(this::renderOffsetOnly);
-    }
-    
-    private Optional<FragmentAndParameters> renderOffsetOnly(Long offset) {
-        return FragmentAndParameters
-                .withFragment("offset " + renderPlaceholder(OFFSET_PARAMETER)) //$NON-NLS-1$
-                .withParameter(OFFSET_PARAMETER, offset)
-                .buildOptional();
+                .map(this::renderLimitAndOffset)
+                .orElseGet(this::renderLimitOnly);
     }
-    
-    private Optional<FragmentAndParameters> renderLimitOnly(Long limit) {
+
+    private Optional<FragmentAndParameters> renderLimitOnly() {
         return FragmentAndParameters.withFragment("limit " + renderPlaceholder(LIMIT_PARAMETER)) //$NON-NLS-1$
-                .withParameter(LIMIT_PARAMETER, limit)
+                .withParameter(LIMIT_PARAMETER, pagingModel.limit())
                 .buildOptional();
     }
     
-    private Optional<FragmentAndParameters> renderLimitAndOffset(Long limit, Long offset) {
+    private Optional<FragmentAndParameters> renderLimitAndOffset(Long offset) {
         return FragmentAndParameters.withFragment("limit " + renderPlaceholder(LIMIT_PARAMETER) //$NON-NLS-1$
                     + " offset " + renderPlaceholder(OFFSET_PARAMETER)) //$NON-NLS-1$
-                .withParameter(LIMIT_PARAMETER, limit)
+                .withParameter(LIMIT_PARAMETER, pagingModel.limit())
                 .withParameter(OFFSET_PARAMETER, offset)
                 .buildOptional();
     }
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/render/SelectRenderer.java b/src/main/java/org/mybatis/dynamic/sql/select/render/SelectRenderer.java
@@ -38,7 +38,7 @@ public class SelectRenderer {
     private SelectRenderer(Builder builder) {
         selectModel = Objects.requireNonNull(builder.selectModel);
         renderingStrategy = Objects.requireNonNull(builder.renderingStrategy);
-        sequence = builder.sequence().orElse(new AtomicInteger(1));
+        sequence = builder.sequence().orElseGet(() -> new AtomicInteger(1));
     }
     
     public SelectStatementProvider render() {

Original file line number	Diff line number	Diff line change
`@@ -52,12 +52,12 @@ protected SqlTable(Supplier<Optional<String>> catalogSupplier, Supplier<Optional`
`52`	`52`	`private String compose(Supplier<Optional<String>> catalogSupplier, Supplier<Optional<String>> schemaSupplier,`
`53`	`53`	`String tableName) {`
`54`	`54`	`return catalogSupplier.get().map(c -> compose(c, schemaSupplier, tableName))`
`55`		`- .orElse(compose(schemaSupplier, tableName));`
	`55`	`+ .orElseGet(() -> compose(schemaSupplier, tableName));`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`private String compose(String catalog, Supplier<Optional<String>> schemaSupplier, String tableName) {`
`59`	`59`	`return schemaSupplier.get().map(s -> composeCatalogSchemaAndAndTable(catalog, s, tableName))`
`60`		`- .orElse(composeCatalogAndTable(catalog, tableName));`
	`60`	`+ .orElseGet(() -> composeCatalogAndTable(catalog, tableName));`
`61`	`61`	`}`
`62`	`62`
`63`	`63`	`private String compose(Supplier<Optional<String>> schemaSupplier, String tableName) {`
Original file line number	Diff line number	Diff line change
`@@ -37,7 +37,7 @@ private GuaranteedTableAliasCalculator(Map<SqlTable, String> aliases) {`
`37`	`37`	`public Optional<String> aliasForColumn(SqlTable table) {`
`38`	`38`	`return super.aliasForColumn(table)`
`39`	`39`	`.map(Optional::of)`
`40`		`- .orElse(Optional.of(table.tableNameAtRuntime()));`
	`40`	`+ .orElseGet(() -> Optional.of(table.tableNameAtRuntime()));`
`41`	`41`	`}`
`42`	`42`
`43`	`43`	`public static TableAliasCalculator of(Map<SqlTable, String> aliases) {`
Original file line number	Diff line number	Diff line change
`@@ -50,7 +50,7 @@ private QueryExpressionModel(Builder builder) {`
`50`	`50`	`table = Objects.requireNonNull(builder.table);`
`51`	`51`	`joinModel = builder.joinModel;`
`52`	`52`	`tableAliasCalculator = joinModel().map(jm -> GuaranteedTableAliasCalculator.of(builder.tableAliases))`
`53`		`- .orElse(TableAliasCalculator.of(builder.tableAliases));`
	`53`	`+ .orElseGet(() -> TableAliasCalculator.of(builder.tableAliases));`
`54`	`54`	`whereModel = builder.whereModel;`
`55`	`55`	`groupByModel = builder.groupByModel;`
`56`	`56`	`}`
Original file line number	Diff line number	Diff line change
`@@ -36,13 +36,13 @@ public FetchFirstPagingModelRenderer(RenderingStrategy renderingStrategy,`
`36`	`36`	`public Optional<FragmentAndParameters> render() {`
`37`	`37`	`return pagingModel.offset()`
`38`	`38`	`.map(this::renderWithOffset)`
`39`		`- .orElse(renderFetchFirstRowsOnly());`
	`39`	`+ .orElseGet(this::renderFetchFirstRowsOnly);`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`private Optional<FragmentAndParameters> renderWithOffset(Long offset) {`
`43`	`43`	`return pagingModel.fetchFirstRows()`
`44`	`44`	`.map(ffr -> renderOffsetAndFetchFirstRows(offset, ffr))`
`45`		`- .orElse(renderOffsetOnly(offset));`
	`45`	`+ .orElseGet(() -> renderOffsetOnly(offset));`
`46`	`46`	`}`
`47`	`47`
`48`	`48`	`private Optional<FragmentAndParameters> renderFetchFirstRowsOnly() {`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ public class SelectRenderer {`
`38`	`38`	`private SelectRenderer(Builder builder) {`
`39`	`39`	`selectModel = Objects.requireNonNull(builder.selectModel);`
`40`	`40`	`renderingStrategy = Objects.requireNonNull(builder.renderingStrategy);`
`41`		`- sequence = builder.sequence().orElse(new AtomicInteger(1));`
	`41`	`+ sequence = builder.sequence().orElseGet(() -> new AtomicInteger(1));`
`42`	`42`	`}`
`43`	`43`
`44`	`44`	`public SelectStatementProvider render() {`