Add tests for preferring Kotlin types

sqldelight-compiler/src/test/kotlin/app/cash/sqldelight/core/QueriesTypeTest.kt

@@ -743,6 +743,10 @@ class QueriesTypeTest {
       |SELECT *
       |FROM soupView
       |WHERE soup_token = ?;
+      |
+      |maxSoupBroth:
+      |SELECT MAX(soup_broth)
+      |FROM soupView;
       """.trimMargin(),
       temporaryFolder,
       fileName = "MyView.sq",
@@ -798,6 +802,22 @@ class QueriesTypeTest {
       |    )
       |  }
       |
+      |  public fun <T : Any> maxSoupBroth(mapper: (MAX: ChickenSoupBase.Broth?) -> T): Query<T> =
+      |      Query(-1_892_940_684, arrayOf("soupBase", "soup"), driver, "MyView.sq", "maxSoupBroth", ""${'"'}
+      |  |SELECT MAX(soup_broth)
+      |  |FROM soupView
+      |  ""${'"'}.trimMargin()) { cursor ->
+      |    mapper(
+      |      cursor.getBytes(0)?.let { soupBaseAdapter.soup_brothAdapter.decode(it) }
+      |    )
+      |  }
+      |
+      |  public fun maxSoupBroth(): Query<MaxSoupBroth> = maxSoupBroth { MAX ->
+      |    MaxSoupBroth(
+      |      MAX
+      |    )
+      |  }
+      |
       |  private inner class ForSoupTokenQuery<out T : Any>(
       |    public val soup_token: String,
       |    mapper: (SqlCursor) -> T,

sqldelight-compiler/src/test/kotlin/app/cash/sqldelight/core/queries/ExpressionTest.kt

@@ -10,9 +10,11 @@ import app.cash.sqldelight.core.dialects.textType
 import app.cash.sqldelight.test.util.FixtureCompiler
 import com.google.common.truth.Truth.assertThat
 import com.squareup.burst.BurstJUnit4
+import com.squareup.kotlinpoet.ClassName
 import com.squareup.kotlinpoet.DOUBLE
 import com.squareup.kotlinpoet.INT
 import com.squareup.kotlinpoet.LONG
+import com.squareup.kotlinpoet.STRING
 import com.squareup.kotlinpoet.asClassName
 import org.junit.Assume.assumeTrue
 import org.junit.Rule
@@ -376,6 +378,79 @@ class ExpressionTest {
     ).inOrder()
   }
 
+  @Test fun `coalesce returns the kotlin type for given homogeneous argument types`(dialect: TestDialect) {
+    val file = FixtureCompiler.parseSql(
+      """
+      |import com.example.Foo;
+      |
+      |CREATE TABLE test (
+      |  foo INTEGER AS Foo NOT NULL,
+      |  bar INTEGER AS Foo
+      |);
+      |
+      |someSelect:
+      |SELECT coalesce(foo, bar),
+      |       coalesce(bar, bar),
+      |       coalesce(foo, bar)
+      |FROM test;
+      """.trimMargin(),
+      tempFolder,
+      dialect = dialect.dialect,
+    )
+
+    val query = file.namedQueries.first()
+    assertThat(query.resultColumns.map { it.javaType }).containsExactly(
+      ClassName("com.example", "Foo"),
+      ClassName("com.example", "Foo").copy(nullable = true),
+      ClassName("com.example", "Foo"),
+    ).inOrder()
+  }
+
+  @Test fun `coalesce returns the dialect type for given heterogeneous argument types`(dialect: TestDialect) {
+    val dialectTextType = when {
+      dialect.dialect.isSqlite -> "TEXT"
+      else -> "VARCHAR(1)"
+    }
+
+    val file = FixtureCompiler.parseSql(
+      """
+      |import com.example.Foo;
+      |import com.example.Bar;
+      |
+      |CREATE TABLE test (
+      |  foo INTEGER AS Foo NOT NULL,
+      |  foo2 REAL AS Foo NOT NULL,
+      |  bar INTEGER AS Bar,
+      |  baz $dialectTextType
+      |);
+      |
+      |someSelect:
+      |SELECT coalesce(foo, bar),
+      |       coalesce(foo, foo2),
+      |       coalesce(foo, baz),
+      |       coalesce(bar, baz),
+      |       coalesce(foo, bar, baz)
+      |FROM test;
+      """.trimMargin(),
+      tempFolder,
+      dialect = dialect.dialect,
+    )
+
+    val integerKotlinType = when (dialect) {
+      POSTGRESQL, HSQL, MYSQL -> INT
+      else -> LONG
+    }
+
+    val query = file.namedQueries.first()
+    assertThat(query.resultColumns.map { it.javaType }).containsExactly(
+      integerKotlinType,
+      DOUBLE,
+      STRING,
+      STRING.copy(nullable = true),
+      STRING,
+    ).inOrder()
+  }
+
   @Test fun `max takes the proper type`(dialect: TestDialect) {
     val file = FixtureCompiler.parseSql(
       """
@@ -414,6 +489,76 @@ class ExpressionTest {
     ).inOrder()
   }
 
