V MariaDB, REGEXP operátor se používá k určení, zda řetězec odpovídá regulárnímu výrazu.
Pokud řetězec odpovídá zadanému regulárnímu výrazu, výsledek je 1 , jinak je to 0 .
Syntaxe
Syntaxe vypadá takto:
expr REGEXP pat
Kde expr je vstupní řetězec a pat je regulární výraz, pro který řetězec testujete.
Příklady
Níže jsou uvedeny příklady použití REGEXP operátor s různými vzory.
Základní regulární výraz
Začněme tím nejjednodušším příkladem. Nejjednodušší regulární výraz, který můžeme použít, je ten, který neobsahuje žádné speciální znaky. Zde použijeme pouze řetězec. Pokud se jakákoli část vstupního řetězce shoduje s tímto řetězcem, vrátí shodu.
SELECT
'Corn' REGEXP 'Corn' AS "Corn",
'Acorn' REGEXP 'Corn' AS "Acorn",
'Corner' REGEXP 'Corn' AS "Corner",
'Cheese' REGEXP 'Corn' AS "Cheese";Výsledek:
+------+-------+--------+--------+ | Corn | Acorn | Corner | Cheese | +------+-------+--------+--------+ | 1 | 1 | 1 | 0 | +------+-------+--------+--------+
Shodovat se se začátkem řetězce
V tomto příkladu regulární výraz určuje, že řetězec musí začínat Co .
SELECT
'Corn' REGEXP '^Co' AS "Corn",
'Acorn' REGEXP '^Co' AS "Acorn",
'Cheese' REGEXP '^Co' AS "Cheese";Výsledek:
+------+-------+--------+ | Corn | Acorn | Cheese | +------+-------+--------+ | 1 | 0 | 0 | +------+-------+--------+
Přizpůsobit konec řetězce
V tomto příkladu regulární výraz určuje, že řetězec musí končit rn .
SELECT
'Corn' REGEXP 'rn$' AS "Corn",
'Acorn' REGEXP 'rn$' AS "Acorn",
'Cheese' REGEXP 'rn$' AS "Cheese";Výsledek:
+------+-------+--------+ | Corn | Acorn | Cheese | +------+-------+--------+ | 1 | 1 | 0 | +------+-------+--------+
Odpovídají libovolnému znaku
. znak odpovídá libovolnému znaku.
SELECT
'Corn' REGEXP '.' AS "Corn",
'Cheese' REGEXP '.' AS "Cheese",
'' REGEXP '.' AS "";Výsledek:
+------+--------+---+ | Corn | Cheese | | +------+--------+---+ | 1 | 1 | 0 | +------+--------+---+
Tento znak se obvykle používá ve spojení s jinými znaky k určení dalších kritérií. Například:
SELECT
'Corn' REGEXP '^C.rn$' AS "Corn",
'Crn' REGEXP '^C.rn$' AS "Crn";Výsledek:
+------+-----+ | Corn | Crn | +------+-----+ | 1 | 0 | +------+-----+
Zde určíme, že řetězec musí začínat C , že za ním musí následovat znak (jakýkoli znak) a že musí končit rn .
Všimněte si, že tento znak určuje jednu instanci znaku. Pokud chcete zadat více instancí (například ee místo pouhého e ), budete muset přidat další . znaky.
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";Výsledek:
+-------+-------+-------+------+ | Tweet | Tweat | Tweet | Twit | +-------+-------+-------+------+ | 1 | 1 | 0 | 0 | +-------+-------+-------+------+
Dalším způsobem, jak toho dosáhnout, je zadat počet výskytů ve složených závorkách:
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";Výsledek:
+-------+-------+-------+------+ | Tweet | Tweat | Tweet | Twit | +-------+-------+-------+------+ | 1 | 1 | 0 | 0 | +-------+-------+-------+------+
Pokud však znáte znak, který hledáte, můžete jej zadat (místo . znak), jak ukazuje následující příklad.
Odpovídají nule nebo více instancím konkrétní postavy
Pro specifikaci nula nebo více instancí e můžeme provést následující postava:
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";Výsledek:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 1 | 1 | 1 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
První čtyři se shodují, ale poslední tři nikoli.
Shodujte se s jednou nebo více instancemi konkrétní postavy
Předchozí příklad můžeme upravit tak, že dostaneme shodu pouze pokud jeden nebo bylo nalezeno více znaků (předchozí příklad vrátil shodu, pokud nula nebo jich bylo nalezeno více). K tomu jednoduše použijeme + místo * :
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";Výsledek:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 1 | 1 | 0 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
V tomto případě čtvrté slovo vrátí výsledek odlišný od předchozího příkladu.
Odpovídá nule nebo jedné instanci konkrétní postavy
Předchozí příklad můžeme upravit tak, že získáme shodu pouze na nule nebo na jednom z požadovaných znaků. K tomu používáme ? :
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";Výsledek:
+------+-------+--------+-----+------+-------+-------+ | Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit | +------+-------+--------+-----+------+-------+-------+ | 1 | 0 | 0 | 1 | 0 | 0 | 0 | +------+-------+--------+-----+------+-------+-------+
Střídání
Můžete použít | znak, který odpovídá jedné nebo jiné sekvenci znaků:
SELECT
'Tweet' REGEXP 'Tw|et' AS "Tweet",
'For Let' REGEXP 'Tw|et' AS "For Let",
'Banana' REGEXP 'Tw|et' AS "Banana";Výsledek:
+-------+---------+--------+ | Tweet | For Let | Banana | +-------+---------+--------+ | 1 | 1 | 0 | +-------+---------+--------+
Zde je další příklad, kde hledám celá slova:
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";Výsledek:
+-----+-----+---------+--------+ | Cat | Dog | Doggone | Banana | +-----+-----+---------+--------+ | 1 | 1 | 1 | 0 | +-----+-----+---------+--------+
Stále získáme shodu, i když se náš regulární výraz shoduje pouze s částí řetězce.
Shoda s nulou nebo více instancemi sekvence
Můžete použít závorky spolu s hvězdičkou ()* pro určení nula nebo více instancí sekvence:
SELECT
'Banana' REGEXP '(an)*' AS "Banana",
'Land' REGEXP '(an)*' AS "Land",
'Cheese' REGEXP '(an)*' AS "Cheese";Výsledek:
+--------+------+--------+ | Banana | Land | Cheese | +--------+------+--------+ | 1 | 1 | 1 | +--------+------+--------+
Další příklad:
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";Výsledek:
+--------+------+------+-----+ | Banana | Band | Bald | Bad | +--------+------+------+-----+ | 0 | 1 | 0 | 0 | +--------+------+------+-----+
Opakování
Jak je vidět v předchozím příkladu, k určení opakování můžete použít složené závorky. Tento zápis poskytuje obecnější způsob psaní regulárních výrazů než některé z předchozích příkladů:
SELECT
'Tweeet' REGEXP 'e{3}' AS "Tweeet",
'Tweet' REGEXP 'e{3}' AS "Tweet";Výsledek:
+--------+-------+ | Tweeet | Tweet | +--------+-------+ | 1 | 0 | +--------+-------+
Rozsah
K určení rozsahu můžete použít znak pomlčky. Zde je příklad, který specifikuje rozsah čísel:
SELECT
'Tweet 123' REGEXP '[0-9]' AS "Tweet 123",
'Tweet ABC' REGEXP '[0-9]' AS "Tweet ABC";Výsledek:
+--------+-------+ | Tweeet | Tweet | +--------+-------+ | 1 | 0 | +--------+-------+
A následující příklad specifikuje rozsah písmen:
SELECT
'Tweet 123' REGEXP '[A-Z]' AS "Tweet 123",
'ABC' REGEXP '[A-Z]' AS "ABC",
'123' REGEXP '[A-Z]' AS "123";Výsledek:
+-----------+-----+-----+ | Tweet 123 | ABC | 123 | +-----------+-----+-----+ | 1 | 1 | 0 | +-----------+-----+-----+
Pokud omezíme rozsah čísel, stane se toto:
SELECT
'123' REGEXP '[1-3]' AS "123",
'012' REGEXP '[1-3]' AS "012",
'045' REGEXP '[1-3]' AS "045";Výsledek:
+-----+-----+-----+ | 123 | 012 | 045 | +-----+-----+-----+ | 1 | 1 | 0 | +-----+-----+-----+
Není v rozsahu
Můžeme použít ^ znak pro úpravu předchozího příkladu tak, aby byl vyloučen zadaný rozsah znaků:
SELECT
'123' REGEXP '[^1-3]' AS "123",
'012' REGEXP '[^1-3]' AS "012",
'045' REGEXP '[^1-3]' AS "045";Výsledek:
+-----+-----+-----+ | 123 | 012 | 045 | +-----+-----+-----+ | 0 | 1 | 1 | +-----+-----+-----+
V tomto případě dostaneme opačný výsledek než v předchozím příkladu.
Nulové hodnoty
Pokud je výraz nebo vzor null , výsledkem je null :
SELECT
null REGEXP 'Corn' AS "Corn",
'Acorn' REGEXP null AS "Acorn",
null REGEXP null AS "Corner";Výsledek:
+------+-------+--------+ | Corn | Acorn | Corner | +------+-------+--------+ | NULL | NULL | NULL | +------+-------+--------+