What causes "integer addition overflow: %s + %s" in prestodb/presto?

Cast operands to BIGINT before adding: CAST(a AS BIGINT) + CAST(b AS BIGINT)

prestodb/presto · error · PrestoException

NUMERIC_VALUE_OUT_OF_RANGE

NUMERIC_VALUE_OUT_OF_RANGE

Error message

integer addition overflow: %s + %s

What it means

Overflow guard in the INTEGER + INTEGER operator: Math.addExact detected that adding the two 32-bit operands would exceed INT range, so the engine raises NUMERIC_VALUE_OUT_OF_RANGE instead of silently wrapping. Both operands are formatted into the message; the fix is to cast operands to BIGINT or DOUBLE before adding.

Source

Thrown at presto-main-base/src/main/java/com/facebook/presto/type/IntegerOperators.java:72

import static io.airlift.slice.Slices.utf8Slice;
import static java.lang.Float.floatToRawIntBits;
import static java.lang.String.format;

public final class IntegerOperators
{
    private IntegerOperators()
    {
    }

    @ScalarOperator(ADD)
    @SqlType(StandardTypes.INTEGER)
    public static long add(@SqlType(StandardTypes.INTEGER) long left, @SqlType(StandardTypes.INTEGER) long right)
    {
        try {
            return Math.addExact((int) left, (int) right);
        }
        catch (ArithmeticException e) {
            throw new PrestoException(NUMERIC_VALUE_OUT_OF_RANGE, format("integer addition overflow: %s + %s", left, right), e);
        }
    }

    @ScalarOperator(SUBTRACT)
    @SqlType(StandardTypes.INTEGER)
    public static long subtract(@SqlType(StandardTypes.INTEGER) long left, @SqlType(StandardTypes.INTEGER) long right)
    {
        try {
            return Math.subtractExact((int) left, (int) right);
        }
        catch (ArithmeticException e) {
            throw new PrestoException(NUMERIC_VALUE_OUT_OF_RANGE, format("integer subtraction overflow: %s - %s", left, right), e);
        }
    }

    @ScalarOperator(MULTIPLY)
    @SqlType(StandardTypes.INTEGER)
    public static long multiply(@SqlType(StandardTypes.INTEGER) long left, @SqlType(StandardTypes.INTEGER) long right)

View on GitHub (pinned to 55bb57d202)

Solutions

Cast operands to BIGINT before adding: CAST(a AS BIGINT) + CAST(b AS BIGINT)
Use try(a + b) to get NULL instead of failing the query
Change the column type to BIGINT if values legitimately exceed int range
Clamp inputs or validate ranges before summing

Example fix

// before (SQL)
SELECT visits_a + visits_b FROM stats -- INTEGER overflow
// after
SELECT CAST(visits_a AS BIGINT) + CAST(visits_b AS BIGINT) FROM stats

Defensive patterns

Strategy: validation

Validate before calling

SELECT * FROM t WHERE CAST(a AS BIGINT) + CAST(b AS BIGINT) > 2147483647 OR CAST(a AS BIGINT) + CAST(b AS BIGINT) < -2147483648; -- find overflow rows

Try / catch

SELECT try(a + b) FROM t -- NULL instead of NUMERIC_VALUE_OUT_OF_RANGE

Prevention

Promote to BIGINT before adding INTEGER columns likely to overflow
Use try() for arithmetic on untrusted/large data
Watch for INTEGER columns holding accumulating counters and migrate them to BIGINT

When it happens

Trigger: `left + right` on INTEGER-typed values where the exact 32-bit sum overflows (beyond 2147483647 or below -2147483648) — add() in IntegerOperators.java:72.

Common situations: Summing large counters stored as INTEGER, accumulating user counts or byte sizes that exceed 2^31, arithmetic on legacy int columns that silently wrapped in other engines.

Related errors

AI-assisted analysis of prestodb/presto@55bb57d202 (2026-09-04). Data as JSON: /api/errors/e1c1881dcfadcb21. Report an issue: GitHub.