SQL sta per Structured Query Language. I comandi SQL di base sono istruzioni utilizzate per comunicare con un database al fine di eseguire attività, funzioni e query con dei dati.
I comandi di SQL possono essere utilizzati per cercare nel database e per svolgere altre funzioni come creare o eliminare tabelle, e aggiungere o modificare dati.
Ecco una lista dei comandi SQL di base (a volte chiamati clausole) che dovresti conoscere se devi lavorare con SQL.
Sommario
Comandi SQL di base: iniziamo con SELECT e FROM
Uno dei comandi Sql di base e tra i più utilizzati è SELECT
che costituisce la parte di una query che determina quali colonne di dati mostrare nei risultati. Ci sono varie opzioni che puoi applicare per mostrare anche dati che non fanno parte di una colonna della tabella.
L’esempio qui sotto mostra tre colonne selezionate dalla tabella “student” con il comando FROM
e una colonna calcolata. Il database contiene studentID, FirstName e LastName degli studenti. Possiamo combinare le colonne FirstName e LastName per ottenere la colonna calcolata FullName.
SELECT studentID, FirstName, LastName, FirstName + ' ' + LastName AS FullName
FROM student;
+-----------+-------------------+------------+------------------------+
| studentID | FirstName | LastName | FullName |
+-----------+-------------------+------------+------------------------+
| 1 | Monique | Davis | Monique Davis |
| 2 | Teri | Gutierrez | Teri Gutierrez |
| 3 | Spencer | Pautier | Spencer Pautier |
| 4 | Louis | Ramsey | Louis Ramsey |
| 5 | Alvin | Greene | Alvin Greene |
| 6 | Sophie | Freeman | Sophie Freeman |
| 7 | Edgar Frank "Ted" | Codd | Edgar Frank "Ted" Codd |
| 8 | Donald D. | Chamberlin | Donald D. Chamberlin |
| 9 | Raymond F. | Boyce | Raymond F. Boyce |
+-----------+-------------------+------------+------------------------+
9 rows in set (0.00 sec)
CREATE TABLE
Il comando CREATE TABLE
serve per creare una tabella nel database. Puoi specificare il nome della tabella e le colonne che deve contenere.
CREATE TABLE table_name (
column_1 datatype,
column_2 datatype,
column_3 datatype
);
ALTER TABLE
ALTER TABLE
è uno dei comandi Sql di base se si ha la necessità di cambiare la struttura di una tabella. Ecco come puoi aggiungere una colonna a un database:
ALTER TABLE table_name
ADD column_name datatype;
CHECK
La clausola CHECK
viene usata per limitare l’intervallo dei valori che possono essere inseriti in una colonna.
Se definisci una clausola CHECK
su una singola colonna, ammetti solo alcuni valori al suo interno. Se definisci una clausola CHECK
su una tabella, puoi limitare i valori in determinate colonne sulla base dei valori presenti nella riga corrispondente di altre colonne.
Il seguente codice crea una clausola CHECK
sulla colonna “Age” quando viene creata la tabella “Persons”, e fa sì che non ci possa essere nessuna persona al di sotto di 18 anni.
CREATE TABLE Persons (
ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int,
CHECK (Age>=18)
);
Per dare un nome a una clausola CHECK
o definirne una su colonne multiple puoi usare la seguente sintassi:
CREATE TABLE Persons (
ID int NOT NULL,
LastName varchar(255) NOT NULL,
FirstName varchar(255),
Age int,
City varchar(255),
CONSTRAINT CHK_Person CHECK (Age>=18 AND City='Sandnes')
);
WHERE
(AND
, OR
, IN
, BETWEEN
e LIKE
)
Tra i comandi Sql di base abbiamo la clausola WHERE
che viene utilizzata per limitare il numero di righe restituite.
Ad esempio, consideriamo un comando SELECT
e i risultati senza la clausola WHERE
, per poi aggiungere la clausola WHERE
.
SELECT studentID, FullName, sat_score, rcd_updated FROM student;
+-----------+------------------------+-----------+---------------------+
| studentID | FullName | sat_score | rcd_updated |
+-----------+------------------------+-----------+---------------------+
| 1 | Monique Davis | 400 | 2017-08-16 15:34:50 |
| 2 | Teri Gutierrez | 800 | 2017-08-16 15:34:50 |
| 3 | Spencer Pautier | 1000 | 2017-08-16 15:34:50 |
| 4 | Louis Ramsey | 1200 | 2017-08-16 15:34:50 |
| 5 | Alvin Greene | 1200 | 2017-08-16 15:34:50 |
| 6 | Sophie Freeman | 1200 | 2017-08-16 15:34:50 |
| 7 | Edgar Frank "Ted" Codd | 2400 | 2017-08-16 15:35:33 |
| 8 | Donald D. Chamberlin | 2400 | 2017-08-16 15:35:33 |
| 9 | Raymond F. Boyce | 2400 | 2017-08-16 15:35:33 |
+-----------+------------------------+-----------+---------------------+
9 rows in set (0.00 sec)
Ora ripetiamo la query ma limitando le righe restituite con la clausola WHERE
.
STUDENT studentID, FullName, sat_score, recordUpdated
FROM student
WHERE (studentID BETWEEN 1 AND 5 OR studentID = 8)
AND
sat_score NOT IN (1000, 1400);
+-----------+----------------------+-----------+---------------------+
| studentID | FullName | sat_score | rcd_updated |
+-----------+----------------------+-----------+---------------------+
| 1 | Monique Davis | 400 | 2017-08-16 15:34:50 |
| 2 | Teri Gutierrez | 800 | 2017-08-16 15:34:50 |
| 4 | Louis Ramsey | 1200 | 2017-08-16 15:34:50 |
| 5 | Alvin Greene | 1200 | 2017-08-16 15:34:50 |
| 8 | Donald D. Chamberlin | 2400 | 2017-08-16 15:35:33 |
+-----------+----------------------+-----------+---------------------+
5 rows in set (0.00 sec)
UPDATE
Per aggiornare dei dati in una tabella tra i comandi Sql di base abbiamo l’istruzione UPDATE
.
Utilizza la clausola WHERE
per specificare quali dati vuoi aggiornare. È possibile aggiornare più di una colonna alla volta usando la sintassi:
UPDATE table_name
SET column1 = value1,
column2 = value2, ...
WHERE condition;
Ecco un esempio in cui aggiorniamo la colonna Name per la riga con Id 4:
UPDATE Person
SET Name = "Elton John"
WHERE Id = 4;
Puoi anche aggiornare le colonne in una tabella usando i valori di altre tabelle. Con la clausola JOIN
puoi ottenere dati da tabelle multiple, secondo la sintassi:
UPDATE table_name1
SET table_name1.column1 = table_name2.columnA
table_name1.column2 = table_name2.columnB
FROM table_name1
JOIN table_name2 ON table_name1.ForeignKey = table_name2.Key
Ecco un esempio di aggiornamento della colonna Manager per tutte le righe:
UPDATE Person
SET Person.Manager = Department.Manager
FROM Person
JOIN Department ON Person.DepartmentID = Department.ID
GROUP BY
GROUP BY
ti permette di combinare righe e unire dati.
Ecco la sintassi di GROUP BY
:
SELECT column_name, COUNT(*)
FROM table_name
GROUP BY column_name;
HAVING
HAVING
ti permette di filtrare i dati combinati con la clausola GROUP BY
in modo tale da avere un set limitato di dati da visualizzare.
Ecco la sintassi di HAVING
:
SELECT column_name, COUNT(*)
FROM table_name
GROUP BY column_name
HAVING COUNT(*) > value;

