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