Merge pull request #165 from alien11689/add-distinct-on-postgresql-extension

Add distinct on postgresql extension

Author: pjagielski

README.md

@@ -316,6 +316,52 @@ object MyTable : Table("test") {
 }
 ```
 
+### Support for Postgresql `distinct on (...)`
+
+Postgresql allows usage of nonstandard clause [`DISTINCT ON` in queries](https://www.postgresql.org/docs/current/sql-select.html).
+
+Krush provides custom `distinctOn` extension method which can be used as first parameter in custom `slice` extension method.
+
+**Postgresql specific extensions needs `krush-runtime-postgresql` dependency in maven or gradle**
+
+Example code:
+
+```kotlin
+@JvmInline
+value class MyStringId(val raw: String)
+
+@JvmInline
+value class MyVersion(val raw: Int)
+
+fun Table.myStringId(name: String) = stringWrapper(name, ::MyStringId) { it.raw }
+
+fun Table.myVersion(name: String) = integerWrapper(name, ::MyVersion) { it.raw }
+
+
+object MyTable : Table("test") {
+    val id = myStringId("my_id").nullable()
+    val version = myVersion("my_version").nullable()
+    val content = jsonb("content").nullable()
+}
+
+fun findNewestContentVersion(id: MyStringId): String? =
+    MyTable
+        .slice(MyTable.id.distinctOn(), MyTable.content)
+        .select { MyTable.id eq id }
+        .orderBy(MyTable.id to SortOrder.ASC, MyTable.version to SortOrder.DESC)
+        .map { it[MyTable.content] }
+        .firstOrNull()
+```
+
+when `findNewestContentVersion(MyStringId("123"))` is called  will generate SQL:
+
+```postgresql
+SELECT DISTINCT ON (test.my_id) TRUE, test.my_id, test."content"
+FROM test
+WHERE test.my_id = '123'
+ORDER BY test.my_id ASC, test.my_version DESC
+```
+
 ### Example projects
 
 * [https://github.com/TouK/kotlin-exposed-realworld](https://github.com/TouK/kotlin-exposed-realworld)

example/src/main/kotlin/pl/touk/krush/distincton/SimpleVersionedJsonContent.kt

@@ -0,0 +1,47 @@
+package pl.touk.krush.distincton
+
+import org.jetbrains.exposed.sql.SortOrder
+import org.jetbrains.exposed.sql.Table
+import org.jetbrains.exposed.sql.insert
+import org.jetbrains.exposed.sql.max
+import org.jetbrains.exposed.sql.select
+import pl.touk.krush.distinctOn
+import pl.touk.krush.jsonb
+import pl.touk.krush.slice
+
+object SimpleVersionedJsonContent : Table("simple_versioned_json_content") {
+    val id = contentId("id")
+    val version = version("version")
+    val content = jsonb("content")
+
+    fun insert(id: ContentId, content: String) {
+        SimpleVersionedJsonContent.insert {
+            it[SimpleVersionedJsonContent.id] = id
+            it[SimpleVersionedJsonContent.content] = content
+            it[SimpleVersionedJsonContent.version] = findNewestVersion(id)?.increment() ?: Version.initial
+        }
+    }
+
+    fun findNewestContent(id: ContentId): String? =
+        SimpleVersionedJsonContent
+            .slice(SimpleVersionedJsonContent.id.distinctOn(), SimpleVersionedJsonContent.content)
+            .select { SimpleVersionedJsonContent.id eq id }
+            .orderBy(SimpleVersionedJsonContent.id to SortOrder.ASC, SimpleVersionedJsonContent.version to SortOrder.DESC)
+            .map { it[SimpleVersionedJsonContent.content] }
+            .firstOrNull()
+
+    fun findOldestContent(id: ContentId): String? =
+        SimpleVersionedJsonContent
+            .slice(SimpleVersionedJsonContent.id.distinctOn(), SimpleVersionedJsonContent.content)
+            .select { SimpleVersionedJsonContent.id eq id }
+            .orderBy(SimpleVersionedJsonContent.id to SortOrder.ASC, SimpleVersionedJsonContent.version to SortOrder.ASC)
+            .map { it[SimpleVersionedJsonContent.content] }
+            .firstOrNull()
+
+    private fun findNewestVersion(id: ContentId): Version? =
+        SimpleVersionedJsonContent
+            .slice(SimpleVersionedJsonContent.version.max())
+            .select { SimpleVersionedJsonContent.id eq id }
+            .map { it[SimpleVersionedJsonContent.version.max()] }
+            .firstOrNull()
+}

example/src/main/kotlin/pl/touk/krush/distincton/TenantVersionedJsonContent.kt

@@ -0,0 +1,51 @@
+package pl.touk.krush.distincton
+
+import org.jetbrains.exposed.sql.SortOrder
+import org.jetbrains.exposed.sql.Table
+import org.jetbrains.exposed.sql.and
+import org.jetbrains.exposed.sql.insert
+import org.jetbrains.exposed.sql.max
+import org.jetbrains.exposed.sql.select
+import org.jetbrains.exposed.sql.selectAll
+import pl.touk.krush.distinctOn
+import pl.touk.krush.jsonb
+import pl.touk.krush.slice
+
+data class TenantJsonContent(val id: ContentId, val tenantId: TenantId, val content: String)
+
+object TenantVersionedJsonContent : Table("tenant_versioned_json_content") {
+    val id = contentId("id")
+    val tenantId = tenantId("tenant_id")
+    val version = version("version")
+    val content = jsonb("content")
+
+    fun insert(tenantJsonContent: TenantJsonContent) {
+        val currentVersion = findNewestVersion(tenantJsonContent.id, tenantJsonContent.tenantId)
+        TenantVersionedJsonContent.insert {
+            it[id] = tenantJsonContent.id
+            it[tenantId] = tenantJsonContent.tenantId
+            it[content] = tenantJsonContent.content
+            it[version] = currentVersion?.increment() ?: Version.initial
+        }
+    }
+
+    fun getNewestContents(): List<TenantJsonContent> =
+        TenantVersionedJsonContent
+            .slice(distinctOn(id, tenantId), content)
+            .selectAll()
+            .orderBy(id to SortOrder.ASC, tenantId to SortOrder.ASC, version to SortOrder.DESC)
+            .map {
+                TenantJsonContent(
+                    id = it[id],
+                    tenantId = it[tenantId],
+                    content = it[content],
+                )
+            }
+
+    private fun findNewestVersion(id: ContentId, tenantId: TenantId): Version? =
+        TenantVersionedJsonContent
+            .slice(version.max())
+            .select { TenantVersionedJsonContent.id eq id and (TenantVersionedJsonContent.tenantId eq tenantId) }
+            .map { it[version.max()] }
+            .firstOrNull()
+}

example/src/main/kotlin/pl/touk/krush/distincton/model.kt

@@ -0,0 +1,34 @@
+package pl.touk.krush.distincton
+
+import org.jetbrains.exposed.sql.Table
+import pl.touk.krush.integerWrapper
+import pl.touk.krush.uuidWrapper
+import java.util.UUID
+
+@JvmInline
+value class ContentId(val raw: UUID) {
+    companion object {
+        fun generate(): ContentId = ContentId(UUID.randomUUID())
+    }
+}
+
+@JvmInline
+value class TenantId(val raw: UUID) {
+    companion object {
+        fun generate(): TenantId = TenantId(UUID.randomUUID())
+    }
+}
+
+@JvmInline
+value class Version(val raw: Int) : Comparable<Version> {
+    override fun compareTo(other: Version): Int = raw.compareTo(other.raw)
+    fun increment(): Version = Version(raw + 1)
+
+    companion object {
+        val initial: Version = Version(1)
+    }
+}
+
+fun Table.contentId(name: String) = uuidWrapper(name, ::ContentId) { it.raw }
+fun Table.tenantId(name: String) = uuidWrapper(name, ::TenantId) { it.raw }
+fun Table.version(name: String) = integerWrapper(name, ::Version) { it.raw }

example/src/main/resources/db/migration/V1__tables.sql

@@ -36,4 +36,21 @@ CREATE TABLE IF NOT EXISTS reasons (
     id serial primary key,
     reason varchar,
     details json
-)
+);
+
+CREATE TABLE IF NOT EXISTS simple_versioned_json_content
+(
+    id      UUID  NOT NULL,
+    version INT   NOT NULL,
+    content jsonb NOT NULL,
+    CONSTRAINT pk_simple_versioned_json_content PRIMARY KEY (id, version)
+);
+
+CREATE TABLE IF NOT EXISTS tenant_versioned_json_content
+(
+    id        UUID  NOT NULL,
+    tenant_id UUID  NOT NULL,
+    version   INT   NOT NULL,
+    content   jsonb NOT NULL,
+    CONSTRAINT pk_tenant_versioned_json_content PRIMARY KEY (id, tenant_id, version)
+);

example/src/test/kotlin/pl/touk/krush/distincton/SimpleVersionedJsonContentTest.kt

@@ -0,0 +1,41 @@
+package pl.touk.krush.distincton
+
+import org.assertj.core.api.Assertions.assertThat
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.junit.jupiter.api.BeforeAll
+import org.junit.jupiter.api.Test
+import pl.touk.krush.base.BaseDatabaseTest
+
+class SimpleVersionedJsonContentTest : BaseDatabaseTest() {
+
+    private val contentId1 = ContentId.generate()
+    private val contentId2 = ContentId.generate()
+
+    @BeforeAll
+    fun insertTestData() {
+        transaction {
+            SimpleVersionedJsonContent.insert(contentId1, "\"{'field1': 'value1'}\"")
+            SimpleVersionedJsonContent.insert(contentId1, "\"{'field1': 'value2', 'field2': 10}\"")
+            SimpleVersionedJsonContent.insert(contentId2, "\"{'field1': 'value3', 'field3': 5}\"")
+            SimpleVersionedJsonContent.insert(contentId2, "\"{'field1': 'value4', 'field4': 7}\"")
+        }
+    }
+
+    @Test
+    fun shouldGetNewestContent() {
+        transaction {
+            assertThat(SimpleVersionedJsonContent.findNewestContent(contentId1)).isEqualTo("\"{'field1': 'value2', 'field2': 10}\"")
+            assertThat(SimpleVersionedJsonContent.findNewestContent(contentId2)).isEqualTo("\"{'field1': 'value4', 'field4': 7}\"")
+            assertThat(SimpleVersionedJsonContent.findNewestContent(ContentId.generate())).isNull()
+        }
+    }
+
+    @Test
+    fun shouldGetOldestContent() {
+        transaction {
+            assertThat(SimpleVersionedJsonContent.findOldestContent(contentId1)).isEqualTo("\"{'field1': 'value1'}\"")
+            assertThat(SimpleVersionedJsonContent.findOldestContent(contentId2)).isEqualTo("\"{'field1': 'value3', 'field3': 5}\"")
+            assertThat(SimpleVersionedJsonContent.findOldestContent(ContentId.generate())).isNull()
+        }
+    }
+}

example/src/test/kotlin/pl/touk/krush/distincton/TenantVersionedJsonContentTest.kt

@@ -0,0 +1,34 @@
+package pl.touk.krush.distincton
+
+import org.assertj.core.api.Assertions.assertThat
+import org.jetbrains.exposed.sql.transactions.transaction
+import org.junit.jupiter.api.Test
+import pl.touk.krush.base.BaseDatabaseTest
+
+class TenantVersionedJsonContentTest : BaseDatabaseTest() {
+
+    @Test
+    fun shouldGetNewestContents() {
+        val contentId1 = ContentId.generate()
+        val contentId2 = ContentId.generate()
+
+        val tenantId1 = TenantId.generate()
+        val tenantId2 = TenantId.generate()
+
+        transaction {
+            TenantVersionedJsonContent.insert(TenantJsonContent(contentId1, tenantId1, "\"{'field1': 'value1'}\""))
+            TenantVersionedJsonContent.insert(TenantJsonContent(contentId1, tenantId1, "\"{'field1': 'value2', 'field2': 10}\""))
+            TenantVersionedJsonContent.insert(TenantJsonContent(contentId2, tenantId1, "\"{'field1': 'value3', 'field3': 5}\""))
+            TenantVersionedJsonContent.insert(TenantJsonContent(contentId1, tenantId2, "\"{'field1': 'value4', 'field3': 7}\""))
+            TenantVersionedJsonContent.insert(TenantJsonContent(contentId1, tenantId2, "\"{'field1': 'value5', 'field3': 7}\""))
+        }
+
+        transaction {
+            assertThat(TenantVersionedJsonContent.getNewestContents()).containsExactlyInAnyOrder(
+                TenantJsonContent(contentId1, tenantId1, "\"{'field1': 'value2', 'field2': 10}\""),
+                TenantJsonContent(contentId2, tenantId1, "\"{'field1': 'value3', 'field3': 5}\""),
+                TenantJsonContent(contentId1, tenantId2, "\"{'field1': 'value5', 'field3': 7}\""),
+            )
+        }
+    }
+}

runtime-postgresql/src/main/kotlin/pl/touk/krush/DistinctOn.kt

@@ -0,0 +1,52 @@
+package pl.touk.krush
+
+import org.jetbrains.exposed.sql.Column
+import org.jetbrains.exposed.sql.Expression
+import org.jetbrains.exposed.sql.ExpressionWithColumnType
+import org.jetbrains.exposed.sql.FieldSet
+import org.jetbrains.exposed.sql.Function
+import org.jetbrains.exposed.sql.QueryBuilder
+import org.jetbrains.exposed.sql.Slice
+import org.jetbrains.exposed.sql.Table
+
+/**
+ * There is no postgresql distinct on implemented yet (https://github.com/JetBrains/Exposed/issues/500)
+ *
+ * Current implementation assumes that:
+ * - `distinct on` can be used on single or multiple number of columns
+ * - all columns of `distinct on` clause are also columns present in the query
+ * - each column of `distinct on` clause can be referenced normally in `order by` etc.
+ *
+ * To allow above:
+ * - custom slice is introduced because it is less intrusive way to extend exposed with `distinct on` clause
+ * - after `distinct on (...)` there will be `TRUE` part added
+ */
+
+fun <T> Column<T>.distinctOn(): DistinctOnColumns<T> = DistinctOnColumns(this)
+
+fun <T> distinctOn(expr: ExpressionWithColumnType<T>, vararg others: Expression<*>) = DistinctOnColumns(expr, *others)
+
+fun Table.slice(distinctOnColumns: DistinctOnColumns<*>, vararg columns: Expression<*>): FieldSet {
+    val distinctOn = distinctOnColumns.toDistinctOn()
+    return Slice(this, listOf(distinctOn) + distinctOn.fieldset() + columns)
+}
+
+class DistinctOnColumns<T>(
+    private val expr: ExpressionWithColumnType<T>,
+    private vararg val others: Expression<*>,
+) {
+    fun toDistinctOn() = DistinctOn(expr, *others)
+}
+
+class DistinctOn<T>(
+    private val expr: ExpressionWithColumnType<T>,
+    private vararg val others: Expression<*>,
+) : Function<T>(expr.columnType) {
+    override fun toQueryBuilder(queryBuilder: QueryBuilder): Unit = queryBuilder {
+        append("DISTINCT ON(")
+        (fieldset()).appendTo(separator = ", ") { +it }
+        append(") TRUE")
+    }
+
+    fun fieldset() = listOf(expr) + others
+}