AVG()
Il comando AVG()
viene usato per calcolare la media di una colonna contenente dati numerici, appartenenti a un set di righe individuate da un comando SQL.
Ecco la sintassi:
SELECT groupingField, AVG(num_field)
FROM table1
GROUP BY groupingField
Ed ecco un altro esempio usando la tabella student:
SELECT studentID, FullName, AVG(sat_score)
FROM student
GROUP BY studentID, FullName;
AS
AS
ti permette di rinominare una colonna o una tabella.
SELECT user_only_num1 AS AgeOfServer, (user_only_num1 - warranty_period) AS NonWarrantyPeriod FROM server_table
Qui sotto puoi vedere l’output:
+-------------+------------------------+
| AgeOfServer | NonWarrantyPeriod |
+-------------+------------------------+
| 36 | 24 |
| 24 | 12 |
| 61 | 49 |
| 12 | 0 |
| 6 | -6 |
| 0 | -12 |
| 36 | 24 |
| 36 | 24 |
| 24 | 12 |
+-------------+------------------------+
Puoi usare AS
anche per assegnare un nome a una tabella per riferirti ad essa più facilmente nell’istruzione JOIN
.
SELECT ord.product, ord.ord_number, ord.price, cust.cust_name, cust.cust_number
FROM customer_table AS cust
JOIN order_table AS ord ON cust.cust_number = ord.cust_number
Ecco il risultato dell’output:
+-------------+------------+-----------+-----------------+--------------+
| product | ord_number | price | cust_name | cust_number |
+-------------+------------+-----------+-----------------+--------------+
| RAM | 12345 | 124 | John Smith | 20 |
| CPU | 12346 | 212 | Mia X | 22 |
| USB | 12347 | 49 | Elise Beth | 21 |
| Cable | 12348 | 0 | Paul Fort | 19 |
| Mouse | 12349 | 66 | Nats Back | 15 |
| Laptop | 12350 | 612 | Mel S | 36 |
| Keyboard| 12351 | 24 | George Z | 95 |
| Keyboard| 12352 | 24 | Ally B | 55 |
| Air | 12353 | 12 | Maria Trust | 11 |
+-------------+------------+-----------+-----------------+--------------+

