Menu
CoddyTech

PostgreSQL Cheat Sheet: comandi psql

Ultimo aggiornamento

Comandi psql

I meta-comandi vengono eseguiti dentro psql (il client da terminale di PostgreSQL), non sul server. Iniziano con una barra rovesciata e non richiedono il punto e virgola.

Cosa faComando
Elenca i database\l
Connettiti a un altro database\c shop
Elenca le tabelle\dt
Elenca le tabelle di tutti gli schemi\dt *.*
Descrivi una tabella (colonne, indici, chiavi)\d users
Descrivi con archiviazione e commenti\d+ users
Elenca gli schemi\dn
Elenca le viste\dv
Elenca gli indici\di
Elenca le funzioni\df
Elenca i ruoli (utenti)\du
Mostra la connessione attuale\conninfo
Esegui SQL da un file\i setup.sql
Attiva o disattiva il tempo delle query\timing
Output espanso (una colonna per riga)\x
Modifica l'ultima query nel tuo editor\e
Aiuto sulla sintassi SQL\h CREATE TABLE
Elenca tutti i meta-comandi\?
Esci da psql\q

Connettersi dal terminale

Cosa faComando
Connettiti a un database come utentepsql -U postgres -d shop
Connettiti a un host e a una porta remotipsql -h db.example.com -p 5432 -U app -d shop
Connettiti con un URL di connessionepsql postgresql://app:secret@localhost:5432/shop
Esegui una query ed escipsql -d shop -c "SELECT count(*) FROM users;"
Esegui un file SQLpsql -d shop -f setup.sql
Crea un database dalla shellcreatedb shop
Elimina un database dalla shelldropdb shop

Database e schemi

Cosa faSQL
Crea un databaseCREATE DATABASE shop;
Elimina un databaseDROP DATABASE shop;
Mostra il database attualeSELECT current_database();
Crea uno schemaCREATE SCHEMA sales;
Mostra l'ordine di ricerca degli schemiSHOW search_path;
Cerca prima in uno schemaSET search_path TO sales, public;
Mostra la versione del serverSELECT version();

Tabelle e tipi di dati

Cosa faSQL
Crea una tabella con una chiave identityCREATE TABLE products (id integer GENERATED ALWAYS AS IDENTITY PRIMARY KEY, name text NOT NULL, price numeric(10,2) CHECK (price >= 0), created_at timestamptz DEFAULT now());
Aggiungi una colonnaALTER TABLE users ADD COLUMN phone text;
Rinomina una colonnaALTER TABLE users RENAME COLUMN country TO country_code;
Cambia il tipo di una colonnaALTER TABLE users ALTER COLUMN age TYPE smallint;
Imposta un valore predefinitoALTER TABLE users ALTER COLUMN active SET DEFAULT false;
Elimina una colonnaALTER TABLE users DROP COLUMN tags;
Svuota una tabella e azzera la sua identityTRUNCATE orders, users RESTART IDENTITY;
Elimina una tabella se esisteDROP TABLE IF EXISTS products;
Decimale esatto per gli importinumeric(10,2)
Data e ora con fuso orariotimestamptz
UUID casualeSELECT gen_random_uuid();
Tipo enumCREATE TYPE mood AS ENUM ('happy', 'sad');

Vincoli e chiavi

Cosa faSQL
Aggiungi una chiave primariaALTER TABLE logs ADD PRIMARY KEY (id);
Chiave esterna che elimina le righe figlieCREATE TABLE reviews (id integer PRIMARY KEY, user_id integer REFERENCES users(id) ON DELETE CASCADE);
Aggiungi un vincolo checkALTER TABLE orders ADD CONSTRAINT amount_positive CHECK (amount > 0);
Unique in cui i NULL contano come uguali (15+)CREATE TABLE emails (address text UNIQUE NULLS NOT DISTINCT);
Rendi obbligatoria una colonnaALTER TABLE users ALTER COLUMN country SET NOT NULL;
Elimina un vincoloALTER TABLE users DROP CONSTRAINT users_email_key;

Query (extra di PostgreSQL)

SELECT, WHERE e JOIN standard sono nella SQL cheat sheet; queste sono le forme di PostgreSQL.

