Anhang G. Beschreibung der MySQL-Syntax für reguläre Ausdrücke
Zurück |  | Weiter

## Anhang G. Beschreibung der MySQL-Syntax für reguläre Ausdrücke

Ein regulärer Ausdruck ist ein mächtiges Werkzeug, um ein Muster für eine komplexe Suchoperation zu spezifizieren.

MySQL verwendet Henry Spencers Implementierung für reguläre Ausdrücke, die auf POSIX 1003.2 zugeschnitten ist. Siehe auch Anhang C, Danksagungen. MySQL benutzt die erweiterte Version, um Mustererkennung mit dem `REGEXP`-Operator in SQL-Anweisungen zu ermöglichen. Siehe hierzu Abschnitt 3.3.4.7, „Übereinstimmende Suchmuster“, und Abschnitt 12.3.1, „String-Vergleichsfunktionen“.

Dieser Anhang fasst mit Beispielen die Sonderzeichen und Konstrukte zusammen, die in MySQL für `REGEXP`-Operationen eingesetzt werden können. Wir wiederholen hier nicht jedes Detail von Henry Spencers `regex(7)`-Handbuchseite. Diese Seite ist in den Quelldistributionen von MySQL inbegriffen, nämlich in der Datei `regex.7` unter dem Verzeichnis `regex`.

Ein regulärer Ausdruck beschreibt eine Menge von Strings. Der einfachste reguläre Ausdruck ist einer ohne Sonderzeichen. So erkennt beispielsweise der reguläre Ausdruck `hello` nichts anderes als den String `hello`.

Nichttriviale reguläre Ausdrücke verwenden spezielle Konstrukte, um mehr als nur einen einzigen String erkennen zu können. So passt beispielsweise der reguläre Ausdruck `hello|word` entweder auf den String `hello` oder auf den String `word`.

Als komplexeres Beispiel erkennt der reguläre Ausdruck `B[an]*s` die Strings `Bananas`, `Baaaaas`, `Bs` und und alle anderen Strings, die mit `B` anfangen, mit `s` enden und beliebig viele `a`- oder `n`-Zeichen dazwischen aufweisen.

Ein regulärer Ausdruck für den `REGEXP`-Operator kann alle folgenden Sonderzeichen und Konstrukte benutzen:

- `^`

  Den Anfang eines Strings erkennen.

      mysql> SELECT 'fo\nfo' REGEXP '^fo$';                   -> 0
      mysql> SELECT 'fofo' REGEXP '^fo';                      -> 1

- `$`

  Das Ende eines Strings erkennen.

      mysql> SELECT 'fo\no' REGEXP '^fo\no$';                 -> 1
      mysql> SELECT 'fo\no' REGEXP '^fo$';                    -> 0

- `.`

  Irgendwelche Zeichen erkennen (einschließlich Carriage Return und Newline).

      mysql> SELECT 'fofo' REGEXP '^f.*$';                    -> 1
      mysql> SELECT 'fo\r\nfo' REGEXP '^f.*$';                -> 1

- `a*`

  Irgendeine Folge von null oder mehr `a`-Zeichen erkennen.

      mysql> SELECT 'Ban' REGEXP '^Ba*n';                     -> 1
      mysql> SELECT 'Baaan' REGEXP '^Ba*n';                   -> 1
      mysql> SELECT 'Bn' REGEXP '^Ba*n';                      -> 1

- `a+`

  Irgendeine Folge von einem oder mehr `a`-Zeichen erkennen.

      mysql> SELECT 'Ban' REGEXP '^Ba+n';                     -> 1
      mysql> SELECT 'Bn' REGEXP '^Ba+n';                      -> 0

- `a?`

  Null oder ein `a`-Zeichen erkennen.

      mysql> SELECT 'Bn' REGEXP '^Ba?n';                      -> 1
      mysql> SELECT 'Ban' REGEXP '^Ba?n';                     -> 1
      mysql> SELECT 'Baan' REGEXP '^Ba?n';                    -> 0

