Introduzione alle strutture di controllo: IF, CASE, RETURN

Le strutture di controllo sono la base di qualsiasi programma, che sia uno script SQL, codice Python o anche un robot su Marte che si chiede se mandare un segnale a casa o cercare la vita dietro l’angolo del cratere.

In PL/pgSQL le strutture di controllo ci aiutano a:

• Eseguire certe azioni se le condizioni sono vere.
• Controllare l’ordine di esecuzione del codice.
• Implementare la logica delle decisioni.

Pensale come segnali stradali: "Se vedi STOP, fermati. Se vedi il verde — vai!"

Le strutture di controllo più popolari in PL/pgSQL:

• IF – controlla una condizione ed esegue i comandi corrispondenti.
• CASE – alternativa a IF quando hai tante condizioni.
• RETURN – termina l’esecuzione della funzione e restituisce il risultato.

Hai già un’idea di cosa siano. E dopo aver visto altri linguaggi di programmazione, capirli sarà davvero semplice.

L’operatore condizionale IF

L’operatore IF si usa per eseguire codice solo se una certa condizione è TRUE (vera). Ecco la sua struttura base:

IF condizione THEN
  -- Codice che viene eseguito se la condizione è vera.
ELSE
  -- Codice alternativo se la condizione è falsa.
END IF;

Scriviamo una funzione che prende un numero e restituisce se è pari o dispari:

CREATE OR REPLACE FUNCTION check_even_odd(num INTEGER)
RETURNS TEXT AS $$
BEGIN
  IF num % 2 = 0 THEN
    RETURN 'Numero pari';
  ELSE
    RETURN 'Numero dispari';
  END IF;
END;
$$ LANGUAGE plpgsql;

Ora testiamola:

SELECT check_even_odd(4); -- Numero pari
SELECT check_even_odd(7); -- Numero dispari

Spiegazione veloce: IF num % 2 = 0 THEN controlla se il numero è divisibile per 2 senza resto.

La condizione ELSIF

A volte un solo controllo non basta e ti serve verificare più condizioni. Per questo c’è ELSIF.

Supponiamo di avere una funzione che restituisce un messaggio testuale sulla temperatura:

CREATE OR REPLACE FUNCTION temperature_comment(temp INTEGER)
RETURNS TEXT AS $$
BEGIN
  IF temp < 0 THEN
    RETURN 'Molto freddo!';
  ELSIF temp >= 0 AND temp <= 20 THEN
    RETURN 'Fresco';
  ELSE
    RETURN 'Caldo!';
  END IF;
END;
$$ LANGUAGE plpgsql;

Testiamo:

SELECT temperature_comment(-5);  -- Molto freddo!
SELECT temperature_comment(15);  -- Fresco
SELECT temperature_comment(25);  -- Caldo!

Sintassi di CASE

Se hai tante condizioni, l’operatore CASE ti salva la vita. È un po’ simile a IF, ma più "elegante".

CASE
  WHEN condizione_1 THEN valore_1
  WHEN condizione_2 THEN valore_2
  ELSE valore_di_default
END;

Creiamo una funzione che restituisce una valutazione testuale in base al numero:

CREATE OR REPLACE FUNCTION grade_comment(score INTEGER)
RETURNS TEXT AS $$
BEGIN
  RETURN CASE
    WHEN score >= 90 THEN 'Eccellente'
    WHEN score >= 75 THEN 'Buono'
    WHEN score >= 50 THEN 'Sufficiente'
    ELSE 'Insufficiente'
  END;
END;
$$ LANGUAGE plpgsql;

Testiamo:

SELECT grade_comment(95); -- Eccellente
SELECT grade_comment(80); -- Buono
SELECT grade_comment(45); -- Insufficiente

Nota: a differenza di IF, CASE restituisce un valore, quindi puoi usare RETURN direttamente dentro CASE.

L’operatore RETURN

RETURN termina l’esecuzione della funzione e restituisce un valore. È fondamentale per le funzioni in PL/pgSQL che devono restituire qualcosa (tipo testo, numero, ecc.).

Vediamo come funziona RETURN con un esempio semplice:

CREATE OR REPLACE FUNCTION return_example()
RETURNS TEXT AS $$
BEGIN
  RETURN 'Ciao, Mondo!';
END;
$$ LANGUAGE plpgsql;

Risultato:

SELECT return_example(); -- Ciao, Mondo!

Ma che succede se abbiamo più rami di codice? Ad esempio, un controllo sui dati in ingresso. In quel caso RETURN verrà usato in punti diversi della funzione:

CREATE OR REPLACE FUNCTION check_positive_negative(num INTEGER)
RETURNS TEXT AS $$
BEGIN
  IF num > 0 THEN
    RETURN 'Numero positivo';
  ELSIF num = 0 THEN
    RETURN 'Zero';
  ELSE
    RETURN 'Numero negativo';
  END IF;
END;
$$ LANGUAGE plpgsql;

Testiamo:

SELECT check_positive_negative(10); -- Numero positivo
SELECT check_positive_negative(0);  -- Zero
SELECT check_positive_negative(-5); -- Numero negativo

Errori tipici e dove ci si può confondere

1. Dimenticare l’operatore END: se ti scordi END CASE; o END IF;, PostgreSQL ti ricorderà subito che devi chiudere il blocco di codice.
2. Errori logici usando ELSIF: l’ordine delle condizioni è importante! Una condizione più generale (temp > 0) non deve venire prima di una più specifica (temp > 20).
3. Dimenticare RETURN: in PL/pgSQL la funzione deve restituire qualcosa se hai dichiarato RETURNS.

Questo è tutto. Abbiamo visto le basi delle strutture di controllo e della logica in PL/pgSQL. Queste cose ti serviranno quando scriverai funzioni più complesse! La prossima volta vediamo i cicli e come usarli.