Sqlserver
 sql >> Base de Dados >  >> RDS >> Sqlserver

Strings de formato numérico personalizado com suporte por FORMAT() no SQL Server


Este artigo fornece uma referência para os especificadores de formato numérico personalizado que podem ser usados ​​ao formatar números usando o FORMAT() função no SQL Server. Exemplos incluídos.


Formatar string Descrição/Exemplo
0
Zero espaço reservado . Substitui o zero pelo dígito correspondente se houver um; caso contrário, zero aparecerá na string de resultado.

Exemplos :
SELECT 
  FORMAT(12.34, '0') R1,
  FORMAT(012.34, '00') R2,
  FORMAT(12.34, '000') R3,
  FORMAT(012.34, '0000') R4,
  FORMAT(12.54, '00') R5;
+------+------+------+------+------+
| R1   | R2   | R3   | R4   | R5   |
|------+------+------+------+------|
| 12   | 12   | 012  | 0012 | 13   |
+------+------+------+------+------+
#
Espaço reservado para dígitos . Substitui o símbolo “#” pelo dígito correspondente, se houver; caso contrário, nenhum dígito aparecerá na string de resultado.

Nenhum dígito aparece na string de resultado se o dígito correspondente na string de entrada for um 0 não significativo.

Exemplos :
SELECT 
  FORMAT(12.34, '#') R1,
  FORMAT(012.34, '##') R2,
  FORMAT(12.34, '###') R3,
  FORMAT(012.34, '####') R4,
  FORMAT(12.54, '##') R5;
+------+------+------+------+------+
| R1   | R2   | R3   | R4   | R5   |
|------+------+------+------+------|
| 12   | 12   | 12   | 12   | 13   |
+------+------+------+------+------+
.
Ponto decimal . Determina a localização do separador decimal na string de resultado.

Exemplos :
SELECT 
  FORMAT(12.34, '0.0', 'en-US') R1,
  FORMAT(12.34, '.00', 'en-US') R2,
  FORMAT(12.34, '.', 'en-US') R3,
  FORMAT(12.34, '.00', 'fr-FR') R4;
+------+-------+------+-------+
| R1   | R2    | R3   | R4    |
|------+-------+------+-------|
| 12.3 | 12.34 | 12   | 12,34 |
+------+-------+------+-------+
,
Separador de grupo e escala numérica . Pode ser usado tanto como separador de grupo (também conhecido como separador de milhar) quanto como especificador de escala numérica.
  • Como um separador de grupo , ele insere um caractere separador de grupo localizado entre cada grupo.
  • Como um especificador de escala numérica , ele divide um número por 1.000 para cada vírgula especificada.

