Spesso i database vengono trattati come semplici archivi a cui delegare banali operazioni di filtro o aggregazione, lasciando l’onere del calcolo scientifico e analitico a linguaggi esterni. Eppure, spostare l’elaborazione matematica direttamente dove risiede il dato grezzo è una delle strategie più efficaci per abbattere la latenza di rete e semplificare l’architettura.

Questi 3 esercizi pratici mostrano come trasformare T-SQL in un vero e proprio motore analitico utilizzando le funzioni matematiche native (LOG, EXP, POWER, SQRT).

Ogni scenario affronta un problema reale ed è scritto con una logica production-ready: gestione preventiva degli errori, robustezza del codice e attenzione alle performance, requisiti indispensabili quando si coordinano progetti di analisi dati complessi e automatizzati.

Esercizio 1 – Calcolo del pH di una soluzione (facile)

Testo

In un laboratorio chimico, la concentrazione di ioni idrogeno [math][H^+][/math] (in mol/L) viene misurata per diverse soluzioni. Il pH è definito come:

[math]\text{pH} = -\log_{10}([H^+])[/math]

Scrivi una query T‑SQL che, data una tabella Soluzioni con colonna ConcentrazioneH (tipo DECIMAL(10,8)), restituisca per ogni soluzione il valore del pH arrotondato a 2 decimali. Gestisci i casi in cui la concentrazione è ≤ 0 (valore non valido) restituendo NULL.

Soluzione

-- Tabella di esempio
CREATE TABLE #Soluzioni (
    Id INT IDENTITY(1,1),
    ConcentrazioneH DECIMAL(10,8)
);

INSERT INTO #Soluzioni (ConcentrazioneH) VALUES
    (0.00000010),  -- pH ≈ 7.00
    (0.00000001),  -- pH ≈ 8.00
    (0.00000100),  -- pH ≈ 6.00
    (-0.00000005), -- non valido
    (0.0);         -- non valido

-- Query principale
SELECT 
    Id,
    ConcentrazioneH,
    -- LOG10 calcola il logaritmo in base 10.
    -- Se il valore è <= 0, LOG10 genera un errore; usiamo NULLIF per evitarlo. CASE WHEN ConcentrazioneH > 0 
        THEN ROUND(-LOG10(ConcentrazioneH), 2) 
        ELSE NULL 
    END AS pH
FROM #Soluzioni;

-- Pulizia
DROP TABLE #Soluzioni;

Spiegazione

• Funzione LOG10: calcola il logaritmo in base 10 di un numero positivo.
• Controllo di validità: con CASE verifichiamo che la concentrazione sia strettamente positiva; altrimenti restituiamo NULL per evitare errori di runtime.
• Arrotondamento: ROUND(…, 2) garantisce due decimali, come richiesto.
• Production‑ready: la gestione degli errori (con NULLIF o CASE) è essenziale in ambienti reali.

Domanda di riflessione

Quale proprietà dei logaritmi hai utilizzato per definire il pH? E cosa succederebbe se la base del logaritmo fosse 2 invece di 10?

Esercizio 2 – Crescita esponenziale di una popolazione (facile‑medio)

Testo

La popolazione di una colonia batterica cresce secondo il modello esponenziale:

[math]N(t) = N_0 \cdot e^{rt}[/math]

dove [math]N_0[/math] è la popolazione iniziale, [math]r[/math] è il tasso di crescita (per ora) e [math]t[/math] è il tempo in ore.

Data una tabella Colonie con colonne Nome, PopIniziale e TassoCrescita, scrivi una query che calcoli la popolazione prevista dopo 8 ore. Usa la funzione EXP di T‑SQL. Gestisci eventuali valori negativi di TassoCrescita (decrescita) e arrotonda il risultato all’intero più vicino.

Soluzione

CREATE TABLE #Colonie (
    Nome VARCHAR(50),
    PopIniziale INT,
    TassoCrescita DECIMAL(5,4)  -- es. 0.023 per 2.3% all'ora
);

INSERT INTO #Colonie (Nome, PopIniziale, TassoCrescita) VALUES
    ('E. coli', 1000, 0.023),
    ('Lactobacillus', 500, -0.005),  -- decrescita
    ('S. aureus', 2000, 0.000);

DECLARE @Ore INT = 8;

