menu
languageItaliano
save_alt Download

Cheat Sheet del linguaggio SQL

Guida di riferimento ai comandi e alla sintassi SQL essenziali per interrogare i database

🔍 Basi di SELECT

Recupera i dati dalle tabelle specificando quali colonne restituire. Usa DISTINCT per rimuovere i duplicati e AS per gli alias delle colonne.
SELECT customer_id, name, email
FROM customers;

-- With alias and DISTINCT
SELECT DISTINCT country AS customer_country
FROM customers;

Punti chiave:

  • Indica colonne specifiche invece di * per prestazioni migliori
  • DISTINCT rimuove le righe duplicate
  • La parola chiave AS crea alias per le colonne
  • L'ordine delle colonne nella SELECT determina quello del risultato

⚡ Clausola WHERE

Filtra le righe in base a condizioni usando gli operatori di confronto. Combina più condizioni con AND/OR per filtri complessi.
SELECT name, price
FROM products
WHERE price > 100;

-- Multiple conditions
SELECT name, category
FROM products
WHERE category = 'Electronics'
  AND price <= 500;

Punti chiave:

  • Filtra le righe prima di restituire i risultati
  • Puoi combinare più condizioni con AND/OR
  • I valori stringa richiedono gli apici singoli
  • Operatori: =, !=, <>, <, >, <=, >=

⚙️ Operatori logici

Combina più condizioni usando AND (tutte devono essere vere), OR (almeno una deve essere vera) e NOT (nega la condizione).
-- AND operator
SELECT * FROM orders
WHERE status = 'shipped' AND total > 100;

-- OR operator
SELECT * FROM customers
WHERE country = 'USA' OR country = 'Canada';

-- NOT operator
SELECT * FROM products
WHERE NOT category = 'Discontinued';

Punti chiave:

  • AND ha precedenza maggiore di OR
  • Usa le parentesi per controllare l'ordine di valutazione
  • NOT equivale a != o <>
  • Combina gli operatori per logiche complesse

↕️ ORDER BY

Ordina i risultati della query in ordine crescente (ASC) o decrescente (DESC). Ordina per più colonne per ordinamenti complessi.
-- Single column sort
SELECT name, price
FROM products
ORDER BY price DESC;

-- Multiple columns
SELECT name, category, price
FROM products
ORDER BY category ASC, price DESC;

Punti chiave:

  • ASC è il valore predefinito se non specificato
  • Ordina per più colonne (priorità da sinistra a destra)
  • Puoi ordinare per una colonna non presente nella SELECT
  • I valori NULL vanno all'inizio o alla fine (dipende dal DB)

✂️ LIMIT / OFFSET

Limita il numero di righe restituite e salta righe con OFFSET. Fondamentale per la paginazione e per lavorare con grandi set di risultati.
-- First 10 rows
SELECT name, price
FROM products
ORDER BY price DESC
LIMIT 10;

-- Pagination (skip first 20, get next 10)
SELECT name, price
FROM products
ORDER BY price DESC
LIMIT 10 OFFSET 20;

Punti chiave:

  • Fondamentale per la paginazione
  • Abbinalo a ORDER BY per risultati coerenti
  • OFFSET parte da 0 (prima riga)
  • Nota: SQL Server usa TOP invece di LIMIT

*️⃣ Pattern matching (LIKE)

Trova corrispondenze nel testo con i caratteri jolly: % corrisponde a qualsiasi sequenza di caratteri, _ a un singolo carattere.
-- Starts with 'John'
SELECT name, email
FROM customers
WHERE name LIKE 'John%';

-- Contains 'smith'
SELECT name FROM customers
WHERE name LIKE '%smith%';

-- Exact pattern (5 characters starting with 'A')
SELECT code FROM products
WHERE code LIKE 'A____';

Punti chiave:

  • % corrisponde a zero o più caratteri
  • _ corrisponde esattamente a un carattere
  • La distinzione tra maiuscole e minuscole dipende dalla collation del database
  • Puoi usare NOT LIKE per escludere

↔️ Intervalli e insiemi (BETWEEN, IN)

Filtra per intervalli con BETWEEN (estremi inclusi) o confronta con una lista di valori usando IN. Più efficiente di molte condizioni OR.
-- BETWEEN (inclusive)
SELECT name, price
FROM products
WHERE price BETWEEN 50 AND 100;

-- IN operator
SELECT name, country
FROM customers
WHERE country IN ('USA', 'Canada', 'Mexico');

-- NOT IN
SELECT name FROM products
WHERE category NOT IN ('Discontinued', 'Draft');

Punti chiave:

  • BETWEEN include entrambi gli estremi
  • IN è più pulito di molte condizioni OR
  • Puoi usare IN con le subquery
  • BETWEEN funziona con date e stringhe

❓ Gestione dei NULL

Lavora con i valori NULL usando IS NULL e IS NOT NULL. Usa COALESCE per fornire valori predefiniti alle colonne NULL.
-- Find NULL values
SELECT name, phone
FROM customers
WHERE phone IS NULL;

