Come funziona REGEXP_REPLACE() in MariaDB

In MariaDB, il REGEXP_REPLACE() La funzione sostituisce le occorrenze della sottostringa all'interno di una stringa che corrisponde al modello di espressione regolare specificato.

L'intera stringa viene restituita insieme alle sostituzioni.

Se non c'è corrispondenza (cioè la stringa di input non contiene la sottostringa), l'intera stringa viene restituita invariata.

Sintassi

La sintassi è questa:

REGEXP_REPLACE(subject, pattern, replace)

Dove subject è la stringa di input, pattern è il modello di espressione regolare per la sottostringa e replace è la stringa sostitutiva.

Nota che, al momento della scrittura, la versione di MariaDB di REGEXP_REPLACE() accetta meno argomenti rispetto a REGEXP_REPLACE() di MySQL funzione. La versione di MySQL consente di fornire argomenti per la posizione iniziale della ricerca, quale occorrenza cercare, nonché un modo per perfezionare l'espressione regolare con il tipo di corrispondenza.

Esempio

Ecco un esempio di base dell'utilizzo di REGEXP_REPLACE() in MariaDB:

SELECT REGEXP_REPLACE('Cats and dogs', 'd.g', 'bird');

Risultato:

+------------------------------------------------+
| REGEXP_REPLACE('Cats and dogs', 'd.g', 'bird') |
+------------------------------------------------+
| Cats and birds                                 |
+------------------------------------------------+

In questo caso c'è una corrispondenza e la sottostringa viene sostituita con la stringa sostitutiva.

Le espressioni regolari possono essere molto potenti e questo esempio usa un esempio molto semplice. Per utilizzare REGEXP_REPLACE() in modo efficace, dovrai conoscere lo schema corretto da utilizzare per il risultato desiderato.

Partite multiple

Ecco un esempio con più corrispondenze:

SELECT REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird');

Risultato:

+----------------------------------------------------------+
| REGEXP_REPLACE('My dog likes other dogs', 'd.g', 'bird') |
+----------------------------------------------------------+
| My bird likes other birds                                |
+----------------------------------------------------------+

Nessuna corrispondenza

Ecco un esempio in cui non c'è corrispondenza:

SELECT REGEXP_REPLACE('Cats and dogs', 't.g', 'bird');

Risultato:

+------------------------------------------------+
| REGEXP_REPLACE('Cats and dogs', 't.g', 'bird') |
+------------------------------------------------+
| Cats and dogs                                  |
+------------------------------------------------+

Non c'è corrispondenza, quindi la stringa originale viene restituita invariata.

Maiuscole/minuscole

Il REGEXP_REPLACE() segue le regole di distinzione tra maiuscole e minuscole delle regole di confronto effettive. La corrispondenza viene eseguita senza distinzione tra maiuscole e minuscole per le regole di confronto senza distinzione tra maiuscole e minuscole e con distinzione tra maiuscole e minuscole per le regole di confronto con distinzione tra maiuscole e minuscole e per i dati binari.

Ecco un esempio:

SELECT 
    REGEXP_REPLACE('My Cats', 'c.t', 'dog') AS "My Default",
    REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_ci, 'c.t', 'dog') AS "Case Insensitive",
    REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_cs, 'c.t', 'dog') AS "Case Sensitive";

Risultato:

+------------+------------------+----------------+
| My Default | Case Insensitive | Case Sensitive |
+------------+------------------+----------------+
| My dogs    | My dogs          | My Cats        |
+------------+------------------+----------------+

Le mie regole di confronto predefinite non fanno distinzione tra maiuscole e minuscole. Le altre due stringhe sono state forzate rispettivamente a un confronto senza distinzione tra maiuscole e minuscole e con distinzione tra maiuscole e minuscole.

Fornire un BINARY string fa anche distinzione tra maiuscole e minuscole (ne parleremo più avanti).

