diff --git a/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java b/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java
index 14d034aa4..1159f93fe 100644
--- a/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java
+++ b/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java
@@ -133,6 +133,10 @@ static UpdateDSL<UpdateModel> update(SqlTable table) {
         return UpdateDSL.update(table);
     }
 
+    static WhereDSL where() {
+        return WhereDSL.where();
+    }
+    
     static <T> WhereDSL where(BindableColumn<T> column, VisitableCondition<T> condition) {
         return WhereDSL.where(column, condition);
     }
diff --git a/src/main/java/org/mybatis/dynamic/sql/delete/DeleteDSL.java b/src/main/java/org/mybatis/dynamic/sql/delete/DeleteDSL.java
index c07c0b605..0b67f1430 100644
--- a/src/main/java/org/mybatis/dynamic/sql/delete/DeleteDSL.java
+++ b/src/main/java/org/mybatis/dynamic/sql/delete/DeleteDSL.java
@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2017 the original author or authors.
+ *    Copyright 2016-2019 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.
@@ -35,6 +35,10 @@ private DeleteDSL(SqlTable table, Function<DeleteModel, R> adapterFunction) {
         this.adapterFunction = Objects.requireNonNull(adapterFunction);
     }
     
+    public DeleteWhereBuilder where() {
+        return new DeleteWhereBuilder();
+    }
+    
     public <T> DeleteWhereBuilder where(BindableColumn<T> column, VisitableCondition<T> condition) {
         return new DeleteWhereBuilder(column, condition);
     }