ORDER BY
ORDER BY
offre un modo per ordinare i risultati secondo una o più colonne nella sezione SELECT
. Nell’esempio qui sotto, gli studenti sono stati messi in ordine discendente secondo il loro FullName. L’ordine di default è ascendente (ASC
) e per ordinarli al contrario devi usare DESC
.
SELECT studentID, FullName, sat_score
FROM student
ORDER BY FullName DESC;
COUNT
COUNT
viene usato per contare il numero di righe e restituire il risultato come una colonna.
Ecco alcuni esempi delle situazioni in cui COUNT
risulta utile:
- Contare tutte le righe di una tabella (senza usare
GROUP BY
) - Contare il totale di sottogruppi di dati (richiede una sezione
GROUP BY
nell’istruzione)
Questo codice fornisce il conteggio di tutte le righe. Nota che puoi dare un nome alla colonna COUNT restituita usando AS
.
SELECT count(*) AS studentCount FROM student;
DELETE
DELETE
viene usato per cancellare un dato in una tabella.
Fai attenzione, perché puoi cancellare tutti i dati di una tabella o soltanto alcuni di essi. Usa la condizione WHERE
per specificare quali dati vuoi eliminare, secondo la sintassi:
DELETE FROM table_name
WHERE condition;
Ecco un esempio in cui eliminiamo i dati con Id 3 dalla colonna Person:
DELETE FROM Person
WHERE Id = 3;
INNER JOIN
JOIN
, o anche detto Inner Join, seleziona dati che hanno valori corrispondenti in due tabelle.
SELECT * FROM A x JOIN B y ON y.aId = x.Id
LEFT JOIN
L’istruzione LEFT JOIN
restituisce tutte le righe della tabella di sinistra e le righe corrispondenti di quella di destra. Le righe della tabella di sinistra vengono restituite anche se non c’è corrispondenza con la tabella di destra. Le righe della tabella di sinistra senza corrispondenza presenteranno null
per i valori della tabella di destra.
SELECT * FROM A x LEFT JOIN B y ON y.aId = x.Id
RIGHT JOIN
RIGHT JOIN
restituisce tutte le righe della tabella di destra e le corrispondenti di quella di sinistra. In contrapposizione a LEFT JOIN
, restituisce tutte le righe della tabella di destra anche se non c’è corrispondenza con la tabella di sinistra. Le righe della tabella di destra senza corrispondenza presenteranno null
per i valori della tabella sinistra.
SELECT * FROM A x RIGHT JOIN B y ON y.aId = x.Id
FULL OUTER JOIN
Il comando FULL OUTER JOIN
restituisce tutte le righe in cui c’è corrispondenza in entrambe le tabelle.
Se ci sono righe nella tabella di sinistra non corrispondenti alla tabella di destra, non verranno incluse, e se ci sono righe della tabella di destra non corrispondenti alla tabella di sinistra anche queste non verranno incluse verranno incluse.
SELECT Customers.CustomerName, Orders.OrderID
FROM Customers
FULL OUTER JOIN Orders
ON Customers.CustomerID=Orders.CustomerID
ORDER BY Customers.CustomerName
INSERT
INSERT
ti permette di inserire dei dati in una tabella.
INSERT INTO table_name (column_1, column_2, column_3)
VALUES (value_1, 'value_2', value_3);
LIKE
LIKE
viene usato insieme a un comando WHERE
o HAVING
(come parte di GROUP BY
) per limitare le righe selezionate quando una colonna presenta un certo pattern di caratteri al suo interno.
Questo codice seleziona gli studenti che hanno FullName
che inizia con “Monique” o termina con “Greene”.
SELECT studentID, FullName, sat_score, rcd_updated
FROM student
WHERE
FullName LIKE 'Monique%' OR
FullName LIKE '%Greene';
+-----------+---------------+-----------+---------------------+
| studentID | FullName | sat_score | rcd_updated |
+-----------+---------------+-----------+---------------------+
| 1 | Monique Davis | 400 | 2017-08-16 15:34:50 |
| 5 | Alvin Greene | 1200 | 2017-08-16 15:34:50 |
+-----------+---------------+-----------+---------------------+
2 rows in set (0.00 sec)
Puoi inserire NOT
prima diLIKE
per escludere le righe contenenti il pattern invece di selezionarle. Questo codice esclude le righe contenenti “cer Pau” e “Ted” nella colonna FullName.
SELECT studentID, FullName, sat_score, rcd_updated
FROM student
WHERE FullName NOT LIKE '%cer Pau%' AND FullName NOT LIKE '%"Ted"%';
+-----------+----------------------+-----------+---------------------+
| studentID | FullName | sat_score | rcd_updated |
+-----------+----------------------+-----------+---------------------+
| 1 | Monique Davis | 400 | 2017-08-16 15:34:50 |
| 2 | Teri Gutierrez | 800 | 2017-08-16 15:34:50 |
| 4 | Louis Ramsey | 1200 | 2017-08-16 15:34:50 |
| 5 | Alvin Greene | 1200 | 2017-08-16 15:34:50 |
| 6 | Sophie Freeman | 1200 | 2017-08-16 15:34:50 |
| 8 | Donald D. Chamberlin | 2400 | 2017-08-16 15:35:33 |
| 9 | Raymond F. Boyce | 2400 | 2017-08-16 15:35:33 |
+-----------+----------------------+-----------+---------------------+
7 rows in set (0.00 sec)
Conclusione
Abbiamo visto insieme i comandi Sql di base utili per iniziare a costruire le prime query.
Se sei interessato ad approfondire il mondo dei database in modo da conoscere altre funzionalità di Sql Server puoi dare uno sguardo ai seguenti articoli:
- Database in Recovery Pending in Sql Server 2019 – Bartolomeo Alberico
- Verificare dimensione tabelle in SQL Server 2019 – Bartolomeo Alberico
- Come cambiare path file database in Sql Server 2019 – Bartolomeo Alberico
- Come utilizzare Query Store in Sql Server 2019 – Bartolomeo Alberico
- Database in modalità Suspect in Sql Server 2019 – Bartolomeo Alberico
invece se seguire un videocorso sui comandi Sql di base puoi iniziare con il video che trovi a fine articolo.