Números de ponto fixo com sinal que mantêm a precisão durante operações de adição, subtração e multiplicação. Na divisão, os dígitos menos significativos são descartados (não arredondados).
- P - precisão. Intervalo válido: [ 1 : 76 ]. Determina quantos dígitos decimais o número pode ter (incluindo a parte fracionária). Por padrão, a precisão é 10.
- S - escala. Intervalo válido: [ 0 : P ]. Determina quantos dígitos decimais a parte fracionária pode ter.
Decimal(P) é equivalente a Decimal(P, 0). Da mesma forma, a sintaxe Decimal é equivalente a Decimal(10, 0).
Dependendo do valor do parâmetro P, Decimal(P, S) é sinônimo de:
- P de [ 1 : 9 ] - para Decimal32(S)
- P de [ 10 : 18 ] - para Decimal64(S)
- P de [ 19 : 38 ] - para Decimal128(S)
- P de [ 39 : 76 ] - para Decimal256(S)
Intervalos de valores do Decimal
- 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) )
Por exemplo, Decimal32(4) pode conter números de -99999.9999 a 99999.9999, com passo de 0.0001.
Internamente, os dados são representados como inteiros com sinal comuns, com a respectiva largura de bits. Os intervalos reais de valores que podem ser armazenados na memória são um pouco maiores do que os especificados acima e só são verificados na conversão a partir de uma string.
Como as CPUs modernas não oferecem suporte nativo a inteiros de 128 e 256 bits, as operações com Decimal128 e Decimal256 são emuladas. Assim, Decimal128 e Decimal256 são significativamente mais lentos do que Decimal32/Decimal64.
Operações e tipo de resultado
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)
Regras para a escala:
- adição, subtração: S = max(S1, S2).
- multiplicação: S = S1 + S2.
- divisão: S = S1.
Para operações semelhantes entre Decimal e inteiros, o resultado é um Decimal do mesmo tamanho do argumento.
Operações entre Decimal e Float32/Float64 não são definidas. Se você precisar delas, poderá converter explicitamente um dos argumentos usando as funções internas toDecimal32, toDecimal64, toDecimal128 ou toFloat32, toFloat64. Tenha em mente que o resultado perderá precisão e que a conversão de tipo é uma operação computacionalmente cara.
Algumas funções sobre Decimal retornam o resultado em Float64 (por exemplo, var ou stddev). Os cálculos intermediários ainda podem ser feitos em Decimal, o que pode levar a resultados diferentes entre entradas Float64 e Decimal com os mesmos valores.
Durante cálculos com Decimal, podem ocorrer overflows de inteiros. Dígitos excedentes na parte fracionária são descartados (não arredondados). Dígitos excedentes na parte inteira resultarão em uma exceção.
A verificação de overflow não está implementada para Decimal128 e Decimal256. Em caso de overflow, um resultado incorreto é retornado; nenhuma exceção é lançada.
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. Quando as verificações estão desativadas e ocorre overflow, o resultado será incorreto:
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.