- `de|abc`

  Eine der Zeichenfolgen `de` oder `abc` erkennen.

      mysql> SELECT 'pi' REGEXP 'pi|apa';                     -> 1
      mysql> SELECT 'axe' REGEXP 'pi|apa';                    -> 0
      mysql> SELECT 'apa' REGEXP 'pi|apa';                    -> 1
      mysql> SELECT 'apa' REGEXP '^(pi|apa)$';                -> 1
      mysql> SELECT 'pi' REGEXP '^(pi|apa)$';                 -> 1
      mysql> SELECT 'pix' REGEXP '^(pi|apa)$';                -> 0

- `(abc)*`

  Null oder mehr Instanzen der Zeichenfolge `abc` erkennen.

      mysql> SELECT 'pi' REGEXP '^(pi)*$';                    -> 1
      mysql> SELECT 'pip' REGEXP '^(pi)*$';                   -> 0
      mysql> SELECT 'pipi' REGEXP '^(pi)*$';                  -> 1

- `{1}`, `{2,3}`

  Die `{n}`- oder `{m,n}`-Notation bietet eine allgemeingültigere Möglichkeit, reguläre Ausdrücke zu schreiben, die viele Exemplare des vorangehenden atomaren Bestandteils (oder „Teils“) des Musters erkennen. `m` und `n` sind Integer.

  - `a*`

    Kann als `a{0,}` geschrieben werden.

  - `a+`

    Kann als `a{1,}` geschrieben werden.

  - `a?`

    Kann als `a{0,1}` geschrieben werden.

  Genauer gesagt: `a{n}` erkennt genau `n` Instanzen von `a`. `a{n,}` erkennt `n` oder mehr Instanzen von `a`. `a{m,n}` erkennt `m` bis einschließlich `n` Instanzen von `a`.

  `m` und `n` müssen zwischen `0` und `RE_DUP_MAX` (Standardwert 255) einschließlich liegen. Sind sowohl `m` als auch `n` angegeben, muss `m` kleiner oder gleich `n` sein.

      mysql> SELECT 'abcde' REGEXP 'a[bcd]{2}e';              -> 0
      mysql> SELECT 'abcde' REGEXP 'a[bcd]{3}e';              -> 1
      mysql> SELECT 'abcde' REGEXP 'a[bcd]{1,10}e';           -> 1

- `[a-dX]`, `[^a-dX]`

  Erkennt jedes Zeichen, das gleich (oder, wenn ^ verwendet wird, ungleich) `a`, `b`, `c`, `d` oder `X` ist. Ein `-`-Zeichen zwischen zwei anderen Zeichen bildet einen Bereich, der alle Zeichen vom ersten bis zum zweiten erkennt. So erkennt beispielsweise `[0-9]` jede Ziffer des Dezimalsystems. Um das Literalzeichen `]` einzubinden, muss dieses unmittelbar hinter der öffnenden eckigen Klammer `[` stehen. Um ein Literalzeichen `-` einzubinden, muss es als erstes oder letztes Zeichen geschrieben werden. Jedes Zeichen innerhalb eines Klammerpaars `[]`, das keine definierte Sonderbedeutung hat, erkennt nur sich selbst.

      mysql> SELECT 'aXbc' REGEXP '[a-dXYZ]';                 -> 1
      mysql> SELECT 'aXbc' REGEXP '^[a-dXYZ]$';               -> 0
      mysql> SELECT 'aXbc' REGEXP '^[a-dXYZ]+$';              -> 1
      mysql> SELECT 'aXbc' REGEXP '^[^a-dXYZ]+$';             -> 0
      mysql> SELECT 'gheis' REGEXP '^[^a-dXYZ]+$';            -> 1
      mysql> SELECT 'gheisa' REGEXP '^[^a-dXYZ]+$';           -> 0

