Kotlin support for not criteria group

jeffgbutler · jeffgbutler · commit 8f37d01af67e · 2022-01-17T17:28:13.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
@@ -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,13 @@ 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();
     }
@@ -291,13 +291,13 @@ static NotCriterion not(ExistsPredicate existsPredicate, List<AndOrCriteriaGroup
                 .build();
     }
 
-    static NotCriterion not(CriteriaGroup criteriaGroup, AndOrCriteriaGroup...subCriteria) {
-        return not(criteriaGroup, Arrays.asList(subCriteria));
+    static NotCriterion not(SqlCriterion initialCriterion, AndOrCriteriaGroup...subCriteria) {
+        return not(initialCriterion, Arrays.asList(subCriteria));
     }
 
-    static NotCriterion not(CriteriaGroup criteriaGroup, List<AndOrCriteriaGroup> subCriteria) {
+    static NotCriterion not(SqlCriterion initialCriterion, List<AndOrCriteriaGroup> subCriteria) {
         return new NotCriterion.Builder()
-                .withInitialCriterion(criteriaGroup)
+                .withInitialCriterion(initialCriterion)
                 .withSubCriteria(subCriteria)
                 .build();
     }
@@ -322,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();
     }
@@ -350,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/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinBaseBuilders.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/KotlinBaseBuilders.kt
@@ -16,9 +16,9 @@
 package org.mybatis.dynamic.sql.util.kotlin
 
 import org.mybatis.dynamic.sql.BindableColumn
-import org.mybatis.dynamic.sql.CriteriaGroup
 import org.mybatis.dynamic.sql.AndOrCriteriaGroup
 import org.mybatis.dynamic.sql.ExistsPredicate
+import org.mybatis.dynamic.sql.SqlCriterion
 import org.mybatis.dynamic.sql.SqlTable
 import org.mybatis.dynamic.sql.VisitableCondition
 import org.mybatis.dynamic.sql.select.AbstractQueryExpressionDSL
@@ -49,9 +49,9 @@ abstract class KotlinBaseBuilder<D : AbstractWhereSupport<*>, B : KotlinBaseBuil
             where(existsPredicate, sc)
         }
 
-    fun where(criteriaGroup: CriteriaGroup, subCriteria: CriteriaReceiver): B =
+    fun where(initialCriterion: SqlCriterion, subCriteria: CriteriaReceiver = {}): B =
         applyToWhere(subCriteria) { sc ->
-            where(criteriaGroup, sc)
+            where(initialCriterion, sc)
         }
 
     fun applyWhere(whereApplier: WhereApplier): B =
@@ -69,9 +69,9 @@ abstract class KotlinBaseBuilder<D : AbstractWhereSupport<*>, B : KotlinBaseBuil
             and(existsPredicate, sc)
         }
 
-    fun and(criteriaGroup: CriteriaGroup, subCriteria: CriteriaReceiver): B =
+    fun and(initialCriterion: SqlCriterion, subCriteria: CriteriaReceiver = {}): B =
         applyToWhere(subCriteria) { sc ->
-            and(criteriaGroup, sc)
+            and(initialCriterion, sc)
         }
 
     fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>, subCriteria: CriteriaReceiver = {}): B =
@@ -84,9 +84,9 @@ abstract class KotlinBaseBuilder<D : AbstractWhereSupport<*>, B : KotlinBaseBuil
             or(existsPredicate, sc)
         }
 
-    fun or(criteriaGroup: CriteriaGroup, subCriteria: CriteriaReceiver): B =
+    fun or(initialCriterion: SqlCriterion, subCriteria: CriteriaReceiver = {}): B =
         applyToWhere(subCriteria) { sc ->
-            or(criteriaGroup, sc)
+            or(initialCriterion, sc)
         }
 
     fun allRows(): B = self()
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/elements/SqlElements.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/elements/SqlElements.kt
@@ -21,9 +21,11 @@ import org.mybatis.dynamic.sql.BindableColumn
 import org.mybatis.dynamic.sql.Constant
 import org.mybatis.dynamic.sql.CriteriaGroup
 import org.mybatis.dynamic.sql.ExistsPredicate
+import org.mybatis.dynamic.sql.NotCriterion
 import org.mybatis.dynamic.sql.SortSpecification
 import org.mybatis.dynamic.sql.SqlBuilder
 import org.mybatis.dynamic.sql.SqlColumn
