[SPARK-59249][SQL][FOLLOWUP] Include SQL type in Python UDT identity

### What changes were proposed in this pull request?

This is a follow-up to [SPARK-59249](https://issues.apache.org/jira/browse/SPARK-59249) and [`this commit`](ebb0bd2), which routed grouped-key ordering through `InternalRowComparableWrapper`'s shared ordering cache.

This PR includes both `pyUDT` and `sqlType` in `PythonUserDefinedType.equals` and `hashCode`.

`serializedPyClass` remains excluded from identity, and `acceptsType` retains its existing compatibility semantics.

The PR also adds regression coverage for the shared `InternalRowComparableWrapper` ordering cache in both lookup orders, plus focused equality and hash-code tests.

### Why are the changes needed?

`InternalRowComparableWrapper` caches generated orderings by data type. Python UDT equality previously considered only the Python class name, so UDTs with the same class name but different underlying SQL types could share a cache entry.

For example, binary and `UTF8_LCASE` string-backed UDTs could reuse the first generated comparator, producing lookup-order-dependent collation semantics.

### How was this patch tested?

Added regression tests to `InternalRowComparableWrapperSuite`, covering binary-first and UTF8_LCASE-first cache lookup orders, and to `DataTypeSuite`, covering equality, hash codes, differing SQL types, and exclusion of serialized Python class data.

Ran:

```
build/sbt \
  'catalyst/testOnly org.apache.spark.sql.catalyst.util.InternalRowComparableWrapperSuite' \
  'catalyst/testOnly org.apache.spark.sql.types.DataTypeSuite'
```

`InternalRowComparableWrapperSuite`: 7 passed; `DataTypeSuite`: 352 passed.

### Was this patch authored or co-authored using generative AI tooling?

Yes co-authored-by: OpenAI Codex GPT-5.6 sol.

Closes #58799 from lavanv11/sc-244639-python-udt-ordering.

Authored-by: Lavan Vivekanandasarma <lavan.vivek@databricks.com>
Signed-off-by: Yicong-Huang <17627829+Yicong-Huang@users.noreply.github.com>

Author: lavanv11

sql/api/src/main/scala/org/apache/spark/sql/types/UserDefinedType.scala

@@ -154,9 +154,9 @@ private[sql] class PythonUserDefinedType(
   }
 
   override def equals(other: Any): Boolean = other match {
-    case that: PythonUserDefinedType => pyUDT == that.pyUDT
+    case that: PythonUserDefinedType => pyUDT == that.pyUDT && sqlType == that.sqlType
     case _ => false
   }
 
-  override def hashCode(): Int = Objects.hashCode(pyUDT)
+  override def hashCode(): Int = Objects.hash(pyUDT, sqlType)
 }

sql/catalyst/src/test/scala/org/apache/spark/sql/catalyst/util/InternalRowComparableWrapperSuite.scala

@@ -17,16 +17,40 @@
 
 package org.apache.spark.sql.catalyst.util
 
+import java.util.UUID
+
 import org.apache.spark.SparkFunSuite
 import org.apache.spark.sql.catalyst.InternalRow
 import org.apache.spark.sql.catalyst.plans.physical.KeyedPartitioning
 import org.apache.spark.sql.types._
+import org.apache.spark.unsafe.types.UTF8String
 
 class InternalRowComparableWrapperSuite extends SparkFunSuite {
 
   private val structA = new StructType().add("a", IntegerType)
   private val structB = new StructType().add("b", IntegerType)
 
+  private def checkPythonUDTOrderingCache(binaryFirst: Boolean): Unit = {
+    // The cache lasts for the JVM, so use a name that no earlier test run could have populated.
+    val pyUDT = UUID.randomUUID().toString
+    val lcaseType = StringType("UTF8_LCASE")
+    def ordering(sqlType: DataType) = KeyedPartitioning.groupedKeyRowOrdering(
+      Seq(new PythonUserDefinedType(sqlType, pyUDT, "serializedPyClass")))
+
+    val (binaryOrdering, lcaseOrdering) = if (binaryFirst) {
+      val binaryOrdering = ordering(StringType)
+      (binaryOrdering, ordering(lcaseType))
+    } else {
+      val lcaseOrdering = ordering(lcaseType)
+      (ordering(StringType), lcaseOrdering)
+    }
+    val uppercase = InternalRow(UTF8String.fromString("A"))
+    val lowercase = InternalRow(UTF8String.fromString("a"))
+
+    assert(binaryOrdering.compare(uppercase, lowercase) !== 0)
+    assert(lcaseOrdering.compare(uppercase, lowercase) === 0)
+  }
+
   test("SPARK-59187: comparableTypes erases the naming and nothing else") {
     // The erasure has to answer exactly what `DataType.equalsStructurally` answers with
     // `ignoreNullability`, since that is the question two rows are asking of each other. Anything
@@ -95,6 +119,14 @@ class InternalRowComparableWrapperSuite extends SparkFunSuite {
     assert(KeyedPartitioning.groupedKeyRowOrdering(Seq(IntegerType, LongType)) eq wrapper.ordering)
   }
 
+  test("Python UDT ordering cache distinguishes SQL types with binary first") {
+    checkPythonUDTOrderingCache(binaryFirst = true)
+  }
+
+  test("Python UDT ordering cache distinguishes SQL types with UTF8_LCASE first") {
+    checkPythonUDTOrderingCache(binaryFirst = false)
+  }
+
   test("SPARK-59187: a factory answers for the types it settled on") {
     // A caller that reports a type list beside the rows a factory built takes it from here, so the
     // two cannot answer differently.

sql/catalyst/src/test/scala/org/apache/spark/sql/types/DataTypeSuite.scala

@@ -38,6 +38,18 @@ class DataTypeSuite extends SparkFunSuite with SQLHelper {
   private val UNICODE_COLLATION_ID = CollationFactory.collationNameToId("UNICODE")
   private val UTF8_LCASE_COLLATION_ID = CollationFactory.collationNameToId("UTF8_LCASE")
 
+  test("PythonUserDefinedType equality includes the SQL type") {
+    val pyUDT = "org.apache.spark.sql.types.ExamplePythonUDT"
+    val first = new PythonUserDefinedType(StringType, pyUDT, "firstSerializedClass")
+    val same = new PythonUserDefinedType(StringType, pyUDT, "secondSerializedClass")
+    val differentSqlType =
+      new PythonUserDefinedType(StringType("UTF8_LCASE"), pyUDT, "firstSerializedClass")
+
+    assert(first === same)
+    assert(first.hashCode === same.hashCode)
+    assert(first !== differentSqlType)
+  }
+
   test("construct an ArrayType") {
     val array = ArrayType(StringType)