added comparisonMode to ColumnSchema.Value

Author: Jolanrensen

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/impl/schema/DataFrameSchemaImpl.kt

@@ -23,25 +23,29 @@ public class DataFrameSchemaImpl(override val columns: Map<String, ColumnSchema>
         var result: CompareResult = Equals
 
         // check for each column in this schema if there is a column with the same name in the other schema
-        // - if so, those schemas for equality, taking comparisonMode into account
-        // - if not, consider the other schema derived from this (or unrelated if comparisonMode == STRICT)
+        // - if so, check those schemas for equality, taking comparisonMode into account
+        // - if not, consider the other schema derived from this (or unrelated (None) if comparisonMode == STRICT)
         this.columns.forEach { (thisColName, thisSchema) ->
             val otherSchema = other.columns[thisColName]
             result += when {
                 otherSchema != null -> {
-                    val comparison = thisSchema.compare(
-                        other = otherSchema,
-                        comparisonMode = if (comparisonMode == STRICT_FOR_NESTED_SCHEMAS) STRICT else comparisonMode,
-                    )
-                    if (comparison != Equals && comparisonMode == STRICT) None else comparison
+                    // increase comparisonMode strictness when dealing with nested schemas of FrameColumns or ColumnGroups
+                    val newComparisonMode =
+                        if (comparisonMode == STRICT_FOR_NESTED_SCHEMAS && thisSchema !is ColumnSchema.Value) {
+                            STRICT
+                        } else {
+                            comparisonMode
+                        }
+
+                    thisSchema.compare(other = otherSchema, comparisonMode = newComparisonMode)
                 }
 
                 else -> if (comparisonMode == STRICT) None else IsDerived
             }
             if (result == None) return None
         }
         // then check for each column in the other schema if there is a column with the same name in this schema
-        // if not, consider the other schema as super to this (or unrelated if comparisonMode == STRICT)
+        // if not, consider the other schema as super to this (or unrelated (None) if comparisonMode == STRICT)
         other.columns.forEach { (otherColName, _) ->
             if (this.columns[otherColName] != null) return@forEach
             result += if (comparisonMode == STRICT) None else IsSuper

core/src/main/kotlin/org/jetbrains/kotlinx/dataframe/schema/ColumnSchema.kt

@@ -6,7 +6,7 @@ import org.jetbrains.kotlinx.dataframe.DataFrame
 import org.jetbrains.kotlinx.dataframe.DataRow
 import org.jetbrains.kotlinx.dataframe.columns.ColumnKind
 import org.jetbrains.kotlinx.dataframe.schema.ComparisonMode.LENIENT
-import org.jetbrains.kotlinx.dataframe.schema.ComparisonMode.STRICT_FOR_NESTED_SCHEMAS
+import org.jetbrains.kotlinx.dataframe.schema.ComparisonMode.STRICT
 import kotlin.reflect.KType
 import kotlin.reflect.full.isSubtypeOf
 import kotlin.reflect.full.isSupertypeOf
@@ -41,9 +41,10 @@ public sealed class ColumnSchema {
         override val nullable: Boolean = type.isMarkedNullable
         override val contentType: KType? = null
 
-        public fun compare(other: Value): CompareResult =
+        public fun compare(other: Value, comparisonMode: ComparisonMode = LENIENT): CompareResult =
             when {
                 type == other.type -> CompareResult.Equals
+                comparisonMode == STRICT -> CompareResult.None
                 type.isSubtypeOf(other.type) -> CompareResult.IsDerived
                 type.isSupertypeOf(other.type) -> CompareResult.IsSuper
                 else -> CompareResult.None
@@ -95,7 +96,7 @@ public sealed class ColumnSchema {
         if (kind != other.kind) return CompareResult.None
         if (this === other) return CompareResult.Equals
         return when (this) {
-            is Value -> compare(other as Value)
+            is Value -> compare(other as Value, comparisonMode)
             is Group -> compare(other as Group, comparisonMode)
             is Frame -> compare(other as Frame, comparisonMode)
         }