SQL di Base: SELECT, INSERT, UPDATE, DELETE

Bentornato.

Nella lezione precedente hai imparato database e tabelle.

Hai imparato che un database contiene tabelle.

Le tabelle contengono righe e colonne.

Le righe sono record.

Le colonne descrivono i dati.

Molto organizzato.

Molto PostgreSQL.

Oggi impariamo le quattro azioni di base che userai continuamente:

• SELECT;
• INSERT;
• UPDATE;
• DELETE.

Questi sono i comandi principali per lavorare con i dati.

Ti permettono di:

• leggere dati;
• aggiungere dati;
• modificare dati;
• rimuovere dati.

Questo spesso si chiama CRUD.

CRUD significa:

Create
Read
Update
Delete

Non è la parola più bella.

Sembra qualcosa sotto una vecchia tastiera.

Ma è molto importante.

Quasi ogni applicazione fa CRUD.

Un blog.

Un negozio.

Un task manager.

Un sistema di prenotazioni.

Una dashboard.

Anche una moderna app super elegante con animazioni e gradienti emotivi probabilmente sta facendo CRUD da qualche parte sullo sfondo.

I database sono umili.

Ma potenti.

Cosa Imparerai

In questa lezione imparerai:

• come leggere righe con SELECT;
• come selezionare colonne specifiche;
• come aggiungere righe con INSERT;
• come inserire più righe;
• come modificare righe con UPDATE;
• perché WHERE è estremamente importante;
• come eliminare righe con DELETE;
• come evitare errori pericolosi da principiante;
• come praticare CRUD su una tabella reale.

Alla fine di questa lezione saprai lavorare con i dati in una tabella PostgreSQL.

Non solo creare tabelle.

Usarle davvero.

Qui il database inizia a sembrare vivo.

Un po’ spaventoso.

Ma vivo.

Prepara il Database

Apri PostgreSQL:

sudo -iu postgres psql

Connettiti al database delle lezioni precedenti:

\c learning_postgresql

Se non hai questo database, crealo:

CREATE DATABASE learning_postgresql;

Poi connettiti:

\c learning_postgresql

Ora ci serve una tabella per esercitarci.

Useremo una tabella chiamata products.

Se esiste già, puoi rimuoverla prima:

DROP TABLE IF EXISTS products;

Poi creala:

CREATE TABLE products (
  id SERIAL PRIMARY KEY,
  name VARCHAR(100) NOT NULL,
  category VARCHAR(100),
  price INTEGER,
  available BOOLEAN
);

Questa tabella salva prodotti.

Ogni prodotto ha:

• id;
• name;
• category;
• price;
• available.

Semplice.

Chiaro.

Pronto per l’azione.

La tabella del database è lì in piedi tipo:

Per favore, dammi dati.

Molto educata.

Per ora.

INSERT: Aggiungere Dati

INSERT aggiunge nuove righe a una tabella.

Esempio:

INSERT INTO products (name, category, price, available)
VALUES ('Laptop', 'Electronics', 900, true);

PostgreSQL dovrebbe dire:

INSERT 0 1

Significa che una riga è stata inserita.

Ora aggiungi altri prodotti:

INSERT INTO products (name, category, price, available)
VALUES ('Mouse', 'Electronics', 25, true);

INSERT INTO products (name, category, price, available)
VALUES ('Keyboard', 'Electronics', 70, false);

INSERT INTO products (name, category, price, available)
VALUES ('Desk Chair', 'Furniture', 150, true);

Ora abbiamo dati.

Righe reali.

La tabella non è più vuota.

Una tabella senza dati è come un negozio con scaffali ma senza prodotti.

Tecnicamente pronta.

Emotivamente triste.

Sintassi di INSERT

La struttura base è:

INSERT INTO table_name (column1, column2, column3)
VALUES (value1, value2, value3);

Per la nostra tabella:

INSERT INTO products (name, category, price, available)
VALUES ('Monitor', 'Electronics', 250, true);

Importante:

I valori testuali usano virgolette singole:

'Monitor'
'Electronics'

I numeri non usano virgolette:

250

I booleani usano:

true
false

PostgreSQL è severo.

Se scrivi testo senza virgolette, non indovinerà.

PostgreSQL non fa interpretazione emotiva.

Fa struttura.

Ed è per questo che ci piace.

Più o meno.

Inserire Più Righe

Puoi inserire più righe insieme.

