Cadenas de formato numérico estándar compatibles con FORMAT() en SQL Server

Moneda . Convierte el número en una cadena que representa una cantidad de moneda.

Se puede usar un especificador de precisión opcional para especificar el número de lugares decimales.

Ejemplos (usando varias culturas) :

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 |
+--------+--------+------+---------+------+----------+

decimales . Convierte el número en una cadena de dígitos decimales (0-9), con el prefijo de un signo menos si el número es negativo. Este formato solo se admite para tipos enteros.

Si se utiliza el especificador de precisión (opcional), especifica el número total de dígitos en el resultado. Si el número no tiene tantos dígitos, se completará con ceros a su izquierda.

Ejemplos :

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 |
+------+------+------+------+-------+------+

Exponencial (científico) . Convierte el número en una cadena de la forma “-d.ddd…E+ddd” o “-d.ddd…e+ddd”, donde cada “d” indica un dígito (0-9). La cadena comienza con un signo menos si el número es negativo. Exactamente un dígito siempre precede al punto decimal.

Si se usa un especificador de precisión, especifica cuántos dígitos hay a la derecha del punto decimal. Si se omite, aparecerán seis dígitos a la derecha del punto decimal.

Ejemplos :

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 |
+---------------+--------+------------+-------------+----------------+

Punto fijo . Convierte el número en una cadena de la forma "-ddd.ddd..." donde cada "d" indica un dígito (0-9). La cadena comienza con un signo menos si el número es negativo.

Se puede usar un especificador de precisión opcional para especificar el número de lugares decimales.

Ejemplos :

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 |
+-------+------+--------+---------+----------+-------+

Generales . Convierte el número a la notación más compacta de punto fijo o científica, según el tipo de número y si está presente un especificador de precisión.

Si se utiliza el especificador de precisión (opcional), define el número máximo de dígitos significativos que pueden aparecer en la cadena de resultados. Si se omite, o si el valor es cero, la precisión está determinada por el tipo de número.

Consulte la documentación oficial de .NET para obtener una explicación de cómo el tipo de número puede afectar la precisión. Es posible que deba hacer una referencia cruzada con la documentación oficial para FORMAT() para ver cómo cada tipo numérico de .NET se asigna a un tipo numérico de T-SQL.

Ejemplos :

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 |
+--------+--------+------+-------+--------+--------+

Número . Convierte el número en una cadena con el formato "-d,ddd,ddd.ddd...".

Si se utiliza el especificador de precisión (opcional), define el número de dígitos a la derecha del punto decimal.

Ejemplos :

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 |
+----------+-------+-----------+------------+----------+

Porcentaje . Multiplica el número por 100 y lo convierte en una cadena que representa un porcentaje.

Si se utiliza el especificador de precisión, define el número de lugares decimales.

Ejemplos :

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% |
+---------+------+------+----------+--------+

Ida y vuelta . Intenta asegurarse de que un valor numérico que se convierte en una cadena se analice de nuevo en el mismo valor numérico.

El especificador de precisión se ignora cuando se usa este especificador de formato.

NOTA :en .NET, este especificador de formato solo es compatible con Single , Doble y Entero grande tipos de números Además, para Doble valores, este especificador de formato en algunos casos falla en el viaje de ida y vuelta del valor original. También ofrece un bajo rendimiento cuando se usa con el Doble y Soltero tipos

Además, la documentación de .NET recomienda que este especificador de formato se use para BigInteger solo tipo. Se recomienda que Doble los tipos usan G17 y Único los tipos usan G9 .

¿Qué significa esto para SQL Server? Básicamente, probablemente debería evitar este especificador de formato en SQL Server. En su lugar, utilice G17 para el flotador tipo de datos y G9 por el verdadero tipo de datos.

Ejemplos
Este es un ejemplo que compara la R especificador de formato con G17 y 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)

hexadecimal . Convierte el número en una cadena de dígitos hexadecimales.

El caso utilizado (es decir, X o x ) especifica si se deben usar caracteres en mayúsculas o minúsculas para los dígitos hexadecimales superiores a 9. Esto se debe a que los valores hexadecimales pueden constar de los siguientes caracteres; 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e y f (cualquier caso). Mayúsculas y minúsculas representan el mismo valor cuando se usa hexadecimal (p. ej., f y F ambos se convierten a 15 en decimal).

Este especificador de formato solo se admite para tipos integrales.

Si se utiliza el especificador de precisión (opcional), especifica el número total de dígitos en el resultado. Si el número no tiene tantos dígitos, se completará con ceros a su izquierda.

Ejemplos :

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 |
+------+------+--------+--------+--------+----------+------+