Chaînes de format numérique standard prises en charge par FORMAT() dans SQL Server

Devise . Convertit le nombre en une chaîne qui représente un montant en devise.

Un spécificateur de précision facultatif peut être utilisé pour spécifier le nombre de décimales.

Exemples (utilisant diverses cultures) :

SELECT 
  FORMAT(12.34, 'C', 'en-us') R1,
  FORMAT(012.34, 'C', 'iv') R2,
  FORMAT(12.34, 'C0', 'ja-jp') R3,
  FORMAT(12.54, 'c', 'vi-vn') R4,
  FORMAT(12.54, 'c0', 'en-au') R5,
  FORMAT(12.54, 'c4', 'en-gb') R6;
+--------+--------+------+---------+------+----------+
| R1     | R2     | R3   | R4      | R5   | R6       |
|--------+--------+------+---------+------+----------|
| $12.34 | ¤12.34 | ¥12  | 12,54 ₫ | $13  | £12.5400 |
+--------+--------+------+---------+------+----------+

Décimal . Convertit le nombre en une chaîne de chiffres décimaux (0-9), précédée d'un signe moins si le nombre est négatif. Ce format est pris en charge uniquement pour les types intégraux.

Si le spécificateur de précision (facultatif) est utilisé, il spécifie le nombre total de chiffres dans le résultat. Si le nombre n'a pas autant de chiffres, il sera complété par des zéros à sa gauche.

Exemples :

SELECT 
  FORMAT(123, 'D') R1,
  FORMAT(123, 'D0') R2,
  FORMAT(123, 'D3') R3,
  FORMAT(123, 'd4') R4,
  FORMAT(0123, 'd5') R5,
  FORMAT(1.23, 'd') R6;
+------+------+------+------+-------+------+
| R1   | R2   | R3   | R4   | R5    | R6   |
|------+------+------+------+-------+------|
| 123  | 123  | 123  | 0123 | 00123 | NULL |
+------+------+------+------+-------+------+

Exponentielle (scientifique) . Convertit le nombre en une chaîne de la forme « -d.ddd…E+ddd » ou « -d.ddd…e+ddd », où chaque « d » indique un chiffre (0-9). La chaîne commence par un signe moins si le nombre est négatif. Exactement un chiffre précède toujours la virgule décimale.

Si un spécificateur de précision est utilisé, il spécifie le nombre de chiffres à droite de la virgule décimale. S'il est omis, six chiffres apparaîtront à droite de la virgule décimale.

Exemples :

SELECT 
  FORMAT(1024.1234567, 'E') R1,
  FORMAT(1024.1234567, 'E0') R2,
  FORMAT(1024.1234567, 'E3') R3,
  FORMAT(1024.1234567, 'e4') R4,
  FORMAT(1024.1234567, 'e7') R5;
+---------------+--------+------------+-------------+----------------+
| R1            | R2     | R3         | R4          | R5             |
|---------------+--------+------------+-------------+----------------|
| 1.024123E+003 | 1E+003 | 1.024E+003 | 1.0241e+003 | 1.0241235e+003 |
+---------------+--------+------------+-------------+----------------+

Point fixe . Convertit le nombre en une chaîne de la forme "-ddd.ddd…" où chaque "d" indique un chiffre (0-9). La chaîne commence par un signe moins si le nombre est négatif.

Un spécificateur de précision facultatif peut être utilisé pour spécifier le nombre de décimales.

Exemples :

SELECT 
  FORMAT(12.345, 'F', 'en-us') R1,
  FORMAT(12.345, 'F0', 'en-us') R2,
  FORMAT(12.345, 'f3', 'en-us') R3,
  FORMAT(12.345, 'f4', 'en-us') R4,
  FORMAT(12.345, 'f5', 'en-us') R5,
  FORMAT(12.345, 'f', 'vi-vn') R6;
+-------+------+--------+---------+----------+-------+
| R1    | R2   | R3     | R4      | R5       | R6    |
|-------+------+--------+---------+----------+-------|
| 12.35 | 12   | 12.345 | 12.3450 | 12.34500 | 12,35 |
+-------+------+--------+---------+----------+-------+

Général . Convertit le nombre en la plus compacte des notations à virgule fixe ou scientifique, selon le type de nombre et si un spécificateur de précision est présent.

Si le spécificateur de précision (facultatif) est utilisé, il définit le nombre maximal de chiffres significatifs pouvant apparaître dans la chaîne de résultat. S'il est omis ou si la valeur est zéro, la précision est déterminée par le type de nombre.

Consultez la documentation officielle de .NET pour une explication de la façon dont le type de nombre peut affecter la précision. Vous devrez peut-être faire référence à cela avec la documentation officielle pour FORMAT() afin de voir comment chaque type numérique .NET correspond à un type numérique T-SQL.

Exemples :

SELECT 
  FORMAT(12.345, 'G', 'en-us') R1,
  FORMAT(12.345, 'G0', 'en-us') R2,
  FORMAT(12.345, 'g3', 'en-us') R3,
  FORMAT(12.345, 'g4', 'en-us') R4,
  FORMAT(12.345, 'g5', 'en-us') R5,
  FORMAT(12.345, 'g', 'vi-vn') R6;
+--------+--------+------+-------+--------+--------+
| R1     | R2     | R3   | R4    | R5     | R6     |
|--------+--------+------+-------+--------+--------|
| 12.345 | 12.345 | 12.3 | 12.35 | 12.345 | 12,345 |
+--------+--------+------+-------+--------+--------+

