I MariaDB er REGEXP operator bruges til at bestemme, om en streng matcher et regulært udtryk.
Hvis strengen matcher det angivne regulære udtryk, er resultatet 1 , ellers er det 0 .
Syntaks
Syntaksen ser sådan ud:
expr REGEXP pat
Hvor expr er inputstrengen og pat er det regulære udtryk, som du tester strengen for.
Eksempler
Nedenfor er eksempler på brug af REGEXP operatør med forskellige mønstre.
Grundlæggende regulært udtryk
Lad os starte med det enkleste eksempel. Det enkleste regulære udtryk, vi kan bruge, er et, der ikke har nogen specielle tegn. Her bruger vi bare en snor. Hvis en del af inputstrengen matcher denne streng, returnerer den et match.
SELECT
'Corn' REGEXP 'Corn' AS "Corn",
'Acorn' REGEXP 'Corn' AS "Acorn",
'Corner' REGEXP 'Corn' AS "Corner",
'Cheese' REGEXP 'Corn' AS "Cheese";Resultat:
+------+-------+--------+--------+ | Corn | Acorn | Corner | Cheese | +------+-------+--------+--------+ | 1 | 1 | 1 | 0 | +------+-------+--------+--------+
Match begyndelsen af en streng
I dette eksempel angiver det regulære udtryk, at strengen skal begynde med Co .
SELECT
'Corn' REGEXP '^Co' AS "Corn",
'Acorn' REGEXP '^Co' AS "Acorn",
'Cheese' REGEXP '^Co' AS "Cheese";Resultat:
+------+-------+--------+ | Corn | Acorn | Cheese | +------+-------+--------+ | 1 | 0 | 0 | +------+-------+--------+
Match slutningen af en streng
I dette eksempel angiver det regulære udtryk, at strengen skal slutte med rn .
SELECT
'Corn' REGEXP 'rn$' AS "Corn",
'Acorn' REGEXP 'rn$' AS "Acorn",
'Cheese' REGEXP 'rn$' AS "Cheese";Resultat:
+------+-------+--------+ | Corn | Acorn | Cheese | +------+-------+--------+ | 1 | 1 | 0 | +------+-------+--------+
Match ethvert tegn
SELECT
'Corn' REGEXP '.' AS "Corn",
'Cheese' REGEXP '.' AS "Cheese",
'' REGEXP '.' AS "";Resultat:
+------+--------+---+ | Corn | Cheese | | +------+--------+---+ | 1 | 1 | 0 | +------+--------+---+
Dette tegn bruges typisk sammen med andre tegn til at specificere yderligere kriterier. For eksempel:
SELECT
'Corn' REGEXP '^C.rn$' AS "Corn",
'Crn' REGEXP '^C.rn$' AS "Crn";Resultat:
+------+-----+ | Corn | Crn | +------+-----+ | 1 | 0 | +------+-----+
Her angiver vi, at strengen skal starte med C , at det skal efterfølges af et tegn (et hvilket som helst tegn), og at det skal slutte med rn .
Bemærk, at dette tegn angiver en enkelt forekomst af tegnet. Hvis du ønsker at angive flere forekomster (for eksempel ee i stedet for blot e ), skal du tilføje mere . tegn.
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";Resultat:
+-------+-------+-------+------+ | Tweet | Tweat | Tweet | Twit | +-------+-------+-------+------+ | 1 | 1 | 0 | 0 | +-------+-------+-------+------+
En anden måde at gøre dette på er at angive antallet af forekomster inden for krøllede parenteser:
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";Resultat:
+-------+-------+-------+------+ | Tweet | Tweat | Tweet | Twit | +-------+-------+-------+------+ | 1 | 1 | 0 | 0 | +-------+-------+-------+------+
Men hvis du kender det tegn, du leder efter, kan du angive dette tegn (i stedet for . tegn), som vist i følgende eksempel.
Match nul eller flere forekomster af en bestemt karakter
Vi kan gøre følgende for at angive nul eller flere forekomster af e tegn:
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";Resultat:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 1 | 1 | 1 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
De første fire matcher, men de sidste tre gør det ikke.
Match en eller flere forekomster af en bestemt karakter
Vi kan ændre det foregående eksempel, så vi kun får et match, hvis en eller flere tegn er fundet (det forrige eksempel returnerede et match, hvis nul). eller flere blev fundet). For at gøre dette bruger vi blot + i stedet for * :
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";Resultat:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 1 | 1 | 0 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
I dette tilfælde returnerer det fjerde ord et andet resultat end det foregående eksempel.
Match nul eller én forekomst af et specifikt tegn
Vi kan ændre det foregående eksempel, så vi kun får et match på nul eller et af de ønskede tegn. For at gøre dette bruger vi ? :
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";Resultat:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 0 | 0 | 1 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
Alternativ
Du kan bruge | tegn, der matcher en eller anden sekvens af tegn:
SELECT
'Tweet' REGEXP 'Tw|et' AS "Tweet",
'For Let' REGEXP 'Tw|et' AS "For Let",
'Banana' REGEXP 'Tw|et' AS "Banana";Resultat:
+-------+---------+--------+ | Tweet | For Let | Banana | +-------+---------+--------+ | 1 | 1 | 0 | +-------+---------+--------+
Her er et andet eksempel, hvor jeg søger efter hele ord:
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";Resultat:
+-----+-----+---------+--------+ | Cat | Dog | Doggone | Banana | +-----+-----+---------+--------+ | 1 | 1 | 1 | 0 | +-----+-----+---------+--------+
Vi får stadig et match, selvom vores regulære udtryk kun matcher en del af strengen.
Match nul eller flere forekomster af en sekvens
Du kan bruge parenteser sammen med stjernen ()* for at angive nul eller flere forekomster af en sekvens:
SELECT
'Banana' REGEXP '(an)*' AS "Banana",
'Land' REGEXP '(an)*' AS "Land",
'Cheese' REGEXP '(an)*' AS "Cheese";Resultat:
+--------+------+--------+ | Banana | Land | Cheese | +--------+------+--------+ | 1 | 1 | 1 | +--------+------+--------+
Et andet eksempel:
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";Resultat:
+--------+------+------+-----+ | Banana | Band | Bald | Bad | +--------+------+------+-----+ | 0 | 1 | 0 | 0 | +--------+------+------+-----+
Gentagelse
Som set i et tidligere eksempel kan du bruge krøllede parenteser til at angive gentagelse. Denne notation giver en mere generel måde at skrive regulære udtryk på end nogle af de foregående eksempler:
SELECT
'Tweeet' REGEXP 'e{3}' AS "Tweeet",
'Tweet' REGEXP 'e{3}' AS "Tweet";Resultat:
+--------+-------+ | Tweeet | Tweet | +--------+-------+ | 1 | 0 | +--------+-------+
Rækkevidde
Du kan bruge bindestregen til at angive et område. Her er et eksempel, der specificerer en række tal:
SELECT
'Tweet 123' REGEXP '[0-9]' AS "Tweet 123",
'Tweet ABC' REGEXP '[0-9]' AS "Tweet ABC";Resultat:
+--------+-------+ | Tweeet | Tweet | +--------+-------+ | 1 | 0 | +--------+-------+
Og det følgende eksempel angiver en række bogstaver:
SELECT
'Tweet 123' REGEXP '[A-Z]' AS "Tweet 123",
'ABC' REGEXP '[A-Z]' AS "ABC",
'123' REGEXP '[A-Z]' AS "123";Resultat:
+-----------+-----+-----+ | Tweet 123 | ABC | 123 | +-----------+-----+-----+ | 1 | 1 | 0 | +-----------+-----+-----+
Her er, hvad der sker, hvis vi begrænser antallet af tal:
SELECT
'123' REGEXP '[1-3]' AS "123",
'012' REGEXP '[1-3]' AS "012",
'045' REGEXP '[1-3]' AS "045";Resultat:
+-----+-----+-----+ | 123 | 012 | 045 | +-----+-----+-----+ | 1 | 1 | 0 | +-----+-----+-----+
Ikke inden for et område
Vi kan bruge ^ tegn for at ændre det foregående eksempel, så det angivne antal tegn udelukkes:
SELECT
'123' REGEXP '[^1-3]' AS "123",
'012' REGEXP '[^1-3]' AS "012",
'045' REGEXP '[^1-3]' AS "045";Resultat:
+-----+-----+-----+ | 123 | 012 | 045 | +-----+-----+-----+ | 0 | 1 | 1 | +-----+-----+-----+
I dette tilfælde får vi det modsatte resultat af det foregående eksempel.
Nul-værdier
Hvis enten udtrykket eller mønsteret er null , resultatet er null :
SELECT
null REGEXP 'Corn' AS "Corn",
'Acorn' REGEXP null AS "Acorn",
null REGEXP null AS "Corner";Resultat:
+------+-------+--------+ | Corn | Acorn | Corner | +------+-------+--------+ | NULL | NULL | NULL | +------+-------+--------+