SELECT 
    Nome,
    PopIniziale,
    TassoCrescita,
    -- EXP(x) calcola e^x. 
    -- Moltiplichiamo PopIniziale * EXP(TassoCrescita * @Ore)
    -- Arrotondiamo con ROUND(..., 0) e convertiamo a INT.
    CAST(ROUND(PopIniziale * EXP(TassoCrescita * @Ore), 0) AS INT) AS PopolazionePrevista
FROM #Colonie;

DROP TABLE #Colonie;

Spiegazione

• EXP è la funzione esponenziale naturale ([math]e^x[/math]).
• Il prodotto TassoCrescita * @Ore è l’esponente; se negativo, EXP restituisce un valore compreso tra 0 e 1, modellando la decrescita.
• Arrotondamento: ROUND(…, 0) arrotonda al numero intero più vicino; il cast a INT elimina i decimali (già arrotondati).
• Gestione di tasso zero: EXP(0)=1, quindi la popolazione rimane invariata.

Domanda di riflessione

Perché usiamo EXP invece di POWER con base fissa? Quale vantaggio offre la base [math]e[/math] in contesti di crescita continua?

Esercizio 3 – Tempo di raddoppio di un investimento (medio)

Testo

Un consulente finanziario deve calcolare il numero di anni necessari affinché un investimento raddoppi il proprio valore, dato un tasso di interesse annuale composto continuamente. La formula è:

[math]t = \frac{\ln(2)}{r}[/math]

dove [math]r[/math] è il tasso di interesse annuale (es. 0.05 per il 5%).

Scrivi una stored procedure CalcolaTempoRaddoppio che accetta il tasso [math]@r[/math] (tipo DECIMAL(10,6)) e restituisce il tempo in anni, arrotondato a 2 decimali. Gestisci i casi in cui [math]@r[/math] sia ≤ 0 (tasso non valido) restituendo un messaggio di errore.

La procedura deve essere production‑ready, con gestione delle eccezioni e commenti.

Soluzione

CREATE PROCEDURE CalcolaTempoRaddoppio
    @r DECIMAL(10,6),
    @tempo DECIMAL(10,2) OUTPUT
AS
BEGIN
    SET NOCOUNT ON;
    
    BEGIN TRY
        -- Controllo validità del tasso
        IF @r <= 0
        BEGIN
            RAISERROR('Il tasso di interesse deve essere positivo.', 16, 1);
            RETURN;
        END

        -- Calcolo: ln(2) / r. LOG(2) in T-SQL è il logaritmo naturale (base e).
        SET @tempo = ROUND(LOG(2) / @r, 2);
    END TRY
    BEGIN CATCH
        -- Gestione di eventuali altri errori (es. overflow)
        DECLARE @ErrMsg NVARCHAR(4000) = ERROR_MESSAGE();
        RAISERROR('Errore nel calcolo: %s', 16, 1, @ErrMsg);
        SET @tempo = NULL;
    END CATCH
END
GO

-- Test
DECLARE @risultato DECIMAL(10,2);
EXEC CalcolaTempoRaddoppio @r = 0.07, @tempo = @risultato OUTPUT;
SELECT @risultato AS AnniRaddoppio;  -- circa 9.90 anni

Spiegazione

• LOG(2) in T‑SQL è il logaritmo naturale (base [math]e[/math]) di 2 (equivalente a LN(2) in altri RDBMS).
• Divisione per il tasso [math]r[/math]. Se [math]r[/math] è positivo, il risultato è finito.
• Arrotondamento a 2 decimali come richiesto.
• Gestione errori: TRY…CATCH cattura eccezioni (es. se [math]@r[/math] è troppo piccolo e il risultato overflow, anche se in pratica con decimali non succede). Il RAISERROR personalizzato rende il feedback chiaro.

CREATE PROCEDURE CalcolaTempoRaddoppioModerno
    @r DECIMAL(10,6),
    @tempo DECIMAL(10,2) OUTPUT
AS
BEGIN
    SET NOCOUNT ON;
    
    BEGIN TRY
        -- Validazione preventiva dell'input tramite THROW
        IF @r <= 0 BEGIN -- THROW richiede: NumeroErrore (>= 50000), Messaggio, Stato (da 1 a 255)
            THROW 50001, 'Il tasso di interesse deve essere strettamente positivo.', 1;
        END

        -- Calcolo: ln(2) / r
        SET @tempo = ROUND(LOG(2) / @r, 2);
    END TRY
    BEGIN CATCH
        -- In caso di errore (divisione per zero, overflow o errore personalizzato)
        -- azzeriamo il parametro di output per sicurezza
        SET @tempo = NULL;
        
        -- Rilancia l'eccezione esatta che ha attivato il CATCH.
        -- In questo modo, i sistemi di orchestrazione (ADF, Airflow)
        -- cattureranno il fallimento originale con tutti i dettagli.
        THROW; 
    END CATCH