Esempio:

INSERT INTO products (name, category, price, available)
VALUES
  ('Notebook', 'Office', 5, true),
  ('Pen', 'Office', 2, true),
  ('Desk Lamp', 'Furniture', 45, true);

Questo è utile quando vuoi aggiungere più righe in una volta.

Ora leggi la tabella:

SELECT * FROM products;

Dovresti vedere tutti i prodotti.

Se non li vedi, controlla:

• ti sei connesso al database corretto?
• hai creato la tabella?
• hai dimenticato un punto e virgola?
• PostgreSQL ha mostrato un errore?

PostgreSQL di solito dice la verità.

A volte brutalmente.

SELECT: Leggere Dati

SELECT legge dati da una tabella.

La query più semplice:

SELECT * FROM products;

Questo significa:

Dammi tutte le colonne da tutti i prodotti.

* significa tutte le colonne.

È utile per imparare.

Ma nelle applicazioni reali spesso è meglio selezionare solo le colonne necessarie.

Esempio:

SELECT name, price FROM products;

Questo mostra solo:

• name;
• price.

Molto più pulito.

PostgreSQL ama richieste precise.

Anche le persone.

Di solito.

SELECT con Colonne Specifiche

Prova:

SELECT name FROM products;

Questo restituisce solo i nomi dei prodotti.

Prova:

SELECT name, category FROM products;

Questo restituisce nomi e categorie.

Prova:

SELECT name, price, available FROM products;

Questo restituisce nomi, prezzi e disponibilità.

Non ti serve sempre tutto.

Se ti servono solo i nomi dei prodotti, chiedi solo i nomi.

Non chiedere tutto l’armadio del database.

Il database non è la tua valigia emotiva.

SELECT con ORDER BY

Puoi ordinare i risultati con ORDER BY.

Esempio:

SELECT name, price FROM products
ORDER BY price;

Questo ordina i prodotti per prezzo dal più basso al più alto.

Per ordinare dal più alto al più basso:

SELECT name, price FROM products
ORDER BY price DESC;

DESC significa descending.

Esiste anche ASC per ascending:

SELECT name, price FROM products
ORDER BY price ASC;

Ascending è il default.

Quindi questo:

ORDER BY price

è uguale a:

ORDER BY price ASC

Ordinare è utile.

Soprattutto quando i tuoi dati smettono di essere piccoli e carini.

SELECT con WHERE

WHERE filtra le righe.

Esempio:

SELECT * FROM products
WHERE category = 'Electronics';

Questo significa:

Dammi i prodotti dove la categoria è Electronics.

Altro esempio:

SELECT * FROM products
WHERE available = true;

Questo mostra solo i prodotti disponibili.

Altro:

SELECT * FROM products
WHERE price > 100;

Questo mostra i prodotti con prezzo maggiore di 100.

Nota importante per MDX e documentazione:

Quando scrivi operatori come >, <, >=, <= nel testo normale, mettili dentro backticks.

Nei blocchi SQL vanno bene.

MDX è sensibile.

Come PostgreSQL, ma con più drama frontend.

WHERE È Importante

WHERE è estremamente importante.

Dice a PostgreSQL quali righe vuoi.

Senza WHERE, i comandi spesso influenzano tutte le righe.

Questo va bene per:

SELECT * FROM products;

Ma è pericoloso per:

UPDATE products
SET price = 1;

Questo aggiorna ogni prodotto.

Tutti i prezzi diventano 1.

Complimenti.

Hai distrutto il negozio.

Molto generoso.

Molto male.

Pensa sempre prima di eseguire UPDATE o DELETE.

Soprattutto senza WHERE.

UPDATE: Modificare Dati

UPDATE modifica righe esistenti.

Esempio:

UPDATE products
SET price = 950
WHERE name = 'Laptop';

Questo modifica il prezzo del Laptop.

Ora controlla:

SELECT * FROM products
WHERE name = 'Laptop';

Dovresti vedere il prezzo aggiornato.

Struttura base:

UPDATE table_name
SET column_name = new_value
WHERE condition;

Esempio:

UPDATE products
SET available = true
WHERE name = 'Keyboard';

Questo rende disponibile la Keyboard.

Bene.

La tastiera è tornata in società.

Aggiornare Più Colonne

Puoi aggiornare più colonne insieme.

Esempio:

UPDATE products
SET price = 80,
    available = true
