Various samples

Author: deusaquilus

build.gradle.kts

@@ -1,6 +1,6 @@
 plugins {
   kotlin("jvm") version "2.1.20" // Currently the plugin is only available for Kotlin-JVM
-  id("io.exoquery.exoquery-plugin") version "2.1.20-1.1.2.PL"
+  id("io.exoquery.exoquery-plugin") version "2.1.20-L.1.3.2.PL"
   kotlin("plugin.serialization") version "2.1.20"
 }
 
@@ -20,9 +20,8 @@ kotlin {
 }
 
 dependencies {
-  api("io.exoquery:exoquery-jdbc:0.1.0.PL-0.1.0")
+  api("io.exoquery:exoquery-runner-jdbc:L.1.3.2.PL-L.1.3.2")
   implementation("org.postgresql:postgresql:42.7.0")
-
   implementation("io.zonky.test:embedded-postgres:2.0.7")
   implementation("io.zonky.test.postgres:embedded-postgres-binaries-linux-amd64:16.2.0")
 
@@ -32,6 +31,23 @@ dependencies {
   testImplementation(kotlin("test-annotations-common"))
 }
 
+tasks.register<Jar>("customFatJar") {
+  // copy the standard `jar` task’s contents first
+  with(tasks.named<Jar>("jar").get())
+
+  manifest {
+    attributes["Main-Class"] = "com.baeldung.fatjar.Application"
+  }
+
+  archiveBaseName.set("all-in-one-jar")
+  duplicatesStrategy = DuplicatesStrategy.EXCLUDE
+
+  from({
+    configurations.runtimeClasspath.get()
+      .map { if (it.isDirectory) it else zipTree(it) }
+  })
+}
+
 // OPTIONAL: Make tests show in the build log even when they pass
 tasks.withType<Test>().configureEach {
   testLogging {
@@ -40,3 +56,7 @@ tasks.withType<Test>().configureEach {
     exceptionFormat = org.gradle.api.tasks.testing.logging.TestExceptionFormat.FULL
   }
 }
+
+configurations.forEach {
+  it.exclude(group = "com.sschr15.annotations", module = "jb-annotations-kmp")
+}

src/main/kotlin/io/exoquery/example/BetterKtorPathSyntax.kt

@@ -0,0 +1,47 @@
+package io.exoquery.example
+
+import kotlin.reflect.KClass
+
+interface Elem {
+  data class Static(val name: String) : Elem
+  object Variable : Elem
+}
+
+interface PathBase {
+  val elems: List<Elem>
+}
+data class Path0(override val elems: List<Elem>): PathBase
+data class Path1<T1>(override val elems: List<Elem>): PathBase
+data class Path2<T1, T2>(override val elems: List<Elem>): PathBase
+data class Path3<T1, T2, T3>(override val elems: List<Elem>): PathBase
+data class Path4<T1, T2, T3, T4>(override val elems: List<Elem>): PathBase
+
+fun <T1, R> Path1<T1>.then(then: (T1) -> R): R = TODO()
+fun <T1, T2, R> Path2<T1, T2>.then(then: (T1, T2) -> R): R = TODO()
+
+
+class Var<T>
+
+
+interface PathBuilder {
+  val root get(): Path0 = Path0(emptyList())
+  operator fun Path0.div(other: String): Path0 = Path0(elems + Elem.Static(other))
+
+  operator fun <T1> Path0.div(other: Var<T1>): Path1<T1> = Path1(elems + Elem.Variable)
+  operator fun <T1> Path1<T1>.div(other: String): Path1<T1> = Path1(elems + Elem.Static(other))
+  operator fun <T1, T2> Path1<T1>.div(other: Var<T2>): Path2<T1, T2> = Path2(elems + Elem.Variable)
+}
+
+fun <P: PathBase> path(builder: PathBuilder.() -> P): P = TODO()
+
+object V {
+  val String: Var<kotlin.String> = Var()
+  val Int: Var<kotlin.Int> = Var()
+}
+
+
+fun myStuff() {
+  path { root/"foo"/V.String/"bar"/V.Int }.then { name: String, id: Int ->
+    println("id: $id, name: $name")
+  }
+}

src/main/kotlin/io/exoquery/example/Common.kt

@@ -0,0 +1,41 @@
+package io.exoquery.example
+
+import io.exoquery.controller.jdbc.JdbcController
+import io.exoquery.controller.jdbc.JdbcControllers
+import io.exoquery.controller.runActions
+import io.zonky.test.db.postgres.embedded.EmbeddedPostgres
+import javax.sql.DataSource
+
+object Common {
+
+
+  val postgres = EmbeddedPostgres.start()
+  val ds: DataSource = postgres.postgresDatabase
+
+  val postgresController = JdbcControllers.Postgres(ds)
+  suspend fun setupDB(ctx: JdbcController) {
+    ctx.runActions(
+      """
+      CREATE TABLE Person (
+        id SERIAL PRIMARY KEY,
+        name VARCHAR(255),
+        age INT
+      );
+      INSERT INTO Person (name, age) VALUES
+        ('Leib', 19),
+        ('Leah', 17),
+        ('Marina', 27),
+        ('Karina', 37);
+      CREATE TABLE Address (
+        ownerId INT,
+        street VARCHAR(255),
+        zip VARCHAR(255)
+      );
+      INSERT INTO Address (ownerId, street, zip) VALUES
+        (1, '123 St.', '12345'),
+        (2, '456 St.', '67890'),
+        (3, '789 St.', '54321');
+    """
+    )
+  }
+}

src/main/kotlin/io/exoquery/example/ExampleE.kt

@@ -0,0 +1,153 @@
+package io.exoquery.example
+
+import io.exoquery.annotation.CapturedFunction
+import io.exoquery.capture
+
+
+
+fun booleanLogicConversion_20250529() {
+
+data class Client(val name: String, val isRegistered: Boolean)
+
+val q =
+  capture.select {
+    val c = from(Table<Client>())
+    where { c.isRegistered || c.name == "Joe" }
+    Pair(c.name, c.isRegistered || c.name == "Joe")
+  }
+
+println(q.buildFor.Postgres().value)
+// SELECT p.name FROM Client AS p WHERE p.isRegistered OR p.name = 'Joe'
+
+println(q.buildFor.SqlServer().value)
+// SELECT p.name FROM Client AS p WHERE p.isRegistered = 1 OR p.name = 'Joe'
+
+
+}
+
+
+fun dateTypesOutOfTheBox_20250529() {
+
+
+
+data class Client(val name: String, val birthDate: kotlinx.datetime.LocalDate)
+val minBirthday = kotlinx.datetime.LocalDate(2000, 1, 1)
+
+val q =
+  capture.select {
+    val c = from(Table<Client>())
+    where { c.birthDate < param(minBirthday) } // use paramCtx for java.time.*
+    c.name
+  }
+
+println(q.buildFor.Postgres().value)
+
+
+}
+
+
+
+fun windowFunctions_20250530_A() {
+
+data class Customer(val name: String, val age: Int, val membership: String)
+
+val q =
+  capture.select {
+    val c = from(Table<Customer>())
+    Pair(
+      c.name,
+      // Average age of customers in the same membership group, ordered by name
+      over().partitionBy(c.membership).orderBy(c.name).avg(c.age)
+    )
+  }
+
+println(q.buildFor.Postgres().value)
+//> SELECT p.name, AVG(p.age) OVER (PARTITION BY p.membership ORDER BY p.name)
+//  FROM Customer AS p
+
+
+
+}
+
+
+
+
+fun windowFunctions_20250530_B() {
+
+data class Data(val name: String, val a: Int, val b: Int, val c: Int)
+
+
+data class Customer(val name: String, val age: Int, val membership: String)
+data class VipCustomer(val name: String, val statusAge: Int, val tier: Int)
+
+@CapturedFunction
+fun ntile(by: Customer, n: Int) = capture.expression {
+  over()
+    .partitionBy(by.membership)
+    .orderBy(by.age)
+    .frame(free("NTILE($n)").invoke<Int>())
+}
+
+
+@CapturedFunction
+fun ntileByAge(by: String, age: Int, n: Int) = capture.expression {
+  over()
+    .partitionBy(by)
+    .orderBy(age)
+    .frame(free("NTILE($n)").invoke<Int>())
+}
+
+
+
+
+
+val ntile2 = capture.expression {
+  { c: Customer, n: Int ->
+    over()
+      .partitionBy(c.membership)
+      .orderBy(c.age)
+      .sum(n)
+  }
+}
+
+val q =
+  capture.select {
+    val c = from(Table<Customer>())
+    Data(
+      c.name,
+      ntile(c, 5).use,
+      ntile(c, 10).use,
+      ntile(c, 20).use,
+    )
+  }
+
+  /*
+  ntileByAge(c.name, c.age, 5).use,
+      ntileByAge(c.name, c.age, 10).use,
+      ntileByAge(c.name, c.age, 20).use,
+   */
+
+
+println(q.buildFor.Postgres().value)
+
+}
+
+
+fun dateTypesOutOfTheBox_20250529_2() {
+
+data class Client(val name: String, val birthDate: java.time.LocalDate)
+val minBirthday = java.time.LocalDate.of(2000, 1, 1)
+val q =
+  capture.select {
+    val c = from(Table<Client>())
+    where { c.birthDate < paramCtx(minBirthday) }
+    c.name
+  }
+
+println(q.buildFor.Postgres().value)
+
+}
+
+fun paramsWithCustomSerialization_20250529() {
+
+}

src/main/kotlin/io/exoquery/example/ExamplesA.kt

@@ -0,0 +1,39 @@
+package io.exoquery.example
+
+import io.exoquery.capture
+
+fun correlatedExample1_20250520() {
+
+  val q = capture.select {
+    val p = from(Table<Person>())
+    where { p.age > Table<Person>().map { it.age }.avg() }
+    Pair(p.name, p.age)
+  }
+
+  println(q.buildFor.Postgres().value)
+}
+
+fun correlatedExample2_20250520() {
+  val q = capture.select {
+    val p = from(Table<Person>())
+    where { p.age >
+        Table<Person>().map { min(it.age) + avg(it.age) }.value()
+    }
+    Pair(p.name, p.age)
+  }
+
+  println(q.buildFor.Postgres().value)
+}
+
+fun nullabilityExample_20250521() {
+  val q = capture.select {
+    val p: Person   = from(Table<Person>())
+    val a: Address? = joinLeft(Table<Address>()) { p.id == it.ownerId }
+    Triple(p.name, a?.street ?: "defaultStreet", a?.zip ?: "defaultZip")
+  }
+
+  println(q.buildFor.Postgres().value)
+}
+
+fun main() {
+}

src/main/kotlin/io/exoquery/example/ExamplesB.kt

@@ -0,0 +1,34 @@
+package io.exoquery.example
+
+import io.exoquery.capture
+import io.exoquery.runOn
+import kotlinx.serialization.Serializable
+
+object ExamplesB {
+  val ctx = Common.postgresController
+
+  @JvmInline
+  @Serializable
+  value class PersonId(val id: Int)
+  @Serializable
+  data class Person(val id: PersonId, val name: String, val age: Int)
+  @Serializable
+  data class Address(val ownerId: PersonId, val street: String, val zip: String)
+
+  val myId = PersonId(1)
+  val q =
+    capture.select {
+      val p = from(Table<Person>())
+      val a = join(Table<Address>()) { p.id == it.ownerId }
+      where { p.id == param(myId) }
+      p to a
+    }
+
+  suspend fun valueExample_20250521() = q.buildFor.Postgres().runOn(ctx)
+}
+
+suspend fun main() {
+  Common.setupDB(Common.postgresController)
+  val result = ExamplesB.valueExample_20250521()
+  println(result)
+}