Rename the statement class - maybe finally have the right name?

Author: jeffgbutler

README.md

@@ -57,7 +57,7 @@ One capability is that very expressive dynamic queries can be generated.  Here's
         try {
             AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
 
-            SelectStatement selectStatement = select(id, animalName, bodyWeight, brainWeight)
+            SelectStatementProvider selectStatement = select(id, animalName, bodyWeight, brainWeight)
                     .from(animalData)
                     .where(id, isIn(1, 5, 7))
                     .or(id, isIn(2, 6, 8), and(animalName, isLike("%bat")))
@@ -159,8 +159,8 @@ import org.apache.ibatis.annotations.DeleteProvider;
 import org.apache.ibatis.annotations.Result;
 import org.apache.ibatis.annotations.Results;
 import org.apache.ibatis.annotations.SelectProvider;
-import org.mybatis.dynamic.sql.delete.render.DeleteStatement;
-import org.mybatis.dynamic.sql.select.render.SelectStatement;
+import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
+import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
 import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
 
 public class SimpleTableAnnotatedMapper {
@@ -174,10 +174,10 @@ 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(SelectStatement selectStatement);
+    List<SimpleTableRecord> selectMany(SelectStatementProvider selectStatement);
 
     @DeleteProvider(type=SqlProviderAdapter.class, method="delete")
-    int delete(DeleteStatement deleteStatement);
+    int delete(DeleteStatementProvider deleteStatement);
 }
 ```
 ### Third - Create dynamic statements
@@ -188,7 +188,7 @@ All SQL construction methods can be accessed through expressive static methods i
 For example, a very simple select statement can be defined like this:
 
 ```java
-        SelectStatement selectStatement = select(count())
+        SelectStatementProvider selectStatement = select(count())
                 .from(simpleTable)
                 .where(id, isEqualTo(3))
                 .build()
@@ -198,7 +198,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
-        SelectStatement selectStatement = select(count())
+        SelectStatementProvider selectStatement = select(count())
                 .from(simpleTable, "a")
                 .where(id, isNull())
                 .build()
@@ -207,7 +207,7 @@ Or this (also note that you can give a table an alias):
 A delete statement looks like this:
 
 ```java
-        DeleteStatement deleteStatement = deleteFrom(simpleTable)
+        DeleteStatementProvider deleteStatement = deleteFrom(simpleTable)
                 .where(occupation, isNull())
                 .build()
                 .render(RenderingStrategy.MYBATIS3);
@@ -216,7 +216,7 @@ A delete statement looks like this:
 The "between" condition is also expressive:
 
 ```java
-        SelectStatement selectStatement = select(count())
+        SelectStatementProvider selectStatement = select(count())
                 .from(simpleTable)
                 .where(id, isBetween(1).and(4))
                 .build()
@@ -226,7 +226,7 @@ The "between" condition is also expressive:
 More complex expressions can be built using the "and" and "or" conditions as follows:
 
 ```java
-        SelectStatement selectStatement = select(count())
+        SelectStatementProvider selectStatement = select(count())
                 .from(simpleTable)
                 .where(id, isGreaterThan(2))
                 .or(occupation, isNull(), and(id, isLessThan(6)))
@@ -255,7 +255,7 @@ an example from `examples.simple.SimpleTableAnnotatedMapperTest`:
         try {
             SimpleTableXmlMapper mapper = session.getMapper(SimpleTableXmlMapper.class);
 
-            SelectStatement selectStatement = select(id.as("A_ID"), firstName, lastName, birthDate, employed, occupation)
+            SelectStatementProvider selectStatement = select(id.as("A_ID"), firstName, lastName, birthDate, employed, occupation)
                     .from(simpleTable)
                     .where(id, isEqualTo(1))
                     .or(occupation, isNull())

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

@@ -22,7 +22,7 @@
 import org.mybatis.dynamic.sql.SqlCriterion;
 import org.mybatis.dynamic.sql.SqlTable;
 import org.mybatis.dynamic.sql.VisitableCondition;
-import org.mybatis.dynamic.sql.delete.render.DeleteStatement;
+import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
 import org.mybatis.dynamic.sql.where.AbstractWhereDSL;
 
 public class DeleteDSL<R> {
@@ -64,7 +64,7 @@ public static DeleteDSL<DeleteModel> deleteFrom(SqlTable table) {
     }
 
     public static <T> DeleteDSL<MyBatis3DeleteModelAdapter<T>> deleteFromWithMapper(
-            Function<DeleteStatement, T> mapperMethod, SqlTable table) {
+            Function<DeleteStatementProvider, T> mapperMethod, SqlTable table) {
         return deleteFrom(deleteModel -> MyBatis3DeleteModelAdapter.of(deleteModel, mapperMethod), table);
     }
 

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

@@ -20,7 +20,7 @@
 
 import org.mybatis.dynamic.sql.SqlTable;
 import org.mybatis.dynamic.sql.delete.render.DeleteRenderer;
-import org.mybatis.dynamic.sql.delete.render.DeleteStatement;
+import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
 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 DeleteStatement render(RenderingStrategy renderingStrategy) {
+    public DeleteStatementProvider render(RenderingStrategy renderingStrategy) {
         return DeleteRenderer.withDeleteModel(this)
                 .withRenderingStrategy(renderingStrategy)
                 .build()

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

@@ -18,7 +18,7 @@
 import java.util.Objects;
 import java.util.function.Function;
 
-import org.mybatis.dynamic.sql.delete.render.DeleteStatement;
+import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 
 /**
@@ -30,9 +30,9 @@
 public class MyBatis3DeleteModelAdapter<R> {
 
     private DeleteModel deleteModel;
-    private Function<DeleteStatement, R> mapperMethod;
+    private Function<DeleteStatementProvider, R> mapperMethod;
 
-    private MyBatis3DeleteModelAdapter(DeleteModel deleteModel, Function<DeleteStatement, R> mapperMethod) {
+    private MyBatis3DeleteModelAdapter(DeleteModel deleteModel, Function<DeleteStatementProvider, R> mapperMethod) {
         this.deleteModel = Objects.requireNonNull(deleteModel);
         this.mapperMethod = Objects.requireNonNull(mapperMethod);
     }
@@ -41,12 +41,12 @@ public R execute() {
         return mapperMethod.apply(deleteStatement());
     }
 
-    private DeleteStatement deleteStatement() {
+    private DeleteStatementProvider deleteStatement() {
         return deleteModel.render(RenderingStrategy.MYBATIS3);
     }
 
     public static <R> MyBatis3DeleteModelAdapter<R> of(DeleteModel deleteModel,
-            Function<DeleteStatement, R> mapperMethod) {
+            Function<DeleteStatementProvider, R> mapperMethod) {
         return new MyBatis3DeleteModelAdapter<>(deleteModel, mapperMethod);
     }
 }

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

@@ -20,7 +20,7 @@
 import org.mybatis.dynamic.sql.delete.DeleteModel;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 import org.mybatis.dynamic.sql.where.WhereModel;
-import org.mybatis.dynamic.sql.where.render.WhereClauseAndParameters;
+import org.mybatis.dynamic.sql.where.render.WhereClauseProvider;
 
 public class DeleteRenderer {
     private DeleteModel deleteModel;
@@ -31,13 +31,13 @@ private DeleteRenderer(Builder builder) {
         renderingStrategy = Objects.requireNonNull(builder.renderingStrategy);
     }
 
-    public DeleteStatement render() {
-        return DeleteStatement.withTableName(deleteModel.table().name())
-                .withWhereClause(deleteModel.whereModel().map(this::renderWhereModel))
+    public DeleteStatementProvider render() {
+        return DeleteStatementProvider.withTableName(deleteModel.table().name())
+                .withWhereClause(deleteModel.whereModel().map(this::renderWhereClause))
                 .build();
     }
 
-    private WhereClauseAndParameters renderWhereModel(WhereModel whereModel) {
+    private WhereClauseProvider renderWhereClause(WhereModel whereModel) {
         return whereModel.render(renderingStrategy);
     }
 

src/main/java/org/mybatis/dynamic/sql/delete/render/DeleteStatement.java renamed to src/main/java/org/mybatis/dynamic/sql/delete/render/DeleteStatementProvider.java

@@ -22,26 +22,26 @@
 import java.util.Objects;
 import java.util.Optional;
 
-import org.mybatis.dynamic.sql.where.render.WhereClauseAndParameters;
+import org.mybatis.dynamic.sql.where.render.WhereClauseProvider;
 
-public class DeleteStatement {
+public class DeleteStatementProvider {
     private String tableName;
-    private Optional<WhereClauseAndParameters> whereClauseAndParameters;
+    private Optional<WhereClauseProvider> whereClauseProvider;
 
-    private DeleteStatement(Builder builder) {
+    private DeleteStatementProvider(Builder builder) {
         tableName = Objects.requireNonNull(builder.tableName);
-        whereClauseAndParameters = Objects.requireNonNull(builder.whereClauseAndParameters);
+        whereClauseProvider = Objects.requireNonNull(builder.whereClauseProvider);
     }
 
     public Map<String, Object> getParameters() {
-        return whereClauseAndParameters.map(WhereClauseAndParameters::parameters)
+        return whereClauseProvider.map(WhereClauseProvider::getParameters)
                 .orElse(Collections.emptyMap());
     }
 
     public String getDeleteStatement() {
         return "delete from" //$NON-NLS-1$
                 + spaceBefore(tableName)
-                + spaceBefore(whereClauseAndParameters.map(WhereClauseAndParameters::whereClause));
+                + spaceBefore(whereClauseProvider.map(WhereClauseProvider::getWhereClause));
     }
 
     public static Builder withTableName(String tableName) {
@@ -50,20 +50,20 @@ public static Builder withTableName(String tableName) {
 
     public static class Builder {
         private String tableName;
-        private Optional<WhereClauseAndParameters> whereClauseAndParameters = Optional.empty();
+        private Optional<WhereClauseProvider> whereClauseProvider = Optional.empty();
 
         public Builder withTableName(String tableName) {
             this.tableName = tableName;
             return this;
         }
 
-        public Builder withWhereClause(Optional<WhereClauseAndParameters> whereClauseAndParameters) {
-            this.whereClauseAndParameters = whereClauseAndParameters;
+        public Builder withWhereClause(Optional<WhereClauseProvider> whereClauseProvider) {
+            this.whereClauseProvider = whereClauseProvider;
             return this;
         }
 
-        public DeleteStatement build() {
-            return new DeleteStatement(this);
+        public DeleteStatementProvider build() {
+            return new DeleteStatementProvider(this);
         }
     }
 }

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

@@ -23,7 +23,7 @@
 
 import org.mybatis.dynamic.sql.SqlTable;
 import org.mybatis.dynamic.sql.insert.render.InsertRenderer;
-import org.mybatis.dynamic.sql.insert.render.InsertStatement;
+import org.mybatis.dynamic.sql.insert.render.InsertStatementProvider;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 import org.mybatis.dynamic.sql.util.InsertMapping;
 
@@ -50,7 +50,7 @@ public SqlTable table() {
         return table;
     }
 
-    public InsertStatement<T> render(RenderingStrategy renderingStrategy) {
+    public InsertStatementProvider<T> render(RenderingStrategy renderingStrategy) {
         return InsertRenderer.withInsertModel(this)
                 .withRenderingStrategy(renderingStrategy)
                 .build()

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

@@ -20,7 +20,7 @@
 
 import org.mybatis.dynamic.sql.SqlTable;
 import org.mybatis.dynamic.sql.insert.render.InsertSelectRenderer;
-import org.mybatis.dynamic.sql.insert.render.InsertSelectStatement;
+import org.mybatis.dynamic.sql.insert.render.InsertSelectStatementProvider;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
 import org.mybatis.dynamic.sql.select.SelectModel;
 
@@ -47,7 +47,7 @@ public Optional<InsertColumnListModel> columnList() {
         return columnList;
     }
 
-    public InsertSelectStatement render(RenderingStrategy renderingStrategy) {
+    public InsertSelectStatementProvider render(RenderingStrategy renderingStrategy) {
         return InsertSelectRenderer.withInsertSelectModel(this)
                 .withRenderingStrategy(renderingStrategy)
                 .build()

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

@@ -41,14 +41,14 @@ private BatchInsert(Builder<T> builder) {
      * 
      * @return a List of InsertStatements
      */
-    public List<InsertStatement<T>> insertStatements() {
+    public List<InsertStatementProvider<T>> insertStatements() {
         return records.stream()
                 .map(this::toInsertStatement)
                 .collect(Collectors.toList());
     }
 
-    private InsertStatement<T> toInsertStatement(T record) {
-        return InsertStatement.withRecord(record)
+    private InsertStatementProvider<T> toInsertStatement(T record) {
+        return InsertStatementProvider.withRecord(record)
                 .withTableName(tableName)
                 .withColumnsPhrase(columnsPhrase)
                 .withValuesPhrase(valuesPhrase)

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

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