In MariaDB, il LIKE l'operatore consente di eseguire la corrispondenza dei modelli. Determina se una stringa di caratteri specifica corrisponde a un modello specificato. Restituisce 1 (TRUE) o 0 (FALSO).
Un modello può includere caratteri regolari, oltre al % e _ caratteri jolly.
Questi caratteri jolly sono spiegati nella tabella seguente.
| Carattere jolly | Descrizione |
|---|---|
% | Corrisponde a qualsiasi stringa di zero o più caratteri. Può essere utilizzato sia come prefisso che come suffisso e può essere utilizzato anche nel mezzo di una stringa. |
_ | Corrisponde a qualsiasi singolo carattere. |
Sintassi
La sintassi è questa:
expr LIKE pat [ESCAPE 'escape_char']Esempio
Supponiamo di avere la seguente tabella:
SELECT * FROM Pets;Risultato:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
Ecco un esempio per dimostrare come il LIKE operatore lavora.
SELECT *
FROM Pets
WHERE PetName LIKE 'F%';Risultato:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
In questo esempio, ho usato LIKE operatore in combinazione con il % operatore jolly per restituire animali il cui nome inizia con la lettera F .
Maiuscole/minuscole
LIKE esegue corrispondenze di sottostringhe senza distinzione tra maiuscole e minuscole se le regole di confronto per l'espressione e il modello non fanno distinzione tra maiuscole e minuscole.
Pertanto, possiamo modificare l'esempio precedente per utilizzare un f minuscolo , e ottieni sempre lo stesso risultato:
SELECT *
FROM Pets
WHERE PetName LIKE 'f%';Risultato:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
Tuttavia, possiamo forzare una corrispondenza con distinzione tra maiuscole e minuscole utilizzando il COLLATE clausola con regole di confronto binarie. In alternativa, puoi utilizzare CAST() per costringerlo a una stringa binaria.
Esempio:
SELECT *
FROM Pets
WHERE PetName LIKE 'f%' COLLATE utf8_bin;Risultato:
Empty set (0.000 sec)
Nessun risultato viene restituito.
Ma se lo cambiamo in una F maiuscola :
SELECT *
FROM Pets
WHERE PetName LIKE 'F%' COLLATE utf8_bin;Risultato:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
Otteniamo tre partite, come previsto.
Argomenti numerici
Gli argomenti numerici sono forzati a stringhe binarie.
SELECT *
FROM Pets
WHERE PetId LIKE 7;Risultato:
+-------+-----------+---------+---------+------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------+ | 7 | 3 | 2 | Bark | NULL | +-------+-----------+---------+---------+------+
Date
Ecco un esempio che corrisponde all'anno da una data:
SELECT *
FROM Pets
WHERE DOB LIKE '2020%';Risultato:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
Puoi anche usare il LIKE operatore rispetto al risultato di funzioni di data, come DAYNAME() , MONTHNAME() , ecc.
SELECT *
FROM Pets
WHERE MONTHNAME(DOB) LIKE 'Nov%';Risultato:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 5 | 1 | 1 | Tweet | 2020-11-28 | +-------+-----------+---------+---------+------------+
Il _ Operatore con caratteri jolly
Il trattino basso (_ ) l'operatore jolly corrisponde a qualsiasi singolo carattere.
Esempio:
SELECT *
FROM Pets
WHERE PetName LIKE '_e%';Risultato:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
In questo caso, abbiamo abbinato nomi di animali domestici in cui il secondo carattere è una e .
Il personaggio di fuga
A volte potresti trovarti nella situazione in cui devi cercare un trattino basso o un segno di percentuale. In questi casi, puoi utilizzare una barra rovesciata (\ ) per sfuggire a questi caratteri. Ciò impedirà che vengano interpretati come caratteri jolly.
Supponiamo di avere la seguente tabella:
SELECT * FROM Owners;Risultato:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 3 | Nancy | Simpson | (489) 591-0408 | NULL | | 4 | Boris | Trump | (349) 611-8908 | NULL | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+--------------------+
Nota che il proprietario 2 (Bart) ha un indirizzo email che contiene un trattino basso.
Ecco un esempio di cosa succede quando non lo facciamo sfuggire a un trattino basso:
SELECT * FROM Owners
WHERE Email LIKE 'b_%';Risultato:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+--------------------+
In questo caso, corrispondeva a due righe. In questo caso, non importava quale fosse il secondo personaggio:corrispondeva a qualsiasi carattere. Il fatto che la prima riga contenga un trattino basso per il secondo carattere è solo una coincidenza. Sarebbe stato compatibile anche se fosse stato qualcos'altro.
Ma cosa accadrebbe se volessimo abbinare solo quegli indirizzi email che hanno un trattino basso come secondo carattere?
È qui che entra in gioco il personaggio di fuga.
SELECT * FROM Owners
WHERE Email LIKE 'b\_%';Risultato:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | +---------+-----------+----------+----------------+--------------------+
Ora otteniamo solo una riga:la riga che contiene il carattere di sottolineatura come secondo carattere.
Modifica del carattere di escape
È possibile modificare il carattere di escape. Puoi farlo con ESCAPE argomento.
Esempio:
SELECT * FROM Owners
WHERE Email LIKE 'b*_%' ESCAPE '*';Risultato:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | +---------+-----------+----------+----------------+--------------------+
In questo caso ho assegnato l'asterisco (* ) come carattere di escape.
Ciò può essere particolarmente utile quando è necessario utilizzare la barra rovesciata per altri scopi, come la codifica di caratteri speciali. In questi casi, potresti trovarti a dover "fuggire due volte" da questi personaggi, il che potrebbe creare confusione. La modifica del carattere di escape può quindi essere d'aiuto in tali situazioni.
Valori NULL
La percentuale (% ) il carattere jolly corrisponde a qualsiasi cosa, quasi. Una cosa che non corrisponde è NULL .
SELECT * FROM Owners
WHERE Email LIKE '%';Risultato:
+---------+-----------+----------+----------------+--------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+--------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+--------------------+
Nella nostra tabella, ci sono due righe con NULL nella Email colonna, ma quelli non vengono restituiti qui.
Prestazioni
Query che contengono il LIKE operatore può essere eseguito molto più lentamente di altre query e probabilmente dovresti evitare di usare LIKE operatore a meno che tu non ne abbia davvero bisogno. Usando il % operatore come prefisso può essere particolarmente lento.
Questo non vuol dire che non dovresti usarlo affatto. Il LIKE operatore è parte integrante di SQL e incontrerai molti scenari in cui sarà l'unica opzione (o almeno, l'opzione migliore).
Il NOT LIKE Operatore
Puoi anche usare NOT LIKE per verificare se una stringa non abbinare un modello.