+import org.mybatis.dynamic.sql.SqlCriterion
 import org.mybatis.dynamic.sql.StringConstant
 import org.mybatis.dynamic.sql.VisitableCondition
 import org.mybatis.dynamic.sql.select.aggregate.Avg
@@ -150,7 +152,7 @@ fun <T> substring(
 
 fun <T> upper(column: BindableColumn<T>): Upper<T> = SqlBuilder.upper(column)
 
-fun group(initialCriterion: CriteriaGroup, subCriteria: CriteriaReceiver): CriteriaGroup =
+fun group(initialCriterion: SqlCriterion, subCriteria: CriteriaReceiver): CriteriaGroup =
     SqlBuilder.group(initialCriterion, CriteriaCollector().apply(subCriteria).criteria)
 
 fun group(existsPredicate: ExistsPredicate, subCriteria: CriteriaReceiver): CriteriaGroup =
@@ -163,6 +165,19 @@ fun <T> group(
 ): CriteriaGroup =
     SqlBuilder.group(column, condition, CriteriaCollector().apply(subCriteria).criteria)
 
+fun not(initialCriterion: SqlCriterion, subCriteria: CriteriaReceiver = {}): NotCriterion =
+    SqlBuilder.not(initialCriterion, CriteriaCollector().apply(subCriteria).criteria)
+
+fun not(existsPredicate: ExistsPredicate, subCriteria: CriteriaReceiver = {}): NotCriterion =
+    SqlBuilder.not(existsPredicate, CriteriaCollector().apply(subCriteria).criteria)
+
+fun <T> not(
+    column: BindableColumn<T>,
+    condition: VisitableCondition<T>,
+    subCriteria: CriteriaReceiver = {}
+): NotCriterion =
+    SqlBuilder.not(column, condition, CriteriaCollector().apply(subCriteria).criteria)
+
 // conditions for all data types
 fun <T> isNull(): IsNull<T> = SqlBuilder.isNull()
 
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/canonical/PersonMapperTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/canonical/PersonMapperTest.kt
@@ -45,6 +45,7 @@ import org.mybatis.dynamic.sql.util.kotlin.elements.isLike
 import org.mybatis.dynamic.sql.util.kotlin.elements.isNotLike
 import org.mybatis.dynamic.sql.util.kotlin.elements.isNull
 import org.mybatis.dynamic.sql.util.kotlin.elements.isTrue
+import org.mybatis.dynamic.sql.util.kotlin.elements.not
 import org.mybatis.dynamic.sql.util.kotlin.mybatis3.insertInto
 import org.mybatis.dynamic.sql.util.kotlin.mybatis3.select
 import java.io.InputStreamReader
@@ -169,6 +170,21 @@ class PersonMapperTest {
         }
     }
 
