SQL-Formatmodelle¶

Formatelemente¶

Formatelemente sind Ziffern- und/oder Buchstabenfolgen (meist ohne Berücksichtigung von Groß- und Kleinschreibung) und in einigen Fällen auch Symbole. Formatelemente können direkt miteinander verkettet werden.

Einige Formatelemente werden häufig in allen Formatmodellen verwendet, um die Ausgabe zu steuern und den Eingabetext abzugleichen. Andere Formatelemente haben bestimmte Verwendungen, die auf dem Wertetyp basieren, in den/aus dem sie umgewandelt werden. Weitere Informationen finden Sie in den folgenden Abschnitten dieses Themas:

• Formatmodifizierer und generische Leerzeichenverwaltung

• Formatelemente mit fester Position

• Textminimale Formatelemente

Formatliterale¶

Formatliterale sind Sequenzen, die aus folgenden Kombinationen bestehen können:

• Zeichenfolgen beliebiger Zeichen, die durch doppelte Anführungszeichen getrennt sind (ein doppeltes Anführungszeichen wird durch zwei nebeneinander liegende doppelte Anführungszeichen dargestellt).

• Eines oder mehrere der folgenden Symbole:

  Symbol/Zeichen	Anmerkungen
  . (Punkt)	Wird in festen numerischen Modellen als Formatelement behandelt, wenn das Zeichen auf 0, 9 oder X folgt; ansonsten bleibt es erhalten, wie es ist.
  , (Komma)	Wird in numerischen Modellen als Formatelement behandelt, wenn das Zeichen auf 0, 9 oder X folgt; ansonsten bleibt es erhalten, wie es ist.
  ; (Semikolon)	Bleibt immer erhalten, wie es ist.
  : (Doppelpunkt)	Bleibt immer erhalten, wie es ist.
  - (Minuszeichen)	Bleibt immer erhalten, wie es ist.
  = (Gleichheitszeichen)	Bleibt immer erhalten, wie es ist.
  / (Schrägstrich)	Bleibt immer erhalten, wie es ist.
  ( (linke Klammer)	Bleibt immer erhalten, wie es ist.
  ) (rechte Klammer)	Bleibt immer erhalten, wie es ist.

Ein Literal wird immer so ausgegeben, wie es ist, und genau dort, wo es sich im Formatmodell befand.

Hier ein kurzes Beispiel für die Verwendung eines Modells im SQL-Format, um das Minuszeichen nach einer Zahl und nicht vor einer Zahl auszugeben. Das MI gibt an, wo das Minuszeichen gesetzt werden soll, wenn die Zahl eine negative Zahl ist.

select to_varchar(-123.45, '999.99MI') as EXAMPLE;

Copy

Die Ausgabe würde 123.45- und nicht dem Standard -123.45 ähneln.

Weitere Beispiele finden Sie am Ende dieses Themas.

Ausgabezeichenfolgen mit dem Füllmodusmodifikator ausgeben¶

Standardmäßig ist der Füllmodus auf fill gesetzt, und der Füllmodusmodifikator FM schaltet ihn auf compact um. Bei erneuter Verwendung wird er zurück auf fill geschaltet usw.

In den meisten Fällen gewährleistet der fill-Modus bei der Ausgabe, dass Formatelemente eine Ausgabe mit fester Breite erzeugen, indem Sie die Zahlen links mit führenden Nullen oder Leerzeichen und den Text rechts mit Leerzeichen auffüllen. Dies garantiert, dass die spaltenweise Ausgabe bei Schriftarten mit fester Breite angepasst wird.

Im compact-Modus erzeugen die meisten Formatelemente nur eine Ausgabe mit minimaler Breite (d. h. führende Nullen und Leerzeichen sowie nachstehende Leerzeichen werden unterdrückt).

Die Formatelemente, die diesen Regeln nicht entsprechen, werden unten explizit angegeben.

Der Modifikator für genaue Übereinstimmung FX hat keinen Einfluss auf die Ausgabe. Das Unterstrichformatelement gibt nichts aus.

