Indipendenza logica e fisica dei dati
La ragione per cui una base di dati sopravvive dieci anni mentre le applicazioni vengono riscritte è che può cambiare a un livello senza rompere gli altri. Questa lezione spiega i due tipi di indipendenza e come si realizzano davvero.
Base
Obiettivi di apprendimento
- Descrivere i tre livelli di descrizione dei dati e che cosa contiene ciascuno
- Definire con precisione l'indipendenza logica e quella fisica
- Spiegare quale meccanismo fornisce ciascun tipo di indipendenza
- Riconoscere le modifiche di schema sicure e quelle che rompono le applicazioni
- Spiegare perché l'indipendenza è un obbligo di progetto, non una funzione del DBMS
Prerequisiti
- Introduzione alle basi di dati
- I DBMS: definizione e funzionalità
Introduzione
Una biblioteca installa una base di dati nel 2015. Nel 2018 la tabella dei prestiti viene divisa in due. Nel 2021 il motore di memorizzazione passa da MyISAM a InnoDB. Nel 2024 una colonna viene rinominata. Per tutto questo tempo l'applicazione al banco scritta nel 2015 continua a funzionare — solo la rinomina del 2024 richiede un rilascio coordinato.
Non è fortuna. È la proprietà economicamente più importante della tecnologia delle basi di dati, e ha un nome: indipendenza dei dati. L'idea è che una base di dati è descritta a più livelli, e ogni livello può cambiare senza obbligare a cambiare gli altri.
I tre livelli di descrizione
I tre livelli
- Il livello fisico (livello interno) descrive come i dati sono memorizzati: file, pagine, indici, compressione, partizionamento, cifratura.
- Il livello logico (livello concettuale) descrive quali dati sono memorizzati: entità, attributi, tipi, chiavi, vincoli, relazioni — indipendentemente da ogni decisione di memorizzazione.
- Il livello esterno (livello delle viste) descrive che cosa vede ciascun gruppo di utenti: un sottoinsieme dello schema logico, eventualmente riorganizzato, eventualmente con valori derivati.
Una sola base di dati di biblioteca, descritta ai tre livelli:
| Livello | Descrizione | Esempio |
|---|---|---|
| Fisico | Strutture di memorizzazione | prestito in un albero B+ clusterizzato su (socio, dataInizio); indice secondario su copia; pagine da 16 KB; InnoDB |
| Logico | Il modello completo | socio(codice, cognome, nome, ...), prestito(id, socio, copia, dataInizio, dataScadenza, dataRestituzione) con chiavi e vincoli |
| Esterno | Viste per ruolo | Il banco vede v_prestiti_banco (senza codice fiscale); il direttore vede v_statistiche_mensili; il socio vede v_miei_prestiti |
livello esterno v_banco v_direzione v_socio ← uno per gruppo di utenti
\ | /
\ | /
livello logico ───── lo schema concettuale completo ─────
|
livello fisico ───── file, pagine, indici, motore ─────
Indipendenza logica dei dati
Indipendenza logica
L'indipendenza logica dei dati è la capacità di modificare lo schema logico — aggiungere una tabella, aggiungere una colonna, dividere una tabella, introdurre una relazione — senza modificare le applicazioni che usano la base di dati, a condizione che accedano ai dati attraverso il livello esterno.
Concretamente: la biblioteca decide di registrare l'indirizzo e-mail del socio. Esegue ALTER TABLE socio ADD COLUMN email VARCHAR(120). L'applicazione al banco, che legge codice, cognome, nome, telefono, non è toccata: non ha mai chiesto email, e SELECT in SQL nomina le proprie colonne.
Funziona grazie a una proprietà facile da sottovalutare: aggiungere è sicuro, togliere non lo è.
| Modifica dello schema logico | Effetto sulle applicazioni esistenti |
|---|---|
| Aggiungere una colonna nullable | Sicura — nessuno l'ha chiesta |
Aggiungere una colonna con DEFAULT |
Sicura — gli insert esistenti funzionano ancora |
| Aggiungere una nuova tabella | Sicura |
| Aggiungere un indice | Sicura (è fisica) |
| Rinominare una colonna | Rompe ogni SELECT che la nomina |
| Rimuovere una colonna | Rompe ogni SELECT che la nomina |
| Cambiare il tipo di una colonna | Rompe se il nuovo tipo è incompatibile |
| Dividere una tabella in due | Rompe, a meno che una vista non preservi la vecchia forma |
Aggiungere un NOT NULL senza default |
Rompe gli insert esistenti |
Le ultime tre sono i casi in cui l'indipendenza logica va realizzata invece che sperata: la risposta è la vista.
Le viste come meccanismo dell'indipendenza logica
Supponiamo che la biblioteca divida socio in socio (identità e contatti) e socio_abbonamento (storico degli abbonamenti). Ogni applicazione che faceva SELECT codice, cognome, abbonamento FROM socio ora fallisce.
La soluzione disciplinata: prima della divisione, creare una vista con la vecchia forma e far usare quella alle applicazioni.
-- prima della divisione, le applicazioni usano questa vista
CREATE VIEW v_socio AS
SELECT codice, cognome, nome, telefono, abbonamento, dataIscrizione
FROM socio;
-- dopo la divisione la vista viene ridefinita; le applicazioni sono intatte
CREATE OR REPLACE VIEW v_socio AS
SELECT s.codice, s.cognome, s.nome, s.telefono,
a.tipo AS abbonamento, s.dataIscrizione
FROM socio s
LEFT JOIN socio_abbonamento a ON a.socio = s.codice AND a.corrente = 1;
Le applicazioni non si sono accorte di nulla. Questa è l'indipendenza logica in azione: lo schema esterno è rimasto stabile mentre lo schema logico cambiava sotto.
Indipendenza fisica dei dati
Indipendenza fisica
L'indipendenza fisica dei dati è la capacità di modificare lo schema fisico — indici, motore di memorizzazione, organizzazione dei file, partizionamento, compressione — senza modificare lo schema logico né le applicazioni.
Concretamente: il report sui prestiti per copia è lento. Il DBA crea un indice:
CREATE INDEX idx_prestito_copia ON prestito (copia);
Nessuna applicazione cambia. Nessun SQL cambia. Il testo dell'interrogazione è identico; cambia il piano. Questa è l'indipendenza fisica: lo schema logico è lo stesso, le applicazioni sono le stesse, sono cambiate solo le decisioni di memorizzazione.
| Modifica fisica | Visibile alle applicazioni? |
|---|---|
| Creare o eliminare un indice secondario | No |
| Cambiare il motore di memorizzazione (MyISAM → InnoDB) | No, se le funzionalità usate sono le stesse |
| Partizionare una tabella grande | No |
| Comprimere una tabella | No |
| Spostare una tabella in un altro tablespace | No |
| Cambiare la dimensione delle pagine | No |
| Cambiare la chiave di clusterizzazione | No (ma può cambiare drasticamente le prestazioni) |
L'indipendenza fisica è quasi assoluta nei DBMS relazionali, ed è il motivo per cui lo stesso SQL gira su un portatile e su un cluster. Le eccezioni riguardano le prestazioni, non la correttezza: una modifica fisica può rendere un'interrogazione cento volte più veloce o più lenta, e l'applicazione non saprà perché.
Come il DBMS fornisce l'indipendenza
L'indipendenza non è automatica: è realizzata da due corrispondenze (mapping) che il DBMS mantiene.
schema esterno/i ──[ corrispondenza esterno/logico ]──▶ schema logico
schema logico ──[ corrispondenza logico/fisico ]──▶ schema fisico
- La corrispondenza esterno/logico traduce la definizione di una vista in un'interrogazione sullo schema logico. È ciò che permette allo schema logico di cambiare mentre le viste restano stabili.
- La corrispondenza logico/fisico traduce tabelle e colonne in file, pagine e accessi a indice. È ciò che permette alla memorizzazione di cambiare mentre lo schema logico resta stabile.
Entrambe le corrispondenze vivono nel catalogo. Quando scrivi SELECT * FROM v_socio, il processore di query espande la vista attraverso la prima corrispondenza e poi pianifica l'accesso attraverso la seconda. Non ne vedi mai nessuna delle due.
| Tipo di indipendenza | Cambia a questo livello | Non influenza | Fornita da |
|---|---|---|---|
| Logica | Schema logico | Schema esterno e applicazioni | Viste + corrispondenza esterno/logico |
| Fisica | Schema fisico | Schema logico e applicazioni | Motore di memorizzazione + corrispondenza logico/fisico |
Dove l'indipendenza si rompe
Un approccio onesto richiede di nominare i limiti.
1. Applicazioni che aggirano il livello esterno
Un'applicazione con SELECT * è accoppiata alla forma della tabella: aggiungere una colonna cambia il suo result set e può rompere la deserializzazione. Un'applicazione che interroga le tabelle di base invece delle viste è accoppiata allo schema logico. L'indipendenza è una disciplina che l'applicazione deve rispettare.
2. ORM che rispecchiano lo schema
Un object-relational mapper genera classi dalle tabelle. Aggiungi una colonna NOT NULL senza default e la classe generata la richiede; rinomina una colonna e il mapping si rompe. L'ORM reintroduce esattamente l'accoppiamento che l'indipendenza dei dati elimina — a meno che il mapping non sia mantenuto deliberatamente.
3. Cambiamento semantico
Aggiungere una colonna è strutturalmente sicuro. Cambiare che cosa una colonna significa — da "abbonamento corrente" a "abbonamento al momento del prestito" — non è mai sicuro, qualunque cosa dicano le viste. L'indipendenza strutturale non può proteggere da un cambiamento di significato.
4. Vincoli che rifiutano i dati esistenti
ALTER TABLE ... ADD CONSTRAINT ... NOT NULL fallisce se esistono valori nulli. ADD FOREIGN KEY fallisce se esistono orfani. Non sono fallimenti dell'indipendenza ma della qualità dei dati: il DBMS sta dicendo che lo stato corrente non soddisfa la nuova regola. La soluzione è una migrazione dei dati, non un trucco sullo schema.
5. Accoppiamento sulle prestazioni
L'indipendenza fisica garantisce che una modifica fisica non rompa la correttezza. Non garantisce che non rompa un livello di servizio. Un indice eliminato per errore trasforma un'interrogazione da 5 ms in 40 secondi; nulla fallisce e tutto è in fiamme.
Un esempio completo
La tabella prestito della biblioteca è cresciuta fino a 4 milioni di righe. Nello stesso anno devono accadere tre cose: un audit impone che il codice fiscale del socio non sia mai visibile agli operatori al banco; il report dei prestiti diventa troppo lento; lo schema deve registrare quale dipendente ha registrato ciascun prestito.
Passo 1 — livello esterno (sicurezza). Creare una vista senza la colonna sensibile, e concedere al ruolo del banco l'accesso solo alla vista:
CREATE VIEW v_prestito_banco AS
SELECT p.id, p.socio, p.copia, p.dataInizio, p.dataScadenza, p.dataRestituzione
FROM prestito p;
REVOKE ALL ON prestito FROM 'desk'@'%';
GRANT SELECT, INSERT, UPDATE ON v_prestito_banco TO 'desk'@'%';
L'applicazione al banco cambia la sua clausola FROM una volta. Dopo, la tabella sottostante può guadagnare colonne liberamente.
Passo 2 — livello fisico (prestazioni). Aggiungere l'indice che serve al report:
CREATE INDEX idx_prestito_dataInizio ON prestito (dataInizio, socio);
Nessun cambiamento logico, nessun cambiamento applicativo.
Passo 3 — livello logico (nuovo fatto). Aggiungere la colonna, con un default, così che gli insert esistenti continuino a funzionare:
ALTER TABLE prestito ADD COLUMN registratoDa VARCHAR(40) NULL;
Le applicazioni esistenti non sono toccate: non nominano la colonna, e la colonna accetta NULL. La vista v_prestito_banco non la espone, quindi il banco non la vede finché l'applicazione non è pronta.
Tre modifiche a tre livelli, e esattamente una riga di codice applicativo è cambiata — quella che doveva, perché il banco aveva davvero bisogno di vedere qualcosa di nuovo.
Classifica la modifica
Per ciascuna modifica indica (a) a quale livello appartiene, (b) se è sicura per applicazioni esistenti che accedono tramite viste e nominano le colonne, e (c) quale meccanismo ripristina o preserva l'indipendenza quando non è sicura.
CREATE INDEX idx_socio_cognome ON socio (cognome);ALTER TABLE socio ADD COLUMN email VARCHAR(120) NULL;ALTER TABLE socio RENAME COLUMN telefono TO cellulare;- Dividere
prestitoinprestitoeprestito_storico. - Cambiare il motore da MyISAM a InnoDB.
ALTER TABLE socio ADD CONSTRAINT uq_email UNIQUE (email);quando tre soci condividono un indirizzo e-mail.ALTER TABLE prestito ADD COLUMN registratoDa VARCHAR(40) NOT NULL;- Partizionare
prestitoper anno didataInizio. - Ridefinire
v_socioin modo cheabbonamentorestituisca l'abbonamento al momento del prestito invece di quello corrente. - Eliminare un indice su cui si basava un report notturno.
Mostra la soluzione commentata
1. Fisica. Sicura. Nulla di logico è cambiato; può cambiare solo il piano (in meglio).
2. Logica. Sicura: la colonna è nullable e nessuna applicazione la nomina. È l'esempio canonico di indipendenza logica.
3. Logica. Non sicura — ogni SELECT che nomina telefono fallisce. Meccanismo: creare una vista v_socio che espone telefono AS cellulare prima della rinomina, far usare la vista alle applicazioni, poi rinominare e ridefinire la vista. Nota l'ordine: la vista deve esistere prima della modifica, altrimenti c'è una finestra in cui le applicazioni si rompono.
4. Logica. Non sicura in generale, perché una riga che era una ora sono due. Meccanismo: una vista che unisce le due tabelle per riprodurre la vecchia forma. Ma vedi il punto 9: se la divisione cambia la cardinalità vista dall'applicazione, una vista può nascondere la struttura e non la semantica.
5. Fisica. Sicura, purché le funzionalità usate esistano nel nuovo motore (InnoDB supporta transazioni e chiavi esterne, MyISAM no — quindi i vincoli dello schema logico possono essere coinvolti). È un buon esempio di modifica fisicamente indipendente che può rivelare una lacuna logica.
6. Logica. Non sicura — l'istruzione fallirà, perché i dati correnti violano il vincolo. Il meccanismo non è una vista ma una migrazione dei dati: riconciliare i duplicati (sono tre soci che condividono una casella, o un errore di inserimento?) e solo allora aggiungere il vincolo. Il DBMS sta correttamente rifiutando di accettare una regola che i dati non soddisfano.
7. Logica. Non sicura: gli INSERT esistenti che non nominano registratoDa falliranno. Due strade sicure: aggiungerla nullable, popolarla, poi aggiungere il NOT NULL; oppure aggiungerla con un DEFAULT. Entrambe sono il pattern standard di migrazione in tre passi.
8. Fisica. Sicura. Il partizionamento è una decisione di memorizzazione; le interrogazioni sono immutate e l'ottimizzatore può usare il partition pruning.
9. Questo è il caso interessante: non è affatto una modifica strutturale, è una modifica semantica. Strutturalmente la vista restituisce ancora una riga per socio con una colonna chiamata abbonamento. Un'applicazione compilata contro di essa continuerà a funzionare e comincerà silenziosamente a rispondere a un'altra domanda. Nessun livello di indipendenza dei dati protegge da questo, perché il cambiamento è in che cosa significano i dati. Richiede un rilascio coordinato, un nuovo nome di colonna, o entrambi. L'indipendenza strutturale non è indipendenza semantica.
10. Fisica. Strutturalmente sicura, operativamente pericolosa: la correttezza è preservata, le prestazioni no. È per questo che l'indipendenza fisica viene descritta come protezione della correttezza, non dei livelli di servizio.
Che cosa insegna questo esercizio. L'indipendenza non è un interruttore. È un insieme di abitudini: nomina le colonne, leggi tramite viste, modifica lo schema per passi additivi, e tratta i cambiamenti di significato come la categoria separata e pericolosa che sono.
Errori comuni
- "
SELECT *è comodo." È il modo più affidabile di distruggere l'indipendenza logica. La forma del result set diventa un contratto implicito. - "Le viste rallentano tutto." Una vista viene espansa nell'interrogazione e ottimizzata insieme a essa. Una vista semplice su una tabella di solito non costa nulla. Una vista con join e aggregati pesanti costa quanto costano i join — cioè quanto costerebbe comunque l'interrogazione vera.
- "L'indipendenza fisica significa che non devo pensare agli indici." Significa che un indice sbagliato non corrompe i dati. Significa che un indice sbagliato rende il sistema inutilizzabile alle due di notte.
- "Se compila, la modifica è sicura." I cambiamenti semantici compilano perfettamente e rompono il business.
- "Rinomino la colonna e sistemo il codice dopo." L'indipendenza richiede che la vista esista prima della modifica; "dopo" è il disservizio.
- "Il DBMS mi dà l'indipendenza automaticamente." Ti dà le corrispondenze. Devi usare le viste, nominare le colonne e modificare in modo additivo.
Riepilogo
- Una base di dati è descritta a tre livelli: fisico (come è memorizzata), logico (che cosa è memorizzato), esterno (che cosa vede ciascun utente).
- L'indipendenza logica — lo schema logico cambia senza toccare le applicazioni — è fornita dalle viste e dalla corrispondenza esterno/logico.
- L'indipendenza fisica — lo schema fisico cambia senza toccare lo schema logico né le applicazioni — è fornita dal motore di memorizzazione e dalla corrispondenza logico/fisico.
- Aggiungere è sicuro; rimuovere, rinominare e irrigidire non lo sono. Il pattern di migrazione sicuro è additivo: aggiungi nullable, popola, poi vincola.
- L'indipendenza protegge la correttezza, non le prestazioni e non il significato. I cambiamenti semantici e gli errori sugli indici sono fuori dal suo ambito.
- L'indipendenza è una disciplina: colonne nominate, accesso tramite viste, migrazioni additive.
Domande di verifica
- Quale livello contiene i dati veri e propri, e che cosa contengono gli altri due?
- Fornisci una modifica logicamente indipendente e una che non lo è, e spiega la differenza in termini di ciò da cui dipende un'applicazione.
- Che cosa protegge esattamente una vista, e che cosa non protegge?
- Perché
ALTER TABLE socio ADD COLUMN email VARCHAR(120) NOT NULL;rompe le applicazioni mentre... NULL;no? - Un'interrogazione diventa lenta dopo un anno, senza modifiche al codice né allo schema. È un fallimento dell'indipendenza fisica? Spiega.
Mostra le risposte
-
Solo il livello fisico contiene dati. Il livello logico contiene la descrizione delle tabelle e dei vincoli; il livello esterno contiene le definizioni delle viste. Entrambi sono metadati nel catalogo.
-
Logicamente indipendente: aggiungere una colonna nullable — le applicazioni che nominano le colonne non la referenziano mai, quindi nulla di ciò da cui dipendono è cambiato. Non indipendente: rinominare una colonna — le applicazioni dipendono dal nome, che fa parte del contratto esterno. Il criterio è: la modifica altera qualcosa che l'applicazione menziona esplicitamente?
-
Una vista protegge le applicazioni dalle modifiche alla struttura delle tabelle sottostanti e può limitare quali colonne e righe vede un ruolo. Non protegge dai cambiamenti di significato, non protegge le applicazioni che la aggirano, ed è spesso di sola lettura quando contiene join o aggregati, quindi le scritture tramite essa possono non essere possibili.
-
Perché gli
INSERTesistenti che non nominanoemailinserirebberoNULL, cheNOT NULLvieta — ogni insert fallisce. ConNULLammesso le stesse istruzioni riescono e la nuova colonna resta vuota finché l'applicazione non comincia a popolarla. È il principio della migrazione additiva. -
No — è una conseguenza dell'indipendenza fisica che funziona come progettata. Nulla si è rotto; l'ottimizzatore ha semplicemente scelto un piano diverso perché sono cambiati il volume dei dati e le statistiche. L'indipendenza fisica garantisce che le modifiche fisiche non rompano la correttezza, non che le prestazioni siano invarianti. La soluzione è fisica: esaminare il piano con
EXPLAINe aggiungere o correggere gli indici (Modulo 7).
Dove andare adesso
- L'architettura a tre livelli ANSI/SPARC: la formalizzazione standard di questi tre livelli.
- Basi di dati relazionali e non relazionali: quali famiglie preservano queste garanzie e quali le cedono.
- Le fasi della progettazione di una base di dati: dove ciascun livello viene prodotto nel processo di progettazione.
- I DBMS: definizione e funzionalità: i componenti che mantengono le corrispondenze.