-- Exclude NULL values
SELECT name, email
FROM customers
WHERE email IS NOT NULL;

-- Provide default value
SELECT name, COALESCE(phone, 'No phone') AS contact
FROM customers;

Punti chiave:

  • Non puoi usare = o != con NULL
  • Devi usare IS NULL o IS NOT NULL
  • COALESCE restituisce il primo argomento non NULL
  • NULL nelle operazioni matematiche dà come risultato NULL

Σ Funzioni di aggregazione

Esegui calcoli su insiemi di righe: COUNT, SUM, AVG, MIN, MAX. Le aggregazioni ignorano i valori NULL (tranne COUNT(*)).
-- Basic aggregates
SELECT
  COUNT(*) AS total_orders,
  SUM(amount) AS total_revenue,
  AVG(amount) AS avg_order_value,
  MIN(amount) AS smallest_order,
  MAX(amount) AS largest_order
FROM orders;

-- COUNT variations
SELECT COUNT(*) AS all_rows,
       COUNT(email) AS rows_with_email,
       COUNT(DISTINCT country) AS unique_countries
FROM customers;

Punti chiave:

  • COUNT(*) include tutte le righe (anche con NULL)
  • COUNT(column) esclude i valori NULL
  • COUNT(DISTINCT column) conta i valori unici
  • SUM/AVG funzionano solo con tipi numerici

▦ GROUP BY / HAVING

Raggruppa le righe per valori di colonna e applica funzioni di aggregazione. Usa HAVING per filtrare i gruppi (come WHERE, ma per i gruppi).
-- Group by single column
SELECT country, COUNT(*) AS customer_count
FROM customers
GROUP BY country
ORDER BY customer_count DESC;

-- Group by multiple columns with HAVING
SELECT category, status, AVG(price) AS avg_price
FROM products
GROUP BY category, status
HAVING AVG(price) > 50;

Punti chiave:

  • Tutte le colonne non aggregate della SELECT devono stare nel GROUP BY
  • WHERE filtra le righe prima del raggruppamento
  • HAVING filtra i gruppi dopo l'aggregazione
  • Puoi usare funzioni di aggregazione nella clausola HAVING

🔗 Join (riferimento rapido) VEDI LA GUIDA COMPLETA

Combina dati da più tabelle in base a colonne correlate. INNER JOIN restituisce solo le corrispondenze, LEFT/RIGHT conservano un lato.
-- INNER JOIN (most common)
SELECT orders.id, customers.name, orders.amount
FROM orders
INNER JOIN customers
  ON orders.customer_id = customers.id;

-- LEFT JOIN (all orders, even without customer)
SELECT orders.id, customers.name
FROM orders
LEFT JOIN customers
  ON orders.customer_id = customers.id;

Punti chiave:

  • INNER JOIN è il più comune (puoi scrivere solo JOIN)
  • LEFT/RIGHT JOIN conservano tutte le righe di una tabella
  • Usa la clausola ON per specificare la condizione di join

⬚ Subquery

Query dentro altre query per filtri e calcoli complessi. Usale con IN, EXISTS o come valori scalari.
-- Subquery with IN
SELECT name, price
FROM products
WHERE category_id IN (
  SELECT id FROM categories
  WHERE name = 'Electronics'
);

-- Subquery with EXISTS
SELECT name FROM customers c
WHERE EXISTS (
  SELECT 1 FROM orders o
  WHERE o.customer_id = c.id
);

-- Scalar subquery
SELECT name, price,
  price - (SELECT AVG(price) FROM products) AS price_diff
FROM products;

Punti chiave:

  • Una subquery con IN restituisce più valori
  • EXISTS verifica l'esistenza (efficiente)
  • Una subquery scalare restituisce un solo valore
  • Una subquery correlata fa riferimento alla query esterna

✂️ Funzioni sulle stringhe

Estrai, trasforma e formatta dati testuali. SUBSTRING estrae per posizione; LEFT/RIGHT prendono da un'estremità.
-- Extract characters by position
SELECT SUBSTRING(name, 1, 3) AS prefix FROM products;

-- First / last N characters
SELECT LEFT(email, 5), RIGHT(phone, 4) FROM users;

-- Dynamic position (find @ then extract domain)
SELECT SUBSTRING(email, INSTR(email, '@') + 1) AS domain
FROM users;

-- Common string helpers
SELECT
  UPPER(name), LOWER(name),
  TRIM(name),
  LENGTH(name)
FROM users;

Punti chiave:

  • In SQL le posizioni partono da 1 (primo carattere = posizione 1)
  • Usa LEFT/RIGHT per inizio/fine; SUBSTRING per la parte centrale
  • SQLite non supporta LEFT/RIGHT: usa SUBSTRING
  • Oracle usa SUBSTR(), non SUBSTRING()

Cerchi un modo migliore per scrivere SQL?

Beekeeper Studio è un editor SQL moderno e intuitivo con autocompletamento, cronologia delle query e supporto per oltre 15 database.

Prova Beekeeper Studio gratis