Fix integral truediv and floordiv for pyarrow types with large divisor and avoid floating points for floordiv

pandas/core/arrays/arrow/array.py

@@ -127,12 +127,34 @@ def floordiv_compat(
         left: pa.ChunkedArray | pa.Array | pa.Scalar,
         right: pa.ChunkedArray | pa.Array | pa.Scalar,
     ) -> pa.ChunkedArray:
-        # Ensure int // int -> int mirroring Python/Numpy behavior
-        # as pc.floor(pc.divide_checked(int, int)) -> float
-        converted_left = cast_for_truediv(left, right)
-        result = pc.floor(pc.divide(converted_left, right))
-        if pa.types.is_integer(left.type) and pa.types.is_integer(right.type):
+        divided = pc.divide(left, right)
+        if pa.types.is_integer(divided.type):
+            # GH 56676: avoid storing intermediate calculating in floating point type.
+            has_remainder = pc.not_equal(pc.multiply(divided, right), left)
+            result = pc.if_else(
+                # Pass a typed arrow scalar rather than stdlib int
+                # which always inferred as int64, to prevent overflow
+                # in case of large uint64 values.
+                pc.and_(
+                    pc.less(
+                        pc.bit_wise_xor(left, right), pa.scalar(0, type=divided.type)
+                    ),
+                    has_remainder,
+                ),
+                # GH 55561: floordiv should round towards negative infinity.
+                # pv.divide for integral types rounds towards 0.
+                # Avoid using subtract_checked which would incorrectly raise
+                # for -9223372036854775808 // 1, because if integer overflow
+                # occurs, then has_remainder should be false, and overflowed
+                # value is discarded.
+                pc.subtract(divided, pa.scalar(1, type=divided.type)),
+                divided,
+            )
+            # Ensure compatibility with older versions of pandas where
+            # int8 // int64 returned int8 rather than int64.
             result = result.cast(left.type)
+        else:
+            result = pc.floor(divided)
         return result
 
     ARROW_ARITHMETIC_FUNCS = {

pandas/tests/extension/test_arrow.py

@@ -3239,13 +3239,36 @@ def test_arrow_floordiv():
 
 
 def test_arrow_floordiv_large_values():
-    # GH 55561
+    # GH 56645
     a = pd.Series([1425801600000000000], dtype="int64[pyarrow]")
     expected = pd.Series([1425801600000], dtype="int64[pyarrow]")
     result = a // 1_000_000
     tm.assert_series_equal(result, expected)
 
 
+def test_arrow_floordiv_large_integral_result():
+    # GH 56676
+    a = pd.Series([18014398509481983, -9223372036854775808], dtype="int64[pyarrow]")
+    result = a // 1
+    tm.assert_series_equal(result, a)
+
+
+def test_arrow_floordiv_larger_divisor():
+    # GH 56676
+    a = pd.Series([-23], dtype="int64[pyarrow]")
+    result = a // 24
+    expected = pd.Series([-1], dtype="int64[pyarrow]")
+    tm.assert_series_equal(result, expected)
+
+
+def test_arrow_floordiv_no_overflow():
+    # GH 56676
+    a = pd.Series([9223372036854775808], dtype="uint64[pyarrow]")
+    b = pd.Series([1], dtype="uint64[pyarrow]")
+    result = a // b
+    tm.assert_series_equal(result, a)
+
+
 def test_string_to_datetime_parsing_cast():
     # GH 56266
     string_dates = ["2020-01-01 04:30:00", "2020-01-02 00:00:00", "2020-01-03 00:00:00"]