Il software che utilizziamo a scuola è:
ℹ️
Scopri di più ⭐️
Esercizi svolti 🌎
W3S
Note
Verrà aggiornato solo quando avrò voglia!
- Migliorare la sezione contenuti
- Migliorare la dimostrazione
- Definizioni
- Consigli
- Data Manipulation Language (DML)
- Modifica dei dati
Un database è un insieme organizzato di dati. Può essere tutto, da un semplice elenco di contatti telefonici fino a un intero inventario di prodotti per un'azienda.
Un DBMS è un software che gestisce i database. Esempi comuni sono MySQL, PostgreSQL, MongoDB e SQLite.
Un database relazionale è un tipo di database che organizza i dati in tabelle con righe e colonne, molto simile a come i dati sono organizzati in un foglio di calcolo. Ogni riga rappresenta un record distinto e ogni colonna rappresenta un campo di quel record. Le tabelle possono essere collegate tra loro attraverso chiavi primarie e chiavi esterne, permettendo di creare relazioni tra i dati. Questo modello di database è molto comune e largamente utilizzato in molte applicazioni. Esempi di DBMS relazionali includono MySQL, PostgreSQL e SQLite.
I database NoSQL, o "non solo SQL", sono un tipo di database che non seguono il modello relazionale standard. Sono progettati per essere altamente scalabili e per gestire grandi quantità di dati distribuiti su molteplici macchine. I database NoSQL non richiedono uno schema fisso, il che significa che i dati possono essere inseriti nel database senza dover prima definire la struttura della tabella. Questo li rende molto flessibili e adatti per lavorare con dati non strutturati o semi-strutturati. Esistono diversi tipi di database NoSQL, tra cui database di documenti (come MongoDB), database di chiave-valore (come Redis), database di colonne (come Cassandra) e database di grafi (come Neo4j).
Comandi utilizzati per definire o modificare la struttura di un database o di una tabella. Esempi di comandi DDL includono CREATE
, ALTER
e DROP
.
Comandi utilizzati per manipolare i dati all'interno delle tabelle di un database. Esempi di comandi DML includono SELECT
, INSERT
, UPDATE
e DELETE
.
Comandi utilizzati per controllare l'accesso ai dati all'interno del database. Esempi di comandi DCL includono GRANT
e REVOKE
, che sono utilizzati per gestire i diritti e i privilegi degli utenti.
Linguaggio di interrogazione strutturato, utilizzato per gestire e manipolare i database.
Con SQL si possono fare seguenti operazioni:
DDL | Creazione di tabelle |
DML | Aggiornamento dei dati |
Cancellazione dei dati | |
Interrogazione dei dati | |
DCL | Gestione dei permessi di accesso |
Una query SQL è un modo di comunicare con il database per ottenere le informazioni di cui hai bisogno o per effettuare **modifiche nei dati. Detto meglio: Una query è una richiesta di dati da un database.
select |
Determines which columns to include in the query's result set |
from |
Identifies the tables from which to retrive data and how the tables should be joined |
where |
Filters out unwanted data |
group by |
Used to group rows together by common column values |
having |
Filters out unwanted groups |
order by |
Sorts the rows of the final result set by one or more columns |
Un identificatore univoco per una riga in una tabella.
Un campo in una tabella che fa riferimento alla chiave primaria di un'altra tabella.
Il processo di organizzazione dei dati in un database per ridurre la ridondanza e migliorare l'integrità dei dati.
Leggi di più
La normalizzazione è un concetto fondamentale nella progettazione di database. L'obiettivo della normalizzazione è di eliminare la ridondanza dei dati e di garantire l'integrità dei dati. Ci sono diverse forme di normalizzazione, ognuna delle quali è chiamata "forma normale". Le prime tre forme normali sono le più comuni.
-
Prima forma normale (1NF): In questa forma, ogni colonna di una tabella deve contenere valori atomici, cioè valori indivisibili. Inoltre, ogni colonna deve essere unica.
Esempio:
Non normalizzato:
ID Nome Telefoni 1 Mario 123456, 789012 2 Luigi 345678 1NF:
ID Nome Telefono 1 Mario 123456 1 Mario 789012 2 Luigi 345678 -
Seconda forma normale (2NF): Una tabella è in 2NF se è in 1NF e ogni colonna non chiave dipende interamente dalla chiave primaria.
Esempio:
Non 2NF:
ID Nome Telefono Città 1 Mario 123456 Roma 1 Mario 789012 Roma 2 Luigi 345678 Milano 2NF:
Tabella Utenti:
ID Nome Città 1 Mario Roma 2 Luigi Milano Tabella Telefoni:
ID Telefono 1 123456 1 789012 2 345678 -
Terza forma normale (3NF): Una tabella è in 3NF se è in 2NF e non esistono dipendenze transitiva, cioè una colonna non chiave non dipende da altre colonne non chiave.
Esempio:
Non 3NF:
ID Nome Città Provincia 1 Mario Roma Lazio 2 Luigi Milano Lombardia 3NF:
Tabella Utenti:
ID Nome ID_Città 1 Mario 1 2 Luigi 2 Tabella Città:
ID Nome Provincia 1 Roma Lazio 2 Milano Lombardia -
Quarta forma normale (4NF): Una tabella è in 4NF se è in 3NF e non ha dipendenze multivalutate. Una dipendenza multivalutata si verifica quando un insieme di attributi dipende da un altro insieme di attributi.
4NF:
Tabella Utenti:
ID Nome 1 Mario 2 Luigi Tabella Lingue:
ID Lingua 1 Inglese 2 Italiano 3 Francese Tabella Utenti_Lingue:
ID_Utente ID_Lingua 1 1 1 2 2 1 2 3 -
Quinta forma normale (5NF, AKA SWAG): Assicura che ogni dipendenza di join sia implicitamente rappresentata dalle dipendenze di chiave e di inclusione. Questo è un concetto avanzato che va oltre il campo di applicazione di questo esempio.
Il processo di combinazione di tabelle per migliorare le prestazioni di lettura a scapito delle prestazioni di scrittura.
Struttura di dati che migliora la velocità delle operazioni di database.
Un modello o struttura per un database definito in un linguaggio formale supportato dal sistema di gestione del database.
Questo schema è chiamato "star" perché i diagrammi delle sue tabelle sembrano una stella. Al centro c'è una tabella dei fatti, e le tabelle dimensionali si irradiano da essa come i raggi di una stella. Questo schema è comunemente usato nei data warehouse.
- Punti di forza: Facile da comprendere e da navigare. Ottimo per le query di analisi dei dati.
- Debolezze: Può portare a una certa ridondanza dei dati a causa della denormalizzazione.
Questo schema è una variante dello schema star in cui le tabelle dimensionali sono normalizzate. Questo riduce la ridondanza dei dati, ma può rendere le query più complesse.
- Punti di forza: Riduce la ridondanza dei dati grazie alla normalizzazione. Può risparmiare spazio di archiviazione.
- Debolezze: Le query possono diventare più complesse a causa delle tabelle aggiuntive. Può richiedere più tempo per eseguire le query rispetto allo schema star.
In questo schema, tutti i dati sono memorizzati in una singola tabella. Questo può essere semplice da implementare, ma può portare a problemi di ridondanza dei dati e di integrità dei dati.
- Punti di forza: Semplice da implementare. Non richiede la gestione delle relazioni tra le tabelle.
- Debolezze: Può portare a una grande ridondanza dei dati. Può causare problemi di integrità dei dati. Non è adatto per i dati complessi.
Questo schema utilizza la normalizzazione per ridurre la ridondanza dei dati e migliorare l'integrità dei dati. Questo può comportare la creazione di molte tabelle correlate.
- Punti di forza: Riduce la ridondanza dei dati e migliora l'integrità dei dati. Facilita l'aggiornamento dei dati.
- Debolezze: Può portare a un gran numero di tabelle correlate, rendendo le query più complesse. Può richiedere più tempo per eseguire le query rispetto agli schemi denormalizzati.
Questo schema è usato per modellare le relazioni tra entità in un database. Le entità sono cose come persone, luoghi o oggetti, e le relazioni sono i modi in cui queste entità sono collegate.
- Punti di forza: Molto intuitivo e facile da comprendere. Ottimo per modellare relazioni complesse tra entità.
- Debolezze: Può diventare complicato con un gran numero di entità e relazioni. Non è ottimizzato per le prestazioni di query.
Questo schema combina elementi dei database relazionali e dei database orientati agli oggetti. Permette di memorizzare dati complessi e relazioni tra i dati.
- Punti di forza: Flessibile e potente, permette di modellare dati complessi e relazioni tra i dati. Supporta l'ereditarietà, che può essere utile per la modellazione di dati.
- Debolezze: Più complesso da implementare e gestire rispetto ai database puramente relazionali. Non tutti i DBMS supportano pienamente il modello object-relational.
Rendi il blocco CASE WHEN più esplicito, elencando tutte le condizioni in modo chiaro.
SELECT
Nome,
CASE
WHEN Età < 18 THEN 'Minorenne'
WHEN Età >= 18 AND Età < 65 THEN 'Adulto'
ELSE 'Anziano'
END AS FasciaEtà
FROM
Persone;
Indenta il codice in modo che le clausole siano chiaramente visibili e allinea i termini per una migliore leggibilità.
SELECT
Colonna1,
Colonna2
FROM
Tabella
WHERE
Condizione = 'Valore';
Evita ambiguità nelle operazioni aritmetiche utilizzando le parentesi per definire la precedenza degli operatori.
SELECT
(Colonna1 + Colonna2) * Colonna3 AS Risultato
FROM
Tabella;
Usa alias significativi per rendere chiare le colonne calcolate.
SELECT
Nome,
(Punteggio1 + Punteggio2) / 2 AS MediaPunteggio
FROM
Studenti;
La Data Manipulation Language (DML) è una parte del linguaggio SQL (Structured Query Language) utilizzata per manipolare i dati all'interno di un database relazionale.
La DML consente di eseguire le seguenti azioni principali:
- Inserimento di dati (INSERT): La DML permette di aggiungere nuovi dati a una tabella esistente del database.
- Aggiornamento dei dati (UPDATE): È possibile utilizzare la DML per modificare o aggiornare dati esistenti all'interno di una tabella.
- Cancellazione dei dati (DELETE): La DML consente di rimuovere dati da una tabella, sia in base a condizioni specifiche che per eliminare tutti i dati.
- Interrogazione dei dati (SELECT)
Verranno mostrate tutte colonne di una specifica tabella
SELECT *
FROM nome_tabella;
Verranno mostrate solo le colonne selezionate (colonna1 e colonna2)
SELECT
colonna1,
colonna2
FROM nome_tabella;
Possiamo assegnare dei nomi più comprensibili utilizzando AS, in questo caso colonna1 verrà mostrata con il "Nome" e la colonna2 con il "Cognome"
Note
Si può anche omettere il AS, funzionerà ugualmente
SELECT
colonna1 AS Nome,
colonna2 AS Cognome
FROM nome_tabella;
In questa query:
Orders AS o
assegna l'aliaso
alla tabellaOrders
Customers AS c
assegna l'aliasc
alla tabellaCustomers
Products AS p
assegna l'aliasp
alla tabellaProducts
SELECT
o.OrderID,
c.CustomerName,
p.ProductName,
o.Quantity
FROM
Orders AS o
INNER JOIN
Customers AS c ON o.CustomerID = c.CustomerID
INNER JOIN
Products AS p ON o.ProductID = p.ProductID;
Possiamo mostrare delle colonne che effettuando dei calcoli aritmetici, molto utili poiché non ce bisogno di creare colonne inutili! Espressioni supportate: + - / * %
SELECT
colonna1,
(colonna2 * 2) AS 'Doppio valore' -- spazio? mettici le ' o "
FROM nome_tabella;
Verranno ignorati i valori ripetuti
SELECT DISTINCT colonna1
FROM nome_tabella;
Questa query seleziona i nomi dei clienti che iniziano con "Jo".
SELECT
Nome
FROM Clienti
WHERE Nome LIKE 'Jo%';
Questa query selezionerà i nomi dei clienti che terminano con la sequenza "son".
SELECT
Nome
FROM Clienti
WHERE Nome LIKE '%son';
Questa query selezionerà i titoli dei libri che contengono la parola "avventura" ovunque nel titolo.
SELECT
Titolo
FROM Libri
WHERE Titolo LIKE '%avventura%';
Questa query selezionerà le parole che hanno tre lettere, dove il carattere mancante può essere qualsiasi lettera. Ad esempio, potrebbe corrispondere a "cat", "cot", "cut", ecc.
SELECT
Parola
FROM Dizionario
WHERE Parola LIKE 'c_t';
Questa query seleziona tutti gli ordini in cui il prodotto è specificamente "Computer".
SELECT
Prodotto
FROM Ordini
WHERE Prodotto = 'Computer';
Questa query seleziona i nomi dei clienti che non hanno un indirizzo specificato, ovvero il valore della colonna "Indirizzo" è NULL.
L'operatore IS NULL viene utilizzato per verificare se un valore è nullo.
SELECT
Nome
FROM Clienti
WHERE Indirizzo IS NULL;
Questa query selezionerà tutti i record dalla tabella "Prodotti" in cui il valore nella colonna "Descrizione" non è nullo.
SELECT *
FROM Prodotti
WHERE Descrizione IS NOT NULL;
Questa query seleziona tutti gli ordini in cui il prodotto è uno dei valori elencati nella lista (Libro, Computer, Cuffie).
L'operatore IN permette di filtrare i risultati in base a una lista di valori specifici.
SELECT
Prodotto
FROM Ordini
WHERE Prodotto IN ('Libro', 'Computer', 'Cuffie');
Questa query selezionerà i nomi dei clienti che hanno la città di residenza uguale a "Roma".
L'operatore = viene utilizzato per confrontare i valori in modo esatto.
SELECT
Nome
FROM Clienti
WHERE Città = 'Roma';
Questa query selezionerà i prodotti nel magazzino che hanno una quantità diversa da zero.
Gli operatori <> o != indicano che il valore nella colonna "Quantità" è diverso da zero.
SELECT
Prodotto
FROM Magazzino
WHERE Quantità <> 0;
Questa query selezionerà i nomi e le età degli studenti che hanno un'età superiore a 18 anni.
L'operatore > indica che il valore nella colonna "Età" deve essere maggiore di 18.
SELECT
Nome,
Età
FROM Studenti
WHERE Età > 18;
Questa query selezionerà i nomi degli studenti e i voti degli esami in cui il voto è uguale o maggiore di 60.
L'operatore >= indica che il valore nella colonna "Voto" deve essere 60 o superiore.
SELECT
Nome,
Voto
FROM Esami
WHERE Voto >= 60;
Questa query selezionerà i nomi dei dipendenti con uno stipendio inferiore a 30.000 unità monetarie.
L'operatore < indica che il valore nella colonna "Stipendio" deve essere inferiore a 30.000.
SELECT
Nome
FROM Dipendenti
WHERE Stipendio < 30000;
Questa query selezionerà i nomi degli atleti e i punteggi in cui il punteggio è uguale o inferiore a 100.
L'operatore <= indica che il valore nella colonna "Punteggio" deve essere 100 o inferiore.
SELECT
Nome,
Punteggio
FROM Atleti
WHERE Punteggio <= 100;
Questa query selezionerà i nomi dei dipendenti che lavorano nel reparto "Vendite" e hanno uno stipendio superiore a 30.000 unità monetarie.
L'operatore AND combina due condizioni e richiede che entrambe siano vere per selezionare una riga.
SELECT
Nome
FROM Dipendenti
WHERE Reparto = 'Vendite' AND Stipendio > 30000;
Demostrazione
...
Nome | Reparto | Stipendio |
---|---|---|
Mario | Vendite | 35000 |
Laura | Vendite | 28000 |
Luigi | Logistica | 32000 |
Risultato:
Nome |
---|
Mario |
Questa query selezionerà i nomi dei clienti che appartengono alla categoria "VIP" o alla categoria "Nuovi Clienti".
L'operatore OR consente di selezionare le righe che soddisfano almeno una delle condizioni.
SELECT
Nome
FROM Clienti
WHERE Categoria = 'VIP' OR Categoria = 'Nuovi Clienti';
Demostrazione
...
Nome | Categoria |
---|---|
Anna | VIP |
Giovanni | Standard |
Luca | Nuovi Clienti |
Risultato:
Nome |
---|
Anna |
Luca |
Questa query selezionerà i nomi dei prodotti che appartengono alle categorie "Elettronica" o "Informatica" e hanno un prezzo superiore a 500 unità monetarie.
Le parentesi sono utilizzate per definire le priorità delle condizioni.
SELECT
Nome
FROM Prodotti
WHERE (Categoria = 'Elettronica' OR Categoria = 'Informatica') AND Prezzo > 500;
Demostrazione
...
Nome | Categoria | Prezzo |
---|---|---|
Prodotto A | Elettronica | 550 |
Prodotto B | Informatica | 450 |
Prodotto C | Elettronica | 480 |
Risultato:
Nome |
---|
Prodotto A |
Questa query selezionerà i titoli dei libri che non appartengono al genere "Fantascienza".
L'operatore NOT nega una condizione, selezionando le righe che non la soddisfano.
SELECT
Titolo
FROM Libri
WHERE NOT Genere = 'Fantascienza';
Demostrazione
...
Titolo | Genere |
---|---|
Libro 1 | Fantascienza |
Libro 2 | Fantasy |
Libro 3 | Romanzo |
Risultato:
Titolo |
---|
Libro 2 |
Libro 3 |
Questa query selezionerà i nomi e le età degli studenti e li ordinerà in modo crescente in base all'età.
Il risultato mostrerà gli studenti dall'età più bassa alla più alta.
Note
Se non specifici alcun tipo di ordinamento (né ASC né DESC), l'ordinamento di base sarà in modo ascendente (ASC).
SELECT
Nome,
Età
FROM Studenti
ORDER BY Età;
Questa query selezionerà i prodotti e i loro prezzi e li ordinerà in modo decrescente in base al prezzo.
Il risultato mostrerà i prodotti con il prezzo più alto prima.
SELECT
Prodotto,
Prezzo
FROM Prodotti
ORDER BY Prezzo DESC;
Questa query selezionerà i nomi, i cognomi e i punteggi degli studenti e li ordinerà in modo decrescente in base al punteggio e poi in modo crescente in base al cognome.
Note
Gli studenti con punteggi più alti verranno mostrati per primi, e in caso di punteggi uguali, verranno ordinati in base al cognome in ordine alfabetico crescente.
SELECT
Nome,
Cognome,
Punteggio
FROM Studenti
ORDER BY Punteggio DESC, Cognome ASC;
Questa query selezionerà i nomi e gli stipendi annuali calcolati moltiplicando lo stipendio mensile per 12.
I risultati verranno ordinati in modo decrescente in base allo stipendio annuale.
SELECT
Nome,
Stipendio * 12 AS StipendioAnnuale
FROM Dipendenti
ORDER BY StipendioAnnuale DESC;
Questa query restituirà i nomi e i cognomi dei primi 5 clienti nella tabella "Clienti".
La clausola LIMIT viene utilizzata per limitare il numero di righe restituite ai primi 5 risultati.
SELECT
Nome,
Cognome
FROM Clienti LIMIT 5;
Demostrazione
...
Nome | Cognome |
---|---|
John | Doe |
Risultato:
Nome | Cognome |
---|---|
John | Doe |
La combinazione di ORDER BY e LIMIT consente di ottenere i primi N risultati dell'ordinamento desiderato.
SELECT
Prodotto,
Prezzo
FROM Prodotti
ORDER BY Prezzo DESC LIMIT 3;
Demostrazione
...
Altri dati della tabella Prodotti ordinati per Prezzo ...Prodotto | Prezzo |
---|---|
Prodotto A | 100 |
Risultato:
Altri 2 risultati della tabella Prodotti ordinati per Prezzo ...Prodotto | Prezzo |
---|---|
Prodotto C | 80 |
L'istruzione OFFSET specifica da quale posizione iniziare a restituire i risultati.
SELECT
Nome,
Cognome
FROM Dipendenti LIMIT 5 OFFSET 5;
Demostrazione
...
Dati della tabella Dipendenti ...Nome | Cognome |
---|
Risultato:
Altri 4 risultati della tabella Dipendenti (dal sesto al decimo) ...Nome | Cognome |
---|---|
Emily | Johnson |
Questa query restituirà i titoli dei libri a partire dal 21simo (offset di 20) fino al trentesimo (10 risultati successivi).
La combinazione di LIMIT e OFFSET consente di recuperare porzioni specifiche di dati.
SELECT
Titolo
FROM Libri LIMIT 10 OFFSET 20;
Demostrazione
...
Dati della tabella Libri ...Titolo |
---|
Risultato:
Altri 9 risultati della tabella Libri (dal ventunesimo al trentesimo) ...Titolo |
---|
Libro 21 |
Questa query calcola la somma di tutti i valori nella colonna "Quantita" della tabella "Ordini" e restituisce il risultato con il nome "TotaleQuantita".
SELECT
SUM(Quantita) AS TotaleQuantita
FROM Ordini;
Questa query calcola la somma delle quantità di prodotti per ciascuna categoria nella tabella "Prodotti".
SELECT
Categoria,
SUM(Quantita) AS TotaleQuantita
FROM Prodotti
GROUP BY Categoria;
Questa query calcola la media dei valori nella colonna "Prezzo" della tabella "Prodotti" e restituisce il risultato con il nome "MediaPrezzo".
SELECT
AVG(Prezzo) AS MediaPrezzo
FROM Prodotti;
Questa query calcola la media dei punteggi degli esami superiori a 70 per ciascun anno nella tabella "Esami".
SELECT
Anno,
AVG(CASE WHEN Punteggio > 70 THEN Punteggio ELSE NULL END) AS MediaSuperiori70
FROM Esami
GROUP BY Anno;
Questa query calcola la media ponderata dei punteggi degli studenti nella tabella "Voti", considerando il peso di ciascun voto.
SELECT
Studente,
AVG(Punteggio * Peso / 100) AS MediaPonderata
FROM Voti
GROUP BY Studente;
Questa query conta il numero totale di righe nella tabella "Clienti" e restituisce il risultato con il nome "NumeroClienti".
SELECT
COUNT(*) AS NumeroClienti
FROM Clienti;
Questa query conta il numero di categorie distinte nella tabella "Prodotti".
SELECT
COUNT(DISTINCT Categoria) AS NumeroCategorie
FROM Prodotti;
Questa query restituisce il valore massimo nella colonna "Punteggio" della tabella "Studenti" con il nome "PunteggioMassimo".
SELECT
MAX(Punteggio) AS PunteggioMassimo
FROM Studenti;
Questa query restituisce il massimo stipendio per ciascun dipartimento nella tabella "Dipendenti".
SELECT
Dipartimento,
MAX(Stipendio) AS StipendioMassimo
FROM Dipendenti
GROUP BY Dipartimento;
Questa query restituisce il valore minimo nella colonna "Quantita" della tabella "Magazzino" con il nome "QuantitaMinima".
SELECT
MIN(Quantita) AS QuantitaMinima
FROM Magazzino;
Questa query restituisce il voto minimo positivo per ciascun anno nella tabella "Esami".
SELECT Anno,
MIN(CASE WHEN Voto > 0 THEN Voto ELSE NULL END) AS VotoMinimoPositivo
FROM Esami
GROUP BY Anno;
Questa query calcola la media dei voti nella colonna "MediaVoti" della tabella "Esami" e restituisce il risultato arrotondato a due decimali con il nome "MediaVotiArrotondata".
SELECT
ROUND(MediaVoti, 2) AS MediaVotiArrotondata
FROM Esami;
In SQL, un "JOIN" è un metodo per combinare righe provenienti da due o più tabelle, basato su una colonna correlata tra di loro. Ci sono diversi tipi di JOIN in SQL:
- INNER JOIN: Restituisce le righe quando c'è una corrispondenza in entrambe le tabelle.
- LEFT JOIN: Restituisce tutte le righe dalla tabella di sinistra, e le righe corrispondenti dalla tabella di destra. Se non c'è corrispondenza, il risultato è NULL sulla parte destra.
- RIGHT JOIN: Restituisce tutte le righe dalla tabella di destra, e le righe corrispondenti dalla tabella di sinistra. Se non c'è corrispondenza, il risultato è NULL sulla parte sinistra.
- FULL JOIN: Restituisce le righe quando c'è una corrispondenza in una delle tabelle. Quindi, se c'è una riga in una delle tabelle che non corrisponde con l'altra, il risultato sarà NULL.
The Orders
table:
OrderID | CustomerID | OrderDate |
---|---|---|
1 | 3 | 2022-01-22 |
2 | 1 | 2022-03-20 |
3 | 2 | 2022-04-22 |
4 | 4 | 2022-02-10 |
The Customers
table:
CustomerID | CustomerName |
---|---|
1 | John Doe |
2 | Jane Doe |
3 | Alice |
4 | Bob |
If you want to combine these two tables to get a list of orders with the customer's name, you can use an INNER JOIN. The SQL query would look like this:
SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate
FROM Orders
INNER JOIN Customers ON Orders.CustomerID = Customers.CustomerID;
This will return a table that only includes orders for which a corresponding customer exists:
OrderID | CustomerName | OrderDate |
---|---|---|
1 | Alice | 2022-01-22 |
2 | John Doe | 2022-03-20 |
3 | Jane Doe | 2022-04-22 |
4 | Bob | 2022-02-10 |
The Orders
table:
OrderID | CustomerID | OrderDate |
---|---|---|
1 | 3 | 2022-01-22 |
2 | 1 | 2022-03-20 |
3 | 2 | 2022-04-22 |
4 | 5 | 2022-02-10 |
The Customers
table:
CustomerID | CustomerName |
---|---|
1 | John Doe |
2 | Jane Doe |
3 | Alice |
If you want to combine these two tables to get a list of orders with the customer's name, you can use a LEFT JOIN. The SQL query would look like this:
SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate
FROM Orders
LEFT JOIN Customers ON Orders.CustomerID = Customers.CustomerID;
This will return a table that includes all orders, but customer names will only appear for orders where a corresponding customer exists. If an order has a CustomerID
that doesn't exist in the Customers
table, the CustomerName
for that order will be NULL.
OrderID | CustomerName | OrderDate |
---|---|---|
1 | Alice | 2022-01-22 |
2 | John Doe | 2022-03-20 |
3 | Jane Doe | 2022-04-22 |
4 | NULL | 2022-02-10 |
The Orders
table:
OrderID | CustomerID | OrderDate |
---|---|---|
1 | 3 | 2022-01-22 |
2 | 1 | 2022-03-20 |
3 | 2 | 2022-04-22 |
The Customers
table:
CustomerID | CustomerName |
---|---|
1 | John Doe |
2 | Jane Doe |
3 | Alice |
4 | Bob |
If you want to combine these two tables to get a list of customers with their orders, you can use a RIGHT JOIN. The SQL query would look like this:
SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate
FROM Orders
RIGHT JOIN Customers ON Orders.CustomerID = Customers.CustomerID;
This will return a table that includes all customers, but orders will only appear for customers where a corresponding order exists. If a customer doesn't have any orders in the Orders
table, the OrderID
and OrderDate
for that customer will be NULL.
OrderID | CustomerName | OrderDate |
---|---|---|
1 | Alice | 2022-01-22 |
2 | John Doe | 2022-03-20 |
3 | Jane Doe | 2022-04-22 |
NULL | Bob | NULL |
The Orders
table:
OrderID | CustomerID | OrderDate |
---|---|---|
1 | 3 | 2022-01-22 |
2 | 1 | 2022-03-20 |
3 | 2 | 2022-04-22 |
4 | 5 | 2022-02-10 |
The Customers
table:
CustomerID | CustomerName |
---|---|
1 | John Doe |
2 | Jane Doe |
3 | Alice |
4 | Bob |
If you want to combine these two tables to get a list of all orders and all customers, you can use a FULL JOIN. The SQL query would look like this:
SELECT Orders.OrderID, Customers.CustomerName, Orders.OrderDate
FROM Orders
FULL JOIN Customers ON Orders.CustomerID = Customers.CustomerID;
This will return a table that includes all orders and all customers. If an order has a CustomerID
that doesn't exist in the Customers
table, the CustomerName
for that order will be NULL. Similarly, if a customer doesn't have any orders in the Orders
table, the OrderID
and OrderDate
for that customer will be NULL.
OrderID | CustomerName | OrderDate |
---|---|---|
1 | Alice | 2022-01-22 |
2 | John Doe | 2022-03-20 |
3 | Jane Doe | 2022-04-22 |
4 | NULL | 2022-02-10 |
NULL | Bob | NULL |
fatto da me e GitHub Copilot.