Amazon Redshift unterstützt UDFs ab Patch 198 nicht mehr die Erstellung von neuem Python. Das bestehende Python UDFs wird bis zum 30. Juni 2026 weiterhin funktionieren. Weitere Informationen finden Sie im [Blog-Posting](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
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
**Topics**
+ [Der Operator \$1\$1 (Verkettung)](r_concat_op.md)
+ [Funktion ASCII](r_ASCII.md)
+ [Die Funktion BPCHARCMP](r_BPCHARCMP.md)
+ [Die Funktion BTRIM](r_BTRIM.md)
+ [Die Funktion BTTEXT\$1PATTERN\$1CMP](r_BTTEXT_PATTERN_CMP.md)
+ [Die Funktion CHAR\$1LENGTH](r_CHAR_LENGTH.md)
+ [Die Funktion CHARACTER\$1LENGTH](r_CHARACTER_LENGTH.md)
+ [Funktion CHARINDEX](r_CHARINDEX.md)
+ [Die Funktion CHR](r_CHR.md)
+ [Funktion COLLATE](r_COLLATE.md)
+ [Funktion CONCAT](r_CONCAT.md)
+ [CRC32 Funktion](crc32-function.md)
+ [Funktion DIFFERENCE](DIFFERENCE.md)
+ [Die Funktion INITCAP](r_INITCAP.md)
+ [Die Funktionen LEFT und RIGHT](r_LEFT.md)
+ [Die Funktion LEN](r_LEN.md)
+ [Die Funktion LENGTH](r_LENGTH.md)
+ [Die Funktion LOWER](r_LOWER.md)
+ [Die Funktionen LPAD und RPAD](r_LPAD.md)
+ [Die Funktion LTRIM](r_LTRIM.md)
+ [Funktion OCTENDEX](OCTETINDEX.md)
+ [Die OCTET\$1LENGTH-Funktion](r_OCTET_LENGTH.md)
+ [Die Funktion POSITION](r_POSITION.md)
+ [Die Funktion QUOTE\$1IDENT](r_QUOTE_IDENT.md)
+ [Die Funktion QUOTE\$1LITERAL](r_QUOTE_LITERAL.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](r_REPEAT.md)
+ [Die Funktion REPLACE](r_REPLACE.md)
+ [Die Funktion REPLICATE](r_REPLICATE.md)
+ [Die Funktion REVERSE](r_REVERSE.md)
+ [Die Funktion RTRIM](r_RTRIM.md)
+ [Funktion SOUNDEX](SOUNDEX.md)
+ [Die Funktion SPLIT\$1PART](SPLIT_PART.md)
+ [Die Funktion STRPOS](r_STRPOS.md)
+ [Die Funktion STRTOL](r_STRTOL.md)
+ [Die Funktion SUBSTRING](r_SUBSTRING.md)
+ [Die Funktion TEXTLEN](r_TEXTLEN.md)
+ [Die Funktion TRANSLATE](r_TRANSLATE.md)
+ [Die Funktion TRIM](r_TRIM.md)
+ [Die Funktion UPPER](r_UPPER.md)
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.
**Veraltete Funktionen, die ausschließlich für Führungsknoten gelten**
Die folgenden Zeichenfolgefunktionen sind veraltet, da sie nur auf dem Führungsknoten ausgeführt werden. Weitere Informationen finden Sie unter [Exklusive Führungsknotenfunktionen](c_SQL_functions_leader_node_only.md)
+ GET\$1BYTE
+ SET\$1BIT
+ SET\$1BYTE
+ TO\$1ASCII
# Der Operator \$1\$1 (Verkettung)
Verkettet zwei Ausdrücke auf beiden Seiten des Symbols `||` und gibt den verketteten Ausdruck zurück.
Ähnlich [Funktion CONCAT](r_CONCAT.md).
**Anmerkung**
Wenn ein oder beide Ausdrücke null sind, ist das Ergebnis der Verkettung `NULL`.
## Syntax
```
expression1 || expression2
```
## Argumente
*expression1*
Eine `CHAR`-Zeichenfolge, eine `VARCHAR`-Zeichenfolge, ein binärer Ausdruck oder ein Ausdruck, der zu einem dieser Typen ausgewertet wird.
*expression2*
Eine `CHAR`-Zeichenfolge, eine `VARCHAR`-Zeichenfolge, ein binärer Ausdruck oder ein Ausdruck, der zu einem dieser Typen ausgewertet wird.
## Rückgabetyp
Der Rückgabetyp der Zeichenfolge ist derselbe Typ wie die Eingabeargumente. Beim Verketten von zwei Zeichenfolgen vom Typ `VARCHAR` wird eine Zeichenfolge vom Typ `VARCHAR` zurückgegeben.
## Beispiele
In den folgenden Beispielen werden die Tabellen USERS und VENUE aus der TICKIT-Beispieldatenbank verwendet. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um die Felder FIRSTNAME und LASTNAME aus der Tabelle USERS in der Beispieldatenbank zu verketten.
```
SELECT (firstname || ' ' || lastname) as fullname
FROM users
ORDER BY 1
LIMIT 10;
+-----------------+
| fullname |
+-----------------+
| Aaron Banks |
| Aaron Booth |
| Aaron Browning |
| Aaron Burnett |
| Aaron Casey |
| Aaron Cash |
| Aaron Castro |
| Aaron Dickerson |
| Aaron Dixon |
| Aaron Dotson |
+-----------------+
```
Um Spalten zu verketten, die möglicherweise Null-Werte enthalten, verwenden Sie den Ausdruck [NVL- und COALESCE-Funktionen](r_NVL_function.md). Im folgenden Beispiel wird NVL verwendet, um `0` zurückzugeben, wenn `NULL` gefunden wird.
```
SELECT (venuename || ' seats ' || NVL(venueseats, 0)) as seating
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 |
+-------------------------------------+
```
# Funktion ASCII
Die ASCII-Funktion gibt den ASCII-Code oder den Unicode-Codepunkt des ersten Zeichens in der von Ihnen angegebenen Zeichenfolge zurück. Wenn die Zeichenfolge leer ist, gibt die Funktion `0` zurück. Wenn die Zeichenfolge null ist, wird `NULL` zurückgegeben.
## Syntax
```
ASCII('string')
```
## Argument
*string*
Eine `CHAR`- oder `VARCHAR`-Zeichenfolge.
## Rückgabetyp
INTEGER
## Beispiele
Verwenden Sie das folgende Beispiel, um `NULL` zurückzugeben. Die NULLIF-Funktion gibt `NULL` zurück, wenn die beiden Argumente identisch sind. Daher lautet das Eingabeargument für die ASCII-Funktion `NULL`. Weitere Informationen finden Sie unter [NULLIF-Funktion](r_NULLIF_function.md).
```
SELECT ASCII(NULLIF('',''));
+-------+
| ascii |
+-------+
| NULL |
+-------+
```
Verwenden Sie das folgende Beispiel, um den ASCII-Code von 0 zurückzugeben.
```
SELECT ASCII('');
+-------+
| ascii |
+-------+
| 0 |
+-------+
```
Verwenden Sie das folgende Beispiel, um den ASCII-Code 97 für den ersten Buchstaben des Wortes amazon zurückzugeben.
```
SELECT ASCII('amazon');
+-------+
| ascii |
+-------+
| 97 |
+-------+
```
Verwenden Sie das folgende Beispiel, um den ASCII-Code 65 für den ersten Buchstaben des Wortes Amazon zurückzugeben.
```
SELECT ASCII('Amazon');
+-------+
| ascii |
+-------+
| 65 |
+-------+
```
# Die Funktion BPCHARCMP
Vergleicht den Wert zweier Zeichenfolgen und gibt eine Ganzzahl aus. Wenn die Zeichenfolgen identisch sind, gibt die Funktion `0` zurück. Ist die erste Zeichenfolge alphabetisch größer, gibt die Funktion `1` zurück. Ist die zweite Zeichenfolge größer, gibt die Funktion `-1` zurück.
Im Fall von Multibyte-Zeichen basiert der Vergleich auf der Byte-Kodierung.
Synonym von [Die Funktion BTTEXT\$1PATTERN\$1CMP](r_BTTEXT_PATTERN_CMP.md).
## Syntax
```
BPCHARCMP(string1, string2)
```
## Argumente
*string1*
Eine `CHAR`- oder `VARCHAR`-Zeichenfolge.
*string2*
Eine `CHAR`- oder `VARCHAR`-Zeichenfolge.
## Rückgabetyp
INTEGER
## Beispiele
In den folgenden Beispielen wird die Tabelle USERS aus der TICKIT-Beispieldatenbank verwendet. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um für die ersten zehn Einträge in der USERS-Tabelle zu bestimmen, ob der Vorname eines Benutzers alphabetisch größer als der Nachname des Benutzers ist. Für Einträge, bei denen die Zeichenfolge für FIRSTNAME alphabetisch nach der Zeichenfolge für LASTNAME steht, gibt die Funktion `1` zurück. Wenn LASTNAME alphabetisch nach FIRSTNAME steht, gibt die Funktion `-1` zurück.
```
SELECT userid, firstname, lastname, BPCHARCMP(firstname, lastname)
FROM users
ORDER BY 1, 2, 3, 4
LIMIT 10;
+--------+-----------+-----------+-----------+
| userid | firstname | lastname | bpcharcmp |
+--------+-----------+-----------+-----------+
| 1 | Rafael | Taylor | -1 |
| 2 | Vladimir | Humphrey | 1 |
| 3 | Lars | Ratliff | -1 |
| 4 | Barry | Roy | -1 |
| 5 | Reagan | Hodge | 1 |
| 6 | Victor | Hernandez | 1 |
| 7 | Tamekah | Juarez | 1 |
| 8 | Colton | Roy | -1 |
| 9 | Mufutau | Watkins | -1 |
| 10 | Naida | Calderon | 1 |
+--------+-----------+-----------+-----------+
```
Verwenden Sie das folgende Beispiel, um alle Einträge der Tabelle USERS zurückzugeben, für welche die Funktion `0` zurückgibt. Die Funktion gibt `0` zurück, wenn FIRSTNAME mit LASTNAME identisch ist.
```
SELECT userid, firstname, lastname,
BPCHARCMP(firstname, lastname)
FROM users
WHERE BPCHARCMP(firstname, lastname)=0
ORDER BY 1, 2, 3, 4;
+--------+-----------+----------+-----------+
| userid | firstname | lastname | bpcharcmp |
+--------+-----------+----------+-----------+
| 62 | Chase | Chase | 0 |
| 4008 | Whitney | Whitney | 0 |
| 12516 | Graham | Graham | 0 |
| 13570 | Harper | Harper | 0 |
| 16712 | Cooper | Cooper | 0 |
| 18359 | Chase | Chase | 0 |
| 27530 | Bradley | Bradley | 0 |
| 31204 | Harding | Harding | 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
```
# Die Funktion BTTEXT\$1PATTERN\$1CMP
Synonym mit der Funktion BPCHARCMP.
Details dazu finden Sie unter [Die Funktion BPCHARCMP](r_BPCHARCMP.md).
# Die Funktion CHAR\$1LENGTH
Synonym mit der Funktion LEN.
Siehe [Die Funktion LEN](r_LEN.md).
# Die Funktion CHARACTER\$1LENGTH
Synonym mit der Funktion LEN.
Siehe [Die Funktion LEN](r_LEN.md).
# Funktion CHARINDEX
Gibt den Ort der angegebenen Unterzeichenfolge innerhalb einer Zeichenfolge zurück.
Ähnliche Funktionen finden Sie unter [Die Funktion POSITION](r_POSITION.md) und [Die Funktion STRPOS](r_STRPOS.md).
## Syntax
```
CHARINDEX( substring, string )
```
## Argumente
*substring*
Die Unterzeichenfolge, die innerhalb der *Zeichenfolge* gesucht werden soll.
*string*
Die Zeichenfolge oder Spalte, die durchsucht werden soll.
## Rückgabetyp
INTEGER
Die CHARINDEX-Funktion gibt eine `INTEGER` zurück, die der Position der Teilzeichenfolge 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. CHARINDEX gibt `0` zurück, wenn die Teilzeichenfolge nicht innerhalb der Zeichenfolge gefunden wird.
## Beispiele
Verwenden Sie das folgende Beispiel, um die Position der Zeichenfolge `fish` innerhalb des Worts `dog` zu zeigen.
```
SELECT CHARINDEX('fish', 'dog');
+-----------+
| charindex |
+-----------+
| 0 |
+-----------+
```
Verwenden Sie das folgende Beispiel, um die Position der Zeichenfolge `fish` innerhalb des Worts `dogfish` zu zeigen.
```
SELECT CHARINDEX('fish', 'dogfish');
+-----------+
| charindex |
+-----------+
| 4 |
+-----------+
```
Im folgenden Beispiel wird die Tabelle SALES aus der TICKIT-Beispieldatenbank verwendet. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um die Zahl der bestimmten Verkaufstransaktionen mit einer Kommission von mehr als 999,00 aus der Tabelle SALES zurückzugeben. Dieser Befehl zählt Provisionen über 999,00, indem geprüft wird, ob die Dezimalzahl mehr als 4 Stellen vom Anfang des Provisionswerts entfernt ist.
```
SELECT DISTINCT CHARINDEX('.', commission), COUNT (CHARINDEX('.', commission))
FROM sales
WHERE CHARINDEX('.', commission) > 4
GROUP BY CHARINDEX('.', commission)
ORDER BY 1,2;
+-----------+-------+
| charindex | count |
+-----------+-------+
| 5 | 629 |
+-----------+-------+
```
# Die Funktion CHR
Die CHR-Funktion gibt das Zeichen zurück, das mit dem ASCII-Codepunktzeichenwert übereinstimmt, der durch den Eingabeparameter angegeben wird.
## Syntax
```
CHR(number)
```
## Argument
*number (Zahl*
Der Eingabeparameter ist eine `INTEGER`, die einen ASCII-Codepunktwert darstellt.
## Rückgabetyp
CHAR
Die CHR-Funktion gibt eine `CHAR`-Zeichenfolge zurück, wenn ein ASCII-Zeichen mit dem Eingabewert übereinstimmt. Wenn es für die Eingabezahl keine ASCII-Übereinstimmung gibt, gibt die Funktion `NULL` zurück.
## Beispiele
Verwenden Sie das folgende Beispiel, um das Zeichen zurückzugeben, das dem ASCII-Codepunkt 0 entspricht. Beachten Sie, dass die CHR-Funktion `NULL` für die Eingabe `0` zurückgibt.
```
SELECT CHR(0);
+-----+
| chr |
+-----+
| |
+-----+
```
Verwenden Sie das folgende Beispiel, um das Zeichen zurückzugeben, das dem ASCII-Codepunkt 65 entspricht.
```
SELECT CHR(65);
+-----+
| chr |
+-----+
| A |
+-----+
```
Verwenden Sie das folgende Beispiel, um Ereignisnamen zurückzugeben, die mit einem großen A beginnen (ASCII-Codepunkt 65). Verwenden Sie das folgende Beispiel, um die Tabelle EVENT aus der TICKIT-Beispieldatenbank zu verwenden. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
```
SELECT DISTINCT eventname FROM event
WHERE SUBSTRING(eventname, 1, 1)=CHR(65) LIMIT 5;
+-----------------------+
| eventname |
+-----------------------+
| A Catered Affair |
| As You Like It |
| A Man For All Seasons |
| Alan Jackson |
| Armando Manzanero |
+-----------------------+
```
# Funktion COLLATE
Die Funktion COLLATE überschreibt die Sortierung einer Zeichenfolgenspalte oder eines Ausdrucks.
Weitere Informationen zur Erstellung von Tabellen mit der Datenbanksortierung finden Sie unter [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Weitere Informationen zur Erstellung von Datenbanken mit der Datenbanksortierung finden Sie unter [CREATE DATABASE](r_CREATE_DATABASE.md).
## Syntax
```
COLLATE( string, 'case_sensitive' | 'cs' | 'case_insensitive' | 'ci');
```
## Argumente
*string*
Eine Zeichenfolgenspalte oder ein Ausdruck, die/den Sie überschreiben möchten.
*'case\$1sensitive'* \$1 *'cs'* \$1 *'case\$1insensitive'* \$1 *'ci'*
Die Zeichenfolgenkonstante eines Sortierungsnamens. Amazon Redshift unterstützt nur die folgenden Werte für diesen Parameter:
+ *case\$1sensitive*
+ *cs*
+ *case\$1insensitive*
+ *Ci*
*case\$1sensitive* und *cs* sind austauschbar und liefern dieselben Ergebnisse. Ebenso sind *case\$1insensitive* und *ci* austauschbar und führen zu denselben Ergebnissen.
## Rückgabetyp
Die Funktion COLLATE gibt abhängig vom ersten Eingabeausdruckstyp `VARCHAR`, `CHAR` oder `SUPER` zurück. Diese Funktion ändert nur die Sortierung des ersten Eingabearguments, nicht jedoch seinen Ausgabewert.
## Beispiele
Verwenden Sie das folgende Beispiel, um Tabelle T zu erstellen und col1 in Tabelle T als `case_sensitive` zu definieren.
```
CREATE TABLE T ( col1 Varchar(20) COLLATE case_sensitive );
INSERT INTO T VALUES ('john'),('JOHN');
```
Wenn Sie die erste Abfrage ausführen, gibt Amazon Redshift nur `john` zurück. Nachdem COLLATE-Funktion auf col1 ausgeführt wurde, ändert sich die Sortierung zu `case_insensitive`. Die zweite Abfrage gibt `john` und `JOHN` zurück.
```
SELECT * FROM T WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
+------+
SELECT * FROM T WHERE COLLATE(col1, 'case_insensitive') = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
```
Verwenden Sie das folgende Beispiel, um Tabelle A zu erstellen und col1 in Tabelle A als `case_insensitive` zu definieren.
```
CREATE TABLE A ( col1 Varchar(20) COLLATE case_insensitive );
INSERT INTO A VALUES ('john'),('JOHN');
```
Wenn Sie die erste Abfrage ausführen, gibt Amazon Redshift `john` und `JOHN` zurück. Nachdem COLLATE-Funktion auf col1 ausgeführt wurde, ändert sich die Sortierung zu `case_sensitive`. Die zweite Abfrage gibt nur `john` zurück.
```
SELECT * FROM A WHERE col1 = 'john';
+------+
| col1 |
+------+
| john |
| JOHN |
+------+
SELECT * FROM A WHERE COLLATE(col1, 'case_sensitive') = 'john';
+------+
| col1 |
+------+
| john |
+------+
```
# 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.
## 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 es sich bei den Eingabeausdrücken um verschiedene Typen handelt, versucht Amazon Redshift implizit einen der beiden Ausdrücke umzuwandeln. Wenn Werte nicht umgewandelt werden können, wird ein Fehler zurückgegeben.
## Nutzungshinweise
+ Für die Funktion CONCAT und den Verkettungsoperator gilt, dass das Ergebnis der Verkettung null ist, wenn einer oder beide Ausdrücke null sind.
## 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';
?column?
-------------------
December 25, 2008
(1 row)
```
Im folgenden Beispiel wird eine verschachtelte CONCAT-Funktion innerhalb einer anderen CONCAT-Funktion benutzt, um drei Zeichenfolgen zu verketten:
```
SELECT CONCAT('Thursday, ', CONCAT('December 25, ', '2008'));
concat
-----------------------------
Thursday, December 25, 2008
(1 row)
```
Um Spalten zu verketten, die enthalten könnten, verwenden Sie die NULLs, die einen bestimmten Wert zurückgibt[NVL- und COALESCE-Funktionen](r_NVL_function.md), wenn sie auf NULL trifft. 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)
```
Im folgenden Beispiel werden zwei Binärausdrücke verkettet. Hierbei ist `abc` ein Binärwert (mit einer hexadezimalen Darstellung von `616263`) und `def` ein Binärwert (mit einer hexadezimalen Darstellung von `646566`). Das Ergebnis wird automatisch als hexadezimale Darstellung des Binärwerts angezeigt.
```
SELECT CONCAT('abc'::VARBYTE, 'def'::VARBYTE);
concat
-------------------
616263646566
```
# CRC32 Funktion
CRC32 ist eine Funktion, die zur Fehlererkennung verwendet wird. Die Funktion verwendet einen CRC32 Algorithmus, um Änderungen zwischen Quell- und Zieldaten zu erkennen. Die CRC32 Funktion konvertiert eine Zeichenfolge mit variabler Länge in eine Zeichenfolge mit 8 Zeichen, bei der es sich um eine Textdarstellung des Hexadezimalwerts einer 32-Bit-Binärsequenz handelt. Um Änderungen zwischen Quell- und Zieldaten zu erkennen, verwenden Sie die CRC32 Funktion für die Quelldaten und speichern Sie die Ausgabe. Verwenden Sie dann die CRC32 Funktion für die Zieldaten und vergleichen Sie diese Ausgabe mit der Ausgabe der Quelldaten. Die Ausgaben sind identisch, wenn die Daten nicht geändert wurden, und sie sind unterschiedlich, wenn die Daten geändert wurden.
## Syntax
```
CRC32(string)
```
## Argumente
*string*
Eine `CHAR`-Zeichenfolge, eine `VARCHAR`-Zeichenfolge oder ein Ausdruck, die bzw. der implizit als ein `CHAR`- oder `VARCHAR`-Typ ausgewertet wird.
## Rückgabetyp
Die CRC32 Funktion gibt eine 8-stellige Zeichenfolge zurück, die eine Textdarstellung des Hexadezimalwerts einer 32-Bit-Binärsequenz ist. Die Amazon Redshift CRC32 Redshift-Funktion basiert auf dem CRC-32C-Polynom.
## Beispiele
Um den 8-Bit-Wert für die Zeichenfolge `Amazon Redshift` anzuzeigen.
```
SELECT CRC32('Amazon Redshift');
+----------+
| crc32 |
+----------+
| f2726906 |
+----------+
```
# Funktion DIFFERENCE
Die Funktion DIFFERENCE vergleicht die amerikanischen Soundex-Codes zweier Zeichenfolgen. Die Funktion gibt `INTEGER` zurück, um die Anzahl der übereinstimmenden Zeichen zwischen den Soundex-Codes anzugeben.
Ein Soundex-Code ist eine Zeichenfolge, die vier Zeichen lang ist. Ein Soundex-Code stellt eher den Klang eines Wortes und weniger seine Schreibweise dar. Zum Beispiel haben `Smith` und `Smyth` den gleichen Soundex-Code.
## Syntax
```
DIFFERENCE(string1, string2)
```
## Argumente
*string1*
Eine `CHAR`-Zeichenfolge, eine `VARCHAR`-Zeichenfolge oder ein Ausdruck, die bzw. der implizit als ein `CHAR`- oder `VARCHAR`-Typ ausgewertet wird.
*string2*
Eine `CHAR`-Zeichenfolge, eine `VARCHAR`-Zeichenfolge oder ein Ausdruck, die bzw. der implizit als ein `CHAR`- oder `VARCHAR`-Typ ausgewertet wird.
## Rückgabetyp
INTEGER
Die Funktion DIFFERENCE gibt einen `INTEGER`-Wert von 0–4 zurück, der die Anzahl der übereinstimmenden Zeichen in den amerikanische Soundex-Codes der beiden Zeichenfolgen zählt. Ein Soundex-Code hat 4 Zeichen, daher gibt die DIFFERENCE-Funktion `4` zurück, wenn alle 4 Zeichen der Werte des amerikanischen Soundex-Codes der Zeichenfolgen identisch sind. DIFFERENCE gibt `0` zurück, wenn eine der beiden Zeichenfolgen leer ist. Die Funktion gibt `1` zurück, wenn keine Zeichenfolge gültige Zeichen enthält. Die Funktion DIFFERENCE konvertiert nur englische alphabetische ASCII-Zeichen in Klein- oder Großbuchstaben, einschließlich a–z und A–Z. DIFFERENCE ignoriert andere Zeichen.
## Beispiele
Verwenden Sie das folgende Beispiel, um die Soundex-Werte der Zeichenfolgen `%` und `@` zu vergleichen. Die Funktion gibt `1` zurück, da keine Zeichenfolge gültige Zeichen enthält.
```
SELECT DIFFERENCE('%', '@');
+------------+
| difference |
+------------+
| 1 |
+------------+
```
Verwenden Sie das folgende Beispiel, um die Soundex-Werte von `Amazon` und einer leeren Zeichenfolge zu vergleichen. Die Funktion gibt `0` zurück, da eine der beiden Zeichenfolgen leer ist.
```
SELECT DIFFERENCE('Amazon', '');
+------------+
| difference |
+------------+
| 0 |
+------------+
```
Verwenden Sie das folgende Beispiel, um die Soundex-Werte der Zeichenfolgen `Amazon` und `Ama` zu vergleichen. Die Funktion gibt `2` zurück, weil 2 Zeichen der Soundex-Werte der Zeichenfolgen identisch sind.
```
SELECT DIFFERENCE('Amazon', 'Ama');
+------------+
| difference |
+------------+
| 2 |
+------------+
```
Verwenden Sie das folgende Beispiel, um die Soundex-Werte der Zeichenfolgen `Amazon` und `+-*/%Amazon` zu vergleichen. Die Funktion gibt `4` zurück, weil 4 Zeichen der Soundex-Werte der Zeichenfolgen identisch sind. Beachten Sie, dass die Funktion die ungültigen Zeichen `+-*/%` in der zweiten Zeichenfolge ignoriert.
```
SELECT DIFFERENCE('Amazon', '+-*/%Amazon');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
Verwenden Sie das folgende Beispiel, um die Soundex-Werte der Zeichenfolgen `AC/DC` und `Ay See Dee See` zu vergleichen. Die Funktion gibt `4` zurück, weil 4 Zeichen der Soundex-Werte der Zeichenfolgen identisch sind.
```
SELECT DIFFERENCE('AC/DC', 'Ay See Dee See');
+------------+
| difference |
+------------+
| 4 |
+------------+
```
# Die Funktion INITCAP
Wandelt den ersten Buchstaben jedes Worts in einer angegebenen Zeichenfolge in einen Großbuchstaben um. INITCAP unterstützt UTF-8-Multibyte-Zeichen bis zu einer maximalen Länge von vier Bytes pro Zeichen.
## Syntax
```
INITCAP(string)
```
## Argument
*string*
Eine `CHAR`-Zeichenfolge, eine `VARCHAR`-Zeichenfolge oder ein Ausdruck, die bzw. der implizit als ein `CHAR`- oder `VARCHAR`-Typ ausgewertet wird.
## Rückgabetyp
VARCHAR
## Nutzungshinweise
Die INITCAP-Funktion wandelt den ersten Buchstaben jedes Worts in einer Zeichenfolge in einen Großbuchstaben um. Alle folgenden Buchstaben werden in Kleinbuchstaben umgewandelt (ober bleiben Kleinbuchstaben). Daher ist es wichtig, zu verstehen, welche Zeichen (außer Leerzeichen) als Worttrennzeichen fungieren. Ein *Worttrennzeichen* ist ein nicht alphanumerisches Zeichen, einschließlich Interpunktionszeichen, Symbolen und Steuerzeichen. Alle folgenden Zeichen sind Worttrennzeichen:
```
! " # $ % & ' ( ) * + , - . / : ; < = > ? @ [ \ ] ^ _ ` { | } ~
```
Tabulatorzeichen, Zeichen für neue Zeilen, Seitenvorschübe, Zeilenvorschübe und Zeilenumbrüche sind ebenfalls Worttrennzeichen.
## Beispiele
In den folgenden Beispielen werden Daten aus der Tabellen CATEGORY und USERS in der TICKIT-Beispieldatenbank verwendet. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um die Anfangsbuchstaben jedes Worts in der Spalte CATDESC in Großbuchstaben umzuwandeln.
```
SELECT catid, catdesc, INITCAP(catdesc)
FROM category
ORDER BY 1, 2, 3;
+-------+--------------------------------------------+--------------------------------------------+
| catid | catdesc | initcap |
+-------+--------------------------------------------+--------------------------------------------+
| 1 | Major League Baseball | Major League Baseball |
| 2 | National Hockey League | National Hockey League |
| 3 | National Football League | National Football League |
| 4 | National Basketball Association | National Basketball Association |
| 5 | Major League Soccer | Major League Soccer |
| 6 | Musical theatre | Musical Theatre |
| 7 | All non-musical theatre | All Non-Musical Theatre |
| 8 | All opera and light opera | All Opera And Light Opera |
| 9 | All rock and pop music concerts | All Rock And Pop Music Concerts |
| 10 | All jazz singers and bands | All Jazz Singers And Bands |
| 11 | All symphony, concerto, and choir concerts | All Symphony, Concerto, And Choir Concerts |
+-------+--------------------------------------------+--------------------------------------------+
```
Verwenden Sie das folgende Beispiel, um zu zeigen, dass die INITCAP-Funktion Großbuchstaben nicht beibehält, wenn sie sich nicht am Anfang von Wörtern befinden. Zum Beispiel wird Zeichenfolge `MLB` zu `Mlb`.
```
SELECT INITCAP(catname)
FROM category
ORDER BY catname;
+-----------+
| initcap |
+-----------+
| Classical |
| Jazz |
| Mlb |
| Mls |
| Musicals |
| Nba |
| Nfl |
| Nhl |
| Opera |
| Plays |
| Pop |
+-----------+
```
Verwenden Sie das folgende Beispiel, um zu zeigen, dass nicht alphanumerische Zeichen außer Leerzeichen als Worttrennzeichen dienen. Mehrere Buchstaben in jeder Zeichenfolge werden großgeschrieben.
```
SELECT email, INITCAP(email)
FROM users
ORDER BY userid DESC LIMIT 5;
+------------------------------------+------------------------------------+
| email | initcap |
+------------------------------------+------------------------------------+
| urna.Ut@egetdictumplacerat.edu | Urna.Ut@Egetdictumplacerat.Edu |
| nibh.enim@egestas.ca | Nibh.Enim@Egestas.Ca |
| in@Donecat.ca | In@Donecat.Ca |
| sodales@blanditviverraDonec.ca | Sodales@Blanditviverradonec.Ca |
| sociis.natoque.penatibus@vitae.org | Sociis.Natoque.Penatibus@Vitae.Org |
+------------------------------------+------------------------------------+
```
# 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*
Eine `CHAR`-Zeichenfolge, eine `VARCHAR`-Zeichenfolge oder ein beliebiger Ausdruck, die bzw. der implizit als eine `CHAR`- oder `VARCHAR`-Zeichenfolge ausgewertet wird.
*integer*
Eine positive Ganzzahl.
## Rückgabetyp
VARCHAR
## Beispiele
Verwenden Sie das folgende Beispiel, um Daten aus die Tabelle EVENT in der TICKIT-Beispieldatenbank zu verwenden. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um die 5 Zeichen ganz links und 5 ganz rechts von Ereignisnamen zurückzugeben, deren Ereignis IDs zwischen 1000 und 1005 liegt.
```
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 |
+---------+----------------+--------+---------+
```
# Die Funktion LEN
Gibt die Länge der angegebenen Zeichenfolge durch die Anzahl der Zeichen an.
## Syntax
LEN ist synonym mit [Die Funktion LENGTH](r_LENGTH.md), [Die Funktion CHAR\$1LENGTH](r_CHAR_LENGTH.md), [Die Funktion CHARACTER\$1LENGTH](r_CHARACTER_LENGTH.md) und [Die Funktion TEXTLEN](r_TEXTLEN.md).
```
LEN(expression)
```
## Argument
*expression*
Eine `CHAR`-Zeichenfolge, eine `VARCHAR`-Zeichenfolge, ein `VARBYTE`-Ausdruck oder ein Ausdruck, die bzw. der implizit als ein `CHAR`-, `VARCHAR`- oder `VARBYTE`-Typ ausgewertet wird.
## Rückgabetyp
INTEGER
Die LEN-Funktion gibt eine Ganzzahl zurück, die die Anzahl der Zeichen in der Eingabezeichenfolge anzeigt.
Wenn es sich um eine Folge von Zeichen handelt, gibt die LEN-Funktion die tatsächliche Anzahl der Zeichen in Multibyte-Zeichenfolgen zurück, nicht die Anzahl der Bytes. Beispielsweise ist eine `VARCHAR(12)`-Spalte erforderlich, um drei chinesische Zeichen mit vier Bytes zu speichern. Die LEN-Funktion gibt für diese Zeichenfolge `3` zurück. Verwenden Sie die Funktion [OCTET\$1LENGTH](r_OCTET_LENGTH.md), um die Länge einer Zeichenfolge in Bytes abzurufen.
## Nutzungshinweise
Wenn *Ausdruck* eine `CHAR`-Zeichenfolge ist, werden nachfolgende Leerzeichen nicht gezählt.
Wenn *Ausdruck* eine `VARCHAR`-Zeichenfolge ist, werden nachfolgende Leerzeichen gezählt.
## Beispiele
Verwenden Sie das folgende Beispiel, um die Anzahl der Bytes und die Anzahl der Zeichen der Zeichenfolge `français` zurückzugeben.
```
SELECT OCTET_LENGTH('français'),
LEN('français');
+--------------+-----+
| octet_length | len |
+--------------+-----+
| 9 | 8 |
+--------------+-----+
```
Verwenden Sie das folgende Beispiel, um die Anzahl der Bytes und die Anzahl der Zeichen der Zeichenfolge `français` zurückzugeben, ohne die Funktion OCTET\$1LENGTH zu nutzen. Weitere Informationen hierzu finden Sie unter [CAST-Funktion](r_CAST_function.md).
```
SELECT LEN(CAST('français' AS VARBYTE)) as bytes, LEN('français');
+-------+-----+
| bytes | len |
+-------+-----+
| 9 | 8 |
+-------+-----+
```
Verwenden Sie das folgende Beispiel, um die Anzahl der Zeichen in folgenden Zeichenfolgen zurückzugeben: `cat` ohne abschließende Leerzeichen,`cat ` mit drei abschließenden Leerzeichen, `cat ` mit drei abschließenden Leerzeichen, umgewandelt in ein `CHAR` der Länge 6 und `cat ` mit drei abschließenden Leerzeichen, umgewandelt in ein `VARCHAR` der Länge 6. Beachten Sie, dass die Funktion zwar nachfolgende Leerzeichen für `CHAR`-Zeichenfolgen nicht zählt, nachgestellte Leerzeichen für `VARCHAR`-Zeichenfolgen werden aber gezählt.
```
SELECT LEN('cat'), LEN('cat '), LEN(CAST('cat ' AS CHAR(6))) AS len_char, LEN(CAST('cat ' AS VARCHAR(6))) AS len_varchar;
+-----+-----+----------+-------------+
| len | len | len_char | len_varchar |
+-----+-----+----------+-------------+
| 3 | 6 | 3 | 6 |
+-----+-----+----------+-------------+
```
Verwenden Sie das folgende Beispiel, um Daten aus die Tabelle VENUE in der TICKIT-Beispieldatenbank zu verwenden. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um die 10 längsten Ortsnamen in der Tabelle VENUE zurückzugeben.
```
SELECT venuename, LEN(venuename)
FROM venue
ORDER BY 2 DESC, 1
LIMIT 10;
+-----------------------------------------+-----+
| venuename | len |
+-----------------------------------------+-----+
| Saratoga Springs Performing Arts Center | 39 |
| Lincoln Center for the Performing Arts | 38 |
| Nassau Veterans Memorial Coliseum | 33 |
| Jacksonville Municipal Stadium | 30 |
| Rangers BallPark in Arlington | 29 |
| University of Phoenix Stadium | 29 |
| Circle in the Square Theatre | 28 |
| Hubert H. Humphrey Metrodome | 28 |
| Oriole Park at Camden Yards | 27 |
| Dick's Sporting Goods Park | 26 |
+-----------------------------------------+-----+
```
# Die Funktion LENGTH
Synonym mit der Funktion LEN.
Siehe [Die Funktion LEN](r_LEN.md).
# 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*
Eine `VARCHAR`-Zeichenfolge oder ein beliebiger Ausdruck, die/der zum Typ `VARCHAR` ausgewertet wird.
## Rückgabetyp
Zeichenfolge
Die LOWER-Funktion gibt eine Zeichenfolge zurück, die den gleichen Datentyp wie die Zeichenfolge hat. Wenn es sich bei der Eingabe beispielsweise um eine `CHAR`-Zeichenfolge handelt, gibt die Funktion eine `CHAR`-Zeichenfolge zurück.
## Beispiele
Verwenden Sie das folgende Beispiel, um Daten aus die Tabelle CATEGORY in der TICKIT-Beispieldatenbank zu verwenden. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um die Zeichenfolge `VARCHAR` im Feld CATGROUP in Kleinbuchstaben zu konvertieren.
```
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 |
+-----------+-----------+
```
# 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 `CHAR`-Zeichenfolge, eine `VARCHAR`-Zeichenfolge oder ein Ausdruck, die bzw. der implizit als ein `CHAR`- oder `VARCHAR`-Typ ausgewertet wird.
*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* null oder eine negative Zahl ist, ist das Ergebnis der Funktion eine leere Zeichenfolge.
*string2*
(Optional) Ein oder mehrere Zeichen, die vor oder nach *string1* angefügt werden. Wenn dieses Argument nicht angegeben wird, werden Leerzeichen verwendet.
## Rückgabetyp
VARCHAR
## Beispiele
In den folgenden Beispielen werden Daten aus der EVENT-Tabelle in der TICKIT-Beispieldatenbank verwendet. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um einen angegebenen Satz von Veranstaltungsnamen auf 20 Zeichen zu kürzen und vor den kürzeren Namen Leerzeichen einzufügen.
```
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 |
+-----------------------+
```
Verwenden Sie das folgende Beispiel, um denselben Satz von Veranstaltungsnamen auf 20 Zeichen zu kürzen und vor den kürzeren Namen jedoch `0123456789` anzufügen.
```
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 |
+----------------------+
```
# 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. Die Kürzung ist abgeschlossen, wenn in der Eingabezeichenfolge kein Trimm-Zeichen enthalten ist.
## 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
```
# Funktion OCTENDEX
Die Funktion OCTEINDEX gibt den Ort einer Teilzeichenfolge innerhalb eines Strings als Anzahl der Bytes zurück.
## Syntax
```
OCTETINDEX(substring, string)
```
## Argumente
*substring*
Eine `CHAR`-Zeichenfolge, eine `VARCHAR`-Zeichenfolge oder ein Ausdruck, die bzw. der implizit als ein `CHAR`- oder `VARCHAR`-Typ ausgewertet wird.
*string*
Eine `CHAR`-Zeichenfolge, eine `VARCHAR`-Zeichenfolge oder ein Ausdruck, die bzw. der implizit als ein `CHAR`- oder `VARCHAR`-Typ ausgewertet wird.
## Rückgabetyp
INTEGER
Die Funktion OCTETINDEX gibt einen `INTEGER`-Wert zurück, der der Position der *Teilzeichenfolge* innerhalb der *Zeichenfolge* als Anzahl von Bytes entspricht, wobei das erste Zeichen in der *Zeichenfolge* als 1 gezählt wird. Wenn die *Zeichenfolge* keine Multibyte-Zeichen enthält, entspricht das Ergebnis dem Ergebnis der Funktion CHARINDEX. Wenn die *Zeichenfolge* die *Teilzeichenfolge* nicht enthält, gibt die Funktion `0` zurück. Wenn die *Teilzeichenfolge* leer ist, gibt die Funktion `1` zurück.
## Beispiele
Verwenden Sie das folgende Beispiel, um die Position der Teilzeichenfolge `q` in der Zeichenfolge `Amazon Redshift` zurückzugeben. Dieses Beispiel gibt `0` zurück, da die *Teilzeichenfolge* nicht in der *Zeichenfolge* enthalten ist.
```
SELECT OCTETINDEX('q', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 0 |
+------------+
```
Verwenden Sie das folgende Beispiel, um die Position einer leeren Teilzeichenfolge in der Zeichenfolge `Amazon Redshift` zurückzugeben. Dieses Beispiel gibt `1` zurück, da die *Teilzeichenfolge* leer ist.
```
SELECT OCTETINDEX('', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 1 |
+------------+
```
Verwenden Sie das folgende Beispiel, um die Position der Teilzeichenfolge `Redshift` in der Zeichenfolge `Amazon Redshift` zurückzugeben. Dieses Beispiel gibt `8` zurück, da die *Teilzeichenfolge* mit dem achten Byte der *Zeichenfolge* beginnt.
```
SELECT OCTETINDEX('Redshift', 'Amazon Redshift');
+------------+
| octetindex |
+------------+
| 8 |
+------------+
```
Verwenden Sie das folgende Beispiel, um die Position der Teilzeichenfolge `Redshift` in der Zeichenfolge `Amazon Redshift` zurückzugeben. Im folgenden Beispiel wird `21` zurückgegeben, da die ersten sechs Zeichen der *Zeichenfolge* Doppelbyte-Zeichen sind.
```
SELECT OCTETINDEX('Redshift', 'Άμαζον Amazon Redshift');
+------------+
| octetindex |
+------------+
| 21 |
+------------+
```
# Die OCTET\$1LENGTH-Funktion
Gibt die Länge der angegebenen Zeichenfolge durch die Anzahl der Bytes an.
## Syntax
```
OCTET_LENGTH(expression)
```
## Argument
*expression*
Eine `CHAR`-Zeichenfolge, eine `VARCHAR`-Zeichenfolge, ein `VARBYTE`-Ausdruck oder ein Ausdruck, die bzw. der implizit als ein `CHAR`-, `VARCHAR`- oder `VARBYTE`-Typ ausgewertet wird.
## Rückgabetyp
INTEGER
Die Funktion „OCTET\$1LENGTH“ gibt eine Ganzzahl zurück, die die Anzahl der Bytes in der Eingabezeichenfolge anzeigt.
Wenn es sich um eine Folge von Zeichen handelt, gibt die [LEN](r_LEN.md)-Funktion die tatsächliche Anzahl der Zeichen in Multibyte-Zeichenfolgen zurück, nicht die Anzahl der Bytes. Beispielsweise ist eine `VARCHAR(12)`-Spalte erforderlich, um drei chinesische Zeichen mit vier Bytes zu speichern. Die Funktion OCTET\$1LENGTH gibt für diese Zeichenfolge `12` zurück und die LEN-Funktion gibt für dieselbe Zeichenfolge `3` zurück.
## Nutzungshinweise
Wenn *Ausdruck* eine `CHAR`-Zeichenfolge ist, gibt die Funktion die Länge der `CHAR`-Zeichenfolge zurück. Zum Beispiel ist die Ausgabe einer `CHAR(6)`-Eingabe ein `CHAR(6)`.
Wenn *Ausdruck* eine `VARCHAR`-Zeichenfolge ist, werden nachfolgende Leerzeichen gezählt.
## Beispiele
Verwenden Sie das folgende Beispiel, um die Anzahl der Byte zurückzugeben, wenn die Zeichenfolge `francais` mit drei abschließenden Leerzeichen in ein `CHAR` und einen `VARCHAR`-Typ umgewandelt wird. Weitere Informationen hierzu finden Sie unter [CAST-Funktion](r_CAST_function.md).
```
SELECT OCTET_LENGTH(CAST('francais ' AS CHAR(15))) AS octet_length_char, OCTET_LENGTH(CAST('francais ' AS VARCHAR(15))) AS octet_length_varchar;
+-------------------+----------------------+
| octet_length_char | octet_length_varchar |
+-------------------+----------------------+
| 15 | 11 |
+-------------------+----------------------+
```
Verwenden Sie das folgende Beispiel, um die Anzahl der Bytes und die Anzahl der Zeichen der Zeichenfolge `français` zurückzugeben.
```
SELECT OCTET_LENGTH('français'), LEN('français');
+--------------+-----+
| octet_length | len |
+--------------+-----+
| 9 | 8 |
+--------------+-----+
```
Verwenden Sie das folgende Beispiel, um die Anzahl der Byte zurückzugeben, wenn die Zeichenfolge `français` in ein `VARBYTE` umgewandelt wird.
```
SELECT OCTET_LENGTH(CAST('français' AS VARBYTE));
+--------------+
| octet_length |
+--------------+
| 9 |
+--------------+
```
# Die Funktion POSITION
Gibt den Ort der angegebenen Unterzeichenfolge innerhalb einer Zeichenfolge zurück.
Ähnliche Funktionen finden Sie unter [Funktion CHARINDEX](r_CHARINDEX.md) und [Die Funktion STRPOS](r_STRPOS.md).
## 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 `INTEGER` zurück, die der Position der Teilzeichenfolge 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. POSITION gibt `0` zurück, wenn die Teilzeichenfolge nicht innerhalb der Zeichenfolge gefunden wird.
## Beispiele
Verwenden Sie das folgende Beispiel, um die Position der Zeichenfolge `fish` innerhalb des Worts `dog` zu zeigen.
```
SELECT POSITION('fish' IN 'dog');
+-----------+
| position |
+-----------+
| 0 |
+-----------+
```
Verwenden Sie das folgende Beispiel, um die Position der Zeichenfolge `fish` innerhalb des Worts `dogfish` zu zeigen.
```
SELECT POSITION('fish' IN 'dogfish');
+-----------+
| position |
+-----------+
| 4 |
+-----------+
```
Im folgenden Beispiel wird die Tabelle SALES aus der TICKIT-Beispieldatenbank verwendet. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um die Zahl der bestimmten Verkaufstransaktionen mit einer Kommission von mehr als 999,00 aus der Tabelle SALES zurückzugeben. Dieser Befehl zählt Provisionen über 999,00, indem geprüft wird, ob die Dezimalzahl mehr als 4 Stellen vom Anfang des Provisionswerts entfernt ist.
```
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 |
+-----------+-------+
```
# Die Funktion QUOTE\$1IDENT
Die Funktion QUOTE\$1IDENT gibt die angegebene Zeichenfolge als Zeichenfolge mit einem doppelten Anführungszeichen am Anfang und einem am Ende zurück. Die Funktionsausgabe kann als Bezeichner in einer SQL-Anweisung verwendet werden. Diese Funktion verdoppelt eingebettete doppelte Anführungszeichen korrekt.
QUOTE\$1IDENT fügt doppelte Anführungszeichen nur dann hinzu, wenn dies zum Erstellen eines gültigen Bezeichners erforderlich ist. Dies ist bei Zeichenfolgen der Fall, die Nicht-Bezeichner-Zeichen enthalten oder bei denen Großbuchstaben wie Kleinbuchstaben behandelt werden. Wenn eine Zeichenfolge immer in einfachen Anführungszeichen zurückgegeben werden soll, verwenden Sie [QUOTE\$1LITERAL](r_QUOTE_LITERAL.md).
## Syntax
```
QUOTE_IDENT(string)
```
## Argument
*string*
Eine `CHAR`- oder `VARCHAR`-Zeichenfolge.
## Rückgabetyp
Die QUOTE\$1IDENT-Funktion gibt denselben Zeichenfolgetyp wie die *Eingabezeichenfolge* zurück.
## Beispiele
Verwenden Sie das folgende Beispiel, um die Zeichenfolge `"CAT"` mit doppelten Anführungszeichen zurückzugeben.
```
SELECT QUOTE_IDENT('"CAT"');
+-------------+
| quote_ident |
+-------------+
| """CAT""" |
+-------------+
```
Verwenden Sie das folgende Beispiel, um Daten aus die Tabelle CATEGORY in der TICKIT-Beispieldatenbank zu verwenden. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um die Spalte CATNAME in doppelten Anführungszeichen zurückzugeben.
```
SELECT catid, QUOTE_IDENT(catname)
FROM category
ORDER BY 1,2;
+-------+-------------+
| catid | quote_ident |
+-------+-------------+
| 1 | "MLB" |
| 2 | "NHL" |
| 3 | "NFL" |
| 4 | "NBA" |
| 5 | "MLS" |
| 6 | "Musicals" |
| 7 | "Plays" |
| 8 | "Opera" |
| 9 | "Pop" |
| 10 | "Jazz" |
| 11 | "Classical" |
+-------+-------------+
```
# Die Funktion QUOTE\$1LITERAL
Die QUOTE\$1LITERAL-Funktion gibt die angegebene Zeichenfolge als eine Zeichenfolge in Anführungszeichen zurück, damit sie als Zeichenfolgeliteral in einer SQL-Anweisung verwendet werden kann. Wenn es sich beim Eingabeparameter um eine Zahl handelt, wird er von QUOTE\$1LITERAL als Zeichenfolge behandelt. Eingebettete einfache Anführungszeichen und Backslashes werden korrekt verdoppelt.
## Syntax
```
QUOTE_LITERAL(string)
```
## Argument
*string*
Eine `CHAR`- oder `VARCHAR`-Zeichenfolge.
## Rückgabetyp
Die QUOTE\$1LITERAL-Funktion gibt eine `CHAR`- oder `VARCHAR`-Zeichenfolge zurück, die den gleichen Datentyp wie die *Eingabezeichenfolge* hat.
## Beispiele
Verwenden Sie das folgende Beispiel, um die Zeichenfolge `''CAT''` mit EINZELNEN Anführungszeichen zurückzugeben.
```
SELECT QUOTE_LITERAL('''CAT''');
+---------------+
| quote_literal |
+---------------+
| '''CAT''' |
+---------------+
```
In den folgenden Beispielen werden die Daten aus der CATEGORY-Tabelle in der TICKIT-Beispieldatenbank verwendet. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um die Spalte CATNAME in doppelten Anführungszeichen zurückzugeben.
```
SELECT catid, QUOTE_LITERAL(catname)
FROM category
ORDER BY 1,2;
+-------+---------------+
| catid | quote_literal |
+-------+---------------+
| 1 | 'MLB' |
| 2 | 'NHL' |
| 3 | 'NFL' |
| 4 | 'NBA' |
| 5 | 'MLS' |
| 6 | 'Musicals' |
| 7 | 'Plays' |
| 8 | 'Opera' |
| 9 | 'Pop' |
| 10 | 'Jazz' |
| 11 | 'Classical' |
+-------+---------------+
```
Verwenden Sie das folgende Beispiel, um die Spalte CATID in doppelten Anführungszeichen zurückzugeben.
```
SELECT QUOTE_LITERAL(catid), catname
FROM category
ORDER BY 1,2;
+---------------+-----------+
| quote_literal | catname |
+---------------+-----------+
| '1' | MLB |
| '10' | Jazz |
| '11' | Classical |
| '2' | NHL |
| '3' | NFL |
| '4' | NBA |
| '5' | MLS |
| '6' | Musicals |
| '7' | Plays |
| '8' | Opera |
| '9' | Pop |
+---------------+-----------+
```
# 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 angegebene Muster in der Zeichenfolge auftritt. Wenn keine Übereinstimmung gefunden wird, gibt die Funktion `0` zurück. Weitere Informationen zu regulären Ausdrücken finden Sie unter [POSIX-Operatoren](pattern-matching-conditions-posix.md) und [Regulärer Ausdruck](https://en.wikipedia.org/wiki/Regular_expression) in Wikipedia.
## Syntax
```
REGEXP_COUNT( source_string, pattern [, position [, parameters ] ] )
```
## Argumente
*source\$1string*
Eine `CHAR`- oder `VARCHAR`-Zeichenfolge.
*pattern*
Ein UTF-8-Zeichenfolgenliteral, das ein Muster für reguläre Ausdrücke darstellt. Weitere Informationen finden Sie unter [POSIX-Operatoren](pattern-matching-conditions-posix.md).
*position*
(optional) Ein positiver `INTEGER`, 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*
(Optional) 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. Weitere Informationen zu PCRE finden Sie unter [Perl-kompatible reguläre Ausdrücke](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) in Wikipedia.
## Rückgabetyp
INTEGER
## Beispiele
Verwenden Sie das folgende Beispiel, um die Häufigkeit zu zählen, mit der eine Folge aus drei Buchstaben auftritt.
```
SELECT REGEXP_COUNT('abcdefghijklmnopqrstuvwxyz', '[a-z]{3}');
+--------------+
| regexp_count |
+--------------+
| 8 |
+--------------+
```
Verwenden Sie das folgende Beispiel, um die Anzahl der Vorkommen der Zeichenfolge `FOX` zu zählen, wobei nicht zwischen Groß- und Kleinschreibung unterschieden wird.
```
SELECT REGEXP_COUNT('the fox', 'FOX', 1, 'i');
+--------------+
| regexp_count |
+--------------+
| 1 |
+--------------+
```
Verwenden Sie das folgende Beispiel, um ein im PCRE-Dialekt geschriebenes Muster zu verwenden, um Wörter mit mindestens einer Zahl und einem Kleinbuchstaben zu finden. Dieses Beispiel verwendet den Operator `?=`, 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 |
+--------------+
```
Verwenden Sie das folgende Beispiel, um ein im PCRE-Dialekt geschriebenes Muster zu verwenden, 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 |
+--------------+
```
Im folgenden Beispiel werden Daten aus der Tabelle USERS in der TICKIT-Beispieldatenbank verwendet. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um die Häufigkeit zu zählen, mit der der Name der obersten Domain 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 |
+-----------------------------------------------+--------------+
```
# 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](r_POSITION.md) ähnlich. Sie können damit jedoch eine Zeichenfolge nach einem regulären Ausdrucksmuster durchsuchen. Weitere Informationen zu regulären Ausdrücken finden Sie unter [POSIX-Operatoren](pattern-matching-conditions-posix.md) und [Regulärer Ausdruck](https://en.wikipedia.org/wiki/Regular_expression) in Wikipedia.
## Syntax
```
REGEXP_INSTR( source_string, pattern [, position [, occurrence] [, option [, parameters ] ] ] ] )
```
## Argumente
*source\$1string*
Ein Zeichenfolgenausdruck (beispielsweise ein Spaltenname), der gesucht werden soll.
*pattern*
Ein UTF-8-Zeichenfolgenliteral, das ein Muster für reguläre Ausdrücke darstellt. Weitere Informationen finden Sie unter [POSIX-Operatoren](pattern-matching-conditions-posix.md).
*position*
(optional) Ein positiver `INTEGER`, 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*
(Optional) Eine positive `INTEGER`, die angibt, welches Vorkommen des Musters verwendet werden soll. REGEXP\$1INSTR überspringt die ersten `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*
(Optional) 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 ist `0`.
*parameters (Parameter*
(Optional) 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. Weitere Informationen zu PCRE finden Sie unter [Perl-kompatible reguläre Ausdrücke](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) in Wikipedia.
## Rückgabetyp
Ganzzahl
## Beispiele
In den folgenden Beispielen werden Daten aus der Tabelle USERS in der TICKIT-Beispieldatenbank verwendet. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um nach dem Zeichen `@` zu suchen, mit dem Domain-Namen 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@sodalesMaurisblandit.edu | 21 |
| Suspendisse.tristique@nonnisiAenean.edu | 22 |
| amet.faucibus.ut@condimentumegetvolutpat.ca | 17 |
| sed@lacusUtnec.ca | 4 |
+-----------------------------------------------+--------------+
```
Verwenden Sie das folgende Beispiel, um nach Varianten des Worts `Center` zu suchen. 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 |
+-----------------------+--------------+
```
Verwenden Sie das folgende Beispiel, um die Anfangsposition des ersten Vorkommens der Zeichenfolge `FOX` zu finden, wobei nicht zwischen Groß- und Kleinschreibung unterschieden wird.
```
SELECT REGEXP_INSTR('the fox', 'FOX', 1, 1, 0, 'i');
+--------------+
| regexp_instr |
+--------------+
| 5 |
+--------------+
```
Verwenden Sie das folgende Beispiel, um ein im PCRE-Dialekt geschriebenes Muster zu verwenden, 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 |
+--------------+
```
Verwenden Sie das folgende Beispiel, um ein im PCRE-Dialekt geschriebenes Muster zu verwenden, 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](r_REPLACE.md) ähnlich. Sie können jedoch eine Zeichenfolge nach einem regulären Ausdrucksmuster durchsuchen. Weitere Informationen zu regulären Ausdrücken finden Sie unter [POSIX-Operatoren](pattern-matching-conditions-posix.md) und [Regulärer Ausdruck](https://en.wikipedia.org/wiki/Regular_expression) in Wikipedia.
REGEXP\$1REPLACE ist [Die Funktion TRANSLATE](r_TRANSLATE.md) und [Die Funktion REPLACE](r_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 `CHAR`- oder `VARCHAR`-Zeichenfolgeausdruck (beispielsweise ein Spaltenname), der gesucht werden soll.
*pattern*
Ein UTF-8-Zeichenfolgenliteral, das ein Muster für reguläre Ausdrücke darstellt. Weitere Informationen finden Sie unter [POSIX-Operatoren](pattern-matching-conditions-posix.md).
*replace\$1string*
(Optional) Ein `CHAR`- oder `VARCHAR`-Zeichenfolgeausdruck (beispielsweise ein Spaltenname), der jedes Vorkommen eines Musters ersetzt. Der Standardwert ist eine leere Zeichenfolge ("").
*position*
(Optional) 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*
(Optional) 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. Weitere Informationen zu PCRE finden Sie unter [Perl-kompatible reguläre Ausdrücke](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) in Wikipedia.
## Rückgabetyp
VARCHAR
Wenn *pattern* oder *replace\$1string* `NULL` sind, ist der Rückgabewert `NULL`.
## Beispiele
Verwenden Sie das folgende Beispiel, um alle Vorkommen der Zeichenfolge `FOX` innerhalb des Werts `quick brown fox` zu ersetzen, 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. Verwenden Sie das folgende Beispiel, um alle Vorkommen eines solchen Worts durch den Wert `[hidden]` zu ersetzen.
```
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. Verwenden Sie das folgende Beispiel, um alle Vorkommen eines solchen Worts mit dem Wert `[hidden]` zu ersetzen. 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] |
+----------------------------------+
```
In den folgenden Beispielen werden Daten aus der Tabelle USERS in der TICKIT-Beispieldatenbank verwendet. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um `@` und den Domain-Name aus E-Mail-Adressen zu löschen.
```
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 |
+-----------------------------------------------+-----------------------+
```
Verwenden Sie das folgende Beispiel, um die Domain-Namen von E-Mail-Adressen durch `internal.company.com` zu ersetzen.
```
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 |
+-----------------------------------------------+--------------------------------------------+
```
# 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](r_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. Weitere Informationen zu regulären Ausdrücken finden Sie unter [POSIX-Operatoren](pattern-matching-conditions-posix.md) und [Regulärer Ausdruck](https://en.wikipedia.org/wiki/Regular_expression) in Wikipedia.
## Syntax
```
REGEXP_SUBSTR( source_string, pattern [, position [, occurrence [, parameters ] ] ] )
```
## Argumente
*source\$1string*
Ein Zeichenfolgeausdruck, der durchsucht werden soll.
*pattern*
Ein UTF-8-Zeichenfolgenliteral, das ein Muster für reguläre Ausdrücke darstellt. Weitere Informationen finden Sie unter [POSIX-Operatoren](pattern-matching-conditions-posix.md).
*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 leer.
*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. Weitere Informationen zu PCRE finden Sie unter [Perl-kompatible reguläre Ausdrücke](https://en.wikipedia.org/wiki/Perl_Compatible_Regular_Expressions) in Wikipedia.
## Rückgabetyp
VARCHAR
## Beispiele
Im folgenden Beispiel wird der E-Mail-Adresse-Abschnitt zwischen dem Zeichen @ und der Domänenerweiterung zurückgegeben. Die abgefragten `users`-Daten stammen aus den Amazon-Redshift-Beispieldaten. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
```
SELECT email, regexp_substr(email,'@[^.]*')
FROM users
ORDER BY userid LIMIT 4;
email | regexp_substr
-----------------------------------------------+--------------------------
Suspendisse.tristique@nonnisiAenean.edu | @nonnisiAenean
amet.faucibus.ut@condimentumegetvolutpat.ca | @condimentumegetvolutpat
sed@lacusUtnec.ca | @lacusUtnec
Cum@accumsan.com | @accumsan
```
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
```
Im folgenden Beispiel wird der Teil der Eingabe zurückgegeben, der dem zweiten Vorkommen der Zeichenfolge `FOX` entspricht, wobei nicht zwischen Groß- und Kleinschreibung unterschieden wird. Das Ergebnis ist leer (nicht-null, Länge 0), weil es kein zweites Vorkommen gibt.
```
SELECT regexp_substr('the fox', 'FOX', 1, 2, 'i');
regexp_substr
---------------
```
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.
Synonym mit [Die Funktion REPLICATE](r_REPLICATE.md).
## Syntax
```
REPEAT(string, integer)
```
## Argumente
*string*
Der erste Eingabeparameter ist die Zeichenfolge, die wiederholt werden soll.
*integer*
Der zweite Parameter ist eine `INTEGER`, die die Häufigkeit angibt, mit der die Zeichenfolge wiederholt werden soll.
## Rückgabetyp
VARCHAR
## Beispiele
Verwenden Sie das folgende Beispiel, um Daten aus die Tabelle CATEGORY in der TICKIT-Beispieldatenbank zu verwenden. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um den Wert der Spalte CATID in der Tabelle CATEGORY dreimal zu wiederholen.
```
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 |
+-------+--------+
```
Das folgende Beispiel zeigt das Generieren von Zeichenketten mit bis zu 16.000.000 Byte:
```
SELECT
LEN(REPEAT('X', 5000000)) AS five_million_bytes,
LEN(REPEAT('Y', 16000000)) AS sixteen_million_bytes;
five_million_bytes | sixteen_million_bytes
----------+-----------
5000000 | 16000000
```
# Die Funktion REPLACE
Ersetzt alle Vorkommen eines Satzes von Zeichen innerhalb einer vorhandenen Zeichenfolge durch andere angegebene Zeichen.
REPLACE ist [Die Funktion TRANSLATE](r_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(string, 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
Verwenden Sie das folgende Beispiel, um Daten aus die Tabelle CATEGORY in der TICKIT-Beispieldatenbank zu verwenden. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um die Zeichenfolge `Shows` in `Theatre` im Feld CATGROUP zu konvertieren.
```
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 |
+-------+----------+----------+
```
# Die Funktion REPLICATE
Synonym mit der Funktion REPEAT.
Siehe [Die Funktion REPEAT](r_REPEAT.md).
# 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 `VARCHAR`-Zeichenfolgen konvertiert. Nachfolgende Leerzeichen in `CHAR`-Zeichenfolgen werden ignoriert.
## Rückgabetyp
VARCHAR
## Beispiele
In den folgenden Beispielen werden Daten aus der Tabellen USERS und SALES in der TICKIT-Beispieldatenbank verwendet. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um fünf verschiedene Namen von Städten und die entsprechenden Umkehrungen der Namen aus der Tabelle USERS auszuwählen.
```
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 |
+----------+----------+
```
Verwenden Sie das folgende Beispiel, um fünf Verkaufszahlen IDs und ihre entsprechende umgekehrte IDs Umwandlung als Zeichenketten auszuwählen.
```
SELECT salesid, REVERSE(salesid)
FROM sales
ORDER BY salesid DESC LIMIT 5;
+---------+---------+
| salesid | reverse |
+---------+---------+
| 172456 | 654271 |
| 172455 | 554271 |
| 172454 | 454271 |
| 172453 | 354271 |
| 172452 | 254271 |
+---------+---------+
```
# 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. Die Kürzung ist abgeschlossen, wenn in der Eingabezeichenfolge kein Trimm-Zeichen enthalten ist.
## 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.
# Funktion SOUNDEX
Die Funktion SOUNDEX gibt den amerikanischen Soundex-Wert zurück, der aus dem ersten Buchstaben der Eingabezeichenfolge gefolgt von einer 3-stelligen Kodierung der Laute besteht, die die englische Aussprache der angegebenen Zeichenfolge repräsentieren. Zum Beispiel haben `Smith` und `Smyth` den gleichen Soundex-Wert.
## Syntax
```
SOUNDEX(string)
```
## Argumente
*string*
Sie geben eine `CHAR`- oder `VARCHAR`-Zeichenfolge an, die Sie in einen amerikanischen Soundex-Codewert konvertieren möchten.
## Rückgabetyp
VARCHAR(4)
## Nutzungshinweise
Die Funktion SOUNDEX konvertiert nur englische alphabetische ASCII-Zeichen in Klein- und Großbuchstaben, einschließlich a–z und A–Z. SOUNDEX ignoriert andere Zeichen. SOUNDEX gibt einen einzelnen Soundex-Wert für eine Zeichenfolge aus mehreren Wörtern zurück, die durch Leerzeichen getrennt sind.
```
SELECT SOUNDEX('AWS Amazon');
+---------+
| soundex |
+---------+
| A252 |
+---------+
```
SOUNDEX gibt eine leere Zeichenfolge zurück, wenn die Eingabezeichenfolge keine englischen Buchstaben enthält.
```
SELECT SOUNDEX('+-*/%');
+---------+
| soundex |
+---------+
| |
+---------+
```
## Beispiele
Verwenden Sie das folgende Beispiel, um den Soundex-Wert für `Amazon` zurückzugeben.
```
SELECT SOUNDEX('Amazon');
+---------+
| soundex |
+---------+
| A525 |
+---------+
```
Verwenden Sie das folgende Beispiel, um den Soundex-Wert für `smith` und `smyth` zurückzugeben. Beachten Sie, dass die Soundex-Werte identisch sind.
```
SELECT SOUNDEX('smith'), SOUNDEX('smyth');
+-------+-------+
| smith | smyth |
+-------+-------+
| S530 | S530 |
+-------+-------+
```
# 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 STRPOS
Gibt die Position einer Unterzeichenfolge innerhalb einer angegebenen Zeichenfolge zurück.
Ähnliche Funktionen finden Sie unter [Funktion CHARINDEX](r_CHARINDEX.md) und [Die Funktion POSITION](r_POSITION.md).
## Syntax
```
STRPOS(string, substring )
```
## Argumente
*string*
Der erste Eingabeparameter ist die `CHAR`- oder `VARCHAR`-Zeichenfolge, die durchsucht werden soll.
*substring*
Der zweite Parameter ist die Unterzeichenfolge, nach der innerhalb der *Zeichenfolge* gesucht werden soll.
## Rückgabetyp
INTEGER
Die STRPOS-Funktion gibt eine `INTEGER` zurück, die der Position der *Teilzeichenfolge* 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
STRPOS gibt `0` zurück, wenn die *Teilzeichenfolge* nicht innerhalb der *Zeichenfolge* gefunden wird.
```
SELECT STRPOS('dogfish', 'fist');
+--------+
| strpos |
+--------+
| 0 |
+--------+
```
## Beispiele
Verwenden Sie das folgende Beispiel, um die Position von `fish` innerhalb von`dogfish` anzuzeigen.
```
SELECT STRPOS('dogfish', 'fish');
+--------+
| strpos |
+--------+
| 4 |
+--------+
```
Verwenden Sie das folgende Beispiel, um die Tabelle SALES aus der TICKIT-Beispieldatenbank zu verwenden. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um die Zahl der Verkaufstransaktionen mit einer COMMISSION von mehr als 999,00 aus der Tabelle SALES zurückzugeben.
```
SELECT DISTINCT STRPOS(commission, '.'),
COUNT (STRPOS(commission, '.'))
FROM sales
WHERE STRPOS(commission, '.') > 4
GROUP BY STRPOS(commission, '.')
ORDER BY 1, 2;
+--------+-------+
| strpos | count |
+--------+-------+
| 5 | 629 |
+--------+-------+
```
# Die Funktion STRTOL
Konvertiert einen Zeichenfolgenausdruck einer Nummer der angegebenen Basis in den entsprechenden Ganzzahlwert. Der konvertierte Wert muss innerhalb des signierten 64-Bit-Bereichs liegen.
## Syntax
```
STRTOL(num_string, base)
```
## Argumente
*num\$1string*
Zeichenfolgeausdruck einer Zahl, der konvertiert werden soll. Wenn *num\$1string* leer ist (`''`) oder mit dem Null-Zeichen (`'\0'`) beginnt, ist der konvertierte Wert `0`. Wenn *num\$1string* eine Spalte ist, die einen NULL-Wert enthält, gibt STRTOL `NULL` zurück. Die Zeichenfolge kann mit einer beliebigen Zahl von Leerzeichen beginnen, optional gefolgt von einem einzelnen Plus (`+`)- oder Minus (`-`)-Zeichen, um einen positiven oder negativen Wert anzugeben. Der Standardwert ist '`+`'. Wenn *base* `16` ist, kann die Zeichenfolge optional mit `0x` beginnen.
*base*
`INTEGER` zwischen 2 und 36.
## Rückgabetyp
BIGINT
Wenn *num\$1string* null ist, gibt die Funktion `NULL` zurück.
## Beispiele
Verwenden Sie die folgenden Beispiele, um Zeichenfolgen- und Basiswertpaare in Ganzzahlen zu konvertieren.
```
SELECT STRTOL('0xf',16);
+--------+
| strtol |
+--------+
| 15 |
+--------+
SELECT STRTOL('abcd1234',16);
+------------+
| strtol |
+------------+
| 2882343476 |
+------------+
SELECT STRTOL('1234567', 10);
+---------+
| strtol |
+---------+
| 1234567 |
+---------+
SELECT STRTOL('1234567', 8);
+--------+
| strtol |
+--------+
| 342391 |
+--------+
SELECT STRTOL('110101', 2);
+--------+
| strtol |
+--------+
| 53 |
+--------+
SELECT STRTOL('\0', 2);
+--------+
| strtol |
+--------+
| 0 |
+--------+
```
# 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(character_string FROM start_position [ FOR number_characters ] )
```
```
SUBSTRING(character_string, start_position, number_characters )
```
```
SUBSTRING(binary_expression, start_byte, number_bytes )
```
```
SUBSTRING(binary_expression, start_byte )
```
## Argumente
*character\$1string*
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.
*number\$1characters*
Die Anzahl der Zeichen, die extrahiert werden soll (die Länge der Unterzeichenfolge). Die *number\$1characters* basiert auf der Anzahl der Zeichen, nicht der Bytes. Daher werden Zeichen mit mehreren Bytes als einzelne Zeichen gezählt. Diese Zahl darf nicht negativ sein.
*binary\$1expression*
Der binary\$1expression des zu durchsuchenden Datentyps VARBYTE.
*start\$1byte*
Die Position innerhalb des Binärausdrucks, an der die Extrahierung gestartet werden soll, beginnend mit 1. Diese Zahl kann negativ sein.
*number\$1bytes*
Die Anzahl der Bytes, die extrahiert werden sollen, also die Länge der Unterzeichenfolge. Diese Zahl darf nicht negativ sein.
## Rückgabetyp
Je nach Eingabe VARCHAR oder VARBYTE.
## Nutzungshinweise
Im Folgenden finden Sie einige Beispiele dafür, wie Sie *start\$1position* und *number\$1characters* verwenden können, um Teilzeichenfolgen aus verschiedenen Positionen in einer Zeichenfolge zu extrahieren.
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 *number\$1characters* die Länge von *string* überschreiten, gibt SUBSTRING eine Unterzeichenfolge ab *start\$1position* bis zum Ende der Zeichenfolge zurück. 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 `number_characters` -1 zurück. Beispiel:
```
select substring('caterpillar',-2,6);
substring
-----------
cat
(1 row)
```
Wenn `start_position` \$1 `number_characters` -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 zeigt eine negative Startposition eines Binärwerts `abc`. Da die Startpositon -3 ist, wird die Unterzeichenfolge ab dem Anfang des Binärwerts extrahiert. Das Ergebnis wird automatisch als hexadezimale Darstellung der binären Unterzeichenfolgen angezeigt.
```
select substring('abc'::varbyte, -3);
substring
-----------
616263
```
Das folgende Beispiel zeigt eine 1 für die Startposition eines Binärwerts `abc`. Da keine Länge angegeben ist, wird die Zeichenfolge von der Startposition bis zum Ende der Zeichenfolge extrahiert. Das Ergebnis wird automatisch als hexadezimale Darstellung der binären Unterzeichenfolgen angezeigt.
```
select substring('abc'::varbyte, 1);
substring
-----------
616263
```
Das folgende Beispiel zeigt eine 3 für die Startposition eines Binärwerts `abc`. Da keine Länge angegeben ist, wird die Zeichenfolge von der Startposition bis zum Ende der Zeichenfolge extrahiert. Das Ergebnis wird automatisch als hexadezimale Darstellung der binären Unterzeichenfolgen angezeigt.
```
select substring('abc'::varbyte, 3);
substring
-----------
63
```
Das folgende Beispiel zeigt eine 2 für die Startposition eines Binärwerts `abc`. Die Zeichenfolge wird von der Startposition auf Position 10 extrahiert, aber das Ende der Zeichenfolge befindet sich an Position 3. Das Ergebnis wird automatisch als hexadezimale Darstellung der binären Unterzeichenfolgen angezeigt.
```
select substring('abc'::varbyte, 2, 10);
substring
-----------
6263
```
Das folgende Beispiel zeigt eine 2 für die Startposition eines Binärwerts `abc`. Die Zeichenfolge wird für 1 Byte aus der Startposition extrahiert. Das Ergebnis wird automatisch als hexadezimale Darstellung der binären Unterzeichenfolgen angezeigt.
```
select substring('abc'::varbyte, 2, 1);
substring
-----------
62
```
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 TEXTLEN
Synonym mit der Funktion LEN.
Siehe [Die Funktion LEN](r_LEN.md).
# 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](r_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
Verwenden Sie das folgende Beispiel, um mehrere Zeichen in einer Zeichenfolge zu ersetzen.
```
SELECT TRANSLATE('mint tea', 'inea', 'osin');
+-----------+
| translate |
+-----------+
| most tin |
+-----------+
```
In den folgenden Beispielen werden Daten aus der Tabelle USERS in der TICKIT-Beispieldatenbank verwendet. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie das folgende Beispiel, um für alle Werte in einer Spalte das Zeichen @ durch einen Punkt zu ersetzen.
```
SELECT email, TRANSLATE(email, '@', '.') as obfuscated_email
FROM users LIMIT 10;
+---------------------------------------+---------------------------------------+
| email | obfuscated_email |
+---------------------------------------+---------------------------------------+
| Cum@accumsan.com | Cum.accumsan.com |
| lorem.ipsum@Vestibulumante.com | lorem.ipsum.Vestibulumante.com |
| non.justo.Proin@ametconsectetuer.edu | non.justo.Proin.ametconsectetuer.edu |
| non.ante.bibendum@porttitortellus.org | non.ante.bibendum.porttitortellus.org |
| eros@blanditatnisi.org | eros.blanditatnisi.org |
| augue@Donec.ca | augue.Donec.ca |
| cursus@pedeacurna.edu | cursus.pedeacurna.edu |
| at@Duis.com | at.Duis.com |
| quam@facilisisvitaeorci.ca | quam.facilisisvitaeorci.ca |
| mi.lorem@nunc.edu | mi.lorem.nunc.edu |
+---------------------------------------+---------------------------------------+
```
Verwenden Sie das folgende Beispiel, um für alle Werte in einer Spalte Leerzeichen durch Unterstriche zu ersetzen und Punkte zu entfernen.
```
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 die Leerzeichen oder angegebenen Zeichen einer Zeichenfolge.
## Syntax
```
TRIM( [ BOTH | LEADING | TRAILING ] [trim_chars FROM ] string )
```
## Argumente
BOTH \$1 LEADING \$1 TRAILING
(Optional) Gibt an, von wo Zeichen gekürzt werden sollen. Verwenden Sie BOTH, um führende und nachgestellte Zeichen zu entfernen, verwenden Sie LEADING, um nur führende Zeichen zu entfernen, und verwenden Sie TRAILING, um nur nachfolgende Zeichen zu entfernen. Wenn dieser Parameter weggelassen wird, werden sowohl führende als auch nachfolgende Zeichen gekürzt.
*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 `CHAR`-Zeichenfolge zurück. Wenn Sie die TRIM-Funktion mit einem SQL-Befehl verwenden, konvertiert Amazon Redshift die Ergebnisse implizit in `VARCHAR`. Wenn Sie die TRIM-Funktion in der SELECT-Liste für eine SQL-Funktion verwenden, konvertiert Amazon Redshift die Ergebnisse nicht implizit und Sie müssen möglicherweise eine explizite Konvertierung ausführen, um einen Fehler wegen fehlender Datentypübereinstimmung zu vermeiden. Weitere Informationen zu expliziten Konvertierungen finden Sie in den Abschnitten zu den Funktionen [CAST-Funktion](r_CAST_function.md) und [CONVERT-Funktion](r_CONVERT_function.md).
## Beispiele
Verwenden Sie das folgende Beispiel, um Leerzeichen am Anfang und am Ende aus der Zeichenfolge ` dog ` zu entfernen.
```
SELECT TRIM(' dog ');
+-------+
| btrim |
+-------+
| dog |
+-------+
```
Verwenden Sie das folgende Beispiel, um Leerzeichen am Anfang und am Ende aus der Zeichenfolge ` dog ` zu entfernen.
```
SELECT TRIM(BOTH FROM ' dog ');
+-------+
| btrim |
+-------+
| dog |
+-------+
```
Verwenden Sie das folgende Beispiel, um die führenden doppelten Anführungszeichen aus der Zeichenfolge `"dog"` zu entfernen.
```
SELECT TRIM(LEADING '"' FROM'"dog"');
+-------+
| ltrim |
+-------+
| dog" |
+-------+
```
Verwenden Sie das folgende Beispiel, um die nachstehenden doppelten Anführungszeichen aus der Zeichenfolge `"dog"` zu entfernen.
```
SELECT TRIM(TRAILING '"' FROM'"dog"');
+-------+
| rtrim |
+-------+
| "dog |
+-------+
```
TRIM entfernt alle Zeichen in *trim\$1chars*, wenn sie sich am Anfang oder am Ende 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. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
```
SELECT venueid, venuename, TRIM('CDG' FROM venuename)
FROM venue
WHERE venuename LIKE '%Park'
ORDER BY 2
LIMIT 7;
+---------+----------------------------+---------------------------+
| venueid | venuename | btrim |
+---------+----------------------------+---------------------------+
| 121 | AT&T Park | AT&T 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. Wenn es sich bei der Eingabe beispielsweise um eine `VARCHAR`-Zeichenfolge handelt, gibt die Funktion eine `VARCHAR`-Zeichenfolge zurück.
## Beispiele
Verwenden Sie das folgende Beispiel, um Daten aus die Tabelle CATEGORY in der TICKIT-Beispieldatenbank zu verwenden. Weitere Informationen finden Sie unter [Beispieldatenbank](c_sampledb.md).
Verwenden Sie Folgendes, um das Feld CATNAME-Feld in Großbuchstaben zu konvertieren.
```
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 |
+-----------+-----------+
```