Para especificar um separador de grupo, coloque uma ou mais vírgulas entre espaços reservados de dois dígitos (0 ou #) que formatam os dígitos integrais de um número. Isso resulta na inserção de um caractere separador de grupo entre cada grupo de números na parte integral da saída.

Para especificar um especificador de escala numérica, coloque uma ou mais vírgulas imediatamente à esquerda do ponto decimal explícito ou implícito.

Exemplos – Como um separador de grupo :
SELECT 
  FORMAT(12345678, '#,#', 'en-US') 'US English',
  FORMAT(12345678, '#,#', 'fr-FR') 'French',
  FORMAT(12345678, '#,#', 'es-ES') 'Spanish';
+--------------+------------+------------+
| US English   | French     | Spanish    |
|--------------+------------+------------|
| 12,345,678   | 12 345 678 | 12.345.678 |
+--------------+------------+------------+

Exemplos – como especificador de escala numérica :
SELECT 
  FORMAT(12000, '#,', 'en-US') 'R1',
  FORMAT(1234567890, '#,', 'en-US') R2,
  FORMAT(1234567890, '#,,', 'en-US') R3;
+------+---------+------+
| R1   | R2      | R3   |
|------+---------+------|
| 12   | 1234568 | 1235 |
+------+---------+------+

Exemplos – como ambos :
SELECT 
  FORMAT(1234567890, '#,#,', 'en-US') R1,
  FORMAT(1234567890, '#,#,,', 'en-US') R2;
+-----------+-------+
| R1        | R2    |
|-----------+-------|
| 1,234,568 | 1,235 |
+-----------+-------+
%
Espaço reservado de porcentagem . Multiplica um número por 100 e insere um símbolo de porcentagem localizado na string de resultado.

Exemplos :
SELECT 
  FORMAT(0.1234, '#.# %', 'en-US') R1,
  FORMAT(0.1235, '#.#%', 'zh-cn') R2,
  FORMAT(0.125, '#. %', 'en-US') R3,
  FORMAT(0.1234, '%#.00,', 'tr') R4,
  FORMAT(0.1234, '#.#%', 'it') R5;
+--------+-------+------+--------+-------+
| R1     | R2    | R3   | R4     | R5    |
|--------+-------+------+--------+-------|
| 12.3 % | 12.4% | 13 % | %12,34 | 12,3% |
+--------+-------+------+--------+-------+
‰
Marcador de espaço por mil . Multiplica um número por 1000 e insere um símbolo localizado por mil na string de resultado.

Exemplos :
SELECT 
  FORMAT(0.01234, '#.# ‰', 'en-US') 'R1',
  FORMAT(0.01235, '#.# ‰', 'en-US') R2,
  FORMAT(0.0125, '#. ‰', 'en-US') R3,
  FORMAT(0.01234, '#.# ‰', 'fr-FR') R4;
+--------+--------+------+--------+
| R1     | R2     | R3   | R4     |
|--------+--------+------+--------|
| 12.3 ‰ | 12.4 ‰ | 13 ‰ | 12,3 ‰ |
+--------+--------+------+--------+

E0
E+0
E-0
e0
e+0
e-0
Notação exponencial . Se seguido por pelo menos um zero (0 ), formata o resultado usando a notação exponencial. O caso (E ou e ) indica o caso do símbolo do expoente na string de resultado. O número de zeros após o E ou e caractere determina o número mínimo de dígitos no expoente. Um sinal de mais (+ ) indica que um caractere de sinal sempre precede o expoente. Um sinal de menos (- ) indica que um caractere de sinal precede apenas expoentes negativos.

Exemplos :
SELECT 
  FORMAT(123456789, '0e0') R1,
  FORMAT(123456789, '0e+0') R2,
  FORMAT(123456789, '0E+00') R3,
  FORMAT(1234.56789, '0.0##e+00') R4,
  FORMAT(12.3456789-12, '0e-0') R5;
+------+------+-------+-----------+------+
| R1   | R2   | R3    | R4        | R5   |
|------+------+-------+-----------+------|
| 1e8  | 1e+8 | 1E+08 | 1.235e+03 | 3e-1 |
+------+------+-------+-----------+------+

\
Caractere de escape . Faz com que o próximo caractere seja interpretado como um literal em vez de um especificador de formato personalizado.

Exemplo :
SELECT FORMAT(123, '\#0000') Result;
+----------+
| Result   |
|----------|
| #0123    |
+----------+

'string'
"string"
Delimitador de string literal . Indica que os caracteres incluídos devem ser copiados para a string de resultado inalterada.

Exemplo :
SELECT FORMAT(23, '## Degrees') Result;
+------------+
| Result     |
|------------|
| 23 Degrees |
+------------+

;
Separador de seção . Este é um especificador de formato condicional que define seções com strings de formato separadas para números positivos, negativos e zero. Isso permite que você aplique uma formatação diferente a um número, dependendo de seu valor ser positivo, negativo ou zero. Uma string de formato personalizado pode conter até três seções separadas por ponto e vírgula.
  • Uma seção :a string de formato se aplica a todos os valores (assim como nos exemplos anteriores).
  • Duas seções :A primeira seção se aplica a valores positivos e zeros, e a segunda seção se aplica a valores negativos.
    Se o número a ser formatado for negativo, mas se tornar zero após o arredondamento de acordo com o formato da segunda seção, o zero resultante será formatado de acordo com a primeira seção.
  • Três seções :a primeira seção se aplica a valores positivos, a segunda seção se aplica a valores negativos e a terceira seção se aplica a zeros.
    A segunda seção pode ser deixada em branco (por não ter nada entre os pontos e vírgulas), caso em que a primeira seção se aplica a todos os valores diferentes de zero.

    Se o número a ser formatado for diferente de zero, mas se tornar zero após o arredondamento de acordo com o formato na primeira ou na segunda seção, o zero resultante será formatado de acordo com a terceira seção.

Observe que os valores negativos sempre são exibidos sem um sinal de menos quando os separadores de seção são usados. Se você quiser que o valor final formatado tenha um sinal de menos, precisará incluir explicitamente o sinal de menos como parte da string de formato personalizado. Isso também se aplica a qualquer outra formatação preexistente associada a um número.

Exemplo – Uma seção (sem separadores de seção)
Esta é uma string de formato típica que consiste em uma seção (assim como nos exemplos anteriores). Portanto, nenhum separador de separação é usado. 
SELECT 
  FORMAT(123, '0 (Number)') Positive,
  FORMAT(-123, '0 (Number)') Negative,
  FORMAT(0, '0 (Number)') Zero;
+--------------+---------------+------------+
| Positive     | Negative      | Zero       |
|--------------+---------------+------------|
| 123 (Number) | -123 (Number) | 0 (Number) |
+--------------+---------------+------------+

Observe que o sinal de menos permanece intacto, porque não usei nenhum separador de seção.

Exemplos – Duas seções :
/* EXAMPLE 1 - Same format string, different values */
SELECT 
  FORMAT(123,  '0 (Positive or Zero); 0 (Negative)') Positive,
  FORMAT(-123, '0 (Positive or Zero); 0 (Negative)') Negative,
  FORMAT(0,    '0 (Positive or Zero); 0 (Negative)') Zero;
+------------------------+-----------------+----------------------+
| Positive               | Negative        | Zero                 |
|------------------------+-----------------+----------------------|
| 123 (Positive or Zero) |  123 (Negative) | 0 (Positive or Zero) |
+------------------------+-----------------+----------------------+

/* EXAMPLE 2 - Rounding. 
Negative values rounded to zero get 
formatted under the first format string. 
*/
SELECT 
  FORMAT(0.1,  '0 (Positive or Zero); 0 (Negative)') Positive,
  FORMAT(-0.1, '0 (Positive or Zero); 0 (Negative)') Negative;
+----------------------+----------------------+
| Positive             | Negative             |
|----------------------+----------------------|
| 0 (Positive or Zero) | 0 (Positive or Zero) |
+----------------------+----------------------+

Exemplos – Três seções :
/* EXAMPLE 1 - Basic Usage */
SELECT FORMAT(123, '0 (Positive); 0 (Negative); 0 (Zero)') Result;
+----------------+
| Result         |
|----------------|
| 123 (Positive) |
+----------------+

/* EXAMPLE 2 - Same format string, different values */
SELECT 
  FORMAT(123,   '0 (Positive); 0 (Negative); 0 (Zero)') 'Positive',
  FORMAT(-123,  '0 (Positive); 0 (Negative); 0 (Zero)') 'Negative',
  FORMAT(0,     '0 (Positive); 0 (Negative); 0 (Zero)') 'Zero',
  FORMAT(0.123, '0 (Positive); 0 (Negative); 0 (Zero)') 'Rounded to Zero';

+----------------+----------------+-----------+-------------------+
| Positive       | Negative       | Zero      | Rounded to Zero   |
|----------------+----------------+-----------+-------------------|
| 123 (Positive) | 123 (Negative) |  0 (Zero) |  0 (Zero)         |
+----------------+----------------+-----------+-------------------+

/* EXAMPLE 3 - Second format string is empty */
SELECT 
  FORMAT(123,   '0 (Positive);; 0 (Zero)') 'Positive',
  FORMAT(-123,  '0 (Positive);; 0 (Zero)') 'Negative',
  FORMAT(0,     '0 (Positive);; 0 (Zero)') 'Zero',
  FORMAT(0.123, '0 (Positive);; 0 (Zero)') 'Rounded to Zero';
+----------------+-----------------+-----------+-------------------+
| Positive       | Negative        | Zero      | Rounded to Zero   |
|----------------+-----------------+-----------+-------------------|
| 123 (Positive) | -123 (Positive) |  0 (Zero) |  0 (Zero)         |
+----------------+-----------------+-----------+-------------------+
Outro
Todos os outros caracteres. O caractere é copiado para a string de resultado inalterada.

Exemplo :
SELECT FORMAT(12, '# °C') Result;
+----------+
| Result   |
|----------|
| 12 °C    |
+----------+

A lista acima é uma lista completa de strings de formato personalizado .NET válidas, com base nas informações da documentação oficial do .NET para strings de formato personalizado no site da Microsoft no momento da redação.

A razão pela qual eles são relevantes para o SQL Server FORMAT() função é que ele só aceita cadeias de caracteres de formato .NET Framework válidas.

Além do personalizado acima strings de formato, você também pode usar padrão cadeias de formato. Aqui está uma lista completa de strings de formato numérico padrão que você pode usar com o SQL Server.

Você também pode formatar valores de data e hora. Veja a lista de strings de formato de data e hora padrão, bem como as strings de formato de data e hora personalizadas que você pode usar com o FORMAT() função.

Se você ainda está tentando entender o que é uma string de formato, consulte O que é uma string de formato no SQL Server? para uma compreensão básica das strings de formato e como elas pertencem ao FORMAT() função.