Documentation

Author: jeffgbutler

CHANGELOG.md

@@ -4,7 +4,7 @@ This log will detail notable changes to MyBatis Dynamic SQL. Full details are av
 
 ## Release 1.4.0 - Unreleased
 
-The release includes new function in the Where Clause DSL to support arbitrary grouping of conditions, and also use
+The release includes new functionality in the Where Clause DSL to support arbitrary grouping of conditions, and also use
 of a "not" condition. It should now be possible to write any type of where clause.
 
 Additionally, there were significant updates to the Kotlin DSL - both to support the new functionality in the
@@ -44,6 +44,9 @@ GitHub milestone: [https://github.com/mybatis/mybatis-dynamic-sql/issues?q=miles
    insertBatch, and insertMultiple, the "into" function is moved inside the completer lambda. The old methods are now
    deprecated and will be removed in version 1.5.0 of the library. This also allowed us to make some insert DSL
    methods into infix functions. ([#452](https://github.com/mybatis/mybatis-dynamic-sql/pull/452))
+8. Updated the "exists" support to expose table aliases specified in the outer query to the query in the exists
+   clause. This makes it easier to use exists without having to re-specify the aliases for columns from the outer query.
+   ([#437](https://github.com/mybatis/mybatis-dynamic-sql/issues/437))
 
 ## Release 1.3.1 - December 18, 2021
 

src/site/markdown/docs/subQueries.md

@@ -135,15 +135,16 @@ SelectStatementProvider selectStatement = select(itemMaster.allColumns())
         .where(exists(
                 select(orderLine.allColumns())
                 .from(orderLine, "ol")
-                .where(orderLine.itemId, isEqualTo(itemMaster.itemId.qualifiedWith("im")))
+                .where(orderLine.itemId, isEqualTo(itemMaster.itemId))
         ))
         .orderBy(itemMaster.itemId)
         .build()
         .render(RenderingStrategies.MYBATIS3);
 ```
 
-Note that we have to apply the qualifier for the outer query ("im") to the inner query. The qualifier
-for the inner query ("ol") is automatically applied.
+Note that the qualifier for the outer query ("im") is automatically applied to the inner query, as well as the
+qualifier for the inner query ("ol"). Carrying alias from an outer query to an inner query is only supported with
+exists or not exists sub queries.
 
 An example of a column based subquery is as follows:
 
@@ -168,25 +169,29 @@ An example of an exists subquery is as follows:
 ```kotlin
 val selectStatement = select(ItemMaster.allColumns()) {
     from(ItemMaster, "im")
-    where(exists {
-        select(OrderLine.allColumns()) {
-            from(OrderLine, "ol")
-            where(OrderLine.itemId, isEqualTo(ItemMaster.itemId.qualifiedWith("im")))
-        }
-    })
-    orderBy(ItemMaster.itemId)
+    where {
+       exists {
+          select(OrderLine.allColumns()) {
+             from(OrderLine, "ol")
+             where { OrderLine.itemId isEqualTo ItemMaster.itemId }
+          }
+       }
+       orderBy(ItemMaster.itemId)
+    }
 }
 ```
 
 An example of a column based subquery is as follows:
 ```kotlin
 val selectStatement = select(id, firstName, lastName, birthDate, employed, occupation, addressId) {
     from(Person)
-    where(id, isEqualTo {
-        select(max(id)) {
-            from(Person)
-        }
-    })
+    where {
+       id isEqualTo {
+          select(max(id)) {
+             from(Person)
+          }
+       }
+    }
 }
 ```
 
@@ -241,12 +246,12 @@ with the select DSL. You can write subqueries like this:
 
 ```kotlin
 val updateStatement = update(Person) {
-    set(addressId).equalToQueryResult {
+    set(addressId) equalToQueryResult {
         select(add(max(addressId), constant<Int>("1"))) {
             from(Person)
         }
     }
-    where(id, isEqualTo(3))
+    where { id isEqualTo 3 }
 }
 ```
 
@@ -289,12 +294,12 @@ val selectStatement =
         from {
             select(id, firstName) {
                 from(Person)
-                where(id, isLessThan(22))
+                where { id isLessThan 22 }
                 orderBy(firstName.descending())
             }
         }
-        where(rowNum, isLessThan(5))
-        and(firstName, isLike("%a%"))
+        where { rowNum isLessThan 5 }
+        and { firstName isLike "%a%" }
     }
 ```
 
@@ -307,13 +312,13 @@ val selectStatement =
         from {
             select(id, firstName) {
                 from(Person, "a")
-                where(id, isLessThan(22))
+                where { id isLessThan 22 }
                 orderBy(firstName.descending())
             }
             + "b"
         }
-        where(rowNum, isLessThan(5))
-        and(firstName, isLike("%a%"))
+        where { rowNum isLessThan 5 }
+        and { firstName isLike "%a%" }
     }
 ```
 
@@ -356,15 +361,17 @@ val selectStatement = select(OrderLine.orderId, OrderLine.quantity,
         ItemMaster.itemId.qualifiedWith("im"), ItemMaster.description) {
     from(OrderMaster, "om")
     join(OrderLine, "ol") {
-        on(OrderMaster.orderId, equalTo(OrderLine.orderId))
+        on(OrderMaster.orderId) equalTo OrderLine.orderId
     }
-    leftJoin({
-        select(ItemMaster.allColumns()) {
-            from(ItemMaster)
-        }
-        + "im"
-    }) {
-        on(OrderLine.itemId, equalTo(ItemMaster.itemId.qualifiedWith("im")))
+    leftJoin(
+       {
+          select(ItemMaster.allColumns()) {
+             from(ItemMaster)
+          }
+          + "im"
+      }
+    ) {
+        on(OrderLine.itemId) equalTo (ItemMaster.itemId qualifiedWith "im")
     }
     orderBy(OrderLine.orderId, ItemMaster.itemId)
 }

src/test/kotlin/examples/kotlin/mybatis3/joins/ExistsTest.kt

@@ -94,6 +94,49 @@ class ExistsTest {
         }
     }
 
+    @Test
+    fun testExistsPropagatedAliases() {
+        newSession().use { session ->
+            val mapper = session.getMapper(CommonSelectMapper::class.java)
+
+            val selectStatement = select(itemMaster.allColumns()) {
+                from(itemMaster, "im")
+                where {
+                    exists {
+                        select(orderLine.allColumns()) {
+                            from(orderLine, "ol")
+                            where { orderLine.itemId isEqualTo itemMaster.itemId }
+                        }
+                    }
+                }
+                orderBy(itemMaster.itemId)
+            }
+
+            val expectedStatement: String = "select im.* from ItemMaster im" +
+                    " where 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(3)
+
+            with(rows[0]) {
+                assertThat(this).containsEntry("ITEM_ID", 22)
+                assertThat(this).containsEntry("DESCRIPTION", "Helmet")
+            }
+
+            with(rows[1]) {
+                assertThat(this).containsEntry("ITEM_ID", 33)
+                assertThat(this).containsEntry("DESCRIPTION", "First Base Glove")
+            }
+
+            with(rows[2]) {
+                assertThat(this).containsEntry("ITEM_ID", 44)
+                assertThat(this).containsEntry("DESCRIPTION", "Outfield Glove")
+            }
+        }
+    }
+
     @Test
     fun testNotExists() {
         newSession().use { session ->