Amazon Redshift unterstützt ab Patch 198 nicht mehr die Erstellung neuer Python-UDFs. Bestehende Python-UDFs werden 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.
# SIMILAR TO
Der SIMILAR TO-Operator vergleicht einen Zeichenfolgenausdruck (beispielsweise einen Spaltennamen) mit einem regulären Ausdruck entsprechend dem Standardformat für SQL. Ein regulärer Ausdruck entsprechend dem Standardformat für SQL kann verschiedene Metazeichen zum Patternmatching enthalten, darunter die beiden Zeichen, die auch der Operator [LIKE](r_patternmatching_condition_like.md) unterstützt.
Der Operator SIMILAR TO gibt „wahr“ genau dann zurück, wenn das Muster der gesamten Zeichenfolge entspricht. Bei regulären Ausdrücken entsprechend dem POSIX-Standard hingegen kann das Muster einer beliebigen Teilzeichenfolge entsprechen.
Bei SIMILAR TO wird beim Patternmatching die Groß-/Kleinschreibung berücksichtigt.
**Anmerkung**
Patternmatching mit regulären Ausdrücken unter Verwendung von SIMILAR TO erfordert einen hohen Rechenaufwand. Wir empfehlen, nach Möglichkeit LIKE zu verwenden, insbesondere, wenn eine große Anzahl an Zeilen verarbeitet werden muss. Ein Beispiel: Die folgenden Abfragen sind funktional identisch, aber die Abfrage mit LIKE wird 7-mal schneller ausgeführt als die Abfrage mit einem regulären Ausdruck:
```
select count(*) from event where eventname SIMILAR TO '%(Ring|Die)%';
select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%';
```
## Syntax
```
expression [ NOT ] SIMILAR TO pattern [ ESCAPE 'escape_char' ]
```
## Argumente
*expression*
Ein gültiger UTF-8 Zeichenausdruck, z. B. ein Spaltenname.
SIMILAR TO
Bei SIMILAR TO erfolgt die Suche über die gesamte Zeichenfolge in dem Ausdruck *expression* und unter Berücksichtigung der Groß-/Kleinschreibung.
*pattern*
Ein gültiger UTF-8 Zeichenausdruck, der ein SQL-Standardmuster für reguläre Ausdrücke darstellt.
*escape\_char*
Ein Zeichenfolgenausdruck zur Kennzeichnung von Metazeichen im Muster als Literal. Dies ist standardmäßig die Zeichenfolge \\\\ (doppelter umgekehrter Schrägstrich).
Wenn das Muster *pattern* keine Metazeichen enthält, wird das Muster als die Zeichenfolge selbst interpretiert.
Die Zeichenfolgenausdrücke können vom Datentyp CHAR oder VARCHAR sein. Wenn unterschiedliche Datentypen verwendet werden, konvertiert Amazon Redshift *pattern* in den Datentyp des Ausdrucks *expression*.
SIMILAR TO unterstützt die folgenden Metazeichen in Mustern:
| Operator | Beschreibung |
| --- | --- |
| % | Entspricht einer Folge von 0 oder mehr Zeichen. |
| \_ | Entspricht einem beliebigen Zeichen. |
| \| | Alternativen (eines der beiden angegebenen Teilmuster). |
| \* | Wiederholt das vorangehende Element 0 oder mehr Male. |
| \+ | Wiederholt das vorangehende Element 1 oder mehr Male. |
| ? | Wiederholt das vorangehende Element 0 oder 1 Mal. |
| {m} | Wiederholt das vorangehende Element genau m Male. |
| {m,} | Wiederholt das vorangehende Element m oder mehr Male. |
| {m,n} | Wiederholt das vorangehende Element m bis n Male. |
| () | Klammern fassen Elemente zu einem logischen Element zusammen. |
| [...] | Ausdrücke in eckigen Klammern geben eine Zeichenklasse an, wie bei regulären Ausdrücken entsprechend dem POSIX-Standard. |
## Beispiele
In der folgenden Tabelle werden Beispiele für Patternmatching mit SIMILAR TO dargestellt.
| Ausdruck | Rückgabewert |
| --- | --- |
| 'abc' SIMILAR TO 'abc' | Wahr |
| 'abc' SIMILAR TO '\_b\_' | True |
| 'abc' SIMILAR TO '\_A\_' | False |
| 'abc' SIMILAR TO '%(b\|d)%' | True |
| 'abc' SIMILAR TO '(b\|c)%' | False |
| 'AbcAbcdefgefg12efgefg12' SIMILAR TO '((Ab)?c)\+d((efg)\+(12))\+' | True |
| 'aaaaaab11111xy' SIMILAR TO 'a{6}\_ [0-9]{5}(x\|y){2}' | True |
| '$0.87' SIMILAR TO '$[0-9]\+(.[0-9][0-9])?' | Wahr |
Das folgende Beispiel listet Städte auf, deren Name ein „E“ oder ein „H“ enthält:
```
SELECT DISTINCT city FROM users
WHERE city SIMILAR TO '%E%|%H%' ORDER BY city LIMIT 5;
city
-----------------
Agoura Hills
Auburn Hills
Benton Harbor
Beverly Hills
Chicago Heights
```
In dem folgenden Beispiel wird die Standard-Escape-Zeichenfolge (`\\`) verwendet, um nach Zeichenfolgen zu suchen, die den Unterstrich (`_`) enthalten.
```
SELECT tablename, "column" FROM pg_table_def
WHERE "column" SIMILAR TO '%start\\_%'
ORDER BY tablename, "column" LIMIT 5;
tablename | column
--------------------------+---------------------
stcs_abort_idle | idle_start_time
stcs_abort_idle | txn_start_time
stcs_analyze_compression | start_time
stcs_auto_worker_levels | start_level
stcs_auto_worker_levels | start_wlm_occupancy
```
In dem folgenden Beispiel wird als Escape-Zeichenfolge `^` verwendet, und dann wird nach Zeichenfolgen gesucht, die den Unterstrich (`_`) enthalten.
```
SELECT tablename, "column" FROM pg_table_def
WHERE "column" SIMILAR TO '%start^_%' ESCAPE '^'
ORDER BY tablename, "column" LIMIT 5;
tablename | column
--------------------------+---------------------
stcs_abort_idle | idle_start_time
stcs_abort_idle | txn_start_time
stcs_analyze_compression | start_time
stcs_auto_worker_levels | start_level
stcs_auto_worker_levels | start_wlm_occupancy
```