+    @Test
+    fun testFirstNameNotIn() {
+        newSession().use { session ->
+            val mapper = session.getMapper(PersonMapper::class.java)
+
+            val rows = mapper.select {
+                where(not(firstName, isIn("Fred", "Barney")))
+            }
+
+            assertThat(rows).hasSize(4)
+            assertThat(rows[0].firstName).isEqualTo("Wilma")
+            assertThat(rows[1].firstName).isEqualTo("Pebbles")
+        }
+    }
+
     @Test
     fun testDelete() {
         newSession().use { session ->
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/general/KGroupingTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/general/KGroupingTest.kt
@@ -26,7 +26,9 @@ import org.mybatis.dynamic.sql.util.kotlin.elements.exists
 import org.mybatis.dynamic.sql.util.kotlin.elements.group
 import org.mybatis.dynamic.sql.util.kotlin.elements.isEqualTo
 import org.mybatis.dynamic.sql.util.kotlin.elements.isGreaterThan
+import org.mybatis.dynamic.sql.util.kotlin.elements.isGreaterThanOrEqualTo
 import org.mybatis.dynamic.sql.util.kotlin.elements.isLessThan
+import org.mybatis.dynamic.sql.util.kotlin.elements.not
 import org.mybatis.dynamic.sql.util.kotlin.mybatis3.select
 
 object FooDynamicSqlSupport {
@@ -216,4 +218,38 @@ class KGroupingTest {
         assertThat(selectStatement.parameters).containsEntry("p8", 0)
         assertThat(selectStatement.parameters).containsEntry("p9", 2)
     }
+
+    @Test
+    fun testNotGroupAndOrCriteriaGroups() {
+        val selectStatement = select(A, B, C) {
+            from(foo)
+            where(not(group(B, isEqualTo(4)) {
+                and(C, isLessThan(5))
+            }) {
+                and(A, isGreaterThan(3))
+            })
+            and(not(A, isGreaterThan(4)))
+            or(
+                not(
+                    group(C, isLessThan(6)) {
+                        and(A, isGreaterThanOrEqualTo(7))
+                    }
+                )
+            )
+        }
+
+        val expected = "select A, B, C" +
+                " from Foo" +
+                " where not ((B = #{parameters.p1} and C < #{parameters.p2}) and A > #{parameters.p3})" +
+                " and not A > #{parameters.p4}" +
+                " or not (C < #{parameters.p5} and A >= #{parameters.p6})"
+
+        assertThat(selectStatement.selectStatement).isEqualTo(expected)
+        assertThat(selectStatement.parameters).containsEntry("p1", 4)
+        assertThat(selectStatement.parameters).containsEntry("p2", 5)
+        assertThat(selectStatement.parameters).containsEntry("p3", 3)
+        assertThat(selectStatement.parameters).containsEntry("p4", 4)
+        assertThat(selectStatement.parameters).containsEntry("p5", 6)
+        assertThat(selectStatement.parameters).containsEntry("p6", 7)
+    }
 }
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/joins/ExistsTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/joins/ExistsTest.kt
@@ -29,6 +29,7 @@ import org.junit.jupiter.api.Test
 import org.mybatis.dynamic.sql.util.kotlin.elements.exists
 import org.mybatis.dynamic.sql.util.kotlin.elements.isEqualTo
 import org.mybatis.dynamic.sql.util.kotlin.elements.isGreaterThan
+import org.mybatis.dynamic.sql.util.kotlin.elements.not
 import org.mybatis.dynamic.sql.util.kotlin.elements.notExists
 import org.mybatis.dynamic.sql.util.kotlin.mybatis3.select
 import org.mybatis.dynamic.sql.util.mybatis3.CommonSelectMapper
@@ -130,6 +131,39 @@ class ExistsTest {
         }
     }
 
+    @Test
+    fun testNotExistsNewNot() {
+        newSession().use { session ->
+            val mapper = session.getMapper(CommonSelectMapper::class.java)
+
+            val selectStatement = select(itemMaster.allColumns()) {
+                from(itemMaster, "im")
+                where(
+                    not(exists {
+                        select(orderLine.allColumns()) {
+                            from(orderLine, "ol")
+                            where(orderLine.itemId, isEqualTo(itemMaster.itemId.qualifiedWith("im")))
+                        }
+                    })
+                )
+                orderBy(itemMaster.itemId)
+            }
+
+            val expectedStatement: String = "select im.* from ItemMaster im" +
+                    " where not exists (select ol.* from OrderLine ol where ol.item_id = im.item_id)" +
+                    " order by item_id"
+            assertThat(selectStatement.selectStatement).isEqualTo(expectedStatement)
+
+            val rows = mapper.selectManyMappedRows(selectStatement)
+            assertThat(rows).hasSize(1)
+
+            with(rows[0]) {
+                assertThat(this).containsEntry("ITEM_ID", 55)
+                assertThat(this).containsEntry("DESCRIPTION", "Catcher Glove")
+            }
+        }
+    }
+
     @Test
     fun testAndExists() {
         newSession().use { session ->

Original file line number	Diff line number	Diff line change
`@@ -219,8 +219,8 @@ static <T> WhereDSL where(BindableColumn<T> column, VisitableCondition<T> condit`
`219`	`219`	`return WhereDSL.where().where(column, condition, subCriteria);`
`220`	`220`	`}`
`221`	`221`
`222`		`- static WhereDSL where(CriteriaGroup criteriaGroup, AndOrCriteriaGroup... subCriteria) {`
`223`		`- return WhereDSL.where().where(criteriaGroup, subCriteria);`
	`222`	`+ static WhereDSL where(SqlCriterion initialCriterion, AndOrCriteriaGroup... subCriteria) {`
	`223`	`+ return WhereDSL.where().where(initialCriterion, subCriteria);`
`224`	`224`	`}`
`225`	`225`
`226`	`226`	`static WhereDSL where(ExistsPredicate existsPredicate, AndOrCriteriaGroup... subCriteria) {`
`@@ -254,13 +254,13 @@ static CriteriaGroup group(ExistsPredicate existsPredicate, List<AndOrCriteriaGr`
`254`	`254`	`.build();`
`255`	`255`	`}`
`256`	`256`
`257`		`- static CriteriaGroup group(CriteriaGroup criteriaGroup, AndOrCriteriaGroup...subCriteria) {`
`258`		`- return group(criteriaGroup, Arrays.asList(subCriteria));`
	`257`	`+ static CriteriaGroup group(SqlCriterion initialCriterion, AndOrCriteriaGroup...subCriteria) {`
	`258`	`+ return group(initialCriterion, Arrays.asList(subCriteria));`
`259`	`259`	`}`
`260`	`260`
`261`		`- static CriteriaGroup group(CriteriaGroup criteriaGroup, List<AndOrCriteriaGroup> subCriteria) {`
	`261`	`+ static CriteriaGroup group(SqlCriterion initialCriterion, List<AndOrCriteriaGroup> subCriteria) {`
`262`	`262`	`return new CriteriaGroup.Builder()`
`263`		`- .withInitialCriterion(criteriaGroup)`
	`263`	`+ .withInitialCriterion(initialCriterion)`
`264`	`264`	`.withSubCriteria(subCriteria)`
`265`	`265`	`.build();`
`266`	`266`	`}`
`@@ -291,13 +291,13 @@ static NotCriterion not(ExistsPredicate existsPredicate, List<AndOrCriteriaGroup`
`291`	`291`	`.build();`
`292`	`292`	`}`
`293`	`293`
`294`		`- static NotCriterion not(CriteriaGroup criteriaGroup, AndOrCriteriaGroup...subCriteria) {`
`295`		`- return not(criteriaGroup, Arrays.asList(subCriteria));`
	`294`	`+ static NotCriterion not(SqlCriterion initialCriterion, AndOrCriteriaGroup...subCriteria) {`
	`295`	`+ return not(initialCriterion, Arrays.asList(subCriteria));`
`296`	`296`	`}`
`297`	`297`
`298`		`- static NotCriterion not(CriteriaGroup criteriaGroup, List<AndOrCriteriaGroup> subCriteria) {`
	`298`	`+ static NotCriterion not(SqlCriterion initialCriterion, List<AndOrCriteriaGroup> subCriteria) {`
`299`	`299`	`return new NotCriterion.Builder()`
`300`		`- .withInitialCriterion(criteriaGroup)`
	`300`	`+ .withInitialCriterion(initialCriterion)`
`301`	`301`	`.withSubCriteria(subCriteria)`
`302`	`302`	`.build();`
`303`	`303`	`}`
`@@ -322,10 +322,10 @@ static AndOrCriteriaGroup or(ExistsPredicate existsPredicate, AndOrCriteriaGroup`
`322`	`322`	`.build();`
`323`	`323`	`}`
`324`	`324`
`325`		`- static AndOrCriteriaGroup or(CriteriaGroup criteriaGroup, AndOrCriteriaGroup...subCriteria) {`
	`325`	`+ static AndOrCriteriaGroup or(SqlCriterion initialCriterion, AndOrCriteriaGroup...subCriteria) {`
`326`	`326`	`return new AndOrCriteriaGroup.Builder()`
`327`	`327`	`.withConnector("or") //$NON-NLS-1$`
`328`		`- .withInitialCriterion(criteriaGroup)`
	`328`	`+ .withInitialCriterion(initialCriterion)`
`329`	`329`	`.withSubCriteria(Arrays.asList(subCriteria))`
`330`	`330`	`.build();`
`331`	`331`	`}`
`@@ -350,10 +350,10 @@ static AndOrCriteriaGroup and(ExistsPredicate existsPredicate, AndOrCriteriaGrou`
`350`	`350`	`.build();`
`351`	`351`	`}`
`352`	`352`
`353`		`- static AndOrCriteriaGroup and(CriteriaGroup criteriaGroup, AndOrCriteriaGroup...subCriteria) {`
	`353`	`+ static AndOrCriteriaGroup and(SqlCriterion initialCriterion, AndOrCriteriaGroup...subCriteria) {`
`354`	`354`	`return new AndOrCriteriaGroup.Builder()`
`355`	`355`	`.withConnector("and") //$NON-NLS-1$`
`356`		`- .withInitialCriterion(criteriaGroup)`
	`356`	`+ .withInitialCriterion(initialCriterion)`
`357`	`357`	`.withSubCriteria(Arrays.asList(subCriteria))`
`358`	`358`	`.build();`
`359`	`359`	`}`