[python] Probe one null row so decimal-precision casts are validated

can_execute_cast probed an empty array, which only resolves the PyArrow cast
kernel. Some kernels still reject the target type parameters on non-empty input:
INT -> DECIMAL(10, 2) has a kernel but needs precision >= 12 to hold an int's
range at scale 2 (BIGINT needs >= 21), so the empty probe accepted it, the alter
succeeded, and reading an old file failed with ArrowInvalid "Precision is not
great enough".

Probe a single null row instead. It triggers PyArrow's static type-parameter
validation (decimal precision sufficiency) while a null value avoids per-value
parse/overflow errors that safe=False -- matching the read path -- tolerates.

Author: TheR1sing3un

paimon-python/pypaimon/casting/data_type_casts.py

@@ -239,11 +239,16 @@ def _pyarrow_cast_supported(source_type, target_type) -> bool:
     cached = _EXECUTABLE_CAST_CACHE.get(cache_key)
     if cached is not None:
         return cached
-    # An empty-array cast exercises only kernel resolution (not per-value
-    # conversion), so it reports whether PyArrow has a cast kernel for the pair
-    # without depending on any data. ``safe=False`` matches the read path.
+    # Probe a one-row (null-valued) array rather than an empty one. An empty
+    # array only resolves the cast kernel; some kernels additionally reject the
+    # target type parameters on any non-empty input -- e.g. INT -> DECIMAL(10,2)
+    # has a kernel but needs precision >= 12 to hold an int's range at scale 2,
+    # so an empty probe passes yet the read later fails with ArrowInvalid. A
+    # single null row triggers that static type-parameter validation while
+    # avoiding per-value parse/overflow errors (which ``safe=False`` -- matching
+    # the read path -- tolerates anyway).
     try:
-        pa.array([], type=source_pa).cast(target_pa, safe=False)
+        pa.nulls(1, type=source_pa).cast(target_pa, safe=False)
         ok = True
     except (pa.lib.ArrowNotImplementedError, pa.lib.ArrowInvalid,
             pa.lib.ArrowTypeError):

paimon-python/pypaimon/tests/filesystem_catalog_test.py

@@ -283,13 +283,24 @@ def test_update_column_type_rejects_non_executable_cast(self):
                 False)
         self.assertIn("no executable cast", str(ctx.exception))
 
-        # An executable widening still succeeds.
+        # INT -> DECIMAL(10, 2) has a PyArrow kernel but the target precision is
+        # too small to hold an int's range at scale 2 (needs >= 12); the read
+        # path would fail with ArrowInvalid, so reject it at alter time too.
+        with self.assertRaises(RuntimeError) as ctx:
+            catalog.alter_table(
+                identifier,
+                [SchemaChange.update_column_type(
+                    "k", AtomicType("DECIMAL(10, 2)"))],
+                False)
+        self.assertIn("no executable cast", str(ctx.exception))
+
+        # A wide-enough DECIMAL is executable and succeeds.
         catalog.alter_table(
             identifier,
-            [SchemaChange.update_column_type("k", AtomicType("BIGINT"))],
+            [SchemaChange.update_column_type("k", AtomicType("DECIMAL(12, 2)"))],
             False)
         table = catalog.get_table(identifier)
-        self.assertEqual(table.fields[0].type.type, "BIGINT")
+        self.assertEqual(table.fields[0].type.type, "DECIMAL(12, 2)")
 
     def test_add_column_before_partition(self):
         catalog = CatalogFactory.create({

paimon-python/pypaimon/tests/schema_evolution_nested_read_test.py

@@ -36,7 +36,7 @@
 import pyarrow as pa
 
 from pypaimon import CatalogFactory, Schema
-from pypaimon.casting.data_type_casts import supports_cast
+from pypaimon.casting.data_type_casts import can_execute_cast, supports_cast
 from pypaimon.schema.data_types import (ArrayType, AtomicInteger, AtomicType,
                                         DataField, MapType, MultisetType,
                                         PyarrowFieldParser, RowType,
@@ -728,6 +728,21 @@ def test_unsupported_casts(self):
             self.assertFalse(supports_cast(AtomicType(src), AtomicType(dst)),
                              '{} -> {}'.format(src, dst))
 
+    def test_can_execute_cast_decimal_precision(self):
+        # A numeric -> decimal cast has a PyArrow kernel but is only executable
+        # when the target precision can hold the source's range at the target
+        # scale (INT needs >= 12 at scale 2, BIGINT >= 21). An empty-array probe
+        # misses this; can_execute_cast must reject the too-small targets so the
+        # read path does not later fail with ArrowInvalid.
+        for src, dst in [('INT', 'DECIMAL(10, 2)'), ('BIGINT', 'DECIMAL(10, 2)'),
+                         ('BIGINT', 'DECIMAL(20, 2)')]:
+            self.assertFalse(can_execute_cast(AtomicType(src), AtomicType(dst)),
+                             '{} -> {}'.format(src, dst))
+        for src, dst in [('INT', 'DECIMAL(12, 2)'), ('BIGINT', 'DECIMAL(21, 2)'),
+                         ('INT', 'BIGINT'), ('DOUBLE', 'INT'), ('INT', 'STRING')]:
+            self.assertTrue(can_execute_cast(AtomicType(src), AtomicType(dst)),
+                            '{} -> {}'.format(src, dst))
+
     def test_constructed_to_string(self):
         # ROW/ARRAY/MAP have a read-time string rendering; vector and
         # multiset do not, so their type change must be rejected.