In SQL, un operatore è un carattere speciale o una parola chiave che specifica un'azione eseguita su una o più espressioni.
Gli operatori SQL sono parte integrante di SQL e ci consentono di scrivere query che restituiscono risultati rilevanti.
In questo articolo, presento 12 degli operatori SQL più comunemente usati durante la scrittura di query SQL.
The Equals (= ) Operatore
L'operatore Uguale (= ) è probabilmente l'operatore più comunemente usato in SQL. Confronta l'uguaglianza di due espressioni. Anche se hai una vaga familiarità con SQL, probabilmente conoscerai questo operatore.
Immagina di avere un database per un hotel per animali domestici e di voler ottenere informazioni su tutti gli animali domestici di nome Fluffy.
In tal caso, potremmo fare questo:
SELECT PetId, PetName, DOB
FROM Pets
WHERE PetName = 'Fluffy';Risultato:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | +---------+-----------+------------+
La nostra query utilizza l'operatore Uguale (= ) per confrontare l'uguaglianza del valore di PetName colonna e la stringa Fluffy .
Nel nostro caso, possiamo vedere che l'hotel per animali domestici ha attualmente due animali chiamati Fluffy.
Il maggiore di (> ) Operatore
L'operatore Maggiore di (> ) confronta due espressioni e restituisce TRUE se l'operando di sinistra ha un valore maggiore dell'operando di destra; in caso contrario, il risultato è FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB > '2020-01-01';Risultato:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
In questo caso, sta confrontando il valore del DOB colonna e la data 2020-01-01 per vedere se il DOB la colonna è maggiore.
Meno di (< ) Operatore
L'operatore Minore di (< ) fa il contrario. Confronta due espressioni e restituisce TRUE se l'operando di sinistra ha un valore inferiore all'operando di destra; in caso contrario, il risultato è FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB < '2020-01-01';Risultato:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Il maggiore o uguale a (>= ) Operatore
L'operatore Maggiore di o Uguale a (>= ) confronta due espressioni e restituisce TRUE se l'operando di sinistra ha un valore maggiore o uguale all'operando di destra; in caso contrario, restituisce FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB >= '2020-09-17';Risultato:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Nota che ha restituito 2020-09-17 e tutte le date maggiori di quella. Se avessimo utilizzato l'operatore Maggiore di (> ), sarebbero state restituite solo le prime due righe.
Il minore o uguale a (<= ) Operatore
L'operatore Minore di o Uguale a (<= ) confronta due espressioni e restituisce TRUE se l'operando di sinistra ha un valore inferiore o uguale all'operando di destra; in caso contrario, il risultato è FALSE .
SELECT PetName, DOB
FROM Pets
WHERE DOB <= '2020-09-17';Risultato:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | | Wag | 2020-03-15 | | Fluffy | 2020-09-17 | +-----------+------------+
Nota che ha restituito 2020-09-17 e tutte le date inferiori a quella. Se avessimo utilizzato l'operatore Minore di (< ), sarebbero state restituite solo le prime tre righe.
Il AND Operatore
Il AND combina due espressioni booleane e restituisce TRUE quando entrambe le espressioni sono TRUE .
Ecco un esempio.
SELECT PetId, DOB
FROM Pets
WHERE PetName = 'Fluffy'
AND DOB > '2020-01-01';Risultato:
+---------+------------+ | PetId | DOB | |---------+------------| | 1 | 2020-11-20 | | 6 | 2020-09-17 | +---------+------------+
In questo caso, otteniamo solo i dettagli degli animali domestici il cui nome è Fluffy e la loro data di nascita è compresa tra le due date.
Il OR Operatore
Il OR combina due espressioni booleane e restituisce TRUE quando una delle condizioni è TRUE .
Ecco un esempio.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy' OR PetName = 'Bark';Risultato:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Questo è fondamentalmente l'opposto di AND operatore. Se avessimo usato AND , nessuna riga sarebbe stata restituita, perché non possiamo avere due valori diversi in una colonna contemporaneamente.
Il BETWEEN Operatore
Il BETWEEN operatore ci consente di specificare un intervallo da testare. Ad esempio, possiamo usarlo per restituire animali nati tra due date.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB BETWEEN '2018-01-01' AND '2020-01-01';Risultato:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fetch | 2019-08-16 | | Scratch | 2018-10-01 | +-----------+------------+
Il NOT Operatore
Il NOT nega un input booleano (inverte il valore di qualsiasi espressione booleana). Quindi restituisce TRUE quando l'espressione è FALSE .
Ecco cosa succede quando aggiungiamo NOT operatore al nostro esempio precedente.
SELECT
PetName,
DOB
FROM Pets
WHERE DOB NOT BETWEEN '2018-01-01' AND '2020-01-01';Risultato:
+-----------+------------+ | PetName | DOB | |-----------+------------| | Fluffy | 2020-11-20 | | Wag | 2020-03-15 | | Tweet | 2020-11-28 | | Fluffy | 2020-09-17 | +-----------+------------+
Questa volta abbiamo preso tutti gli altri animali domestici, gli animali domestici che non erano nato tra quelle date.
In MariaDB, NOT si limita a negare il IN , BETWEEN e EXISTS clausole. La maggior parte degli altri DBMS consente NOT per negare qualsiasi espressione.
Il IN Operatore
Il IN determina se un valore specificato corrisponde a qualsiasi valore in una sottoquery o in un elenco.
Ecco un esempio.
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName IN ('Fluffy', 'Bark', 'Wag');Risultato:
+---------+-----------+------------+ | PetId | PetName | DOB | |---------+-----------+------------| | 1 | Fluffy | 2020-11-20 | | 4 | Wag | 2020-03-15 | | 6 | Fluffy | 2020-09-17 | | 7 | Bark | NULL | +---------+-----------+------------+
Potremmo ottenere lo stesso risultato usando due OR operatori:
SELECT
PetId,
PetName,
DOB
FROM Pets
WHERE PetName = 'Fluffy'
OR PetName = 'Bark'
OR PetName = 'Wag';
Tuttavia, il IN operatore è un modo più conciso per farlo. Il IN operatore è particolarmente utile quando si dispone di un lungo elenco di valori con cui confrontare.
Il IN l'operatore viene quasi sempre eseguito più velocemente di più OR operatori, soprattutto su set di dati più grandi.
Un altro vantaggio del IN operatore, è che può contenere un altro SELECT elenco. Questa è nota come subquery . Una sottoquery è una query nidificata all'interno di un'altra query (o anche di un'altra sottoquery).
Ecco un esempio.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId IN ( SELECT PetTypeId FROM Pets );Risultato:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 1 | Bird | | 2 | Cat | | 3 | Dog | +-------------+-----------+
Questo esempio ci mostra quanti tipi di animali sono presenti nel nostro hotel per animali domestici.
Potremmo usare il NOT operatore per capovolgerlo e vedere quanti tipi di animali non sono nel nostro hotel per animali domestici.
SELECT
PetTypeId,
PetType
FROM PetTypes
WHERE PetTypeId NOT IN ( SELECT PetTypeId FROM Pets );Risultato:
+-------------+-----------+ | PetTypeId | PetType | |-------------+-----------| | 4 | Rabbit | +-------------+-----------+
Quindi il nostro database contiene un tipo di animale domestico di Rabbit , ma al momento non abbiamo conigli come animali domestici.
Il + e || Operatori di concatenazione di stringhe
Il + e || Gli operatori di concatenazione di stringhe consentono di concatenare le stringhe. La concatenazione di stringhe è l'operazione di unione di stringhe di caratteri end-to-end.
Il motivo per cui ho elencato due operatori che fanno la stessa cosa è perché + è supportato in SQL Server e || operatore è supportato in DB2, Oracle, PostgreSQL, SQLite.
Ecco un esempio che funziona in SQL Server.
SELECT
FirstName,
LastName,
FirstName + LastName
FROM Owners;Risultato:
+-------------+------------+--------------------+ | FirstName | LastName | (No column name) | |-------------+------------+--------------------| | Homer | Connery | HomerConnery | | Bart | Pitt | BartPitt | | Nancy | Simpson | NancySimpson | | Boris | Trump | BorisTrump | +-------------+------------+--------------------+
In questo caso, i proprietari hanno il loro nome e cognome memorizzati in colonne diverse. Nel nostro SELECT list, prima li recuperiamo singolarmente, ma li recuperiamo anche di nuovo, utilizzando un operatore di concatenazione per unirli insieme.
Tuttavia, ci sono un paio di problemi con i nostri risultati.
- Non c'è spazio tra il nome e il cognome.
- Non esiste un nome di colonna.
Fortunatamente è facile da risolvere.
Possiamo usare la stessa operazione di concatenazione per includere lo spazio tra il nome e il cognome.
E possiamo utilizzare un alias di colonna per il risultato concatenato per fornire un nome di colonna nel set di risultati.
SELECT
FirstName,
LastName,
FirstName + ' ' + LastName AS FullName
FROM Owners;Risultato:
+-------------+------------+---------------+ | FirstName | LastName | FullName | |-------------+------------+---------------| | Homer | Connery | Homer Connery | | Bart | Pitt | Bart Pitt | | Nancy | Simpson | Nancy Simpson | | Boris | Trump | Boris Trump | +-------------+------------+---------------+
Se stai usando DB2, Oracle, PostgreSQL, SQLite, scambia il + per || e dovrebbe funzionare bene.
Se stai usando MySQL o MariaDB, dovrai usare CONCAT() funzione per concatenare le stringhe.
Il LIKE Operatore
Il LIKE l'operatore consente di eseguire la corrispondenza dei modelli. Determina se una stringa di caratteri specifica corrisponde a un modello specificato. Un modello può includere caratteri normali e caratteri jolly.
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '%.com';Risultato:
+-------------+------------+-------------------+ | FirstName | LastName | Email | |-------------+------------+-------------------| | Homer | Connery | [email protected] | | Bart | Pitt | [email protected] | +-------------+------------+-------------------+
In questo esempio, ho usato LIKE operatore in combinazione con il % operatore jolly per restituire i proprietari i cui indirizzi email terminano con .com .
Operatore bonus! Il % Operatore con caratteri jolly
Il % l'operatore jolly 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.
Tende ad essere più comunemente usato come suffisso e ha un uso limitato nel mezzo dei modelli, sebbene ci siano alcuni casi d'uso validi per usarlo nel mezzo di un modello, come i seguenti:
SELECT
FirstName,
LastName,
Email
FROM Owners
WHERE Email LIKE '[email protected]%.com';Risultato:
+-------------+------------+------------------+ | FirstName | LastName | Email | |-------------+------------+------------------| | Bart | Pitt | [email protected] | +-------------+------------+------------------+
In questo caso, non conoscevamo l'indirizzo email di Bart, ma sapevamo che iniziava con [email protected] e terminava in .com . Pertanto, siamo stati in grado di utilizzare LIKE insieme al % operatore jolly per compilare il resto.
Tieni presente che questa tecnica può restituire molte righe irrilevanti, a seconda dei dati e di come costruisci la tua istruzione SQL.
Tieni inoltre presente che le query che contengono il LIKE La clausola può essere eseguita molto più lentamente rispetto ad altre query e probabilmente dovresti evitare di usare LIKE clausola 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).
Più operatori SQL
Vedi il mio elenco completo di operatori SQL per un sacco di altri operatori che non sono inclusi qui.
