added tests for concat with empty columns, fixed bug in createColumnGuessing type

Author: Jolanrensen

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/api/concat.kt

@@ -24,7 +24,7 @@ internal fun <T> concatImpl(name: String, columns: List<DataColumn<T>>): DataCol
 internal fun <T> concatImpl(name: String, columns: List<DataColumn<T>?>, columnSizes: List<Int>): DataColumn<T> {
     when (columns.size) {
         0 -> return DataColumn.empty(name).cast()
-        1 -> return columns[0] ?: DataColumn.empty(name).cast()
+        1 -> return columns.single() ?: DataColumn.empty(name).cast()
     }
 
     if (columns.all { it == null || it.isColumnGroup() }) {

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/columns/constructors.kt

@@ -7,7 +7,6 @@ import org.jetbrains.kotlinx.dataframe.ColumnsContainer
 import org.jetbrains.kotlinx.dataframe.ColumnsSelector
 import org.jetbrains.kotlinx.dataframe.DataColumn
 import org.jetbrains.kotlinx.dataframe.DataFrame
-import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.Selector
 import org.jetbrains.kotlinx.dataframe.api.AddDataRow
 import org.jetbrains.kotlinx.dataframe.api.AddExpression
@@ -43,9 +42,9 @@ import org.jetbrains.kotlinx.dataframe.index
 import org.jetbrains.kotlinx.dataframe.nrow
 import org.jetbrains.kotlinx.dataframe.util.CREATE_COLUMN
 import org.jetbrains.kotlinx.dataframe.util.GUESS_COLUMN_TYPE
-import kotlin.reflect.KClass
 import kotlin.reflect.KType
 import kotlin.reflect.full.isSubtypeOf
+import kotlin.reflect.full.starProjectedType
 import kotlin.reflect.full.withNullability
 import kotlin.reflect.typeOf
 
@@ -262,10 +261,10 @@ internal fun <T> createColumnGuessingType(
         return { value -> if (value != null && value is Number) converter(value) else value }
     }
 
-    return when (type.classifier!! as KClass<*>) {
+    return when (type.classifier?.starProjectedType) {
         // guessValueType can only return DataRow if all values are `AnyRow?`
         // or allColsMakesColGroup == true, and all values are `AnyCol`
-        DataRow::class ->
+        typeOf<AnyRow>() ->
             if (allColsMakesColGroup && values.firstOrNull() is AnyCol) {
                 val df = dataFrameOf(values as Iterable<AnyCol>)
                 DataColumn.createColumnGroup(name, df)
@@ -276,7 +275,7 @@ internal fun <T> createColumnGuessingType(
                 DataColumn.createColumnGroup(name, df)
             }.asDataColumn().cast()
 
-        DataFrame::class -> {
+        typeOf<AnyFrame>() -> {
             val frames = values.map {
                 when (it) {
                     null -> DataFrame.empty()
@@ -289,7 +288,7 @@ internal fun <T> createColumnGuessingType(
             DataColumn.createFrameColumn(name, frames).asDataColumn().cast()
         }
 
-        List::class -> {
+        typeOf<List<*>>() -> {
             val nullable = type.isMarkedNullable
             var isListOfRows: Boolean? = null
             val subType = type.arguments.first().type!! // List<T> -> T

core/src/test/kotlin/org/jetbrains/kotlinx/dataframe/api/concat.kt

@@ -1,6 +1,8 @@
 package org.jetbrains.kotlinx.dataframe.api
 
 import io.kotest.matchers.shouldBe
+import org.jetbrains.kotlinx.dataframe.DataColumn
+import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.junit.Test
 
 class ConcatTests {
@@ -9,7 +11,7 @@ class ConcatTests {
     fun `different types`() {
         val a by columnOf(1, 2)
         val b by columnOf(3.0, null)
-        a.concat(b) shouldBe columnOf(1, 2, 3.0, null).named("a")
+        a.concat(b) shouldBe columnOf<Number?>(1, 2, 3.0, null).named("a")
     }
 
     @Test
@@ -23,4 +25,28 @@ class ConcatTests {
 
         dfWithCategory.columnNames() shouldBe listOf("value", "type", "category")
     }
+
+    @Test
+    fun `concat empty DataFrames no rows`() {
+        val dfWithSchema = DataFrame.emptyOf<Pair<Int, String>>()
+        (dfWithSchema concat dfWithSchema).let { concatenated ->
+            concatenated shouldBe dfWithSchema
+            concatenated.schema() shouldBe dfWithSchema.schema()
+        }
+
+        val dfNothingCols = dataFrameOf(
+            "a" to DataColumn.empty(),
+            "b" to DataColumn.empty(),
+        )
+        (dfNothingCols concat dfNothingCols).let { concatenated ->
+            concatenated shouldBe dfNothingCols
+            concatenated.schema() shouldBe dfNothingCols.schema()
+        }
+    }
+
+    @Test
+    fun `concat empty DataFrames no cols`() {
+        val dfNoCols = DataFrame.empty(5)
+        (dfNoCols concat dfNoCols) shouldBe DataFrame.empty(10)
+    }
 }