Gli attributi, esercizi spiegati
Cinque esempi, dalle schermate alle colonne
- 25 minuti di lettura
Cinque esempi, uno per ogni idea della teoria, ognuno in un'ambientazione diversa da Ritrovato. Hanno tutti lo stesso ritmo:
- Prevedi: leggi la richiesta e prima di aprire prova tu a rispondere, su un foglio.
- In italiano: cosa si decide, a parole.
- Passo per passo: le decisioni una alla volta.
- Cosa portiamo a casa: la cosa da ricordare.
Gli esempi con output li ho provati su PostgreSQL. Se vuoi provarli anche tu, crea un database tuo (createdb prove), poi psql -d prove e incolli.
A · Dalle schermate agli attributi
Tullio Fabbri ha un negozio di biciclette usate vicino a Ponte Ciclo. Compra biciclette da chi non le usa più, le sistema, le rivende. Nel suo canvas ci sono queste schermate e azioni:
- L'elenco delle biciclette in vendita: si vede il modello, la taglia del telaio e il prezzo; si filtra per tipo (città, corsa, pieghevole) e si ordina per prezzo.
- La scheda di una bicicletta: tutto quello che c'è nell'elenco, più le condizioni.
- «Compro»: Tullio registra una bicicletta in arrivo. Controlla il numero di telaio sul registro della polizia, per essere sicuro che non sia rubata.
- «Vendo»: segna a che prezzo e quando.
Il riquadro 6 dice solo «le biciclette: cosa sai di ognuna?». Una collega propone otto attributi: modello, tipo, taglia del telaio, prezzo, numero di telaio, condizioni, peso, colore dei pedali.
Quali tieni?
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
Per ogni attributo, quale schermata o azione lo usa:
| Attributo | Chi lo usa | Verdetto |
|---|---|---|
modello | elenco (mostro), scheda | dentro |
tipo | elenco (filtro) | dentro |
taglia_telaio_cm | elenco (mostro), scheda | dentro |
prezzo | elenco (mostro e ordino), «Vendo» | dentro |
numero_telaio | «Compro» (controllo con il registro) | dentro, e unico |
condizioni | scheda | dentro |
peso | nessuna | fuori |
colore_pedali | nessuna | fuori |
Più due che mancano e che le azioni chiedono. «Vendo» scrive quando: serve venduta_il. E scrive a che prezzo: Tullio può fare lo sconto, quindi non basta il prezzo di listino, serve anche prezzo_di_vendita. Tutti e due restano vuoti finché la bicicletta non è venduta.
In italiano. «Per ogni attributo mi chiedo chi lo usa. Se nessuno, lo tolgo. Poi rileggo le azioni per vedere se scrivono qualcosa che non ho ancora.»
Passo per passo. Si fa in due passaggi, uno per verso.
| Verso | Domanda | Risultato |
|---|---|---|
| Dagli attributi alle schermate | quale schermata mostra o filtra questo? | peso e colore_pedali non trovano nessuno |
| Dalle azioni agli attributi | cosa scrive o controlla «Compro»? «Vendo»? | «Compro» controlla numero_telaio; «Vendo» scrive quando e a che prezzo: servono venduta_il e prezzo_di_vendita |
Il secondo passaggio è quello che si salta di più. Leggere le azioni trova gli attributi che mancano, come il primo passaggio trova quelli di troppo.
Cosa portiamo a casa. Gli attributi si trovano scorrendo il canvas in due direzioni: dagli attributi alle schermate (per toglierne) e dalle azioni agli attributi (per aggiungerne).
B · Scegliere i tipi
La lavanderia self-service di Vecchia Fiera ha otto lavatrici. Il gestore vuole una scheda per ogni macchina: il numero, quanti chili porta, quanto costa un ciclo, quando è partito l'ultimo ciclo (vuoto se non è mai stata usata), il telefono per le emergenze e se è fuori uso.
Per ogni attributo scegli il tipo, e se serve un vincolo. Poi pensa: cosa va storto se scegli male?
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
| Attributo | Tipo | Perché |
|---|---|---|
numero | INTEGER | il numero stampato sulla macchina; unico |
capacita_kg | INTEGER | chili interi; maggiore di zero |
prezzo_ciclo | NUMERIC(4,2) | sono soldi |
ultimo_ciclo | TIMESTAMP | serve anche l'ora: se «è partita alle 8:40», un DATE non basta |
gestore_tel | TEXT | un telefono non è un numero: nessuna somma, e lo zero iniziale conta |
fuori_uso | BOOLEAN | sì o no; all'inizio no |
CREATE TABLE lavatrici (
id SERIAL PRIMARY KEY,
numero INTEGER NOT NULL UNIQUE,
capacita_kg INTEGER NOT NULL CHECK (capacita_kg > 0),
prezzo_ciclo NUMERIC(4,2) NOT NULL CHECK (prezzo_ciclo > 0),
ultimo_ciclo TIMESTAMP,
gestore_tel TEXT NOT NULL,
fuori_uso BOOLEAN NOT NULL DEFAULT false
); Table "public.lavatrici"
Column | Type | Collation | Nullable | Default
--------------+-----------------------------+-----------+----------+---------------------------------------
id | integer | | not null | nextval('lavatrici_id_seq'::regclass)
numero | integer | | not null |
capacita_kg | integer | | not null |
prezzo_ciclo | numeric(4,2) | | not null |
ultimo_ciclo | timestamp without time zone | | |
gestore_tel | text | | not null |
fuori_uso | boolean | | not null | false
Indexes:
"lavatrici_pkey" PRIMARY KEY, btree (id)
"lavatrici_numero_key" UNIQUE CONSTRAINT, btree (numero)
Check constraints:
"lavatrici_capacita_kg_check" CHECK (capacita_kg > 0)
"lavatrici_prezzo_ciclo_check" CHECK (prezzo_ciclo > 0::numeric)In italiano. «Ogni attributo ha il tipo che dice cosa è: un testo, un conto, dei soldi, un momento, un sì o no.»
Passo per passo. Le due scelte che meritano una domanda.
| Domanda | Risposta | Tipo |
|---|---|---|
| Ci faccio dei conti con il telefono? | No: nemmeno una somma. E 0212345678 perderebbe lo zero | TEXT |
| A Vecchia Fiera conta solo il giorno dell'ultimo ciclo? | No: serve per vedere quale macchina è ferma da ore | TIMESTAMP |
E ultimo_ciclo è facoltativo: vuoto vuol dire «mai usata». Lo vedi provando due macchine:
INSERT INTO lavatrici (numero, capacita_kg, prezzo_ciclo, gestore_tel) VALUES (1, 8, 4.50, '0212345678') RETURNING *; id | numero | capacita_kg | prezzo_ciclo | ultimo_ciclo | gestore_tel | fuori_uso
----+--------+-------------+--------------+--------------+-------------+-----------
1 | 1 | 8 | 4.50 | | 0212345678 | f
(1 row)La macchina 1 non è mai partita (ultimo_ciclo vuoto), il telefono ha il suo zero e fuori_uso ha preso f (falso) dal DEFAULT.
Cosa portiamo a casa. Il tipo si sceglie con due domande: «ci faccio dei conti?» (se no, testo) e «mi serve l'ora, o solo il giorno?». I soldi sono sempre NUMERIC.
C · Obbligatorio o facoltativo
Il banco dei fiori di Largo Lista prende ordini di bouquet. Ogni ordine ha un cliente, un bouquet e un prezzo. Chi vuole può aggiungere una dedica per il biglietto. Il bouquet si ritira al banco oppure si consegna: in quel caso serve l'indirizzo.
Quali attributi sono obbligatori? Per gli altri: cosa vuol dire il vuoto? E cosa risponde WHERE dedica <> '' se la dedica manca?
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
cliente,bouquet,prezzo: obbligatori. Senza uno dei tre non c'è un ordine.dedica: facoltativa. Vuoto vuol dire nessuna dedica.consegna_a: facoltativo. Vuoto vuol dire ritira al banco.
CREATE TABLE ordini_fiori (
id SERIAL PRIMARY KEY,
cliente TEXT NOT NULL,
bouquet TEXT NOT NULL,
prezzo NUMERIC(6,2) NOT NULL CHECK (prezzo > 0),
dedica TEXT,
consegna_a TEXT
);Con quattro ordini (Marta Villa con la dedica e l'indirizzo, Ernesto Pozzi senza niente, Dario Sala con la dedica da ritirare, Rita Bellini con l'indirizzo senza dedica):
SELECT cliente, bouquet FROM ordini_fiori WHERE dedica <> '' ORDER BY id; cliente | bouquet
-------------+------------
Marta Villa | Rose rosse
Dario Sala | Tulipani
(2 rows)Giusto, ma solo perché il vuoto è NULL: il confronto con NULL non dà vero, e le righe senza dedica restano fuori. Con un testo vuoto '' invece, dedica <> '' le escluderebbe per un altro motivo, e dedica IS NULL non ne troverebbe nessuna.
In italiano. «Obbligatorio se senza l'ordine non ha senso. Facoltativo se il vuoto vuol dire qualcosa che so dire a parole.»
Passo per passo. Il vuoto, usato bene, è un'informazione:
SELECT cliente, bouquet FROM ordini_fiori WHERE consegna_a IS NOT NULL ORDER BY id; cliente | bouquet
--------------+------------
Marta Villa | Rose rosse
Rita Bellini | Mimose
(2 rows)Sono le consegne da fare: gli ordini con un indirizzo. Non serve una colonna da_consegnare: si legge da consegna_a. E per contare:
SELECT COUNT(*) AS ordini, COUNT(consegna_a) AS da_consegnare, COUNT(dedica) AS con_dedica FROM ordini_fiori; ordini | da_consegnare | con_dedica
--------+---------------+------------
4 | 2 | 2
(1 row)COUNT(*) conta le righe, COUNT(colonna) conta solo quelle con un valore: i vuoti non ci sono.
Cosa portiamo a casa. Obbligatorio è il normale. Facoltativo si sceglie, e si scrive cosa vuol dire il NULL. Il vuoto ben scelto toglie colonne: consegna_a fa anche da «da consegnare».
D · Calcolato o salvato
Il parcheggio delle biciclette di Ponte Ciclo registra quando una bicicletta entra e quando esce. Chi esce paga: 50 centesimi se è rimasta meno di tre ore, un euro se di più. Sono i prezzi di oggi; domani potrebbero cambiare.
Il gestore vuole vedere: da quanto tempo è dentro una bicicletta, quali sono dentro adesso, quanto ha incassato. Propone cinque colonne: entrata_alle, uscita_alle, durata, e_dentro, importo. Quali sono salvate e quali calcolate?
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
entrata_alle: salvata. È il fatto di partenza.uscita_alle: salvata, facoltativa. Vuota vuol dire: è ancora dentro.durata: calcolata (uscita_alle - entrata_alle).e_dentro: calcolata (uscita_alle IS NULL).importo: salvata, ma con un nome diverso:importo_pagato. È una fotografia: quello che il cliente ha pagato davvero. Se domani il prezzo sale, le soste di ieri non cambiano.
CREATE TABLE soste (
id SERIAL PRIMARY KEY,
targa_bici TEXT NOT NULL,
entrata_alle TIMESTAMP NOT NULL,
uscita_alle TIMESTAMP CHECK (uscita_alle >= entrata_alle),
importo_pagato NUMERIC(4,2) CHECK (importo_pagato >= 0)
);In italiano. «Quello che si può ricavare dagli altri attributi non lo salvo. Quello che è un fatto del momento (quanto ho incassato, a quel prezzo) lo salvo.»
Passo per passo. Con tre soste (due uscite, una ancora dentro):
SELECT targa_bici, uscita_alle - entrata_alle AS durata FROM soste WHERE uscita_alle IS NOT NULL ORDER BY id; targa_bici | durata
------------+----------
PC-0412 | 10:30:00
PC-0098 | 02:30:00
(2 rows)SELECT targa_bici FROM soste WHERE uscita_alle IS NULL; targa_bici
------------
PC-0733
(1 row)La bicicletta PC-0733 è dentro: nessuna colonna e_dentro, la risposta viene da uscita_alle. E l'incasso:
SELECT SUM(importo_pagato) AS incassato FROM soste; incassato
-----------
1.50
(1 row)Perché importo_pagato si salva e durata no? La domanda della teoria: se domani cambia l'originale, questo dato deve cambiare? La durata dipende solo da entrata e uscita, che non cambiano: la ricalcoli ogni volta e non puoi sbagliare. L'importo dipende dal prezzo di quel giorno: se lo ricalcolassi con il prezzo di domani, l'incasso di ieri cambierebbe.
Cosa portiamo a casa. Si salvano i fatti. Si calcolano le conseguenze. Le soste di ieri hanno pagato il prezzo di ieri: quando il prezzo di un dato cambia nel tempo, quello che è già successo si fotografa.
E · Uno schema rivisto con le domande
Il dopolavoro ha un laboratorio di ceramica. Un compagno ti passa il suo schema, scritto di fretta, e ti chiede di rileggerlo con le sei domande sugli attributi e le dieci di SQL.
CREATE TABLE Iscritti (
id SERIAL PRIMARY KEY,
nome_testo TEXT,
Email TEXT,
eta INTEGER,
materiali TEXT,
quota REAL,
carta_di_credito TEXT,
giorni_di_iscrizione INTEGER,
livello TEXT
);Trova più problemi che puoi (almeno sette). Poi riscrivi lo schema.
Prevedi Scrivi su un foglio cosa ti aspetti, poi apri.
| Cosa non va | Quale domanda lo trova |
|---|---|
Iscritti, Email: maiuscole. E nome_testo: il tipo nel nome | 2 (i nomi) |
| Tutto è facoltativo, perfino il nome: si salva una riga vuota | 3 (i NULL) |
Email non è UNIQUE: due iscritti con la stessa email | 3 (unico) |
eta: si calcola da una data di nascita | 5 (calcolato) |
materiali contiene 'argilla, smalti': una lista in una colonna | SQL 5 (le liste) |
quota REAL: i soldi in virgola mobile | 4 (i tipi) |
carta_di_credito: nessuna schermata ne ha bisogno, e il numero intero è un rischio | 1 e 6 |
giorni_di_iscrizione: calcolato, e già sbagliato domani | 5 |
livello: testo libero, anche «quasi esperta» | 5 dei valori ammessi (CHECK) |
Sono nove. Lo schema riscritto:
CREATE TABLE iscritti_ceramica (
id SERIAL PRIMARY KEY,
nome TEXT NOT NULL,
email TEXT NOT NULL UNIQUE,
nato_il DATE NOT NULL,
livello TEXT NOT NULL DEFAULT 'principiante' CHECK (livello IN ('principiante', 'intermedio', 'esperto')),
quota NUMERIC(6,2) NOT NULL CHECK (quota > 0),
iscritto_il DATE NOT NULL DEFAULT CURRENT_DATE
);
CREATE TABLE materiali_scelti (
iscritto_id INTEGER NOT NULL REFERENCES iscritti_ceramica(id),
materiale TEXT NOT NULL,
PRIMARY KEY (iscritto_id, materiale)
);In italiano. «Tolgo quello che si calcola (età, giorni), quello che non serve (la carta), e sposto la lista in una tabella. Poi metto i vincoli: tutto obbligatorio, email unica, livello tra tre parole.»
Passo per passo. Prima di correggere, guarda cosa accetta lo schema brutto, senza nessun errore:
INSERT INTO Iscritti (nome_testo, Email, eta, materiali, quota, carta_di_credito, giorni_di_iscrizione, livello)
VALUES ('Rosa Bellini', 'rosa@esempio.it', 34, 'argilla, smalti', 60, '4539 1488 0343 6467', 0, 'quasi esperta');
INSERT INTO Iscritti (Email) VALUES ('rosa@esempio.it');
SELECT COUNT(*) AS usano_gli_smalti FROM Iscritti WHERE materiali = 'smalti'; usano_gli_smalti
------------------
0
(1 row)Una riga quasi vuota, la stessa email due volte, e Rosa usa gli smalti ma il conteggio dice zero: il testo 'argilla, smalti' non è uguale a 'smalti'. Con lo schema riscritto gli stessi dati sono respinti o ordinati:
INSERT INTO iscritti_ceramica (nome, email, nato_il, livello, quota) VALUES ('Rosa Bellini', 'rosa@esempio.it', '1992-04-03', 'quasi esperta', 60);ERROR: new row for relation "iscritti_ceramica" violates check constraint "iscritti_ceramica_livello_check"
DETAIL: Failing row contains (1, Rosa Bellini, rosa@esempio.it, 1992-04-03, quasi esperta, 60.00, 2026-11-19).E con il livello giusto (qui lasciato al DEFAULT) e i materiali in una riga ciascuno:
SELECT COUNT(*) AS usano_gli_smalti FROM materiali_scelti WHERE materiale = 'smalti'; usano_gli_smalti
------------------
1
(1 row)Cosa portiamo a casa. Rileggere uno schema significa fargli le domande una per una. Uno schema sbagliato non dà errori: i guai arrivano dalle risposte sbagliate, mesi dopo.