In MariaDB, il NOT LIKE operatore viene utilizzato per verificare se una stringa non è o meno abbinare un modello. Restituisce l'inverso del LIKE operatore. È come applicare il NOT operatore contro l'intero LIKE espressione.
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 NOT 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 di utilizzo di NOT LIKE contro quel tavolo:
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%';Risultato:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
In questo esempio, ho usato NOT LIKE insieme al % operatore con caratteri jolly per restituire animali il cui nome non inizia con la lettera F .
Questo è il set di risultati opposto che avremmo ottenuto se avessimo usato solo LIKE . In tal caso, otterremmo risultati solo in cui il nome dell'animale inizia con la lettera F .
Maiuscole/minuscole
NOT 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 NOT LIKE 'f%';Risultato:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
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 NOT 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 | | 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 | +-------+-----------+---------+---------+------------+
Questa volta, l'intero tavolo è stato restituito. Questo perché niente corrispondeva al f minuscolo .
Ma se lo cambiamo in una F maiuscola :
SELECT *
FROM Pets
WHERE PetName NOT LIKE 'F%' COLLATE utf8_bin;Risultato:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +-------+-----------+---------+---------+------------+
Otteniamo cinque partite, come previsto. Le righe in cui il nome dell'animale domestico inizia con F sono esclusi.
Argomenti numerici
Gli argomenti numerici sono forzati a stringhe binarie.
SELECT *
FROM Pets
WHERE PetId NOT LIKE 1;Risultato:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 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 | +-------+-----------+---------+---------+------------+
Date
Ecco un esempio di data:
SELECT *
FROM Pets
WHERE DOB NOT LIKE '2020%';Risultato:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | +-------+-----------+---------+---------+------------+
Puoi anche usare il NOT LIKE operatore rispetto al risultato di funzioni di data, come DAYNAME() , MONTHNAME() , ecc.
SELECT *
FROM Pets
WHERE MONTHNAME(DOB) NOT LIKE 'Nov%';Risultato:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | +-------+-----------+---------+---------+------------+
Il _ Operatore con caratteri jolly
Il trattino basso (_ ) l'operatore jolly corrisponde a qualsiasi singolo carattere.
Esempio:
SELECT *
FROM Pets
WHERE PetName NOT LIKE '_e%';Risultato:
+-------+-----------+---------+---------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | +-------+-----------+---------+---------+------------+ | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 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 | +-------+-----------+---------+---------+------------+
In questo caso, abbiamo restituito nomi di animali domestici in cui il secondo carattere è non un 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 NOT LIKE 'b_%';Risultato:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | +---------+-----------+----------+----------------+-------------------+
In questo caso, ha restituito solo due righe. Sono state escluse le due righe in cui l'indirizzo email inizia con un b , ed è seguito da un altro carattere, quindi da un numero qualsiasi di caratteri. Sono state inoltre escluse le righe con null indirizzo email.
Tuttavia, poiché non siamo sfuggiti al carattere di sottolineatura, 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 NOT LIKE 'b\_%';Risultato:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+-------------------+
Possiamo vedere che Burt è stato aggiunto ai risultati.
Modifica del carattere di escape
È possibile modificare il carattere di escape. Puoi farlo con ESCAPE argomento.
Esempio:
SELECT * FROM Owners
WHERE Email NOT LIKE 'b*_%' ESCAPE '*';Risultato:
+---------+-----------+----------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | +---------+-----------+----------+----------------+-------------------+ | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +---------+-----------+----------+----------------+-------------------+
In questo caso ho assegnato l'asterisco (* ) come carattere di escape.
Questo può essere 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.