END
GO

-- Test di funzionamento corretto
DECLARE @risultato DECIMAL(10,2);
EXEC CalcolaTempoRaddoppioModerno @r = 0.05, @tempo = @risultato OUTPUT;
SELECT @risultato AS AnniRaddoppio; -- Restituisce 13.86

-- Test per scatenare l'errore personalizzato
-- EXEC CalcolaTempoRaddoppioModerno @r = 0.0, @tempo = @risultato OUTPUT;

Domanda di riflessione

Quale proprietà dei logaritmi giustifica l’uso di LOG(2)/r per il tempo di raddoppio? E se il tasso fosse espresso in percentuale (es. 7 invece di 0.07), come modificheresti la procedura?

Risposte alle Domande di Riflessione

Esercizio 1

Domanda: Quale proprietà dei logaritmi hai utilizzato per definire il pH? E cosa succederebbe se la base del logaritmo fosse 2 invece di 10?

Risposta:
La definizione di pH si basa sulla proprietà del logaritmo decimale (base 10) per esprimere la concentrazione di ioni idrogeno su una scala logaritmica che comprime un ampio intervallo di valori (da [math]10^{-14}[/math] a [math]1[/math]) in un intervallo più gestibile (da 0 a 14).

Se usassimo base 2, il valore del pH cambierebbe perché il logaritmo in base 2 di una data concentrazione è diverso da quello in base 10. La relazione sarebbe [math]\text{pH}_2 = -\log_2([H^+])[/math]. Per convertire, si potrebbe usare il cambio di base: [math]\log_2(x) = \frac{\log_{10}(x)}{\log_{10}(2)}[/math]. In pratica, i valori numerici sarebbero diversi, ma la scala rimarrebbe logaritmica; la scelta della base è convenzionale e legata alla definizione originale del pH (Sørensen scelse la base 10 per comodità con le potenze di 10).

Esercizio 2

Domanda: Perché usiamo EXP invece di POWER con base fissa? Quale vantaggio offre la base [math]e[/math] in contesti di crescita continua?

Risposta:
La funzione EXP calcola [math]e^x[/math], dove [math]e[/math] è la costante di Nepero (≈2.71828). Nei modelli di crescita continua, l’equazione differenziale [math]\frac{dN}{dt} = rN[/math] ha come soluzione [math]N(t) = N_0 e^{rt}[/math]. La base [math]e[/math] è naturale perché è l’unica base per cui la derivata di [math]e^{rt}[/math] è [math]re^{rt}[/math], semplificando i calcoli analitici.

Utilizzare POWER con una base fissa (es. 2) richiederebbe di scrivere [math]2^{kt}[/math] e il tasso di crescita non sarebbe più [math]r[/math] ma un tasso equivalente, meno intuitivo. In pratica, EXP è più diretto per modelli continui e coincide con le funzioni matematiche standard nei linguaggi di programmazione.

Esercizio 3

Domanda: Quale proprietà dei logaritmi giustifica l’uso di LOG(2)/r per il tempo di raddoppio? E se il tasso fosse espresso in percentuale (es. 7 invece di 0.07), come modificheresti la procedura?

Risposta:
La formula del tempo di raddoppio deriva dall’equazione [math]Ce^{rt} = 2C[/math], dividendo per [math]C[/math] si ha [math]e^{rt} = 2[/math]. Prendendo il logaritmo naturale di entrambi i membri: [math]rt = \ln(2)[/math], quindi [math]t = \frac{\ln(2)}{r}[/math]. Questa è una diretta applicazione della proprietà che il logaritmo è l’inverso dell’esponenziale.

Se il tasso fosse espresso in percentuale (es. 7), dovremmo dividerlo per 100 per ottenere il tasso decimale [math]r = 0.07[/math]. Nella procedura, si potrebbe aggiungere un parametro booleano o accettare direttamente il valore in percentuale e convertirlo internamente: SET @r = @r / 100.0.