Parsen von Eingabezeichenfolgen mithilfe von Modifikatoren¶

Das Parsen von Eingabezeichenfolgen wird sowohl vom Füllmodusmodifikator FM als auch vom Modifikator für genaue Übereinstimmung FX beeinflusst. Anfänglich:

• Der Füllmodus ist auf fill eingestellt, und FM schaltet ihn auf compact und zurück.

• Der Modus für genaue Übereinstimmung ist auf lax eingestellt, und FX schaltet ihn auf exact und zurück.

Beim Abgleich von Zeichenfolgen mit Formatelementen und Literalen während der Analyse wird die Groß- und Kleinschreibung nicht berücksichtigt.

Im lax-Modus überspringt der erste Schritt des Eingabeparsings führende Leerzeichen (eine Sequenz von Leerzeichen, Tabulatoren, LF, CR, FF und VT Zeichen); der Modus am Anfang der Eingabe ist genau, wenn das erste Formatelement FX ist, ansonsten ist er lax.

Im lax-Übereinstimmungmodus werden Leerzeichen in Literalen mit einer nicht leeren Eingabefolge von Leerzeichen verglichen. Nicht-Leerzeichen werden eins zu eins abgeglichen. Im exact-Modus müssen alle Zeichen in einem Literal eins zu eins mit den eingegebenen Zeichen übereinstimmen.

Die numerischen Formatelemente werden mit den entsprechenden Ziffernfolgen abgeglichen:

• Wenn sowohl der fill als auch der exact-Modus aktiviert sind, muss die Anzahl der Stellen genau der Breite der entsprechenden numerischen Formatelemente entsprechen (führende Nullen werden erwartet).

• Wenn der compact- oder lax-Modus aktiv ist, darf eine übereinstimmende Eingabezahl höchstens die Anzahl der Ziffern haben, die der maximalen Breite des Formatelements entspricht, und mindestens eine Ziffer; führende Nullen werden ignoriert.

Die Elemente des Textformats werden unabhängig von der Groß- und Kleinschreibung abgeglichen:

• Wenn sowohl der fill- als auch der exact-Modus aktiviert sind, wird die Anzahl der nachstehenden Leerzeichen bis zur maximalen Breite des Elements erwartet.

• Ansonsten werden Leerzeichen nach den Textelementen mit variabler Länge im lax-Modus ignoriert, und eine genaue Übereinstimmung mit dem tatsächlichen Wort (ohne Leerzeichen) wird im exact-Modus erwartet.

Schließlich wird das nachstehende Leerzeichen bis zum Ende der Eingabezeichenfolge ignoriert, wenn der lax-Modus aktuell aktiviert ist.

Normalerweise erlauben weder der lax- noch der exact-Modus übereinstimmende Leerzeichen, wenn Leerzeichen im Formatmodell nicht vorhanden sind oder durch Ausgabe des Inhalts von Formatelementen im fill-Modus nicht erzeugt werden konnten.

Stellen, an denen Leerzeichen ignoriert werden sollten, wenn sie sowohl im fill- als auch im exact-Modus vorhanden sind, können mit dem Formatelement _ (Unterstrich) explizit markiert werden.

Als Faustregel gilt, dass ein Format im exact-Modus nur Eingabezeichenfolgen erkennt, die im gleichen Format ausgegeben wurden, während ein Format im lax-Modus Eingabezeichenfolgen erkennt, die in einem ähnlichen Format ausgegeben wurden, wobei beliebige Füllmodusmodifikatoren hinzugefügt oder entfernt wurden.

Numerische Formate mit fester Position¶

Zahlen mit fester Position werden durch Ziffernelemente 0 oder 9 dargestellt. Beispielsweise enthält 999 Zahlen mit 1 bis 3 Dezimalstellen. Der Bruchteil der Zahlen wird durch die Trennzeichen . (Punkt) oder D begrenzt:

• . wird immer als Punkt dargestellt.

