From 6b0a3f7ca7183c0f32a4f05216913a54745af1ed Mon Sep 17 00:00:00 2001
From: "kamila.myczkowska" <kamila.myczkowska@gmail.com>
Date: Thu, 9 Aug 2018 15:18:04 +0200
Subject: [PATCH] Version 1.0.2

---
 LICENSE.md                                    |  2 +-
 README.md                                     |  9 ++-
 build.gradle                                  |  4 +-
 .../kotlin/com/kameocode/anydao/AnyDao.kt     | 78 +++++++++----------
 .../com/kameocode/anydao/AnyDaoClasses.kt     | 11 ++-
 .../anydao/context/QueryPathContext.kt        |  4 +-
 .../com/kameocode/anydao/wraps/PathWrap.kt    |  5 +-
 .../com/kameocode/anydao/test/ClausesTest.kt  |  6 +-
 .../com/kameocode/anydao/test/PagesTest.kt    | 24 +++---
 .../kameocode/anydao/test/SingleSelectTest.kt | 58 ++++++++++++++
 10 files changed, 131 insertions(+), 70 deletions(-)
 create mode 100644 src/test/kotlin/com/kameocode/anydao/test/SingleSelectTest.kt

diff --git a/LICENSE.md b/LICENSE.md
index 60e9b83..b81fb94 100644
--- a/LICENSE.md
+++ b/LICENSE.md
@@ -183,7 +183,7 @@
       the brackets!)  The text should be enclosed in the appropriate
       comment syntax for the file format. We also recommend that a
       file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
+      same "printed KPage" as the copyright notice for easier
       identification within third-party archives.
 
    Copyright [2018] [Kameo]
diff --git a/README.md b/README.md
index dc2c85d..7a13fd3 100644
--- a/README.md
+++ b/README.md
@@ -77,11 +77,11 @@ Add to your project maven/gradle dependency:
 <dependency>
     <groupId>com.kameocode</groupId>
     <artifactId>any-dao</artifactId>
-    <version>1.0.1</version>
+    <version>1.0.2</version>
 </dependency>
 ```
 ```
-compile 'com.kameocode:any-dao:1.0.1'
+compile 'com.kameocode:any-dao:1.0.2'
 ```
 Create instance of AnyDao:
 ```
