Decimal, Decimal(P), Decimal(P, S), Decimal32(S), Decimal64(S), Decimal128(S), Decimal256(S)

Знаковые числа с фиксированной точкой, сохраняющие точность при сложении, вычитании и умножении. При делении младшие разряды отбрасываются (без округления).

• P — точность. Допустимый диапазон: [ 1 : 76 ]. Определяет, сколько десятичных знаков может содержать число (включая дробную часть). По умолчанию точность равна 10.
• S — масштаб. Допустимый диапазон: [ 0 : P ]. Определяет, сколько десятичных знаков может содержать дробная часть.

Decimal(P) эквивалентен Decimal(P, 0). Аналогично, запись Decimal эквивалентна Decimal(10, 0).

В зависимости от значения параметра P, Decimal(P, S) является синонимом:

• при P в диапазоне [ 1 : 9 ] — для Decimal32(S)
• при P в диапазоне [ 10 : 18 ] — для Decimal64(S)
• при P в диапазоне [ 19 : 38 ] — для Decimal128(S)
• при P в диапазоне [ 39 : 76 ] — для Decimal256(S)

• Decimal(P, S) - (-1 * 10^(P - S), 1 * 10^(P - S))
• Decimal32(S) - (-1 * 10^(9 - S), 1 * 10^(9 - S))
• Decimal64(S) - (-1 * 10^(18 - S), 1 * 10^(18 - S))
• Decimal128(S) - (-1 * 10^(38 - S), 1 * 10^(38 - S))
• Decimal256(S) - (-1 * 10^(76 - S), 1 * 10^(76 - S))

Например, Decimal32(4) может хранить числа от -99999.9999 до 99999.9999 с шагом 0.0001.

Внутренне данные представлены как обычные знаковые целые числа соответствующей разрядности. Фактические диапазоны значений, которые могут храниться в памяти, немного шире, чем указано выше; они проверяются только при преобразовании из строки.

Поскольку современные процессоры не поддерживают 128-битные и 256-битные целые числа нативно, операции с Decimal128 и Decimal256 эмулируются. Поэтому Decimal128 и Decimal256 работают значительно медленнее, чем Decimal32/Decimal64.

Бинарные операции над Decimal дают более широкий тип результата (при любом порядке аргументов).

• Decimal64(S1) <op> Decimal32(S2) -> Decimal64(S)
• Decimal128(S1) <op> Decimal32(S2) -> Decimal128(S)
• Decimal128(S1) <op> Decimal64(S2) -> Decimal128(S)
• Decimal256(S1) <op> Decimal<32|64|128>(S2) -> Decimal256(S)

Правила для масштаба:

• сложение, вычитание: S = max(S1, S2).
• умножение: S = S1 + S2.
• деление: S = S1.

Для аналогичных операций между Decimal и целыми числами результатом будет Decimal того же размера, что и аргумент Decimal.

Операции между Decimal и Float32/Float64 не определены. Если они вам нужны, можно явно привести один из аргументов с помощью встроенных функций toDecimal32, toDecimal64, toDecimal128 или toFloat32, toFloat64. Имейте в виду, что результат потеряет точность, а преобразование типов — вычислительно затратная операция.

Некоторые функции для Decimal возвращают результат в формате Float64 (например, var или stddev). При этом промежуточные вычисления всё равно могут выполняться в Decimal, что может приводить к различиям в результатах для входных данных Float64 и Decimal с одинаковыми значениями.

При вычислениях с Decimal возможно целочисленное переполнение. Лишние цифры в дробной части отбрасываются (без округления). Лишние цифры в целой части приводят к исключению.

SELECT toDecimal32(2, 4) AS x, x / 3

┌──────x─┬─divide(toDecimal32(2, 4), 3)─┐
│ 2.0000 │                       0.6666 │
└────────┴──────────────────────────────┘

SELECT toDecimal32(4.2, 8) AS x, x * x

DB::Exception: Scale is out of bounds.

SELECT toDecimal32(4.2, 8) AS x, 6 * x

DB::Exception: Decimal math overflow.

Проверки переполнения замедляют операции. Если известно, что переполнение исключено, имеет смысл отключить проверки с помощью настройки decimal_check_overflow. Если проверки отключены и всё же происходит переполнение, результат будет некорректным:

SET decimal_check_overflow = 0;
SELECT toDecimal32(4.2, 8) AS x, 6 * x

┌──────────x─┬─multiply(6, toDecimal32(4.2, 8))─┐
│ 4.20000000 │                     -17.74967296 │
└────────────┴──────────────────────────────────┘

Проверки переполнения выполняются не только при арифметических операциях, но и при сравнении значений:

SELECT toDecimal32(1, 8) < 100

DB::Exception: Can't compare.

См. также

• isDecimalOverflow
• countDigits