• Um ein anderes Zeichen für die D-Elemente zu verwenden, ändern Sie die Eingabezeichenfolge, um alle Punkte durch Kommas und alle Kommas durch Punkte zu ersetzen, bevor Sie die Übertragungsfunktion anwenden.

Normalerweise werden die führenden Nullen im ganzzahligen Teil und die nachstehende Nullen im Bruchteil durch Leerzeichen ersetzt (außer wenn der Wert des ganzzahligen Teils null ist. In diesem Fall wird er als einzelnes 0-Zeichen dargestellt). Um dieses Verhalten zu unterdrücken, verwenden Sie das Formatelement 0 anstelle von 9. Die entsprechenden Positionen enthalten 0-Zeichen. Wenn das Formatelement B vor der Zahl verwendet wird, unterdrückt es die Beibehaltung der letzten 0 im ganzzahligen Wert (d. h., wenn Sie B verwenden und der Wert des ganzzahligen Teils der Zahl Null ist, werden alle Ziffern als Leerzeichen dargestellt).

Das Zifferngruppentrennzeichen , (Komma) oder G bewirkt, dass das entsprechende Gruppentrennzeichen ausgegeben wird, wenn die Zahl groß genug ist, sodass sich die Ziffern auf beiden Seiten des Gruppentrennzeichens befinden. Ein Beispiel für ein Formatmodell, das zur Ausgabe von Währungssummen nützlich ist, wäre 999,999.00.

Wenn der ganzzahlige Teil der Zahl mehr Ziffern enthält als das Format Ziffernpositionen enthält, werden alle Ziffern als # ausgegeben, um einen Überlauf anzuzeigen.

Das Exponentenelement bewirkt, dass Zahlen mit fester Position normalisiert werden, sodass die erste Ziffer im ganzzahligen Teil 1 bis 9 ist (es sei denn, der Wert der Zahl ist Null; in diesem Fall ist der Wert des Exponenten ebenfalls Null). Das Element EE wählt automatisch die richtige Anzahl von Ziffern im Exponenten aus und gibt das +-Zeichen nicht aus, während EEE, EEEE und EEEEE immer das +- oder --Zeichen und die angeforderte Anzahl von Ziffern für den Exponenten ausgeben (führende Nullen werden nicht unterdrückt). Der Exponentenüberlauf wird durch # anstelle von Ziffern angezeigt.

Die Exponentenindikatoren geben je nach Groß- und Kleinschreibung des ersten Buchstabens im Formatelement entweder E oder e aus.

Das Formatelement X funktioniert wie 9, nur dass Hexadezimalziffern 0-9A-F ausgegeben werden. Hexadezimalbrüche werden derzeit nicht unterstützt. Ähnlich wie 9 ersetzt X führende Nullen durch Leerzeichen. Wenn das Element 0 zusammen mit X verwendet wird, werden hexadezimale Ziffern ohne Unterdrückung der führenden Nullen ausgegeben (verwenden Sie also 000X, um Hex-Zahlen zu auszugeben, die immer 4 Ziffern enthalten).

Beachten Sie, dass X hexadezimale Ziffern mit lateinischen Großbuchstaben ausgibt und x lateinische Kleinbuchstaben. Das hexadezimale 0 verwendet den Fall des nachfolgenden Formatelements X.

Normalerweise werden Hexadezimalzahlen als vorzeichenlose Zeichen ausgegeben, d. h. negative Zahlen haben alle 1 in den wichtigsten Bits, aber durch die Verwendung des X-Elements zusammen mit einem expliziten Vorzeichen (S oder MI) wird das --Zeichen zusammen mit dem absoluten Wert der Zahl ausgegeben.

Modelle für numerische Formate mit fester Position melden einen Überlauf bei speziellen Werten (unendlich oder keine Zahl) von Gleitkommazahlen.

Textminimale numerische Formate¶

Während numerische Formatmodelle mit fester Position immer explizit die Anzahl der Ziffern angeben, verwenden textminimale Formatelemente basierend auf dem Wert der Zahl eine minimale Anzahl von Ziffern. Die TM*-Formatelemente erzeugen unabhängig von dem Füllmodusmodifikator (fill oder compact) immer eine Ausgabe mit variabler Länge ohne Leerzeichen.

