Fondamenti delle basi di dati

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.

Intermediate

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.

  1. CREATE INDEX idx_socio_cognome ON socio (cognome);
  2. ALTER TABLE socio ADD COLUMN email VARCHAR(120) NULL;
  3. ALTER TABLE socio RENAME COLUMN telefono TO cellulare;
  4. Dividere prestito in prestito e prestito_storico.
  5. Cambiare il motore da MyISAM a InnoDB.
  6. ALTER TABLE socio ADD CONSTRAINT uq_email UNIQUE (email); quando tre soci condividono un indirizzo e-mail.
  7. ALTER TABLE prestito ADD COLUMN registratoDa VARCHAR(40) NOT NULL;
  8. Partizionare prestito per anno di dataInizio.
  9. Ridefinire v_socio in modo che abbonamento restituisca l'abbonamento al momento del prestito invece di quello corrente.
  10. 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.
  • 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

  1. Quale livello contiene i dati veri e propri, e che cosa contengono gli altri due?
  2. Fornisci una modifica logicamente indipendente e una che non lo è, e spiega la differenza in termini di ciò da cui dipende un'applicazione.
  3. Che cosa protegge esattamente una vista, e che cosa non protegge?
  4. Perché ALTER TABLE socio ADD COLUMN email VARCHAR(120) NOT NULL; rompe le applicazioni mentre ... NULL; no?
  5. Un'interrogazione diventa lenta dopo un anno, senza modifiche al codice né allo schema. È un fallimento dell'indipendenza fisica? Spiega.
Mostra le risposte
  1. 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.

  2. 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?

  3. 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.

  4. Perché gli INSERT esistenti che non nominano email inserirebbero NULL, che NOT NULL vieta — ogni insert fallisce. Con NULL ammesso le stesse istruzioni riescono e la nuova colonna resta vuota finché l'applicazione non comincia a popolarla. È il principio della migrazione additiva.

  5. 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 EXPLAIN e aggiungere o correggere gli indici (Modulo 7).

Dove andare adesso

Lezioni correlate