refactor

0.12.2

CHANGELOG.md

@@ -1,6 +1,24 @@
 # Changelog
 
-## 0.12.0-beta
+## 0.12.3
+
+* `Repos`:
+  * `Exposed`:
+    * Add abstract exposed variants of `KeyValue` and `KeyValues` repos
+    * Add new extension `Query#selectPaginated`
+
+## 0.12.2
+
+* `Versions`:
+  * `Serialization`: `1.4.0-RC` -> `1.4.0`
+  * `Compose`: `1.2.0-alpha01-dev753` -> `1.2.0-alpha01-dev755`
+
+## 0.12.1
+
+* `Versions`:
+  * `Ktor`: `2.0.3` -> `2.1.0`
+
+## 0.12.0
 
 **OLD DEPRECATIONS HAVE BEEN REMOVED**
 
@@ -18,6 +36,17 @@
 * `Ktor`:
   * All previously standard functions related to work with binary data by default have been deprecated
 
+## 0.11.14
+
+* `Pagination`:
+    * `PaginationResult` got new field `objectsNumber` which by default is a times between `pagesNumber` and `size`
+
+## 0.11.13
+
+* `Versions`:
+    * `Coroutines`: `1.6.3` -> `1.6.4`
+    * `Compose`: `1.2.0-alpha01-dev629` -> `1.2.0-alpha01-dev731`
+
 ## 0.11.12
 
 * `Repos`:

gradle.properties

@@ -14,5 +14,5 @@ crypto_js_version=4.1.1
 # Project data
 
 group=dev.inmo
-version=0.12.0
-android_code_version=137
+version=0.12.3
+android_code_version=142

gradle/libs.versions.toml

@@ -1,17 +1,17 @@
 [versions]
 
 kt = "1.7.0"
-kt-serialization = "1.4.0-RC"
+kt-serialization = "1.4.0"
 kt-coroutines = "1.6.4"
 
-jb-compose = "1.2.0-alpha01-dev753"
+jb-compose = "1.2.0-alpha01-dev755"
 jb-exposed = "0.39.2"
 jb-dokka = "1.7.0"
 
 klock = "3.0.0"
 uuid = "0.5.0"
 
-ktor = "2.0.3"
+ktor = "2.1.0"
 
 gh-release = "2.4.1"
 

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.4.1-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-7.5-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

pagination/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/PaginationResult.kt

@@ -1,23 +1,60 @@
 package dev.inmo.micro_utils.pagination
 
-import kotlinx.serialization.Serializable
+import kotlinx.serialization.*
+import kotlin.math.ceil
 
+/**
+ * @param page Current page number
+ * @param size Current page size. It can be greater than size of [results]
+ * @param results Result objects
+ * @param objectsNumber Count of all objects across all pages
+ */
 @Serializable
 data class PaginationResult<T>(
     override val page: Int,
-    val pagesNumber: Int,
+    override val size: Int,
     val results: List<T>,
-    override val size: Int
-) : Pagination
+    val objectsNumber: Long
+) : Pagination {
+    /**
+     * Amount of pages for current pagination
+     */
+    @EncodeDefault
+    val pagesNumber: Int = ceil(objectsNumber / size.toFloat()).toInt()
 
-fun <T> emptyPaginationResult() = PaginationResult<T>(0, 0, emptyList(), 0)
+    constructor(
+        page: Int,
+        results: List<T>,
+        pagesNumber: Int,
+        size: Int
+    ) : this(
+        page,
+        size,
+        results,
+        (pagesNumber * size).toLong()
+    )
+    @Deprecated("Replace with The other order of incoming parameters or objectsCount parameter")
+    constructor(
+        page: Int,
+        pagesNumber: Int,
+        results: List<T>,
+        size: Int
+    ) : this(
+        page,
+        results,
+        pagesNumber,
+        size
+    )
+}
+
+fun <T> emptyPaginationResult() = PaginationResult<T>(0, 0, emptyList(), 0L)
 
 /**
  * @return New [PaginationResult] with [data] without checking of data sizes equality
  */
 fun <I, O> PaginationResult<I>.changeResultsUnchecked(
     data: List<O>
-): PaginationResult<O> = PaginationResult(page, pagesNumber, data, size)
+): PaginationResult<O> = PaginationResult(page, size, data, objectsNumber)
 /**
  * @return New [PaginationResult] with [data] <b>with</b> checking of data sizes equality
  */