Numéro . Convertit le nombre en une chaîne de la forme "-d,ddd,ddd.ddd…".

Si le spécificateur de précision (facultatif) est utilisé, il définit le nombre de chiffres à droite de la virgule décimale.

Exemples :

SELECT 
  FORMAT(1234.56, 'N', 'en-us') R1,
  FORMAT(1234.56, 'N0', 'en-us') R2,
  FORMAT(1234.56, 'n3', 'en-us') R3,
  FORMAT(1234.56, 'n4', 'en-us') R4,
  FORMAT(1234.56, 'n', 'vi-vn') R5;
+----------+-------+-----------+------------+----------+
| R1       | R2    | R3        | R4         | R5       |
|----------+-------+-----------+------------+----------|
| 1,234.56 | 1,235 | 1,234.560 | 1,234.5600 | 1.234,56 |
+----------+-------+-----------+------------+----------+

Pourcentage . Multiplie le nombre par 100 et le convertit en une chaîne qui représente un pourcentage.

Si le spécificateur de précision est utilisé, il définit le nombre de décimales.

Exemples :

SELECT 
  FORMAT(.1234, 'P', 'en-us') R1,
  FORMAT(.1234, 'P0', 'en-us') R2,
  FORMAT(.1250, 'p0', 'en-us') R3,
  FORMAT(.1250, 'p3', 'en-us') R4,
  FORMAT(.1250, 'p', 'vi-vn') R5;
+---------+------+------+----------+--------+
| R1      | R2   | R3   | R4       | R5     |
|---------+------+------+----------+--------|
| 12.34 % | 12 % | 13 % | 12.500 % | 12,50% |
+---------+------+------+----------+--------+

Aller-retour . Tente de s'assurer qu'une valeur numérique qui est convertie en chaîne est analysée de nouveau dans la même valeur numérique.

Le spécificateur de précision est ignoré lors de l'utilisation de ce spécificateur de format.

REMARQUE  :Dans .NET, ce spécificateur de format n'est pris en charge que par le Single , Double , et BigInteger types de nombres. Aussi, pour Double valeurs, ce spécificateur de format échoue dans certains cas à réussir l'aller-retour avec la valeur d'origine. Il offre également des performances médiocres lorsqu'il est utilisé avec le Double et Célibataire les types.

De plus, la documentation .NET recommande que ce spécificateur de format soit utilisé pour le BigInteger tapez uniquement. Il recommande que Double les types utilisent G17 , et Célibataire les types utilisent G9 .

Qu'est-ce que cela signifie pour SQL Server ? Fondamentalement, vous devriez probablement éviter ce spécificateur de format dans SQL Server. Utilisez plutôt G17 pour le flotteur type de données et G9 pour le vrai type de données.

Exemples
Voici un exemple qui compare le R spécificateur de format avec G17 et G9 .

DECLARE @myFloat float, @myReal real;
SET @myFloat = '123456789.1234567';
SET @myReal = @myFloat;
SELECT 
  @myFloat 'Float Value', 
  @myReal 'Real Value';
SELECT 
  FORMAT(@myFloat, 'R') 'Float R',
  FORMAT(@myFloat, 'G17') 'Float G17',
  FORMAT(@myReal, 'R') 'Real R',
  FORMAT(@myReal, 'G9') 'Real G9';
+------------------+--------------+
| Float Value      | Real Value   |
|------------------+--------------|
| 123456789.123457 | 1.234568E+08 |
+------------------+--------------+
(1 row affected)
+-------------------+-------------------+-----------+-----------+
| Float R           | Float G17         | Real R    | Real G9   |
|-------------------+-------------------+-----------+-----------|
| 123456789.1234567 | 123456789.1234567 | 123456792 | 123456792 |
+-------------------+-------------------+-----------+-----------+
(1 row affected)

Hexadécimal . Convertit le nombre en une chaîne de chiffres hexadécimaux.

La casse utilisée (c'est-à-dire X ou x ) spécifie s'il faut utiliser des caractères majuscules ou minuscules pour les chiffres hexadécimaux supérieurs à 9. En effet, une valeur hexadécimale peut être composée des caractères suivants ; 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e et f (dans les deux cas). Les majuscules et les minuscules représentent la même valeur lors de l'utilisation de l'hexadécimal (par exemple, f et F les deux se convertissent en 15 en décimal).

Ce spécificateur de format est pris en charge uniquement pour les types intégraux.

Si le spécificateur de précision (facultatif) est utilisé, il spécifie le nombre total de chiffres dans le résultat. Si le nombre n'a pas autant de chiffres, il sera complété par des zéros à sa gauche.

Exemples :

SELECT 
  FORMAT(123, 'X') R1,
  FORMAT(123, 'x') R2,
  FORMAT(123, 'x6') R3,
  FORMAT(12345678, 'x') R4,
  FORMAT(123, 'x6') R5,
  FORMAT(-123, 'x') R6,
  FORMAT(1.23, 'X') R7;
+------+------+--------+--------+--------+----------+------+
| R1   | R2   | R3     | R4     | R5     | R6       | R7   |
|------+------+--------+--------+--------+----------+------|
| 7B   | 7b   | 00007b | bc614e | 00007b | ffffff85 | NULL |
+------+------+--------+--------+--------+----------+------+