Optimization - only pass constants to Optional.orElse()

Author: jeffgbutler

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) {

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) {

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;
     }

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() {

src/main/java/org/mybatis/dynamic/sql/select/render/LimitAndOffsetPagingModelRenderer.java

@@ -36,13 +36,13 @@ public LimitAndOffsetPagingModelRenderer(RenderingStrategy renderingStrategy,
     public Optional<FragmentAndParameters> render() {
         return pagingModel.limit()
                 .map(this::renderWithLimit)
-                .orElse(renderOffsetOnly());
+                .orElseGet(this::renderOffsetOnly);
     }
 
     private Optional<FragmentAndParameters> renderWithLimit(Long limit) {
         return pagingModel.offset()
                 .map(o -> renderLimitAndOffset(limit, o))
-                .orElse(renderLimitOnly(limit));
+                .orElseGet(() -> renderLimitOnly(limit));
     }
 
     private Optional<FragmentAndParameters> renderOffsetOnly() {

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() {