@@ -33,12 +70,9 @@ fun <T> List<T>.createPaginationResult(
     commonObjectsNumber: Long
 ) = PaginationResult(
     pagination.page,
-    calculatePagesNumber(
-        commonObjectsNumber,
-        pagination.size
-    ),
+    pagination.size,
     this,
-    pagination.size
+    commonObjectsNumber
 )
 
 fun <T> List<T>.createPaginationResult(
@@ -46,12 +80,9 @@ fun <T> List<T>.createPaginationResult(
     commonObjectsNumber: Long
 ) = PaginationResult(
     calculatePage(firstIndex, size),
-    calculatePagesNumber(
-        commonObjectsNumber,
-        size
-    ),
+    size,
     this,
-    size
+    commonObjectsNumber
 )
 
 fun <T> Pair<Long, List<T>>.createPaginationResult(

pagination/common/src/commonMain/kotlin/dev/inmo/micro_utils/pagination/SimplePagination.kt

@@ -26,6 +26,10 @@ inline fun Pagination.nextPage() =
         size
     )
 
+/**
+ * @param page Current page number
+ * @param size Current page size
+ */
 @Serializable
 data class SimplePagination(
     override val page: Int,

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/mappers/KeyValueMappers.kt

@@ -1,7 +1,6 @@
 package dev.inmo.micro_utils.repos.mappers
 
-import dev.inmo.micro_utils.pagination.Pagination
-import dev.inmo.micro_utils.pagination.PaginationResult
+import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.repos.*
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
@@ -21,11 +20,8 @@ open class MapperReadKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
         pagination,
         reversed
     ).let {
-        PaginationResult(
-            it.page,
-            it.pagesNumber,
-            it.results.map { it.toInnerValue() },
-            it.size
+        it.changeResultsUnchecked(
+            it.results.map { it.toInnerValue() }
         )
     }
 
@@ -36,11 +32,8 @@ open class MapperReadKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
         pagination,
         reversed
     ).let {
-        PaginationResult(
-            it.page,
-            it.pagesNumber,
-            it.results.map { it.toInnerKey() },
-            it.size
+        it.changeResultsUnchecked(
+            it.results.map { it.toInnerKey() }
         )
     }
 
@@ -53,11 +46,8 @@ open class MapperReadKeyValueRepo<FromKey, FromValue, ToKey, ToValue>(
         pagination,
         reversed
     ).let {
-        PaginationResult(
-            it.page,
-            it.pagesNumber,
-            it.results.map { it.toInnerKey() },
-            it.size
+        it.changeResultsUnchecked(
+            it.results.map { it.toInnerKey() }
         )
     }
 

repos/common/src/commonMain/kotlin/dev/inmo/micro_utils/repos/mappers/OneToManyKeyValueMappers.kt

@@ -1,7 +1,6 @@
 package dev.inmo.micro_utils.repos.mappers
 
-import dev.inmo.micro_utils.pagination.Pagination
-import dev.inmo.micro_utils.pagination.PaginationResult
+import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.repos.*
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.map
@@ -19,11 +18,8 @@ open class MapperReadKeyValuesRepo<FromKey, FromValue, ToKey, ToValue>(
         pagination,
         reversed
     ).let {
-        PaginationResult(
-            it.page,
-            it.pagesNumber,
-            it.results.map { it.toInnerValue() },
-            it.size
+        it.changeResultsUnchecked(
+            it.results.map { it.toInnerValue() }
         )
     }
 
@@ -34,11 +30,8 @@ open class MapperReadKeyValuesRepo<FromKey, FromValue, ToKey, ToValue>(
         pagination,
         reversed
     ).let {
-        PaginationResult(
-            it.page,
-            it.pagesNumber,
-            it.results.map { it.toInnerKey() },
-            it.size
+        it.changeResultsUnchecked(
+            it.results.map { it.toInnerKey() }
         )
     }
 
@@ -51,11 +44,8 @@ open class MapperReadKeyValuesRepo<FromKey, FromValue, ToKey, ToValue>(
         pagination,
         reversed
     ).let {
-        PaginationResult(
-            it.page,
-            it.pagesNumber,
-            it.results.map { it.toInnerKey() },
-            it.size
+        it.changeResultsUnchecked(
+            it.results.map { it.toInnerKey() }
         )
     }
 

repos/common/src/main/kotlin/dev/inmo/micro_utils/repos/keyvalue/KeyValueStore.kt

@@ -3,8 +3,7 @@ package dev.inmo.micro_utils.repos.keyvalue
 import android.content.Context
 import android.content.SharedPreferences
 import androidx.core.content.edit
-import dev.inmo.micro_utils.pagination.Pagination
-import dev.inmo.micro_utils.pagination.PaginationResult
+import dev.inmo.micro_utils.pagination.*
 import dev.inmo.micro_utils.pagination.utils.paginate
 import dev.inmo.micro_utils.pagination.utils.reverse
 import dev.inmo.micro_utils.repos.KeyValueRepo
@@ -72,14 +71,11 @@ class KeyValueStore<T : Any> internal constructor (
         return sharedPreferences.all.values.paginate(
             resultPagination
         ).let {
-            PaginationResult(
-                it.page,
-                it.pagesNumber,
+            it.changeResultsUnchecked(
                 it.results.map {
                     @Suppress("UNCHECKED_CAST")
                     it as T
-                }.let { if (reversed) it.reversed() else it },
-                it.size
+                }.let { if (reversed) it.reversed() else it }
             )
         }
     }
@@ -89,11 +85,8 @@ class KeyValueStore<T : Any> internal constructor (
         return sharedPreferences.all.keys.paginate(
             resultPagination
         ).let {
-            PaginationResult(
-                it.page,
-                it.pagesNumber,
-                it.results.let { if (reversed) it.reversed() else it },
-                it.size
+            it.changeResultsUnchecked(
+                it.results.let { if (reversed) it.reversed() else it }
             )
         }
     }
@@ -103,11 +96,8 @@ class KeyValueStore<T : Any> internal constructor (
         return sharedPreferences.all.mapNotNull { (k, value) -> if (value == v) k else null }.paginate(
             resultPagination
         ).let {
-            PaginationResult(
-                it.page,
-                it.pagesNumber,
-                it.results.let { if (reversed) it.reversed() else it },
-                it.size
+            it.changeResultsUnchecked(
+                it.results.let { if (reversed) it.reversed() else it }
             )
         }
     }

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/AbstractExposedWriteCRUDRepo.kt

@@ -26,7 +26,6 @@ abstract class AbstractExposedWriteCRUDRepo<ObjectType, IdType, InputValueType>(
     override val deletedObjectsIdsFlow: Flow<IdType> = _deletedObjectsIdsFlow.asSharedFlow()
 
     protected abstract fun InsertStatement<Number>.asObject(value: InputValueType): ObjectType
-    abstract val selectByIds: SqlExpressionBuilder.(List<IdType>) -> Op<Boolean>
 
     protected abstract fun insert(value: InputValueType, it: InsertStatement<Number>)
     protected abstract fun update(id: IdType, value: InputValueType, it: UpdateStatement)

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/CommonExposedRepo.kt

@@ -0,0 +1,20 @@
+package dev.inmo.micro_utils.repos.exposed
+
+import org.jetbrains.exposed.sql.*
+
+interface CommonExposedRepo<IdType, ObjectType> : ExposedRepo {
+    val ResultRow.asObject: ObjectType
+    val selectById: SqlExpressionBuilder.(IdType) -> Op<Boolean>
+    val selectByIds: SqlExpressionBuilder.(List<IdType>) -> Op<Boolean>
+        get() = { list ->
+            if (list.isEmpty()) {
+                Op.FALSE
+            } else {
+                var op = selectById(list.first())
+                (1 until list.size).forEach {
+                    op = op.or(selectById(list[it]))
+                }
+                op
+            }
+        }
+}

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/ExposedCRUDRepo.kt

@@ -2,7 +2,4 @@ package dev.inmo.micro_utils.repos.exposed
 
 import org.jetbrains.exposed.sql.*
 
-interface ExposedCRUDRepo<ObjectType, IdType> : ExposedRepo {
-    val ResultRow.asObject: ObjectType
-    val selectById: SqlExpressionBuilder.(IdType) -> Op<Boolean>
-}
+interface ExposedCRUDRepo<ObjectType, IdType> : CommonExposedRepo<IdType, ObjectType>

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/AbstractExposedKeyValueRepo.kt

@@ -0,0 +1,72 @@
+package dev.inmo.micro_utils.repos.exposed.keyvalue
+
+import dev.inmo.micro_utils.repos.KeyValueRepo
+import kotlinx.coroutines.flow.*
+import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.statements.InsertStatement
+import org.jetbrains.exposed.sql.statements.UpdateStatement
+import org.jetbrains.exposed.sql.transactions.transaction
+
+abstract class AbstractExposedKeyValueRepo<Key, Value>(
+    override val database: Database,
+    tableName: String? = null
+) : KeyValueRepo<Key, Value>, AbstractExposedReadKeyValueRepo<Key, Value>(
+    database,
+    tableName
+) {
+    protected val _onNewValue = MutableSharedFlow<Pair<Key, Value>>()
+    protected val _onValueRemoved = MutableSharedFlow<Key>()
+
+    override val onNewValue: Flow<Pair<Key, Value>> = _onNewValue.asSharedFlow()
+    override val onValueRemoved: Flow<Key> = _onValueRemoved.asSharedFlow()
+
+    protected abstract fun update(k: Key, v: Value, it: UpdateStatement)
+    protected abstract fun insert(k: Key, v: Value, it: InsertStatement<Number>)
+
+    override suspend fun set(toSet: Map<Key, Value>) {
+        transaction(database) {
+            toSet.mapNotNull { (k, v) ->
+                if (update({ selectById(k) }) { update(k, v, it) } > 0) {
+                    k to v
+                } else {
+                    val inserted = insert {
+                        insert(k, v, it)
+                    }.getOrNull(keyColumn) != null
+                    if (inserted) {
+                        k to v
+                    } else {
+                        null
+                    }
+                }
+            }
+        }.forEach {
+            _onNewValue.emit(it)
+        }
+    }
+
+    override suspend fun unset(toUnset: List<Key>) {
+        transaction(database) {
+            toUnset.mapNotNull {
+                if (deleteWhere { selectById(it) } > 0) {
+                    it
+                } else {
+                    null
+                }
+            }
+        }.forEach {
+            _onValueRemoved.emit(it)
+        }
+    }
+
+    override suspend fun unsetWithValues(toUnset: List<Value>) {
+        transaction(database) {
+            toUnset.flatMap {
+                val keys = select { selectByValue(it) }.mapNotNull { it.asKey }
+                deleteWhere { selectByIds(keys) }
+                keys
+            }
+        }.distinct().forEach {
+            _onValueRemoved.emit(it)
+        }
+    }
+}

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/keyvalue/AbstractExposedReadKeyValueRepo.kt

@@ -0,0 +1,60 @@
+package dev.inmo.micro_utils.repos.exposed.keyvalue
+
+import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.repos.ReadKeyValueRepo
+import dev.inmo.micro_utils.repos.exposed.*
+import dev.inmo.micro_utils.repos.exposed.utils.selectPaginated
+import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.transactions.transaction
+
+abstract class AbstractExposedReadKeyValueRepo<Key, Value>(
+    override val database: Database,
+    tableName: String? = null
+) : ReadKeyValueRepo<Key, Value>,
+    CommonExposedRepo<Key, Value>,
+    Table(tableName ?: "") {
+    abstract val keyColumn: Column<*>
+    abstract val ResultRow.asKey: Key
+    abstract val selectByValue: SqlExpressionBuilder.(Value) -> Op<Boolean>
+
+    override suspend fun get(k: Key): Value? = transaction(database) {
+        select { selectById(k) }.limit(1).firstOrNull() ?.asObject
+    }
+
+    override suspend fun contains(key: Key): Boolean = transaction(database) {
+        select { selectById(key) }.limit(1).any()
+    }
+
+    override suspend fun count(): Long = transaction(database) { selectAll().count() }
+
+    override suspend fun keys(pagination: Pagination, reversed: Boolean): PaginationResult<Key> = transaction(database) {
+        selectAll().selectPaginated(
+            pagination,
+            keyColumn,
+            reversed
+        ) {
+            it.asKey
+        }
+    }
+
+    override suspend fun keys(v: Value, pagination: Pagination, reversed: Boolean): PaginationResult<Key> = transaction(database) {
+        select { selectByValue(v) }.selectPaginated(
+            pagination,
+            keyColumn,
+            reversed
+        ) {
+            it.asKey
+        }
+    }
+
+    override suspend fun values(pagination: Pagination, reversed: Boolean): PaginationResult<Value> = transaction(database) {
+        selectAll().selectPaginated(
+            pagination,
+            keyColumn,
+            reversed
+        ) {
+            it.asObject
+        }
+    }
+}

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/onetomany/AbstractExposedKeyValueRepo.kt

@@ -0,0 +1,69 @@
+package dev.inmo.micro_utils.repos.exposed.onetomany
+
+import dev.inmo.micro_utils.repos.KeyValuesRepo
+import kotlinx.coroutines.flow.*
+import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.statements.InsertStatement
+import org.jetbrains.exposed.sql.transactions.transaction
+
+abstract class AbstractExposedKeyValuesRepo<Key, Value>(
+    override val database: Database,
+    tableName: String? = null
+) : KeyValuesRepo<Key, Value>, AbstractExposedReadKeyValuesRepo<Key, Value>(
+    database,
+    tableName
+) {
+    protected val _onNewValue: MutableSharedFlow<Pair<Key, Value>> = MutableSharedFlow()
+    override val onNewValue: Flow<Pair<Key, Value>>
+        get() = _onNewValue.asSharedFlow()
+    protected val _onValueRemoved: MutableSharedFlow<Pair<Key, Value>> = MutableSharedFlow()
+    override val onValueRemoved: Flow<Pair<Key, Value>>
+        get() = _onValueRemoved.asSharedFlow()
+    protected val _onDataCleared: MutableSharedFlow<Key> = MutableSharedFlow()
+    override val onDataCleared: Flow<Key>
+        get() = _onDataCleared.asSharedFlow()
+
+    protected abstract fun insert(k: Key, v: Value, it: InsertStatement<Number>)
+
+    override suspend fun add(toAdd: Map<Key, List<Value>>) {
+        transaction(database) {
+            toAdd.keys.flatMap { k ->
+                toAdd[k] ?.mapNotNull { v ->
+                    if (select { selectById(k).and(selectByValue(v)) }.limit(1).any()) {
+                        return@mapNotNull null
+                    }
+                    val insertResult = insert {
+                        insert(k, v, it)
+                    }
+                    if (insertResult.insertedCount > 0) {
+                        k to v
+                    } else {
+                        null
+                    }
+                } ?: emptyList()
+            }
+        }.forEach { _onNewValue.emit(it) }
+    }
+
+    override suspend fun remove(toRemove: Map<Key, List<Value>>) {
+        transaction(database) {
+            toRemove.keys.flatMap { k ->
+                toRemove[k] ?.mapNotNull { v ->
+                    if (deleteWhere { selectById(k).and(selectByValue(v)) } > 0 ) {
+                        k to v
+                    } else {
+                        null
+                    }
+                } ?: emptyList()
+            }
+        }.forEach {
+            _onValueRemoved.emit(it)
+        }
+    }
+
+    override suspend fun clear(k: Key) {
+        transaction(database) {
+            deleteWhere { selectById(k) }
+        }.also { _onDataCleared.emit(k) }
+    }
+}

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/onetomany/AbstractExposedReadKeyValueRepo.kt

@@ -0,0 +1,74 @@
+package dev.inmo.micro_utils.repos.exposed.onetomany
+
+import dev.inmo.micro_utils.pagination.*
+import dev.inmo.micro_utils.repos.ReadKeyValueRepo
+import dev.inmo.micro_utils.repos.ReadKeyValuesRepo
+import dev.inmo.micro_utils.repos.exposed.*
+import dev.inmo.micro_utils.repos.exposed.utils.selectPaginated
+import org.jetbrains.exposed.sql.*
+import org.jetbrains.exposed.sql.SqlExpressionBuilder.eq
+import org.jetbrains.exposed.sql.transactions.transaction
+
+abstract class AbstractExposedReadKeyValuesRepo<Key, Value>(
+    override val database: Database,
+    tableName: String? = null
+) : ReadKeyValuesRepo<Key, Value>,
+    CommonExposedRepo<Key, Value>,
+    Table(tableName ?: "") {
+    abstract val keyColumn: Column<*>
+    abstract val ResultRow.asKey: Key
+    abstract val selectByValue: SqlExpressionBuilder.(Value) -> Op<Boolean>
+
+    override suspend fun count(k: Key): Long = transaction(database) { select { selectById(k) }.count() }
+
+    override suspend fun count(): Long = transaction(database) { selectAll().count() }
+
+    override suspend fun get(
+        k: Key,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Value> = transaction(database) {
+        select { selectById(k) }.selectPaginated(
+            pagination,
+            keyColumn,
+            reversed
+        ) {
+            it.asObject
+        }
+    }
+
+    override suspend fun keys(
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Key> = transaction(database) {
+        selectAll().selectPaginated(
+            pagination,
+            keyColumn,
+            reversed
+        ) {
+            it.asKey
+        }
+    }
+
+    override suspend fun keys(
+        v: Value,
+        pagination: Pagination,
+        reversed: Boolean
+    ): PaginationResult<Key> = transaction(database) {
+        select { selectByValue(v) }.selectPaginated(
+            pagination,
+            keyColumn,
+            reversed
+        ) {
+            it.asKey
+        }
+    }
+
+    override suspend fun contains(k: Key): Boolean = transaction(database) {
+        select { selectById(k) }.limit(1).any()
+    }
+
+    override suspend fun contains(k: Key, v: Value): Boolean = transaction(database) {
+        select { selectById(k).and(selectByValue(v)) }.limit(1).any()
+    }
+}

repos/exposed/src/jvmMain/kotlin/dev/inmo/micro_utils/repos/exposed/utils/PaginatedSelect.kt

@@ -0,0 +1,21 @@
+package dev.inmo.micro_utils.repos.exposed.utils
+
+import dev.inmo.micro_utils.pagination.*
+import org.jetbrains.exposed.sql.*
+
+fun <T> Query.selectPaginated(
+    pagination: Pagination,
+    orderBy: Pair<Expression<*>, SortOrder>? = null,
+    createResult: (ResultRow) -> T
+): PaginationResult<T> {
+    val count = count()
+    val list = paginate(pagination, orderBy).map(createResult)
+    return list.createPaginationResult(pagination, count)
+}
+
+fun <T> Query.selectPaginated(
+    pagination: Pagination,
+    orderBy: Expression<*>?,
+    reversed: Boolean = false,
+    createResult: (ResultRow) -> T
+) = selectPaginated(pagination, orderBy ?.let { it to if (reversed) SortOrder.DESC else SortOrder.ASC }, createResult)