@@ -276,7 +276,7 @@ These expressions should be accessible directly on expression/path elements:
 
 > Paging
 ```
-    val pagedListOfUsers = anyDao.pages(UserODB::class, Page(100)) { 
+    val pagedListOfUsers = anyDao.pages(UserODB::class, KPage(100)) { 
         it[UserODB::email] like "email1" 
     }
     pagedListOfUsers.forEach { list->
@@ -321,4 +321,5 @@ For more examples, see: [tests](src/test/kotlin/com/kameocode/anydao/test/)
 * added support for pure java classes for anyDao.exist and anyDao.count 
 
 **v 1.0.2**
-* Support for nullable select
\ No newline at end of file
+* Support for nullable select
+* Page is now KPage 
\ No newline at end of file
diff --git a/build.gradle b/build.gradle
index 339198f..23fc88c 100644
--- a/build.gradle
+++ b/build.gradle
@@ -17,7 +17,7 @@ plugins {
 
 group 'com.kameocode'
 archivesBaseName = "any-dao"
-version '1.0.1'
+version '1.0.2'
 
 description 'AnyDAO is an Kotlin JPA wrapper library which makes your database queries short, clean and easy to read.'
 
@@ -113,7 +113,7 @@ uploadArchives {
             snapshotRepository(url: "https://oss.sonatype.org/content/repositories/snapshots/") {
                 authentication(userName: tossrhUsername, password: tossrhPassword)
             }
-            //  repository(url: mavenLocal().url)
+            //repository(url: mavenLocal().url)
 
 
             pom.project {
diff --git a/src/main/kotlin/com/kameocode/anydao/AnyDao.kt b/src/main/kotlin/com/kameocode/anydao/AnyDao.kt
index 41912a1..4859d4f 100644
--- a/src/main/kotlin/com/kameocode/anydao/AnyDao.kt
+++ b/src/main/kotlin/com/kameocode/anydao/AnyDao.kt
@@ -125,7 +125,7 @@ class AnyDao(val em: EntityManager) {
     }
 
 
-    fun <E : Any, RESULT : Any> all(clz: Class<E>, resultClass: Class<RESULT>, query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)? = null): List<RESULT> {
+    fun <E : Any, RESULT> all(clz: Class<E>, resultClass: Class<RESULT>, query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)? = null): List<RESULT> {
         val qq: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>) = query ?: { this as KSelect<RESULT> }
         val pc = QueryPathContext<RESULT>(clz, em)
         val res = pc.invokeQuery(qq).resultList
@@ -136,23 +136,23 @@ class AnyDao(val em: EntityManager) {
         return all(clz.java, E::class.java)
     }
 
-    inline fun <E : Any, reified RESULT : Any> all(clz: KClass<E>, noinline query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)? = null): List<RESULT> {
+    inline fun <E : Any, reified RESULT> all(clz: KClass<E>, noinline query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)? = null): List<RESULT> {
         return all(clz.java, RESULT::class.java, query)
     }
 
     @Throws(NoResultException::class)
-    fun <E : Any, RESULT : Any> one(clz: Class<E>, resultClass: Class<RESULT>, query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)): RESULT {
+    fun <E : Any, RESULT> one(clz: Class<E>, resultClass: Class<RESULT>, query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)): RESULT {
         val pc = QueryPathContext<RESULT>(clz, em)
         val jpaQuery = pc.invokeQuery(query)
         return pc.mapToPluralsIfNeeded<RESULT>(jpaQuery.singleResult)
     }
 
     @Throws(NoResultException::class)
-    inline fun <E : Any, reified RESULT : Any> one(clz: KClass<E>, noinline query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)): RESULT {
+    inline fun <E : Any, reified RESULT> one(clz: KClass<E>, noinline query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)): RESULT {
         return one(clz.java, RESULT::class.java, query)
     }
 
-    fun <E : Any, RESULT : Any> first(clz: Class<E>, resultClass: Class<RESULT>, query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)): RESULT? {
+    fun <E : Any, RESULT> first(clz: Class<E>, resultClass: Class<RESULT>, query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)): RESULT? {
         val pc = QueryPathContext<RESULT>(clz, em)
         val jpaQuery = pc.invokeQuery(query)
         jpaQuery.maxResults = 1
@@ -192,29 +192,29 @@ class AnyDao(val em: EntityManager) {
         return one(clz, Long::class.java, wrapperQuery)
     }
 
-    inline fun <E : Any, reified RESULT : Any> first(clz: KClass<E>, noinline query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)): RESULT? {
+    inline fun <E : Any, reified RESULT> first(clz: KClass<E>, noinline query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)): RESULT? {
         return first(clz.java, RESULT::class.java, query)
     }
 
-    inline fun <E : Any, reified RESULT : Any> allMutable(clz: KClass<E>, noinline query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)? = null): MutableList<RESULT> {
+    inline fun <E : Any, reified RESULT> allMutable(clz: KClass<E>, noinline query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)? = null): MutableList<RESULT> {
         return all(clz.java, RESULT::class.java, query) as MutableList<RESULT>
     }
 
-    inline fun <E : Any, reified RESULT : Any> pages(clz: KClass<E>, page: Page = Page(),
-                                                     noinline query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)
-    ): PagesResult<RESULT> {
+    inline fun <E : Any, reified RESULT> pages(clz: KClass<E>, KPage: KPage = KPage(),
+                                               noinline query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)
+    ): KPagesResult<RESULT> {
 
-        return pages(clz.java, RESULT::class.java, page, query)
+        return pages(clz.java, RESULT::class.java, KPage, query)
     }
 
-    fun <E : Any, RESULT : Any> pages(clz: Class<E>, resultClz: Class<RESULT>, page: Page = Page(),
-                                      query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)
-    ): PagesResult<RESULT> {
-        return object : PagesResult<RESULT>(page.pageSize) {
-            var currentpage = page;
+    fun <E : Any, RESULT> pages(clz: Class<E>, resultClz: Class<RESULT>, KPage: KPage = KPage(),
+                                query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)
+    ): KPagesResult<RESULT> {
+        return object : KPagesResult<RESULT>(KPage.pageSize) {
+            var currentpage = KPage;
 
             override fun beforeForeach() {
-                currentpage = page
+                currentpage = KPage
             }
 
             override fun invoke(): List<RESULT> {
@@ -225,39 +225,39 @@ class AnyDao(val em: EntityManager) {
         };
     }
 
-    inline fun <E : Any, reified RESULT : Any> page(clz: KClass<E>, page: Page,
-                                                    noinline query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)): List<RESULT> {
+    inline fun <E : Any, reified RESULT> page(clz: KClass<E>, KPage: KPage,
+                                              noinline query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)): List<RESULT> {
 
-        return page(clz.java, RESULT::class.java, page, query)
+        return page(clz.java, RESULT::class.java, KPage, query)
     }
 
-    fun <E : Any, RESULT : Any> page(clz: Class<E>, resultClass: Class<RESULT>, page: Page,
-                                     query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)): List<RESULT> {
+    fun <E : Any, RESULT> page(clz: Class<E>, resultClass: Class<RESULT>, KPage: KPage,
+                               query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)): List<RESULT> {
 
         val wrapperQuery: KRoot<E>.(KRoot<E>) -> (KSelect<RESULT>) = {
             val result = query.invoke(this, this);
-            this.limit(page.pageSize);
-            this.skip(page.offset)
+            this.limit(KPage.pageSize);
+            this.skip(KPage.offset)
             result;
         }
 
         return all(clz, resultClass, wrapperQuery)
     }
 
-    inline fun <E : Any, NUM, reified RESULT : Any> pageSorted(clz: KClass<E>, prop: KProperty1<E, NUM>, num: NUM?, page: Page,
-                                                               noinline query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)): List<RESULT> where NUM : Number, NUM : Comparable<NUM> {
-        return pageSorted(clz.java, RESULT::class.java, prop, num, page, query);
+    inline fun <E : Any, NUM, reified RESULT> pageSorted(clz: KClass<E>, prop: KProperty1<E, NUM>, num: NUM?, KPage: KPage,
+                                                         noinline query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)): List<RESULT> where NUM : Number, NUM : Comparable<NUM> {
+        return pageSorted(clz.java, RESULT::class.java, prop, num, KPage, query);
     }
 
-    fun <E : Any, NUM, RESULT : Any> pageSorted(clz: Class<E>, resultClz: Class<RESULT>, prop: KProperty1<E, NUM>, num: NUM?, page: Page,
-                                                query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)): List<RESULT> where NUM : Number, NUM : Comparable<NUM> {
+    fun <E : Any, NUM, RESULT> pageSorted(clz: Class<E>, resultClz: Class<RESULT>, prop: KProperty1<E, NUM>, num: NUM?, KPage: KPage,
+                                          query: (KRoot<E>.(KRoot<E>) -> KSelect<RESULT>)): List<RESULT> where NUM : Number, NUM : Comparable<NUM> {
 
         val wrapperQuery: KRoot<E>.(KRoot<E>) -> (KSelect<RESULT>) = {
             if (num != null)
                 this[prop].greaterThan(num)
             this.orderBy(prop)
             val result = query.invoke(this, this);
-            this.limit(page.pageSize);
+            this.limit(KPage.pageSize);
             this.skip(0)
 
             result;
@@ -267,22 +267,22 @@ class AnyDao(val em: EntityManager) {
     }
 
 
-    inline fun <reified E : Any, reified NUM> pagesSorted(clz: KClass<E>, prop: KProperty1<E, NUM>, page: Page = Page(),
+    inline fun <reified E : Any, reified NUM> pagesSorted(clz: KClass<E>, prop: KProperty1<E, NUM>, KPage: KPage = KPage(),
                                                           noinline query: (KRoot<E>.(KRoot<E>) -> KSelect<E>)
-    ): PagesResult<E> where NUM : Number, NUM : Comparable<NUM> {
-        return pagesSorted(clz.java, E::class.java, prop, page, query);
+    ): KPagesResult<E> where NUM : Number, NUM : Comparable<NUM> {
+        return pagesSorted(clz.java, E::class.java, prop, KPage, query);
     }
 
-    fun <E : Any, NUM> pagesSorted(clz: Class<E>, resultClass: Class<E>, prop: KProperty1<E, NUM>, page: Page = Page(),
+    fun <E : Any, NUM> pagesSorted(clz: Class<E>, resultClass: Class<E>, prop: KProperty1<E, NUM>, KPage: KPage = KPage(),
                                    query: (KRoot<E>.(KRoot<E>) -> KSelect<E>)
-    ): PagesResult<E> where NUM : Number, NUM : Comparable<NUM> {
+    ): KPagesResult<E> where NUM : Number, NUM : Comparable<NUM> {
 
-        return object : PagesResult<E>(page.pageSize) {
-            var currentpage = page;
+        return object : KPagesResult<E>(KPage.pageSize) {
+            var currentpage = KPage;
             var num: NUM? = null;
 
             override fun beforeForeach() {
-                currentpage = page
+                currentpage = KPage
                 num = null
             }
 
@@ -318,7 +318,7 @@ class AnyDao(val em: EntityManager) {
 
     companion object {
         @JvmStatic
-        fun <E : Any, RESULT : Any> getPredicate(root: Root<E>, criteriaQuery: CriteriaQuery<*>, cb: CriteriaBuilder,
+        fun <E : Any, RESULT> getPredicate(root: Root<E>, criteriaQuery: CriteriaQuery<*>, cb: CriteriaBuilder,
                                                  query: KRoot<E>.(KRoot<E>) -> KSelect<RESULT>): Predicate {
             val pc = PredicatePathContext(root as Root<Any>, criteriaQuery, cb);
             return pc.toPredicate(query)
diff --git a/src/main/kotlin/com/kameocode/anydao/AnyDaoClasses.kt b/src/main/kotlin/com/kameocode/anydao/AnyDaoClasses.kt
index f87d01d..5fc7e3f 100644
--- a/src/main/kotlin/com/kameocode/anydao/AnyDaoClasses.kt
+++ b/src/main/kotlin/com/kameocode/anydao/AnyDaoClasses.kt
@@ -4,7 +4,6 @@ import com.kameocode.anydao.context.PathContext
 import com.kameocode.anydao.wraps.FromWrap
 import com.kameocode.anydao.wraps.PathWrap
 import com.kameocode.anydao.wraps.RootWrap
-import com.kameocode.anydao.wraps.RootWrapUpdate
 import java.io.Serializable
 import javax.persistence.Tuple
 import javax.persistence.TupleElement
@@ -16,7 +15,7 @@ import kotlin.reflect.KProperty1
 
 typealias KRoot<E> = RootWrap<E, E>
 typealias QueryUnit<T> = T.(T) -> Unit
-typealias KQuery<E, RESULT> = KRoot<E>.(KRoot<E>) -> (KSelect<RESULT>)
+typealias KQuery<E, RESULT> = RootWrap<E, E>.(RootWrap<E, E>) -> (KSelect<RESULT>)
 typealias KClause<E> = PathWrap<E, Any>.(PathWrap<E, Any>) -> Unit
 typealias KFromClause<E> = FromWrap<E, Any>.(FromWrap<E, Any>) -> Unit
 
@@ -116,12 +115,12 @@ class TupleWrap(private val arr: Array<Any>,
 
 }
 
-data class Page(val pageSize: Int = 10, val offset: Int = 0) {
-    fun next() = Page(pageSize, offset + pageSize)
+data class KPage(val pageSize: Int = 10, val offset: Int = 0) {
+    fun next() = KPage(pageSize, offset + pageSize)
 }
 
-abstract class PagesResult<E>(val pageSize: Int) {
-    abstract fun invoke(): List<E>
+abstract class KPagesResult<E>(val pageSize: Int) {
+    internal abstract fun invoke(): List<E>
 
     abstract protected fun beforeForeach()
 
diff --git a/src/main/kotlin/com/kameocode/anydao/context/QueryPathContext.kt b/src/main/kotlin/com/kameocode/anydao/context/QueryPathContext.kt
index bd629fd..56ad3c1 100644
--- a/src/main/kotlin/com/kameocode/anydao/context/QueryPathContext.kt
+++ b/src/main/kotlin/com/kameocode/anydao/context/QueryPathContext.kt
@@ -61,7 +61,7 @@ class QueryPathContext<G>(clz: Class<*>,
 
 
 
-    fun <RESULT : Any> mapToPluralsIfNeeded(res: RESULT): RESULT {
+    fun <RESULT> mapToPluralsIfNeeded(res: RESULT): RESULT {
         if (selector is com.kameocode.anydao.AnyDao.PathArraySelect ) {
             return res;
         }
@@ -82,7 +82,7 @@ class QueryPathContext<G>(clz: Class<*>,
         return res
     }
 
-    fun <RESULT : Any> mapToPluralsIfNeeded(res: List<RESULT>): List<RESULT> {
+    fun <RESULT> mapToPluralsIfNeeded(res: List<RESULT>): List<RESULT> {
         if (selector is com.kameocode.anydao.AnyDao.PathArraySelect) {
             return res;
         }
diff --git a/src/main/kotlin/com/kameocode/anydao/wraps/PathWrap.kt b/src/main/kotlin/com/kameocode/anydao/wraps/PathWrap.kt
index de36f92..7ed0f62 100644
--- a/src/main/kotlin/com/kameocode/anydao/wraps/PathWrap.kt
+++ b/src/main/kotlin/com/kameocode/anydao/wraps/PathWrap.kt
@@ -41,7 +41,6 @@ open class PathWrap<E, G> constructor(
         return this
     }
 
-
     infix fun <F> select(pw: KProperty1<E, F>): SelectWrap<F> {
         return select(get(pw))
     }
@@ -55,6 +54,10 @@ open class PathWrap<E, G> constructor(
     }
 
 
+    infix fun <F> selectNullable(pw: ExpressionWrap<F, G>): SelectWrap<F?> {
+        return pw.getDirectSelection() as SelectWrap<F?>
+    }
+
     fun <F, G> select(pw1: ISelectExpressionProvider<F>, pw2: ISelectExpressionProvider<G>): com.kameocode.anydao.AnyDao.PathPairSelect<F, G> {
         return com.kameocode.anydao.AnyDao.PathPairSelect(pw1.getDirectSelection(), pw2.getDirectSelection(), false, pc.cb)
     }
diff --git a/src/test/kotlin/com/kameocode/anydao/test/ClausesTest.kt b/src/test/kotlin/com/kameocode/anydao/test/ClausesTest.kt
index 55f4ee6..08ddd96 100644
--- a/src/test/kotlin/com/kameocode/anydao/test/ClausesTest.kt
+++ b/src/test/kotlin/com/kameocode/anydao/test/ClausesTest.kt
@@ -4,7 +4,7 @@ import com.kameocode.anydao.KClause
 import com.kameocode.anydao.KFromClause
 import com.kameocode.anydao.KQuery
 import com.kameocode.anydao.KRoot
-import com.kameocode.anydao.Page
+import com.kameocode.anydao.KPage
 import com.kameocode.anydao.test.helpers.AddressODB
 import com.kameocode.anydao.test.helpers.BaseTest
 import com.kameocode.anydao.test.helpers.TaskODB
@@ -320,8 +320,8 @@ class ClausesTest : BaseTest() {
             // expected
         }
         val first = anyDao.first(UserODB::class, query)
-        val page = anyDao.page(UserODB::class, Page(), query)
-        val pages = anyDao.pages(UserODB::class, Page(), query)
+        val page = anyDao.page(UserODB::class, KPage(), query)
+        val pages = anyDao.pages(UserODB::class, KPage(), query)
         Assert.assertEquals(setOf(u2.task, u3.task).map { it.id }.toSet(), res1.map { it.id }.toSet())
 
         Assert.assertEquals(2, count)
diff --git a/src/test/kotlin/com/kameocode/anydao/test/PagesTest.kt b/src/test/kotlin/com/kameocode/anydao/test/PagesTest.kt
index 7ac4e78..dd0a14d 100644
--- a/src/test/kotlin/com/kameocode/anydao/test/PagesTest.kt
+++ b/src/test/kotlin/com/kameocode/anydao/test/PagesTest.kt
@@ -1,6 +1,6 @@
 package com.kameocode.anydao.test
 
-import com.kameocode.anydao.Page
+import com.kameocode.anydao.KPage
 import com.kameocode.anydao.test.helpers.BaseTest
 import com.kameocode.anydao.test.helpers.TaskODB
 import com.kameocode.anydao.test.helpers.UserODB
@@ -19,26 +19,26 @@ class PagesTest : BaseTest() {
             anyDao.persist(UserODB(email = "email$i", task = TaskODB(name = "task$i"), counter = i))
         }
 
-        val res1 = anyDao.page(UserODB::class, Page()) { it[UserODB::email] like "email1" }
-        val res1a = anyDao.page(UserODB::class, Page()) { it }
-        val res1b = anyDao.page(UserODB::class, Page().next()) { it }
+        val res1 = anyDao.page(UserODB::class, KPage()) { it[UserODB::email] like "email1" }
+        val res1a = anyDao.page(UserODB::class, KPage()) { it }
+        val res1b = anyDao.page(UserODB::class, KPage().next()) { it }
 
         Assert.assertEquals(1, res1.size)
         Assert.assertEquals(10, res1a.size)
         Assert.assertEquals(9, res1b.size)
 
-        val res2 = anyDao.page(UserODB::class, Page()) { it[UserODB::counter].mod(3) eq 1 }
+        val res2 = anyDao.page(UserODB::class, KPage()) { it[UserODB::counter].mod(3) eq 1 }
         Assert.assertEquals(7, res2.size)
 
 
-        val sup = anyDao.pages(UserODB::class, Page(3)) { it[UserODB::counter].mod(3) eq 1 }
+        val sup = anyDao.pages(UserODB::class, KPage(3)) { it[UserODB::counter].mod(3) eq 1 }
         Assert.assertEquals(3, sup.invoke().size)
         Assert.assertEquals(3, sup.invoke().size)
         Assert.assertEquals(1, sup.invoke().size)
         Assert.assertEquals(0, sup.invoke().size)
 
 
-        val sup2 = anyDao.pages(UserODB::class, Page(3)) { it[UserODB::counter].mod(3) eq 1 }
+        val sup2 = anyDao.pages(UserODB::class, KPage(3)) { it[UserODB::counter].mod(3) eq 1 }
         val chunkSizes2 = mutableListOf<Int>()
         sup2.forEach { chunkSizes2.add(it.size) }
         Assert.assertEquals(listOf(3, 3, 1), chunkSizes2)
@@ -49,19 +49,19 @@ class PagesTest : BaseTest() {
         Assert.assertEquals("Should return same results second time", listOf(3, 3, 1), chunkSizes2b)
 
 
-        val sup3 = anyDao.pages(UserODB::class, Page(3)) { it[UserODB::counter].mod(3) eq 1 }
+        val sup3 = anyDao.pages(UserODB::class, KPage(3)) { it[UserODB::counter].mod(3) eq 1 }
         val chunkSizes3 = mutableListOf<Int>()
         sup3.forEachFlat { chunkSizes3.add(1) }
         Assert.assertEquals(listOf(1, 1, 1, 1, 1, 1, 1), chunkSizes3)
 
 
-        val sup4 = anyDao.pages(UserODB::class, Page(3)) { it[UserODB::counter].mod(3) eq 1 }
+        val sup4 = anyDao.pages(UserODB::class, KPage(3)) { it[UserODB::counter].mod(3) eq 1 }
         val chunkSizes4 = mutableListOf<Int>()
         sup4.forEachUntil { chunkSizes4.add(it.size); false }
         Assert.assertEquals(listOf(3), chunkSizes4)
 
 
-        val sup5 = anyDao.pages(UserODB::class, Page(3)) { it[UserODB::counter].mod(3) eq 1 }
+        val sup5 = anyDao.pages(UserODB::class, KPage(3)) { it[UserODB::counter].mod(3) eq 1 }
         val chunkSizes5 = mutableListOf<Int>()
         sup5.forEachFlatUntil { chunkSizes5.add(1); chunkSizes5.size < 2 }
         Assert.assertEquals(listOf(1, 1), chunkSizes5)
@@ -75,12 +75,12 @@ class PagesTest : BaseTest() {
             anyDao.persist(UserODB(email = "email$i", task = TaskODB(name = "task$i")))
         }
 
-        val res1 = anyDao.pagesSorted(UserODB::class, UserODB::id, Page(3)) { not { it[UserODB::email] like "n" } }
+        val res1 = anyDao.pagesSorted(UserODB::class, UserODB::id, KPage(3)) { not { it[UserODB::email] like "n" } }
         val chunkSizes1 = mutableListOf<Int>()
         res1.forEach { chunkSizes1.add(it.size) }
         Assert.assertEquals(listOf(3, 3, 3, 1), chunkSizes1)
 
-        val res2 = anyDao.pagesSorted(UserODB::class, UserODB::id, Page(10)) { not { it[UserODB::email] like "n" } }
+        val res2 = anyDao.pagesSorted(UserODB::class, UserODB::id, KPage(10)) { not { it[UserODB::email] like "n" } }
         val chunkSizes2 = mutableListOf<Int>()
         res2.forEach { chunkSizes2.add(it.size) }
         Assert.assertEquals(listOf(10), chunkSizes2)
diff --git a/src/test/kotlin/com/kameocode/anydao/test/SingleSelectTest.kt b/src/test/kotlin/com/kameocode/anydao/test/SingleSelectTest.kt
new file mode 100644
index 0000000..18d0acc
--- /dev/null
+++ b/src/test/kotlin/com/kameocode/anydao/test/SingleSelectTest.kt
@@ -0,0 +1,58 @@
+package com.kameocode.anydao.test
+
+import com.kameocode.anydao.test.helpers.BaseTest
+import com.kameocode.anydao.test.helpers.TaskODB
+import com.kameocode.anydao.test.helpers.UserODB
+import com.kameocode.anydao.wraps.JoinWrap
+import org.junit.Assert
+import org.junit.Test
+import javax.persistence.criteria.JoinType
+
+
+class SingleSelectTest : BaseTest() {
+
+    @Test
+    fun `should return plain select with nullable`() {
+        anyDao.persist(
+                UserODB(email = "email1", task = TaskODB(name = "t1"), taskNullable = TaskODB(name = "t1n")),
+                UserODB(email = "email2", task = TaskODB(name = "t1")),
+                UserODB(email = "email3", task = TaskODB(name = "t2")))
+
+        val res1: List<TaskODB> = anyDao.all(UserODB::class) {
+            it.select(UserODB::task)
+        }
+        Assert.assertEquals(3, res1.size)
+
+
+
+        val res2: List<TaskODB?> = anyDao.all(UserODB::class) {
+            val task: JoinWrap<TaskODB?, UserODB> = it.join(UserODB::taskNullable, JoinType.LEFT)
+            it.selectNullable(task)
+        }
+        Assert.assertEquals(3, res2.size)
+        Assert.assertNotNull(res2[0])
+        Assert.assertNull(res2[1])
+        Assert.assertNull(res2[2])
+
+
+        val res3: List<TaskODB?> = anyDao.all(UserODB::class) {
+            val task: JoinWrap<TaskODB?, UserODB> = it.join(UserODB::taskNullable, JoinType.LEFT)
+            it.select(task)
+        }
+        Assert.assertEquals(3, res3.size)
+        Assert.assertNotNull(res3[0])
+        Assert.assertNull(res2[1])
+        Assert.assertNull(res3[2])
+
+        val res4: List<TaskODB> = anyDao.all(UserODB::class) {
+            val task: JoinWrap<TaskODB, UserODB> = it.join(UserODB::taskNullable, JoinType.LEFT)
+            it.select(task)
+        }
+        Assert.assertEquals(3, res4.size)
+        Assert.assertNotNull(res4[0])
+        Assert.assertNull(res4[1])
+        Assert.assertNull(res4[2])
+    }
+
+}
+