Rename *Support classes to *Provider

Author: jeffgbutler

README.md

@@ -58,7 +58,7 @@ One capability is that very expressive dynamic queries can be generated.  Here's
         try {
             AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
 
-            SelectSupport selectSupport = select(id, animalName, bodyWeight, brainWeight)
+            SelectProvider selectProvider = select(id, animalName, bodyWeight, brainWeight)
                     .from(animalData)
                     .where(id, isIn(1, 5, 7))
                     .or(id, isIn(2, 6, 8), and(animalName, isLike("%bat")))
@@ -68,7 +68,7 @@ One capability is that very expressive dynamic queries can be generated.  Here's
                     .build()
                     .render(RenderingStrategy.MYBATIS3);
 
-            List<AnimalData> animals = mapper.selectMany(selectSupport);
+            List<AnimalData> animals = mapper.selectMany(selectProvider);
             assertThat(animals.size()).isEqualTo(4);
         } finally {
             sqlSession.close();
@@ -158,8 +158,8 @@ import org.apache.ibatis.annotations.Delete;
 import org.apache.ibatis.annotations.Result;
 import org.apache.ibatis.annotations.Results;
 import org.apache.ibatis.annotations.Select;
-import org.mybatis.dynamic.sql.delete.render.DeleteSupport;
-import org.mybatis.dynamic.sql.select.render.SelectSupport;
+import org.mybatis.dynamic.sql.delete.render.DeleteProvider;
+import org.mybatis.dynamic.sql.select.render.SelectProvider;
 
 public class SimpleTableAnnotatedMapper {
 
@@ -174,12 +174,12 @@ public class SimpleTableAnnotatedMapper {
             @Result(column="employed", property="employed", jdbcType=JdbcType.VARCHAR, typeHandler=YesNoTypeHandler.class),
             @Result(column="occupation", property="occupation", jdbcType=JdbcType.VARCHAR)
     })
-    List<SimpleTableRecord> selectMany(SelectSupport selectSupport);
+    List<SimpleTableRecord> selectMany(SelectProvider selectProvider);
 
     @Delete({
         "${fullDeleteStatement}"
     })
-    int delete(DeleteSupport deleteSupport);
+    int delete(DeleteProvider deleteProvider);
 }
 ```
 An XML mapper might look like this:
@@ -216,7 +216,7 @@ All conditions can be accessed through expressive static methods in the ```org.m
 For example, a very simple select statement can be defined like this:
 
 ```java
-        SelectSupport selectSupport = select(count())
+        SelectProvider selectProvider = select(count())
                 .from(simpleTable)
                 .where(id, isEqualTo(3))
                 .build()
@@ -226,7 +226,7 @@ For example, a very simple select statement can be defined like this:
 Or this (also note that you can give a table an alias):
 
 ```java
-        SelectSupport selectSupport = select(count())
+        SelectProvider selectProvider = select(count())
                 .from(simpleTable, "a")
                 .where(id, isNull())
                 .build()
@@ -235,7 +235,7 @@ Or this (also note that you can give a table an alias):
 A delete statement looks like this:
 
 ```java
-        DeleteSupport deleteSupport = deleteFrom(simpleTable)
+        DeleteProvider deleteProvider = deleteFrom(simpleTable)
                 .where(occupation, isNull())
                 .build()
                 .render(RenderingStrategy.MYBATIS3);
@@ -244,7 +244,7 @@ A delete statement looks like this:
 The "between" condition is also expressive:
 
 ```java
-        SelectSupport selectSupport = select(count())
+        SelectProvider selectProvider = select(count())
                 .from(simpleTable)
                 .where(id, isBetween(1).and(4))
                 .build()
