Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.
# Zeichenfolgenfunktionen
Zeichenfolgefunktionen verarbeiten und bearbeiten Zeichenfolgen oder Ausdrücke, die zu Zeichenfolgen ausgewertet werden. Wenn das Argument *string* in diesen Funktionen ein Literalwert ist, muss es in einfache Anführungszeichen eingeschlossen werden. Die unterstützten Datentypen sind CHAR und VARCHAR.
Im folgenden Abschnitt werden Funktionsnamen, Syntax und Beschreibungen der unterstützten Funktionen bereitgestellt. Alle Offsets in Zeichenfolgen sind eins-basiert.
**Topics**
+ [Der Operator \$1\$1 (Verkettung)](concat_op.md)
+ [Die Funktion BTRIM](BTRIM.md)
+ [Funktion CONCAT](CONCAT.md)
+ [Funktion FORMAT\$1STRING](FORMAT_STRING.md)
+ [Die Funktionen LEFT und RIGHT](LEFT.md)
+ [Die Funktion LENGTH](LENGTH.md)
+ [Die Funktion LOWER](LOWER.md)
+ [Die Funktionen LPAD und RPAD](LPAD.md)
+ [Die Funktion LTRIM](LTRIM.md)
+ [Die Funktion POSITION](POSITION.md)
+ [Die Funktion REGEXP\$1COUNT](REGEXP_COUNT.md)
+ [Die Funktion REGEXP\$1INSTR](REGEXP_INSTR.md)
+ [Die Funktion REGEXP\$1REPLACE](REGEXP_REPLACE.md)
+ [Die Funktion REGEXP\$1SUBSTR](REGEXP_SUBSTR.md)
+ [Die Funktion REPEAT](REPEAT.md)
+ [Die Funktion REPLACE](REPLACE.md)
+ [Die Funktion REVERSE](REVERSE.md)
+ [Die Funktion RTRIM](RTRIM.md)
+ [SPLIT-Funktion](split.md)
+ [Die Funktion SPLIT\$1PART](SPLIT_PART.md)
+ [Die Funktion SUBSTRING](SUBSTRING.md)
+ [Die Funktion TRANSLATE](TRANSLATE.md)
+ [Die Funktion TRIM](TRIM.md)
+ [Die Funktion UPPER](UPPER.md)
+ [UUID-Funktion](UUID.md)
# Der Operator \$1\$1 (Verkettung)
Verkettet zwei Ausdrücke auf beiden Seiten des Symbols \$1\$1 und gibt den verketteten Ausdruck zurück.
Der Verkettungsoperator ist ähnlich wie. [Funktion CONCAT](CONCAT.md)
**Anmerkung**
Für die Funktion CONCAT und den Verkettungsoperator gilt, dass das Ergebnis der Verkettung null ist, wenn einer oder beide Ausdrücke null sind.
## Syntax
```
expression1 || expression2
```
## Argumente
*expression1*, *expression2*
Bei beiden Argumenten kann es sich um Zeichenfolgen oder Ausdrücke mit fester Länge oder mit variabler Länge handeln.
## Rückgabetyp
Der Operator \$1\$1 gibt eine Zeichenfolge zurück. Der Zeichenfolgetyp ist derselbe wie die Eingabeargumente.
## Beispiel
Im folgenden Beispiel werden die Felder FIRSTNAME und LASTNAME aus der Tabelle USERS verkettet:
```
select firstname || ' ' || lastname
from users
order by 1
limit 10;
concat
-----------------
Aaron Banks
Aaron Booth
Aaron Browning
Aaron Burnett
Aaron Casey
Aaron Cash
Aaron Castro
Aaron Dickerson
Aaron Dixon
Aaron Dotson
(10 rows)
```
Um Spalten zu verketten, die möglicherweise Null-Werte enthalten, verwenden Sie den Ausdruck [NVL- und COALESCE-Funktionen](NVL_function.md). Im folgenden Beispiel wird NVL verwendet, um eine 0 zurückzugeben, wenn NULL gefunden wird.
```
select venuename || ' seats ' || nvl(venueseats, 0)
from venue where venuestate = 'NV' or venuestate = 'NC'
order by 1
limit 10;
seating
-----------------------------------
Ballys Hotel seats 0
Bank of America Stadium seats 73298
Bellagio Hotel seats 0
Caesars Palace seats 0
Harrahs Hotel seats 0
Hilton Hotel seats 0
Luxor Hotel seats 0
Mandalay Bay Hotel seats 0
Mirage Hotel seats 0
New York New York seats 0
```
# Die Funktion BTRIM
Die BTRIM-Funktion kürzt eine Zeichenfolge durch Entfernen von Leerzeichen am Anfang und am Ende oder durch Entfernen von Zeichen am Anfang und am Ende, die mit einer optionalen angegebenen Zeichenfolge übereinstimmen.
## Syntax
```
BTRIM(string [, trim_chars ] )
```
## Argumente
*string*
Die VARCHAR-Eingabezeichenfolge, die gekürzt werden soll.
*trim\$1chars*
Die VARCHAR-Zeichenfolge, die die Zeichen für die Übereinstimmung enthält.
## Rückgabetyp
Die BTRIM-Funktion gibt eine VARCHAR-Zeichenfolge zurück.
## Beispiele
Im folgenden Beispiel werden Leerzeichen am Anfang und am Ende aus der Zeichenfolge entfernt `' abc '`:
```
select ' abc ' as untrim, btrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
Im folgenden Beispiel werden die Zeichenfolgen `'xyz'` am Anfang und am Ende aus der Zeichenfolge `'xyzaxyzbxyzcxyz'` entfernt. Die Zeichenfolgen `'xyz'` am Anfang und am Ende werden entfernt, entsprechende Zeichenfolgen innerhalb dieser Zeichenfolge jedoch nicht.
```
select 'xyzaxyzbxyzcxyz' as untrim,
btrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | axyzbxyzc
```
Im folgenden Beispiel werden die Teile am Anfang und am Ende der Zeichenfolge `'setuphistorycassettes'` entfernt, die mit einem der Zeichen in der *trim\$1chars*-Liste `'tes'` übereinstimmen. Alle `t`, `e` oder `s` am Anfang oder Ende der Eingabezeichenfolge, die vor einem anderen Zeichen stehen, das nicht in der *trim\$1chars*-Liste enthalten ist, werden entfernt.
```
SELECT btrim('setuphistorycassettes', 'tes');
btrim
-----------------
uphistoryca
```
# Funktion CONCAT
Die CONCAT-Funktion verkettet zwei Ausdrücke und gibt den Ergebnisausdruck zurück. Um mehr als zwei Ausdrücke zu verketten, verwenden Sie verschachtelte CONCAT-Funktionen. Der Verkettungsoperator (`||`) zwischen zwei Ausdrücken generiert dieselben Ergebnisse wie die CONCAT-Funktion.
**Anmerkung**
Für die Funktion CONCAT und den Verkettungsoperator gilt, dass das Ergebnis der Verkettung null ist, wenn einer oder beide Ausdrücke null sind.
## Syntax
```
CONCAT ( expression1, expression2 )
```
## Argumente
*expression1*, *expression2*
Beide Argumente können eine Zeichenfolge mit fester Länge, eine Zeichenfolge variabler Länge, ein binärer Ausdruck oder ein Ausdruck sein, der für eine dieser Eingaben ausgewertet wird.
## Rückgabetyp
CONCAT gibt einen Ausdruck zurück. Der Datentyp des Ausdrucks ist derselbe Typ wie die Eingabeargumente.
Wenn die Eingabeausdrücke unterschiedlichen Typs sind, wird AWS Clean Rooms versucht, einen der Ausdrücke implizit umzuwandeln. Wenn Werte nicht umgewandelt werden können, wird ein Fehler zurückgegeben.
## Beispiele
Im folgenden Beispiel werden zwei Zeichenliterale verkettet:
```
select concat('December 25, ', '2008');
concat
-------------------
December 25, 2008
(1 row)
```
Die folgende Abfrage verwendet anstelle von `||` den Operator CONCAT und generiert dasselbe Ergebnis:
```
select 'December 25, '||'2008';
concat
-------------------
December 25, 2008
(1 row)
```
Im folgenden Beispiel werden zwei CONCAT-Funktionen verwendet, um drei Zeichenfolgen zu verketten:
```
select concat('Thursday, ', concat('December 25, ', '2008'));
concat
-----------------------------
Thursday, December 25, 2008
(1 row)
```
Um Spalten zu verketten, die möglicherweise Null-Werte enthalten, verwenden Sie [NVL- und COALESCE-Funktionen](NVL_function.md). Im folgenden Beispiel wird NVL verwendet, um eine 0 zurückzugeben, wenn NULL gefunden wird.
```
select concat(venuename, concat(' seats ', nvl(venueseats, 0))) as seating
from venue where venuestate = 'NV' or venuestate = 'NC'
order by 1
limit 5;
seating
-----------------------------------
Ballys Hotel seats 0
Bank of America Stadium seats 73298
Bellagio Hotel seats 0
Caesars Palace seats 0
Harrahs Hotel seats 0
(5 rows)
```
Die folgende Abfrage verkettet CITY- und STATE-Werte aus der Tabelle VENUE:
```
select concat(venuecity, venuestate)
from venue
where venueseats > 75000
order by venueseats;
concat
-------------------
DenverCO
Kansas CityMO
East RutherfordNJ
LandoverMD
(4 rows)
```
Die folgende Abfrage verwendet verschachtelte CONCAT-Funktionen. Die Abfrage verkettet CITY- und STATE-Werte aus der Tabelle, trennt die Ergebniszeichenfolge jedoch durch ein Komma und ein Leerzeichen:
```
select concat(concat(venuecity,', '),venuestate)
from venue
where venueseats > 75000
order by venueseats;
concat
---------------------
Denver, CO
Kansas City, MO
East Rutherford, NJ
Landover, MD
(4 rows)
```
# Funktion FORMAT\$1STRING
Die FORMAT\$1STRING-Funktion erstellt eine formatierte Zeichenfolge, indem sie Platzhalter in einer Vorlagenzeichenfolge durch die angegebenen Argumente ersetzt. Sie gibt eine formatierte Zeichenfolge aus Formatzeichenfolgen im Printf-Stil zurück.
Die Funktion FORMAT\$1STRING ersetzt die Platzhalter in der Vorlagenzeichenfolge durch die entsprechenden Werte, die als Argumente übergeben wurden. Diese Art der Zeichenkettenformatierung kann nützlich sein, wenn Sie dynamisch Zeichenfolgen erstellen müssen, die eine Mischung aus statischem Text und dynamischen Daten enthalten, z. B. beim Generieren von Ausgabenachrichten, Berichten oder anderen Arten von informativem Text. Die FORMAT\$1STRING-Funktion bietet eine präzise und lesbare Möglichkeit, diese Arten von formatierten Zeichenfolgen zu erstellen, wodurch es einfacher wird, den Code, der die Ausgabe generiert, zu verwalten und zu aktualisieren.
## Syntax
```
format_string(strfmt, obj, ...)
```
## Argumente
*strfmt*
Ein STRING-Ausdruck.
*obj*
Ein STRING- oder numerischer Ausdruck.
## Rückgabetyp
FORMAT\$1STRING gibt einen STRING zurück.
## Beispiel
Das folgende Beispiel enthält eine Vorlagenzeichenfolge, die zwei Platzhalter enthält: `%d` für einen Dezimalwert (Ganzzahl) und `%s` für einen Zeichenkettenwert. Der `%d` Platzhalter wird durch den Dezimalwert (Ganzzahl) (`100`) ersetzt, und der Platzhalter %s wird durch den Zeichenfolgenwert () ersetzt. `"days"` Die Ausgabe ist eine Vorlagenzeichenfolge, bei der die Platzhalter durch die angegebenen Argumente ersetzt wurden:. `"Hello World 100 days"`
```
SELECT format_string("Hello World %d %s", 100, "days");
Hello World 100 days
```
# Die Funktionen LEFT und RIGHT
Diese Funktionen geben die angegebene Zahl der Zeichen am weitesten links oder am weitesten rechts in einer Zeichenfolge zurück.
Die Zahl basiert auf der Anzahl der Zeichen, nicht der Bytes. Daher werden Zeichen mit mehreren Bytes als einzelne Zeichen gezählt.
## Syntax
```
LEFT ( string, integer )
RIGHT ( string, integer )
```
## Argumente
*string*
Jede Zeichenfolge oder jeder Ausdruck, der zu einer Zeichenfolge ausgewertet wird.
*integer*
Eine positive Ganzzahl.
## Rückgabetyp
LEFT und RIGHT geben eine VARCHAR-Zeichenfolge zurück.
## Beispiel
Das folgende Beispiel gibt die 5 Zeichen ganz links und die 5 ganz rechts von Ereignisnamen zurück, die IDs zwischen 1000 und 1005 liegen:
```
select eventid, eventname,
left(eventname,5) as left_5,
right(eventname,5) as right_5
from event
where eventid between 1000 and 1005
order by 1;
eventid | eventname | left_5 | right_5
--------+----------------+--------+---------
1000 | Gypsy | Gypsy | Gypsy
1001 | Chicago | Chica | icago
1002 | The King and I | The K | and I
1003 | Pal Joey | Pal J | Joey
1004 | Grease | Greas | rease
1005 | Chicago | Chica | icago
(6 rows)
```
# Die Funktion LENGTH
# Die Funktion LOWER
Konvertiert eine Zeichenfolge in Kleinbuchstaben. LOWER unterstützt UTF-8-Multibyte-Zeichen bis zu einer maximalen Länge von vier Bytes pro Zeichen.
## Syntax
```
LOWER(string)
```
## Argument
*string*
Der Eingabeparameter ist eine VARCHAR-Zeichenfolge (oder ein anderer Datentyp wie CHAR, der implizit in VARCHAR konvertiert werden kann).
## Rückgabetyp
Die LOWER-Funktion gibt eine Zeichenfolge zurück, die den gleichen Datentyp wie die Eingabezeichenfolge hat.
## Beispiele
Im folgenden Beispiel wird das Feld „CATNAME“ in Kleinbuchstaben konvertiert:
```
select catname, lower(catname) from category order by 1,2;
catname | lower
----------+-----------
Classical | classical
Jazz | jazz
MLB | mlb
MLS | mls
Musicals | musicals
NBA | nba
NFL | nfl
NHL | nhl
Opera | opera
Plays | plays
Pop | pop
(11 rows)
```
# Die Funktionen LPAD und RPAD
Diese Funktionen fügen vor oder nach einer Zeichenfolge Zeichen an, basierend auf einer angegebenen Länge.
## Syntax
```
LPAD (string1, length, [ string2 ])
```
```
RPAD (string1, length, [ string2 ])
```
## Argumente
*string1*
Eine Zeichenfolge oder ein Ausdruck, der zu einer Zeichenfolge ausgewertet wird, beispielsweise der Name einer Zeichenspalte.
*length*
Eine Ganzzahl, die die Länge des Ergebnisses der Funktion definiert. Die Länge einer Zeichenfolge basiert auf der Anzahl der Zeichen, nicht der Bytes. Daher werden Zeichen mit mehreren Bytes als einzelne Zeichen gezählt. Wenn *string1* länger als die angegebene Länge ist, wird sie abgeschnitten (rechts). Wenn *length* eine negative Zahl ist, ist das Ergebnis der Funktion eine leere Zeichenfolge.
*string2*
Ein oder mehrere Zeichen, die vor oder nach *string1* angefügt werden. Dieses Argument ist optional. Wenn es nicht angegeben wird, werden Leerzeichen verwendet.
## Rückgabetyp
Diese Funktionen geben einen VARCHAR-Datentyp zurück.
## Beispiele
Schneidet einen angegebenen Satz von Veranstaltungsnamen auf 20 Zeichen ab und fügt vor den kürzeren Namen Leerzeichen an:
```
select lpad(eventname,20) from event
where eventid between 1 and 5 order by 1;
lpad
--------------------
Salome
Il Trovatore
Boris Godunov
Gotterdammerung
La Cenerentola (Cind
(5 rows)
```
Schneidet denselben Satz von Veranstaltungsnamen auf 20 Zeichen ab, fügt vor den kürzeren Namen jedoch an `0123456789`.
```
select rpad(eventname,20,'0123456789') from event
where eventid between 1 and 5 order by 1;
rpad
--------------------
Boris Godunov0123456
Gotterdammerung01234
Il Trovatore01234567
La Cenerentola (Cind
Salome01234567890123
(5 rows)
```
# Die Funktion LTRIM
Kürzt Zeichen ab dem Anfang einer Zeichenfolge. Entfernt die längste Zeichenfolge, die nur Zeichen aus der Liste der Trimm-Zeichen enthält. Das Kürzen ist abgeschlossen, wenn in der Eingabezeichenfolge kein Kürzungszeichen vorkommt.
## Syntax
```
LTRIM( string [, trim_chars] )
```
## Argumente
*string*
Eine Zeichenfolgenspalte, ein Ausdruck oder ein Zeichenfolgenliteral, die/der/das gekürzt werden soll.
*trim\$1chars*
Eine Zeichenfolgenspalte, ein Ausdruck oder ein Zeichenfolgenliteral, die/der/das die Zeichen darstellt, die ab dem Anfang von *string* gekürzt werden sollen. Wenn nicht angegeben, wird ein Leerzeichen als Trimm-Zeichen verwendet.
## Rückgabetyp
Die LTRIM-Funktion gibt eine Zeichenfolge zurück, die denselben Datentyp wie die Eingabezeichenfolge (*string*) hat (CHAR oder VARCHAR).
## Beispiele
Im folgenden Beispiel wird das Jahr aus der `listime`-Spalte gekürzt. Die Trimm-Zeichen im Zeichenfolgenliteral `'2008-'` geben die Zeichen an, die von links gekürzt werden sollen. Bei Verwendung der Trimm-Zeichen `'028-'` erzielen Sie dasselbe Ergebnis.
```
select listid, listtime, ltrim(listtime, '2008-')
from listing
order by 1, 2, 3
limit 10;
listid | listtime | ltrim
-------+---------------------+----------------
1 | 2008-01-24 06:43:29 | 1-24 06:43:29
2 | 2008-03-05 12:25:29 | 3-05 12:25:29
3 | 2008-11-01 07:35:33 | 11-01 07:35:33
4 | 2008-05-24 01:18:37 | 5-24 01:18:37
5 | 2008-05-17 02:29:11 | 5-17 02:29:11
6 | 2008-08-15 02:08:13 | 15 02:08:13
7 | 2008-11-15 09:38:15 | 11-15 09:38:15
8 | 2008-11-09 05:07:30 | 11-09 05:07:30
9 | 2008-09-09 08:03:36 | 9-09 08:03:36
10 | 2008-06-17 09:44:54 | 6-17 09:44:54
```
LTRIM entfernt alle Zeichen in *trim\$1chars*, wenn sie sich am Anfang von *string* befinden. Im folgenden Beispiel werden die Zeichen „C“, „D“ und „G“gekürzt, wenn sie sich am Anfang von VENUENAME befinden. Dabei handelt es sich um eine VARCHAR-Spalte.
```
select venueid, venuename, ltrim(venuename, 'CDG')
from venue
where venuename like '%Park'
order by 2
limit 7;
venueid | venuename | btrim
--------+----------------------------+--------------------------
121 | ATT Park | ATT Park
109 | Citizens Bank Park | itizens Bank Park
102 | Comerica Park | omerica Park
9 | Dick's Sporting Goods Park | ick's Sporting Goods Park
97 | Fenway Park | Fenway Park
112 | Great American Ball Park | reat American Ball Park
114 | Miller Park | Miller Park
```
Im folgenden Beispiel wird das Trimm-Zeichen `2` verwendet, das aus der`venueid`-Spalte abgerufen wird.
```
select ltrim('2008-01-24 06:43:29', venueid)
from venue where venueid=2;
ltrim
------------------
008-01-24 06:43:29
```
Im folgenden Beispiel werden keine Zeichen gekürzt, da vor dem Trimm-Zeichen `'0'` eine `2` enthalten ist.
```
select ltrim('2008-01-24 06:43:29', '0');
ltrim
-------------------
2008-01-24 06:43:29
```
Im folgenden Beispiel werden standardmäßige Leerzeichen als Trimm-Zeichen verwendet und die beiden Leerzeichen zu Beginn der Zeichenfolge werden gekürzt.
```
select ltrim(' 2008-01-24 06:43:29');
ltrim
-------------------
2008-01-24 06:43:29
```
# Die Funktion POSITION
Gibt den Ort der angegebenen Unterzeichenfolge innerhalb einer Zeichenfolge zurück.
## Syntax
```
POSITION(substring IN string )
```
## Argumente
*substring*
Die Unterzeichenfolge, die innerhalb der *Zeichenfolge* gesucht werden soll.
*string*
Die Zeichenfolge oder Spalte, die durchsucht werden soll.
## Rückgabetyp
Die POSITION-Funktion gibt eine Ganzzahl zurück, die der Position der Unterzeichenfolge entspricht (eins-basiert, nicht null-basiert). Die Position basiert auf der Anzahl der Zeichen, nicht der Bytes. Daher werden Zeichen mit mehreren Bytes als einzelne Zeichen gezählt.
## Nutzungshinweise
POSITION gibt 0 zurück, wenn die Unterzeichenfolge nicht innerhalb der Zeichenfolge gefunden wird:
```
select position('dog' in 'fish');
position
----------
0
(1 row)
```
## Beispiele
Im folgenden Beispiel wird die Position der Zeichenfolge `fish` innerhalb des Worts `dogfish` gezeigt:
```
select position('fish' in 'dogfish');
position
----------
4
(1 row)
```
Im folgenden Beispiel wird die Zahl der Verkaufstransaktionen mit einer COMMISSION von mehr als 999,00 aus der Tabelle SALES zurückgegeben:
```
select distinct position('.' in commission), count (position('.' in commission))
from sales where position('.' in commission) > 4 group by position('.' in commission)
order by 1,2;
position | count
---------+-------
5 | 629
(1 row)
```
# Die Funktion REGEXP\$1COUNT
Durchsucht eine Zeichenfolge nach einem regulären Ausdrucksmuster und gibt eine Ganzzahl zurück, die die Häufigkeit angibt, mit der das Muster in der Zeichenfolge auftritt. Wenn keine Übereinstimmung gefunden wird, gibt die Funktion 0 zurück.
## Syntax
```
REGEXP_COUNT ( source_string, pattern [, position [, parameters ] ] )
```
## Argumente
*source\$1string*
Ein Zeichenfolgenausdruck (beispielsweise ein Spaltenname), der gesucht werden soll.
*pattern*
Ein Zeichenfolgenliteral, das ein Muster für reguläre Ausdrücke darstellt.
*position*
Eine positive Ganzzahl, die die Position innerhalb von *source\$1string* angibt, an der die Suche gestartet werden soll. Die Position basiert auf der Anzahl der Zeichen, nicht der Bytes. Daher werden Zeichen mit mehreren Bytes als einzelne Zeichen gezählt. Der Standardwert ist 1. Wenn *position* kleiner als 1 ist, beginnt die Suche mit dem ersten Zeichen von *source\$1string*. Wenn *position* größer als die Anzahl der Zeichen in *source\$1string* ist, ist das Ergebnis 0.
*parameters (Parameter*
Ein oder mehrere Zeichenfolgenliterale, die angeben, wie die Funktion mit dem Muster übereinstimmt. Die folgenden Werte sind möglich:
+ c – Übereinstimmung mit Unterscheidung von Groß- und Kleinschreibung durchführen. Die Standardeinstellung ist, beim Abgleich die Groß- und Kleinschreibung zu beachten.
+ i – Übereinstimmung ohne Unterscheidung von Groß- und Kleinschreibung durchführen.
+ p – Das Musters mit einem PCRE-Dialekt (Perl Compatible Regular Expression) interpretieren.
## Rückgabetyp
Ganzzahl
## Beispiel
Im folgenden Beispiel wird die Häufigkeit gezählt, mit der eine Folge aus drei Buchstaben auftritt.
```
SELECT regexp_count('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
regexp_count
--------------
8
```
Im folgenden Beispiel wird die Häufigkeit gezählt, mit der der Name der obersten Domäne entweder `org` oder `edu` ist.
```
SELECT email, regexp_count(email,'@[^.]*\\.(org|edu)')FROM users
ORDER BY userid LIMIT 4;
email | regexp_count
-----------------------------------------------+--------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | 1
Suspendisse.tristique@nonnisiAenean.edu | 1
amet.faucibus.ut@condimentumegetvolutpat.ca | 0
sed@lacusUtnec.ca | 0
```
Im folgenden Beispiel wird die Anzahl der Vorkommen der Zeichenfolge `FOX` gezählt, wobei nicht zwischen Groß- und Kleinschreibung unterschieden wird.
```
SELECT regexp_count('the fox', 'FOX', 1, 'i');
regexp_count
--------------
1
```
Im folgenden Beispiel wird ein im PCRE-Dialekt geschriebenes Muster verwendet, um Wörter mit mindestens einer Zahl und einem Kleinbuchstaben zu finden. Hierfür wird der Operator `?=` verwendet, der eine bestimmte Lookahead-Konnotation in PCRE hat. In diesem Beispiel wird die Anzahl der Vorkommen solcher Wörter gezählt, wobei zwischen Groß- und Kleinschreibung unterschieden wird.
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'p');
regexp_count
--------------
2
```
Im folgenden Beispiel wird ein im PCRE-Dialekt geschriebenes Muster verwendet, um Wörter mit mindestens einer Zahl und einem Kleinbuchstaben zu finden. Hierfür wird der Operator `?=` verwendet, der eine bestimmte Konnotation in PCRE hat. In diesem Beispiel wird die Anzahl der Vorkommen solcher Wörter gezählt. Dies unterscheidet sich insofern vom vorherigen Beispiel, als dass nicht zwischen Groß- und Kleinschreibung unterschieden wird.
```
SELECT regexp_count('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 'ip');
regexp_count
--------------
3
```
# Die Funktion REGEXP\$1INSTR
Durchsucht eine Zeichenfolge nach einem regulären Ausdrucksmuster und gibt eine Ganzzahl zurück, die die Anfangs- oder Endposition der übereinstimmenden Unterzeichenfolge angibt. Wenn keine Übereinstimmung gefunden wird, gibt die Funktion 0 zurück. REGEXP\$1INSTR ist der Funktion [POSITION](POSITION.md) ähnlich. Sie können damit jedoch eine Zeichenfolge nach einem regulären Ausdrucksmuster durchsuchen.
## Syntax
```
REGEXP_INSTR ( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## Argumente
*source\$1string*
Ein Zeichenfolgenausdruck (beispielsweise ein Spaltenname), der gesucht werden soll.
*pattern*
Ein Zeichenfolgenliteral, das ein Muster für reguläre Ausdrücke darstellt.
*position*
Eine positive Ganzzahl, die die Position innerhalb von *source\$1string* angibt, an der die Suche gestartet werden soll. Die Position basiert auf der Anzahl der Zeichen, nicht der Bytes. Daher werden Zeichen mit mehreren Bytes als einzelne Zeichen gezählt. Der Standardwert ist 1. Wenn *position* kleiner als 1 ist, beginnt die Suche mit dem ersten Zeichen von *source\$1string*. Wenn *position* größer als die Anzahl der Zeichen in *source\$1string* ist, ist das Ergebnis 0.
*occurrence*
Eine positive Ganzzahl, die angibt, welches Vorkommen des Musters verwendet werden soll. REGEXP\$1INSTR überspringt die erste *occurrence* -1 Übereinstimmungen. Der Standardwert ist 1. Wenn *occurrence* kleiner als 1 oder größer als die Anzahl der Zeichen in *source\$1string* ist, wird die Suche ignoriert und das Ergebnis ist 0.
*option*
Ein Wert, der angibt, ob die Position des ersten Zeichens der Übereinstimmung (`0`) oder die Position des ersten Zeichens nach dem Ende der Übereinstimmung (`1`) zurückgegeben werden soll. Ein Wert ungleich null entspricht 1. Der Standardwert lautet 0.
*parameters (Parameter*
Ein oder mehrere Zeichenfolgenliterale, die angeben, wie die Funktion mit dem Muster übereinstimmt. Die folgenden Werte sind möglich:
+ c – Übereinstimmung mit Unterscheidung von Groß- und Kleinschreibung durchführen. Die Standardeinstellung ist, beim Abgleich die Groß- und Kleinschreibung zu beachten.
+ i – Übereinstimmung ohne Unterscheidung von Groß- und Kleinschreibung durchführen.
+ e – Teilzeichenfolge mittels eines Unterausdrucks extrahieren.
Wenn *pattern* einen Unterausdruck enthält, sucht REGEXP\$1INSTR nach einer Teilzeichenfolge, die mit dem ersten Unterausdruck in *pattern* übereinstimmt. REGEXP\$1INSTR berücksichtigt nur den ersten Unterausdruck. Zusätzliche Unterausdrücke werden ignoriert. Wenn das Muster über keinen Unterausdruck verfügt, ignoriert REGEXP\$1INSTR den Parameter 'e'.
+ p – Das Musters mit einem PCRE-Dialekt (Perl Compatible Regular Expression) interpretieren.
## Rückgabetyp
Ganzzahl
## Beispiel
Im folgenden Beispiel wird nach dem Zeichen `@` gesucht, mit dem Domänennamen beginnen. Anschließend wird die Anfangsposition der ersten Übereinstimmung zurückgegeben.
```
SELECT email, regexp_instr(email, '@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_instr
-----------------------------------------------+--------------
Etiam.laoreet.libero@example.com | 21
Suspendisse.tristique@nonnisiAenean.edu | 22
amet.faucibus.ut@condimentumegetvolutpat.ca | 17
sed@lacusUtnec.ca | 4
```
Im folgenden Beispiel wird nach Varianten des Worts `Center` gesucht. Anschließend wird die Anfangsposition der ersten Übereinstimmung zurückgegeben.
```
SELECT venuename, regexp_instr(venuename,'[cC]ent(er|re)$')
FROM venue
WHERE regexp_instr(venuename,'[cC]ent(er|re)$') > 0
ORDER BY venueid LIMIT 4;
venuename | regexp_instr
-----------------------+--------------
The Home Depot Center | 16
Izod Center | 6
Wachovia Center | 10
Air Canada Centre | 12
```
Im folgenden Beispiel wird die Anfangsposition des ersten Vorkommens der Zeichenfolge `FOX` gefunden, wobei nicht zwischen Groß- und Kleinschreibung unterschieden wird.
```
SELECT regexp_instr('the fox', 'FOX', 1, 1, 0, 'i');
regexp_instr
--------------
5
```
Im folgenden Beispiel wird ein im PCRE-Dialekt geschriebenes Muster verwendet, um Wörter mit mindestens einer Zahl und einem Kleinbuchstaben zu finden. Hierfür wird der Operator `?=` verwendet, der eine bestimmte Lookahead-Konnotation in PCRE hat. In diesem Beispiel wird die Anfangsposition des zweiten Wortes gefunden.
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'p');
regexp_instr
--------------
21
```
Im folgenden Beispiel wird ein im PCRE-Dialekt geschriebenes Muster verwendet, um Wörter mit mindestens einer Zahl und einem Kleinbuchstaben zu finden. Hierfür wird der Operator `?=` verwendet, der eine bestimmte Lookahead-Konnotation in PCRE hat. In diesem Beispiel wird die Anfangsposition des zweiten Worts gefunden. Dies unterscheidet sich insofern vom vorherigen Beispiel, als dass nicht zwischen Groß- und Kleinschreibung unterschieden wird.
```
SELECT regexp_instr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 0, 'ip');
regexp_instr
--------------
15
```
# Die Funktion REGEXP\$1REPLACE
Durchsucht eine Zeichenfolge nach einem regulären Ausdrucksmuster und ersetzt jedes Vorkommen des Musters durch die angegebene Zeichenfolge. REGEXP\$1REPLACE ist [Die Funktion REPLACE](REPLACE.md) ähnlich. Sie können jedoch eine Zeichenfolge nach einem regulären Ausdrucksmuster durchsuchen.
REGEXP\$1REPLACE ist [Die Funktion TRANSLATE](TRANSLATE.md) und [Die Funktion REPLACE](REPLACE.md) ähnlich. TRANSLATE führt jedoch mehrere Einzelzeichenersetzungen durch und REPLACE ersetzt eine ganze Zeichenfolge durch eine andere Zeichenfolge. Mit REGEXP\$1REPLACE können Sie dagegen eine Zeichenfolge nach einem regulären Ausdrucksmuster durchsuchen.
## Syntax
```
REGEXP_REPLACE ( source_string, pattern [, replace_string [ , position [, parameters ] ] ] )
```
## Argumente
*source\$1string*
Ein Zeichenfolgenausdruck (beispielsweise ein Spaltenname), der gesucht werden soll.
*pattern*
Ein Zeichenfolgenliteral, das ein Muster für reguläre Ausdrücke darstellt.
*replace\$1string*
Ein Zeichenfolgenausdruck (beispielsweise ein Spaltenname), der jedes Vorkommen eines Musters ersetzt. Der Standardwert ist eine leere Zeichenfolge ("").
*position*
Eine positive Ganzzahl, die die Position innerhalb von *source\$1string* angibt, an der die Suche gestartet werden soll. Die Position basiert auf der Anzahl der Zeichen, nicht der Bytes. Daher werden Zeichen mit mehreren Bytes als einzelne Zeichen gezählt. Der Standardwert ist 1. Wenn *position* kleiner als 1 ist, beginnt die Suche mit dem ersten Zeichen von *source\$1string*. Wenn *position* größer als die Anzahl der Zeichen in *source\$1string* ist, ist das Ergebnis *source\$1string*.
*parameters (Parameter*
Ein oder mehrere Zeichenfolgenliterale, die angeben, wie die Funktion mit dem Muster übereinstimmt. Die folgenden Werte sind möglich:
+ c – Übereinstimmung mit Unterscheidung von Groß- und Kleinschreibung durchführen. Die Standardeinstellung ist, beim Abgleich die Groß- und Kleinschreibung zu beachten.
+ i – Übereinstimmung ohne Unterscheidung von Groß- und Kleinschreibung durchführen.
+ p – Das Musters mit einem PCRE-Dialekt (Perl Compatible Regular Expression) interpretieren.
## Rückgabetyp
VARCHAR
Wenn *pattern* oder *replace\$1string* NULL sind, ist der Rückgabewert NULL.
## Beispiel
Im folgenden Beispiel werden `@` und der Domänenname aus E-Mail-Adressen gelöscht.
```
SELECT email, regexp_replace(email, '@.*\\.(org|gov|com|edu|ca)$')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_replace
-----------------------------------------------+----------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero
Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique
amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut
sed@lacusUtnec.ca | sed
```
Im folgenden Beispiel werden die Domänennamen von E-Mail-Adressen durch diesen Wert ersetzt: `internal.company.com`.
```
SELECT email, regexp_replace(email, '@.*\\.[[:alpha:]]{2,3}',
'@internal.company.com') FROM users
ORDER BY userid LIMIT 4;
email | regexp_replace
-----------------------------------------------+--------------------------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | Etiam.laoreet.libero@internal.company.com
Suspendisse.tristique@nonnisiAenean.edu | Suspendisse.tristique@internal.company.com
amet.faucibus.ut@condimentumegetvolutpat.ca | amet.faucibus.ut@internal.company.com
sed@lacusUtnec.ca | sed@internal.company.com
```
Im folgenden Beispiel werden alle Vorkommen der Zeichenfolge `FOX` innerhalb des Werts `quick brown fox` ersetzt, wobei nicht zwischen Groß- und Kleinschreibung unterschieden wird.
```
SELECT regexp_replace('the fox', 'FOX', 'quick brown fox', 1, 'i');
regexp_replace
---------------------
the quick brown fox
```
Im folgenden Beispiel wird ein im PCRE-Dialekt geschriebenes Muster verwendet, um Wörter mit mindestens einer Zahl und einem Kleinbuchstaben zu finden. Hierfür wird der Operator `?=` verwendet, der eine bestimmte Lookahead-Konnotation in PCRE hat. In diesem Beispiel werden alle Vorkommen eines solchen Worts mit dem Wert ersetzt `[hidden]`.
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'p');
regexp_replace
-------------------------------
[hidden] plain A1234 [hidden]
```
Im folgenden Beispiel wird ein im PCRE-Dialekt geschriebenes Muster verwendet, um Wörter mit mindestens einer Zahl und einem Kleinbuchstaben zu finden. Hierfür wird der Operator `?=` verwendet, der eine bestimmte Lookahead-Konnotation in PCRE hat. In diesem Beispiel werden alle Vorkommen eines solchen Worts mit dem Wert `[hidden]` ersetzt. Dies unterscheidet sich insofern vom vorherigen Beispiel, als dass nicht zwischen Groß- und Kleinschreibung unterschieden wird.
```
SELECT regexp_replace('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', '[hidden]', 1, 'ip');
regexp_replace
----------------------------------
[hidden] plain [hidden] [hidden]
```
# Die Funktion REGEXP\$1SUBSTR
Gibt Zeichen aus einer Zeichenfolge zurück, indem diese nach einem regulären Ausdrucksmuster durchsucht wird. REGEXP\$1SUBSTR ist der Funktion [Die Funktion SUBSTRING](SUBSTRING.md) ähnlich. Sie können jedoch eine Zeichenfolge nach einem regulären Ausdrucksmuster durchsuchen. Wenn die Funktion den regulären Ausdruck keinem Zeichen in der Zeichenfolge zuordnen kann, wird eine leere Zeichenfolge zurückgegeben.
## Syntax
```
REGEXP_SUBSTR ( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## Argumente
*source\$1string*
Ein Zeichenfolgeausdruck, der durchsucht werden soll.
*pattern*
Ein Zeichenfolgenliteral, das ein Muster für reguläre Ausdrücke darstellt.
*position*
Eine positive Ganzzahl, die die Position innerhalb von *source\$1string* angibt, an der die Suche gestartet werden soll. Die Position basiert auf der Anzahl der Zeichen, nicht der Bytes. Daher werden Zeichen mit mehreren Bytes als einzelne Zeichen gezählt. Der Standardwert ist 1. Wenn *position* kleiner als 1 ist, beginnt die Suche mit dem ersten Zeichen von *source\$1string*. Wenn *position* größer als die Anzahl der Zeichen in *source\$1string* ist, ist das Ergebnis eine leere Zeichenfolge ("").
*occurrence*
Eine positive Ganzzahl, die angibt, welches Vorkommen des Musters verwendet werden soll. REGEXP\$1SUBSTR überspringt die erste *occurrence* -1 Übereinstimmungen. Der Standardwert ist 1. Wenn *occurrence* kleiner als 1 oder größer als die Anzahl der Zeichen in *source\$1string* ist, wird die Suche ignoriert und das Ergebnis ist NULL.
*parameters (Parameter*
Ein oder mehrere Zeichenfolgenliterale, die angeben, wie die Funktion mit dem Muster übereinstimmt. Die folgenden Werte sind möglich:
+ c – Übereinstimmung mit Unterscheidung von Groß- und Kleinschreibung durchführen. Die Standardeinstellung ist, beim Abgleich die Groß- und Kleinschreibung zu beachten.
+ i – Übereinstimmung ohne Unterscheidung von Groß- und Kleinschreibung durchführen.
+ e – Teilzeichenfolge mittels eines Unterausdrucks extrahieren.
Wenn *pattern* einen Unterausdruck enthält, sucht REGEXP\$1SUBSTR nach einer Teilzeichenfolge, die mit dem ersten Unterausdruck in *pattern* übereinstimmt. Ein Unterausdruck ist ein Ausdruck innerhalb des Musters, der in Klammern gesetzt ist. Bei dem Muster `'This is a (\\w+)'` beispielsweise wird der erste Ausdruck mit der Zeichenfolge `'This is a '`, gefolgt von einem Wort abgeglichen. Anstatt ein *Muster* zurückzugeben, gibt REGEXP\$1SUBSTR mit dem Parameter `e` nur die Zeichenfolge innerhalb des Unterausdrucks zurück.
REGEXP\$1SUBSTR berücksichtigt nur den ersten Unterausdruck. Zusätzliche Unterausdrücke werden ignoriert. Wenn das Muster über keinen Unterausdruck verfügt, ignoriert REGEXP\$1SUBSTR den Parameter 'e'.
+ p – Das Musters mit einem PCRE-Dialekt (Perl Compatible Regular Expression) interpretieren.
## Rückgabetyp
VARCHAR
## Beispiel
Im folgenden Beispiel wird der E-Mail-Adresse-Abschnitt zwischen dem Zeichen @ und der Domänenerweiterung zurückgegeben.
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu | @sodalesMaurisblandit
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
```
Im folgenden Beispiel wird der Teil der Eingabe zurückgegeben, der dem ersten Vorkommen der Zeichenfolge `FOX` entspricht, wobei nicht zwischen Groß- und Kleinschreibung unterschieden wird.
```
SELECT regexp_substr('the fox', 'FOX', 1, 1, 'i');
regexp_substr
---------------
fox
```
Das folgende Beispiel gibt den ersten Teil der Eingabe zurück, der mit Kleinbuchstaben beginnt. Dies ist funktionell identisch mit derselben SELECT-Anweisung ohne den `c`-Parameter.
```
SELECT regexp_substr('THE SECRET CODE IS THE LOWERCASE PART OF 1931abc0EZ.', '[a-z]+', 1, 1, 'c');
regexp_substr
---------------
abc
```
Im folgenden Beispiel wird ein im PCRE-Dialekt geschriebenes Muster verwendet, um Wörter mit mindestens einer Zahl und einem Kleinbuchstaben zu finden. Hierfür wird der Operator `?=` verwendet, der eine bestimmte Lookahead-Konnotation in PCRE hat. In diesem Beispiel wird der Teil der Eingabe zurückgegeben, der dem zweiten Wort entspricht.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'p');
regexp_substr
---------------
a1234
```
Im folgenden Beispiel wird ein im PCRE-Dialekt geschriebenes Muster verwendet, um Wörter mit mindestens einer Zahl und einem Kleinbuchstaben zu finden. Hierfür wird der Operator `?=` verwendet, der eine bestimmte Lookahead-Konnotation in PCRE hat. In diesem Beispiel wird der der Teil der Eingabe zurückgegeben, der dem zweiten Wort entspricht. Dies unterscheidet sich insofern vom vorherigen Beispiel, als dass nicht zwischen Groß- und Kleinschreibung unterschieden wird.
```
SELECT regexp_substr('passwd7 plain A1234 a1234', '(?=[^ ]*[a-z])(?=[^ ]*[0-9])[^ ]+', 1, 2, 'ip');
regexp_substr
---------------
A1234
```
Im folgenden Beispiel wird ein Unterausdruck verwendet, um die zweite Zeichenfolge zu finden, die dem Muster `'this is a (\\w+)'` entspricht, wobei nicht zwischen Groß- und Kleinschreibung unterschieden wird. Der Unterausdruck in Klammern wird zurückgegeben.
```
select regexp_substr(
'This is a cat, this is a dog. This is a mouse.',
'this is a (\\w+)', 1, 2, 'ie');
regexp_substr
---------------
dog
```
# Die Funktion REPEAT
Wiederholt eine Zeichenfolge mit der angegebenen Häufigkeit. Wenn der Eingabeparameter numerisch ist, wird er von REPEAT als Zeichenfolge behandelt.
## Syntax
```
REPEAT(string, integer)
```
## Argumente
*string*
Der erste Eingabeparameter ist die Zeichenfolge, die wiederholt werden soll.
*integer*
Der zweite Parameter ist eine Ganzzahl, die die Häufigkeit angibt, mit der die Zeichenfolge wiederholt werden soll.
## Rückgabetyp
Die REPEAT-Funktion gibt eine Zeichenfolge zurück.
## Beispiele
Im folgenden Beispiel wird der Wert der Spalte CATID in der Tabelle CATEGORY dreimal wiederholt:
```
select catid, repeat(catid,3)
from category
order by 1,2;
catid | repeat
-------+--------
1 | 111
2 | 222
3 | 333
4 | 444
5 | 555
6 | 666
7 | 777
8 | 888
9 | 999
10 | 101010
11 | 111111
(11 rows)
```
# Die Funktion REPLACE
Ersetzt alle Vorkommen eines Satzes von Zeichen innerhalb einer vorhandenen Zeichenfolge durch andere angegebene Zeichen.
REPLACE ist [Die Funktion TRANSLATE](TRANSLATE.md) und [Die Funktion REGEXP\$1REPLACE](REGEXP_REPLACE.md) ähnlich. TRANSLATE führt jedoch mehrere Einzelzeichenersetzungen durch und REPLACE ersetzt eine ganze Zeichenfolge durch eine andere Zeichenfolge. REPLACE ersetzt dagegen eine ganze Zeichenfolge durch eine andere Zeichenfolge.
## Syntax
```
REPLACE(string1, old_chars, new_chars)
```
## Argumente
*string*
Die CHAR- oder VARCHAR-Zeichenfolge, die durchsucht werden soll.
*old\$1chars*
Die CHAR- oder VARCHAR-Zeichenfolge, die ersetzt werden soll.
*new\$1chars*
Die neue CHAR- oder VARCHAR-Zeichenfolge, die *old\$1string* ersetzt.
## Rückgabetyp
VARCHAR
Wenn *old\$1chars* oder *new\$1chars* NULL sind, ist der Rückgabewert NULL.
## Beispiele
Im folgenden Beispiel wird die Zeichenfolge `Shows` in `Theatre` im Feld CATGROUP konvertiert:
```
select catid, catgroup,
replace(catgroup, 'Shows', 'Theatre')
from category
order by 1,2,3;
catid | catgroup | replace
-------+----------+----------
1 | Sports | Sports
2 | Sports | Sports
3 | Sports | Sports
4 | Sports | Sports
5 | Sports | Sports
6 | Shows | Theatre
7 | Shows | Theatre
8 | Shows | Theatre
9 | Concerts | Concerts
10 | Concerts | Concerts
11 | Concerts | Concerts
(11 rows)
```
# Die Funktion REVERSE
Die REVERSE-Funktion wird für eine Zeichenfolge ausgeführt und gibt die Zeichen in umgekehrter Reihenfolge wieder. Beispielsweise gibt `reverse('abcde')` `edcba` zurück. Diese Funktion kann auf numerische und Datumsdatentypen sowie Zeichendatentypen angewendet werden. In den meisten Fällen hat sie jedoch für Zeichenfolgen mit Zeichen praktischen Nutzen.
## Syntax
```
REVERSE ( expression )
```
## Argument
*expression*
Ein Ausdruck mit einem Zeichen-, Datums-, Zeitstempel- oder numerischen Datentyp, der das Ziel der Zeichenumkehrung darstellt. Alle Ausdrücke werden implizit in Zeichenfolgen mit variabler Länge konvertiert. Leerzeichen am Ende von Zeichenfolgen mit fester Breite werden ignoriert.
## Rückgabetyp
REVERSE gibt einen VARCHAR zurück.
## Beispiele
Wählt fünf verschiedene Namen von Städten und die entsprechenden Umkehrungen der Namen aus der Tabelle USERS aus:
```
select distinct city as cityname, reverse(cityname)
from users order by city limit 5;
cityname | reverse
---------+----------
Aberdeen | needrebA
Abilene | enelibA
Ada | adA
Agat | tagA
Agawam | mawagA
(5 rows)
```
Wählen Sie fünf Buchstaben IDs und die entsprechende umgekehrte IDs Zeichenkette aus:
```
select salesid, reverse(salesid)::varchar
from sales order by salesid desc limit 5;
salesid | reverse
--------+---------
172456 | 654271
172455 | 554271
172454 | 454271
172453 | 354271
172452 | 254271
(5 rows)
```
# Die Funktion RTRIM
Die RTRIM-Funktion kürzt einen angegebenen Satz von Zeichen ab dem Ende einer Zeichenfolge. Entfernt die längste Zeichenfolge, die nur Zeichen aus der Liste der Trimm-Zeichen enthält. Das Kürzen ist abgeschlossen, wenn in der Eingabezeichenfolge kein Kürzungszeichen vorkommt.
## Syntax
```
RTRIM( string, trim_chars )
```
## Argumente
*string*
Eine Zeichenfolgenspalte, ein Ausdruck oder ein Zeichenfolgenliteral, die/der/das gekürzt werden soll.
*trim\$1chars*
Eine Zeichenfolgenspalte, ein Ausdruck oder ein Zeichenfolgenliteral, die/der/das die Zeichen darstellt, die am Ende von *string* gekürzt werden sollen. Wenn nicht angegeben, wird ein Leerzeichen als Trimm-Zeichen verwendet.
## Rückgabetyp
Eine Zeichenfolge mit demselben Datentyp wie das *string*-Argument.
## Beispiel
Im folgenden Beispiel werden Leerzeichen am Anfang und am Ende aus der Zeichenfolge entfernt `' abc '`:
```
select ' abc ' as untrim, rtrim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
Im folgenden Beispiel werden die Zeichenfolgen `'xyz'` am Ende der Zeichenfolge `'xyzaxyzbxyzcxyz'` entfernt. Die Zeichenfolgen `'xyz'` am Ende werden entfernt, entsprechende Zeichenfolgen innerhalb dieser Zeichenfolge jedoch nicht.
```
select 'xyzaxyzbxyzcxyz' as untrim,
rtrim('xyzaxyzbxyzcxyz', 'xyz') as trim;
untrim | trim
-----------------+-----------
xyzaxyzbxyzcxyz | xyzaxyzbxyzc
```
Im folgenden Beispiel werden die Teile am Ende der Zeichenfolge `'setuphistorycassettes'` entfernt, die mit einem der Zeichen in der *trim\$1chars*-Liste `'tes'` übereinstimmen. Alle `t`, `e` oder `s` am Ende der Eingabezeichenfolge, die vor einem anderen Zeichen stehen, das nicht in der *trim\$1chars*-Liste enthalten ist, werden entfernt.
```
SELECT rtrim('setuphistorycassettes', 'tes');
rtrim
-----------------
setuphistoryca
```
Im folgenden Beispiel werden die Zeichen „Park“ ab dem Ende von VENUENAME gekürzt, wenn vorhanden:
```
select venueid, venuename, rtrim(venuename, 'Park')
from venue
order by 1, 2, 3
limit 10;
venueid | venuename | rtrim
--------+----------------------------+-------------------------
1 | Toyota Park | Toyota
2 | Columbus Crew Stadium | Columbus Crew Stadium
3 | RFK Stadium | RFK Stadium
4 | CommunityAmerica Ballpark | CommunityAmerica Ballp
5 | Gillette Stadium | Gillette Stadium
6 | New York Giants Stadium | New York Giants Stadium
7 | BMO Field | BMO Field
8 | The Home Depot Center | The Home Depot Cente
9 | Dick's Sporting Goods Park | Dick's Sporting Goods
10 | Pizza Hut Park | Pizza Hut
```
Beachten Sie, dass RTRIM alle `P`, `a`, `r` oder `k` entfernt, wenn sie sich am Ende eines VENUENAME befinden.
# SPLIT-Funktion
Die SPLIT-Funktion ermöglicht es Ihnen, Teilstrings aus einer größeren Zeichenfolge zu extrahieren und mit ihnen als Array zu arbeiten. Die SPLIT-Funktion ist nützlich, wenn Sie eine Zeichenfolge anhand eines bestimmten Trennzeichens oder Musters in einzelne Komponenten aufteilen müssen.
## Syntax
```
split(str, regex, limit)
```
## Argumente
*str*
Ein Zeichenkettenausdruck, der aufgeteilt werden soll.
*regex*
Eine Zeichenfolge, die einen regulären Ausdruck darstellt. Die *Regex-Zeichenfolge* sollte ein regulärer Java-Ausdruck sein.
*limit*
Ein Integer-Ausdruck, der steuert, wie oft die *Regex* angewendet wird.
+ *limit > 0: Die Länge des resultierenden Arrays wird den Grenzwert nicht überschreiten, und der letzte Eintrag des resultierenden Arrays enthält alle Eingaben, die über die letzte übereinstimmende Regex hinausgehen.*
+ limit <= 0: *Regex* wird so oft wie möglich angewendet, und das resultierende Array kann eine beliebige Größe haben.
## Rückgabetyp
Die SPLIT-Funktion gibt ein ARRAY zurück.
Falls`limit > 0`: Die Länge des resultierenden Arrays wird den Grenzwert nicht überschreiten, und der letzte Eintrag des resultierenden Arrays enthält alle Eingaben, die über den letzten übereinstimmenden regulären Ausdruck hinausgehen.
Wenn`limit <= 0`: Regex wird so oft wie möglich angewendet, und das resultierende Array kann eine beliebige Größe haben.
## Beispiel
In diesem Beispiel teilt die SPLIT-Funktion die Eingabezeichenfolge `'oneAtwoBthreeC'` überall dort auf, wo sie auf die Zeichen `'A'``'B'`, oder trifft `'C'` (wie im Muster für reguläre Ausdrücke angegeben). `'[ABC]'` Die resultierende Ausgabe ist ein Array aus vier Elementen:`"one"`, `"two"``"three"`, und einer leeren Zeichenfolge`""`.
```
SELECT split('oneAtwoBthreeC', '[ABC]');
["one","two","three",""]
```
# Die Funktion SPLIT\$1PART
Teilt eine Zeichenfolge am angegebenen Trennzeichen und gibt den Teil an der angegebenen Position zurück.
## Syntax
```
SPLIT_PART(string, delimiter, position)
```
## Argumente
*string*
Eine Zeichenfolgenspalte, ein Ausdruck oder ein Zeichenfolgenliteral, die/der/das geteilt werden soll. Die Zeichenfolge kann CHAR oder VARCHAR sein.
*delimiter*
Die Trennzeichen-Zeichenfolge, die Abschnitte des Eingabe-*string* angibt.
Wenn *delimiter* ein Literal ist, schließen Sie es in einfache Anführungszeichen ein.
*position*
Position des *string*-Abschnitts, der zurückgegeben werden soll (gezählt ab 1). Es muss sich um eine Ganzzahl größer als 0 handeln. Wenn *position* größer als die Anzahl der Zeichenfolgenabschnitte ist, gibt SPLIT\$1PART eine leere Zeichenfolge zurück. Wenn *delimiter* nicht in *string* gefunden wird, enthält der zurückgegebene Wert den Inhalt des angegebenen Teils. Dabei kann es sich um die gesamte *Zeichenfolge* oder einen leeren Wert handeln.
## Rückgabetyp
Eine CHAR- oder VARCHAR-Zeichenfolge, identisch mit dem Parameter *string*.
## Beispiele
Im folgenden Beispiel wird ein Zeichenfolgenliteral mithilfe des Trennzeichens `$` in Teile aufgeteilt und der zweite Teil zurückgegeben.
```
select split_part('abc$def$ghi','$',2)
split_part
----------
def
```
Im folgenden Beispiel wird ein Zeichenfolgenliteral mithilfe des Trennzeichens `$` in Teile aufgeteilt. Es wird eine leere Zeichenfolge zurückgegeben, da der Teil `4` nicht gefunden wurde.
```
select split_part('abc$def$ghi','$',4)
split_part
----------
```
Im folgenden Beispiel wird ein Zeichenfolgenliteral mithilfe des Trennzeichens `#` in Teile aufgeteilt. Da das Trennzeichen nicht gefunden wurde, wird die gesamte Zeichenfolge zurückgegeben, wobei es sich um den ersten Teil handelt.
```
select split_part('abc$def$ghi','#',1)
split_part
------------
abc$def$ghi
```
Im folgenden Beispiel wird das Zeitstempelfeld LISTTIME in die Komponenten Jahr, Monat und Datum aufgeteilt.
```
select listtime, split_part(listtime,'-',1) as year,
split_part(listtime,'-',2) as month,
split_part(split_part(listtime,'-',3),' ',1) as day
from listing limit 5;
listtime | year | month | day
---------------------+------+-------+------
2008-03-05 12:25:29 | 2008 | 03 | 05
2008-09-09 08:03:36 | 2008 | 09 | 09
2008-09-26 05:43:12 | 2008 | 09 | 26
2008-10-04 02:00:30 | 2008 | 10 | 04
2008-01-06 08:33:11 | 2008 | 01 | 06
```
Im folgenden Beispiel wird das Zeitstempelfeld LISTTIME ausgewählt und am Zeichen `'-'` getrennt, um den Monat zu erhalten (den zweiten Teil der Zeichenfolge LISTTIME). Anschließend wird die Zahl der Einträge für jeden Monat gezählt:
```
select split_part(listtime,'-',2) as month, count(*)
from listing
group by split_part(listtime,'-',2)
order by 1, 2;
month | count
-------+-------
01 | 18543
02 | 16620
03 | 17594
04 | 16822
05 | 17618
06 | 17158
07 | 17626
08 | 17881
09 | 17378
10 | 17756
11 | 12912
12 | 4589
```
# Die Funktion SUBSTRING
Gibt die Teilmenge einer Zeichenfolge basierend auf der angegebenen Startposition zurück.
Wenn es sich bei der Eingabe um eine Zeichenfolge handelt, basieren die Startposition und die Anzahl der extrahierten Zeichen auf Zeichen, nicht auf Bytes. Daher werden Zeichen mit mehreren Bytes als einzelne Zeichen gezählt. Wenn es sich bei der Eingabe um einen binären Ausdruck handelt, basieren die Startposition und die extrahierte Teilzeichenfolge auf Bytes. Sie können keine negative Länge angeben. Sie können jedoch eine negative Startposition angeben.
## Syntax
```
SUBSTRING(charactestring FROM start_position [ FOR numbecharacters ] )
```
```
SUBSTRING(charactestring, start_position, numbecharacters )
```
```
SUBSTRING(binary_expression, start_byte, numbebytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## Argumente
*Zeichenkette*
Die Zeichenfolge, die durchsucht werden soll. Datentypen, die keine Zeichen sind, werden als Zeichenfolge behandelt.
*start\$1position*
Die Position innerhalb der Zeichenfolge, an der die Extrahierung gestartet werden soll, beginnend mit 1. Die *start\$1position* basiert auf der Anzahl der Zeichen, nicht der Bytes. Daher werden Zeichen mit mehreren Bytes als einzelne Zeichen gezählt. Diese Zahl kann negativ sein.
*Zahl der Zeichen*
Die Anzahl der Zeichen, die extrahiert werden soll (die Länge der Unterzeichenfolge). Die *Zahl der Zeichen* basiert auf der Anzahl der Zeichen, nicht auf der Anzahl der Byte, sodass Multibyte-Zeichen als Einzelzeichen gezählt werden. Diese Zahl darf nicht negativ sein.
*start\$1byte*
Die Position innerhalb des Binärausdrucks, an der die Extrahierung gestartet werden soll, beginnend mit 1. Diese Zahl kann negativ sein.
*Anzahl Byte*
Die Anzahl der Bytes, die extrahiert werden sollen, also die Länge der Unterzeichenfolge. Diese Zahl darf nicht negativ sein.
## Rückgabetyp
VARCHAR
## Nutzungshinweise für Zeichenfolgen
Im folgenden Beispiel wird eine Zeichenfolge mit vier Zeichen zurückgegeben, beginnend mit dem sechsten Zeichen.
```
select substring('caterpillar',6,4);
substring
-----------
pill
(1 row)
```
*Wenn *start\$1position* \$1 *numbecharacters* die Länge der Zeichenfolge überschreitet, gibt SUBSTRING eine *Teilzeichenfolge* zurück, die von der Startposition bis zum Ende der Zeichenfolge beginnt.* Zum Beispiel:
```
select substring('caterpillar',6,8);
substring
-----------
pillar
(1 row)
```
Wenn `start_position` negativ oder 0 ist, gibt die Funktion SUBSTRING eine Unterzeichenfolge ab dem ersten Zeichen der Zeichenfolge mit der Länge `start_position` \$1 `numbecharacters` -1 zurück. Beispiel:
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
Wenn `start_position` \$1 `numbecharacters` -1 gleich oder kleiner als null ist, gibt SUBSTRING eine leere Zeichenfolge zurück. Beispiel:
```
select substring('caterpillar',-5,4);
substring
-----------
(1 row)
```
## Beispiele
Im folgenden Beispiel wird der Monat aus der Zeichenfolge LISTTIME in der Tabelle LISTING zurückgegeben:
```
select listid, listtime,
substring(listtime, 6, 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
Im folgenden Beispiel wird das Gleiche wie oben gezeigt, jedoch mit der Option FROM...FOR:
```
select listid, listtime,
substring(listtime from 6 for 2) as month
from listing
order by 1, 2, 3
limit 10;
listid | listtime | month
--------+---------------------+-------
1 | 2008-01-24 06:43:29 | 01
2 | 2008-03-05 12:25:29 | 03
3 | 2008-11-01 07:35:33 | 11
4 | 2008-05-24 01:18:37 | 05
5 | 2008-05-17 02:29:11 | 05
6 | 2008-08-15 02:08:13 | 08
7 | 2008-11-15 09:38:15 | 11
8 | 2008-11-09 05:07:30 | 11
9 | 2008-09-09 08:03:36 | 09
10 | 2008-06-17 09:44:54 | 06
(10 rows)
```
Sie können SUBSTRING nicht verwenden, um das Präfix einer Zeichenfolge, die möglicherweise Multibyte-Zeichen enthält, auf vorhersehbare Weise zu extrahieren, da Sie die Länge einer Multibyte-Zeichenfolge anhand der Anzahl der Bytes und nicht anhand der Anzahl der Zeichen angeben müssen. Um das Anfangssegment einer Zeichenfolge auf der Basis der Länge in Bytes zu extrahieren, können Sie die Zeichenfolge in (*byte\$1length*) umwandeln, um die Zeichenfolge abzuschneiden, wobei *byte\$1length* die erforderliche Länge ist. Im folgenden Beispiel werden die ersten 5 Bytes aus der Zeichenfolge extrahiert `'Fourscore and seven'`.
```
select cast('Fourscore and seven' as varchar(5));
varchar
-------
Fours
```
Das folgende Beispiel gibt den Vornamen `Ana` zurück, der nach dem letzten Leerzeichen in der Eingabezeichenfolge `Silva, Ana` erscheint.
```
select reverse(substring(reverse('Silva, Ana'), 1, position(' ' IN reverse('Silva, Ana'))))
reverse
-----------
Ana
```
# Die Funktion TRANSLATE
Ersetzt für einen bestimmten Ausdruck alle Vorkommen von angegebenen Zeichen durch angegebene Ersatzzeichen. Vorhandene Zeichen werden aufgrund Ihrer Positionen in den Argumenten *characters\$1to\$1replace* und *characters\$1to\$1substitute* zu Ersatzzeichen zugeordnet. Wenn im Argument *characters\$1to\$1replace* mehr Zeichen als im Argument *characters\$1to\$1substitute* angegeben sind, werden die zusätzlichen Zeichen aus dem Argument *characters\$1to\$1replace* im Rückgabewert ausgelassen.
TRANSLATE ist [Die Funktion REPLACE](REPLACE.md) und [Die Funktion REGEXP\$1REPLACE](REGEXP_REPLACE.md) ähnlich. Während REPLACE jedoch eine ganze Zeichenfolge durch eine andere Zeichenfolge ersetzt und REGEXP\$1REPLACE eine Zeichenfolge nach einem regulären Ausdrucksmuster durchsucht, führt TRANSLATE mehrere Einzelzeichenersetzungen aus.
Wenn ein Argument null ist, ist der Rückgabewert NULL.
## Syntax
```
TRANSLATE ( expression, characters_to_replace, characters_to_substitute )
```
## Argumente
*expression*
Der Ausdruck, der übersetzt werden soll.
*characters\$1to\$1replace*
Eine Zeichenfolge, die die Zeichen enthält, die ersetzt werden sollen.
*characters\$1to\$1substitute*
Eine Zeichenfolge, die die Zeichen enthält, die ersetzt werden sollen.
## Rückgabetyp
VARCHAR
## Beispiele
Im folgenden Beispiel werden mehrere Zeichen in einer Zeichenfolge ersetzt:
```
select translate('mint tea', 'inea', 'osin');
translate
-----------
most tin
```
Im folgenden Beispiel wird für alle Werte in einer Spalte das Zeichen @ durch einen Punkt ersetzt:
```
select email, translate(email, '@', '.') as obfuscated_email
from users limit 10;
email obfuscated_email
-------------------------------------------------------------------------------------------
Etiam.laoreet.libero@sodalesMaurisblandit.edu Etiam.laoreet.libero.sodalesMaurisblandit.edu
amet.faucibus.ut@condimentumegetvolutpat.ca amet.faucibus.ut.condimentumegetvolutpat.ca
turpis@accumsanlaoreet.org turpis.accumsanlaoreet.org
ullamcorper.nisl@Cras.edu ullamcorper.nisl.Cras.edu
arcu.Curabitur@senectusetnetus.com arcu.Curabitur.senectusetnetus.com
ac@velit.ca ac.velit.ca
Aliquam.vulputate.ullamcorper@amalesuada.org Aliquam.vulputate.ullamcorper.amalesuada.org
vel.est@velitegestas.edu vel.est.velitegestas.edu
dolor.nonummy@ipsumdolorsit.ca dolor.nonummy.ipsumdolorsit.ca
et@Nunclaoreet.ca et.Nunclaoreet.ca
```
Im folgenden Beispiel werden für alle Werte in einer Spalte Leerzeichen durch Unterstriche ersetzt und Punkte entfernt:
```
select city, translate(city, ' .', '_') from users
where city like 'Sain%' or city like 'St%'
group by city
order by city;
city translate
--------------+------------------
Saint Albans Saint_Albans
Saint Cloud Saint_Cloud
Saint Joseph Saint_Joseph
Saint Louis Saint_Louis
Saint Paul Saint_Paul
St. George St_George
St. Marys St_Marys
St. Petersburg St_Petersburg
Stafford Stafford
Stamford Stamford
Stanton Stanton
Starkville Starkville
Statesboro Statesboro
Staunton Staunton
Steubenville Steubenville
Stevens Point Stevens_Point
Stillwater Stillwater
Stockton Stockton
Sturgis Sturgis
```
# Die Funktion TRIM
Kürzt eine Zeichenfolge durch Entfernen von Leerzeichen am Anfang und am Ende oder durch Entfernen von Zeichen am Anfang und am Ende, die mit einer optionalen angegebenen Zeichenfolge übereinstimmen.
## Syntax
```
TRIM( [ BOTH ] [ trim_chars FROM ] string
```
## Argumente
*trim\$1chars*
(Optional) Die Zeichen, die aus der Zeichenfolge gekürzt werden sollen. Wenn dieser Parameter ausgelassen wird, werden Leerzeichen ausgeschnitten.
*string*
Die Zeichenfolge, die gekürzt werden soll.
## Rückgabetyp
Die TRIM-Funktion gibt eine VARCHAR- oder eine CHAR\$1Zeichenfolge zurück. Wenn Sie die TRIM-Funktion mit einem SQL-Befehl verwenden, werden die Ergebnisse implizit in VARCHAR konvertiert. AWS Clean Rooms Wenn Sie die TRIM-Funktion in der SELECT-Liste für eine SQL-Funktion verwenden, werden die Ergebnisse AWS Clean Rooms nicht implizit konvertiert, und Sie müssen möglicherweise eine explizite Konvertierung durchführen, um zu vermeiden, dass ein Datentypkonflikt auftritt. Informationen zu expliziten Konvertierungen finden Sie in der [CAST-Funktion](CAST_function.md) Funktion.
## Beispiel
Im folgenden Beispiel werden Leerzeichen am Anfang und am Ende aus der Zeichenfolge entfernt `' abc '`:
```
select ' abc ' as untrim, trim(' abc ') as trim;
untrim | trim
----------+------
abc | abc
```
Im folgenden Beispiel werden die doppelten Anführungszeichen entfernt, die die Zeichenfolge umgeben `"dog"`:
```
select trim('"' FROM '"dog"');
btrim
-------
dog
```
TRIM entfernt alle Zeichen in *trim\$1chars*, wenn sie sich am Anfang von *string* befinden. Im folgenden Beispiel werden die Zeichen „C“, „D“ und „G“gekürzt, wenn sie sich am Anfang von VENUENAME befinden. Dabei handelt es sich um eine VARCHAR-Spalte.
```
select venueid, venuename, trim(venuename, 'CDG')
from venue
where venuename like '%Park'
order by 2
limit 7;
venueid | venuename | btrim
--------+----------------------------+--------------------------
121 | ATT Park | ATT Park
109 | Citizens Bank Park | itizens Bank Park
102 | Comerica Park | omerica Park
9 | Dick's Sporting Goods Park | ick's Sporting Goods Park
97 | Fenway Park | Fenway Park
112 | Great American Ball Park | reat American Ball Park
114 | Miller Park | Miller Park
```
# Die Funktion UPPER
Konvertiert eine Zeichenfolge in Großbuchstaben. UPPER unterstützt UTF-8-Multibyte-Zeichen bis zu einer maximalen Länge von vier Bytes pro Zeichen.
## Syntax
```
UPPER(string)
```
## Argumente
*string*
Der Eingabeparameter ist eine VARCHAR-Zeichenfolge (oder ein anderer Datentyp wie CHAR, der implizit in VARCHAR konvertiert werden kann).
## Rückgabetyp
Die UPPER-Funktion gibt eine Zeichenfolge zurück, die den gleichen Datentyp wie die Eingabezeichenfolge hat.
## Beispiele
Im folgenden Beispiel wird das Feld CATNAME in Großbuchstaben konvertiert:
```
select catname, upper(catname) from category order by 1,2;
catname | upper
----------+-----------
Classical | CLASSICAL
Jazz | JAZZ
MLB | MLB
MLS | MLS
Musicals | MUSICALS
NBA | NBA
NFL | NFL
NHL | NHL
Opera | OPERA
Plays | PLAYS
Pop | POP
(11 rows)
```
# UUID-Funktion
Die UUID-Funktion generiert einen Universally Unique Identifier (UUID).
UUIDs sind global eindeutige Identifikatoren, die üblicherweise verwendet werden, um eindeutige Identifikatoren für verschiedene Zwecke bereitzustellen, z. B.:
+ Identifizieren von Datenbankeinträgen oder anderen Dateneinheiten.
+ Generierung eindeutiger Namen oder Schlüssel für Dateien, Verzeichnisse oder andere Ressourcen.
+ Verfolgen und Korrelieren von Daten in verteilten Systemen.
+ Bereitstellung eindeutiger Kennungen für Netzwerkpakete, Softwarekomponenten oder andere digitale Ressourcen.
Die UUID-Funktion generiert einen UUID-Wert, der mit sehr hoher Wahrscheinlichkeit einzigartig ist, selbst in verteilten Systemen und über lange Zeiträume. UUIDs werden in der Regel anhand einer Kombination aus dem aktuellen Zeitstempel, der Netzwerkadresse des Computers und anderen zufälligen oder pseudozufälligen Daten generiert, wodurch sichergestellt wird, dass es sehr unwahrscheinlich ist, dass jede generierte UUID mit einer anderen UUID in Konflikt gerät.
Im Kontext einer SQL-Abfrage kann die UUID-Funktion verwendet werden, um eindeutige Bezeichner für neue Datensätze zu generieren, die in eine Datenbank eingefügt werden, oder um eindeutige Schlüssel für die Datenpartitionierung, Indizierung oder andere Zwecke bereitzustellen, bei denen ein eindeutiger Bezeichner erforderlich ist.
**Anmerkung**
Die UUID-Funktion ist nicht deterministisch.
## Syntax
```
uuid()
```
## Argumente
Die UUID-Funktion benötigt kein Argument.
## Rückgabetyp
UUID gibt eine UUID-Zeichenfolge (Universally Unique Identifier) zurück. Der Wert wird als kanonische UUID-Zeichenfolge mit 36 Zeichen zurückgegeben.
## Beispiel
Im folgenden Beispiel wird ein Universally Unique Identifier (UUID) generiert. Die Ausgabe ist eine 36-stellige Zeichenfolge, die einen Universally Unique Identifier darstellt.
```
SELECT uuid();
46707d92-02f4-4817-8116-a4c3b23e6266
```