In MariaDB, de REGEXP operator wordt gebruikt om te bepalen of een tekenreeks al dan niet overeenkomt met een reguliere expressie.
Als de tekenreeks overeenkomt met de opgegeven reguliere expressie, is het resultaat 1 , anders is het 0 .
Syntaxis
De syntaxis gaat als volgt:
expr REGEXP pat
Waar expr is de invoerreeks en pat is de reguliere expressie waarvoor je de string test.
Voorbeelden
Hieronder staan voorbeelden van het gebruik van de REGEXP operator met verschillende patronen.
Basis reguliere expressie
Laten we beginnen met het eenvoudigste voorbeeld. De eenvoudigste reguliere expressie die we kunnen gebruiken, is er een die geen speciale tekens bevat. Hier gebruiken we gewoon een string. Als een deel van de invoerreeks overeenkomt met die tekenreeks, wordt een overeenkomst geretourneerd.
SELECT
'Corn' REGEXP 'Corn' AS "Corn",
'Acorn' REGEXP 'Corn' AS "Acorn",
'Corner' REGEXP 'Corn' AS "Corner",
'Cheese' REGEXP 'Corn' AS "Cheese";Resultaat:
+------+-------+--------+--------+ | Corn | Acorn | Corner | Cheese | +------+-------+--------+--------+ | 1 | 1 | 1 | 0 | +------+-------+--------+--------+
Overeenkomen met het begin van een string
In dit voorbeeld geeft de reguliere expressie aan dat de tekenreeks moet beginnen met Co .
SELECT
'Corn' REGEXP '^Co' AS "Corn",
'Acorn' REGEXP '^Co' AS "Acorn",
'Cheese' REGEXP '^Co' AS "Cheese";Resultaat:
+------+-------+--------+ | Corn | Acorn | Cheese | +------+-------+--------+ | 1 | 0 | 0 | +------+-------+--------+
Overeenkomen met het einde van een string
In dit voorbeeld specificeert de reguliere expressie dat de string moet eindigen op rn .
SELECT
'Corn' REGEXP 'rn$' AS "Corn",
'Acorn' REGEXP 'rn$' AS "Acorn",
'Cheese' REGEXP 'rn$' AS "Cheese";Resultaat:
+------+-------+--------+ | Corn | Acorn | Cheese | +------+-------+--------+ | 1 | 1 | 0 | +------+-------+--------+
Overeenkomen met elk personage
De . karakter komt overeen met elk karakter.
SELECT
'Corn' REGEXP '.' AS "Corn",
'Cheese' REGEXP '.' AS "Cheese",
'' REGEXP '.' AS "";Resultaat:
+------+--------+---+ | Corn | Cheese | | +------+--------+---+ | 1 | 1 | 0 | +------+--------+---+
Dit teken wordt meestal gebruikt in combinatie met andere tekens om verdere criteria te specificeren. Bijvoorbeeld:
SELECT
'Corn' REGEXP '^C.rn$' AS "Corn",
'Crn' REGEXP '^C.rn$' AS "Crn";Resultaat:
+------+-----+ | Corn | Crn | +------+-----+ | 1 | 0 | +------+-----+
Hier specificeren we dat de string moet beginnen met C , dat het moet worden gevolgd door een teken (elk teken) en dat het moet eindigen op rn .
Merk op dat dit teken een enkele instantie van het teken aangeeft. Als u meerdere instanties wilt specificeren (bijvoorbeeld ee in plaats van alleen e ), moet je meer . tekens.
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";Resultaat:
+-------+-------+-------+------+ | Tweet | Tweat | Tweet | Twit | +-------+-------+-------+------+ | 1 | 1 | 0 | 0 | +-------+-------+-------+------+
Een andere manier om dit te doen is door het aantal keren dat het voorkomt tussen accolades te specificeren:
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";Resultaat:
+-------+-------+-------+------+ | Tweet | Tweat | Tweet | Twit | +-------+-------+-------+------+ | 1 | 1 | 0 | 0 | +-------+-------+-------+------+
Als u echter weet welk teken u zoekt, kunt u dat teken specificeren (in plaats van de . karakter), zoals aangetoond in het volgende voorbeeld.
Overeenkomen met nul of meer instanties van een specifiek teken
We kunnen het volgende doen om nul of meer instanties van de e . te specificeren karakter:
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";Resultaat:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 1 | 1 | 1 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
De eerste vier komen overeen, maar de laatste drie niet.
Overeenkomen met een of meer instanties van een specifiek teken
We kunnen het vorige voorbeeld aanpassen zodat we alleen een overeenkomst krijgen als één of meer tekens zijn gevonden (het vorige voorbeeld leverde een overeenkomst op als nul of meer gevonden). Om dit te doen, gebruiken we gewoon + in plaats van * :
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";Resultaat:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 1 | 1 | 0 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
In dit geval geeft het vierde woord een ander resultaat dan het vorige voorbeeld.
Overeenkomen met nul of één instantie van een specifiek teken
We kunnen het vorige voorbeeld aanpassen zodat we alleen een match krijgen op nul of een van de gewenste karakters. Om dit te doen, gebruiken we ? :
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";Resultaat:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 0 | 0 | 1 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
Afwisseling
U kunt de | . gebruiken teken dat overeenkomt met een of andere reeks tekens:
SELECT
'Tweet' REGEXP 'Tw|et' AS "Tweet",
'For Let' REGEXP 'Tw|et' AS "For Let",
'Banana' REGEXP 'Tw|et' AS "Banana";Resultaat:
+-------+---------+--------+ | Tweet | For Let | Banana | +-------+---------+--------+ | 1 | 1 | 0 | +-------+---------+--------+
Hier is nog een voorbeeld waarbij ik naar hele woorden zoek:
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";Resultaat:
+-----+-----+---------+--------+ | Cat | Dog | Doggone | Banana | +-----+-----+---------+--------+ | 1 | 1 | 1 | 0 | +-----+-----+---------+--------+
We krijgen nog steeds een overeenkomst, zelfs als onze reguliere expressie slechts met een deel van de tekenreeks overeenkomt.
Overeenkomen met nul of meer instanties van een reeks
U kunt haakjes gebruiken samen met de asterisk ()* om nul of meer exemplaren van een reeks op te geven:
SELECT
'Banana' REGEXP '(an)*' AS "Banana",
'Land' REGEXP '(an)*' AS "Land",
'Cheese' REGEXP '(an)*' AS "Cheese";Resultaat:
+--------+------+--------+ | Banana | Land | Cheese | +--------+------+--------+ | 1 | 1 | 1 | +--------+------+--------+
Nog een voorbeeld:
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";Resultaat:
+--------+------+------+-----+ | Banana | Band | Bald | Bad | +--------+------+------+-----+ | 0 | 1 | 0 | 0 | +--------+------+------+-----+
Herhaling
Zoals te zien is in een eerder voorbeeld, kunt u accolades gebruiken om herhaling te specificeren. Deze notatie biedt een algemenere manier om reguliere expressies te schrijven dan sommige van de voorgaande voorbeelden:
SELECT
'Tweeet' REGEXP 'e{3}' AS "Tweeet",
'Tweet' REGEXP 'e{3}' AS "Tweet";Resultaat:
+--------+-------+ | Tweeet | Tweet | +--------+-------+ | 1 | 0 | +--------+-------+
Bereik
U kunt het koppelteken gebruiken om een bereik op te geven. Hier is een voorbeeld dat een reeks getallen specificeert:
SELECT
'Tweet 123' REGEXP '[0-9]' AS "Tweet 123",
'Tweet ABC' REGEXP '[0-9]' AS "Tweet ABC";Resultaat:
+--------+-------+ | Tweeet | Tweet | +--------+-------+ | 1 | 0 | +--------+-------+
En het volgende voorbeeld specificeert een reeks letters:
SELECT
'Tweet 123' REGEXP '[A-Z]' AS "Tweet 123",
'ABC' REGEXP '[A-Z]' AS "ABC",
'123' REGEXP '[A-Z]' AS "123";Resultaat:
+-----------+-----+-----+ | Tweet 123 | ABC | 123 | +-----------+-----+-----+ | 1 | 1 | 0 | +-----------+-----+-----+
Dit is wat er gebeurt als we het bereik van getallen beperken:
SELECT
'123' REGEXP '[1-3]' AS "123",
'012' REGEXP '[1-3]' AS "012",
'045' REGEXP '[1-3]' AS "045";Resultaat:
+-----+-----+-----+ | 123 | 012 | 045 | +-----+-----+-----+ | 1 | 1 | 0 | +-----+-----+-----+
Niet binnen bereik
We kunnen de ^ . gebruiken karakter om het vorige voorbeeld te wijzigen zodat het gespecificeerde bereik van karakters wordt uitgesloten:
SELECT
'123' REGEXP '[^1-3]' AS "123",
'012' REGEXP '[^1-3]' AS "012",
'045' REGEXP '[^1-3]' AS "045";Resultaat:
+-----+-----+-----+ | 123 | 012 | 045 | +-----+-----+-----+ | 0 | 1 | 1 | +-----+-----+-----+
In dit geval krijgen we het tegenovergestelde resultaat van het vorige voorbeeld.
Null-waarden
Als de uitdrukking of het patroon null is , het resultaat is null :
SELECT
null REGEXP 'Corn' AS "Corn",
'Acorn' REGEXP null AS "Acorn",
null REGEXP null AS "Corner";Resultaat:
+------+-------+--------+ | Corn | Acorn | Corner | +------+-------+--------+ | NULL | NULL | NULL | +------+-------+--------+