In MySQL, il LIKE l'operatore esegue la corrispondenza dei modelli utilizzando un modello SQL.
Se la stringa corrisponde al modello fornito, il risultato è 1 , altrimenti è 0 .
Il modello non deve necessariamente essere una stringa letterale. Questa funzione può essere utilizzata con espressioni stringa e colonne di tabelle.
Sintassi
La sintassi è questa:
expr LIKE pat [ESCAPE 'escape_char']
Dove expr è la stringa di input e pat è il modello per il quale stai testando la stringa.
L'opzione ESCAPE La clausola consente di specificare un carattere di escape. Il carattere di escape predefinito è \ , quindi puoi omettere questa clausola se non è necessario modificarla.
Esempio 1 – Utilizzo di base
Ecco un esempio di come utilizzare questo operatore in un SELECT dichiarazione:
SELECT 'Charlie' LIKE 'Char%';
Risultato:
+------------------------+ | 'Charlie' LIKE 'Char%' | +------------------------+ | 1 | +------------------------+
In questo caso, il valore restituito è 1 il che significa che la stringa di input corrispondeva al modello. In particolare, abbiamo specificato che la stringa di input deve iniziare con Char e finisci con qualsiasi cosa. Il % il carattere corrisponde a qualsiasi numero di caratteri (inclusi zero caratteri).
Ecco cosa succede se eliminiamo il % :
SELECT 'Charlie' LIKE 'Char';
Risultato:
+-----------------------+ | 'Charlie' LIKE 'Char' | +-----------------------+ | 0 | +-----------------------+
Il risultato restituito è 0 il che significa nessuna corrispondenza. Questo perché non abbiamo utilizzato un carattere jolly per specificare altri caratteri.
Esempio 2 – Il _ Carattere jolly
Abbiamo anche la possibilità di utilizzare il _ carattere jolly per specificare un solo carattere. Ecco un esempio:
SELECT 'Charlie' LIKE 'Ch_rlie';
Risultato:
+--------------------------+ | 'Charlie' LIKE 'Ch_rlie' | +--------------------------+ | 1 | +--------------------------+
I due caratteri jolly possono essere combinati all'interno di uno schema, se necessario:
SELECT 'Charlie likes donuts' LIKE 'Ch_rlie%' AS 'Result';
Risultato:
+--------+ | Result | +--------+ | 1 | +--------+
Eccone altri:
SELECT 'Charlie likes donuts' LIKE 'Ch_rlie%donuts' AS 'Result 1', 'Charlie likes donuts' LIKE 'Ch_rlie%nuts' AS 'Result 2', 'Charlie likes donuts' LIKE 'Ch%rlie %likes %' AS 'Result 3', 'Charlie likes donuts' LIKE '% likes %' AS 'Result 4';
Risultato:
+----------+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | Result 4 | +----------+----------+----------+----------+ | 1 | 1 | 1 | 1 | +----------+----------+----------+----------+
Apportiamo alcune modifiche a quell'esempio in modo da poter vedere alcuni esempi di quando non corrispondono:
SELECT 'Charlie likes donuts' LIKE 'Ch%rlie_donuts' AS 'Result 1', 'Charlie likes donuts' LIKE 'Charlie_nuts' AS 'Result 2', 'Charlie likes donuts' LIKE 'Charlie _likes donuts' AS 'Result 3', 'Charlie likes donuts' LIKE '_ likes _' AS 'Result 4';
Risultato:
+----------+----------+----------+----------+ | Result 1 | Result 2 | Result 3 | Result 4 | +----------+----------+----------+----------+ | 0 | 0 | 0 | 0 | +----------+----------+----------+----------+
Esempio 3:un esempio di database
Il LIKE operatore è spesso usato all'interno di un WHERE clausola di un SELECT istruzione quando si interroga un database. Quando viene utilizzato in questo modo, restringe i risultati solo ai record che corrispondono, ma vediamo i risultati effettivi (non solo un 1 o 0 ).
Ecco un esempio di come possiamo utilizzare questo operatore all'interno di una query di database:
SELECT ArtistId, ArtistName FROM Artists WHERE ArtistName LIKE 'B%';
Risultato:
+----------+----------------+ | ArtistId | ArtistName | +----------+----------------+ | 4 | Buddy Rich | | 11 | Black Sabbath | | 15 | Birds of Tokyo | | 16 | Bodyjar | +----------+----------------+
In questo caso, si trattava di una semplice query che restituisce tutti gli artisti i cui nomi iniziano con la lettera B .
Ecco l'elenco completo degli artisti in quella tabella:
SELECT ArtistId, ArtistName FROM Artists;
Risultato:
+----------+------------------------+ | ArtistId | ArtistName | +----------+------------------------+ | 1 | Iron Maiden | | 2 | AC/DC | | 3 | Allan Holdsworth | | 4 | Buddy Rich | | 5 | Devin Townsend | | 6 | Jim Reeves | | 7 | Tom Jones | | 8 | Maroon 5 | | 9 | The Script | | 10 | Lit | | 11 | Black Sabbath | | 12 | Michael Learns to Rock | | 13 | Carabao | | 14 | Karnivool | | 15 | Birds of Tokyo | | 16 | Bodyjar | +----------+------------------------+
Esempio 4 – Fuga con il carattere barra rovesciata
Cosa succede se uno dei caratteri jolly è nella stringa di input e devi eseguire una corrispondenza contro di esso? Puoi eseguire l'escape con il carattere barra rovesciata (\ ). Ecco un esempio di tale ricerca con e senza il carattere di escape:
SELECT 'usr_123' LIKE 'usr_123' AS 'Without escape', 'usr_123' LIKE 'usr\_123' AS 'With escape';
Risultato:
+----------------+-------------+ | Without escape | With escape | +----------------+-------------+ | 1 | 1 | +----------------+-------------+
In questo caso, entrambi combaciavano, ma per ragioni diverse. La prima riga corrispondeva perché il carattere jolly specificava che qualsiasi carattere corrisponderà. Anche la seconda riga corrispondeva, ma solo perché la stringa di input aveva un trattino basso nel posto giusto.
Cambiamo leggermente la stringa di input in modo da ottenere un risultato diverso:
SELECT 'usr+123' LIKE 'usr_123' AS 'Without escape', 'usr+123' LIKE 'usr\_123' AS 'With escape';
Risultato:
+----------------+-------------+ | Without escape | With escape | +----------------+-------------+ | 1 | 0 | +----------------+-------------+
La versione senza caratteri di escape è risultata positiva, perché il carattere jolly significava che potevamo avere qualsiasi carattere in quel punto. La versione con escape affermava esplicitamente che solo il carattere di sottolineatura (_ ) corrisponderà. La stringa di input non aveva un carattere di sottolineatura in quel punto e quindi il risultato è stato negativo.
Esempio 5:ESCAPE Clausola
Puoi anche usare ESCAPE clausola per specificare il proprio carattere di escape personalizzato. Ecco un esempio:
SELECT 'usr_123' LIKE 'usr|_123' ESCAPE '|' AS 'String 1', 'usr+123' LIKE 'usr|_123' ESCAPE '|' AS 'String 2';
Risultato:
+----------+----------+ | String 1 | String 2 | +----------+----------+ | 1 | 0 | +----------+----------+
Esempio 6 – Espressioni numeriche
L'implementazione MySQL di LIKE consente di utilizzare espressioni numeriche. Ecco un esempio:
SELECT 1234 LIKE '12%', 1234 LIKE '12_';
Risultato:
+-----------------+-----------------+ | 1234 LIKE '12%' | 1234 LIKE '12_' | +-----------------+-----------------+ | 1 | 0 | +-----------------+-----------------+