• TM9 gibt die Zahl als Ganzzahl oder Dezimalbruch aus, basierend auf dem Wert der Zahl. Jeder dezimale Festkommazahlenwert wird genau mit der Anzahl der Nachkommastellen ausgegeben, die durch die Skalierung der Zahl bestimmt wird (nachstehende Nullen werden im fill-Modus beibehalten).

• Bei Gleitkommazahlen wählt TM9 die Anzahl der Nachkommastellen basierend auf dem Exponenten der Zahl (beachten Sie, dass eine genaue Binär-Dezimalbruch-Umwandlung nicht möglich ist). Wenn die Größe der Gleitkommazahl zu groß ist und die Positionsnotation zu lang ist, wechselt sie zur wissenschaftlichen Notation (siehe TME unten). Wenn die Gleitkommazahl zu klein ist, gibt TM9 den Wert Null aus.

• TME gibt die Zahl in wissenschaftlicher Schreibweise aus, d. h. mit Exponent (gleich EE) und einer Ziffer an der Ganzzahlposition des Bruchteils. Der Fall des Exponentenindikators (E oder e) stimmt mit der Schreibweise des ersten Buchstabens (T oder t) im Formatelement überein.

• TM wählt entweder TM9 oder TME in Abhängigkeit von der Größe der Zahl, um die Länge des Textes zu minimieren und dabei die Genauigkeit zu erhalten.

Standardformate für die Ausgabe¶

In der folgenden Tabelle sind die Standardformate für die Ausgabe aufgeführt:

Standardformate für das Parsen¶

In der folgenden Tabelle sind die Standardformate für das Parsen aufgeführt:

Die Liste der Formate, die für die automatische optimistische Zeichenfolgenkonvertierung verwendet werden (d. h. für Zeichenfolgen, die automatisch als numerisch erkannt werden) ist die Vereinigung aller Formate in der obigen Tabelle der Standardeingabeformate.

Ausgabebeispiele¶

Dieses Beispiel zeigt, wie Zahlen mit führenden Nullen angezeigt werden:

create table sample_numbers (f float);
insert into sample_numbers (f) values (1.2);
insert into sample_numbers (f) values (123.456);
insert into sample_numbers (f) values (1234.56);
insert into sample_numbers (f) values (-123456.789);
select to_varchar(f, '999,999.999'), to_varchar(f, 'S000,000.000') from sample_numbers;

Copy

Die Ausgabe sieht ungefähr so aus:

+------------------------------+-------------------------------+
| TO_VARCHAR(F, '999,999.999') | TO_VARCHAR(F, 'S000,000.000') |
+==============================+===============================+
|        1.2                   | +000,001.200                  |
+------------------------------+-------------------------------+
|      123.456                 | +000,123.456                  |
+------------------------------+-------------------------------+
|    1,234.56                  | +001,234.560                  |
+------------------------------+-------------------------------+
| -123,456.789                 | -123,456.789                  |
+------------------------------+-------------------------------+

Copy

Sie brauchen keine führenden Nullen, um Zahlen anzupassen. Der Standardfüllmodus ist „fill“. Dies bedeutet, dass führende Leerzeichen verwendet werden, um Zahlen basierend auf den Positionen der Dezimalpunkte anzupassen.

select to_varchar(f, '999,999.999'), to_varchar(f, 'S999,999.999') from sample_numbers;

Copy

Die Ausgabe sieht ungefähr so aus:

+------------------------------+-------------------------------+
| TO_VARCHAR(F, '999,999.999') | TO_VARCHAR(F, 'S999,999.999') |
+==============================+===============================+
|        1.2                   |       +1.2                    |
+------------------------------+-------------------------------+
|      123.456                 |     +123.456                  |
+------------------------------+-------------------------------+
|    1,234.56                  |   +1,234.56                   |
+------------------------------+-------------------------------+
| -123,456.789                 | -123,456.789                  |
+------------------------------+-------------------------------+