- `[.characters.]`

  In einem Ausdruck in eckigen Klammern (`[` und `]`) wird hiermit die Zeichenfolge dieses Kollationselements erkannt. `characters` ist entweder ein einzelnes Zeichen oder ein Zeichenname wie `newline`. Die vollständige Liste der Zeichennamen finden Sie in der Datei `regexp/cname.h`.

      mysql> SELECT '~' REGEXP '[[.~.]]';                     -> 1
      mysql> SELECT '~' REGEXP '[[.tilde.]]';                 -> 1

- `[=character_class=]`

  In einem Ausdruck in eckigen Klammern (`[` und `]`) stellt `[=character_class=]` eine Äquivalenzklasse dar. Sie erkennt alle Zeichen mit demselben Kollationswert einschließlich sich selbst. Wenn beispielsweise `o` und `(+)` die Elemente der Äquivalenzklasse sind, dann sind `[[=o=]]`, `[[=(+)=]]` und `[o(+)]` alle synonym. Eine Äquivalenzklasse darf nicht als Endpunkt eines Bereichs verwendet werden.

- `[:character_class:]`

  In einem Ausdruck in eckigen Klammern (`[` und `]`) stellt `[:character_class:]` eine Zeichenklasse dar, die alle zu dieser Klasse gehörigen Zeichen erkennt. Die folgende Tabelle listet die Standardklassennamen auf. Es sind die Namen der Zeichenklassen, die auf der Handbuchseite `ctype(3)` definiert sind. Die Klassennamen können in manchen Spracheinstellungen andere sein. Eine Zeichenklasse darf nicht als Endpunkt eines Bereichs verwendet werden.

  `alnum` | Alphanumerische Zeichen
  `alpha` | Alphabetische Zeichen
  `blank` | Whitespace-Zeichen
  `cntrl` | Steuerzeichen
  `digit` | Ziffernzeichen
  `graph` | Graphische Zeichen
  `lower` | Kleinbuchstaben
  `print` | Graphische oder Leerzeichen
  `punct` | Interpunktionszeichen
  `space` | Leerzeichen, Tabulator, Newline und Carriage Return
  `upper` | Großbuchstaben
  `xdigit` | Hexadezimalziffern

      mysql> SELECT 'justalnums' REGEXP '[[:alnum:]]+';       -> 1
      mysql> SELECT '!!' REGEXP '[[:alnum:]]+';               -> 0

- `[[:<:]]`, `[[:>:]]`

  Diese Markierungen bedeuten Wortgrenzen. Sie erkennen den Anfang und das Ende eines Worts. Ein Wort ist eine Folge von Wortzeichen, denen kein weiteres Wortzeichen voransteht oder folgt. Ein Wortzeichen ist ein alphanumerisches Zeichen aus der Klasse `alnum` oder ein Unterstrich (`_`).

      mysql> SELECT 'a word a' REGEXP '[[:<:]]word[[:>:]]';   -> 1
      mysql> SELECT 'a xword a' REGEXP '[[:<:]]word[[:>:]]';  -> 0

Um ein Sonderzeichen in einem regulären Ausdruck als Literal zu benutzen, setzen Sie zwei Backslash-Zeichen davor (\). Der Parser von MySQL interpretiert einen der Backslashes und die Bibliothek für reguläre Ausdrücke den anderen. Um beispielsweise den String `1+2` zu erkennen, der das Sonderzeichen `+` enthält, ist nur der letzte der folgenden regulären Ausdrücke der richtige:

    mysql> SELECT '1+2' REGEXP '1+2';                       -> 0
    mysql> SELECT '1+2' REGEXP '1\+2';                      -> 0
    mysql> SELECT '1+2' REGEXP '1\\+2';                     -> 1

Dies ist eine Übersetzung des MySQL-Referenzhandbuchs, das sich auf dev.mysql.com befindet. Das ursprüngliche Referenzhandbuch ist auf Englisch, und diese Übersetzung ist nicht notwendigerweise so aktuell wie die englische Ausgabe. Das vorliegende deutschsprachige Handbuch behandelt MySQL bis zur Version 5.1.

Zurück |  | Weiter
Anhang F. Umgebungsvariablen | Zum Anfang | Anhang H. Beschränkungen in MySQL