Merge pull request #908 from jeffgbutler/general-optimizations

jeffgbutler · web-flow · commit 4a4ff068e305 · 2025-02-12T17:06:00.000-05:00
General optimizations
diff --git a/src/main/java/org/mybatis/dynamic/sql/delete/DeleteDSL.java b/src/main/java/org/mybatis/dynamic/sql/delete/DeleteDSL.java
@@ -27,7 +27,6 @@
 import org.mybatis.dynamic.sql.common.OrderByModel;
 import org.mybatis.dynamic.sql.configuration.StatementConfiguration;
 import org.mybatis.dynamic.sql.util.Buildable;
-import org.mybatis.dynamic.sql.util.Utilities;
 import org.mybatis.dynamic.sql.where.AbstractWhereFinisher;
 import org.mybatis.dynamic.sql.where.AbstractWhereStarter;
 import org.mybatis.dynamic.sql.where.EmbeddedWhereModel;
@@ -51,7 +50,7 @@ private DeleteDSL(SqlTable table, @Nullable String tableAlias, Function<DeleteMo
 
     @Override
     public DeleteWhereBuilder where() {
-        whereBuilder = Utilities.buildIfNecessary(whereBuilder, DeleteWhereBuilder::new);
+        whereBuilder = Objects.requireNonNullElseGet(whereBuilder, DeleteWhereBuilder::new);
         return whereBuilder;
     }
 
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/CountDSL.java b/src/main/java/org/mybatis/dynamic/sql/select/CountDSL.java
@@ -25,7 +25,6 @@
 import org.mybatis.dynamic.sql.SqlTable;
 import org.mybatis.dynamic.sql.configuration.StatementConfiguration;
 import org.mybatis.dynamic.sql.util.Buildable;
-import org.mybatis.dynamic.sql.util.Utilities;
 import org.mybatis.dynamic.sql.where.AbstractWhereFinisher;
 import org.mybatis.dynamic.sql.where.EmbeddedWhereModel;
 
@@ -54,7 +53,7 @@ private CountDSL(BasicColumn countColumn, SqlTable table, Function<SelectModel,
 
     @Override
     public CountWhereBuilder where() {
-        whereBuilder = Utilities.buildIfNecessary(whereBuilder, CountWhereBuilder::new);
+        whereBuilder = Objects.requireNonNullElseGet(whereBuilder, CountWhereBuilder::new);
         return whereBuilder;
     }
 
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/MultiSelectDSL.java b/src/main/java/org/mybatis/dynamic/sql/select/MultiSelectDSL.java
@@ -61,29 +61,29 @@ public MultiSelectDSL orderBy(Collection<? extends SortSpecification> columns) {
         return this;
     }
 
-    public LimitFinisher limit(long limit) {
+    public MultiSelectDSL.LimitFinisher limit(long limit) {
         return limitWhenPresent(limit);
     }
 
-    public LimitFinisher limitWhenPresent(@Nullable Long limit) {
+    public MultiSelectDSL.LimitFinisher limitWhenPresent(@Nullable Long limit) {
         this.limit = limit;
         return new LimitFinisher();
     }
 
-    public OffsetFirstFinisher offset(long offset) {
+    public MultiSelectDSL.OffsetFirstFinisher offset(long offset) {
         return offsetWhenPresent(offset);
     }
 
-    public OffsetFirstFinisher offsetWhenPresent(@Nullable Long offset) {
+    public MultiSelectDSL.OffsetFirstFinisher offsetWhenPresent(@Nullable Long offset) {
         this.offset = offset;
         return new OffsetFirstFinisher();
     }
 
-    public FetchFirstFinisher fetchFirst(long fetchFirstRows) {
+    public MultiSelectDSL.FetchFirstFinisher fetchFirst(long fetchFirstRows) {
         return fetchFirstWhenPresent(fetchFirstRows);
     }
 
-    public FetchFirstFinisher fetchFirstWhenPresent(@Nullable Long fetchFirstRows) {
+    public MultiSelectDSL.FetchFirstFinisher fetchFirstWhenPresent(@Nullable Long fetchFirstRows) {
         this.fetchFirstRows = fetchFirstRows;
         return new FetchFirstFinisher();
     }
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/QueryExpressionDSL.java b/src/main/java/org/mybatis/dynamic/sql/select/QueryExpressionDSL.java
@@ -37,7 +37,6 @@
 import org.mybatis.dynamic.sql.select.join.JoinSpecification;
 import org.mybatis.dynamic.sql.select.join.JoinType;
 import org.mybatis.dynamic.sql.util.Buildable;
-import org.mybatis.dynamic.sql.util.Utilities;
 import org.mybatis.dynamic.sql.where.AbstractWhereFinisher;
 import org.mybatis.dynamic.sql.where.AbstractWhereStarter;
 import org.mybatis.dynamic.sql.where.EmbeddedWhereModel;
@@ -70,7 +69,7 @@ protected QueryExpressionDSL(FromGatherer<R> fromGatherer, SqlTable table, Strin
 
     @Override
     public QueryExpressionWhereBuilder where() {
-        whereBuilder = Utilities.buildIfNecessary(whereBuilder, QueryExpressionWhereBuilder::new);
+        whereBuilder = Objects.requireNonNullElseGet(whereBuilder, QueryExpressionWhereBuilder::new);
         return whereBuilder;
     }
 
@@ -86,7 +85,7 @@ public QueryExpressionDSL<R> configureStatement(Consumer<StatementConfiguration>
      * @return The having builder
      */
     protected QueryExpressionHavingBuilder having() {
-        havingBuilder = Utilities.buildIfNecessary(havingBuilder, QueryExpressionHavingBuilder::new);
+        havingBuilder = Objects.requireNonNullElseGet(havingBuilder, QueryExpressionHavingBuilder::new);
         return havingBuilder;
     }
 
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/SelectDSL.java b/src/main/java/org/mybatis/dynamic/sql/select/SelectDSL.java
@@ -110,29 +110,29 @@ void orderBy(Collection<? extends SortSpecification> columns) {
         orderByModel = OrderByModel.of(columns);
     }
 
-    public LimitFinisher limit(long limit) {
+    public SelectDSL<R>.LimitFinisher limit(long limit) {
         return limitWhenPresent(limit);
     }
 
-    public LimitFinisher limitWhenPresent(@Nullable Long limit) {
+    public SelectDSL<R>.LimitFinisher limitWhenPresent(@Nullable Long limit) {
         this.limit = limit;
         return new LimitFinisher();
     }
 
-    public OffsetFirstFinisher offset(long offset) {
+    public SelectDSL<R>.OffsetFirstFinisher offset(long offset) {
         return offsetWhenPresent(offset);
     }
 
-    public OffsetFirstFinisher offsetWhenPresent(@Nullable Long offset) {
+    public SelectDSL<R>.OffsetFirstFinisher offsetWhenPresent(@Nullable Long offset) {
         this.offset = offset;
         return new OffsetFirstFinisher();
     }
 
-    public FetchFirstFinisher fetchFirst(long fetchFirstRows) {
+    public SelectDSL<R>.FetchFirstFinisher fetchFirst(long fetchFirstRows) {
         return fetchFirstWhenPresent(fetchFirstRows);
     }
 
-    public FetchFirstFinisher fetchFirstWhenPresent(@Nullable Long fetchFirstRows) {
+    public SelectDSL<R>.FetchFirstFinisher fetchFirstWhenPresent(@Nullable Long fetchFirstRows) {
         this.fetchFirstRows = fetchFirstRows;
         return new FetchFirstFinisher();
     }
diff --git a/src/main/java/org/mybatis/dynamic/sql/update/UpdateDSL.java b/src/main/java/org/mybatis/dynamic/sql/update/UpdateDSL.java
@@ -39,7 +39,6 @@
 import org.mybatis.dynamic.sql.util.NullMapping;
 import org.mybatis.dynamic.sql.util.SelectMapping;
 import org.mybatis.dynamic.sql.util.StringConstantMapping;
-import org.mybatis.dynamic.sql.util.Utilities;
 import org.mybatis.dynamic.sql.util.ValueMapping;
 import org.mybatis.dynamic.sql.util.ValueOrNullMapping;
 import org.mybatis.dynamic.sql.util.ValueWhenPresentMapping;
@@ -71,7 +70,7 @@ public <T> SetClauseFinisher<T> set(SqlColumn<T> column) {
 
     @Override
     public UpdateWhereBuilder where() {
-        whereBuilder = Utilities.buildIfNecessary(whereBuilder, UpdateWhereBuilder::new);
+        whereBuilder = Objects.requireNonNullElseGet(whereBuilder, UpdateWhereBuilder::new);
         return whereBuilder;
     }
 
diff --git a/src/main/java/org/mybatis/dynamic/sql/update/render/UpdateRenderer.java b/src/main/java/org/mybatis/dynamic/sql/update/render/UpdateRenderer.java
@@ -15,7 +15,6 @@
  */
 package org.mybatis.dynamic.sql.update.render;
 
-import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.stream.Collectors;
@@ -77,23 +76,15 @@ private FragmentAndParameters calculateUpdateStatementStart() {
     }
 
     private FragmentAndParameters calculateSetPhrase() {
-        List<Optional<FragmentAndParameters>> fragmentsAndParameters = updateModel.columnMappings()
+        FragmentCollector fragmentCollector = updateModel.columnMappings()
                 .map(m -> m.accept(visitor))
-                .toList();
-
-        Validator.assertFalse(fragmentsAndParameters.stream().noneMatch(Optional::isPresent),
-                "ERROR.18"); //$NON-NLS-1$
-
-        FragmentCollector fragmentCollector = fragmentsAndParameters.stream()
                 .flatMap(Optional::stream)
                 .collect(FragmentCollector.collect());
 
-        return toSetPhrase(fragmentCollector);
-    }
+        Validator.assertFalse(fragmentCollector.isEmpty(), "ERROR.18"); //$NON-NLS-1$
 
-    private FragmentAndParameters toSetPhrase(FragmentCollector fragmentCollector) {
         return fragmentCollector.toFragmentAndParameters(
-                Collectors.joining(", ", "set ", "")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
+                        Collectors.joining(", ", "set ", "")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
     }
 
     private Optional<FragmentAndParameters> calculateWhereClause() {
diff --git a/src/main/java/org/mybatis/dynamic/sql/util/FragmentCollector.java b/src/main/java/org/mybatis/dynamic/sql/util/FragmentCollector.java
@@ -16,14 +16,16 @@
 package org.mybatis.dynamic.sql.util;
 
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 import java.util.Optional;
 import java.util.stream.Collector;
 
 public class FragmentCollector {
-    final List<FragmentAndParameters> fragments = new ArrayList<>();
+    final List<String> fragments = new ArrayList<>();
+    final Map<String, Object> parameters = new HashMap<>();
 
     public FragmentCollector() {
         super();
@@ -34,20 +36,22 @@ private FragmentCollector(FragmentAndParameters initialFragment) {
     }
 
     public void add(FragmentAndParameters fragmentAndParameters) {
-        fragments.add(fragmentAndParameters);
+        fragments.add(fragmentAndParameters.fragment());
+        parameters.putAll(fragmentAndParameters.parameters());
     }
 
     public FragmentCollector merge(FragmentCollector other) {
         fragments.addAll(other.fragments);
+        parameters.putAll(other.parameters);
         return this;
     }
 
     public Optional<String> firstFragment() {
-        return fragments.stream().findFirst().map(FragmentAndParameters::fragment);
+        return fragments.stream().findFirst();
     }
 
     public String collectFragments(Collector<CharSequence, ?, String> fragmentCollector) {
-        return fragments.stream().map(FragmentAndParameters::fragment).collect(fragmentCollector);
+        return fragments.stream().collect(fragmentCollector);
     }
 
     public FragmentAndParameters toFragmentAndParameters(Collector<CharSequence, ?, String> fragmentCollector) {
@@ -57,9 +61,7 @@ public FragmentAndParameters toFragmentAndParameters(Collector<CharSequence, ?,
     }
 
     public Map<String, Object> parameters() {
-        return fragments.stream()
-                .map(FragmentAndParameters::parameters)
-                .collect(HashMap::new, HashMap::putAll, HashMap::putAll);
+        return Collections.unmodifiableMap(parameters);
     }
 
     public boolean hasMultipleFragments() {
diff --git a/src/main/java/org/mybatis/dynamic/sql/util/Utilities.java b/src/main/java/org/mybatis/dynamic/sql/util/Utilities.java
@@ -17,17 +17,12 @@
 
 import java.util.Collection;
 import java.util.Objects;
-import java.util.function.Supplier;
 import java.util.stream.Stream;
 
 import org.jspecify.annotations.NonNull;
 import org.jspecify.annotations.Nullable;
 
 public interface Utilities {
-    static <T> T buildIfNecessary(@Nullable T current, @NonNull Supplier<T> builder) {
-        return current == null ? builder.get() : current;
-    }
-
     static long safelyUnbox(@Nullable Long l) {
         return l == null ? 0 : l;
     }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/render/ColumnAndConditionRenderer.java b/src/main/java/org/mybatis/dynamic/sql/where/render/ColumnAndConditionRenderer.java
@@ -15,45 +15,43 @@
  */
 package org.mybatis.dynamic.sql.where.render;
 
-import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore;
-
 import java.util.Objects;
+import java.util.stream.Collectors;
 
 import org.jspecify.annotations.Nullable;
 import org.mybatis.dynamic.sql.BindableColumn;
 import org.mybatis.dynamic.sql.VisitableCondition;
 import org.mybatis.dynamic.sql.render.RenderingContext;
 import org.mybatis.dynamic.sql.util.FragmentAndParameters;
+import org.mybatis.dynamic.sql.util.FragmentCollector;
 
 public class ColumnAndConditionRenderer<T> {
     private final BindableColumn<T> column;
     private final VisitableCondition<T> condition;
     private final RenderingContext renderingContext;
+    private final DefaultConditionVisitor<T> visitor;
 
     private ColumnAndConditionRenderer(Builder<T> builder) {
         column = Objects.requireNonNull(builder.column);
         condition = Objects.requireNonNull(builder.condition);
         renderingContext = Objects.requireNonNull(builder.renderingContext);
-    }
-
-    public FragmentAndParameters render() {
-        FragmentAndParameters renderedLeftColumn = column.alias()
-                .map(FragmentAndParameters::fromFragment)
-                .orElseGet(() -> column.render(renderingContext));
-
-        DefaultConditionVisitor<T> visitor = DefaultConditionVisitor.withColumn(column)
+        visitor = DefaultConditionVisitor.withColumn(column)
                 .withRenderingContext(renderingContext)
                 .build();
+    }
 
-        FragmentAndParameters renderedCondition = condition.accept(visitor);
-
-        String finalFragment = condition.overrideRenderedLeftColumn(renderedLeftColumn.fragment())
-                + spaceBefore(renderedCondition.fragment());
+    public FragmentAndParameters render() {
+        FragmentCollector fc = new FragmentCollector();
+        fc.add(renderLeftColumn());
+        fc.add(condition.accept(visitor));
+        return fc.toFragmentAndParameters(Collectors.joining(" ")); //$NON-NLS-1$
+    }
 
-        return FragmentAndParameters.withFragment(finalFragment)
-                .withParameters(renderedLeftColumn.parameters())
-                .withParameters(renderedCondition.parameters())
-                .build();
+    private FragmentAndParameters renderLeftColumn() {
+        return column.alias()
+                .map(FragmentAndParameters::fromFragment)
+                .orElseGet(() -> column.render(renderingContext))
+                .mapFragment(condition::overrideRenderedLeftColumn);
     }
 
     public static class Builder<T> {
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/render/DefaultConditionVisitor.java b/src/main/java/org/mybatis/dynamic/sql/where/render/DefaultConditionVisitor.java
@@ -47,19 +47,10 @@ private DefaultConditionVisitor(Builder<T> builder) {
 
     @Override
     public FragmentAndParameters visit(AbstractListValueCondition<T> condition) {
-        FragmentCollector fc = condition.values()
-                .map(this::toFragmentAndParameters)
-                .collect(FragmentCollector.collect());
-
-        String joinedFragments =
-                fc.collectFragments(Collectors.joining(",", "(", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-        String finalFragment = condition.operator()
-                + spaceBefore(joinedFragments);
-
-        return FragmentAndParameters
-                .withFragment(finalFragment)
-                .withParameters(fc.parameters())
-                .build();
+        return condition.values().map(this::toFragmentAndParameters)
+                .collect(FragmentCollector.collect())
+                .toFragmentAndParameters(Collectors.joining(",", //$NON-NLS-1$
+                        condition.operator() + " (", ")")); //$NON-NLS-1$ //$NON-NLS-2$
     }
 
     @Override

Original file line number	Diff line number	Diff line change
`@@ -61,29 +61,29 @@ public MultiSelectDSL orderBy(Collection<? extends SortSpecification> columns) {`
`61`	`61`	`return this;`
`62`	`62`	`}`
`63`	`63`
`64`		`- public LimitFinisher limit(long limit) {`
	`64`	`+ public MultiSelectDSL.LimitFinisher limit(long limit) {`
`65`	`65`	`return limitWhenPresent(limit);`
`66`	`66`	`}`
`67`	`67`
`68`		`- public LimitFinisher limitWhenPresent(@Nullable Long limit) {`
	`68`	`+ public MultiSelectDSL.LimitFinisher limitWhenPresent(@Nullable Long limit) {`
`69`	`69`	`this.limit = limit;`
`70`	`70`	`return new LimitFinisher();`
`71`	`71`	`}`
`72`	`72`
`73`		`- public OffsetFirstFinisher offset(long offset) {`
	`73`	`+ public MultiSelectDSL.OffsetFirstFinisher offset(long offset) {`
`74`	`74`	`return offsetWhenPresent(offset);`
`75`	`75`	`}`
`76`	`76`
`77`		`- public OffsetFirstFinisher offsetWhenPresent(@Nullable Long offset) {`
	`77`	`+ public MultiSelectDSL.OffsetFirstFinisher offsetWhenPresent(@Nullable Long offset) {`
`78`	`78`	`this.offset = offset;`
`79`	`79`	`return new OffsetFirstFinisher();`
`80`	`80`	`}`
`81`	`81`
`82`		`- public FetchFirstFinisher fetchFirst(long fetchFirstRows) {`
	`82`	`+ public MultiSelectDSL.FetchFirstFinisher fetchFirst(long fetchFirstRows) {`
`83`	`83`	`return fetchFirstWhenPresent(fetchFirstRows);`
`84`	`84`	`}`
`85`	`85`
`86`		`- public FetchFirstFinisher fetchFirstWhenPresent(@Nullable Long fetchFirstRows) {`
	`86`	`+ public MultiSelectDSL.FetchFirstFinisher fetchFirstWhenPresent(@Nullable Long fetchFirstRows) {`
`87`	`87`	`this.fetchFirstRows = fetchFirstRows;`
`88`	`88`	`return new FetchFirstFinisher();`
`89`	`89`	`}`
Original file line number	Diff line number	Diff line change
`@@ -110,29 +110,29 @@ void orderBy(Collection<? extends SortSpecification> columns) {`
`110`	`110`	`orderByModel = OrderByModel.of(columns);`
`111`	`111`	`}`
`112`	`112`
`113`		`- public LimitFinisher limit(long limit) {`
	`113`	`+ public SelectDSL<R>.LimitFinisher limit(long limit) {`
`114`	`114`	`return limitWhenPresent(limit);`
`115`	`115`	`}`
`116`	`116`
`117`		`- public LimitFinisher limitWhenPresent(@Nullable Long limit) {`
	`117`	`+ public SelectDSL<R>.LimitFinisher limitWhenPresent(@Nullable Long limit) {`
`118`	`118`	`this.limit = limit;`
`119`	`119`	`return new LimitFinisher();`
`120`	`120`	`}`
`121`	`121`
`122`		`- public OffsetFirstFinisher offset(long offset) {`
	`122`	`+ public SelectDSL<R>.OffsetFirstFinisher offset(long offset) {`
`123`	`123`	`return offsetWhenPresent(offset);`
`124`	`124`	`}`
`125`	`125`
`126`		`- public OffsetFirstFinisher offsetWhenPresent(@Nullable Long offset) {`
	`126`	`+ public SelectDSL<R>.OffsetFirstFinisher offsetWhenPresent(@Nullable Long offset) {`
`127`	`127`	`this.offset = offset;`
`128`	`128`	`return new OffsetFirstFinisher();`
`129`	`129`	`}`
`130`	`130`
`131`		`- public FetchFirstFinisher fetchFirst(long fetchFirstRows) {`
	`131`	`+ public SelectDSL<R>.FetchFirstFinisher fetchFirst(long fetchFirstRows) {`
`132`	`132`	`return fetchFirstWhenPresent(fetchFirstRows);`
`133`	`133`	`}`
`134`	`134`
`135`		`- public FetchFirstFinisher fetchFirstWhenPresent(@Nullable Long fetchFirstRows) {`
	`135`	`+ public SelectDSL<R>.FetchFirstFinisher fetchFirstWhenPresent(@Nullable Long fetchFirstRows) {`
`136`	`136`	`this.fetchFirstRows = fetchFirstRows;`
`137`	`137`	`return new FetchFirstFinisher();`
`138`	`138`	`}`