Como o REGEXP funciona no MariaDB

No MariaDB, o REGEXP O operador é usado para determinar se uma string corresponde ou não a uma expressão regular.

Se a string corresponder à expressão regular fornecida, o resultado será 1 , caso contrário é 0 .

Sintaxe

A sintaxe fica assim:

expr REGEXP pat

Onde expr é a string de entrada e pat é a expressão regular para a qual você está testando a string.

Exemplos

Abaixo estão exemplos de uso do REGEXP operador com padrões diferentes.

Expressão regular básica

Vamos começar com o exemplo mais simples. A expressão regular mais simples que podemos usar é aquela que não possui caracteres especiais. Aqui, usamos apenas uma string. Se qualquer parte da string de entrada corresponder a essa string, ela retornará uma correspondência.

SELECT 
  'Corn' REGEXP 'Corn' AS "Corn",
  'Acorn' REGEXP 'Corn' AS "Acorn",
  'Corner' REGEXP 'Corn' AS "Corner",
  'Cheese' REGEXP 'Corn' AS "Cheese";

Resultado:

+------+-------+--------+--------+
| Corn | Acorn | Corner | Cheese |
+------+-------+--------+--------+
|    1 |     1 |      1 |      0 |
+------+-------+--------+--------+

Corresponder ao início de uma string

Neste exemplo, a expressão regular especifica que a string deve começar com Co .

SELECT 
  'Corn' REGEXP '^Co' AS "Corn",
  'Acorn' REGEXP '^Co' AS "Acorn",
  'Cheese' REGEXP '^Co' AS "Cheese";

Resultado:

+------+-------+--------+
| Corn | Acorn | Cheese |
+------+-------+--------+
|    1 |     0 |      0 |
+------+-------+--------+

Corresponder ao final de uma string

Neste exemplo, a expressão regular especifica que a string deve terminar com rn .

SELECT 
  'Corn' REGEXP 'rn$' AS "Corn",
  'Acorn' REGEXP 'rn$' AS "Acorn",
  'Cheese' REGEXP 'rn$' AS "Cheese";

Resultado:

+------+-------+--------+
| Corn | Acorn | Cheese |
+------+-------+--------+
|    1 |     1 |      0 |
+------+-------+--------+

Corresponder a qualquer personagem

O . caractere corresponde a qualquer caractere.

SELECT 
  'Corn' REGEXP '.' AS "Corn",
  'Cheese' REGEXP '.' AS "Cheese",
  '' REGEXP '.' AS "";

Resultado:

+------+--------+---+
| Corn | Cheese |   |
+------+--------+---+
|    1 |      1 | 0 |
+------+--------+---+

Esse caractere é normalmente usado em conjunto com outros caracteres para especificar critérios adicionais. Por exemplo:

SELECT 
  'Corn' REGEXP '^C.rn$' AS "Corn", 
  'Crn' REGEXP '^C.rn$' AS "Crn";

Resultado:

+------+-----+
| Corn | Crn |
+------+-----+
|    1 |   0 |
+------+-----+

Aqui especificamos que a string deve começar com C , que deve ser seguido por um caractere (qualquer caractere) e que deve terminar com rn .

Observe que esse caractere especifica uma única instância do caractere. Se você quiser especificar várias instâncias (por exemplo ee em vez de apenas e ), você precisará adicionar mais . personagens.

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";

Resultado:

+-------+-------+-------+------+
| Tweet | Tweat | Tweet | Twit |
+-------+-------+-------+------+
|     1 |     1 |     0 |    0 |
+-------+-------+-------+------+

Outra maneira de fazer isso é especificar o número de ocorrências entre colchetes:

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";

Resultado:

+-------+-------+-------+------+
| Tweet | Tweat | Tweet | Twit |
+-------+-------+-------+------+
|     1 |     1 |     0 |    0 |
+-------+-------+-------+------+

No entanto, se você conhece o caractere que está procurando, pode especificar esse caractere (em vez do . caractere), conforme demonstrado no exemplo a seguir.

Corresponder a zero ou mais instâncias de um caractere específico

Podemos fazer o seguinte para especificar zero ou mais instâncias do e personagem:

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";

Resultado:

+------+-------+--------+-----+------+-------+-------+
| Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit |
+------+-------+--------+-----+------+-------+-------+
|    1 |     1 |      1 |   1 |    0 |     0 |     0 |
+------+-------+--------+-----+------+-------+-------+

As quatro primeiras partidas, mas as três últimas não.

Corresponder a uma ou mais instâncias de um caractere específico

Podemos modificar o exemplo anterior para obtermos uma correspondência apenas se um ou mais caracteres for encontrado (o exemplo anterior retornou uma correspondência se zero ou mais foram encontrados). Para fazer isso, simplesmente usamos + em vez de * :

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";

Resultado:

+------+-------+--------+-----+------+-------+-------+
| Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit |
+------+-------+--------+-----+------+-------+-------+
|    1 |     1 |      1 |   0 |    0 |     0 |     0 |
+------+-------+--------+-----+------+-------+-------+