Copy

Dieses Beispiel zeigt, was passiert, wenn Sie mit dem Modifikator FM (Füllmodus) vom fill-Modus in den compact-Modus wechseln, d. h. führende Zeichen entfernen, die die Zahlen anpassen würden:

select  to_varchar(f, '999,999.999'), to_varchar(f, 'FM999,999.999') from sample_numbers;

Copy

Die Ausgabe sieht ungefähr so aus:

+------------------------------+--------------------------------+
| TO_VARCHAR(F, '999,999.999') | TO_VARCHAR(F, 'FM999,999.999') |
+==============================+================================+
|        1.2                   | 1.2                            |
+------------------------------+--------------------------------+
|      123.456                 | 123.456                        |
+------------------------------+--------------------------------+
|    1,234.56                  | 1,234.56                       |
+------------------------------+--------------------------------+
| -123,456.789                 | -123,456.789                   |
+------------------------------+--------------------------------+

Copy

In diesem Beispiel wird erläutert, wie Zahlen in Exponentialschreibweise angezeigt werden:

select to_char(1234, '9d999EE'), 'will look like', '1.234E3';

Copy

Die Ausgabe sieht ungefähr so aus:

+--------------------------+------------------+-----------+
| TO_CHAR(1234, '9D999EE') | 'WILL LOOK LIKE' | '1.234E3' |
+==========================+==================+===========+
| 1.234E3                  |  will look like  |  1.234E3  |
+--------------------------+------------------+-----------+

Copy

Dies zeigt, wie Literale in die Ausgabe aufgenommen werden. Die literalen Teile sind in doppelte Anführungszeichen eingeschlossen (die wiederum in einfachen Anführungszeichen stehen, die die Zeichenfolge begrenzen).

select to_char(12, '">"99"<"');

Copy

Die Ausgabe sieht ungefähr so aus:

+-------+
| > 12< |
+-------+

Copy

Eingabebeispiele¶

Diese Beispiele zeigen die Verwendung von Formatmodellen für Eingaben.

Das folgende Beispiel zeigt einige einfache Eingabeoperationen, wobei der Unterschied zwischen der Verwendung von „0“ und „9“ zur Angabe des Ziffernformats hervorgehoben wird.

Die Ziffer „9“ als Formatierer akzeptiert Leerzeichen oder „fehlende“ führende Ziffern. Die Ziffer „0“ als Formatierer akzeptiert keine Leerzeichen oder fehlende führende Nullen.

-- All of the following convert the input to the number 12,345.67.
SELECT TO_NUMBER('012,345.67', '999,999.99', 8, 2);
SELECT TO_NUMBER('12,345.67', '999,999.99', 8, 2);
SELECT TO_NUMBER(' 12,345.67', '999,999.99', 8, 2);
-- The first of the following works, but the others will not convert.
-- (They are not supposed to convert, so "failure" is correct.)
SELECT TO_NUMBER('012,345.67', '000,000.00', 8, 2);
SELECT TO_NUMBER('12,345.67', '000,000.00', 8, 2);
SELECT TO_NUMBER(' 12,345.67', '000,000.00', 8, 2);

Copy

Hier erfahren Sie, wie Sie eines der beiden numerischen Formate (-### oder ###-) akzeptieren.

-- Create the table and insert data.
create table format1 (v varchar, i integer);
insert into format1 (v) values ('-101');
insert into format1 (v) values ('102-');
insert into format1 (v) values ('103');

-- Try to convert varchar to integer without a
-- format model.  This fails (as expected)
-- with a message similar to:
--    "Numeric value '102-' is not recognized"
update format1 set i = TO_NUMBER(v);

-- Now try again with a format specifier that allows the minus sign
-- to be at either the beginning or the end of the number.
-- Note the use of the vertical bar ("|") to indicate that
-- either format is acceptable.
update format1 set i = TO_NUMBER(v, 'MI999|999MI');
select i from format1;

Copy