WHERE name = 'Keyboard';

Questo aggiorna:

• price;
• available.

Usa sempre WHERE, a meno che tu voglia davvero aggiornare ogni riga.

E se vuoi davvero aggiornare ogni riga, fermati e pensaci di nuovo.

Poi forse fallo.

Ma con attenzione.

Con caffè.

E backup.

L'Errore Pericoloso con UPDATE

Pericoloso:

UPDATE products
SET price = 10;

Questo aggiorna tutti i prodotti.

Ogni prodotto ora costa 10.

Laptop?

10.

Mouse?

10.

Desk Chair?

10.

Complimenti, hai inventato il fallimento economico.

Corretto:

UPDATE products
SET price = 10
WHERE name = 'Pen';

La clausola WHERE ti salva.

WHERE non è decorazione.

È una cintura di sicurezza.

Usala.

DELETE: Rimuovere Dati

DELETE rimuove righe da una tabella.

Esempio:

DELETE FROM products
WHERE name = 'Pen';

Questo elimina il prodotto chiamato Pen.

Ora controlla:

SELECT * FROM products;

La Pen dovrebbe essere sparita.

Nessun addio.

Nessuna cerimonia.

Solo SQL.

Struttura base:

DELETE FROM table_name
WHERE condition;

Di nuovo:

Usa WHERE.

Per favore.

L'Errore Pericoloso con DELETE

Pericoloso:

DELETE FROM products;

Questo elimina tutte le righe dalla tabella.

La tabella esiste ancora.

Ma tutti i dati sono spariti.

Vuota.

Silenziosa.

Come un frigo dopo una visita di adolescenti.

Corretto:

DELETE FROM products
WHERE name = 'Notebook';

Questo elimina solo Notebook.

Prima di eliminare, è intelligente testare la condizione con SELECT.

Esempio:

SELECT * FROM products
WHERE name = 'Notebook';

Se il risultato è corretto, allora esegui:

DELETE FROM products
WHERE name = 'Notebook';

Questa abitudine può salvarti dal dolore.

Dolore serio.

Dolore da database.

SELECT Prima di UPDATE o DELETE

Buona abitudine:

Prima di questo:

UPDATE products
SET price = 100
WHERE category = 'Office';

Esegui questo:

SELECT * FROM products
WHERE category = 'Office';

Prima di questo:

DELETE FROM products
WHERE available = false;

Esegui questo:

SELECT * FROM products
WHERE available = false;

Prima controlla le righe.

Poi aggiorna o elimina.

Questa non è paranoia.

È professionalità.

I professionisti dei database sono solo persone che hanno imparato la paura in modo strutturato.

RETURNING

PostgreSQL ha una funzione utile chiamata RETURNING.

Può mostrare le righe coinvolte da INSERT, UPDATE o DELETE.

Esempio:

INSERT INTO products (name, category, price, available)
VALUES ('Webcam', 'Electronics', 60, true)
RETURNING *;

Questo inserisce la riga e la mostra subito.

Esempio con update:

UPDATE products
SET price = 65
WHERE name = 'Webcam'
RETURNING *;

Esempio con delete:

DELETE FROM products
WHERE name = 'Webcam'
RETURNING *;

RETURNING è molto utile.

Ti permette di vedere cosa è successo.

PostgreSQL dice:

Ecco cosa ho modificato.

Molto educato.

Leggermente drammatico.

NULL in INSERT

Se una colonna permette NULL, puoi ometterla durante l’inserimento.

Esempio:

INSERT INTO products (name, price, available)
VALUES ('Mystery Box', 99, false);

Qui non abbiamo fornito category.

Se category permette NULL, PostgreSQL accetta.

Controlla:

SELECT * FROM products
WHERE name = 'Mystery Box';

Dovresti vedere un valore vuoto nella categoria.

Quello è NULL.

NULL significa valore mancante.

Non zero.

Non stringa vuota.

Mancante.

SQL prende i valori mancanti molto sul serio.

Come un detective.

Controlla la Tabella

A questo punto, esegui:

SELECT * FROM products;

Dovresti avere diverse righe.

Prova:

SELECT name, price FROM products
ORDER BY price DESC;

Prova:

SELECT * FROM products
WHERE available = true;

Prova:

SELECT * FROM products
WHERE category = 'Electronics';

Questa è pratica.

E la pratica è dove SQL diventa normale.