@@ -254,7 +254,7 @@ The "between" condition is also expressive:
 More complex expressions can be built using the "and" and "or" conditions as follows:
 
 ```java
-        SelectSupport selectSupport = select(count())
+        SelectProvider selectProvider = select(count())
                 .from(simpleTable)
                 .where(id, isGreaterThan(2))
                 .or(occupation, isNull(), and(id, isLessThan(6)))
@@ -283,14 +283,14 @@ an example from ```examples.simple.SimpleTableXmlMapperTest```:
         try {
             SimpleTableXmlMapper mapper = session.getMapper(SimpleTableXmlMapper.class);
 
-            SelectSupport selectSupport = select(id.as("A_ID"), firstName, lastName, birthDate, employed, occupation)
+            SelectProvider selectProvider = select(id.as("A_ID"), firstName, lastName, birthDate, employed, occupation)
                     .from(simpleTable)
                     .where(id, isEqualTo(1))
                     .or(occupation, isNull())
                     .build()
                     .render(RenderingStrategy.MYBATIS3);
 
-            List<SimpleTableRecord> rows = mapper.selectMany(selectSupport);
+            List<SimpleTableRecord> rows = mapper.selectMany(selectProvider);
 
             assertThat(rows.size()).isEqualTo(3);
         } finally {

src/main/java/org/mybatis/dynamic/sql/AbstractSqlSupport.java src/main/java/org/mybatis/dynamic/sql/AbstractSqlProvider.java

@@ -17,10 +17,10 @@
 
 import java.util.Objects;
 
-public abstract class AbstractSqlSupport {
+public abstract class AbstractSqlProvider {
     private String tableName;
 
-    public AbstractSqlSupport(String tableName) {
+    public AbstractSqlProvider(String tableName) {
         this.tableName = Objects.requireNonNull(tableName);
     }
 

src/main/java/org/mybatis/dynamic/sql/delete/DeleteDSL.java

@@ -29,13 +29,13 @@ private DeleteDSL(SqlTable table) {
         this.table = table;
     }
 
-    public <T> DeleteSupportWhereBuilder where(SqlColumn<T> column, VisitableCondition<T> condition) {
-        return new DeleteSupportWhereBuilder(column, condition);
+    public <T> DeleteWhereBuilder where(SqlColumn<T> column, VisitableCondition<T> condition) {
+        return new DeleteWhereBuilder(column, condition);
     }
 
-    public <T> DeleteSupportWhereBuilder where(SqlColumn<T> column, VisitableCondition<T> condition,
+    public <T> DeleteWhereBuilder where(SqlColumn<T> column, VisitableCondition<T> condition,
             SqlCriterion<?>...subCriteria) {
-        return new DeleteSupportWhereBuilder(column, condition, subCriteria);
+        return new DeleteWhereBuilder(column, condition, subCriteria);
     }
 
     /**
@@ -54,13 +54,13 @@ public static DeleteDSL deleteFrom(SqlTable table) {
         return new DeleteDSL(table);
     }
 
-    public class DeleteSupportWhereBuilder extends AbstractWhereDSL<DeleteSupportWhereBuilder> {
+    public class DeleteWhereBuilder extends AbstractWhereDSL<DeleteWhereBuilder> {
 
-        private <T> DeleteSupportWhereBuilder(SqlColumn<T> column, VisitableCondition<T> condition) {
+        private <T> DeleteWhereBuilder(SqlColumn<T> column, VisitableCondition<T> condition) {
             super(column, condition);
         }
 
-        private <T> DeleteSupportWhereBuilder(SqlColumn<T> column, VisitableCondition<T> condition,
+        private <T> DeleteWhereBuilder(SqlColumn<T> column, VisitableCondition<T> condition,
                 SqlCriterion<?>...subCriteria) {
             super(column, condition, subCriteria);
         }
@@ -73,7 +73,7 @@ public DeleteModel build() {
         }
 
         @Override
-        protected DeleteSupportWhereBuilder getThis() {
+        protected DeleteWhereBuilder getThis() {
             return this;
         }
     }

src/main/java/org/mybatis/dynamic/sql/delete/DeleteModel.java

@@ -19,8 +19,8 @@
 import java.util.Optional;
 
 import org.mybatis.dynamic.sql.SqlTable;
+import org.mybatis.dynamic.sql.delete.render.DeleteProvider;
 import org.mybatis.dynamic.sql.delete.render.DeleteRenderer;
-import org.mybatis.dynamic.sql.delete.render.DeleteSupport;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 import org.mybatis.dynamic.sql.where.WhereModel;
 
@@ -41,7 +41,7 @@ public Optional<WhereModel> whereModel() {
         return whereModel;
     }
 
-    public DeleteSupport render(RenderingStrategy renderingStrategy) {
+    public DeleteProvider render(RenderingStrategy renderingStrategy) {
         return new DeleteRenderer.Builder()
                 .withDeleteModel(this)
                 .withRenderingStrategy(renderingStrategy)

src/main/java/org/mybatis/dynamic/sql/delete/render/DeleteSupport.java src/main/java/org/mybatis/dynamic/sql/delete/render/DeleteProvider.java

@@ -23,14 +23,14 @@
 import java.util.Objects;
 import java.util.Optional;
 
-import org.mybatis.dynamic.sql.AbstractSqlSupport;
-import org.mybatis.dynamic.sql.where.render.WhereSupport;
+import org.mybatis.dynamic.sql.AbstractSqlProvider;
+import org.mybatis.dynamic.sql.where.render.WhereProvider;
 
-public class DeleteSupport extends AbstractSqlSupport {
+public class DeleteProvider extends AbstractSqlProvider {
     private Optional<String> whereClause;
     private Map<String, Object> parameters;
 
-    private DeleteSupport(Builder builder) {
+    private DeleteProvider(Builder builder) {
         super(builder.tableName);
         whereClause = Objects.requireNonNull(builder.whereClause);
         parameters = Objects.requireNonNull(builder.parameters);
@@ -56,14 +56,14 @@ public Builder withTableName(String tableName) {
             return this;
         }
 
-        public Builder withWhereSupport(Optional<WhereSupport> whereSupport) {
-            whereClause = whereSupport.map(WhereSupport::getWhereClause);
-            parameters.putAll(whereSupport.map(WhereSupport::getParameters).orElse(Collections.emptyMap()));
+        public Builder withWhereProvider(Optional<WhereProvider> whereProvider) {
+            whereClause = whereProvider.map(WhereProvider::getWhereClause);
+            parameters.putAll(whereProvider.map(WhereProvider::getParameters).orElse(Collections.emptyMap()));
             return this;
         }
 
-        public DeleteSupport build() {
-            return new DeleteSupport(this);
+        public DeleteProvider build() {
+            return new DeleteProvider(this);
         }
     }
 }

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

@@ -22,8 +22,8 @@
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 import org.mybatis.dynamic.sql.render.TableAliasCalculator;
 import org.mybatis.dynamic.sql.where.WhereModel;
+import org.mybatis.dynamic.sql.where.render.WhereProvider;
 import org.mybatis.dynamic.sql.where.render.WhereRenderer;
-import org.mybatis.dynamic.sql.where.render.WhereSupport;
 
 public class DeleteRenderer {
     private DeleteModel deleteModel;
@@ -34,14 +34,14 @@ private DeleteRenderer(Builder builder) {
         renderingStrategy = Objects.requireNonNull(builder.renderingStrategy);
     }
 
-    public DeleteSupport render() {
-        return new DeleteSupport.Builder()
+    public DeleteProvider render() {
+        return new DeleteProvider.Builder()
                 .withTableName(deleteModel.table().name())
-                .withWhereSupport(deleteModel.whereModel().map(this::renderWhereModel))
+                .withWhereProvider(deleteModel.whereModel().map(this::renderWhereModel))
                 .build();
     }
 
-    private WhereSupport renderWhereModel(WhereModel whereModel) {
+    private WhereProvider renderWhereModel(WhereModel whereModel) {
         return new WhereRenderer.Builder()
                 .withWhereModel(whereModel)
                 .withRenderingStrategy(renderingStrategy)

src/main/java/org/mybatis/dynamic/sql/insert/InsertBatchModel.java

@@ -23,8 +23,8 @@
 import java.util.stream.Stream;
 
 import org.mybatis.dynamic.sql.SqlTable;
+import org.mybatis.dynamic.sql.insert.render.InsertBatchProvider;
 import org.mybatis.dynamic.sql.insert.render.InsertBatchRenderer;
-import org.mybatis.dynamic.sql.insert.render.InsertBatchSupport;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 import org.mybatis.dynamic.sql.util.InsertMapping;
 
@@ -51,7 +51,7 @@ public SqlTable table() {
         return table;
     }
 
-    public InsertBatchSupport<T> render(RenderingStrategy renderingStrategy) {
+    public InsertBatchProvider<T> render(RenderingStrategy renderingStrategy) {
         return new InsertBatchRenderer.Builder<T>()
                 .withInsertBatchModel(this)
                 .withRenderingStrategy(renderingStrategy)

src/main/java/org/mybatis/dynamic/sql/insert/InsertModel.java

@@ -22,8 +22,8 @@
 import java.util.stream.Stream;
 
 import org.mybatis.dynamic.sql.SqlTable;
+import org.mybatis.dynamic.sql.insert.render.InsertProvider;
 import org.mybatis.dynamic.sql.insert.render.InsertRenderer;
-import org.mybatis.dynamic.sql.insert.render.InsertSupport;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 import org.mybatis.dynamic.sql.util.InsertMapping;
 
@@ -50,7 +50,7 @@ public SqlTable table() {
         return table;
     }
 
-    public InsertSupport<T> render(RenderingStrategy renderingStrategy) {
+    public InsertProvider<T> render(RenderingStrategy renderingStrategy) {
         return new InsertRenderer.Builder<T>()
                 .withInsertModel(this)
                 .withRenderingStrategy(renderingStrategy)

src/main/java/org/mybatis/dynamic/sql/insert/InsertSelectModel.java

@@ -23,8 +23,8 @@
 
 import org.mybatis.dynamic.sql.SqlColumn;
 import org.mybatis.dynamic.sql.SqlTable;
+import org.mybatis.dynamic.sql.insert.render.InsertSelectProvider;
 import org.mybatis.dynamic.sql.insert.render.InsertSelectRenderer;
-import org.mybatis.dynamic.sql.insert.render.InsertSelectSupport;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 import org.mybatis.dynamic.sql.select.SelectModel;
 
@@ -51,7 +51,7 @@ public <R> Optional<Stream<R>> mapColumns(Function<SqlColumn<?>, R> mapper) {
         return columns.map(cl -> cl.stream().map(mapper));
     }
 
-    public InsertSelectSupport render(RenderingStrategy renderingStrategy) {
+    public InsertSelectProvider render(RenderingStrategy renderingStrategy) {
         return new InsertSelectRenderer.Builder()
                 .withInsertSelectModel(this)
                 .withRenderingStrategy(renderingStrategy)

src/main/java/org/mybatis/dynamic/sql/insert/render/InsertBatchSupport.java src/main/java/org/mybatis/dynamic/sql/insert/render/InsertBatchProvider.java

@@ -21,29 +21,29 @@
 import java.util.Objects;
 import java.util.stream.Collectors;
 
-import org.mybatis.dynamic.sql.AbstractSqlSupport;
+import org.mybatis.dynamic.sql.AbstractSqlProvider;
 
-public class InsertBatchSupport<T> extends AbstractSqlSupport {
+public class InsertBatchProvider<T> extends AbstractSqlProvider {
 
     private String columnsPhrase;
     private String valuesPhrase;
     private List<T> records;
 
-    private InsertBatchSupport(Builder<T> builder) {
+    private InsertBatchProvider(Builder<T> builder) {
         super(builder.tableName);
         this.columnsPhrase = Objects.requireNonNull(builder.columnsPhrase);
         this.valuesPhrase = Objects.requireNonNull(builder.valuesPhrase);
         this.records = Collections.unmodifiableList(Objects.requireNonNull(builder.records));
     }
 
-    public List<InsertSupport<T>> insertSupports() {
+    public List<InsertProvider<T>> insertProviders() {
         return records.stream()
-                .map(this::toInsertSupport)
+                .map(this::toInsertProvider)
                 .collect(Collectors.toList());
     }
 
-    private InsertSupport<T> toInsertSupport(T record) {
-        return new InsertSupport.Builder<T>()
+    private InsertProvider<T> toInsertProvider(T record) {
+        return new InsertProvider.Builder<T>()
                 .withTableName(super.tableName())
                 .withColumnsPhrase(columnsPhrase)
                 .withValuesPhrase(valuesPhrase)
@@ -77,8 +77,8 @@ public Builder<T> withRecords(List<T> records) {
             return this;
         }
 
-        public InsertBatchSupport<T> build() {
-            return new InsertBatchSupport<>(this);
+        public InsertBatchProvider<T> build() {
+            return new InsertBatchProvider<>(this);
         }
     }
 }

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

@@ -32,11 +32,11 @@ private InsertBatchRenderer(Builder<T> builder) {
         renderingStrategy = Objects.requireNonNull(builder.renderingStrategy);
     }
 
-    public InsertBatchSupport<T> render() {
+    public InsertBatchProvider<T> render() {
         ValuePhraseVisitor visitor = new ValuePhraseVisitor(renderingStrategy);
         FieldAndValueCollector<T> collector = model.mapColumnMappings(toFieldAndValue(visitor))
                 .collect(FieldAndValueCollector.collect());
-        return new InsertBatchSupport.Builder<T>()
+        return new InsertBatchProvider.Builder<T>()
                 .withTableName(model.table().name())
                 .withColumnsPhrase(collector.columnsPhrase())
                 .withValuesPhrase(collector.valuesPhrase())

src/main/java/org/mybatis/dynamic/sql/insert/render/InsertSupport.java src/main/java/org/mybatis/dynamic/sql/insert/render/InsertProvider.java

@@ -19,15 +19,15 @@
 
 import java.util.Objects;
 
-import org.mybatis.dynamic.sql.AbstractSqlSupport;
+import org.mybatis.dynamic.sql.AbstractSqlProvider;
 
-public class InsertSupport<T> extends AbstractSqlSupport {
+public class InsertProvider<T> extends AbstractSqlProvider {
 
     private String columnsPhrase;
     private String valuesPhrase;
     private T record;
 
-    private InsertSupport(Builder<T> builder) {
+    private InsertProvider(Builder<T> builder) {
         super(builder.tableName);
         this.columnsPhrase = Objects.requireNonNull(builder.columnsPhrase);
         this.valuesPhrase = Objects.requireNonNull(builder.valuesPhrase);
@@ -71,8 +71,8 @@ public Builder<T> withRecord(T record) {
             return this;
         }
 
-        public InsertSupport<T> build() {
-            return new InsertSupport<>(this);
+        public InsertProvider<T> build() {
+            return new InsertProvider<>(this);
         }
     }
 }