Improve rendering context

src/main/java/org/mybatis/dynamic/sql/BasicColumn.java

@@ -62,6 +62,7 @@ public interface BasicColumn {
     default FragmentAndParameters render(RenderingContext renderingContext) {
         // the default implementation ensures compatibility with prior releases. When the
         // deprecated renderWithTableAlias method is removed, this function can become purely abstract.
+        // Also remove the method tableAliasCalculator() from RenderingContext.
         return FragmentAndParameters.fromFragment(renderWithTableAlias(renderingContext.tableAliasCalculator()));
     }
 

src/main/java/org/mybatis/dynamic/sql/SqlColumn.java

@@ -18,12 +18,10 @@
 import java.sql.JDBCType;
 import java.util.Objects;
 import java.util.Optional;
-import java.util.function.BiFunction;
 
 import org.jetbrains.annotations.NotNull;
 import org.mybatis.dynamic.sql.render.RenderingContext;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
-import org.mybatis.dynamic.sql.render.TableAliasCalculator;
 import org.mybatis.dynamic.sql.util.FragmentAndParameters;
 import org.mybatis.dynamic.sql.util.StringUtilities;
 
@@ -37,7 +35,7 @@ public class SqlColumn<T> implements BindableColumn<T>, SortSpecification {
     protected final String typeHandler;
     protected final RenderingStrategy renderingStrategy;
     protected final ParameterTypeConverter<T, ?> parameterTypeConverter;
-    protected final BiFunction<TableAliasCalculator, SqlTable, Optional<String>> tableQualifierFunction;
+    protected final String tableQualifier;
     protected final Class<T> javaType;
 
     private SqlColumn(Builder<T> builder) {
@@ -49,7 +47,7 @@ private SqlColumn(Builder<T> builder) {
         typeHandler = builder.typeHandler;
         renderingStrategy = builder.renderingStrategy;
         parameterTypeConverter = builder.parameterTypeConverter;
-        tableQualifierFunction = Objects.requireNonNull(builder.tableQualifierFunction);
+        tableQualifier = builder.tableQualifier;
         javaType = builder.javaType;
     }
 
@@ -107,7 +105,7 @@ public SqlColumn<T> as(String alias) {
      */
     public SqlColumn<T> qualifiedWith(String tableQualifier) {
         Builder<T> b = copy();
-        b.withTableQualifierFunction((tac, t) -> Optional.of(tableQualifier));
+        b.withTableQualifier(tableQualifier);
         return b.build();
     }
 
@@ -117,7 +115,7 @@ public SqlColumn<T> qualifiedWith(String tableQualifier) {
      * a map based on the column name returned from the database.
      *
      * <p>A camel case string is mixed case, and most databases do not support unquoted mixed case strings
-     * as identifiers. Therefore the generated alias will be surrounded by double quotes thereby making it a
+     * as identifiers. Therefore, the generated alias will be surrounded by double quotes thereby making it a
      * quoted identifier. Most databases will respect quoted mixed case identifiers.
      *
      * @return a new column aliased with a camel case version of the column name
@@ -139,11 +137,11 @@ public String orderByName() {
 
     @Override
     public FragmentAndParameters render(RenderingContext renderingContext) {
-        String fragment = tableQualifierFunction.apply(renderingContext.tableAliasCalculator(), table)
-                .map(this::applyTableAlias)
-                .orElseGet(this::name);
-
-        return FragmentAndParameters.fromFragment(fragment);
+        if (tableQualifier == null) {
+            return FragmentAndParameters.fromFragment(renderingContext.aliasedColumnName(this));
+        } else {
+            return FragmentAndParameters.fromFragment(renderingContext.aliasedColumnName(this, tableQualifier));
+        }
     }
 
     @Override
@@ -195,14 +193,10 @@ private <S> Builder<S> copy() {
                 .withTypeHandler(this.typeHandler)
                 .withRenderingStrategy(this.renderingStrategy)
                 .withParameterTypeConverter((ParameterTypeConverter<S, ?>) this.parameterTypeConverter)
-                .withTableQualifierFunction(this.tableQualifierFunction)
+                .withTableQualifier(this.tableQualifier)
                 .withJavaType((Class<S>) this.javaType);
     }
 
-    private String applyTableAlias(String tableAlias) {
-        return tableAlias + "." + name(); //$NON-NLS-1$
-    }
-
     public static <T> SqlColumn<T> of(String name, SqlTable table) {
         return new Builder<T>().withName(name)
                 .withTable(table)
@@ -225,8 +219,7 @@ public static class Builder<T> {
         protected String typeHandler;
         protected RenderingStrategy renderingStrategy;
         protected ParameterTypeConverter<T, ?> parameterTypeConverter;
-        protected BiFunction<TableAliasCalculator, SqlTable, Optional<String>> tableQualifierFunction =
-                TableAliasCalculator::aliasForColumn;
+        protected String tableQualifier;
         protected Class<T> javaType;
 
         public Builder<T> withName(String name) {
@@ -269,9 +262,8 @@ public Builder<T> withParameterTypeConverter(ParameterTypeConverter<T, ?> parame
             return this;
         }
 
-        private Builder<T> withTableQualifierFunction(
-                BiFunction<TableAliasCalculator, SqlTable, Optional<String>> tableQualifierFunction) {
-            this.tableQualifierFunction = tableQualifierFunction;
+        private Builder<T> withTableQualifier(String tableQualifier) {
+            this.tableQualifier = tableQualifier;
             return this;
         }
 

src/main/java/org/mybatis/dynamic/sql/common/AbstractBooleanExpressionRenderer.java

@@ -36,11 +36,7 @@ public abstract class AbstractBooleanExpressionRenderer<M extends AbstractBoolea
     protected AbstractBooleanExpressionRenderer(String prefix, AbstractBuilder<M, ?> builder) {
         model = Objects.requireNonNull(builder.model);
         this.prefix = Objects.requireNonNull(prefix);
-
-        criterionRenderer = new CriterionRenderer.Builder()
-                .withRenderingContext(Objects.requireNonNull(builder.renderingContext))
-                .withParameterName(builder.parameterName)
-                .build();
+        criterionRenderer = new CriterionRenderer(builder.renderingContext);
     }
 
     public Optional<FragmentAndParameters> render() {
@@ -89,7 +85,6 @@ private String addPrefix(String fragment) {
 
     public abstract static class AbstractBuilder<M, B extends AbstractBuilder<M, B>> {
         private final M model;
-        private String parameterName;
         private RenderingContext renderingContext;
 
         protected AbstractBuilder(M model) {
@@ -101,11 +96,6 @@ public B withRenderingContext(RenderingContext renderingContext) {
             return getThis();
         }
 
-        public B withParameterName(String parameterName) {
-            this.parameterName = parameterName;
-            return getThis();
-        }
-
         protected abstract B getThis();
     }
 }

src/main/java/org/mybatis/dynamic/sql/delete/render/DeleteRenderer.java

@@ -17,10 +17,8 @@
 
 import java.util.Objects;
 import java.util.Optional;
-import java.util.concurrent.atomic.AtomicInteger;
 import java.util.stream.Collectors;
 
-import org.mybatis.dynamic.sql.SqlTable;
 import org.mybatis.dynamic.sql.common.OrderByModel;
 import org.mybatis.dynamic.sql.common.OrderByRenderer;
 import org.mybatis.dynamic.sql.delete.DeleteModel;
@@ -42,10 +40,9 @@ private DeleteRenderer(Builder builder) {
         TableAliasCalculator tableAliasCalculator = builder.deleteModel.tableAlias()
                 .map(a -> ExplicitTableAliasCalculator.of(deleteModel.table(), a))
                 .orElseGet(TableAliasCalculator::empty);
-        renderingContext = new RenderingContext.Builder()
+        renderingContext = RenderingContext
                 .withRenderingStrategy(Objects.requireNonNull(builder.renderingStrategy))
                 .withTableAliasCalculator(tableAliasCalculator)
-                .withSequence(new AtomicInteger(1))
                 .build();
     }
 
@@ -68,11 +65,7 @@ private DeleteStatementProvider toDeleteStatementProvider(FragmentCollector frag
     }
 
     private FragmentAndParameters calculateDeleteStatementStart() {
-        SqlTable table = deleteModel.table();
-        String tableName = table.tableNameAtRuntime();
-        String aliasedTableName = renderingContext.tableAliasCalculator().aliasForTable(table)
-                .map(a -> tableName + " " + a).orElse(tableName); //$NON-NLS-1$
-
+        String aliasedTableName = renderingContext.aliasedTableName(deleteModel.table());
         return FragmentAndParameters.fromFragment("delete from " + aliasedTableName); //$NON-NLS-1$
     }
 
@@ -92,12 +85,10 @@ private Optional<FragmentAndParameters> calculateLimitClause() {
     }
 
     private FragmentAndParameters renderLimitClause(Long limit) {
-        String mapKey = renderingContext.nextMapKey();
-        String jdbcPlaceholder = renderingContext
-                .renderingStrategy().getFormattedJdbcPlaceholder(RenderingStrategy.DEFAULT_PARAMETER_PREFIX, mapKey);
+        RenderingContext.ParameterInfo parameterInfo = renderingContext.calculateParameterInfo();
 
-        return FragmentAndParameters.withFragment("limit " + jdbcPlaceholder) //$NON-NLS-1$
-                .withParameter(mapKey, limit)
+        return FragmentAndParameters.withFragment("limit " + parameterInfo.renderedPlaceHolder()) //$NON-NLS-1$
+                .withParameter(parameterInfo.mapKey(), limit)
                 .build();
     }
 

src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertRenderer.java

@@ -20,6 +20,7 @@
 
 import org.mybatis.dynamic.sql.exception.InvalidSqlException;
 import org.mybatis.dynamic.sql.insert.GeneralInsertModel;
+import org.mybatis.dynamic.sql.render.RenderingContext;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 import org.mybatis.dynamic.sql.util.Messages;
 
@@ -34,7 +35,9 @@ private GeneralInsertRenderer(Builder builder) {
     }
 
     public GeneralInsertStatementProvider render() {
-        GeneralInsertValuePhraseVisitor visitor = new GeneralInsertValuePhraseVisitor(renderingStrategy);
+        RenderingContext renderingContext = RenderingContext.withRenderingStrategy(renderingStrategy).build();
+
+        GeneralInsertValuePhraseVisitor visitor = new GeneralInsertValuePhraseVisitor(renderingContext);
         FieldAndValueCollector collector = model.mapColumnMappings(m -> m.accept(visitor))
                 .filter(Optional::isPresent)
                 .map(Optional::get)

src/main/java/org/mybatis/dynamic/sql/insert/render/GeneralInsertValuePhraseVisitor.java

@@ -15,11 +15,10 @@
  */
 package org.mybatis.dynamic.sql.insert.render;
 
+import java.util.Objects;
 import java.util.Optional;
-import java.util.concurrent.atomic.AtomicInteger;
 
-import org.mybatis.dynamic.sql.SqlColumn;
-import org.mybatis.dynamic.sql.render.RenderingStrategy;
+import org.mybatis.dynamic.sql.render.RenderingContext;
 import org.mybatis.dynamic.sql.util.AbstractColumnMapping;
 import org.mybatis.dynamic.sql.util.ConstantMapping;
 import org.mybatis.dynamic.sql.util.GeneralInsertMappingVisitor;
@@ -31,11 +30,10 @@
 
 public class GeneralInsertValuePhraseVisitor extends GeneralInsertMappingVisitor<Optional<FieldAndValueAndParameters>> {
 
-    private final RenderingStrategy renderingStrategy;
-    private final AtomicInteger sequence = new AtomicInteger(1);
+    private final RenderingContext renderingContext;
 
-    public GeneralInsertValuePhraseVisitor(RenderingStrategy renderingStrategy) {
-        this.renderingStrategy = renderingStrategy;
+    public GeneralInsertValuePhraseVisitor(RenderingContext renderingContext) {
+        this.renderingContext = Objects.requireNonNull(renderingContext);
     }
 
     @Override
@@ -85,18 +83,11 @@ private Optional<FieldAndValueAndParameters> buildNullFragment(AbstractColumnMap
     }
 
     private Optional<FieldAndValueAndParameters> buildFragment(AbstractColumnMapping mapping, Object value) {
-        String mapKey = renderingStrategy.formatParameterMapKey(sequence);
-
-        String jdbcPlaceholder = mapping.mapColumn(c -> calculateJdbcPlaceholder(c, mapKey));
+        RenderingContext.ParameterInfo parameterInfo = mapping.mapColumn(renderingContext::calculateParameterInfo);
 
         return FieldAndValueAndParameters.withFieldName(mapping.columnName())
-                .withValuePhrase(jdbcPlaceholder)
-                .withParameter(mapKey, value)
+                .withValuePhrase(parameterInfo.renderedPlaceHolder())
+                .withParameter(parameterInfo.mapKey(), value)
                 .buildOptional();
     }
-
-    private String calculateJdbcPlaceholder(SqlColumn<?> column, String parameterName) {
-        return column.renderingStrategy().orElse(renderingStrategy)
-                .getFormattedJdbcPlaceholder(column, RenderingStrategy.DEFAULT_PARAMETER_PREFIX, parameterName);
-    }
 }