All’inizio SQL sembra strano.

Poi un giorno scrivi:

SELECT * FROM products WHERE available = true;

e sembra naturale.

È lì che il database ti ha accettato.

Forse.

Errori Comuni

Dimenticare il Punto e Virgola

Sbagliato:

SELECT * FROM products

Corretto:

SELECT * FROM products;

Se psql continua ad aspettare, probabilmente hai dimenticato ;.

PostgreSQL non è bloccato.

Sta aspettando che tu finisca la frase.

Molto formale.

Dimenticare le Virgolette per il Testo

Sbagliato:

WHERE name = Laptop;

Corretto:

WHERE name = 'Laptop';

Il testo ha bisogno di virgolette singole.

I nomi delle colonne no.

Questa distinzione conta.

PostgreSQL non indovina.

È un database, non tua nonna.

UPDATE Senza WHERE

Pericoloso:

UPDATE products
SET available = false;

Questo rende tutti i prodotti non disponibili.

Corretto:

UPDATE products
SET available = false
WHERE name = 'Keyboard';

WHERE salva i dati.

Rispetta WHERE.

DELETE Senza WHERE

Pericoloso:

DELETE FROM products;

Questo elimina tutte le righe.

Corretto:

DELETE FROM products
WHERE name = 'Keyboard';

Prima di eliminare, esegui una SELECT con la stessa condizione.

È una forte abitudine.

Tienila.

Pratica

Crea una tabella chiamata tasks.

CREATE TABLE tasks (
  id SERIAL PRIMARY KEY,
  title VARCHAR(150) NOT NULL,
  status VARCHAR(50),
  priority INTEGER
);

Inserisci attività:

INSERT INTO tasks (title, status, priority)
VALUES ('Learn SELECT', 'open', 1);

INSERT INTO tasks (title, status, priority)
VALUES ('Practice INSERT', 'open', 2);

INSERT INTO tasks (title, status, priority)
VALUES ('Be careful with DELETE', 'open', 3);

Leggi tutte le attività:

SELECT * FROM tasks;

Aggiorna un’attività:

UPDATE tasks
SET status = 'done'
WHERE title = 'Learn SELECT';

Elimina un’attività:

DELETE FROM tasks
WHERE title = 'Practice INSERT';

Leggi di nuovo:

SELECT * FROM tasks;

Questo ti dà pratica CRUD completa.

Tabella piccola.

Grande lezione.

Mini Challenge

Crea una tabella chiamata customers.

Deve avere:

• id;
• name;
• email;
• city;
• active.

Inserisci almeno cinque clienti.

Poi scrivi query per:

• mostrare tutti i clienti;
• mostrare solo nomi ed email;
• mostrare solo clienti attivi;
• aggiornare la città di un cliente;
• disattivare un cliente;
• eliminare un cliente.

Prima di ogni UPDATE o DELETE, esegui prima una SELECT con lo stesso WHERE.

Questa è l’abitudine.

Non opzionale.

Beh, tecnicamente opzionale.

Ma anche il casco lo è.

Hai capito.

Riepilogo

Oggi hai imparato:

• INSERT aggiunge righe;
• SELECT legge righe;
• UPDATE modifica righe;
• DELETE rimuove righe;
• WHERE filtra righe;
• ORDER BY ordina risultati;
• RETURNING mostra le righe coinvolte;
• i valori testuali vogliono virgolette singole;
• i booleani usano true o false;
• UPDATE senza WHERE modifica tutte le righe;
• DELETE senza WHERE elimina tutte le righe;
• controllare con SELECT prima di UPDATE o DELETE è un’abitudine professionale.

Questa è una delle lezioni più importanti del corso.

Con questi quattro comandi puoi fare il lavoro base di quasi ogni applicazione con database.

Creare dati.

Leggere dati.

Modificare dati.

Rimuovere dati.

Parole semplici.

Grande responsabilità.

PostgreSQL ti dà potere.

Usalo con attenzione.

Soprattutto vicino a DELETE.

Prossima Lezione

Nella prossima lezione impareremo tipi di dati e vincoli.

Vedremo:

• INTEGER;
• VARCHAR;
• TEXT;
• BOOLEAN;
• DATE;
• NOT NULL;
• UNIQUE;
• regole base per tabelle più sicure.

Perché i database non sono solo storage.

Sono anche guardiani della struttura.

Guardiani severi.

Con punti e virgola.