Sostituisci sensibilità maiuscole/minuscole

La distinzione tra maiuscole e minuscole di confronto può essere ignorata utilizzando (?i ) e (?-i ) Flag PCRE.

Ecco l'esempio precedente, ma questa volta utilizzando il (?-i) flag su ogni pattern per forzare la distinzione tra maiuscole e minuscole:

SELECT 
    REGEXP_REPLACE('My Cats', '(?-i)c.t', 'dog') AS "My Default",
    REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_ci, '(?-i)c.t', 'dog') AS "Case Insensitive",
    REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_cs, '(?-i)c.t', 'dog') AS "Case Sensitive";

Risultato:

+------------+------------------+----------------+
| My Default | Case Insensitive | Case Sensitive |
+------------+------------------+----------------+
| My Cats    | My Cats          | My Cats        |
+------------+------------------+----------------+

E qui sta usando il (?i) flag per forzare la distinzione tra maiuscole e minuscole:

SELECT 
    REGEXP_REPLACE('My Cats', '(?i)c.t', 'dog') AS "My Default",
    REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_ci, '(?i)c.t', 'dog') AS "Case Insensitive",
    REGEXP_REPLACE(_latin7'My Cats' COLLATE latin7_general_cs, '(?i)c.t', 'dog') AS "Case Sensitive";

Risultato:

+------------+------------------+----------------+
| My Default | Case Insensitive | Case Sensitive |
+------------+------------------+----------------+
| My dogs    | My dogs          | My dogs        |
+------------+------------------+----------------+

Stringhe binarie

Passaggio di un BINARY string influisce anche sulla distinzione tra maiuscole e minuscole. Con BINARY stringhe, un carattere maiuscolo è diverso dalla sua controparte minuscola:

Esempio:

SELECT 
    REGEXP_REPLACE('My Cats', 'c.t', 'dog') AS "Character",
    REGEXP_REPLACE(BINARY 'My Cats', 'c.t', 'dog') AS "Binary";

Risultato:

+-----------+---------+
| Character | Binary  |
+-----------+---------+
| My dogs   | My Cats |
+-----------+---------+

Ecco cosa succede se cambiamo caso:

SELECT 
    REGEXP_REPLACE('My Cats', 'C.t', 'dog') AS "Character",
    REGEXP_REPLACE(BINARY 'My Cats', 'C.t', 'dog') AS "Binary";

Risultato:

+-----------+---------+
| Character | Binary  |
+-----------+---------+
| My dogs   | My dogs |
+-----------+---------+

Sensibilità tra maiuscole e minuscole su BINARY le stringhe possono anche essere sovrascritte con (?-i) e (?i) Flag PCRE:

SELECT 
    REGEXP_REPLACE('My Cats', '(?-i)c.t', 'dog') AS "Character",
    REGEXP_REPLACE(BINARY 'My Cats', '(?-i)c.t', 'dog') AS "Binary";

Risultato:

+-----------+---------+
| Character | Binary  |
+-----------+---------+
| My Cats   | My Cats |
+-----------+---------+

Argomenti nulli

Passaggio null poiché qualsiasi argomento risulta in null :

SELECT 
    REGEXP_REPLACE(null, 'c.t', 'dog') AS "1",
    REGEXP_REPLACE('Cat', null, 'dog') AS "2",
    REGEXP_REPLACE('Cat', 'c.t', null) AS "3",
    REGEXP_REPLACE(null, null, null) AS "4";

Risultato:

+------+------+------+------+
| 1    | 2    | 3    | 4    |
+------+------+------+------+
| NULL | NULL | NULL | NULL |
+------+------+------+------+

Numero di argomenti errato

Il passaggio di un numero errato di argomenti o di nessun argomento genera un errore:

SELECT REGEXP_REPLACE();

Risultato:

ERROR 1582 (42000): Incorrect parameter count in the call to native function 'REGEXP_REPLACE'