+  @Test fun `max returns the kotlin type for given heterogeneous argument types`(dialect: TestDialect) {
+    val file = FixtureCompiler.parseSql(
+      """
+      |import com.example.Foo;
+      |
+      |CREATE TABLE test (
+      |  foo INTEGER AS Foo NOT NULL,
+      |  bar INTEGER AS Foo
+      |);
+      |
+      |someSelect:
+      |SELECT max(foo),
+      |       max(foo, bar)
+      |FROM test;
+      """.trimMargin(),
+      tempFolder,
+      dialect = dialect.dialect,
+    )
+
+    val query = file.namedQueries.first()
+    assertThat(query.resultColumns.map { it.javaType }).containsExactly(
+      ClassName("com.example", "Foo").copy(nullable = true),
+      ClassName("com.example", "Foo").copy(nullable = true),
+    ).inOrder()
+  }
+
+    @Test fun `max returns the kotlin type for given homogeneous argument types`(dialect: TestDialect) {
+        val dialectTextType = when {
+            dialect.dialect.isSqlite -> "TEXT"
+            else -> "VARCHAR(1)"
+        }
+        val file = FixtureCompiler.parseSql(
+                """
+                |import com.example.Foo;
+                |import com.example.Bar;
+                |
+                |CREATE TABLE test (
+                |  foo INTEGER AS Foo NOT NULL,
+                |  foo2 REAL AS Foo NOT NULL,
+                |  bar INTEGER AS Bar,
+                |  baz $dialectTextType
+                |);
+                |
+                |someSelect:
+                |SELECT max(foo, bar),
+                |       max(foo, foo2),
+                |       max(foo, baz),
+                |       max(bar, baz),
+                |       max(foo, bar, baz)
+                |FROM test;
+                """.trimMargin(),
+                tempFolder,
+                dialect = dialect.dialect,
+        )
+
+        val integerKotlinType = when (dialect) {
+            POSTGRESQL, HSQL, MYSQL -> INT
+            else -> LONG
+        }
+
+        val query = file.namedQueries.first()
+        assertThat(query.resultColumns.map { it.javaType }).containsExactly(
+                integerKotlinType.copy(nullable = true),
+                DOUBLE.copy(nullable = true),
+                STRING.copy(nullable = true),
+                STRING.copy(nullable = true),
+                STRING.copy(nullable = true),
+        ).inOrder()
+    }
+
   @Test fun `case expression part of limit infers type`() {
     val file = FixtureCompiler.parseSql(
       """
@@ -472,6 +617,76 @@ class ExpressionTest {
     ).inOrder()
   }
 
+    @Test fun `min returns the kotlin type for given heterogeneous argument types`(dialect: TestDialect) {
+        val file = FixtureCompiler.parseSql(
+                """
+      |import com.example.Foo;
+      |
+      |CREATE TABLE test (
+      |  foo INTEGER AS Foo NOT NULL,
+      |  bar INTEGER AS Foo
+      |);
+      |
+      |someSelect:
+      |SELECT min(foo),
+      |       min(foo, bar)
+      |FROM test;
+      """.trimMargin(),
+                tempFolder,
+                dialect = dialect.dialect,
+        )
+
+        val query = file.namedQueries.first()
+        assertThat(query.resultColumns.map { it.javaType }).containsExactly(
+                ClassName("com.example", "Foo").copy(nullable = true),
+                ClassName("com.example", "Foo").copy(nullable = true),
+        ).inOrder()
+    }
+
+    @Test fun `min returns the kotlin type for given homogeneous argument types`(dialect: TestDialect) {
+        val dialectTextType = when {
+            dialect.dialect.isSqlite -> "TEXT"
+            else -> "VARCHAR(1)"
+        }
+        val file = FixtureCompiler.parseSql(
+                """
+                |import com.example.Foo;
+                |import com.example.Bar;
+                |
+                |CREATE TABLE test (
+                |  foo INTEGER AS Foo NOT NULL,
+                |  foo2 REAL AS Foo NOT NULL,
+                |  bar INTEGER AS Bar,
+                |  baz $dialectTextType
+                |);
+                |
+                |someSelect:
+                |SELECT min(foo, bar),
+                |       min(foo, foo2),
+                |       min(foo, baz),
+                |       min(bar, baz),
+                |       min(foo, bar, baz)
+                |FROM test;
+                """.trimMargin(),
+                tempFolder,
+                dialect = dialect.dialect,
+        )
+
+        val integerKotlinType = when (dialect) {
+            POSTGRESQL, HSQL, MYSQL -> INT
+            else -> LONG
+        }
+
+        val query = file.namedQueries.first()
+        assertThat(query.resultColumns.map { it.javaType }).containsExactly(
+                integerKotlinType.copy(nullable = true),
+                DOUBLE.copy(nullable = true),
+                integerKotlinType.copy(nullable = true),
+                integerKotlinType.copy(nullable = true),
+                integerKotlinType.copy(nullable = true),
+        ).inOrder()
+    }
+
   @Test fun `arithmetic on nullable type`() {
     val file = FixtureCompiler.parseSql(
       """

sqldelight-compiler/src/test/query-interface-fixtures/prefer-kotlin-type/com/sample/Data.sq

@@ -0,0 +1,17 @@
+import java.util.List;
+import kotlin.Boolean;
+import com.sample.Person;
+import com.squareup.Redacted;
+
+CREATE TABLE people (
+  _id INTEGER NOT NULL PRIMARY KEY,
+  person1 BLOB AS Person NOT NULL,
+  person2 BLOB AS Person
+);
+
+preferKotlinType:
+SELECT MAX(person1, person2) AS max_person,
+       MIN(person1, person2) AS min_person,
+       COALESCE(person2, person1) AS coalesce_person,
+       IFNULL(person2, person1) AS if_null_person
+FROM people;

sqldelight-compiler/src/test/query-interface-fixtures/prefer-kotlin-type/output/com/sample/PreferKotlinType.kt

@@ -0,0 +1,10 @@
+package com.sample
+
+import com.sample.person
+
+public data class PreferKotlinType(
+  public val max_person: Person?,
+  public val min_person: Person?,
+  public val coalesce_person: Person,
+  public val if_null_person: Person,
+)

sqldelight-compiler/src/test/view-interface-fixtures/requires-adapter/com/sample/Data.sq

@@ -19,3 +19,7 @@ FROM person;
 CREATE VIEW personCool AS
 SELECT *, CASE is_cool WHEN 1 THEN "cool" ELSE "lame" END AS how_cool
 FROM person;
+
+CREATE VIEW personAndMaxFriends AS
+SELECT *, MAX( friends ) AS max_friends
+FROM person;

sqldelight-compiler/src/test/view-interface-fixtures/requires-adapter/output/com/sample/PersonandMaxFriends.kt

@@ -0,0 +1,19 @@
+package com.sample
+
+import com.squareup.Redacted
+import java.util.List
+import kotlin.Boolean
+import kotlin.Long
+import kotlin.String
+
+public data class PersonAndMaxFriends(
+  public val _id: Long,
+  public val name: String,
+  public val last_name: String?,
+  public val is_cool: Boolean,
+  public val friends: List<Person>?,
+  @Redacted
+  public val shhh_its_secret: String,
+  public val how_cool: String,
+  public val max_friends: List<Person>?,
+)