Add Support for "exists"and "not exists" in "where" Clauses

CHANGELOG.md

@@ -10,10 +10,12 @@ GitHub milestone: [https://github.com/mybatis/mybatis-dynamic-sql/issues?q=miles
 
 The major themes of this release include the following:
 
-1. Add support for subqueries in select statements - both in a from clause and a join clause
+1. Add support for subqueries in select statements - both in a from clause and a join clause.
+1. Add support for the "exists" and "not exists" operator. This will work in "where" clauses anywhere
+   they are supported.
 1. Continue to refine the Kotlin DSL. Most changes to the Kotlin DSL are internal and should be source code
    compatible with existing code. There is one breaking change detailed below.
-1. Remove deprecated code from prior releases
+1. Remove deprecated code from prior releases.
 
 ### Breaking Change for Kotlin
 
@@ -37,16 +39,17 @@ The new code looks like this:
    }
 ```
 
-This change makes the Kotlin DSL a bit more consistent and also makes it easier to implement sub-query support in the
+This change makes the Kotlin DSL a bit more consistent and also makes it easier to implement subquery support in the
 Kotlin DSL.
 
 ### Added
 
 - Added a new sort specification that is useful in selects with joins ([#269](https://github.com/mybatis/mybatis-dynamic-sql/pull/269))
 - Added the capability to generate a camel cased alias for a column ([#272](https://github.com/mybatis/mybatis-dynamic-sql/issues/272))
-- Added sub-query support for "from" clauses in a select statement ([#282](https://github.com/mybatis/mybatis-dynamic-sql/pull/282))
+- Added subquery support for "from" clauses in a select statement ([#282](https://github.com/mybatis/mybatis-dynamic-sql/pull/282))
 - Added Kotlin DSL updates to support sub-queries in select statements, where clauses, and insert statements ([#282](https://github.com/mybatis/mybatis-dynamic-sql/pull/282))
-- Added sub-query support for "join" clauses in a select statement ([#293](https://github.com/mybatis/mybatis-dynamic-sql/pull/293))
+- Added subquery support for "join" clauses in a select statement ([#293](https://github.com/mybatis/mybatis-dynamic-sql/pull/293))
+- Added support for the "exists" and "not exists" operator in where clauses ([#296](https://github.com/mybatis/mybatis-dynamic-sql/pull/296))
 
 
 ## Release 1.2.1 - September 29, 2020

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

@@ -0,0 +1,70 @@
+/*
+ *    Copyright 2016-2020 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;
+
+import java.util.Objects;
+
+public class ColumnAndConditionCriterion<T> extends SqlCriterion {
+    private final BindableColumn<T> column;
+    private final VisitableCondition<T> condition;
+
+    private ColumnAndConditionCriterion(Builder<T> builder) {
+        super(builder);
+        column = Objects.requireNonNull(builder.column);
+        condition = Objects.requireNonNull(builder.condition);
+    }
+
+    public BindableColumn<T> column() {
+        return column;
+    }
+
+    public VisitableCondition<T> condition() {
+        return condition;
+    }
+
+    @Override
+    public <R> R accept(SqlCriterionVisitor<R> visitor) {
+        return visitor.visit(this);
+    }
+
+    public static <T> Builder<T> withColumn(BindableColumn<T> column) {
+        return new Builder<T>().withColumn(column);
+    }
+
+    public static class Builder<T> extends AbstractBuilder<Builder<T>> {
+        private BindableColumn<T> column;
+        private VisitableCondition<T> condition;
+
+        public Builder<T> withColumn(BindableColumn<T> column) {
+            this.column = column;
+            return this;
+        }
+
+        public Builder<T> withCondition(VisitableCondition<T> condition) {
+            this.condition = condition;
+            return this;
+        }
+
+        @Override
+        protected Builder<T> getThis() {
+            return this;
+        }
+
+        public ColumnAndConditionCriterion<T> build() {
+            return new ColumnAndConditionCriterion<>(this);
+        }
+    }
+}

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

@@ -0,0 +1,54 @@
+/*
+ *    Copyright 2016-2020 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;
+
+import java.util.Objects;
+
+public class ExistsCriterion extends SqlCriterion {
+    private final ExistsPredicate existsPredicate;
+
+    private ExistsCriterion(Builder builder) {
+        super(builder);
+        this.existsPredicate = Objects.requireNonNull(builder.existsPredicate);
+    }
+
+    public ExistsPredicate existsPredicate() {
+        return existsPredicate;
+    }
+
+    @Override
+    public <R> R accept(SqlCriterionVisitor<R> visitor) {
+        return visitor.visit(this);
+    }
+
+    public static class Builder extends AbstractBuilder<Builder> {
+        private ExistsPredicate existsPredicate;
+
+        public Builder withExistsPredicate(ExistsPredicate existsPredicate) {
+            this.existsPredicate = existsPredicate;
+            return this;
+        }
+
+        public ExistsCriterion build() {
+            return new ExistsCriterion(this);
+        }
+
+        @Override
+        protected Builder getThis() {
+            return this;
+        }
+    }
+}

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

@@ -0,0 +1,50 @@
+/*
+ *    Copyright 2016-2020 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;
+
+import java.util.Objects;
+
+import org.jetbrains.annotations.NotNull;
+import org.mybatis.dynamic.sql.select.SelectModel;
+import org.mybatis.dynamic.sql.util.Buildable;
+
+public class ExistsPredicate {
+    private final Buildable<SelectModel> selectModelBuilder;
+    private final String operator;
+
+    private ExistsPredicate(String operator, Buildable<SelectModel> selectModelBuilder) {
+        this.selectModelBuilder = Objects.requireNonNull(selectModelBuilder);
+        this.operator = Objects.requireNonNull(operator);
+    }
+
+    public String operator() {
+        return operator;
+    }
+
+    public Buildable<SelectModel> selectModelBuilder() {
+        return selectModelBuilder;
+    }
+
+    @NotNull
+    public static ExistsPredicate exists(Buildable<SelectModel> selectModelBuilder) {
+        return new ExistsPredicate("exists", selectModelBuilder); //$NON-NLS-1$
+    }
+
+    @NotNull
+    public static ExistsPredicate notExists(Buildable<SelectModel> selectModelBuilder) {
+        return new ExistsPredicate("not exists", selectModelBuilder); //$NON-NLS-1$
+    }
+}

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

@@ -235,43 +235,81 @@ static <T> WhereDSL where(BindableColumn<T> column, VisitableCondition<T> condit
     }
 
     static <T> WhereDSL where(BindableColumn<T> column, VisitableCondition<T> condition,
-            SqlCriterion<?>... subCriteria) {
+            SqlCriterion... subCriteria) {
         return WhereDSL.where().where(column, condition, subCriteria);
     }
 
+    static WhereDSL where(ExistsPredicate existsPredicate) {
+        return WhereDSL.where().where(existsPredicate);
+    }
+
+    static WhereDSL where(ExistsPredicate existsPredicate, SqlCriterion... subCriteria) {
+        return WhereDSL.where().where(existsPredicate, subCriteria);
+    }
+
     // where condition connectors
-    static <T> SqlCriterion<T> or(BindableColumn<T> column, VisitableCondition<T> condition) {
-        return SqlCriterion.withColumn(column)
+    static <T> SqlCriterion or(BindableColumn<T> column, VisitableCondition<T> condition) {
+        return ColumnAndConditionCriterion.withColumn(column)
                 .withConnector("or") //$NON-NLS-1$
                 .withCondition(condition)
                 .build();
     }
 
-    static <T> SqlCriterion<T> or(BindableColumn<T> column, VisitableCondition<T> condition,
-            SqlCriterion<?>...subCriteria) {
-        return SqlCriterion.withColumn(column)
+    static <T> SqlCriterion or(BindableColumn<T> column, VisitableCondition<T> condition,
+            SqlCriterion...subCriteria) {
+        return ColumnAndConditionCriterion.withColumn(column)
                 .withConnector("or") //$NON-NLS-1$
                 .withCondition(condition)
                 .withSubCriteria(Arrays.asList(subCriteria))
                 .build();
     }
 
-    static <T> SqlCriterion<T> and(BindableColumn<T> column, VisitableCondition<T> condition) {
-        return SqlCriterion.withColumn(column)
+    static SqlCriterion or(ExistsPredicate existsPredicate) {
+        return new ExistsCriterion.Builder()
+                .withConnector("or") //$NON-NLS-1$
+                .withExistsPredicate(existsPredicate)
+                .build();
+    }
+
+    static SqlCriterion or(ExistsPredicate existsPredicate, SqlCriterion...subCriteria) {
+        return new ExistsCriterion.Builder()
+                .withConnector("or") //$NON-NLS-1$
+                .withExistsPredicate(existsPredicate)
+                .withSubCriteria(Arrays.asList(subCriteria))
+                .build();
+    }
+
+    static <T> SqlCriterion and(BindableColumn<T> column, VisitableCondition<T> condition) {
+        return ColumnAndConditionCriterion.withColumn(column)
                 .withConnector("and") //$NON-NLS-1$
                 .withCondition(condition)
                 .build();
     }
 
-    static <T> SqlCriterion<T> and(BindableColumn<T> column, VisitableCondition<T> condition,
-            SqlCriterion<?>...subCriteria) {
-        return SqlCriterion.withColumn(column)
+    static <T> SqlCriterion and(BindableColumn<T> column, VisitableCondition<T> condition,
+            SqlCriterion...subCriteria) {
+        return ColumnAndConditionCriterion.withColumn(column)
                 .withConnector("and") //$NON-NLS-1$
                 .withCondition(condition)
                 .withSubCriteria(Arrays.asList(subCriteria))
                 .build();
     }
 
+    static SqlCriterion and(ExistsPredicate existsPredicate) {
+        return new ExistsCriterion.Builder()
+                .withConnector("and") //$NON-NLS-1$
+                .withExistsPredicate(existsPredicate)
+                .build();
+    }
+
+    static SqlCriterion and(ExistsPredicate existsPredicate, SqlCriterion...subCriteria) {
+        return new ExistsCriterion.Builder()
+                .withConnector("and") //$NON-NLS-1$
+                .withExistsPredicate(existsPredicate)
+                .withSubCriteria(Arrays.asList(subCriteria))
+                .build();
+    }
+
     // join support
     static JoinCriterion and(BasicColumn joinColumn, JoinCondition joinCondition) {
         return new JoinCriterion.Builder()
@@ -375,6 +413,14 @@ static Upper upper(BindableColumn<String> column) {
     }
 
     // conditions for all data types
+    static ExistsPredicate exists(Buildable<SelectModel> selectModelBuilder) {
+        return ExistsPredicate.exists(selectModelBuilder);
+    }
+
+    static ExistsPredicate notExists(Buildable<SelectModel> selectModelBuilder) {
+        return ExistsPredicate.notExists(selectModelBuilder);
+    }
+
     static <T> IsNull<T> isNull() {
         return new IsNull<>();
     }