In MariaDB die REGEXP -Operator wird verwendet, um festzustellen, ob eine Zeichenfolge mit einem regulären Ausdruck übereinstimmt.
Wenn die Zeichenfolge mit dem bereitgestellten regulären Ausdruck übereinstimmt, ist das Ergebnis 1 , andernfalls ist es 0 .
Syntax
Die Syntax lautet wie folgt:
expr REGEXP pat
Wobei expr ist die Eingabezeichenfolge und pat ist der reguläre Ausdruck, für den Sie die Zeichenfolge testen.
Beispiele
Nachfolgend finden Sie Beispiele für die Verwendung von REGEXP Operator mit verschiedenen Mustern.
Einfacher regulärer Ausdruck
Beginnen wir mit dem einfachsten Beispiel. Der einfachste reguläre Ausdruck, den wir verwenden können, ist einer, der keine Sonderzeichen enthält. Hier verwenden wir nur eine Zeichenfolge. Wenn ein Teil der Eingabezeichenfolge mit dieser Zeichenfolge übereinstimmt, wird eine Übereinstimmung zurückgegeben.
SELECT
'Corn' REGEXP 'Corn' AS "Corn",
'Acorn' REGEXP 'Corn' AS "Acorn",
'Corner' REGEXP 'Corn' AS "Corner",
'Cheese' REGEXP 'Corn' AS "Cheese";Ergebnis:
+------+-------+--------+--------+ | Corn | Acorn | Corner | Cheese | +------+-------+--------+--------+ | 1 | 1 | 1 | 0 | +------+-------+--------+--------+
Übereinstimmung mit dem Anfang einer Zeichenfolge
In diesem Beispiel gibt der reguläre Ausdruck an, dass die Zeichenfolge mit Co beginnen muss .
SELECT
'Corn' REGEXP '^Co' AS "Corn",
'Acorn' REGEXP '^Co' AS "Acorn",
'Cheese' REGEXP '^Co' AS "Cheese";Ergebnis:
+------+-------+--------+ | Corn | Acorn | Cheese | +------+-------+--------+ | 1 | 0 | 0 | +------+-------+--------+
Übereinstimmung mit dem Ende einer Zeichenfolge
In diesem Beispiel gibt der reguläre Ausdruck an, dass die Zeichenfolge mit rn enden muss .
SELECT
'Corn' REGEXP 'rn$' AS "Corn",
'Acorn' REGEXP 'rn$' AS "Acorn",
'Cheese' REGEXP 'rn$' AS "Cheese";Ergebnis:
+------+-------+--------+ | Corn | Acorn | Cheese | +------+-------+--------+ | 1 | 1 | 0 | +------+-------+--------+
Entspreche einem beliebigen Zeichen
Der . Zeichen passt zu jedem Zeichen.
SELECT
'Corn' REGEXP '.' AS "Corn",
'Cheese' REGEXP '.' AS "Cheese",
'' REGEXP '.' AS "";Ergebnis:
+------+--------+---+ | Corn | Cheese | | +------+--------+---+ | 1 | 1 | 0 | +------+--------+---+
Dieses Zeichen wird typischerweise in Verbindung mit anderen Zeichen verwendet, um weitere Kriterien anzugeben. Zum Beispiel:
SELECT
'Corn' REGEXP '^C.rn$' AS "Corn",
'Crn' REGEXP '^C.rn$' AS "Crn";Ergebnis:
+------+-----+ | Corn | Crn | +------+-----+ | 1 | 0 | +------+-----+
Hier legen wir fest, dass der String mit C beginnen muss , dass ihm ein beliebiges Zeichen folgen muss und dass es mit rn enden muss .
Beachten Sie, dass dieses Zeichen eine einzelne Instanz des Zeichens angibt. Wenn Sie mehrere Instanzen angeben möchten (zum Beispiel ee statt nur e ), müssen Sie weitere . hinzufügen Zeichen.
SELECT
'Tweet' REGEXP '^Tw..t$' AS "Tweet",
'Tweat' REGEXP '^Tw..t$' AS "Tweat",
'Tweet' REGEXP '^Tw.t$' AS "Tweet",
'Twit' REGEXP '^Tw..t$' AS "Twit";Ergebnis:
+-------+-------+-------+------+ | Tweet | Tweat | Tweet | Twit | +-------+-------+-------+------+ | 1 | 1 | 0 | 0 | +-------+-------+-------+------+
Eine andere Möglichkeit besteht darin, die Anzahl der Vorkommen in geschweiften Klammern anzugeben:
SELECT
'Tweet' REGEXP '^Tw.{2}t$' AS "Tweet",
'Tweat' REGEXP '^Tw.{2}t$' AS "Tweat",
'Tweet' REGEXP '^Tw.{1}t$' AS "Tweet",
'Twit' REGEXP '^Tw.{2}t$' AS "Twit";Ergebnis:
+-------+-------+-------+------+ | Tweet | Tweat | Tweet | Twit | +-------+-------+-------+------+ | 1 | 1 | 0 | 0 | +-------+-------+-------+------+
Wenn Sie jedoch das gesuchte Zeichen kennen, können Sie dieses Zeichen angeben (anstelle von . Zeichen), wie im folgenden Beispiel gezeigt.
Kombiniere mit null oder mehr Instanzen eines bestimmten Charakters
Wir können Folgendes tun, um null oder mehr Instanzen von e anzugeben Zeichen:
SELECT
'Twet' REGEXP '^Twe*t$' AS "Twet",
'Tweet' REGEXP '^Twe*t$' AS "Tweet",
'Tweeet' REGEXP '^Twe*t$' AS "Tweeet",
'Twt' REGEXP '^Twe*t$' AS "Twt",
'Twit' REGEXP '^Twe*t$' AS "Twit",
'Twiet' REGEXP '^Twe*t$' AS "Twiet",
'Tweit' REGEXP '^Twe*t$' AS "Tweit";Ergebnis:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 1 | 1 | 1 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
Die ersten vier passen, aber die letzten drei nicht.
Passen Sie eine oder mehrere Instanzen eines bestimmten Charakters an
Wir können das vorherige Beispiel so ändern, dass wir nur dann eine Übereinstimmung erhalten, wenn eine oder mehr Zeichen gefunden werden (das vorherige Beispiel hat eine Übereinstimmung zurückgegeben, wenn Null oder mehr gefunden wurden). Dazu verwenden wir einfach + statt * :
SELECT
'Twet' REGEXP '^Twe+t$' AS "Twet",
'Tweet' REGEXP '^Twe+t$' AS "Tweet",
'Tweeet' REGEXP '^Twe+t$' AS "Tweeet",
'Twt' REGEXP '^Twe+t$' AS "Twt",
'Twit' REGEXP '^Twe+t$' AS "Twit",
'Twiet' REGEXP '^Twe+t$' AS "Twiet",
'Tweit' REGEXP '^Twe+t$' AS "Tweit";Ergebnis:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 1 | 1 | 0 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
In diesem Fall gibt das vierte Wort ein anderes Ergebnis als im vorherigen Beispiel zurück.
Übereinstimmung mit null oder einer Instanz eines bestimmten Zeichens
Wir können das vorherige Beispiel so modifizieren, dass wir nur eine Übereinstimmung mit null oder einem der gewünschten Zeichen erhalten. Dazu verwenden wir ? :
SELECT
'Twet' REGEXP '^Twe?t$' AS "Twet",
'Tweet' REGEXP '^Twe?t$' AS "Tweet",
'Tweeet' REGEXP '^Twe?t$' AS "Tweeet",
'Twt' REGEXP '^Twe?t$' AS "Twt",
'Twit' REGEXP '^Twe?t$' AS "Twit",
'Twiet' REGEXP '^Twe?t$' AS "Twiet",
'Tweit' REGEXP '^Twe?t$' AS "Tweit";Ergebnis:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 0 | 0 | 1 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
Alternative
Sie können den | verwenden Zeichen, um der einen oder anderen Zeichenfolge zu entsprechen:
SELECT
'Tweet' REGEXP 'Tw|et' AS "Tweet",
'For Let' REGEXP 'Tw|et' AS "For Let",
'Banana' REGEXP 'Tw|et' AS "Banana";Ergebnis:
+-------+---------+--------+ | Tweet | For Let | Banana | +-------+---------+--------+ | 1 | 1 | 0 | +-------+---------+--------+
Hier ist ein weiteres Beispiel, wo ich nach ganzen Wörtern suche:
SELECT
'Cat' REGEXP 'Cat|Dog' AS "Cat",
'Dog' REGEXP 'Cat|Dog' AS "Dog",
'Doggone' REGEXP 'Cat|Dog' AS "Doggone",
'Banana' REGEXP 'Cat|Dog' AS "Banana";Ergebnis:
+-----+-----+---------+--------+ | Cat | Dog | Doggone | Banana | +-----+-----+---------+--------+ | 1 | 1 | 1 | 0 | +-----+-----+---------+--------+
Wir erhalten immer noch eine Übereinstimmung, selbst wenn unser regulärer Ausdruck nur mit einem Teil der Zeichenfolge übereinstimmt.
Übereinstimmung mit null oder mehr Instanzen einer Sequenz
Sie können Klammern zusammen mit dem Sternchen ()* verwenden um null oder mehr Instanzen einer Sequenz anzugeben:
SELECT
'Banana' REGEXP '(an)*' AS "Banana",
'Land' REGEXP '(an)*' AS "Land",
'Cheese' REGEXP '(an)*' AS "Cheese";Ergebnis:
+--------+------+--------+ | Banana | Land | Cheese | +--------+------+--------+ | 1 | 1 | 1 | +--------+------+--------+
Ein weiteres Beispiel:
SELECT
'Banana' REGEXP '^B(an)*d$' AS "Banana",
'Band' REGEXP '^B(an)*d$' AS "Band",
'Bald' REGEXP '^B(an)*d$' AS "Bald",
'Bad' REGEXP '^B(an)*d$' AS "Bad";Ergebnis:
+--------+------+------+-----+ | Banana | Band | Bald | Bad | +--------+------+------+-----+ | 0 | 1 | 0 | 0 | +--------+------+------+-----+
Wiederholung
Wie in einem vorherigen Beispiel gezeigt, können Sie geschweifte Klammern verwenden, um Wiederholungen anzugeben. Diese Notation bietet eine allgemeinere Art, reguläre Ausdrücke zu schreiben, als einige der vorherigen Beispiele:
SELECT
'Tweeet' REGEXP 'e{3}' AS "Tweeet",
'Tweet' REGEXP 'e{3}' AS "Tweet";Ergebnis:
+--------+-------+ | Tweeet | Tweet | +--------+-------+ | 1 | 0 | +--------+-------+
Bereich
Sie können den Bindestrich verwenden, um einen Bereich anzugeben. Hier ist ein Beispiel, das einen Zahlenbereich angibt:
SELECT
'Tweet 123' REGEXP '[0-9]' AS "Tweet 123",
'Tweet ABC' REGEXP '[0-9]' AS "Tweet ABC";Ergebnis:
+--------+-------+ | Tweeet | Tweet | +--------+-------+ | 1 | 0 | +--------+-------+
Und das folgende Beispiel gibt einen Bereich von Buchstaben an:
SELECT
'Tweet 123' REGEXP '[A-Z]' AS "Tweet 123",
'ABC' REGEXP '[A-Z]' AS "ABC",
'123' REGEXP '[A-Z]' AS "123";Ergebnis:
+-----------+-----+-----+ | Tweet 123 | ABC | 123 | +-----------+-----+-----+ | 1 | 1 | 0 | +-----------+-----+-----+
Folgendes passiert, wenn wir den Zahlenbereich begrenzen:
SELECT
'123' REGEXP '[1-3]' AS "123",
'012' REGEXP '[1-3]' AS "012",
'045' REGEXP '[1-3]' AS "045";Ergebnis:
+-----+-----+-----+ | 123 | 012 | 045 | +-----+-----+-----+ | 1 | 1 | 0 | +-----+-----+-----+
Nicht innerhalb eines Bereichs
Wir können den ^ verwenden Zeichen, um das vorherige Beispiel so zu ändern, dass der angegebene Zeichenbereich ausgeschlossen wird:
SELECT
'123' REGEXP '[^1-3]' AS "123",
'012' REGEXP '[^1-3]' AS "012",
'045' REGEXP '[^1-3]' AS "045";Ergebnis:
+-----+-----+-----+ | 123 | 012 | 045 | +-----+-----+-----+ | 0 | 1 | 1 | +-----+-----+-----+
In diesem Fall erhalten wir das Gegenteil zum vorherigen Beispiel.
Nullwerte
Wenn entweder der Ausdruck oder das Muster null ist , ist das Ergebnis null :
SELECT
null REGEXP 'Corn' AS "Corn",
'Acorn' REGEXP null AS "Acorn",
null REGEXP null AS "Corner";Ergebnis:
+------+-------+--------+ | Corn | Acorn | Corner | +------+-------+--------+ | NULL | NULL | NULL | +------+-------+--------+