Cosa faSQL
Confronto senza distinzione tra maiuscole e minuscoleSELECT * FROM users WHERE name ILIKE 'a%';
Corrispondenza con espressione regolareSELECT * FROM users WHERE email ~ '@example\.com$';
Prima riga per gruppoSELECT DISTINCT ON (user_id) user_id, amount FROM orders ORDER BY user_id, amount DESC;
Limit e offsetSELECT * FROM users ORDER BY id LIMIT 10 OFFSET 20;
Limite di righe standardSELECT * FROM users ORDER BY id FETCH FIRST 5 ROWS ONLY;
Cast con ::SELECT '42'::integer + 1;
Valore di riserva per NULLSELECT name, COALESCE(email, 'none') FROM users;
Confronto che tratta i NULL come ugualiSELECT * FROM users WHERE email IS DISTINCT FROM 'asha@example.com';
Genera una serie di numeriSELECT * FROM generate_series(1, 5);
Aggrega in una stringaSELECT string_agg(name, ', ' ORDER BY name) FROM users;
Aggregazione condizionaleSELECT count(*) FILTER (WHERE status = 'paid') AS paid, count(*) AS total FROM orders;

Insert, update, delete e upsert

Cosa faSQL
Inserisci e ottieni il nuovo idINSERT INTO users (name, email) VALUES ('Dana', 'dana@example.com') RETURNING id;
Inserisci più righeINSERT INTO users (name) VALUES ('Eli'), ('Femi');
Upsert (inserisci o aggiorna)INSERT INTO users (name, email) VALUES ('Asha K', 'asha@example.com') ON CONFLICT (email) DO UPDATE SET name = EXCLUDED.name;
Inserisci ignorando i duplicatiINSERT INTO users (name, email) VALUES ('Ben', 'ben@example.com') ON CONFLICT DO NOTHING;
Aggiorna e vedi le righe modificateUPDATE employees SET salary = salary * 1.1 WHERE department = 'IT' RETURNING name, salary;
Aggiorna da un'altra tabellaUPDATE orders SET status = 'vip' FROM users WHERE orders.user_id = users.id AND users.country = 'IN';
Elimina e vedi cosa è stato eliminatoDELETE FROM orders WHERE status = 'refunded' RETURNING id;
Elimina usando un'altra tabellaDELETE FROM orders USING users WHERE orders.user_id = users.id AND users.active = false;
Copia le righe in una nuova tabellaCREATE TABLE paid_orders AS SELECT * FROM orders WHERE status = 'paid';

JSONB

Cosa faSQL
Ottieni un campo come JSONSELECT profile -> 'plan' FROM users;
Ottieni un campo come testoSELECT profile ->> 'plan' FROM users;
Ottieni un campo annidato come testoSELECT profile #>> '{address,city}' FROM users;
Righe il cui JSON contiene un valoreSELECT * FROM users WHERE profile @> '{"plan": "pro"}';
Righe che hanno una chiaveSELECT * FROM users WHERE profile ? 'city';
Imposta una chiaveUPDATE users SET profile = jsonb_set(profile, '{plan}', '"team"') WHERE id = 2;
Unisci oggettiUPDATE users SET profile = profile || '{"beta": true}';
Rimuovi una chiaveUPDATE users SET profile = profile - 'city';
Costruisci JSON dalle colonneSELECT jsonb_build_object('id', id, 'name', name) FROM users;
Righe come array JSONSELECT jsonb_agg(users) FROM users;
Indice per ricerche con @> e ?CREATE INDEX users_profile_idx ON users USING gin (profile);

Array

Cosa faSQL
Letterale di arraySELECT ARRAY[1, 2, 3];
Righe in cui l'array contiene un valoreSELECT * FROM users WHERE 'sql' = ANY(tags);
Righe in cui l'array contiene tutti i valoriSELECT * FROM users WHERE tags @> ARRAY['sql', 'python'];
Una riga per elementoSELECT name, unnest(tags) FROM users;
Aggiungi un elemento in fondoUPDATE users SET tags = array_append(tags, 'sql') WHERE id = 2;
Lunghezza dell'arraySELECT name, cardinality(tags) FROM users;

Date e orari

Cosa faSQL
Adesso, con fuso orarioSELECT now();
OggiSELECT current_date;
Aggiungi un intervalloSELECT current_date + INTERVAL '7 days';
Righe degli ultimi 30 giorniSELECT * FROM orders WHERE created_at > now() - INTERVAL '30 days';
Tronca al meseSELECT date_trunc('month', created_at) AS month, sum(amount) FROM orders GROUP BY 1 ORDER BY 1;
Estrai una parteSELECT EXTRACT(YEAR FROM hired_on) FROM employees;
Differenza tra date (giorni)SELECT DATE '2026-12-25' - DATE '2026-11-17';
Età tra due dateSELECT name, age(current_date, hired_on) FROM employees;
Formatta una data come testoSELECT to_char(hired_on, 'DD Mon YYYY') FROM employees;
Converti testo in dataSELECT to_date('17/11/2026', 'DD/MM/YYYY');
Converti in un fuso orarioSELECT now() AT TIME ZONE 'Asia/Kolkata';

