apache
diff --git a/‎arrow/compute/internal/kernels/base_arithmetic.go‎
Lines changed: 2 additions & 2 deletions b/‎arrow/compute/internal/kernels/base_arithmetic.go‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎go.mod‎
Lines changed: 0 additions & 1 deletion b/‎go.mod‎
Lines changed: 0 additions & 1 deletion
diff --git a/‎go.sum‎
Lines changed: 0 additions & 2 deletions b/‎go.sum‎
Lines changed: 0 additions & 2 deletions
diff --git a/‎internal/utils/math.go‎
Lines changed: 94 additions & 1 deletion b/‎internal/utils/math.go‎
Lines changed: 94 additions & 1 deletion
diff --git a/‎internal/utils/math_32bit_test.go‎
Lines changed: 67 additions & 0 deletions b/‎internal/utils/math_32bit_test.go‎
Lines changed: 67 additions & 0 deletions
diff --git a/‎internal/utils/math_64bit_test.go‎
Lines changed: 67 additions & 0 deletions b/‎internal/utils/math_64bit_test.go‎
Lines changed: 67 additions & 0 deletions
@@ -23,12 +23,12 @@ import (
 	"math"
 	"math/bits"
 
-	"github.com/JohnCGriffin/overflow"
 	"github.com/apache/arrow-go/v18/arrow"
 	"github.com/apache/arrow-go/v18/arrow/compute/exec"
 	"github.com/apache/arrow-go/v18/arrow/decimal128"
 	"github.com/apache/arrow-go/v18/arrow/decimal256"
 	"github.com/apache/arrow-go/v18/arrow/internal/debug"
+	"github.com/apache/arrow-go/v18/internal/utils"
 	"golang.org/x/exp/constraints"
 )
 