Nesse caso, a quarta palavra retorna um resultado diferente do exemplo anterior.

Corresponder a zero ou uma instância de um caractere específico

Podemos modificar o exemplo anterior para que obtenhamos apenas uma correspondência em zero ou um dos caracteres desejados. Para fazer isso, usamos ? :

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";

Resultado:

+------+-------+--------+-----+------+-------+-------+
| Twet | Tweet | Tweeet | Twt | Twit | Twiet | Tweit |
+------+-------+--------+-----+------+-------+-------+
|    1 |     0 |      0 |   1 |    0 |     0 |     0 |
+------+-------+--------+-----+------+-------+-------+

Alternância

Você pode usar o | caractere para corresponder a uma ou outra sequência de caracteres:

SELECT 
  'Tweet' REGEXP 'Tw|et' AS "Tweet",
  'For Let' REGEXP 'Tw|et' AS "For Let",
  'Banana' REGEXP 'Tw|et' AS "Banana";

Resultado:

+-------+---------+--------+
| Tweet | For Let | Banana |
+-------+---------+--------+
|     1 |       1 |      0 |
+-------+---------+--------+

Aqui está outro exemplo em que pesquiso palavras inteiras:

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";

Resultado:

+-----+-----+---------+--------+
| Cat | Dog | Doggone | Banana |
+-----+-----+---------+--------+
|   1 |   1 |       1 |      0 |
+-----+-----+---------+--------+

Ainda obtemos uma correspondência mesmo quando nossa expressão regular corresponde apenas a parte da string.

Corresponder a zero ou mais instâncias de uma sequência

Você pode usar colchetes junto com o asterisco ()* para especificar zero ou mais instâncias de uma sequência:

SELECT 
  'Banana' REGEXP '(an)*' AS "Banana",
  'Land' REGEXP '(an)*' AS "Land",
  'Cheese' REGEXP '(an)*' AS "Cheese";

Resultado:

+--------+------+--------+
| Banana | Land | Cheese |
+--------+------+--------+
|      1 |    1 |      1 |
+--------+------+--------+

Outro exemplo:

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";

Resultado:

+--------+------+------+-----+
| Banana | Band | Bald | Bad |
+--------+------+------+-----+
|      0 |    1 |    0 |   0 |
+--------+------+------+-----+

Repetição

Como visto em um exemplo anterior, você pode usar chaves para especificar a repetição. Essa notação fornece uma maneira mais geral de escrever expressões regulares do que alguns dos exemplos anteriores:

SELECT 
  'Tweeet' REGEXP 'e{3}' AS "Tweeet",
  'Tweet' REGEXP 'e{3}' AS "Tweet";

Resultado:

+--------+-------+
| Tweeet | Tweet |
+--------+-------+
|      1 |     0 |
+--------+-------+

Intervalo

Você pode usar o caractere de hífen para especificar um intervalo. Aqui está um exemplo que especifica um intervalo de números:

SELECT 
  'Tweet 123' REGEXP '[0-9]' AS "Tweet 123",
  'Tweet ABC' REGEXP '[0-9]' AS "Tweet ABC";

Resultado:

+--------+-------+
| Tweeet | Tweet |
+--------+-------+
|      1 |     0 |
+--------+-------+

E o exemplo a seguir especifica um intervalo de letras:

SELECT 
  'Tweet 123' REGEXP '[A-Z]' AS "Tweet 123",
  'ABC' REGEXP '[A-Z]' AS "ABC",
  '123' REGEXP '[A-Z]' AS "123";

Resultado:

+-----------+-----+-----+
| Tweet 123 | ABC | 123 |
+-----------+-----+-----+
|         1 |   1 |   0 |
+-----------+-----+-----+

Aqui está o que acontece se limitarmos o intervalo de números:

SELECT 
  '123' REGEXP '[1-3]' AS "123",
  '012' REGEXP '[1-3]' AS "012",
  '045' REGEXP '[1-3]' AS "045";

Resultado:

+-----+-----+-----+
| 123 | 012 | 045 |
+-----+-----+-----+
|   1 |   1 |   0 |
+-----+-----+-----+

Fora de um intervalo

Podemos usar o ^ caractere para modificar o exemplo anterior para que o intervalo de caracteres especificado seja excluído:

SELECT 
  '123' REGEXP '[^1-3]' AS "123",
  '012' REGEXP '[^1-3]' AS "012",
  '045' REGEXP '[^1-3]' AS "045";

Resultado:

+-----+-----+-----+
| 123 | 012 | 045 |
+-----+-----+-----+
|   0 |   1 |   1 |
+-----+-----+-----+

Neste caso obtemos o resultado oposto ao exemplo anterior.

Valores nulos

Se a expressão ou o padrão for null , o resultado é null :

SELECT 
  null REGEXP 'Corn' AS "Corn",
  'Acorn' REGEXP null AS "Acorn",
  null REGEXP null AS "Corner";

Resultado:

+------+-------+--------+
| Corn | Acorn | Corner |
+------+-------+--------+
| NULL |  NULL |   NULL |
+------+-------+--------+