Sqlserver
 sql >> Datenbank >  >> RDS >> Sqlserver

Standardmäßige numerische Formatzeichenfolgen, die von FORMAT() in SQL Server unterstützt werden

Dieser Artikel enthält eine Referenz für die standardmäßigen numerischen Formatbezeichner, die beim Formatieren von Zahlen mit FORMAT() verwendet werden können Funktion in SQL Server. Beispiele enthalten.

Einige der Beispiele verwenden Genauigkeitsbezeichner (diese bestehen aus einer oder zwei Ziffern, die an den Formatbezeichner angehängt werden). Genauigkeitsbezeichner können ein Wert von 0 bis 99 sein, der die Genauigkeit des Ergebnisses angibt. Wie es funktioniert, hängt vom verwendeten Formatbezeichner ab. Bei einigen Formatbezeichnern wird die Gesamtzahl der Stellen im Ergebnis angegeben, bei anderen die Anzahl der Dezimalstellen. In anderen Fällen wird es vollständig ignoriert.

Zeichenfolge formatieren Beschreibung/Beispiel
C oder c

Währung . Konvertiert die Zahl in eine Zeichenfolge, die einen Währungsbetrag darstellt.

Ein optionaler Genauigkeitsbezeichner kann verwendet werden, um die Anzahl der Dezimalstellen anzugeben.

Beispiele (unter Verwendung verschiedener Kulturen) :

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 oder d

Dezimal . Wandelt die Zahl in eine Folge von Dezimalziffern (0-9) um, denen ein Minuszeichen vorangestellt wird, wenn die Zahl negativ ist. Dieses Format wird nur für ganzzahlige Typen unterstützt.

Wenn der (optionale) Genauigkeitsbezeichner verwendet wird, gibt er die Gesamtzahl der Stellen im Ergebnis an. Wenn die Nummer nicht so viele Ziffern hat, wird sie links mit Nullen aufgefüllt.

Beispiele :

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 |
+------+------+------+------+-------+------+
E oder e

Exponential (wissenschaftlich) . Konvertiert die Zahl in eine Zeichenfolge der Form „-d.ddd…E+ddd“ oder „-d.ddd…e+ddd“, wobei jedes „d“ eine Ziffer (0-9) angibt. Die Zeichenfolge beginnt mit einem Minuszeichen, wenn die Zahl negativ ist. Vor dem Komma steht immer genau eine Ziffer.

Wenn ein Genauigkeitsbezeichner verwendet wird, gibt er an, wie viele Stellen rechts vom Dezimalpunkt stehen. Wenn weggelassen, erscheinen rechts vom Dezimalpunkt sechs Ziffern.

Beispiele :

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 |
+---------------+--------+------------+-------------+----------------+
F oder f

Festpunkt . Konvertiert die Zahl in eine Zeichenkette der Form „-ddd.ddd…“, wobei jedes „d“ eine Ziffer (0-9) darstellt. Die Zeichenfolge beginnt mit einem Minuszeichen, wenn die Zahl negativ ist.

Ein optionaler Genauigkeitsbezeichner kann verwendet werden, um die Anzahl der Dezimalstellen anzugeben.

Beispiele :

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 oder g

Allgemein . Konvertiert die Zahl in die kompaktere Festkomma- oder wissenschaftliche Notation, abhängig vom Typ der Zahl und davon, ob ein Genauigkeitsbezeichner vorhanden ist.

Wenn der (optionale) Genauigkeitsbezeichner verwendet wird, definiert er die maximale Anzahl signifikanter Stellen, die in der Ergebniszeichenfolge erscheinen können. Wenn weggelassen oder wenn der Wert Null ist, wird die Genauigkeit durch den Zahlentyp bestimmt.

In der offiziellen .NET-Dokumentation finden Sie eine Erklärung dazu, wie sich der Zahlentyp auf die Genauigkeit auswirken kann. Möglicherweise müssen Sie dies mit der offiziellen Dokumentation für FORMAT() abgleichen um zu sehen, wie jeder numerische .NET-Typ einem numerischen T-SQL-Typ zugeordnet wird.

Beispiele :

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 oder n

Nummer . Konvertiert die Zahl in einen String der Form „-d,ddd,ddd.ddd…“.