Funzioni di testo

Cosa faSQL
Concatena (NULL dà NULL)SELECT name || ' <' || email || '>' FROM users;
Concatena saltando i NULLSELECT concat_ws(' ', name, email) FROM users;
Maiuscole e minuscoleSELECT upper(name), lower(name) FROM users;
LunghezzaSELECT name, length(name) FROM users;
Parte di una stringaSELECT substring(name FROM 1 FOR 2) FROM users;
SostituisciSELECT replace(email, '@example.com', '') FROM users;
Estrai una parte tra separatoriSELECT split_part(email, '@', 2) FROM users;
Sostituzione con espressione regolareSELECT regexp_replace('a1b22c', '[0-9]+', '', 'g');
Togli gli spazi ai latiSELECT trim(' hi ');

CTE e funzioni finestra

Cosa faSQL
Dai un nome a una subquery con WITHWITH paid AS (SELECT user_id, sum(amount) AS total FROM orders WHERE status = 'paid' GROUP BY user_id) SELECT * FROM paid WHERE total > 50;
CTE ricorsiva (conta fino a 5)WITH RECURSIVE n(i) AS (SELECT 1 UNION ALL SELECT i + 1 FROM n WHERE i < 5) SELECT i FROM n;
Numera le righe per gruppoSELECT name, department, ROW_NUMBER() OVER (PARTITION BY department ORDER BY salary DESC) FROM employees;
Classifica con pari meritoSELECT name, DENSE_RANK() OVER (ORDER BY salary DESC) FROM employees;
Totale progressivoSELECT id, amount, sum(amount) OVER (ORDER BY id) FROM orders;
Valore della riga precedenteSELECT name, salary, LAG(salary) OVER (ORDER BY hired_on) FROM employees;
Join con una subquery propria per ogni rigaSELECT u.name, o.amount FROM users u CROSS JOIN LATERAL (SELECT amount FROM orders WHERE user_id = u.id ORDER BY amount DESC LIMIT 1) o;

Indici

Cosa faSQL
Indice B-tree (il predefinito)CREATE INDEX orders_user_idx ON orders (user_id);
Indice unicoCREATE UNIQUE INDEX employees_name_idx ON employees (name);
Indice multicolonnaCREATE INDEX orders_user_created_idx ON orders (user_id, created_at);
Indice parzialeCREATE INDEX orders_paid_idx ON orders (created_at) WHERE status = 'paid';
Indice su espressioneCREATE INDEX users_lower_email_idx ON users (lower(email));
Indice di copertura (scansioni solo indice)CREATE INDEX orders_user_cover_idx ON orders (user_id) INCLUDE (amount);
Crea senza bloccare le scrittureCREATE INDEX CONCURRENTLY orders_status_idx ON orders (status);
Elimina un indiceDROP INDEX IF EXISTS orders_user_idx;
Vedi il pianoEXPLAIN SELECT * FROM orders WHERE user_id = 1;
Vedi il piano con i tempi realiEXPLAIN ANALYZE SELECT * FROM orders WHERE user_id = 1;

Transazioni e lock

Cosa faSQL
Inizia, poi conferma o annullaBEGIN; UPDATE employees SET salary = 0 WHERE id = 3; ROLLBACK;
Annulla parte di una transazioneBEGIN; INSERT INTO users (name) VALUES ('Gil'); SAVEPOINT s1; DELETE FROM users WHERE name = 'Gil'; ROLLBACK TO s1; COMMIT;
Isolamento più rigorosoBEGIN ISOLATION LEVEL SERIALIZABLE; SELECT count(*) FROM orders; COMMIT;
Blocca le righe che leggiBEGIN; SELECT * FROM orders WHERE id = 1 FOR UPDATE; COMMIT;
Coda di lavori: salta le righe bloccateBEGIN; SELECT id FROM orders WHERE status = 'paid' ORDER BY id LIMIT 1 FOR UPDATE SKIP LOCKED; COMMIT;

Utenti, ruoli e privilegi