@@ -709,7 +709,7 @@ func SubtractDate32(op ArithmeticOp) exec.ArrayKernelExec {
 	case OpSubChecked:
 		return ScalarBinary(getGoArithmeticBinary(func(a, b arrow.Time32, e *error) (result arrow.Duration) {
 			result = arrow.Duration(a) - arrow.Duration(b)
-			val, ok := overflow.Mul64(int64(result), secondsPerDay)
+			val, ok := utils.Mul64(int64(result), secondsPerDay)
 			if !ok {
 				*e = errOverflow
 			}
 
@@ -21,7 +21,6 @@ go 1.23.0
 toolchain go1.23.2
 
 require (
-	github.com/JohnCGriffin/overflow v0.0.0-20211019200055-46fa312c352c
 	github.com/andybalholm/brotli v1.1.1
 	github.com/apache/thrift v0.21.0
 	github.com/docopt/docopt-go v0.0.0-20180111231733-ee0de3bc6815
 
@@ -8,8 +8,6 @@ atomicgo.dev/schedule v0.1.0 h1:nTthAbhZS5YZmgYbb2+DH8uQIZcTlIrd4eYr3UQxEjs=
 atomicgo.dev/schedule v0.1.0/go.mod h1:xeUa3oAkiuHYh8bKiQBRojqAMq3PXXbJujjb0hw8pEU=
 cloud.google.com/go v0.118.0 h1:tvZe1mgqRxpiVa3XlIGMiPcEUbP1gNXELgD4y/IXmeQ=
 cloud.google.com/go v0.118.0/go.mod h1:zIt2pkedt/mo+DQjcT4/L3NDxzHPR29j5HcclNH+9PM=
-github.com/JohnCGriffin/overflow v0.0.0-20211019200055-46fa312c352c h1:RGWPOewvKIROun94nF7v2cua9qP+thov/7M50KEoeSU=
-github.com/JohnCGriffin/overflow v0.0.0-20211019200055-46fa312c352c/go.mod h1:X0CRv0ky0k6m906ixxpzmDRLvX58TFUKS2eePweuyxk=
 github.com/MarvinJWendt/testza v0.1.0/go.mod h1:7AxNvlfeHP7Z/hDQ5JtE3OKYT3XFUeLCDE2DQninSqs=
 github.com/MarvinJWendt/testza v0.2.1/go.mod h1:God7bhG8n6uQxwdScay+gjm9/LnO4D3kkcZX4hv9Rp8=
 github.com/MarvinJWendt/testza v0.2.8/go.mod h1:nwIcjmr0Zz+Rcwfh3/4UhBp7ePKVhuBExvZqnKYWlII=
 
@@ -16,7 +16,12 @@
 
 package utils
 
-import "golang.org/x/exp/constraints"
+import (
+	"math"
+	"math/bits"
+
+	"golang.org/x/exp/constraints"
+)
 
 func Min[T constraints.Ordered](a, b T) T {
 	if a < b {
@@ -31,3 +36,91 @@ func Max[T constraints.Ordered](a, b T) T {
 	}
 	return b
 }
+
+// Add returns the sum of two integers while checking for [overflow].
+// It returns false (not ok) when the operation overflows.
+//
+// [overflow]: https://go.dev/ref/spec#Integer_overflow
+func Add[T constraints.Signed](a, b T) (T, bool) {
+	// Overflow occurs when a and b are too positive or too negative.
+	// That is, when: (a > 0) && (b > 0) && (a > math.Max[T] - b)
+	// or when:       (a < 0) && (b < 0) && (a < math.Min[T] - b)
+	result := a + b
+
+	// No overflow occurred if the result is larger exactly when b is positive.
+	return result, (result > a) == (b > 0)
+}
+
+const (
+	sqrtMaxInt = 1<<((bits.UintSize>>1)-1) - 1
+	sqrtMinInt = -1 << ((bits.UintSize >> 1) - 1)
+)
+
+// Mul returns the product of two integers while checking for [overflow].
+// It returns false (not ok) when the operation overflows.
+//
+// [overflow]: https://go.dev/ref/spec#Integer_overflow
+func Mul(a, b int) (int, bool) {
+	// Avoid division by zero and calculate nothing when a or b is zero.
+	if a == 0 || b == 0 {
+		return 0, true
+	}
+
+	result := a * b
+
+	// Overflow occurred if the result is positive when exactly one input
+	// is negative.
+	if result > 0 == ((a < 0) != (b < 0)) {
+		return result, false
+	}
+
+	// Overflow cannot occur when a or b is zero or one.
+	// Overflow cannot occur when a and b are less positive than sqrt(MaxInt).
+	// Overflow cannot occur when a and b are less negative than sqrt(MinInt).
+	if (sqrtMinInt <= a && a <= sqrtMaxInt &&
+		sqrtMinInt <= b && b <= sqrtMaxInt) || a == 1 || b == 1 {
+		return result, true
+	}
+
+	// Finally, no overflow occurred if division produces the input. This is
+	// last because division can be expensive. Dividing by -1 can overflow,
+	// but we returned early in that case above.
+	return result, (result/a == b)
+}
+
+const (
+	sqrtMaxInt64 = math.MaxInt32
+	sqrtMinInt64 = math.MinInt32
+)
+
+// Mul64 returns the product of two integers while checking for [overflow].
+// It returns false (not ok) when the operation overflows.
+//
+// [overflow]: https://go.dev/ref/spec#Integer_overflow
+func Mul64(a, b int64) (int64, bool) {
+	// Avoid division by zero and calculate nothing when a or b is zero.
+	if a == 0 || b == 0 {
+		return 0, true
+	}
+
+	result := a * b
+
+	// Overflow occurred if the result is positive when exactly one input
+	// is negative.
+	if result > 0 == ((a < 0) != (b < 0)) {
+		return result, false
+	}
+
+	// Overflow cannot occur when a or b is zero or one.
+	// Overflow cannot occur when a and b are less positive than sqrt(MaxInt64).
+	// Overflow cannot occur when a and b are less negative than sqrt(MinInt64).
+	if (sqrtMinInt64 <= a && a <= sqrtMaxInt64 &&
+		sqrtMinInt64 <= b && b <= sqrtMaxInt64) || a == 1 || b == 1 {
+		return result, true
+	}
+
+	// Finally, no overflow occurred if division produces the input. This is
+	// last because division can be expensive. Dividing by -1 can overflow,
+	// but we returned early in that case above.
+	return result, (result/a == b)
+}
@@ -0,0 +1,67 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+//go:build 386 || arm || mips || ppc
+
+package utils
+
+import (
+	"math"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMul_32bit(t *testing.T) {
+	// These constants are smaller in magnitude than the exact square root.
+	assert.Greater(t, sqrtMinInt, int(math.Sqrt(math.MinInt32)))
+	assert.Less(t, sqrtMaxInt, int(math.Sqrt(math.MaxInt32)))
+
+	for _, tt := range []struct {
+		a, b, expected int
+		ok             bool
+	}{
+		{ok: true, a: math.MinInt16, b: 0, expected: 0},
+		{ok: true, a: math.MinInt16, b: 1, expected: math.MinInt16},
+		{ok: true, a: math.MinInt16, b: -1, expected: -math.MinInt16},
+
+		{ok: true, a: math.MaxInt16, b: 0, expected: 0},
+		{ok: true, a: math.MaxInt16, b: 1, expected: math.MaxInt16},
+		{ok: true, a: math.MaxInt16, b: -1, expected: -math.MaxInt16},
+
+		{ok: true, a: math.MinInt16, b: math.MinInt16, expected: 1073741824},
+		{ok: true, a: math.MaxInt16, b: math.MaxInt16, expected: 1073676289},
+		{ok: true, a: math.MinInt16, b: math.MaxInt16, expected: -1073709056},
+		{ok: true, a: math.MaxInt16, b: math.MinInt16, expected: -1073709056},
+
+		{ok: true, a: math.MinInt32, b: 0, expected: 0},
+		{ok: true, a: math.MinInt32, b: 1, expected: math.MinInt32},
+		{ok: false, a: math.MinInt32, b: -1, expected: math.MinInt32},
+		{ok: false, a: math.MinInt32, b: -2, expected: 0},
+		{ok: false, a: math.MinInt32, b: 2, expected: 0},
+
+		{ok: true, a: math.MaxInt32, b: 0, expected: 0},
+		{ok: true, a: math.MaxInt32, b: 1, expected: math.MaxInt32},
+		{ok: true, a: math.MaxInt32, b: -1, expected: -math.MaxInt32},
+		{ok: false, a: math.MaxInt32, b: -2, expected: 2},
+		{ok: false, a: math.MaxInt32, b: 2, expected: -2},
+	} {
+		actual, ok := Mul(tt.a, tt.b)
+		assert.Equal(t, tt.ok, ok, "(%v + %v)", tt.a, tt.b)
+		require.Equal(t, tt.expected, actual, "(%v + %v)", tt.a, tt.b)
+	}
+}
@@ -0,0 +1,67 @@
+// Licensed to the Apache Software Foundation (ASF) under one
+// or more contributor license agreements.  See the NOTICE file
+// distributed with this work for additional information
+// regarding copyright ownership.  The ASF licenses this file
+// to you 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.
+
+//go:build amd64 || arm64 || mips64 || ppc64 || s390x
+
+package utils
+
+import (
+	"math"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMul_64bit(t *testing.T) {
+	// These constants are smaller in magnitude than the exact square root.
+	assert.Greater(t, sqrtMinInt, int(math.Sqrt(math.MinInt64)))
+	assert.Less(t, sqrtMaxInt, int(math.Sqrt(math.MaxInt64)))
+
+	for _, tt := range []struct {
+		a, b, expected int
+		ok             bool
+	}{
+		{ok: true, a: math.MinInt32, b: 0, expected: 0},
+		{ok: true, a: math.MinInt32, b: 1, expected: math.MinInt32},
+		{ok: true, a: math.MinInt32, b: -1, expected: -math.MinInt32},
+
+		{ok: true, a: math.MaxInt32, b: 0, expected: 0},
+		{ok: true, a: math.MaxInt32, b: 1, expected: math.MaxInt32},
+		{ok: true, a: math.MaxInt32, b: -1, expected: -math.MaxInt32},
+
+		{ok: true, a: math.MinInt32, b: math.MinInt32, expected: 4611686018427387904},
+		{ok: true, a: math.MaxInt32, b: math.MaxInt32, expected: 4611686014132420609},
+		{ok: true, a: math.MinInt32, b: math.MaxInt32, expected: -4611686016279904256},
+		{ok: true, a: math.MaxInt32, b: math.MinInt32, expected: -4611686016279904256},
+
+		{ok: true, a: math.MinInt64, b: 0, expected: 0},
+		{ok: true, a: math.MinInt64, b: 1, expected: math.MinInt64},
+		{ok: false, a: math.MinInt64, b: -1, expected: math.MinInt64},
+		{ok: false, a: math.MinInt64, b: -2, expected: 0},
+		{ok: false, a: math.MinInt64, b: 2, expected: 0},
+
+		{ok: true, a: math.MaxInt64, b: 0, expected: 0},
+		{ok: true, a: math.MaxInt64, b: 1, expected: math.MaxInt64},
+		{ok: true, a: math.MaxInt64, b: -1, expected: -math.MaxInt64},
+		{ok: false, a: math.MaxInt64, b: -2, expected: 2},
+		{ok: false, a: math.MaxInt64, b: 2, expected: -2},
+	} {
+		actual, ok := Mul(tt.a, tt.b)
+		assert.Equal(t, tt.ok, ok, "(%v * %v)", tt.a, tt.b)
+		require.Equal(t, tt.expected, actual, "(%v * %v)", tt.a, tt.b)
+	}
+}