@@ -70,6 +74,10 @@ public static <T> DeleteDSL<MyBatis3DeleteModelAdapter<T>> deleteFromWithMapper(
     
     public class DeleteWhereBuilder extends AbstractWhereDSL<DeleteWhereBuilder> {
         
+        private <T> DeleteWhereBuilder() {
+            super();
+        }
+        
         private <T> DeleteWhereBuilder(BindableColumn<T> column, VisitableCondition<T> condition) {
             super(column, condition);
         }
diff --git a/src/main/java/org/mybatis/dynamic/sql/select/QueryExpressionDSL.java b/src/main/java/org/mybatis/dynamic/sql/select/QueryExpressionDSL.java
index c18474c25..387b635af 100644
--- a/src/main/java/org/mybatis/dynamic/sql/select/QueryExpressionDSL.java
+++ b/src/main/java/org/mybatis/dynamic/sql/select/QueryExpressionDSL.java
@@ -82,6 +82,10 @@ public static <R> FromGatherer<R> selectDistinct(SelectDSL<R> selectDSL, BasicCo
                 .build();
     }
     
+    public QueryExpressionWhereBuilder where() {
+        return new QueryExpressionWhereBuilder();
+    }
+
     public <T> QueryExpressionWhereBuilder where(BindableColumn<T> column, VisitableCondition<T> condition) {
         return new QueryExpressionWhereBuilder(column, condition);
     }
@@ -261,6 +265,10 @@ public FromGatherer<R> build() {
     
     public class QueryExpressionWhereBuilder extends AbstractWhereDSL<QueryExpressionWhereBuilder>
             implements Buildable<R> {
+        private <T> QueryExpressionWhereBuilder() {
+            buildDelegateMethod = this::internalBuild;
+        }
+
         private <T> QueryExpressionWhereBuilder(BindableColumn<T> column, VisitableCondition<T> condition) {
             super(column, condition);
             buildDelegateMethod = this::internalBuild;
@@ -413,6 +421,11 @@ private R internalbuild() {
             return selectDSL.build();
         }
         
+        public QueryExpressionWhereBuilder where() {
+            joinModel = buildJoinModel();
+            return new QueryExpressionWhereBuilder();
+        }
+        
         public <T> QueryExpressionWhereBuilder where(BindableColumn<T> column, VisitableCondition<T> condition) {
             joinModel = buildJoinModel();
             return new QueryExpressionWhereBuilder(column, condition);
diff --git a/src/main/java/org/mybatis/dynamic/sql/update/UpdateDSL.java b/src/main/java/org/mybatis/dynamic/sql/update/UpdateDSL.java
index 846467090..c6f351e32 100644
--- a/src/main/java/org/mybatis/dynamic/sql/update/UpdateDSL.java
+++ b/src/main/java/org/mybatis/dynamic/sql/update/UpdateDSL.java
@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2018 the original author or authors.
+ *    Copyright 2016-2019 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.
@@ -54,6 +54,10 @@ public <T> SetClauseFinisher<T> set(SqlColumn<T> column) {
         return new SetClauseFinisher<>(column);
     }
     
+    public UpdateWhereBuilder where() {
+        return new UpdateWhereBuilder();
+    }
+    
     public <T> UpdateWhereBuilder where(BindableColumn<T> column, VisitableCondition<T> condition) {
         return new UpdateWhereBuilder(column, condition);
     }
@@ -145,6 +149,10 @@ public UpdateDSL<R> equalToWhenPresent(Supplier<T> valueSupplier) {
 
     public class UpdateWhereBuilder extends AbstractWhereDSL<UpdateWhereBuilder> {
         
+        public <T> UpdateWhereBuilder() {
+            super();
+        }
+        
         public <T> UpdateWhereBuilder(BindableColumn<T> column, VisitableCondition<T> condition) {
             super(column, condition);
         }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/AbstractWhereDSL.java b/src/main/java/org/mybatis/dynamic/sql/where/AbstractWhereDSL.java
index 54a4dbc93..017f2e1ab 100644
--- a/src/main/java/org/mybatis/dynamic/sql/where/AbstractWhereDSL.java
+++ b/src/main/java/org/mybatis/dynamic/sql/where/AbstractWhereDSL.java
@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2017 the original author or authors.
+ *    Copyright 2016-2019 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.
@@ -26,6 +26,10 @@
 public abstract class AbstractWhereDSL<T extends AbstractWhereDSL<T>> {
     private List<SqlCriterion<?>> criteria = new ArrayList<>();
     
+    protected <S> AbstractWhereDSL() {
+        super();
+    }
+    
     protected <S> AbstractWhereDSL(BindableColumn<S> column, VisitableCondition<S> condition) {
         SqlCriterion<S> criterion = SqlCriterion.withColumn(column)
                 .withCondition(condition)
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/WhereDSL.java b/src/main/java/org/mybatis/dynamic/sql/where/WhereDSL.java
index df8617c6a..4a57eb4de 100644
--- a/src/main/java/org/mybatis/dynamic/sql/where/WhereDSL.java
+++ b/src/main/java/org/mybatis/dynamic/sql/where/WhereDSL.java
@@ -1,5 +1,5 @@
 /**
- *    Copyright 2016-2017 the original author or authors.
+ *    Copyright 2016-2019 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.
@@ -21,6 +21,10 @@
 
 public class WhereDSL extends AbstractWhereDSL<WhereDSL> {
 
+    private WhereDSL() {
+        super();
+    }
+
     private <T> WhereDSL(BindableColumn<T> column, VisitableCondition<T> condition) {
         super(column, condition);
     }
@@ -34,6 +38,10 @@ protected WhereDSL getThis() {
         return this;
     }
 
+    public static WhereDSL where() {
+        return new WhereDSL();
+    }
+
     public static <T> WhereDSL where(BindableColumn<T> column, VisitableCondition<T> condition) {
         return new WhereDSL(column, condition);
     }
diff --git a/src/test/java/examples/emptywhere/EmptyWhereTest.java b/src/test/java/examples/emptywhere/EmptyWhereTest.java
new file mode 100644
index 000000000..4c111e92e
--- /dev/null
+++ b/src/test/java/examples/emptywhere/EmptyWhereTest.java
@@ -0,0 +1,547 @@
+/**
+ *    Copyright 2016-2019 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 examples.emptywhere;
+
+import static examples.emptywhere.OrderDynamicSqlSupport.*;
+import static examples.emptywhere.PersonDynamicSqlSupport.*;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mybatis.dynamic.sql.SqlBuilder.*;
+
+import java.util.Objects;
+
+import org.junit.jupiter.api.Test;
+import org.mybatis.dynamic.sql.delete.DeleteDSL;
+import org.mybatis.dynamic.sql.delete.DeleteModel;
+import org.mybatis.dynamic.sql.delete.render.DeleteStatementProvider;
+import org.mybatis.dynamic.sql.render.RenderingStrategy;
+import org.mybatis.dynamic.sql.select.QueryExpressionDSL;
+import org.mybatis.dynamic.sql.select.SelectModel;
+import org.mybatis.dynamic.sql.select.render.SelectStatementProvider;
+import org.mybatis.dynamic.sql.update.UpdateDSL;
+import org.mybatis.dynamic.sql.update.UpdateModel;
+import org.mybatis.dynamic.sql.update.render.UpdateStatementProvider;
+import org.mybatis.dynamic.sql.where.WhereDSL;
+import org.mybatis.dynamic.sql.where.render.WhereClauseProvider;
+
+public class EmptyWhereTest {
+
+    @Test
+    public void testDeleteThreeConditions() {
+        String fName = "Fred";
+        String lName = "Flintstone";
+        
+        DeleteDSL<DeleteModel>.DeleteWhereBuilder builder = deleteFrom(person)
+                .where(id, isEqualTo(3));
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        DeleteStatementProvider deleteStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "delete from person"
+                + " where id = #{parameters.p1}"
+                + " and first_name = #{parameters.p2}"
+                + " and last_name = #{parameters.p3}";
+        
+        assertThat(deleteStatement.getDeleteStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testDeleteTwoConditions() {
+        String fName = "Fred";
+        String lName = "Flintstone";
+        
+        DeleteDSL<DeleteModel>.DeleteWhereBuilder builder = deleteFrom(person)
+                .where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.or(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        DeleteStatementProvider deleteStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "delete from person"
+                + " where first_name = #{parameters.p1}"
+                + " or last_name = #{parameters.p2}";
+        
+        assertThat(deleteStatement.getDeleteStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testDeleteFirstNameNull() {
+        String fName = null;
+        String lName = "Flintstone";
+        
+        DeleteDSL<DeleteModel>.DeleteWhereBuilder builder = deleteFrom(person)
+                .where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        DeleteStatementProvider deleteStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "delete from person"
+                + " where last_name = #{parameters.p1}";
+        
+        assertThat(deleteStatement.getDeleteStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testDeleteLastNameNull() {
+        String fName = "Fred";
+        String lName = null;
+        
+        DeleteDSL<DeleteModel>.DeleteWhereBuilder builder = deleteFrom(person)
+                .where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        DeleteStatementProvider deleteStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "delete from person"
+                + " where first_name = #{parameters.p1}";
+        
+        assertThat(deleteStatement.getDeleteStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testDeleteAllNull() {
+        String fName = null;
+        String lName = null;
+        
+        DeleteDSL<DeleteModel>.DeleteWhereBuilder builder = deleteFrom(person)
+                .where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        DeleteStatementProvider deleteStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "delete from person";
+        
+        assertThat(deleteStatement.getDeleteStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testSelectThreeConditions() {
+        String fName = "Fred";
+        String lName = "Flintstone";
+        
+        QueryExpressionDSL<SelectModel>.QueryExpressionWhereBuilder builder = select(id, firstName, lastName)
+                .from(person)
+                .where(id, isEqualTo(3));
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        SelectStatementProvider selectStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "select id, first_name, last_name"
+                + " from person"
+                + " where id = #{parameters.p1}"
+                + " and first_name = #{parameters.p2}"
+                + " and last_name = #{parameters.p3}";
+        
+        assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testSelectTwoConditions() {
+        String fName = "Fred";
+        String lName = "Flintstone";
+        
+        QueryExpressionDSL<SelectModel>.QueryExpressionWhereBuilder builder = select(person.allColumns())
+                .from(person)
+                .where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        SelectStatementProvider selectStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "select *"
+                + " from person"
+                + " where first_name = #{parameters.p1}"
+                + " and last_name = #{parameters.p2}";
+        
+        assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testSelectFirstNameNull() {
+        String fName = null;
+        String lName = "Flintstone";
+        
+        QueryExpressionDSL<SelectModel>.QueryExpressionWhereBuilder builder = select(id, firstName, lastName)
+                .from(person)
+                .where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        SelectStatementProvider selectStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "select id, first_name, last_name"
+                + " from person"
+                + " where last_name = #{parameters.p1}";
+        
+        assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testSelectLastNameNull() {
+        String fName = "Fred";
+        String lName = null;
+        
+        QueryExpressionDSL<SelectModel>.QueryExpressionWhereBuilder builder = select(id, firstName, lastName)
+                .from(person)
+                .where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        SelectStatementProvider selectStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "select id, first_name, last_name"
+                + " from person"
+                + " where first_name = #{parameters.p1}";
+        
+        assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testSelectAllNull() {
+        String fName = null;
+        String lName = null;
+        
+        QueryExpressionDSL<SelectModel>.QueryExpressionWhereBuilder builder = select(id, firstName, lastName)
+                .from(person)
+                .where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        SelectStatementProvider selectStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "select id, first_name, last_name"
+                + " from person";
+        
+        assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testJoinThreeConditions() {
+        String fName = "Fred";
+        String lName = "Flintstone";
+        
+        QueryExpressionDSL<SelectModel>.QueryExpressionWhereBuilder builder = select(id, firstName, lastName, orderDate)
+                .from(person).join(order).on(person.id, equalTo(order.personId))
+                .where(id, isEqualTo(3));
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        SelectStatementProvider selectStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "select person.id, person.first_name, person.last_name, order.order_date"
+                + " from person"
+                + " join order on person.id = order.person_id"
+                + " where person.id = #{parameters.p1}"
+                + " and person.first_name = #{parameters.p2}"
+                + " and person.last_name = #{parameters.p3}";
+        
+        assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testJoinTwoConditions() {
+        String fName = "Fred";
+        String lName = "Flintstone";
+        
+        QueryExpressionDSL<SelectModel>.QueryExpressionWhereBuilder builder = select(id, firstName, lastName, orderDate)
+                .from(person).join(order).on(person.id, equalTo(order.personId))
+                .where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        SelectStatementProvider selectStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "select person.id, person.first_name, person.last_name, order.order_date"
+                + " from person"
+                + " join order on person.id = order.person_id"
+                + " where person.first_name = #{parameters.p1}"
+                + " and person.last_name = #{parameters.p2}";
+        
+        assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testJoinFirstNameNull() {
+        String fName = null;
+        String lName = "Flintstone";
+        
+        QueryExpressionDSL<SelectModel>.QueryExpressionWhereBuilder builder = select(id, firstName, lastName, orderDate)
+                .from(person).join(order).on(person.id, equalTo(order.personId))
+                .where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        SelectStatementProvider selectStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "select person.id, person.first_name, person.last_name, order.order_date"
+                + " from person"
+                + " join order on person.id = order.person_id"
+                + " where person.last_name = #{parameters.p1}";
+        
+        assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testJoinLastNameNull() {
+        String fName = "Fred";
+        String lName = null;
+        
+        QueryExpressionDSL<SelectModel>.QueryExpressionWhereBuilder builder = select(id, firstName, lastName, orderDate)
+                .from(person).join(order).on(person.id, equalTo(order.personId))
+                .where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        SelectStatementProvider selectStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "select person.id, person.first_name, person.last_name, order.order_date"
+                + " from person"
+                + " join order on person.id = order.person_id"
+                + " where person.first_name = #{parameters.p1}";
+        
+        assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testJoinAllNull() {
+        String fName = null;
+        String lName = null;
+        
+        QueryExpressionDSL<SelectModel>.QueryExpressionWhereBuilder builder = select(id, firstName, lastName, orderDate)
+                .from(person).join(order).on(person.id, equalTo(order.personId))
+                .where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        SelectStatementProvider selectStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "select person.id, person.first_name, person.last_name, order.order_date"
+                + " from person"
+                + " join order on person.id = order.person_id";
+        
+        assertThat(selectStatement.getSelectStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testUpdateThreeConditions() {
+        String fName = "Fred";
+        String lName = "Flintstone";
+        
+        UpdateDSL<UpdateModel>.UpdateWhereBuilder builder = update(person)
+                .set(id).equalTo(3)
+                .where(id, isEqualTo(3));
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        UpdateStatementProvider updateStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "update person"
+                + " set id = #{parameters.p1}"
+                + " where id = #{parameters.p2}"
+                + " and first_name = #{parameters.p3}"
+                + " and last_name = #{parameters.p4}";
+        
+        assertThat(updateStatement.getUpdateStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testUpdateTwoConditions() {
+        String fName = "Fred";
+        String lName = "Flintstone";
+        
+        UpdateDSL<UpdateModel>.UpdateWhereBuilder builder = update(person)
+                .set(id).equalTo(3)
+                .where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        UpdateStatementProvider updateStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "update person"
+                + " set id = #{parameters.p1}"
+                + " where first_name = #{parameters.p2}"
+                + " and last_name = #{parameters.p3}";
+        
+        assertThat(updateStatement.getUpdateStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testUpdateFirstNameNull() {
+        String fName = null;
+        String lName = "Flintstone";
+        
+        DeleteDSL<DeleteModel>.DeleteWhereBuilder builder = deleteFrom(person)
+                .where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        DeleteStatementProvider deleteStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "delete from person"
+                + " where last_name = #{parameters.p1}";
+        
+        assertThat(deleteStatement.getDeleteStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testUpdateLastNameNull() {
+        String fName = "Fred";
+        String lName = null;
+        
+        UpdateDSL<UpdateModel>.UpdateWhereBuilder builder = update(person)
+                .set(id).equalTo(3)
+                .where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        UpdateStatementProvider updateStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "update person"
+                + " set id = #{parameters.p1}"
+                + " where first_name = #{parameters.p2}";
+        
+        assertThat(updateStatement.getUpdateStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testUpdateAllNull() {
+        String fName = null;
+        String lName = null;
+        
+        UpdateDSL<UpdateModel>.UpdateWhereBuilder builder = update(person)
+                .set(id).equalTo(3)
+                .where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        UpdateStatementProvider updateStatement = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "update person"
+                + " set id = #{parameters.p1}";
+        
+        assertThat(updateStatement.getUpdateStatement()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testWhereThreeConditions() {
+        String fName = "Fred";
+        String lName = "Flintstone";
+        
+        WhereDSL builder = where(id, isEqualTo(3));
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        WhereClauseProvider whereClause = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "where id = #{parameters.p1}"
+                + " and first_name = #{parameters.p2}"
+                + " and last_name = #{parameters.p3}";
+        
+        assertThat(whereClause.getWhereClause()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testWhereTwoConditions() {
+        String fName = "Fred";
+        String lName = "Flintstone";
+        
+        WhereDSL builder = where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        WhereClauseProvider whereClause = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "where first_name = #{parameters.p1}"
+                + " and last_name = #{parameters.p2}";
+        
+        assertThat(whereClause.getWhereClause()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testWhereFirstNameNull() {
+        String fName = null;
+        String lName = "Flintstone";
+        
+        WhereDSL builder = where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        WhereClauseProvider whereClause = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "where last_name = #{parameters.p1}";
+        
+        assertThat(whereClause.getWhereClause()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testWhereLastNameNull() {
+        String fName = "Fred";
+        String lName = null;
+        
+        WhereDSL builder = where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        WhereClauseProvider whereClause = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        String expected = "where first_name = #{parameters.p1}";
+        
+        assertThat(whereClause.getWhereClause()).isEqualTo(expected);
+    }
+
+    @Test
+    public void testWhereAllNull() {
+        String fName = null;
+        String lName = null;
+        
+        WhereDSL builder = where();
+        
+        builder.and(firstName, isEqualTo(fName).when(Objects::nonNull));
+        builder.and(lastName, isEqualTo(lName).when(Objects::nonNull));
+        
+        WhereClauseProvider whereClause = builder.build().render(RenderingStrategy.MYBATIS3);
+        
+        assertThat(whereClause.getWhereClause()).isEmpty();
+    }
+}
diff --git a/src/test/java/examples/emptywhere/OrderDynamicSqlSupport.java b/src/test/java/examples/emptywhere/OrderDynamicSqlSupport.java
new file mode 100644
index 000000000..2052c53be
--- /dev/null
+++ b/src/test/java/examples/emptywhere/OrderDynamicSqlSupport.java
@@ -0,0 +1,37 @@
+/**
+ *    Copyright 2016-2019 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 examples.emptywhere;
+
+import java.util.Date;
+
+import org.mybatis.dynamic.sql.SqlColumn;
+import org.mybatis.dynamic.sql.SqlTable;
+
+public class OrderDynamicSqlSupport {
+    
+    public static Order order = new Order();
+    public static SqlColumn<Integer> personId = order.personId;
+    public static SqlColumn<Date> orderDate = order.orderDate;
+
+    public static class Order extends SqlTable {
+        public SqlColumn<Integer> personId = column("person_id");
+        public SqlColumn<Date> orderDate = column("order_date");
+        
+        public Order() {
+            super("order");
+        }
+    }
+}
diff --git a/src/test/java/examples/emptywhere/PersonDynamicSqlSupport.java b/src/test/java/examples/emptywhere/PersonDynamicSqlSupport.java
new file mode 100644
index 000000000..0966d7e39
--- /dev/null
+++ b/src/test/java/examples/emptywhere/PersonDynamicSqlSupport.java
@@ -0,0 +1,37 @@
+/**
+ *    Copyright 2016-2019 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 examples.emptywhere;
+
+import org.mybatis.dynamic.sql.SqlColumn;
+import org.mybatis.dynamic.sql.SqlTable;
+
+public class PersonDynamicSqlSupport {
+    
+    public static Person person = new Person();
+    public static SqlColumn<Integer> id = person.id;
+    public static SqlColumn<String> firstName = person.firstName;
+    public static SqlColumn<String> lastName = person.lastName;
+
+    public static class Person extends SqlTable {
+        public SqlColumn<Integer> id = column("id");
+        public SqlColumn<String> firstName = column("first_name");
+        public SqlColumn<String> lastName = column("last_name");
+        
+        public Person() {
+            super("person");
+        }
+    }
+}