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. # 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 ```