Comandi Sql di base

Comandi SQL di base – la lista di query per Sql Server 2019

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.

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

(ANDORINBETWEEN 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;
Comandi Sql di base - Utilizzo editor SQL Server Management Studio (SSMS)
Comandi Sql di base – Utilizzo editor SQL Server Management Studio (SSMS)

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          |
+-------------+------------+-----------+-----------------+--------------+
Comandi Sql di base - Utilizzo editor SQL Server Management Studio (SSMS) con Join
Comandi Sql di base – Utilizzo editor SQL Server Management Studio (SSMS) con Join

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:

invece se seguire un videocorso sui comandi Sql di base puoi iniziare con il video che trovi a fine articolo.

Comandi Sql di base – Video

Autore Bartolomeo

Consulente tecnico con la passione per il web e la tecnologia e tutto quello che le ronza intorno.
Nel tempo libero scrivo articoli per il mio blog su argomenti vari, in particolare su configurazione Windows, Linux e WordPress.

Condividi questo articolo!

Lascia un commento

Il tuo indirizzo email non sarà pubblicato.

Ho letto la policy privacy e accetto il trattamento dei miei dati personali in conformità al D.Lgs. 196/2003