CASE in SQL con SQLite: WHEN, THEN, ELSE e IIF

CASE è l'if/else di SQL

CASE è il modo per inserire logica condizionale dentro una query. Scorre i rami WHEN in ordine, sceglie il primo che corrisponde e restituisce il valore dopo THEN. Se non corrisponde nulla, restituisce il valore di ELSE, oppure NULL se non l'hai scritto.

La parola importante è espressione. CASE produce un valore, quindi può stare ovunque sia ammesso un valore: una colonna della SELECT, una chiave di ORDER BY, il lato destro di un confronto, l'argomento di una funzione.

SELECT
    'apple' AS item,
    CASE
        WHEN 5 > 3 THEN 'yes'
        ELSE 'no'
    END AS bigger;

Questa è la forma completa: CASE, uno o più WHEN ... THEN ..., un ELSE facoltativo, poi END. END è obbligatorio: dimenticarlo è l'errore di battitura più comune.

Un esempio realistico

Mettiamo che tu abbia una tabella di ordini e voglia etichettare ogni riga in base alla dimensione. Creane una piccola al volo per poter eseguire la query:

WITH orders(id, total) AS (
    VALUES
        (1, 12.00),
        (2, 89.50),
        (3, 250.00),
        (4, 5.25),
        (5, 1200.00)
)
SELECT
    id,
    total,
    CASE
        WHEN total < 10 THEN 'tiny'
        WHEN total < 100 THEN 'small'
        WHEN total < 500 THEN 'medium'
        ELSE 'large'
    END AS size_bucket
FROM orders;

I rami vengono controllati dall'alto verso il basso. Vince la prima corrispondenza, quindi ordinali dal più specifico al più generale. ELSE cattura tutto ciò che non ha trovato corrispondenza: senza di esso, 1200.00 tornerebbe come NULL invece di 'large'.

Con condizioni contro semplice

Quella che hai visto sopra è la forma con condizioni (searched): ogni WHEN ha la sua condizione booleana. Esiste una forma più breve quando confronti un'espressione con diverse costanti, la forma semplice:

WITH users(id, status) AS (
    VALUES
        (1, 'A'),
        (2, 'B'),
        (3, 'C'),
        (4, 'A')
)
SELECT
    id,
    status,
    CASE status
        WHEN 'A' THEN 'active'
        WHEN 'B' THEN 'banned'
        WHEN 'C' THEN 'closed'
        ELSE 'unknown'
    END AS status_label
FROM users;

L'espressione dopo CASE viene valutata una volta e confrontata con = rispetto a ogni valore di WHEN. È più pulita quando fai ricerche per uguaglianza su una sola colonna.

Un'insidia: il CASE semplice usa =, e in SQL NULL = NULL non è vero. Se status può essere NULL, i rami 'A'/'B'/'C' non corrisponderanno e finirai in ELSE. Per gestire NULL in modo esplicito, passa alla forma con condizioni e usa WHEN status IS NULL THEN ....

CASE in ORDER BY

ORDER BY accetta qualsiasi espressione, quindi CASE funziona benissimo anche lì. È utile quando vuoi un ordinamento personalizzato che non segue l'ordine alfabetico o numerico:

WITH tickets(id, priority) AS (
    VALUES
        (1, 'low'),
        (2, 'high'),
        (3, 'medium'),
        (4, 'high'),
        (5, 'low')
)
SELECT id, priority
FROM tickets
ORDER BY
    CASE priority
        WHEN 'high' THEN 1
        WHEN 'medium' THEN 2
        WHEN 'low' THEN 3
    END,
    id;

In ordine alfabetico 'high' < 'low' < 'medium', che non serve a nulla per decidere le priorità. Mappare ogni priorità su un numero con CASE ti dà l'ordine che vuoi davvero. Il , id finale risolve i pari merito in modo stabile.

CASE in WHERE

Puoi mettere CASE dentro WHERE, ma la maggior parte delle volte non serve: una catena di AND/OR è più chiara. Il suo punto di forza è quando la condizione stessa dipende da un altro valore:

