El Projecte | Sobre nosaltres | Contribuir | Donacions | Llicència

HOME

Abans d'aprendre què significa cada sentència de SQL convé aprendre com està escrita. Igual que en qualsevol idioma, hi ha regles ortogràfiques i gramaticals que, si desconeixes, et faran perdre hores davant de missatges d'error críptics. Aquesta lliçó desmunta una sentència SQL en les seves peces elementals —paraules clau, identificadors, literals, operadors i expressions— i t'explica les regles del llenguatge: el punt i coma, el tractament de majúscules i minúscules, els comentaris, les convencions d'estil professional, la precedència d'operadors i, molt important, com interpretar un missatge d'error de PostgreSQL per localitzar la fallada en segons.

Aquí farem servir sentències molt simples com a vehicle. L'objectiu encara no és aprendre què fa SELECT o WHERE —això és el mòdul 2—; l'objectiu és entendre les regles ortogràfiques amb què s'escriu qualsevol sentència SQL.

Contingut

Anatomia d'una sentència SQL
El punt i coma
Majúscules i minúscules
Identificadors entre cometes
Comentaris
Convencions d'estil i format
Operadors i la seva precedència
Literals: cadenes, números, dates, booleans i NULL
Com llegir un missatge d'error de PostgreSQL
Errors habituals i consells
Exercicis
Conclusió

Anatomia d'una sentència SQL

Tota sentència SQL es compon d'un grapat de tipus d'element. Vegem-ne una i etiquetem cada peça:

SELECT nom, preu * 1.21 AS preu_amb_iva
FROM productes
WHERE actiu = TRUE AND preu > 10.00;

Element	A l'exemple	Què és
Paraules clau	`SELECT`, `FROM`, `WHERE`, `AS`, `AND`, `TRUE`	Termes reservats del llenguatge
Identificadors	`nom`, `preu`, `productes`, `actiu`, `preu_amb_iva`	Noms de taules, columnes, àlies, esquemes
Literals	`1.21`, `10.00`, `TRUE`	Valors escrits directament al text
Operadors	`*`, `=`, `>`, `AND`	Símbols o paraules que combinen valors
Expressions	`preu * 1.21`, `actiu = TRUE AND preu > 10.00`	Combinacions de l'anterior que produeixen un valor
Clàusules	`SELECT ...`, `FROM ...`, `WHERE ...`	Blocs que estructuren la sentència
Terminador	`;`	Marca el final de la sentència

Val la pena aturar-se en la diferència entre paraula clau i identificador, perquè és la font de la meitat dels errors de principiant:

Una paraula clau forma part del llenguatge. No la tries tu: SELECT sempre significa el mateix.
Un identificador és un nom que algú va posar a un objecte: la taula productes es diu així perquè qui va dissenyar BotigaVerda ho va decidir.

Regles dels identificadors a PostgreSQL:

Comencen per lletra o _, i continuen amb lletres, dígits, _ o $.
Llargada màxima: 63 caràcters (el que sobra es trunca en silenci).
No poden coincidir amb una paraula reservada... tret que els posis entre cometes (secció 4).
Es recomana snake_case en minúscules: linies_comanda, data_comanda, referit_per_id.

Una expressió és qualsevol cosa que s'avalua i produeix un valor. Ho pots comprovar sense cap taula:

SELECT 2 + 3;

?column?
5

A PostgreSQL, SELECT sense FROM és perfectament vàlid i és la millor manera d'experimentar amb expressions soltes. El farem servir molt en aquesta lliçó.

El punt i coma

El ; marca el final d'una sentència. El seu paper és doble:

Separar diverses sentències en un mateix fitxer o bloc.
Indicar al client que ja pot enviar la sentència al servidor.

SELECT 1;
SELECT 2;
SELECT 3;

Aquestes són tres sentències independents. Sense els punts i coma, PostgreSQL llegiria SELECT 1 SELECT 2 SELECT 3 i informaria d'un error de sintaxi.

Si a psql prems Retorn sense haver tancat la sentència, el símbol del sistema canvia:

botigaverda=# SELECT nom
botigaverda-# FROM productes
botigaverda-# ;

