Le query SQL più inutili (e cosa fare al loro posto)

Vengono eseguite. Restituiscono dati. Ma sono inutili. Ecco cosa non scrivere in SQL e cosa fare al suo posto.

Alcune query SQL vengono eseguite bene, ma ciò non significa che stiano facendo qualcosa di utile.

In questo articolo, esamineremo esempi reali di query SQL valide, dall'aspetto innocuo, ma completamente inutili. Sprecano risorse, nascondono informazioni o aggiungono semplicemente rumore. Per ognuna di esse, vedremo cosa c'è di sbagliato e come scrivere un'alternativa più intelligente.

Volete esercitarvi subito a scrivere query migliori? Provate il percorsoPratica su SQL su LearnSQL.it: è costruito per aiutarvi a trasformare la teoria in abilità, con 12 corsi e oltre 1000 esercizi interattivi.

Ripuliamo la spazzatura e scriviamo query che portino effettivamente a termine il lavoro.

1. Selezionare tutto senza uno scopo

La query:

SELECT * 
FROM orders;

Perché è inutile: estrae dati non necessari, rallenta le query e appesantisce il database.

Cosa fare invece: specificare solo le colonne necessarie per migliorare le prestazioni.

Una query migliore:

SELECT order_id, customer_id, total_amount
FROM orders;

2. Contare tutto senza filtrare

La query:




SELECT COUNT(*) 
FROM orders;

Perché è inutile: spesso restituisce informazioni fuorvianti se non è filtrata.

Cosa fare invece: utilizzare le condizioni di WHERE o GROUP BY per una maggiore precisione.

Una query migliore:




SELECT COUNT(*) 
FROM orders 
WHERE status = 'completed';

3. Ordine predefinito quando l'ordine non è importante

La query:

SELECT total_amount 
FROM orders 
ORDER BY customer_id;

Perché è inutile: aggiunge tempo di elaborazione senza benefici per l'analisi.

Cosa fare al suo posto: utilizzare ORDER BY intenzionalmente, ad esempio per la creazione di report o per la visualizzazione.

Query migliore: non usare ORDER BY se non necessario;

SELECT total_amount 
FROM orders;

4. Ordinamento senza limiti

Questo è simile al precedente.

La query:

SELECT order_id, customer_id, total_amount 
FROM orders 
ORDER BY created_at DESC;

Perché è inutile: l'ordinamento di grandi insiemi di dati senza vincoli è inefficiente.

Cosa fare invece: se possibile, usare LIMIT o TOP.

Una query migliore:

SELECT order_id, customer_id, total_amount 
FROM orders 
ORDER BY created_at 
DESC LIMIT 10;

5. Raggruppamento senza etichette significative

La query:

SELECT customer_id, COUNT(*) 
FROM orders 
GROUP BY customer_id;

Perché è inutile: Gli ID da soli non forniscono un contesto: i risultati sono difficili da interpretare e non sono utilizzabili.

Cosa fare invece: assicurarsi di includere un'etichetta significativa, come il nome o l'e-mail.

Una query migliore:

SELECT o.customer_id, c.email, COUNT(*) AS total_orders 
FROM orders o 
JOIN customers c 
ON o.customer_id = c.id 
GROUP BY o.customer_id, c.email;

6. Usare HAVING invece di WHERE per filtrare le righe

La query:

SELECT order_id, customer_id, total_amount 
FROM orders 
HAVING total_amount > 100;

Perché è inutile: HAVING è pensato per il filtraggio aggregato, non per il filtraggio delle righe. Anche se tecnicamente funziona, distrae il lettore della query dal comprendere la vostra intenzione.

Cosa fare invece: utilizzare WHERE prima dell'aggregazione.

Una query migliore:

SELECT order_id, customer_id, total_amount 
FROM orders 
WHERE total_amount > 100;

7. Filtro su colonne calcolate senza indicizzazione

La query:

SELECT order_id, customer_id, total_amount 
FROM orders 
WHERE YEAR(created_at) = 2023;

Perché è inutile: impedisce l'uso degli indici, causando scansioni complete della tabella.

Cosa fare invece: utilizzare un filtro basato su un intervallo per sfruttare gli indici.

Una query migliore:

SELECT order_id, customer_id, total_amount 
FROM orders 
WHERE created_at >= '2023-01-01' AND created_at < '2024-01-01';

8. Usare le subquery invece delle join

La query:

SELECT order_id, customer_id, total_amount  
FROM orders  
WHERE customer_id IN (SELECT customer_id FROM blacklisted_customers);

Perché è inutile: può portare a prestazioni lente rispetto a JOIN.

Cosa fare invece: usare una INNER JOIN o LEFT JOIN.

Una query migliore:


SELECT o.order_id, o.customer_id, o.total_amount  
FROM orders o  
JOIN blacklisted_customers b ON o.customer_id = b.customer_id;

9. Autocongiunzione invece di usare Window Functions (Funzioni Finestra)

La query:




SELECT
  o1.customer_id,
  o1.order_id,
COUNT(*) AS row_num  
FROM orders o1
JOIN orders o2
  ON o1.customer_id = o2.customer_id
  AND o1.order_date >= o2.order_date
GROUP BY o1.customer_id, o1.order_id;

Perché è inutile: causa complessità e duplicazioni inutili.

Cosa fare invece: usare le funzioni di finestra pke ROW_NUMBER(), RANK(), o LAG().

Una query migliore:




SELECT 
  customer_id, 
  order_id,  
  ROW_NUMBER() OVER (PARTITION BY customer_id ORDER BY order_date) AS row_num  
FROM orders;

Scrivere SQL più intelligente, non solo SQL valido

Il fatto che una query venga eseguita non significa che sia utile. Evitare queste trappole comuni renderà il vostro SQL più veloce, più pulito e più utile.

Se volete continuare a esercitarvi sul modo giusto di scrivere le query, date un'occhiata alla tracciaPratica su SQL su LearnSQL.it. È ricca di esercizi pratici che aiutano ad affinare le proprie capacità facendo, non solo leggendo.