Move all criteria group support to the new collector

jeffgbutler · jeffgbutler · commit 7e6d571c3f56 · 2022-01-26T15:23:48.000-05:00
diff --git a/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/CriteriaCollector.kt b/src/main/kotlin/org/mybatis/dynamic/sql/util/kotlin/CriteriaCollector.kt
@@ -17,7 +17,6 @@ package org.mybatis.dynamic.sql.util.kotlin
 
 import org.mybatis.dynamic.sql.BindableColumn
 import org.mybatis.dynamic.sql.ColumnAndConditionCriterion
-import org.mybatis.dynamic.sql.CriteriaGroup
 import org.mybatis.dynamic.sql.AndOrCriteriaGroup
 import org.mybatis.dynamic.sql.ExistsCriterion
 import org.mybatis.dynamic.sql.ExistsPredicate
@@ -40,9 +39,6 @@ class CriteriaCollector {
     fun and(existsPredicate: ExistsPredicate, criteriaReceiver: CriteriaReceiver = {}): CriteriaCollector =
         addCriteriaGroup("and", buildCriterion(existsPredicate), criteriaReceiver)
 
-    fun and(criteriaGroup: CriteriaGroup, criteriaReceiver: CriteriaReceiver): CriteriaCollector =
-        addCriteriaGroup("and", buildCriterion(criteriaGroup), criteriaReceiver)
-
     fun <T> or(
         column: BindableColumn<T>,
         condition: VisitableCondition<T>,
@@ -53,9 +49,6 @@ class CriteriaCollector {
     fun or(existsPredicate: ExistsPredicate, criteriaReceiver: CriteriaReceiver = {}): CriteriaCollector =
         addCriteriaGroup("or", buildCriterion(existsPredicate), criteriaReceiver)
 
-    fun or(criteriaGroup: CriteriaGroup, criteriaReceiver: CriteriaReceiver): CriteriaCollector =
-        addCriteriaGroup("or", buildCriterion(criteriaGroup), criteriaReceiver)
-
     private fun <T> buildCriterion(
         column: BindableColumn<T>,
         condition: VisitableCondition<T>
@@ -65,9 +58,6 @@ class CriteriaCollector {
     private fun buildCriterion(existsPredicate: ExistsPredicate): ExistsCriterion =
         ExistsCriterion.Builder().withExistsPredicate(existsPredicate).build()
 
-    private fun buildCriterion(criteriaGroup: CriteriaGroup): CriteriaGroup =
-        CriteriaGroup.Builder().withInitialCriterion(criteriaGroup).build()
-
     private fun addCriteriaGroup(
         connector: String,
         initialCriterion: SqlCriterion,
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
@@ -18,7 +18,6 @@ package org.mybatis.dynamic.sql.util.kotlin
 import org.mybatis.dynamic.sql.BindableColumn
 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
@@ -67,11 +66,6 @@ abstract class KotlinBaseBuilder<D : AbstractWhereSupport<*>, B : KotlinBaseBuil
             where(existsPredicate, sc)
         }
 
-    fun where(initialCriterion: SqlCriterion, subCriteria: CriteriaReceiver = {}): B =
-        applyToWhere(subCriteria) { sc ->
-            where(initialCriterion, sc)
-        }
-
     fun applyWhere(whereApplier: WhereApplier): B =
         self().apply {
             whereApplier.invoke(this)
@@ -87,11 +81,6 @@ abstract class KotlinBaseBuilder<D : AbstractWhereSupport<*>, B : KotlinBaseBuil
             and(existsPredicate, sc)
         }
 
-    fun and(initialCriterion: SqlCriterion, subCriteria: CriteriaReceiver = {}): B =
-        applyToWhere(subCriteria) { sc ->
-            and(initialCriterion, sc)
-        }
-
     fun <T> or(column: BindableColumn<T>, condition: VisitableCondition<T>, subCriteria: CriteriaReceiver = {}): B =
         applyToWhere(subCriteria) { sc ->
             or(column, condition, sc)
@@ -102,11 +91,6 @@ abstract class KotlinBaseBuilder<D : AbstractWhereSupport<*>, B : KotlinBaseBuil
             or(existsPredicate, sc)
         }
 
-    fun or(initialCriterion: SqlCriterion, subCriteria: CriteriaReceiver = {}): B =
-        applyToWhere(subCriteria) { sc ->
-            or(initialCriterion, sc)
-        }
-
     fun allRows(): B = self()
 
     private fun applyToWhere(
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
@@ -19,15 +19,11 @@ package org.mybatis.dynamic.sql.util.kotlin.elements
 import org.mybatis.dynamic.sql.BasicColumn
 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
 import org.mybatis.dynamic.sql.select.aggregate.Count
 import org.mybatis.dynamic.sql.select.aggregate.CountAll
@@ -45,8 +41,6 @@ import org.mybatis.dynamic.sql.select.function.Substring
 import org.mybatis.dynamic.sql.select.function.Subtract
 import org.mybatis.dynamic.sql.select.function.Upper
 import org.mybatis.dynamic.sql.select.join.EqualTo
-import org.mybatis.dynamic.sql.util.kotlin.CriteriaCollector
-import org.mybatis.dynamic.sql.util.kotlin.CriteriaReceiver
 import org.mybatis.dynamic.sql.util.kotlin.KotlinSubQueryBuilder
 import org.mybatis.dynamic.sql.where.condition.IsBetween
 import org.mybatis.dynamic.sql.where.condition.IsEqualTo
@@ -152,32 +146,6 @@ fun <T> substring(
 
 fun <T> upper(column: BindableColumn<T>): Upper<T> = SqlBuilder.upper(column)
 
-fun group(initialCriterion: SqlCriterion, subCriteria: CriteriaReceiver): CriteriaGroup =
-    SqlBuilder.group(initialCriterion, CriteriaCollector().apply(subCriteria).criteria)
-
-fun group(existsPredicate: ExistsPredicate, subCriteria: CriteriaReceiver): CriteriaGroup =
-    SqlBuilder.group(existsPredicate, CriteriaCollector().apply(subCriteria).criteria)
-
-fun <T> group(
-    column: BindableColumn<T>,
-    condition: VisitableCondition<T>,
-    subCriteria: CriteriaReceiver
-): 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,7 +45,6 @@ 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
@@ -176,7 +175,7 @@ class PersonMapperTest {
             val mapper = session.getMapper(PersonMapper::class.java)
 
             val rows = mapper.select {
-                where(not(firstName, isIn("Fred", "Barney")))
+                where { not { firstName (isIn("Fred", "Barney")) }}
             }
 
             assertThat(rows).hasSize(4)
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/general/KGroupingTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/general/KGroupingTest.kt
@@ -23,13 +23,13 @@ import org.assertj.core.api.Assertions.assertThat
 import org.junit.jupiter.api.Test
 import org.mybatis.dynamic.sql.SqlTable
 import org.mybatis.dynamic.sql.util.kotlin.elements.column
-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.isBetween
 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.elements.isLessThanOrEqualTo
+import org.mybatis.dynamic.sql.util.kotlin.elements.isLike
 import org.mybatis.dynamic.sql.util.kotlin.mybatis3.select
 
 object FooDynamicSqlSupport {
@@ -50,35 +50,45 @@ class KGroupingTest {
     fun testSimpleGrouping() {
         val selectStatement = select(A, B, C) {
             from(foo)
-            where (A, isEqualTo(1)) {
-                or(A, isEqualTo(2))
+            where {
+                A (isBetween(1).and(5).map { it + 3 }.filter{ _ -> true })
+                or { A (isLessThanOrEqualTo(3).map { it + 6 }.filter { true }) }
+                or { A (isEqualTo(9)) }
+                or { C (isLike("Fred%")) }
             }
-            and(B, isEqualTo(3))
+            and { B (isEqualTo(3)) }
         }
 
         val expected = "select A, B, C" +
                 " from Foo" +
-                " where (A = #{parameters.p1} or A = #{parameters.p2}) and B = #{parameters.p3}"
+                " where (A between #{parameters.p1} and #{parameters.p2} or A <= #{parameters.p3} or" +
+                " A = #{parameters.p4} or C like #{parameters.p5}) and B = #{parameters.p6}"
 
         assertThat(selectStatement.selectStatement).isEqualTo(expected)
-        assertThat(selectStatement.parameters).containsEntry("p1", 1)
-        assertThat(selectStatement.parameters).containsEntry("p2", 2)
-        assertThat(selectStatement.parameters).containsEntry("p3", 3)
+        assertThat(selectStatement.parameters).containsEntry("p1", 4)
+        assertThat(selectStatement.parameters).containsEntry("p2", 8)
+        assertThat(selectStatement.parameters).containsEntry("p3", 9)
+        assertThat(selectStatement.parameters).containsEntry("p4", 9)
+        assertThat(selectStatement.parameters).containsEntry("p5", "Fred%")
+        assertThat(selectStatement.parameters).containsEntry("p6", 3)
     }
 
     @Test
     fun testComplexGrouping() {
         val selectStatement = select(A, B, C) {
             from(foo)
-            where(group(A, isEqualTo(1)) {
-                or(A, isGreaterThan(5))
-            }) {
-                and(B, isEqualTo(1))
-                or(A, isLessThan(0)) {
-                    and(B, isEqualTo(2))
+            where {
+                group {
+                    A (isEqualTo(1))
+                    or { A (isGreaterThan(5)) }
+                }
+                and { B (isEqualTo(1)) }
+                or {
+                    A (isLessThan(0))
+                    and { B (isEqualTo(2)) }
                 }
             }
-            and(C, isEqualTo("Fred"))
+            and { C (isEqualTo("Fred")) }
         }
 
         val expected = "select A, B, C" +
@@ -99,21 +109,24 @@ class KGroupingTest {
     fun testGroupAndExists() {
         val selectStatement = select(A, B, C) {
             from(foo)
-            where(group(exists {
-                select(foo.allColumns()) {
-                    from (foo)
-                    where(A, isEqualTo(3))
+            where {
+                group {
+                    exists {
+                        select(foo.allColumns()) {
+                            from(foo)
+                            where { A (isEqualTo(3)) }
+                        }
+                    }
+                    and { A (isEqualTo(1)) }
+                    or { A (isGreaterThan(5)) }
                 }
-            }) {
-                and(A, isEqualTo((1)))
-                or(A, isGreaterThan(5))
-            }) {
-                and(B, isEqualTo(1))
-                or(A, isLessThan(0)) {
-                    and(B, isEqualTo(2))
+                and { B (isEqualTo(1)) }
+                or {
+                    A (isLessThan(0))
+                    and { B (isEqualTo(2)) }
                 }
             }
-            and(C, isEqualTo("Fred"))
+            and { C (isEqualTo("Fred")) }
         }
 
         val expected = "select A, B, C" +
@@ -136,27 +149,33 @@ class KGroupingTest {
     fun testNestedGrouping() {
         val selectStatement = select(A, B, C) {
             from(foo)
-            where(
-                group(group(A, isEqualTo(1)) {
-                    or(A, isGreaterThan(5))
-                }) {
-                    and(A, isGreaterThan(5))
+            where {
+                group {
+                    group {
+                        A (isEqualTo(1))
+                        or { A (isGreaterThan(5)) }
+                    }
+                    and { A (isGreaterThan(5)) }
                 }
-            ) {
-                and(group(A, isEqualTo(1)) {
-                    or(A, isGreaterThan(5))
-                }) {
-                    or(B, isEqualTo(1))
+                and {
+                    group {
+                        A (isEqualTo(1))
+                        or { A (isGreaterThan(5)) }
+                    }
+                    or { B (isEqualTo(1)) }
                 }
-                or(group(A, isEqualTo(1)) {
-                    or(A, isGreaterThan(5))
-                }) {
-                    and(A, isLessThan(0)) {
-                        and(B, isEqualTo(2))
+                or {
+                    group {
+                        A (isEqualTo(1))
+                        or { A (isGreaterThan(5)) }
+                    }
+                    and {
+                        A (isLessThan(0))
+                        and { B (isEqualTo(2)) }
                     }
                 }
             }
-            and(C, isEqualTo("Fred"))
+            and { C (isEqualTo("Fred")) }
         }
 
         val expected = "select A, B, C" +
@@ -184,18 +203,23 @@ class KGroupingTest {
     fun testAndOrCriteriaGroups() {
         val selectStatement = select(A, B, C) {
             from(foo)
-            where(A, isEqualTo(6))
-            and(C, isEqualTo("Fred"))
-            and(group(A, isEqualTo(1)) {
-                or(A, isGreaterThan(5))
-            }) {
-                or(B, isEqualTo(1))
+            where { A (isEqualTo(6)) }
+            and { C (isEqualTo("Fred")) }
+            and {
+                group {
+                    A (isEqualTo(1))
+                    or { A (isGreaterThan(5)) }
+                }
+                or { B (isEqualTo(1)) }
             }
-            or(group(A, isEqualTo(1)) {
-                or(A, isGreaterThan(5))
-            }) {
-                and(A, isLessThan(0)) {
-                    and(B, isEqualTo(2))
+            or {
+                group {
+                    A (isEqualTo(1))
+                    or { A (isGreaterThan(5)) }
+                }
+                and {
+                    A (isLessThan(0))
+                    and { B (isEqualTo(2)) }
                 }
             }
         }
@@ -224,19 +248,24 @@ class KGroupingTest {
     fun testNotGroupAndOrCriteriaGroups() {
         val selectStatement = select(A, B, C) {
             from(foo)
-            where(not(group(B, isEqualTo(4)) {
-                and(A, isLessThan(5))
-            }) {
-                and(A, isGreaterThan(3))
-            })
-            and(not(A, isGreaterThan(4)))
-            or(
-                not(
-                    group(B, isLessThan(6)) {
-                        and(A, isGreaterThanOrEqualTo(7))
+            where {
+                not {
+                    group {
+                        B (isEqualTo(4))
+                        and { A (isLessThan(5)) }
                     }
-                )
-            )
+                    and { A (isGreaterThan(3)) }
+                }
+            }
+            and { not { A (isGreaterThan(4)) } }
+            or {
+                not {
+                    group {
+                        B (isLessThan(6))
+                        and { A (isGreaterThanOrEqualTo(7)) }
+                    }
+                }
+            }
         }
 
         val expected = "select A, B, C" +
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/general/NewDSLGroupingTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/general/NewDSLGroupingTest.kt
diff --git a/src/test/kotlin/examples/kotlin/mybatis3/joins/ExistsTest.kt b/src/test/kotlin/examples/kotlin/mybatis3/joins/ExistsTest.kt
