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

CAST the operands (or result expression) to SMALLINT/INTEGER/BIGINT before adding

prestodb/presto · error · PrestoException

NUMERIC_VALUE_OUT_OF_RANGE

NUMERIC_VALUE_OUT_OF_RANGE

Error message

tinyint addition overflow: %s + %s

What it means

Thrown when adding two TINYINT values produces a result outside the signed 8-bit range (-128 to 127). SignedBytes.checkedCast rejects the out-of-range long, and Presto rethrows it as NUMERIC_VALUE_OUT_OF_RANGE. The SQL left + right operator on tinyint operands invokes this function.

Source

Thrown at presto-main-base/src/main/java/com/facebook/presto/type/TinyintOperators.java:70

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

public final class TinyintOperators
{
    private TinyintOperators()
    {
    }

    @ScalarOperator(ADD)
    @SqlType(StandardTypes.TINYINT)
    public static long add(@SqlType(StandardTypes.TINYINT) long left, @SqlType(StandardTypes.TINYINT) long right)
    {
        try {
            return SignedBytes.checkedCast(left + right);
        }
        catch (IllegalArgumentException e) {
            throw new PrestoException(NUMERIC_VALUE_OUT_OF_RANGE, format("tinyint addition overflow: %s + %s", left, right), e);
        }
    }

    @ScalarOperator(SUBTRACT)
    @SqlType(StandardTypes.TINYINT)
    public static long subtract(@SqlType(StandardTypes.TINYINT) long left, @SqlType(StandardTypes.TINYINT) long right)
    {
        try {
            return SignedBytes.checkedCast(left - right);
        }
        catch (IllegalArgumentException e) {
            throw new PrestoException(NUMERIC_VALUE_OUT_OF_RANGE, format("tinyint subtraction overflow: %s - %s", left, right), e);
        }
    }

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

View on GitHub (pinned to 55bb57d202)

Solutions

CAST the operands (or result expression) to SMALLINT/INTEGER/BIGINT before adding
Change the table column type to a wider integer if the data legitimately needs it
Clamp or recompute the data if overflow indicates a data-quality bug
Catch at query level by validating expected ranges before running the arithmetic

Example fix

// before
SELECT a + b FROM t; -- a,b tinyint, overflow risk
// after
SELECT CAST(a AS INTEGER) + CAST(b AS INTEGER) FROM t;

Defensive patterns

Strategy: validation

Validate before calling

// Presto SQL: guard before adding
SELECT * FROM t WHERE CAST(a AS INTEGER) + CAST(b AS INTEGER) BETWEEN -128 AND 127;

Try / catch

-- No try/catch in SQL; use try_cast to a wider type or clamp:
SELECT CAST(a AS INTEGER) + CAST(b AS INTEGER) FROM t;

Prevention

Cast tinyint operands to INTEGER/BIGINT before any arithmetic
Store columns whose math matters as a wider integer type
Remember tinyint range is only -128..127 when writing expressions
Add range assertions in data-quality checks on ingestion

When it happens

Trigger: SELECT tinyint_col + tinyint_col2 where the mathematical sum exceeds 127 or drops below -128, e.g. 100 + 50.

Common situations: Aggregating or combining small-int columns whose intermediate sums grow beyond tinyint range; misclassified columns that should be integer/smallint; porting queries from engines with implicit integer promotion.

Related errors

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