Merge pull request #438 from jeffgbutler/not-criteria

Add Support for a "not" Criteria Group for Where Clauses
mybatis · Jan 18, 2022 · 8739524 · 8739524
2 parents 33c69f3 + e331b60
commit 8739524
Show file tree

Hide file tree

Showing 16 changed files with 451 additions and 136 deletions.
diff --git a/src/main/java/org/mybatis/dynamic/sql/CriteriaGroup.java b/src/main/java/org/mybatis/dynamic/sql/CriteriaGroup.java
@@ -28,7 +28,7 @@
 public class CriteriaGroup extends SqlCriterion {
     private final SqlCriterion initialCriterion;
 
-    private CriteriaGroup(Builder builder) {
+    protected CriteriaGroup(AbstractGroupBuilder<?> builder) {
         super(builder);
         initialCriterion = Objects.requireNonNull(builder.initialCriterion);
     }
@@ -42,14 +42,16 @@ public <R> R accept(SqlCriterionVisitor<R> visitor) {
         return visitor.visit(this);
     }
 
-    public static class Builder extends AbstractBuilder<Builder> {
+    public abstract static class AbstractGroupBuilder<T extends AbstractGroupBuilder<T>> extends AbstractBuilder<T> {
         private SqlCriterion initialCriterion;
 
-        public Builder withInitialCriterion(SqlCriterion initialCriterion) {
+        public T withInitialCriterion(SqlCriterion initialCriterion) {
             this.initialCriterion = initialCriterion;
-            return this;
+            return getThis();
         }
+    }
 
+    public static class Builder extends AbstractGroupBuilder<Builder> {
         public CriteriaGroup build() {
             return new CriteriaGroup(this);
         }

diff --git a/src/main/java/org/mybatis/dynamic/sql/NotCriterion.java b/src/main/java/org/mybatis/dynamic/sql/NotCriterion.java
@@ -0,0 +1,44 @@
+/*
+ *    Copyright 2016-2022 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;
+
+/**
+ * This class represents a criteria group with a NOT.
+ *
+ * @author Jeff Butler
+ * @since 1.4.0
+ */
+public class NotCriterion extends CriteriaGroup {
+    private NotCriterion(Builder builder) {
+        super(builder);
+    }
+
+    @Override
+    public <R> R accept(SqlCriterionVisitor<R> visitor) {
+        return visitor.visit(this);
+    }
+
+    public static class Builder extends AbstractGroupBuilder<Builder> {
+        public NotCriterion build() {
+            return new NotCriterion(this);
+        }
+
+        @Override
+        protected Builder getThis() {
+            return this;
+        }
+    }
+}
diff --git a/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java b/src/main/java/org/mybatis/dynamic/sql/SqlBuilder.java
@@ -219,8 +219,8 @@ static <T> WhereDSL where(BindableColumn<T> column, VisitableCondition<T> condit
         return WhereDSL.where().where(column, condition, subCriteria);
     }
 
-    static WhereDSL where(CriteriaGroup criteriaGroup, AndOrCriteriaGroup... subCriteria) {
-        return WhereDSL.where().where(criteriaGroup, subCriteria);
+    static WhereDSL where(SqlCriterion initialCriterion, AndOrCriteriaGroup... subCriteria) {
+        return WhereDSL.where().where(initialCriterion, subCriteria);
     }
 
     static WhereDSL where(ExistsPredicate existsPredicate, AndOrCriteriaGroup... subCriteria) {
@@ -254,13 +254,50 @@ static CriteriaGroup group(ExistsPredicate existsPredicate, List<AndOrCriteriaGr
                 .build();
     }
 
-    static CriteriaGroup group(CriteriaGroup criteriaGroup, AndOrCriteriaGroup...subCriteria) {
-        return group(criteriaGroup, Arrays.asList(subCriteria));
+    static CriteriaGroup group(SqlCriterion initialCriterion, AndOrCriteriaGroup...subCriteria) {
+        return group(initialCriterion, Arrays.asList(subCriteria));
     }
 
-    static CriteriaGroup group(CriteriaGroup criteriaGroup, List<AndOrCriteriaGroup> subCriteria) {
+    static CriteriaGroup group(SqlCriterion initialCriterion, List<AndOrCriteriaGroup> subCriteria) {
         return new CriteriaGroup.Builder()
-                .withInitialCriterion(criteriaGroup)
+                .withInitialCriterion(initialCriterion)
+                .withSubCriteria(subCriteria)
+                .build();
+    }
+
+    static <T> NotCriterion not(BindableColumn<T> column, VisitableCondition<T> condition,
+                                AndOrCriteriaGroup...subCriteria) {
+        return not(column, condition, Arrays.asList(subCriteria));
+    }
+
+    static <T> NotCriterion not(BindableColumn<T> column, VisitableCondition<T> condition,
+                                List<AndOrCriteriaGroup> subCriteria) {
+        return new NotCriterion.Builder()
+                .withInitialCriterion(new ColumnAndConditionCriterion.Builder<T>().withColumn(column)
+                        .withCondition(condition).build())
+                .withSubCriteria(subCriteria)
+                .build();
+    }
+
+    static NotCriterion not(ExistsPredicate existsPredicate, AndOrCriteriaGroup...subCriteria) {
+        return not(existsPredicate, Arrays.asList(subCriteria));
+    }
+
+    static NotCriterion not(ExistsPredicate existsPredicate, List<AndOrCriteriaGroup> subCriteria) {
+        return new NotCriterion.Builder()
+                .withInitialCriterion(new ExistsCriterion.Builder()
+                        .withExistsPredicate(existsPredicate).build())
+                .withSubCriteria(subCriteria)
+                .build();
+    }
+
+    static NotCriterion not(SqlCriterion initialCriterion, AndOrCriteriaGroup...subCriteria) {
+        return not(initialCriterion, Arrays.asList(subCriteria));
+    }
+
+    static NotCriterion not(SqlCriterion initialCriterion, List<AndOrCriteriaGroup> subCriteria) {
+        return new NotCriterion.Builder()
+                .withInitialCriterion(initialCriterion)
                 .withSubCriteria(subCriteria)
                 .build();
     }
@@ -285,10 +322,10 @@ static AndOrCriteriaGroup or(ExistsPredicate existsPredicate, AndOrCriteriaGroup
                 .build();
     }
 
-    static AndOrCriteriaGroup or(CriteriaGroup criteriaGroup, AndOrCriteriaGroup...subCriteria) {
+    static AndOrCriteriaGroup or(SqlCriterion initialCriterion, AndOrCriteriaGroup...subCriteria) {
         return new AndOrCriteriaGroup.Builder()
                 .withConnector("or") //$NON-NLS-1$
-                .withInitialCriterion(criteriaGroup)
+                .withInitialCriterion(initialCriterion)
                 .withSubCriteria(Arrays.asList(subCriteria))
                 .build();
     }
@@ -313,10 +350,10 @@ static AndOrCriteriaGroup and(ExistsPredicate existsPredicate, AndOrCriteriaGrou
                 .build();
     }
 
-    static AndOrCriteriaGroup and(CriteriaGroup criteriaGroup, AndOrCriteriaGroup...subCriteria) {
+    static AndOrCriteriaGroup and(SqlCriterion initialCriterion, AndOrCriteriaGroup...subCriteria) {
         return new AndOrCriteriaGroup.Builder()
                 .withConnector("and") //$NON-NLS-1$
-                .withInitialCriterion(criteriaGroup)
+                .withInitialCriterion(initialCriterion)
                 .withSubCriteria(Arrays.asList(subCriteria))
                 .build();
     }

diff --git a/src/main/java/org/mybatis/dynamic/sql/SqlCriterionVisitor.java b/src/main/java/org/mybatis/dynamic/sql/SqlCriterionVisitor.java
@@ -21,4 +21,6 @@ public interface SqlCriterionVisitor<R> {
     R visit(ExistsCriterion criterion);
 
     R visit(CriteriaGroup criterion);
+
+    R visit(NotCriterion criterion);
 }
diff --git a/src/main/java/org/mybatis/dynamic/sql/where/AbstractWhereDSL.java b/src/main/java/org/mybatis/dynamic/sql/where/AbstractWhereDSL.java
@@ -58,13 +58,13 @@ public T where(ExistsPredicate existsPredicate, List<AndOrCriteriaGroup> subCrit
     }
 
     @NotNull
-    public T where(CriteriaGroup criterion, AndOrCriteriaGroup...subCriteria) {
-        return where(criterion, Arrays.asList(subCriteria));
+    public T where(SqlCriterion initialCriterion, AndOrCriteriaGroup...subCriteria) {
+        return where(initialCriterion, Arrays.asList(subCriteria));
     }
 
     @NotNull
-    public T where(CriteriaGroup criterion, List<AndOrCriteriaGroup> subCriteria) {
-        initialCriterion = buildCriterion(criterion, subCriteria);
+    public T where(SqlCriterion initialCriterion, List<AndOrCriteriaGroup> subCriteria) {
+        this.initialCriterion = buildCriterion(initialCriterion, subCriteria);
         return getThis();
     }
 
@@ -83,7 +83,7 @@ public <S> T and(BindableColumn<S> column, VisitableCondition<S> condition,
     @NotNull
     public <S> T and(BindableColumn<S> column, VisitableCondition<S> condition,
                      List<AndOrCriteriaGroup> subCriteria) {
-        addCriteriaGroup("and", buildCriterion(column, condition), subCriteria);
+        addSubCriteria("and", buildCriterion(column, condition), subCriteria);
         return getThis();
     }
 
@@ -94,18 +94,18 @@ public T and(ExistsPredicate existsPredicate, AndOrCriteriaGroup...subCriteria)
 
     @NotNull
     public T and(ExistsPredicate existsPredicate, List<AndOrCriteriaGroup> subCriteria) {
-        addCriteriaGroup("and", buildCriterion(existsPredicate), subCriteria);
+        addSubCriteria("and", buildCriterion(existsPredicate), subCriteria);
         return getThis();
     }
 
     @NotNull
-    public T and(CriteriaGroup criteriaGroup, AndOrCriteriaGroup...subCriteria) {
-        return and(criteriaGroup, Arrays.asList(subCriteria));
+    public T and(SqlCriterion initialCriterion, AndOrCriteriaGroup...subCriteria) {
+        return and(initialCriterion, Arrays.asList(subCriteria));
     }
 
     @NotNull
-    public T and(CriteriaGroup criteriaGroup, List<AndOrCriteriaGroup> subCriteria) {
-        addCriteriaGroup("and", buildCriterion(criteriaGroup), subCriteria);
+    public T and(SqlCriterion initialCriterion, List<AndOrCriteriaGroup> subCriteria) {
+        addSubCriteria("and", buildCriterion(initialCriterion), subCriteria);
         return getThis();
     }
 
@@ -118,7 +118,7 @@ public <S> T or(BindableColumn<S> column, VisitableCondition<S> condition,
     @NotNull
     public <S> T or(BindableColumn<S> column, VisitableCondition<S> condition,
                     List<AndOrCriteriaGroup> subCriteria) {
-        addCriteriaGroup("or", buildCriterion(column, condition), subCriteria);
+        addSubCriteria("or", buildCriterion(column, condition), subCriteria);
         return getThis();
     }
 
@@ -129,57 +129,56 @@ public T or(ExistsPredicate existsPredicate, AndOrCriteriaGroup...subCriteria) {
 
     @NotNull
     public T or(ExistsPredicate existsPredicate, List<AndOrCriteriaGroup> subCriteria) {
-        addCriteriaGroup("or", buildCriterion(existsPredicate), subCriteria);
+        addSubCriteria("or", buildCriterion(existsPredicate), subCriteria);
         return getThis();
     }
 
     @NotNull
-    public T or(CriteriaGroup criteriaGroup, AndOrCriteriaGroup...subCriteria) {
-        return or(criteriaGroup, Arrays.asList(subCriteria));
+    public T or(SqlCriterion initialCriterion, AndOrCriteriaGroup...subCriteria) {
+        return or(initialCriterion, Arrays.asList(subCriteria));
     }
 
     @NotNull
-    public T or(CriteriaGroup criteriaGroup, List<AndOrCriteriaGroup> subCriteria) {
-        addCriteriaGroup("or", buildCriterion(criteriaGroup), subCriteria);
+    public T or(SqlCriterion initialCriterion, List<AndOrCriteriaGroup> subCriteria) {
+        addSubCriteria("or", buildCriterion(initialCriterion), subCriteria);
         return getThis();
     }
 
     protected WhereModel internalBuild() {
         return new WhereModel(initialCriterion, subCriteria);
     }
 
-    private <R> ColumnAndConditionCriterion<R> buildCriterion(BindableColumn<R> column,
-                                                              VisitableCondition<R> condition) {
+    private <R> SqlCriterion buildCriterion(BindableColumn<R> column, VisitableCondition<R> condition) {
         return ColumnAndConditionCriterion.withColumn(column).withCondition(condition).build();
     }
 
-    private <R> ColumnAndConditionCriterion<R> buildCriterion(BindableColumn<R> column, VisitableCondition<R> condition,
-                                                              List<AndOrCriteriaGroup> subCriteria) {
+    private <R> SqlCriterion buildCriterion(BindableColumn<R> column, VisitableCondition<R> condition,
+                                            List<AndOrCriteriaGroup> subCriteria) {
         return ColumnAndConditionCriterion.withColumn(column)
                 .withCondition(condition)
                 .withSubCriteria(subCriteria)
                 .build();
     }
 
-    private ExistsCriterion buildCriterion(ExistsPredicate existsPredicate) {
+    private SqlCriterion buildCriterion(ExistsPredicate existsPredicate) {
         return new ExistsCriterion.Builder().withExistsPredicate(existsPredicate).build();
     }
 
-    private ExistsCriterion buildCriterion(ExistsPredicate existsPredicate,
-                                           List<AndOrCriteriaGroup> subCriteria) {
+    private SqlCriterion buildCriterion(ExistsPredicate existsPredicate,
+                                        List<AndOrCriteriaGroup> subCriteria) {
         return new ExistsCriterion.Builder().withExistsPredicate(existsPredicate).withSubCriteria(subCriteria).build();
     }
 
-    private CriteriaGroup buildCriterion(CriteriaGroup criteriaGroup) {
-        return new CriteriaGroup.Builder().withInitialCriterion(criteriaGroup).build();
+    private SqlCriterion buildCriterion(SqlCriterion initialCriterion) {
+        return new CriteriaGroup.Builder().withInitialCriterion(initialCriterion).build();
     }
 
-    private CriteriaGroup buildCriterion(CriteriaGroup criteriaGroup, List<AndOrCriteriaGroup> subCriteria) {
-        return new CriteriaGroup.Builder().withInitialCriterion(criteriaGroup).withSubCriteria(subCriteria).build();
+    private SqlCriterion buildCriterion(SqlCriterion initialCriterion, List<AndOrCriteriaGroup> subCriteria) {
+        return new CriteriaGroup.Builder().withInitialCriterion(initialCriterion).withSubCriteria(subCriteria).build();
     }
 
-    private void addCriteriaGroup(String connector, SqlCriterion initialCriterion,
-                                  List<AndOrCriteriaGroup> subCriteria) {
+    private void addSubCriteria(String connector, SqlCriterion initialCriterion,
+                                List<AndOrCriteriaGroup> subCriteria) {
         this.subCriteria.add(new AndOrCriteriaGroup.Builder()
                 .withInitialCriterion(initialCriterion)
                 .withConnector(connector)

diff --git a/src/main/java/org/mybatis/dynamic/sql/where/AbstractWhereSupport.java b/src/main/java/org/mybatis/dynamic/sql/where/AbstractWhereSupport.java
@@ -21,8 +21,8 @@
 
 import org.mybatis.dynamic.sql.AndOrCriteriaGroup;
 import org.mybatis.dynamic.sql.BindableColumn;
-import org.mybatis.dynamic.sql.CriteriaGroup;
 import org.mybatis.dynamic.sql.ExistsPredicate;
+import org.mybatis.dynamic.sql.SqlCriterion;
 import org.mybatis.dynamic.sql.VisitableCondition;
 
 /**
@@ -54,12 +54,12 @@ public W where(ExistsPredicate existsPredicate, List<AndOrCriteriaGroup> subCrit
         return apply(w -> w.where(existsPredicate, subCriteria));
     }
 
-    public W where(CriteriaGroup criterion, AndOrCriteriaGroup...subCriteria) {
-        return where(criterion, Arrays.asList(subCriteria));
+    public W where(SqlCriterion initialCriterion, AndOrCriteriaGroup...subCriteria) {
+        return where(initialCriterion, Arrays.asList(subCriteria));
     }
 
-    public W where(CriteriaGroup criterion, List<AndOrCriteriaGroup> subCriteria) {
-        return apply(w -> w.where(criterion, subCriteria));
+    public W where(SqlCriterion initialCriterion, List<AndOrCriteriaGroup> subCriteria) {
+        return apply(w -> w.where(initialCriterion, subCriteria));
     }
 
     public W applyWhere(WhereApplier whereApplier) {