Aquest guionet (-#) significa "continuo esperant". No és un error: pots repartir una sentència en tantes línies com vulguis.

Situació	Cal el `;`?
Una sola sentència en un client gràfic	Opcional, però recomanable
Diverses sentències en un fitxer `.sql`	Obligatori
Metaordres de `psql` (`\dt`, `\l`, `\q`)	No, no són SQL
Última sentència d'un fitxer	Recomanable (evita sorpreses en concatenar fitxers)

Consell: posa'l sempre. És gratis i t'estalvia depurar per què un script s'ha executat "a mitges".

Majúscules i minúscules

Aquí hi ha dues regles diferents que convé no barrejar.

3.1. Les paraules clau no distingeixen majúscules

Aquestes quatre sentències són idèntiques per a PostgreSQL:

SELECT nom FROM productes;
select nom from productes;
Select Nom From Productes;
sELeCt nom FrOm productes;

Tot i així, la convenció universal és escriure les paraules clau en MAJÚSCULES, perquè fa la consulta molt més llegible: d'un cop d'ull distingeixes l'estructura del llenguatge dels noms del teu esquema.

3.2. Els identificadors sense cometes es converteixen a minúscules

Aquesta és la part que sorprèn. L'estàndard SQL diu que els identificadors sense cometes s'han de plegar a majúscules; PostgreSQL, per raons històriques, els plega a minúscules. L'efecte pràctic és que:

SELECT Nom FROM Productes;

és exactament el mateix que:

SELECT nom FROM productes;

perquè PostgreSQL converteix internament Nom → nom i Productes → productes.

Compara-ho entre motors:

SGBD	Paraules clau	Identificadors sense cometes	Noms de taula
PostgreSQL	Insensibles	Es pleguen a minúscules	Insensibles (pel plegament)
MySQL a Linux	Insensibles	Es conserven tal qual	Sensibles a majúscules
MySQL a Windows/macOS	Insensibles	Es conserven tal qual	Insensibles (pel sistema de fitxers)
SQLite	Insensibles	Es conserven tal qual	Insensibles
Oracle	Insensibles	Es pleguen a MAJÚSCULES	Insensibles (pel plegament)

Moralitat pràctica: fes servir sempre minúscules i snake_case als teus identificadors. Així el teu SQL es comporta igual a tots els motors i t'estalvies el problema sencer.

Compte: la insensibilitat a majúscules afecta la sintaxi, no les dades. Els valors sí que distingeixen:

SELECT 'València' = 'valència';

?column?
false

Identificadors entre cometes

Si envoltes un identificador amb cometes dobles, PostgreSQL se'l pren literalment: respecta majúscules, espais i caràcters especials.

-- Aquestes dues taules serien DIFERENTS per a PostgreSQL
CREATE TABLE productes (...);     -- es diu internament: productes
CREATE TABLE "Productes" (...);   -- es diu internament: Productes

I a partir d'aquí, qualsevol referència a la segona obliga a repetir les cometes:

SELECT * FROM "Productes";   -- funciona
SELECT * FROM Productes;     -- ERROR: relation "productes" does not exist

Aquest error és dels més desconcertants: la taula existeix, es veu a \dt, i tot i així el motor diu que no la troba. La causa sempre és la mateixa: algú la va crear entre cometes amb majúscules.

Ús de cometes dobles	Quan és legítim
Identificador que coincideix amb paraula reservada (`"order"`, `"user"`)	Acceptable, tot i que és millor reanomenar-lo
Identificador amb espais (`"nom del client"`)	Evitar sempre
Identificador amb majúscules (`"DataComanda"`)	Evitar sempre
Àlies que vols mostrar bonic en un informe (`AS "Preu amb IVA"`)	Ús raonable

Regla del curs: totes les taules i columnes de BotigaVerda estan en minúscules i snake_case precisament perquè mai no necessitis cometes dobles. L'única excepció acceptable seran els àlies de presentació.

I no ho oblidis: cometes dobles = identificador; cometes simples = cadena de text. No són intercanviables (hi tornarem a la secció 8).

Comentaris

SQL admet dues formes de comentari:

-- Comentari d'una línia: des dels dos guionets fins al final de línia

/* Comentari de bloc:
   pot ocupar diverses línies
   i és útil per desactivar trossos de consulta */

SELECT nom,            -- el nom comercial del producte
       preu            /* preu de venda al públic, sense IVA */
FROM productes;

Forma	Sintaxi	Ús típic
Línia	`-- text`	Anotar una columna o una condició
Bloc	`/* text */`	Capçaleres d'script, desactivar temporalment diverses línies

A PostgreSQL els comentaris de bloc es poden imbricar, cosa que no tots els motors permeten:

/* nivell 1 /* nivell 2 */ continuo al nivell 1 */
SELECT 1;

Bones pràctiques amb els comentaris:

Comenta el perquè, no el què. -- filtrem actius sobra si la línia ja diu WHERE actiu = TRUE. En canvi -- els inactius són productes descatalogats que conservem per històric sí que aporta.
Encapçala els scripts llargs amb un bloc que expliqui què fan i qui els manté.
Fes servir -- per desactivar una línia mentre depures, però neteja aquestes restes abans de donar la consulta per bona.

Convencions d'estil i format

SQL ignora els salts de línia i els espais de més, així que el format és enterament per a les persones. I sí, importa: una consulta de vint línies mal formatada és impossible de revisar.

Abans (tot en una línia, paraules clau en minúscules, sense estructura):

select p.nom, cat.nom, p.preu from productes p join categories cat on p.categoria_id = cat.id where p.actiu = true and p.preu between 5 and 20 order by p.preu desc;

Després (una clàusula per línia, paraules clau en majúscules, alineació clara):

SELECT p.nom,
       cat.nom AS categoria,
       p.preu
FROM productes AS p
JOIN categories AS cat ON p.categoria_id = cat.id
WHERE p.actiu = TRUE
  AND p.preu BETWEEN 5 AND 20
ORDER BY p.preu DESC;

Totes dues fan exactament el mateix. La segona es pot llegir, revisar i modificar.

Convencions que segueix aquest curs (i que són les més esteses del sector):

Regla	Exemple
Paraules clau en MAJÚSCULES	`SELECT`, `FROM`, `WHERE`, `AND`
Identificadors en minúscules i `snake_case`	`linies_comanda`, `data_comanda`
Una clàusula principal per línia	`SELECT` / `FROM` / `WHERE` / `ORDER BY` en línies pròpies
Condicions addicionals indentades sota `WHERE`	`AND p.preu > 10`
Llistes llargues de columnes, una per línia	Facilita veure els canvis a Git
Taules en plural, columnes en singular	Taula `clients`, columna `nom`
Claus foranes com `<taula_singular>_id`	`client_id`, `producte_id`, `categoria_id`
Sense espais ni accents als identificadors	`puntuacio`, no `puntuació`
Mai `SELECT *` en codi de producció	Anomena les columnes explícitament

Fixa't que la columna es diu puntuacio i no puntuació, i que la taula pont es diu linies_comanda sense el punt volat de «línies». És deliberat: evitar accents, ç i · als identificadors prevé problemes de codificació, de portabilitat entre motors i d'escriptura en teclats no catalans.

Operadors i la seva precedència

7.1. Aritmètics

Operador	Significat	Exemple	Resultat
`+`	Suma	`SELECT 10 + 3;`	13
`-`	Resta	`SELECT 10 - 3;`	7
`*`	Multiplicació	`SELECT 10 * 3;`	30
`/`	Divisió	`SELECT 10 / 3;`	3
`%`	Mòdul (residu)	`SELECT 10 % 3;`	1
`^`	Potència	`SELECT 2 ^ 10;`	1024

El parany és a /: si tots dos operands són enters, la divisió és entera.

SELECT 10 / 3 AS divisio_entera,
       10.0 / 3 AS divisio_decimal;

divisio_entera	divisio_decimal
3	3.3333333333333333

Només escrivint 10.0 en comptes de 10 canvies el tipus del literal i amb ell el resultat. És una font clàssica de descompensacions en calcular percentatges.

7.2. De comparació

Operador	Significat	Exemple
`=`	Igual	`preu = 10`
`<>` o `!=`	Diferent	`estat <> 'cancellat'`
`<`, `>`	Menor, major	`stock > 0`
`<=`, `>=`	Menor o igual, major o igual	`preu <= 20`
`BETWEEN ... AND ...`	Dins d'un rang, extrems inclosos	`preu BETWEEN 5 AND 20`
`IN (...)`	Pertany a una llista	`pais IN ('Espanya','França')`
`IS NULL` / `IS NOT NULL`	És (o no) nul	`empleat_id IS NULL`

<> és la forma estàndard de "diferent"; != funciona a PostgreSQL i a gairebé tots els motors, però <> és més portable. Els operadors BETWEEN, IN, LIKE i IS NULL s'estudien a fons al mòdul 4.

7.3. Lògics

Operador	Retorna cert quan...
`AND`	Totes dues condicions són certes
`OR`	Com a mínim una condició és certa
`NOT`	La condició és falsa

7.4. Precedència

Quan barreges operadors, PostgreSQL els avalua en aquest ordre (de major a menor prioritat):

Nivell	Operadors
1	`()` parèntesis
2	`::` conversió de tipus
3	`-` unari (signe negatiu)
4	`^` potència
5	`*`, `/`, `%`
6	`+`, `-`
7	`BETWEEN`, `IN`, `LIKE`
8	`=`, `<>`, `<`, `>`, `<=`, `>=`
9	`IS NULL`, `IS NOT NULL`
10	`NOT`
11	`AND`
12	`OR`

El que més problemes causa és que AND té més prioritat que OR. Compara:

SELECT TRUE OR FALSE AND FALSE;    -- s'avalua com: TRUE OR (FALSE AND FALSE)
SELECT (TRUE OR FALSE) AND FALSE;  -- forcem un altre ordre amb parèntesis

Consulta	Resultat
`TRUE OR FALSE AND FALSE`	true
`(TRUE OR FALSE) AND FALSE`	false

Traduït a un cas real de BotigaVerda: "vull les comandes de França o Portugal que estiguin lliurades". Escrit ingènuament:

-- MALAMENT: s'interpreta com  pais='França' OR (pais='Portugal' AND estat='lliurat')
... WHERE pais = 'França' OR pais = 'Portugal' AND estat = 'lliurat'

-- BÉ
... WHERE (pais = 'França' OR pais = 'Portugal') AND estat = 'lliurat'

La primera versió et retornaria totes les comandes franceses, lliurades o no. No dona error: dona un resultat incorrecte en silenci, que és molt pitjor.

Consell professional: encara que et sàpigues la taula de precedència, posa parèntesis sempre que barregis AND i OR. Costen dos caràcters i eliminen l'ambigüitat per a qui llegeixi la teva consulta després.

Literals: cadenes, números, dates, booleans i NULL

Un literal és un valor escrit directament a la sentència.

8.1. Cadenes de text: cometes SIMPLES

SELECT 'Alimentació';
SELECT 'València';

Les cadenes van entre cometes simples. Sempre. Aquest és probablement l'error número u de qui ve d'altres llenguatges de programació, on "text" i 'text' són equivalents:

SELECT "Alimentació";

ERROR:  column "Alimentació" does not exist
LINE 1: SELECT "Alimentació";
               ^

El missatge delata què ha passat: PostgreSQL ha entès les cometes dobles com un identificador, ha buscat una columna anomenada Alimentació i no l'ha trobada.

I si el text conté una cometa simple, com a "L'Eliana"? Es duplica:

SELECT 'L''Eliana' AS poblacio;

poblacio
L'Eliana

PostgreSQL també admet les dollar-quoted strings, molt còmodes per a textos amb moltes cometes:

SELECT $$El comentari deia: 'no m'ha agradat'$$;

8.2. Numèrics

SELECT 42;         -- enter
SELECT -17;        -- enter negatiu
SELECT 12.50;      -- decimal exacte (tipus numeric)
SELECT 1.2e3;      -- notació científica: 1200

Els números no porten cometes. Si escrius '12.50' estàs creant una cadena de text que PostgreSQL de vegades convertirà per tu i de vegades no, amb resultats sorprenents.

8.3. Dates i hores

Les dates s'escriuen com a cadenes de text, entre cometes simples, en format ISO 8601 (AAAA-MM-DD):

SELECT DATE '2026-02-14' AS data;
SELECT TIMESTAMP '2026-02-14 18:30:00' AS moment;
SELECT '2026-02-14'::DATE AS data_amb_cast;

data
2026-02-14

Escriu sempre en format ISO. Si escrius '14/02/2026', el motor ho interpretarà segons la seva configuració regional (DateStyle), i en un servidor configurat a l'americana '03/04/2026' pot significar 3 d'abril o 4 de març. És un error que no salta mai: simplement produeix dades incorrectes. Les funcions de data es veuen a fons al mòdul 6.

8.4. Booleans

SELECT TRUE, FALSE;

PostgreSQL accepta diverses maneres d'escriure'ls: TRUE/FALSE, 't'/'f', 'yes'/'no', '1'/'0'. Fes servir TRUE i FALSE a seques: és el més clar.

Nota de dialecte: MySQL no té un tipus boolean real; BOOLEAN és un àlies de TINYINT(1) on TRUE és 1 i FALSE és 0. SQLite tampoc no té boolean natiu: els desa com a 0 i 1.

8.5. NULL

NULL no és un valor: és l'absència de valor. A BotigaVerda, comandes.empleat_id és NULL quan la comanda va arribar per la web i cap comercial no la va gestionar.

El que importa ara, sintàcticament, és que NULL no es compara amb =:

SELECT NULL = NULL AS amb_igual,
       NULL IS NULL AS amb_is_null;

amb_igual	amb_is_null
(null)	true

NULL = NULL no dona ni cert ni fals: dona NULL, perquè comparar dues incògnites no permet concloure res. Per això existeix l'operador IS NULL. La semàntica completa dels nuls s'estudia a la lliçó 04-03; aquí n'hi ha prou que retinguis la regla: per a nuls, IS NULL; mai = NULL.

8.6. Resum de literals

Tipus	Com s'escriu	Exemple correcte	Error típic
Cadena	Cometes simples	`'Cosmètica natural'`	`"Cosmètica natural"` (seria un identificador)
Número	Sense cometes	`12.50`	`'12.50'`
Data	Cometes simples, format ISO	`'2026-02-14'`	`'14/02/2026'`
Boolean	Sense cometes	`TRUE`	`'TRUE'`
Nul	Paraula clau `NULL`	`IS NULL`	`= NULL`

Com llegir un missatge d'error de PostgreSQL

Els missatges de PostgreSQL són dels millors del sector, però cal saber llegir-los. Tenen fins a quatre parts:

ERROR:  syntax error at or near "FORM"
LINE 2: FORM productes;
        ^

Part	Significat
`ERROR:`	La descripció del problema
`at or near "FORM"`	El token on l'analitzador s'ha encallat
`LINE 2:`	La línia de la teva sentència
`^`	La columna exacta

La clau és l'expressió "at or near" ("a o prop de"). PostgreSQL assenyala on ha detectat el problema, que molt sovint és una posició després d'on realment és l'error. Si el cursor apunta a una cosa que sembla correcta, mira sempre el token anterior.

Exemple real:

SELECT nom preu FROM productes;

ERROR:  syntax error at or near "FROM"
LINE 1: SELECT nom preu FROM productes;
                        ^

El cursor apunta a FROM, però FROM està perfectament escrit. L'error real és que falta una coma entre nom i preu: PostgreSQL va interpretar preu com un àlies de nom (un àlies es pot escriure sense AS), i en arribar a FROM ja no hi encaixava res més.

Els errors més freqüents en començar i la seva traducció:

Missatge	Què significa realment	Com s'arregla
`syntax error at or near "X"`	Gramàtica trencada a X o just abans	Revisa el token anterior: comes, parèntesis, paraules mal escrites
`relation "productes" does not exist`	La taula no existeix, o és en un altre esquema, o es va crear amb cometes i majúscules	`\dt` per veure el nom real; comprova a quina base estàs connectat
`column "Alimentació" does not exist`	Vas fer servir cometes dobles per a una cadena de text	Canvia-les per cometes simples
`column "pru" does not exist`	Errada al nom de la columna	`\d productes` per veure els noms exactes
`operator does not exist: text > integer`	Estàs comparant tipus incompatibles	Revisa el tipus de la columna; fes servir `CAST` (mòdul 6)
`unterminated quoted string at or near "'..."`	Falta tancar una cometa simple	Compta les cometes; si ets a `psql`, el símbol `'#` t'avisa
`division by zero`	Divideixes entre 0	Protegeix el divisor (`NULLIF`, mòdul 6)

Procediment recomanat davant de qualsevol error:

Llegeix el missatge sencer, no només la primera paraula.
Localitza la línia i la columna amb el ^.
Si el que s'assenyala sembla correcte, mira el que hi ha abans.
Comprova el bàsic: comes, parèntesis equilibrats, cometes tancades, tipus de cometa.
Si és un nom, verifica'l amb \d.
Si la consulta és llarga, redueix-la: treu clàusules fins que funcioni i torna-les a afegir una a una.

Errors habituals i consells

Fer servir cometes dobles per al text. "València" és un identificador; 'València' és una cadena. Si l'error parla d'una "column ... does not exist" amb el text que volies buscar, és això.
Oblidar la coma entre columnes. Produeix un syntax error at or near "FROM" que despista molt, perquè FROM està bé.
Crear objectes amb "MajúsculesEntreCometes". Et condemna a repetir les cometes per sempre. Fes servir snake_case en minúscules.
Refiar-te de la precedència d'AND/OR. No dona error, dona resultats equivocats. Posa-hi parèntesis.
Divisió entera inesperada. 10 / 3 és 3. Converteix a decimal abans de calcular percentatges o mitjanes.
Dates en format local. Escriu sempre 'AAAA-MM-DD'.
Comparar amb = NULL. No retorna files mai, i no avisa. Fes servir IS NULL.
Consell: formata abans de depurar. Una consulta d'una sola línia és impossible de revisar; posa-la en diverses línies i l'error sol saltar a la vista.
Consell: prova les expressions amb SELECT sense FROM. Abans de ficar un càlcul en una consulta gran, verifica'l aïllat: SELECT 12.50 * 1.21;.
Consell: quan alguna cosa falli, simplifica. Treu mitja consulta i comprova si l'error persisteix. És la manera més ràpida d'acotar.

Exercicis

Exercici 1

Localitza i corregeix quatre errors de sintaxi a la sentència següent. Indica quin missatge donaria PostgreSQL en cada cas.

SELECT nom preu, stock
FORM productes
WHERE ciutat = "València"
  AND actiu = TRUE

Exercici 2

Sense executar res, prediu el resultat d'aquestes cinc expressions i explica per què. Després comprova-les amb SELECT.

SELECT 7 / 2;
SELECT 7.0 / 2;
SELECT TRUE OR FALSE AND FALSE;
SELECT 'València' = 'valència';
SELECT NULL = NULL;

Exercici 3

Reescriu aquesta consulta aplicant les convencions d'estil del curs (paraules clau en majúscules, una clàusula per línia, indentació de les condicions) i corregeix la fallada lògica que conté: la intenció era obtenir les comandes pagades o enviades les despeses d'enviament de les quals superin els 5 €.

select id, estat, despeses_enviament from comandes where estat = 'pagat' or estat = 'enviat' and despeses_enviament > 5;

Solucions

Solució 1

Els quatre errors, per ordre d'aparició:

#	Error	Missatge de PostgreSQL	Correcció
1	Falta la coma entre `nom` i `preu`	`syntax error at or near "preu"` (o prop de `FORM`)	`SELECT nom, preu, stock`
2	`FORM` en comptes de `FROM`	`syntax error at or near "FORM"`	`FROM productes`
3	Cometes dobles a la cadena `"València"`	`column "València" does not exist`	`= 'València'`
4	Falta el punt i coma final	A `psql`, el símbol es queda a `-#` esperant	Afegir `;`

Hi ha a més un problema semàntic: la taula productes de BotigaVerda no té columna ciutat (aquesta columna és a clients i a empleats). PostgreSQL respondria column "ciutat" does not exist. Versió corregida:

SELECT nom, preu, stock
FROM productes
WHERE actiu = TRUE;

Solució 2

Expressió	Resultat	Motiu
`7 / 2`	`3`	Tots dos operands són enters → divisió entera, es trunca (no s'arrodoneix)
`7.0 / 2`	`3.5000000000000000`	`7.0` és `numeric`, així que la divisió és decimal
`TRUE OR FALSE AND FALSE`	`true`	`AND` té més prioritat: s'avalua `TRUE OR (FALSE AND FALSE)` = `TRUE OR FALSE`
`'València' = 'valència'`	`false`	Les dades sí que distingeixen majúscules, encara que la sintaxi no
`NULL = NULL`	`NULL`	Comparar dues absències de valor no permet concloure res; cal fer servir `IS NULL`

Fixa't en el contrast entre les files 3, 4 i 5: en SQL la insensibilitat a majúscules és cosa de la gramàtica, mai dels valors, i NULL no es comporta com un valor normal.

Solució 3

La fallada lògica és la precedència: AND s'avalua abans que OR, de manera que la consulta original significa estat = 'pagat' OR (estat = 'enviat' AND despeses_enviament > 5), i retornaria totes les comandes pagades, fins i tot les d'enviament gratuït. Versió corregida i formatada:

SELECT id,
       estat,
       despeses_enviament
FROM comandes
WHERE (estat = 'pagat' OR estat = 'enviat')
  AND despeses_enviament > 5;

Els parèntesis agrupen l'alternativa d'estats abans d'aplicar el filtre d'import. Al mòdul 4 veuràs una manera encara més llegible d'escriure aquesta primera condició: estat IN ('pagat', 'enviat').

Conclusió

Ja coneixes les regles ortogràfiques del llenguatge:

Una sentència es compon de paraules clau, identificadors, literals, operadors i expressions, organitzats en clàusules i tancats per ;.
Les paraules clau no distingeixen majúscules, però els identificadors sense cometes es pleguen a minúscules a PostgreSQL: per això el curs fa servir snake_case en minúscules i evita les cometes dobles.
Comentes amb -- i /* */, i formates amb una clàusula per línia perquè el SQL s'escriu una vegada i es llegeix moltes.
Domines els operadors aritmètics, de comparació i lògics, i saps que AND precedeix OR: per això hi poses parèntesis.
Distingeixes els literals: cometes simples per a text i dates ISO, res de cometes per a números i booleans, i IS NULL per als nuls.
Saps llegir un error de PostgreSQL: missatge, token, línia i cursor, recordant que la fallada sol ser just abans del que s'assenyala.

A la lliçó següent, Entendre bases de dades i taules, passarem de la forma al contingut: què és exactament una base de dades, un esquema, una taula, una fila i una columna; quins tipus de dades ofereix PostgreSQL i com triar l'adequat (inclòs per què els diners no s'han de desar mai en un FLOAT); i com inspeccionar l'estructura de taules que ja existeixen.

Sintaxi bàsica de SQL

Contingut

Anatomia d'una sentència SQL

El punt i coma

Majúscules i minúscules

3.1. Les paraules clau no distingeixen majúscules

3.2. Els identificadors sense cometes es converteixen a minúscules

Identificadors entre cometes

Comentaris

Convencions d'estil i format

Operadors i la seva precedència

7.1. Aritmètics

7.2. De comparació

7.3. Lògics

7.4. Precedència

Literals: cadenes, números, dates, booleans i NULL

8.1. Cadenes de text: cometes SIMPLES

8.2. Numèrics

8.3. Dates i hores

8.4. Booleans

8.5. NULL

8.6. Resum de literals

Com llegir un missatge d'error de PostgreSQL

Errors habituals i consells

Exercicis

Exercici 1

Exercici 2

Exercici 3

Solucions

Conclusió

Curs de SQL

Mòdul 1: Introducció a SQL

Mòdul 2: Consultes bàsiques de SQL

Mòdul 3: Treballar amb múltiples taules

Mòdul 4: Filtratge avançat de dades

Mòdul 5: Manipulació de dades

Mòdul 6: Funcions avançades de SQL

Mòdul 7: Subconsultes i consultes imbricades

Mòdul 8: Índexs i optimització del rendiment

Mòdul 9: Transaccions i concurrència

Mòdul 10: Temes avançats

Mòdul 11: SQL a la pràctica

Mòdul 12: Projecte final