ConditionVisitor should render only the condition

Previously the visitor rendered both the column and the condition, but this won't work for simple case statements. We need to be able to render only the condition for simple case statements.

Author: jeffgbutler

src/main/java/org/mybatis/dynamic/sql/select/aggregate/Sum.java

@@ -23,7 +23,7 @@
 import org.mybatis.dynamic.sql.select.function.AbstractUniTypeFunction;
 import org.mybatis.dynamic.sql.util.FragmentAndParameters;
 import org.mybatis.dynamic.sql.util.Validator;
-import org.mybatis.dynamic.sql.where.render.DefaultConditionVisitor;
+import org.mybatis.dynamic.sql.where.render.ColumnAndConditionRenderer;
 
 public class Sum<T> extends AbstractUniTypeFunction<T, Sum<T>> {
     private final Function<RenderingContext, FragmentAndParameters> renderer;
@@ -38,12 +38,13 @@ private Sum(BindableColumn<T> column, VisitableCondition<T> condition) {
         renderer = rc -> {
             Validator.assertTrue(condition.shouldRender(rc), "ERROR.37", "sum"); //$NON-NLS-1$ //$NON-NLS-2$
 
-            DefaultConditionVisitor<T> visitor = new DefaultConditionVisitor.Builder<T>()
+            return new ColumnAndConditionRenderer.Builder<T>()
                     .withColumn(column)
+                    .withCondition(condition)
                     .withRenderingContext(rc)
-                    .build();
-
-            return condition.accept(visitor).mapFragment(this::applyAggregate);
+                    .build()
+                    .render()
+                    .mapFragment(this::applyAggregate);
         };
     }
 

src/main/java/org/mybatis/dynamic/sql/where/render/ColumnAndConditionRenderer.java

@@ -0,0 +1,80 @@
+/*
+ *    Copyright 2016-2024 the original author or authors.
+ *
+ *    Licensed under the Apache License, Version 2.0 (the "License");
+ *    you may not use this file except in compliance with the License.
+ *    You may obtain a copy of the License at
+ *
+ *       https://www.apache.org/licenses/LICENSE-2.0
+ *
+ *    Unless required by applicable law or agreed to in writing, software
+ *    distributed under the License 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 org.mybatis.dynamic.sql.where.render;
+
+import static org.mybatis.dynamic.sql.util.StringUtilities.spaceBefore;
+
+import java.util.Objects;
+
+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;
+
+public class ColumnAndConditionRenderer<T> {
+    private final BindableColumn<T> column;
+    private final VisitableCondition<T> condition;
+    private final RenderingContext renderingContext;
+
+    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.render(renderingContext);
+
+        DefaultConditionVisitor<T> visitor = DefaultConditionVisitor.withColumn(column)
+                .withRenderingContext(renderingContext)
+                .build();
+
+        FragmentAndParameters renderedCondition = condition.accept(visitor);
+
+        String finalFragment = condition.overrideRenderedLeftColumn(renderedLeftColumn.fragment())
+                + spaceBefore(renderedCondition.fragment());
+
+        return FragmentAndParameters.withFragment(finalFragment)
+                .withParameters(renderedLeftColumn.parameters())
+                .withParameters(renderedCondition.parameters())
+                .build();
+    }
+
+    public static class Builder<T> {
+        private BindableColumn<T> column;
+        private VisitableCondition<T> condition;
+        private RenderingContext renderingContext;
+
+        public Builder<T> withColumn(BindableColumn<T> column) {
+            this.column = column;
+            return this;
+        }
+
+        public Builder<T> withCondition(VisitableCondition<T> condition) {
+            this.condition = condition;
+            return this;
+        }
+
+        public Builder<T> withRenderingContext(RenderingContext renderingContext) {
+            this.renderingContext = renderingContext;
+            return this;
+        }
+
+        public ColumnAndConditionRenderer<T> build() {
+            return new ColumnAndConditionRenderer<>(this);
+        }
+    }
+}

src/main/java/org/mybatis/dynamic/sql/where/render/CriterionRenderer.java

@@ -175,10 +175,12 @@ private Optional<RenderedCriterion> calculateRenderedCriterion(List<RenderedCrit
     }
 
     private <T> FragmentAndParameters renderCondition(ColumnAndConditionCriterion<T> criterion) {
-        DefaultConditionVisitor<T> visitor = DefaultConditionVisitor.withColumn(criterion.column())
+        return new ColumnAndConditionRenderer.Builder<T>()
+                .withColumn(criterion.column())
+                .withCondition(criterion.condition())
                 .withRenderingContext(renderingContext)
-                .build();
-        return criterion.condition().accept(visitor);
+                .build()
+                .render();
     }
 
     /**

src/main/java/org/mybatis/dynamic/sql/where/render/DefaultConditionVisitor.java

@@ -47,94 +47,74 @@ private DefaultConditionVisitor(Builder<T> builder) {
 
     @Override
     public FragmentAndParameters visit(AbstractListValueCondition<T> condition) {
-        FragmentAndParameters renderedLeftColumn = column.render(renderingContext);
         FragmentCollector fc = condition.mapValues(this::toFragmentAndParameters).collect(FragmentCollector.collect());
 
         String joinedFragments =
                 fc.collectFragments(Collectors.joining(",", "(", ")")); //$NON-NLS-1$ //$NON-NLS-2$ //$NON-NLS-3$
-        String finalFragment = condition.overrideRenderedLeftColumn(renderedLeftColumn.fragment())
-                + spaceBefore(condition.operator())
+        String finalFragment = condition.operator()
                 + spaceBefore(joinedFragments);
 
         return FragmentAndParameters
                 .withFragment(finalFragment)
                 .withParameters(fc.parameters())
-                .withParameters(renderedLeftColumn.parameters())
                 .build();
     }
 
     @Override
     public FragmentAndParameters visit(AbstractNoValueCondition<T> condition) {
-        FragmentAndParameters renderedLeftColumn = column.render(renderingContext);
-        String finalFragment = condition.overrideRenderedLeftColumn(renderedLeftColumn.fragment())
-                + spaceBefore(condition.operator());
-        return FragmentAndParameters.withFragment(finalFragment)
-                .withParameters(renderedLeftColumn.parameters())
-                .build();
+        return FragmentAndParameters.fromFragment(condition.operator());
     }
 
     @Override
     public FragmentAndParameters visit(AbstractSingleValueCondition<T> condition) {
-        FragmentAndParameters renderedLeftColumn = column.render(renderingContext);
         RenderedParameterInfo parameterInfo = renderingContext.calculateParameterInfo(column);
-        String finalFragment = condition.overrideRenderedLeftColumn(renderedLeftColumn.fragment())
-                + spaceBefore(condition.operator())
+        String finalFragment = condition.operator()
                 + spaceBefore(parameterInfo.renderedPlaceHolder());
 
         return FragmentAndParameters.withFragment(finalFragment)
                 .withParameter(parameterInfo.parameterMapKey(), convertValue(condition.value()))
-                .withParameters(renderedLeftColumn.parameters())
                 .build();
     }
 
     @Override
     public FragmentAndParameters visit(AbstractTwoValueCondition<T> condition) {
-        FragmentAndParameters renderedLeftColumn = column.render(renderingContext);
         RenderedParameterInfo parameterInfo1 = renderingContext.calculateParameterInfo(column);
         RenderedParameterInfo parameterInfo2 = renderingContext.calculateParameterInfo(column);
 
-        String finalFragment = condition.overrideRenderedLeftColumn(renderedLeftColumn.fragment())
-                + spaceBefore(condition.operator1())
+        String finalFragment = condition.operator1()
                 + spaceBefore(parameterInfo1.renderedPlaceHolder())
                 + spaceBefore(condition.operator2())
                 + spaceBefore(parameterInfo2.renderedPlaceHolder());
 
         return FragmentAndParameters.withFragment(finalFragment)
                 .withParameter(parameterInfo1.parameterMapKey(), convertValue(condition.value1()))
                 .withParameter(parameterInfo2.parameterMapKey(), convertValue(condition.value2()))
-                .withParameters(renderedLeftColumn.parameters())
                 .build();
     }
 
     @Override
     public FragmentAndParameters visit(AbstractSubselectCondition<T> condition) {
-        FragmentAndParameters renderedLeftColumn = column.render(renderingContext);
         SelectStatementProvider selectStatement = SelectRenderer.withSelectModel(condition.selectModel())
                 .withRenderingContext(renderingContext)
                 .build()
                 .render();
 
-        String finalFragment = condition.overrideRenderedLeftColumn(renderedLeftColumn.fragment())
-                + spaceBefore(condition.operator())
+        String finalFragment = condition.operator()
                 + " (" //$NON-NLS-1$
                 + selectStatement.getSelectStatement()
                 + ")"; //$NON-NLS-1$
 
         return FragmentAndParameters.withFragment(finalFragment)
                 .withParameters(selectStatement.getParameters())
-                .withParameters(renderedLeftColumn.parameters())
                 .build();
     }
 
     @Override
     public FragmentAndParameters visit(AbstractColumnComparisonCondition<T> condition) {
-        FragmentAndParameters renderedLeftColumn = column.render(renderingContext);
         FragmentAndParameters renderedRightColumn = condition.rightColumn().render(renderingContext);
-        String finalFragment = condition.overrideRenderedLeftColumn(renderedLeftColumn.fragment())
-                + spaceBefore(condition.operator())
+        String finalFragment = condition.operator()
                 + spaceBefore(renderedRightColumn.fragment());
         return FragmentAndParameters.withFragment(finalFragment)
-                .withParameters(renderedLeftColumn.parameters())
                 .withParameters(renderedRightColumn.parameters())
                 .build();
     }