Guida SQLite interattiva: Viste

Q: Cos'è una vista in SQLite?

Una vista è un'istruzione SELECT salvata che puoi interrogare come una tabella. Non memorizza dati: ogni volta che la leggi, SQLite riesegue la query sottostante. Le viste sono utili per dare un nome una volta sola a una query complessa e riutilizzarla ovunque, o per nascondere colonne che chi la usa non deve vedere.

Q: Si può fare INSERT o UPDATE attraverso una vista in SQLite?

Non direttamente. In SQLite le viste sono in sola lettura: INSERT, UPDATE e DELETE su una vista falliscono. Puoi rendere scrivibile una vista collegandole dei trigger INSTEAD OF che traducono la scrittura in operazioni sulle tabelle sottostanti.

Q: Come si elencano tutte le viste di un database SQLite?

Interroga sqlitemaster: SELECT name FROM sqlitemaster WHERE type = 'view';. Nella CLI, .schema mostra le istruzioni CREATE VIEW e .tables elenca le viste insieme alle tabelle.

Una vista è una query salvata

Una vista è un'istruzione SELECT con un nome. Una volta creata, puoi interrogarla come una tabella, ma non viene memorizzato niente. Ogni volta che leggi da una vista, SQLite esegue da capo la query sottostante.

CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    customer TEXT,
    amount REAL,
    status TEXT
);

INSERT INTO orders (customer, amount, status) VALUES
    ('Ada', 120.00, 'paid'),
    ('Boris', 45.50, 'pending'),
    ('Rosa', 300.00, 'paid'),
    ('Boris', 80.00, 'paid');

CREATE VIEW paid_orders AS
SELECT customer, amount FROM orders WHERE status = 'paid';

SELECT * FROM paid_orders;

paid_orders ha l'aspetto e il comportamento di una tabella. Ha delle colonne, puoi farci SELECT, puoi usarla in un join. Ma sotto il cofano ogni query si espande nel filtro originale WHERE status = 'paid'.

Questo è tutto il modello mentale: una vista è un alias per una query.

Perché le viste sono utili

Il vantaggio principale è il nome. Una query complicata riceve un nome breve e descrittivo, e il resto del codice resta leggibile:

CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    customer TEXT,
    amount REAL,
    status TEXT
);

INSERT INTO orders (customer, amount, status) VALUES
    ('Ada', 120.00, 'paid'),
    ('Rosa', 300.00, 'paid'),
    ('Boris', 80.00, 'paid');

CREATE VIEW customer_totals AS
SELECT customer, SUM(amount) AS total, COUNT(*) AS order_count
FROM orders
WHERE status = 'paid'
GROUP BY customer;

SELECT * FROM customer_totals WHERE total > 100;

Senza la vista, chiunque la usi dovrebbe scriversi da solo il GROUP BY, e chiunque potrebbe sbagliare il filtro. Con la vista, l'aggregazione è definita una volta sola. Chi la usa chiede semplicemente customer_totals e aggiunge sopra i filtri che gli servono.

Le viste funzionano anche come confine in stile permessi. Se una query non deve esporre una colonna password_hash, crea una vista che seleziona tutto tranne quella colonna e fai usare la vista al codice dell'applicazione.

Sintassi di CREATE VIEW

La forma completa:

CREATE [TEMPORARY] VIEW [IF NOT EXISTS] view_name [(column_aliases)] AS
SELECT ...;

Alcune cose da sapere:

IF NOT EXISTS salta in silenzio la creazione se la vista esiste già.
TEMPORARY (o TEMP) crea una vista che sparisce quando la connessione si chiude.
Gli alias di colonna tra parentesi ti permettono di rinominare le colonne della vista senza toccare la SELECT sottostante.

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price_cents INTEGER
);

INSERT INTO products (name, price_cents) VALUES
    ('Notebook', 450),
    ('Pen', 200);

CREATE VIEW IF NOT EXISTS price_list (item, dollars) AS
SELECT name, price_cents / 100.0 FROM products;

SELECT * FROM price_list;

La vista espone nomi più comodi (item, dollars) senza rinominare le colonne della tabella di origine.

Sostituire ed eliminare le viste

SQLite non ha CREATE OR REPLACE VIEW né ALTER VIEW. Per cambiare la definizione di una vista, eliminala e ricreala:

CREATE TABLE orders (id INTEGER, status TEXT);
INSERT INTO orders VALUES (1, 'paid'), (2, 'pending');

CREATE VIEW active_orders AS
SELECT * FROM orders WHERE status = 'paid';

DROP VIEW active_orders;

CREATE VIEW active_orders AS
SELECT * FROM orders WHERE status IN ('paid', 'shipped');

SELECT * FROM active_orders;

DROP VIEW IF EXISTS active_orders; è la forma sicura: non dà errore se la vista non c'è. Eliminare una vista non tocca mai le tabelle sottostanti; stai cancellando solo la query salvata.

Viste temporanee

Una TEMP VIEW esiste solo per la connessione al database corrente. Quando la connessione si chiude, la vista sparisce. Utile per sessioni di analisi al volo in cui non vuoi lasciarti dietro definizioni:

CREATE TABLE events (
    id INTEGER PRIMARY KEY,
    type TEXT,
    occurred_at TEXT
);

INSERT INTO events (type, occurred_at) VALUES
    ('login', '2026-04-01'),
    ('purchase', '2026-04-01'),
    ('login', '2026-04-02');

CREATE TEMP VIEW today_logins AS
SELECT * FROM events WHERE type = 'login' AND occurred_at = '2026-04-02';