Cosa faSQL
Crea un ruolo con loginCREATE ROLE app LOGIN PASSWORD 'change-me';
Accesso in sola lettura a una tabellaGRANT SELECT ON users TO app;
Accesso in lettura a ogni tabella di uno schemaGRANT SELECT ON ALL TABLES IN SCHEMA public TO app;
Revoca un privilegioREVOKE SELECT ON users FROM app;
Cambia una passwordALTER ROLE app PASSWORD 'new-secret';
Mostra l'utente attualeSELECT current_user;

Manutenzione e monitoraggio

Cosa faSQL
Query in esecuzioneSELECT pid, state, query FROM pg_stat_activity WHERE state <> 'idle';
Annulla una querySELECT pg_cancel_backend(12345);
Chiudi una connessioneSELECT pg_terminate_backend(12345);
Dimensione di una tabella con i suoi indiciSELECT pg_size_pretty(pg_total_relation_size('orders'));
Dimensione del databaseSELECT pg_size_pretty(pg_database_size(current_database()));
Aggiorna le statistiche del plannerANALYZE orders;
Recupera le righe morteVACUUM orders;
Riscrivi una tabella alla dimensione minima (la blocca)VACUUM FULL orders;
Mostra un'impostazioneSHOW work_mem;
Cambia un'impostazione per questa sessioneSET work_mem = '64MB';

Backup e ripristino

Comandi di shell degli strumenti client di PostgreSQL.

Cosa faComando
Esporta un database in un file SQLpg_dump -U postgres shop > shop.sql
Esporta nel formato custompg_dump -Fc -U postgres shop > shop.dump
Esporta una sola tabellapg_dump -t orders shop > orders.sql
Ripristina un dump SQLpsql -d shop -f shop.sql
Ripristina un dump in formato custompg_restore -d shop shop.dump
Esporta tutti i database e i ruolipg_dumpall > cluster.sql
Esporta una query in CSV (da psql)\copy (SELECT * FROM orders) TO 'orders.csv' CSV HEADER
Importa un CSV (da psql)\copy orders (user_id, amount, status) FROM 'orders.csv' CSV HEADER

Ogni comando psql e ogni istruzione PostgreSQL che ti serve, in tabelle da copiare e incollare: prima la connessione e i comandi \d, poi tabelle, upsert, JSONB, date, funzioni finestra, indici, ruoli, backup e manutenzione.

L'SQL di questa pagina usa la sintassi di PostgreSQL 17 e gran parte funziona anche nelle versioni precedenti. Le istruzioni SQL sono state verificate su PostgreSQL 17; per provarne una, incollala nel playground PostgreSQL, che include tabelle di esempio.

Domande frequenti sulla PostgreSQL cheat sheet

Cosa sono i comandi psql?
psql è il client da terminale di PostgreSQL. Oltre all'SQL, capisce i meta-comandi che iniziano con una barra rovesciata: \l elenca i database, \c si connette a uno di essi, \dt elenca le tabelle, \d users descrive una tabella e \q esce. Vengono eseguiti da psql stesso, quindi non richiedono il punto e virgola e non funzionano in altri client.
Come elenco tutte le tabelle in PostgreSQL?
In psql, digita \dt (o \dt *.* per tutti gli schemi). In SQL, da qualsiasi client: SELECT table_name FROM information_schema.tables WHERE table_schema = 'public';
L'SQL di PostgreSQL è diverso da quello di MySQL?
La base (SELECT, JOIN, GROUP BY) è la stessa. PostgreSQL aggiunge ILIKE, i cast con ::, RETURNING, DISTINCT ON, gli upsert con ON CONFLICT, gli array e JSONB, e usa le colonne identity dove MySQL usa AUTO_INCREMENT.
Qual è la differenza tra JSON e JSONB?
json memorizza il testo così come è scritto; jsonb memorizza una forma binaria già analizzata, elimina le chiavi duplicate e gli spazi, e supporta gli indici (GIN) e operatori come @> e ?. Usa jsonb, a meno che non ti serva il testo originale esatto.
Posso esercitarmi con queste query online?
Sì. Il playground PostgreSQL esegue qualsiasi query su un vero database PostgreSQL 17 nel tuo browser, con tabelle di esempio che puoi modificare. Le istruzioni che richiedono privilegi sul server, come CREATE DATABASE o CREATE ROLE, hanno bisogno di un PostgreSQL tuo.
Questa PostgreSQL cheat sheet è gratuita?

Sì. Puoi leggerla, copiarla e stamparla gratis, senza registrazione.

Illustrazione dei linguaggi di programmazione di Coddy

Impara PostgreSQL con Coddy

Inizia