Nombres signés à virgule fixe qui conservent leur précision lors des opérations d’addition, de soustraction et de multiplication. Pour la division, les chiffres les moins significatifs sont supprimés (et non arrondis).
- P - précision. Plage valide : [ 1 : 76 ]. Détermine le nombre total de chiffres décimaux qu’un nombre peut avoir (y compris la partie fractionnaire). Par défaut, la précision est de 10.
- S - échelle. Plage valide : [ 0 : P ]. Détermine le nombre de chiffres décimaux que la partie fractionnaire peut avoir.
Decimal(P) est équivalent à Decimal(P, 0). De même, la syntaxe Decimal est équivalente à Decimal(10, 0).
Selon la valeur du paramètre P, Decimal(P, S) est synonyme de :
- P de [ 1 : 9 ] - pour Decimal32(S)
- P de [ 10 : 18 ] - pour Decimal64(S)
- P de [ 19 : 38 ] - pour Decimal128(S)
- P de [ 39 : 76 ] - pour Decimal256(S)
Plages de valeurs de 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) )
Par exemple, Decimal32(4) peut contenir des nombres allant de -99999.9999 à 99999.9999, avec un pas de 0.0001.
En interne, les données sont représentées sous forme d’entiers signés classiques de la largeur en bits correspondante. Les plages de valeurs réelles pouvant être stockées en mémoire sont légèrement plus étendues que celles indiquées ci-dessus, et elles ne sont vérifiées que lors de la conversion depuis une chaîne.
Comme les CPU modernes ne prennent pas en charge nativement les entiers de 128 et 256 bits, les opérations sur Decimal128 et Decimal256 sont émulées. Ainsi, Decimal128 et Decimal256 sont sensiblement plus lents que Decimal32/Decimal64.
Opérations et type de résultat
Decimal produisent un type de résultat plus large (quel que soit l’ordre des arguments).
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)
Règles pour l’échelle :
- addition, soustraction : S = max(S1, S2).
- multiplication : S = S1 + S2.
- division : S = S1.
Pour des opérations similaires entre Decimal et des entiers, le résultat est un Decimal de même taille que l’argument.
Les opérations entre Decimal et Float32/Float64 ne sont pas définies. Si vous en avez besoin, vous pouvez convertir explicitement l’un des arguments à l’aide des fonctions intégrées toDecimal32, toDecimal64, toDecimal128 ou toFloat32, toFloat64. Gardez à l’esprit que le résultat perdra en précision et que la conversion de type est une opération coûteuse en calcul.
Certaines fonctions appliquées à Decimal renvoient un résultat de type Float64 (par exemple, var ou stddev). Les calculs intermédiaires peuvent toutefois encore être effectués en Decimal, ce qui peut entraîner des résultats différents entre des entrées Float64 et Decimal ayant les mêmes valeurs.
Vérifications de dépassement
La vérification de dépassement n’est pas implémentée pour Decimal128 et Decimal256. En cas de dépassement, un résultat incorrect est renvoyé et aucune exception n’est levée.
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. Lorsque les vérifications sont désactivées et qu’un dépassement se produit, le résultat sera incorrect :
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.
