Enable a standalone where clause

jeffgbutler · jeffgbutler · commit 1f8c78c251e2 · 2017-12-02T21:35:44.000-05:00
diff --git a/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java b/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java
@@ -43,6 +43,7 @@
 import org.mybatis.dynamic.sql.update.UpdateDSL;
 import org.mybatis.dynamic.sql.update.UpdateModel;
 import org.mybatis.dynamic.sql.util.Buildable;
+import org.mybatis.dynamic.sql.where.WhereDSL;
 import org.mybatis.dynamic.sql.where.condition.IsBetween;
 import org.mybatis.dynamic.sql.where.condition.IsEqualTo;
 import org.mybatis.dynamic.sql.where.condition.IsEqualToWithSubselect;
@@ -106,6 +107,15 @@ static UpdateDSL<UpdateModel> update(SqlTable table) {
         return UpdateDSL.update(table);
     }
 
+    static <T> WhereDSL where(BindableColumn<T> column, VisitableCondition<T> condition) {
+        return WhereDSL.where(column, condition);
+    }
+    
+    static <T> WhereDSL where(BindableColumn<T> column, VisitableCondition<T> condition,
+            SqlCriterion<?>... subCriteria) {
+        return WhereDSL.where(column, condition, subCriteria);
+    }
+    
     // where condition connectors
     static <T> SqlCriterion<T> or(BindableColumn<T> column, VisitableCondition<T> condition) {
         return new SqlCriterion.Builder<T>()
diff --git a/src/main/java/org/mybatis/dynamic/sql/delete/render/DeleteRenderer.java b/src/main/java/org/mybatis/dynamic/sql/delete/render/DeleteRenderer.java
@@ -16,14 +16,11 @@
 package org.mybatis.dynamic.sql.delete.render;
 
 import java.util.Objects;
-import java.util.concurrent.atomic.AtomicInteger;
 
 import org.mybatis.dynamic.sql.delete.DeleteModel;
 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.WhereClauseAndParameters;
-import org.mybatis.dynamic.sql.where.render.WhereRenderer;
 
 public class DeleteRenderer {
     private DeleteModel deleteModel;
@@ -42,13 +39,7 @@ public DeleteStatement render() {
     }
     
     private WhereClauseAndParameters renderWhereModel(WhereModel whereModel) {
-        return new WhereRenderer.Builder()
-                .withWhereModel(whereModel)
-                .withRenderingStrategy(renderingStrategy)
-                .withSequence(new AtomicInteger(1))
-                .withTableAliasCalculator(TableAliasCalculator.empty())
-                .build()
-                .render();
+        return whereModel.render(renderingStrategy);
     }
     
     public static class Builder {
diff --git a/src/main/java/org/mybatis/dynamic/sql/render/TableAliasCalculator.java b/src/main/java/org/mybatis/dynamic/sql/render/TableAliasCalculator.java
@@ -16,6 +16,7 @@
 package org.mybatis.dynamic.sql.render;
 
 import java.util.Collections;
+import java.util.HashMap;
 import java.util.Map;
 import java.util.Objects;
 import java.util.Optional;
@@ -38,11 +39,17 @@ public Optional<String> aliasForTable(SqlTable table) {
         return Optional.ofNullable(aliases.get(table));
     }
     
+    public static TableAliasCalculator of(SqlTable table, String alias) {
+        Map<SqlTable, String> tableAliases = new HashMap<>();
+        tableAliases.put(table, alias);
+        return of(tableAliases);
+    }
+    
     public static TableAliasCalculator of(Map<SqlTable, String> aliases) {
         return new TableAliasCalculator(aliases);
     }
     
     public static TableAliasCalculator empty() {
-        return new TableAliasCalculator(Collections.emptyMap());
+        return of(Collections.emptyMap());
     }
 }
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
@@ -16,19 +16,16 @@
 package org.mybatis.dynamic.sql.update.render;
 
 import java.util.Objects;
-import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
-import org.mybatis.dynamic.sql.render.TableAliasCalculator;
 import org.mybatis.dynamic.sql.update.UpdateModel;
 import org.mybatis.dynamic.sql.util.FragmentAndParameters;
 import org.mybatis.dynamic.sql.util.FragmentCollector;
 import org.mybatis.dynamic.sql.util.UpdateMapping;
 import org.mybatis.dynamic.sql.where.WhereModel;
 import org.mybatis.dynamic.sql.where.render.WhereClauseAndParameters;
-import org.mybatis.dynamic.sql.where.render.WhereRenderer;
 
 public class UpdateRenderer {
     private UpdateModel updateModel;
@@ -59,13 +56,7 @@ private String calculateSetPhrase(FragmentCollector collector) {
     }
     
     private WhereClauseAndParameters renderWhereModel(WhereModel whereModel) {
-        return new WhereRenderer.Builder()
-                .withWhereModel(whereModel)
-                .withRenderingStrategy(renderingStrategy)
-                .withSequence(new AtomicInteger(1))
-                .withTableAliasCalculator(TableAliasCalculator.empty())
-                .build()
-                .render();
+        return whereModel.render(renderingStrategy);
     }
 
     private Function<UpdateMapping, FragmentAndParameters> toFragmentAndParameters(SetPhraseVisitor visitor) {
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/WhereDSL.java b/src/main/java/org/mybatis/dynamic/sql/where/WhereDSL.java
@@ -0,0 +1,49 @@
+/**
+ *    Copyright 2016-2017 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
+ *
+ *       http://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;
+
+import org.mybatis.dynamic.sql.BindableColumn;
+import org.mybatis.dynamic.sql.SqlCriterion;
+import org.mybatis.dynamic.sql.VisitableCondition;
+
+public class WhereDSL extends AbstractWhereDSL<WhereDSL> {
+
+    private <T> WhereDSL(BindableColumn<T> column, VisitableCondition<T> condition) {
+        super(column, condition);
+    }
+
+    private <T> WhereDSL(BindableColumn<T> column, VisitableCondition<T> condition, SqlCriterion<?>... subCriteria) {
+        super(column, condition, subCriteria);
+    }
+
+    @Override
+    protected WhereDSL getThis() {
+        return this;
+    }
+
+    public static <T> WhereDSL where(BindableColumn<T> column, VisitableCondition<T> condition) {
+        return new WhereDSL(column, condition);
+    }
+
+    public static <T> WhereDSL where(BindableColumn<T> column, VisitableCondition<T> condition,
+            SqlCriterion<?>... subCriteria) {
+        return new WhereDSL(column, condition, subCriteria);
+    }
+
+    public WhereModel build() {
+        return super.buildWhereModel();
+    }
+}
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/WhereModel.java b/src/main/java/org/mybatis/dynamic/sql/where/WhereModel.java
@@ -17,10 +17,15 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.function.Function;
 import java.util.stream.Stream;
 
 import org.mybatis.dynamic.sql.SqlCriterion;
+import org.mybatis.dynamic.sql.render.RenderingStrategy;
+import org.mybatis.dynamic.sql.render.TableAliasCalculator;
+import org.mybatis.dynamic.sql.where.render.WhereClauseAndParameters;
+import org.mybatis.dynamic.sql.where.render.WhereRenderer;
 
 public class WhereModel {
     private List<SqlCriterion<?>> criteria = new ArrayList<>();
@@ -33,6 +38,27 @@ public <R> Stream<R> mapCriteria(Function<SqlCriterion<?>, R> mapper) {
         return criteria.stream().map(mapper);
     }
 
+    /**
+     * Renders a where clause without table aliases.
+     * 
+     * @param renderingStrategy rendering strategy
+     * @return rendered where clause
+     */
+    public WhereClauseAndParameters render(RenderingStrategy renderingStrategy) {
+        return render(renderingStrategy, TableAliasCalculator.empty());
+    }
+    
+    public WhereClauseAndParameters render(RenderingStrategy renderingStrategy,
+            TableAliasCalculator tableAliasCalculator) {
+        return new WhereRenderer.Builder()
+                .withWhereModel(this)
+                .withRenderingStrategy(renderingStrategy)
+                .withSequence(new AtomicInteger(1))
+                .withTableAliasCalculator(tableAliasCalculator)
+                .build()
+                .render();
+    }
+    
     public static WhereModel of(List<SqlCriterion<?>> criteria) {
         return new WhereModel(criteria);
     }
diff --git a/src/test/java/examples/animal/data/AnimalDataMapper.java b/src/test/java/examples/animal/data/AnimalDataMapper.java
@@ -21,7 +21,9 @@
 import org.apache.ibatis.annotations.DeleteProvider;
 import org.apache.ibatis.annotations.InsertProvider;
 import org.apache.ibatis.annotations.Result;
+import org.apache.ibatis.annotations.ResultMap;
 import org.apache.ibatis.annotations.Results;
+import org.apache.ibatis.annotations.Select;
 import org.apache.ibatis.annotations.SelectProvider;
 import org.apache.ibatis.annotations.UpdateProvider;
 import org.mybatis.dynamic.sql.delete.render.DeleteStatement;
@@ -30,11 +32,12 @@
 import org.mybatis.dynamic.sql.select.render.SelectStatement;
 import org.mybatis.dynamic.sql.update.render.UpdateStatement;
 import org.mybatis.dynamic.sql.util.SqlProviderAdapter;
+import org.mybatis.dynamic.sql.where.render.WhereClauseAndParameters;
 
 public interface AnimalDataMapper {
 
     @SelectProvider(type=SqlProviderAdapter.class, method="select")
-    @Results({
+    @Results(id="AnimalDataResult", value={
         @Result(column="id", property="id", id=true),
         @Result(column="animal_name", property="animalName"),
         @Result(column="brain_weight", property="brainWeight"),
@@ -62,4 +65,20 @@ public interface AnimalDataMapper {
 
     @InsertProvider(type=SqlProviderAdapter.class, method="insertSelect")
     int insertSelect(InsertSelectStatement insertSelectStatement);
+    
+    @Select({
+        "select id, animal_name, brain_weight, body_weight",
+        "from AnimalData",
+        "${whereClause}"
+    })
+    @ResultMap("AnimalDataResult")
+    List<AnimalData> selectByExample(WhereClauseAndParameters whereClause);
+
+    @Select({
+        "select a.id, a.animal_name, a.brain_weight, a.body_weight",
+        "from AnimalData a",
+        "${whereClause}"
+    })
+    @ResultMap("AnimalDataResult")
+    List<AnimalData> selectByExampleWithAlias(WhereClauseAndParameters whereClause);
 }
diff --git a/src/test/java/examples/animal/data/AnimalDataTest.java b/src/test/java/examples/animal/data/AnimalDataTest.java
@@ -48,8 +48,10 @@
 import org.mybatis.dynamic.sql.insert.render.InsertSelectStatement;
 import org.mybatis.dynamic.sql.insert.render.InsertStatement;
 import org.mybatis.dynamic.sql.render.RenderingStrategy;
+import org.mybatis.dynamic.sql.render.TableAliasCalculator;
 import org.mybatis.dynamic.sql.select.render.SelectStatement;
 import org.mybatis.dynamic.sql.update.render.UpdateStatement;
+import org.mybatis.dynamic.sql.where.render.WhereClauseAndParameters;
 
 @RunWith(JUnitPlatform.class)
 public class AnimalDataTest {
@@ -172,6 +174,23 @@ public void testSelectRowsNotBetween() {
         }
     }
 
+    @Test
+    public void testSelectRowsNotBetweenWithStandaloneWhereClause() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+        try {
+            AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
+            
+            WhereClauseAndParameters whereClause = where(id, isNotBetween(10).and(60))
+                    .build()
+                    .render(RenderingStrategy.MYBATIS3);
+            
+            List<AnimalData> animals = mapper.selectByExample(whereClause);
+            assertThat(animals.size()).isEqualTo(14);
+        } finally {
+            sqlSession.close();
+        }
+    }
+    
     @Test
     public void testUnionSelectWithWhere() {
         SqlSession sqlSession = sqlSessionFactory.openSession();
@@ -725,6 +744,25 @@ public void testComplexCondition() {
         }
     }
 
+    @Test
+    public void testComplexConditionWithStandaloneWhereAndTableAlias() {
+        SqlSession sqlSession = sqlSessionFactory.openSession();
+        try {
+            AnimalDataMapper mapper = sqlSession.getMapper(AnimalDataMapper.class);
+            
+            WhereClauseAndParameters whereClause = where(id, isEqualTo(1), or(bodyWeight, isGreaterThan(1.0)))
+                    .build()
+                    .render(RenderingStrategy.MYBATIS3, TableAliasCalculator.of(animalData, "a"));
+            
+            assertThat(whereClause.whereClause()).isEqualTo("where (a.id = #{parameters.p1,jdbcType=INTEGER} or a.body_weight > #{parameters.p2,jdbcType=DOUBLE})");
+
+            List<AnimalData> animals = mapper.selectByExampleWithAlias(whereClause);
+            assertThat(animals.size()).isEqualTo(59);
+        } finally {
+            sqlSession.close();
+        }
+    }
+    
     @Test
     public void testUpdateByExample() {
         SqlSession sqlSession = sqlSessionFactory.openSession();

Original file line number	Diff line number	Diff line change
`@@ -16,6 +16,7 @@`
`16`	`16`	`package org.mybatis.dynamic.sql.render;`
`17`	`17`
`18`	`18`	`import java.util.Collections;`
	`19`	`+import java.util.HashMap;`
`19`	`20`	`import java.util.Map;`
`20`	`21`	`import java.util.Objects;`
`21`	`22`	`import java.util.Optional;`
`@@ -38,11 +39,17 @@ public Optional<String> aliasForTable(SqlTable table) {`
`38`	`39`	`return Optional.ofNullable(aliases.get(table));`
`39`	`40`	`}`
`40`	`41`
	`42`	`+ public static TableAliasCalculator of(SqlTable table, String alias) {`
	`43`	`+ Map<SqlTable, String> tableAliases = new HashMap<>();`
	`44`	`+ tableAliases.put(table, alias);`
	`45`	`+ return of(tableAliases);`
	`46`	`+ }`
	`47`	`+`
`41`	`48`	`public static TableAliasCalculator of(Map<SqlTable, String> aliases) {`
`42`	`49`	`return new TableAliasCalculator(aliases);`
`43`	`50`	`}`
`44`	`51`
`45`	`52`	`public static TableAliasCalculator empty() {`
`46`		`- return new TableAliasCalculator(Collections.emptyMap());`
	`53`	`+ return of(Collections.emptyMap());`
`47`	`54`	`}`
`48`	`55`	`}`