Wenn der (optionale) Genauigkeitsbezeichner verwendet wird, definiert er die Anzahl der Ziffern rechts vom Dezimalpunkt.

Beispiele :

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 |
+----------+-------+-----------+------------+----------+
P oder p

Prozent . Multipliziert die Zahl mit 100 und wandelt sie in eine Zeichenfolge um, die einen Prozentsatz darstellt.

Wenn der Genauigkeitsbezeichner verwendet wird, definiert er die Anzahl der Dezimalstellen.

Beispiele :

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% |
+---------+------+------+----------+--------+
R oder r

Hin- und Rückfahrt . Versucht sicherzustellen, dass ein numerischer Wert, der in eine Zeichenfolge konvertiert wird, wieder in denselben numerischen Wert geparst wird.

Der Genauigkeitsbezeichner wird ignoriert, wenn dieser Formatbezeichner verwendet wird.

HINWEIS :In .NET wird dieser Formatbezeichner nur von Single unterstützt , Doppelt und BigInteger Nummerntypen. Auch für Double -Werte kann dieser Formatbezeichner in einigen Fällen den ursprünglichen Wert nicht erfolgreich umrunden. Es bietet auch eine schlechte Leistung, wenn es mit Double verwendet wird und Single Typen.

Außerdem empfiehlt die .NET-Dokumentation, dass dieser Formatbezeichner für BigInteger verwendet wird nur tippen. Es empfiehlt sich Double Typen verwenden G17 , und Einzeln Typen verwenden G9 .

Was bedeutet das für SQL Server? Grundsätzlich sollten Sie diesen Formatbezeichner in SQL Server wahrscheinlich vermeiden. Verwenden Sie stattdessen G17 für den Schwimmer Datentyp und G9 für das Echte Datentyp.

Beispiele
Hier ist ein Beispiel, das den R vergleicht Formatbezeichner mit G17 und 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)
X oder x

Hexadezimal . Konvertiert die Zahl in eine Zeichenfolge aus Hexadezimalziffern.

Der verwendete Fall (d. h. X oder x ) gibt an, ob Groß- oder Kleinbuchstaben für Hexadezimalziffern größer als 9 verwendet werden sollen. Dies liegt daran, dass Hexadezimalwerte aus den folgenden Zeichen bestehen können; 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, a, b, c, d, e und f (beide Fälle). Groß- und Kleinschreibung stellen denselben Wert dar, wenn hexadezimal verwendet wird (z. B. f und F beide konvertieren zu 15 in Dezimalzahl).

Dieser Formatbezeichner wird nur für ganzzahlige Typen unterstützt.

Wenn der (optionale) Genauigkeitsbezeichner verwendet wird, gibt er die Gesamtzahl der Stellen im Ergebnis an. Wenn die Nummer nicht so viele Ziffern hat, wird sie links mit Nullen aufgefüllt.

Beispiele :

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

Die obige Liste ist eine vollständige Liste gültiger benutzerdefinierter numerischer .NET-Formatzeichenfolgen, basierend auf den Informationen aus der offiziellen .NET-Dokumentation für standardmäßige numerische Formatzeichenfolgen auf der Microsoft-Website zum Zeitpunkt des Schreibens.

Der Grund, warum diese für den SQL Server FORMAT() relevant sind Funktion ist, dass diese Funktion nur gültige .NET Framework-Formatzeichenfolgen akzeptiert.

Zusätzlich zum oben genannten Standard Formatzeichenfolgen können Sie auch benutzerdefiniert verwenden Zeichenfolgen formatieren. Hier ist eine vollständige Liste benutzerdefinierter numerischer Formatzeichenfolgen, die Sie mit SQL Server verwenden können.

Sie können auch Datums- und Uhrzeitwerte formatieren. Sehen Sie sich die Liste der standardmäßigen Formatzeichenfolgen für Datum und Uhrzeit sowie die benutzerdefinierten Formatzeichenfolgen für Datum und Uhrzeit an, die Sie mit FORMAT() verwenden können Funktion.

Wenn Sie immer noch versuchen zu verstehen, was eine Formatzeichenfolge überhaupt ist, lesen Sie Was ist eine Formatzeichenfolge in SQL Server? für ein grundlegendes Verständnis von Formatstrings und wie sie sich auf FORMAT() beziehen Funktion.