WITH products(id, name, price, on_sale) AS (
    VALUES
        (1, 'mug', 12.00, 1),
        (2, 'shirt', 25.00, 0),
        (3, 'cap', 18.00, 1),
        (4, 'bag', 45.00, 0)
)
SELECT id, name, price
FROM products
WHERE price < CASE WHEN on_sale = 1 THEN 20 ELSE 30 END;

Gli articoli in saldo si qualificano sotto 20, quelli normali sotto 30. La soglia stessa è condizionale. Senza CASE dovresti scrivere (on_sale = 1 AND price < 20) OR (on_sale = 0 AND price < 30): stesso risultato, più rumore.

CASE dentro le aggregazioni

È qui che CASE si guadagna da vivere. Combinalo con SUM o COUNT per calcolare totali su un sottoinsieme di righe in un solo passaggio: l'equivalente SQL di "conta quanti di questi corrispondono":

WITH orders(id, total, status) AS (
    VALUES
        (1, 50.00, 'paid'),
        (2, 30.00, 'pending'),
        (3, 75.00, 'paid'),
        (4, 20.00, 'cancelled'),
        (5, 100.00, 'paid')
)
SELECT
    COUNT(*) AS all_orders,
    SUM(CASE WHEN status = 'paid' THEN 1 ELSE 0 END) AS paid_count,
    SUM(CASE WHEN status = 'paid' THEN total ELSE 0 END) AS paid_revenue
FROM orders;

Il CASE restituisce 1 per le righe che corrispondono e 0 per le altre, così SUM diventa un conteggio condizionale. Lo stesso trucco funziona per il fatturato: restituisci total sulle righe che corrispondono e 0 altrove. Una sola scansione della tabella, diverse aggregazioni condizionali.

IIF: la scorciatoia a due rami

Per una singola condizione con due esiti, SQLite ha IIF(cond, when_true, when_false). È solo una scorciatoia per CASE WHEN cond THEN when_true ELSE when_false END:

WITH accounts(id, balance) AS (
    VALUES
        (1, 100.00),
        (2, -25.00),
        (3, 0.00),
        (4, 1500.00)
)
SELECT
    id,
    balance,
    IIF(balance < 0, 'overdrawn', 'ok') AS state
FROM accounts;

Usa IIF quando la logica è binaria e si legge meglio su una riga. Passa a CASE quando hai tre o più rami, devi gestire NULL separatamente o vuoi l'ordine a cascata di più clausole WHEN.

Insidie da conoscere

Alcune cose che fanno inciampare:

• Dimenticare END. CASE apre un blocco; END lo chiude. SQLite ti darà un errore di parsing ben dopo il punto in cui hai sbagliato.
• Nessun ELSE significa NULL. Se nessuno dei rami WHEN corrisponde e hai omesso ELSE, il risultato è NULL. A volte è quello che vuoi; di solito no.
• L'ordine dei rami conta. Nella forma con condizioni vince il primo WHEN che corrisponde. Mettere WHEN total < 500 prima di WHEN total < 100 rende irraggiungibile il secondo ramo.
• Tipi misti. Ogni ramo può restituire un tipo diverso e SQLite non si lamenta, ma il codice a valle potrebbe farlo. Cerca di far restituire a tutti i rami tipi compatibili (tutti testo, tutti numerici).
• CASE semplice e NULL. Come detto: la forma semplice usa =, che non corrisponde mai a NULL. Usa la forma con condizioni quando ci sono dei null in gioco.

Prossimo passo: le funzioni sulle stringhe

CASE ti permette di ramificare sui valori; il prossimo capitolo inizia a trasformare i valori. Le funzioni sulle stringhe, UPPER, LOWER, SUBSTR, REPLACE, i pattern di LIKE, si occupano del lavoro quotidiano di pulizia e riformattazione delle colonne di testo. Sono il prossimo argomento.