SELECT * FROM today_logins;

Le viste temporanee ti permettono anche di usare un nome di query senza impegnarti a inserirlo nello schema: comodo durante l'esplorazione.

Le viste sono in sola lettura per impostazione predefinita

Questo è il tranello più importante. Non puoi fare INSERT, UPDATE o DELETE direttamente attraverso una vista:

sqlite> INSERT INTO paid_orders (customer, amount) VALUES ('Eve', 50);
Runtime error: cannot modify paid_orders because it is a view

La soluzione sono i trigger INSTEAD OF. Scrivi un trigger che si attiva al posto del tentativo di scrittura e lo traduce in un'operazione reale sulla tabella sottostante:

CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    customer TEXT,
    amount REAL,
    status TEXT
);

CREATE VIEW paid_orders AS
SELECT id, customer, amount FROM orders WHERE status = 'paid';

CREATE TRIGGER paid_orders_insert
INSTEAD OF INSERT ON paid_orders
BEGIN
    INSERT INTO orders (customer, amount, status)
    VALUES (NEW.customer, NEW.amount, 'paid');
END;

INSERT INTO paid_orders (customer, amount) VALUES ('Eve', 50.00);

SELECT * FROM orders;

La vista resta una vista, ma ora le scritture su di essa hanno un posto dove andare. Vediamo i trigger per bene nella prossima pagina.

Niente viste materializzate: costruiscile da te

Alcuni database ti permettono di salvare su disco i risultati di una vista e aggiornarli su richiesta. SQLite no. Ogni lettura di una vista riesegue la query sottostante. Per la maggior parte dei carichi di lavoro va benissimo: SQLite è veloce e il pianificatore di query è bravo. Per le aggregazioni costose interrogate molte volte, crea una vera tabella e tienila sincronizzata tu:

CREATE TABLE orders (
    id INTEGER PRIMARY KEY,
    customer TEXT,
    amount REAL
);

INSERT INTO orders (customer, amount) VALUES
    ('Ada', 120.00), ('Rosa', 300.00), ('Boris', 80.00);

CREATE TABLE customer_totals_cache AS
SELECT customer, SUM(amount) AS total
FROM orders
GROUP BY customer;

SELECT * FROM customer_totals_cache;

Poi aggiorneresti la cache a intervalli regolari, oppure collegheresti dei trigger su orders per tenerla aggiornata. È lavoro manuale, ma è anche l'unica opzione in SQLite.

Elencare le viste

I metadati delle viste stanno in sqlite_master insieme a tabelle e indici:

CREATE TABLE t (x INTEGER);
CREATE VIEW v1 AS SELECT * FROM t;
CREATE VIEW v2 AS SELECT x * 2 AS doubled FROM t;

SELECT name, sql FROM sqlite_master WHERE type = 'view';

La colonna sql ti restituisce l'istruzione CREATE VIEW originale: utile quando hai dimenticato cosa fa una vista. Nella CLI, .schema view_name stampa la stessa cosa in modo più pulito.

Quando usare una vista

Le viste valgono la pena quando:

Una query non banale viene riutilizzata in tre o più punti. Darle un nome una volta è meglio che fare copia e incolla.
Vuoi esporre a una parte dell'applicazione un sottoinsieme selezionato di colonne o righe.
Un'aggregazione è concettualmente una cosa sola (monthly_sales, active_users) che chi la usa dovrebbe trattare come un sostantivo.

Lascia perdere la vista quando:

La query è usata in un solo punto. Scrivila direttamente lì.
Le prestazioni contano e la query sottostante è costosa: paghi quel costo a ogni lettura. Salva invece i risultati in una vera tabella.
La vista dipende da un'altra vista che dipende da un'altra vista ancora. SQLite gestisce bene l'annidamento, ma una catena di tre o quattro viste rende difficile seguire l'SQL reale durante il debug.

Prossimo passo: trigger

Viste e trigger compaiono spesso insieme: lo schema INSTEAD OF che rende scrivibili le viste è uno dei motivi principali per cui esistono i trigger. I trigger sono utili anche da soli per i log di audit, gli aggiornamenti a cascata e per imporre invarianti. È la prossima pagina.

Domande frequenti

Cos'è una vista in SQLite?

Una vista è un'istruzione SELECT salvata che puoi interrogare come una tabella. Non memorizza dati: ogni volta che la leggi, SQLite riesegue la query sottostante. Le viste sono utili per dare un nome una volta sola a una query complessa e riutilizzarla ovunque, o per nascondere colonne che chi la usa non deve vedere.

Si può fare INSERT o UPDATE attraverso una vista in SQLite?

Non direttamente. In SQLite le viste sono in sola lettura: INSERT, UPDATE e DELETE su una vista falliscono. Puoi rendere scrivibile una vista collegandole dei trigger INSTEAD OF che traducono la scrittura in operazioni sulle tabelle sottostanti.

SQLite supporta le viste materializzate?

No. SQLite ha solo viste normali (virtuali): la query viene eseguita ogni volta che leggi dalla vista. Se ti servono risultati in cache, crea una vera tabella e aggiornala tu, oppure usa un trigger per tenerla sincronizzata con le tabelle di origine.

Come si elencano tutte le viste di un database SQLite?

Interroga sqlite_master: SELECT name FROM sqlite_master WHERE type = 'view';. Nella CLI, .schema mostra le istruzioni CREATE VIEW e .tables elenca le viste insieme alle tabelle.

Concetti correlati