[Kernel] Add isNested method to DataType class (delta-io#4722)

#### Which Delta project/connector is this regarding?

- [ ] Spark
- [ ] Standalone
- [ ] Flink
- [x] Kernel
- [ ] Other (fill in here)

## Description

This method centralizes the concept of isNested to the DataType class
instead of individual helper methods. Resolves
delta-io#4571

## How was this patch tested?

Unit tests.

## Does this PR introduce _any_ user-facing changes?

Yes, it adds a new API method isNested.

Author: emkornfield

kernel/kernel-api/src/main/java/io/delta/kernel/internal/types/DataTypeJsonSerDe.java

@@ -282,7 +282,7 @@ private static StructField fixupFieldLevelMetadata(
         }
         List<TypeChange> changes = pathToTypeChanges.get(pathFromAncestor);
         if (changes != null) {
-          if (isNested(element.getField().getDataType())) {
+          if (element.getField().getDataType().isNested()) {
             throw new KernelException(
                 format("Invalid data type for type change: \"%s\"", element.getField()));
           }
@@ -304,12 +304,6 @@ private static StructField fixupFieldLevelMetadata(
     return structField;
   }
 
-  private static boolean isNested(DataType dataType) {
-    return dataType instanceof StructType
-        || dataType instanceof MapType
-        || dataType instanceof ArrayType;
-  }
-
   private static void updateCollation(
       SchemaIterable.MutableSchemaElement element,
       FieldMetadata collationsMetadata,

kernel/kernel-api/src/main/java/io/delta/kernel/internal/util/SchemaUtils.java

@@ -412,8 +412,8 @@ static SchemaChanges computeSchemaChangesById(StructType currentSchema, StructTy
       }
 
       if (!existingField.equals(newField)) {
-        if (!isNestedType(existingField)
-            && !isNestedType(newField)
+        if (!existingField.getDataType().isNested()
+            && !newField.getDataType().isNested()
             && !existingField.getDataType().equivalent(newField.getDataType())) {
           // Type changes only apply to non-nested types.  This loop evaluates both
           // nested and non-nested, so we narrow down updates here. Actual type differences
@@ -434,12 +434,6 @@ static SchemaChanges computeSchemaChangesById(StructType currentSchema, StructTy
     return schemaDiff.build();
   }
 
-  private static boolean isNestedType(StructField existingField) {
-    // TODO: Make is nested a centralized concept
-    DataType d = existingField.getDataType();
-    return d instanceof StructType || d instanceof ArrayType || d instanceof MapType;
-  }
-
   private static Map<SchemaElementId, StructField> fieldsByElementId(StructType schema) {
     Map<SchemaElementId, StructField> fieldIdToField = new HashMap<>();
     for (SchemaIterable.SchemaElement element : new SchemaIterable(schema)) {

kernel/kernel-api/src/main/java/io/delta/kernel/types/ArrayType.java

@@ -55,6 +55,11 @@ public boolean equivalent(DataType dataType) {
         && ((ArrayType) dataType).getElementType().equivalent(getElementType());
   }
 
+  @Override
+  public boolean isNested() {
+    return true;
+  }
+
   @Override
   public boolean equals(Object o) {
     if (this == o) {

kernel/kernel-api/src/main/java/io/delta/kernel/types/BasePrimitiveType.java

@@ -82,6 +82,11 @@ public boolean equals(Object o) {
     return primitiveTypeName.equals(that.primitiveTypeName);
   }
 
+  @Override
+  public boolean isNested() {
+    return false;
+  }
+
   @Override
   public int hashCode() {
     return Objects.hash(primitiveTypeName);

kernel/kernel-api/src/main/java/io/delta/kernel/types/DataType.java

@@ -36,6 +36,13 @@ public boolean equivalent(DataType dataType) {
     return equals(dataType);
   }
 
+  /**
+   * Returns true iff this data is a nested data type (it logically parameterized by other types).
+   *
+   * <p>For example StructType, ArrayType, MapType are nested data types.
+   */
+  public abstract boolean isNested();
+
   @Override
   public abstract int hashCode();
 

kernel/kernel-api/src/main/java/io/delta/kernel/types/DecimalType.java

@@ -57,6 +57,11 @@ public int getScale() {
     return scale;
   }
 
+  @Override
+  public boolean isNested() {
+    return false;
+  }
+
   @Override
   public String toString() {
     return String.format("Decimal(%d, %d)", precision, scale);

kernel/kernel-api/src/main/java/io/delta/kernel/types/MapType.java

@@ -83,6 +83,11 @@ public boolean equals(Object o) {
         && Objects.equals(valueField, mapType.valueField);
   }
 
+  @Override
+  public boolean isNested() {
+    return true;
+  }
+
   @Override
   public int hashCode() {
     return Objects.hash(keyField, valueField);

kernel/kernel-api/src/main/java/io/delta/kernel/types/StructType.java

@@ -134,6 +134,11 @@ public boolean equivalent(DataType dataType) {
             .allMatch(result -> result);
   }
 
+  @Override
+  public boolean isNested() {
+    return true;
+  }
+
   @Override
   public String toString() {
     return String.format(

kernel/kernel-api/src/test/scala/io/delta/kernel/types/TypesSuite.scala

@@ -0,0 +1,67 @@
+/*
+ * Copyright (2025) The Delta Lake Project Authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package io.delta.kernel.types
+
+import java.util.Arrays
+
+import org.scalatest.funsuite.AnyFunSuite
+
+class TypesSuite extends AnyFunSuite {
+  test("isNested - false") {
+    // All primitive types should return false for isNested
+    val primitiveTypes = Seq(
+      BinaryType.BINARY,
+      BooleanType.BOOLEAN,
+      ByteType.BYTE,
+      DateType.DATE,
+      new DecimalType(10, 2),
+      DoubleType.DOUBLE,
+      FloatType.FLOAT,
+      IntegerType.INTEGER,
+      LongType.LONG,
+      ShortType.SHORT,
+      StringType.STRING,
+      TimestampType.TIMESTAMP,
+      TimestampNTZType.TIMESTAMP_NTZ,
+      VariantType.VARIANT)
+
+    primitiveTypes.foreach { dataType =>
+      assert(!dataType.isNested(), s"Expected $dataType to not be nested")
+    }
+  }
+
+  test("isNested - nested types") {
+    // Create instances of nested types
+    val structFields = Arrays.asList(
+      new StructField("field1", IntegerType.INTEGER, true),
+      new StructField("field2", StringType.STRING, true))
+    val structType = new StructType(structFields)
+
+    val arrayType = new ArrayType(
+      new StructField("element", IntegerType.INTEGER, true))
+
+    val mapType = new MapType(
+      new StructField("key", StringType.STRING, false),
+      new StructField("value", IntegerType.INTEGER, true))
+
+    // All nested types should return true for isNested
+    val nestedTypes = Seq(structType, arrayType, mapType)
+
+    nestedTypes.foreach { dataType =>
+      assert(dataType.isNested(), s"Expected $dataType to be nested")
+    }
+  }
+}