> ## Documentation Index
> Fetch the complete documentation index at: https://private-7c7dfe99-mintlify-8c05c8a2.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Documentation des types de données Decimal dans ClickHouse, qui fournissent une arithmétique à virgule fixe avec une précision configurable

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

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).

<div id="parameters">
  ## Paramètres
</div>

* 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)

<div id="decimal-value-ranges">
  ## Plages de valeurs de Decimal
</div>

* 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.

<div id="internal-representation">
  ## Représentation interne
</div>

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.

<div id="operations-and-result-type">
  ## Opérations et type de résultat
</div>

Les opérations binaires sur `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.

<div id="overflow-checks">
  ## Vérifications de dépassement
</div>

Lors des calculs sur des valeurs Decimal, des dépassements d'entier peuvent se produire. Les chiffres en excès dans la partie fractionnaire sont supprimés (sans arrondi). Les chiffres en excès dans la partie entière entraînent une exception.

<Warning>
  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.
</Warning>

```sql theme={null}
SELECT toDecimal32(2, 4) AS x, x / 3
```

```text theme={null}
┌──────x─┬─divide(toDecimal32(2, 4), 3)─┐
│ 2.0000 │                       0.6666 │
└────────┴──────────────────────────────┘
```

```sql theme={null}
SELECT toDecimal32(4.2, 8) AS x, x * x
```

```text theme={null}
DB::Exception: Scale is out of bounds.
```

```sql theme={null}
SELECT toDecimal32(4.2, 8) AS x, 6 * x
```

```text theme={null}
DB::Exception: Decimal math overflow.
```

Les vérifications de dépassement ralentissent les opérations. S'il est établi qu'aucun dépassement n'est possible, il est judicieux de désactiver ces vérifications à l'aide du paramètre `decimal_check_overflow`. Lorsque les vérifications sont désactivées et qu'un dépassement se produit, le résultat sera incorrect :

```sql theme={null}
SET decimal_check_overflow = 0;
SELECT toDecimal32(4.2, 8) AS x, 6 * x
```

```text theme={null}
┌──────────x─┬─multiply(6, toDecimal32(4.2, 8))─┐
│ 4.20000000 │                     -17.74967296 │
└────────────┴──────────────────────────────────┘
```

Les vérifications de dépassement ont lieu non seulement lors d’opérations arithmétiques, mais aussi lors de comparaisons de valeurs :

```sql theme={null}
SELECT toDecimal32(1, 8) < 100
```

```text theme={null}
DB::Exception: Can't compare.
```

**Voir aussi**

* [isDecimalOverflow](/fr/reference/functions/regular-functions/other-functions#isDecimalOverflow)
* [countDigits](/fr/reference/functions/regular-functions/other-functions#countDigits)