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.

# POSIX-Operatoren
<a name="pattern-matching-conditions-posix"></a>

Ein regulärer POSIX-Ausdruck ist eine Zeichenfolge, die ein Übereinstimmungsmuster angibt. Eine Zeichenfolge entspricht einem regulären Ausdruck, wenn sie Teil der regulären Menge ist, die durch den regulären Ausdruck beschrieben wird.

Reguläre Ausdrücke entsprechend der POSIX-Spezifikation ermöglichen eine feinere Modellierung von Mustern als die Operatoren [LIKE](r_patternmatching_condition_like.md) und [SIMILAR TO](pattern-matching-conditions-similar-to.md). Bei regulären Ausdrücken entsprechend dem POSIX-Standard kann das Muster einer beliebigen Teilzeichenfolge entsprechen. Der Operator SIMILAR TO hingegen gibt „wahr“ genau dann zurück, wenn das Muster der gesamten Zeichenfolge entspricht.

**Anmerkung**  
Patternmatching mit regulären Ausdrücken unter Verwendung von POSIX-Operatoren 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 ~ '.*(Ring|Die).*'; 
select count(*) from event where eventname LIKE '%Ring%' OR eventname LIKE '%Die%';
```

## Syntax
<a name="pattern-matching-conditions-posix-synopsis"></a>

```
expression [ ! ] ~ pattern
```

## Argumente
<a name="pattern-matching-conditions-posix-arguments"></a>

 *expression*   
Ein gültiger UTF-8 Zeichenausdruck, z. B. ein Spaltenname. 

\!  
Negationsoperator. Entspricht nicht dem regulären Ausdruck.

\~  
Führt eine Suche über beliebige Teilzeichenfolgen in dem Ausdruck *expression* und unter Berücksichtigung der Groß-/Kleinschreibung durch.   
Der Operator `~~` ist ein Synonym für [LIKE](r_patternmatching_condition_like.md).

 *pattern*   
Ein Zeichenfolgenliteral, das ein Muster für reguläre Ausdrücke darstellt. 

Wenn das Muster *pattern* keine Platzhalterzeichen enthält, wird die Zeichenfolge selbst als Muster verwendet.

Um nach Zeichenfolgen zu suchen, die Metazeichen, beispielsweise `. * | ? ` usw. enthalten, müssen Sie dieses Zeichen mit zwei umgekehrten Schrägstrichen (` \\`) als Literal kennzeichnen. Im Gegensatz zu `SIMILAR TO` und `LIKE` unterstützen reguläre Ausdrücke entsprechend dem POSIX-Standard keine benutzerdefinierten Escape-Zeichenfolgen. 

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*. 

Alle Zeichenfolgenausdrücke können vom Datentyp CHAR oder VARCHAR sein. Wenn in den Ausdrücken unterschiedliche Datentypen verwendet werden, konvertiert Amazon Redshift sie in den Datentyp des Ausdrucks *expression*. 

POSIX unterstützt die folgenden Metazeichen in Mustern: 


| POSIX  | Beschreibung  | 
| --- | --- | 
| .  | Entspricht einem beliebigen Zeichen. | 
| \* | Findet 0 oder mehr Vorkommen. | 
| \+ | Findet 1 oder mehr Vorkommen. | 
| ? | Findet 0 oder 1 Vorkommen. | 
| \| | Gibt alternative Übereinstimmungen an. Beispiel: E \| H bedeutet E oder H. | 
| ^ | Findet die Position am Zeilenanfang. | 
| $  | Findet die Position am Zeilenende. | 
| $  | Findet die Position am Ende der ganzen Zeichenfolge.  | 
| [ ] | In eckigen Klammern steht eine Musterliste, aus der ein Element übereinstimmen muss. Ein der Liste vorangestelltes Caret-Zeichen (^) steht für eine Musterausschlussliste, die auf alle Zeichenfolgen außer den Ausdrücken in der Liste passt. | 
| ( ) | Klammern fassen Elemente zu einem logischen Element zusammen. | 
| {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. | 
| [: :] | Passt auf alle Zeichen in einer POSIX-Zeichenklasse. In den folgenden Zeichenklassen unterstützt Amazon Redshift nur ASCII-Zeichen: [:alnum:], [:alpha:], [:lower:], [:upper:] | 

Amazon Redshift unterstützt die folgenden POSIX-Zeichenklassen: 


| Zeichenklasse  | Beschreibung  | 
| --- | --- | 
| [[:alnum:]] | Alle alphanumerischen ASCII-Zeichen | 
| [[:alpha:]] | Alle alphabetischen ASCII-Zeichen | 
| [[:blank:]] | Alle Whitespace-Zeichen | 
| [[:cntrl:]] | Alle Steuerzeichen (nicht druckbar) | 
| [[:digit:]] | Alle Ziffern | 
| [[:lower:]] | Alle ASCII-Kleinbuchstaben | 
| [[:punct:]] | Alle Interpunktionszeichen | 
| [[:space:]] | Alle Leerzeichen (nicht druckbar) | 
| [[:upper:]] | Alle ASCII-Großbuchstaben | 
| [[:xdigit:]] | Alle gültigen Hexadezimalzeichen | 

 Amazon Redshift unterstützt die folgenden Perl-influenced Operatoren in regulären Ausdrücken. Wenn Sie den Operator nicht als Metazeichen verwenden möchten, müssen Sie ihn mit zwei umgekehrten Schrägstrichen () als Literal kennzeichnen. (‘`\\`’).   


| Operator | Beschreibung  | Entsprechender Zeichenklassenausdruck | 
| --- | --- | --- | 
| \\\\d | Eine Ziffer | [[:digit:]] | 
| \\\\D | Ein Zeichen, das keine Ziffer ist | [^[:digit:]] | 
| \\\\w | Ein Zeichen, das Bestandteil eines Worts sein kann | [[:word:]] | 
| \\\\W | Ein Zeichen, das kein Bestandteil eines Worts sein kann | [^[:word:]] | 
| \\\\s | Ein Whitespace-Zeichen | [[:space:]] | 
| \\\\S | Ein Zeichen, das keinen Whitespace darstellt | [^[:space:]] | 
| \\\\b | Ein Grenzwort |   | 

## Beispiele
<a name="pattern-matching-conditions-posix-synopsis-examples"></a>

In der folgenden Tabelle werden Beispiele für Patternmatching unter Verwendung von POSIX-Operatoren dargestellt:


| Ausdruck  | Rückgabewert  | 
| --- | --- | 
| 'abc' \~ 'abc' | Wahr | 
| 'abc' \~ 'a' | True | 
| 'abc' \~ 'A' | False | 
| 'abc' \~ '.\*(b\|d).\*' | True | 
| 'abc' \~ '(b\|c).\*' | True | 
| 'AbcAbcdefgefg12efgefg12' \~ '((Ab)?c)\+d((efg)\+(12))\+'   | True | 
| 'aaaaaab11111xy' \~ 'a{6}.[1]{5}(x\|y){2}'  | True | 
| '$0.87' \~ '\\\\$[0-9]\+(\\\\.[0-9][0-9])?'  | True | 
| 'ab c' \~ '[[:space:]]'  | True | 
| 'ab c' \~ '\\\\s'  | True | 
| ' ' \~ '\\\\S'  | Falsch | 

Das folgende Beispiel listet Städte auf, deren Name ein `E` oder ein `H` enthält: 

```
SELECT DISTINCT city FROM users
WHERE city ~ '.*E.*|.*H.*' ORDER BY city LIMIT 5;

      city
-----------------
 Agoura Hills
 Auburn Hills
 Benton Harbor
 Beverly Hills
 Chicago Heights
```

Das folgende Beispiel listet Städte auf, deren Name weder `E` noch `H` enthält: 

```
SELECT DISTINCT city FROM users WHERE city !~ '.*E.*|.*H.*' ORDER BY city LIMIT 5;

      city
-----------------
 Aberdeen	
 Abilene	
 Ada	
 Agat	
 Agawam
```

In dem folgenden Beispiel wird die Escape-Zeichenfolge (`\\`) verwendet, um nach Zeichenfolgen zu suchen, die den Punkt (.) enthalten. 

```
SELECT venuename FROM venue
WHERE venuename ~ '.*\\..*'
ORDER BY venueid;

          venuename
------------------------------
 St. Pete Times Forum
 Jobing.com Arena
 Hubert H. Humphrey Metrodome
 U.S. Cellular Field
 Superpages.com Center
 E.J. Nutter Center
 Bernard B. Jacobs Theatre
 St. James Theatre
```