Bases de dades relacionals
Model relacional, claus primàries i foranes, relacions i SQL bàsic
4 fonts originals
01. Resum
Comença per aquí
Si només recordes cinc coses d'aquest tema:
- Model relacional (Codd, 1970): les dades es guarden en taules. SQL és declaratiu: dius què vols, no com trobar-ho.
- Clau primària: identifica cada fila, no es repeteix i mai és nul·la. Clau forana: apunta a la PK d'una altra taula i es pot repetir.
- 1:N → la FK va al costat N. N:M → taula intermèdia amb dues FK.
- DDL canvia l'estructura (
CREATE,ALTER,DROP). DML treballa amb les dades (SELECT,INSERT,UPDATE,DELETE). - Ordre fix:
SELECT→FROM→WHERE→ORDER BY. UnUPDATEoDELETEsenseWHEREafecta totes les files.
A la versió completa, cada apartat acaba amb una pregunta d'examen i la seva resposta model.
La idea en un minut
Una base de dades relacional guarda la informació en taules que es relacionen entre si amb claus. Amb SQL crees les taules, hi poses dades i les consultes.
- 1. El modelQui el va inventar i per què.
- 2. Les taulesFiles, columnes, dominis i propietats.
- 3. Les clausPrimàries, foranes i tipus de relació.
- 4. Les restriccionsEntitat, referencial, domini i UNIQUE.
- 5. SQLDDL (estructura) i DML (dades): CREATE, INSERT, SELECT, UPDATE, DELETE, LIKE i JOIN.
El model relacional
L'any 1970, Edgar F. Codd (IBM) va proposar guardar les dades en taules (relacions). Abans, calia saber com estaven guardades físicament les dades per consultar-les. Amb el model relacional, no.
SQL és el llenguatge que neix d'aquest model. És declaratiu: dius què vols, no com trobar-ho.
Sis objectius: SIMICE — simplificar, independència, menys redundància, integritat, consultes fàcils i escalabilitat.
D'on ve
- Abans dels 70Models jeràrquics o en xarxa. Per accedir a les dades calia conèixer com estaven guardades físicament.
- 1970Edgar F. Codd, investigador d'IBM, publica A Relational Model of Data for Large Shared Data Banks.
- La ideaGuardar les dades en relacions (taules) basades en la teoria de conjunts i l'àlgebra relacional.
- 1981Codd rep el Premi Turing, l'equivalent al Nobel en informàtica.
Abans: jeràrquic o en xarxa
- Estructures complexes
- Calia conèixer l'emmagatzematge físic
- Aplicacions difícils de mantenir
Model relacional
- Dades en taules fàcils d'entendre
- Consultes sense conèixer l'estructura física
- Base matemàtica sòlida
Avui, el model de Codd és la base dels SGBDR (sistemes gestors de bases de dades relacionals): MySQL, PostgreSQL, Oracle, SQL Server i MariaDB.
Els sis objectius
1 · Simplificar
Taules fàcils d'entendre i mantenir.
2 · Independència
Les aplicacions funcionen encara que canviï l'emmagatzematge físic.
3 · Menys redundància
Cada dada es guarda un sol cop.
4 · Integritat
Claus i restriccions asseguren dades correctes.
5 · Consultes fàcils
SQL és declaratiu: dius què vols.
6 · Escalabilitat
Pots ampliar la base de dades sense redissenyar-ho tot.
Anatomia d'una taula
Cada concepte té diversos noms:
| Terme | També es diu | Exemple |
|---|---|---|
| Taula | Relació | Clientes |
| Fila | Tupla, registre | El client 1, Ana López |
| Columna | Atribut | Ciudad |
| Domini | Valors permesos | Edat de 0 a 120 |
Regles: un sol valor per cel·la, cap fila repetida i totes les files amb les mateixes columnes.
Una taula (relació) pot descriure una cosa (clients, productes) o un fet que relaciona coses (matrícules, línies de comanda).
| Terme | També | Què és |
|---|---|---|
| Taula | Relació | Conjunt de files del mateix tipus |
| Fila | Tupla, registre | Un element concret: el client 1, Ana López |
| Columna | Atribut | Una característica: nom, ciutat, telèfon |
| Valor | — | El contingut d'una cel·la |
| Domini | — | Els valors permesos d'una columna: edat de 0 a 120 |
Nom de taula únic
No hi ha dues taules Clientes.
Nom de columna únic
Dins de cada taula.
Sense files repetides
La clau primària ho assegura.
Un valor per cel·la
Atomicitat: res de «Barcelona, Girona» en una cel·la.
Mateixa estructura
Totes les files tenen les mateixes columnes.
La taula Productos (ProductoID, Nombre, Precio, CategoriaID) té 40 productes.
- Quantes files i columnes té?
- Com es diuen les files i les columnes en el model relacional?
- Quin domini té Precio?
Solució
- 40 files i 4 columnes.
- Files = tuples o registres. Columnes = atributs.
- Nombres decimals iguals o més grans que 0. Per exemple
DECIMAL(10,2)ambPrecio >= 0.
Claus primàries i foranes
- Clau primària (PK): identifica cada fila. No es repeteix i mai és nul·la. ClienteID a Clientes.
- Clau forana (FK): apunta a la PK d'una altra taula. Es pot repetir, però ha d'apuntar a una fila que existeixi. ClienteID a Pedidos.
Tres tipus de relació:
- 1:1 — Persona ↔ passaport.
- 1:N — Un client, moltes comandes. La FK va al costat N.
- N:M — Comandes ↔ productes. Cal una taula intermèdia amb dues FK.
Clau primària (PK)
Identifica cada fila.
- No es repeteix
- Mai és nul·la
- N'hi ha una per taula (pot tenir diverses columnes)
ClienteID a la taula Clientes.
Clau forana (FK)
Apunta a la PK d'una altra taula.
- Es pot repetir: un client, moltes comandes
- Si té valor, ha d'existir a l'altra taula
- Pot ser nul·la si la relació és opcional
ClienteID a la taula Pedidos.
Clientes
| ClienteID · PK | Nombre | Ciudad |
|---|---|---|
| 1 | Ana López | Barcelona |
| 2 | Carlos Pérez | Madrid |
| 3 | Marta Ruiz | Valencia |
Pedidos
| PedidoID · PK | ClienteID · FK | Fecha |
|---|---|---|
| 1001 | 1 | 15/09/2026 |
| 1002 | 2 | 16/09/2026 |
| 1003 | 1 | 18/09/2026 |
El client 1 surt dues vegades a Pedidos: l'Ana ha fet dues comandes. La relació es fa amb ClienteID: PK a Clientes i FK a Pedidos.
Tipus de relacions
1:1
Cada fila es relaciona amb com a màxim una de l'altra taula.
Persona ↔ passaport
1:N
Una fila amb moltes. És la més habitual.
Un client fa moltes comandes. Cada comanda és d'un client.
N:M
Moltes amb moltes. Cal una taula intermèdia.
Comandes ↔ productes, a través de Detalle_pedido.
Com saber quina és: fes la pregunta en els dos sentits. Quantes comandes pot tenir un client? Moltes. Quants clients pot tenir una comanda? Un. → 1:N. Si les dues respostes són «moltes», és N:M.
La taula intermèdia té una fila per cada parella:
| PedidoID · FK | ProductoID · FK |
|---|---|
| 1001 | 1 (Ordinador) |
| 1001 | 2 (Teclat) |
| 1002 | 2 (Teclat) |
| 1002 | 3 (Mòbil) |
Pregunta. Explica la diferència entre clau primària i clau forana. On va la clau forana en una relació 1:N? I en una N:M?
Resposta model. La clau primària identifica cada fila d'una taula: no es pot repetir ni ser nul·la. La clau forana és una columna que apunta a la clau primària d'una altra taula: es pot repetir, però ha d'apuntar a una fila que existeixi. En una relació 1:N la clau forana va a la taula del costat N: ClienteID va a Pedidos, perquè cada comanda té un sol client. En una relació N:M cal una taula intermèdia amb dues claus foranes, una cap a cada taula.
Restriccions d'integritat
Les restriccions impedeixen dades incorrectes:
| Restricció | Què mira | Error que evita |
|---|---|---|
| D'entitat | La PK | Dues comandes amb el mateix PedidoID |
| Referencial | La FK | Una comanda del client 999, que no existeix |
| De domini | El valor | Una edat de 150 anys |
| UNIQUE | Repetits en una columna | Dos clients amb el mateix correu |
En SQL: PRIMARY KEY, FOREIGN KEY, CHECK, UNIQUE i NOT NULL.
D'entitat
La clau primària no es pot repetir ni ser nul·la.
Referencial
Una FK ha d'apuntar a una fila que existeix. Evita registres «orfes».
De domini
Limita els valors d'una columna: CHECK (Edad BETWEEN 0 AND 120).
UNIQUE
Una columna que no és la PK tampoc es pot repetir: Email UNIQUE.
Correcte
- PedidoID 1001 i 1002: cada comanda té la seva PK
- Comanda amb ClienteID = 1, que existeix
- Edat 34, dins de 0–120
Incorrecte
- Dues comandes amb PedidoID = 1001 → entitat
- Comanda amb ClienteID = 999, que no existeix → referencial
- Edat 150 → domini
- Dos clients amb el mateix correu → UNIQUE
- Inserir un client amb ClienteID = 2 quan ja n'hi ha un.
- Inserir una comanda del client 57, que no existeix.
- Inserir un client sense ClienteID.
- Guardar una edat de −3.
- Esborrar l'Ana quan encara té comandes.
Solució
- Entitat: PK repetida.
- Referencial: la FK apunta a una PK que no existeix.
- Entitat: PK nul·la.
- Domini: valor fora del permès.
- Referencial: les seves comandes quedarien orfes.
Pregunta. Quina restricció es viola en cada cas? (a) Dues comandes amb el mateix PedidoID. (b) Una comanda del client 999, que no existeix. (c) Una edat de 150. (d) Dos clients amb el mateix correu.
Resposta model. (a) Integritat d'entitat: la clau primària no es pot repetir. (b) Integritat referencial: la clau forana ha d'apuntar a una fila que existeixi. (c) Integritat de domini: el valor és fora dels valors permesos; es controla amb CHECK. (d) UNIQUE: la columna no admet repetits.
Dissenyar taules a partir d'un enunciat
Quatre passos:
- Entitats: els substantius importants. Cada un serà una taula.
- Atributs: què cal saber de cada entitat.
- Claus primàries: un identificador per taula.
- Relacions: 1:N → FK al costat N. N:M → taula intermèdia.
Exemple: una acadèmia amb alumnes i cursos. Un alumne fa molts cursos i un curs té molts alumnes → N:M → taula Matricules amb AlumneID i CursID. La data de matrícula va a Matricules.
Enunciat: una acadèmia vol guardar els seus alumnes, els cursos que ofereix i en quins cursos s'ha matriculat cada alumne.
- 1. EntitatsBusca els substantius importants: alumnes i cursos.
- 2. AtributsAlumne: nom i correu. Curs: nom i hores.
- 3. Claus primàriesAlumneID i CursID.
- 4. RelacionsUn alumne fa molts cursos i un curs té molts alumnes: N:M. Cal una taula intermèdia Matricules amb dues FK.
La data va a Matricules: depèn de l'alumne i del curs alhora.
Una biblioteca vol guardar els socis, els llibres i els préstecs (quin soci s'endú quin llibre i quan). Un soci pot tenir molts préstecs i un llibre es pot prestar moltes vegades.
Solució
Socis–Llibres és N:M. La taula intermèdia Prestecs guarda també les dates. Fa servir una PK pròpia (PrestecID) perquè un soci pot agafar el mateix llibre diverses vegades.
SQL: DDL i DML
SQL té dos grups d'ordres:
- DDL (estructura):
CREATE,ALTER,DROP. - DML (dades):
SELECT,INSERT,UPDATE,DELETE.
Si l'ordre porta TABLE al darrere, és DDL.
DELETE esborra files. DROP esborra la taula sencera.
SQL (Structured Query Language) és el llenguatge estàndard de les bases de dades relacionals.
DDL · Data Definition Language
Defineix l'estructura.
CREATE · ALTER · DROP
DML · Data Manipulation Language
Treballa amb les dades.
SELECT · INSERT · UPDATE · DELETE
Pregunta. Classifica aquestes ordres en DDL o DML i explica la diferència entre DELETE i DROP: CREATE TABLE, INSERT, ALTER TABLE, UPDATE, DROP TABLE, SELECT, DELETE.
Resposta model. DDL (defineix l'estructura): CREATE TABLE, ALTER TABLE i DROP TABLE. DML (treballa amb les dades): INSERT, UPDATE, SELECT i DELETE. DELETE esborra files i la taula continua existint. DROP esborra la taula sencera, amb l'estructura i totes les dades.
Crear taules: tipus de dades
| Tipus | Per a | Exemple |
|---|---|---|
INT | Enters | 1, 225 |
DECIMAL(10,2) | Imports amb cèntims | 25.50 |
VARCHAR(100) | Text variable | Ana López |
CHAR(2) | Text fix | ES |
DATE | Dates | 2026-09-15 |
BOOLEAN | Cert o fals | TRUE |
CREATE TABLE Clientes (
ClienteID INT PRIMARY KEY,
Nombre VARCHAR(100),
Ciudad VARCHAR(50)
);| Tipus | Per a | Exemple |
|---|---|---|
INT | Enters | 1, 225, 1000 |
DECIMAL(10,2) | Nombres amb decimals: 10 xifres, 2 decimals | 25.50, 199.99 |
VARCHAR(100) | Text de longitud variable, fins a 100 caràcters | Ana López |
CHAR(2) | Text de longitud fixa | ES, FR, IT |
DATE | Dates (any-mes-dia) | 2026-09-15 |
BOOLEAN | Lògic | TRUE, FALSE |
CREATE TABLE Clientes (
ClienteID INT PRIMARY KEY,
Nombre VARCHAR(100),
Ciudad VARCHAR(50)
);
CREATE TABLE Pedidos (
PedidoID INT PRIMARY KEY,
Fecha DATE,
Importe DECIMAL(10,2),
ClienteID INT,
FOREIGN KEY (ClienteID) REFERENCES Clientes(ClienteID)
);Primer crees Clientes. Després Pedidos, perquè hi fa referència amb la clau forana.
Consultar: SELECT
L'ordre de les clàusules és fix: SELECT (quines columnes) → FROM (de quina taula) → WHERE (quines files) → ORDER BY (en quin ordre).
SELECT Nombre, Ciudad
FROM Clientes
WHERE Ciudad = 'Barcelona'
ORDER BY Nombre;El text va entre cometes simples. Els números, sense. ORDER BY ordena de menor a major. Per al revés, DESC. «Diferent» és <>.
SELECT tria columnes. WHERE filtra files. ORDER BY les ordena.
SELECT * FROM Clientes; -- totes les columnes
SELECT Nombre, Ciudad FROM Clientes; -- només aquestes
SELECT * FROM Clientes WHERE Ciudad = 'Barcelona';
SELECT * FROM Clientes ORDER BY Nombre; -- ascendent (per defecte)
SELECT * FROM Clientes ORDER BY Nombre DESC; -- descendent| Operador | Significa |
|---|---|
= | Igual |
<> | Diferent |
> · < | Més gran · més petit |
>= · <= | Més gran o igual · més petit o igual |
AND · OR | Les dues condicions · alguna de les dues |
Cercar text: LIKE
Amb = només trobes el text exacte. Amb LIKE busques un patró:
%= qualsevol nombre de caràcters (també cap)._= exactament un caràcter.
| Patró | Vol dir |
|---|---|
'M%' | Comença per M |
'%ez' | Acaba en «ez» |
'%art%' | Conté «art» |
'_a%' | La segona lletra és «a» |
En SQL el comodí és %, no *.
Per trobar els correus de Gmail, els noms que comencen per M o les ciutats que contenen «Sant», fes servir LIKE al WHERE, en lloc del =. El patró va entre cometes simples.
SELECT columnes
FROM taula
WHERE columna LIKE 'patró';% · qualsevol nombre de caràcters
Zero, un o molts.
'M%' → Marta, Marc, Mo
_ · exactament un caràcter
Un per cada _.
'_a%' → Laura, Marta, Pablo
| Patró | Vol dir | Troba (Nombre) | No troba |
|---|---|---|---|
'M%' | Comença per M | Marta Ruiz, Marc Serra | Ana López |
'%ez' | Acaba en «ez» | Ana López, Carlos Pérez, Laura Gómez, Sara Martínez | Marta Ruiz |
'%art%' | Conté «art» | Marta Ruiz, Pablo Martín, Sara Martínez | Marc Serra |
'_a%' | Segona lletra «a» | Carlos, Laura, Marta, Pablo, Sara, Marc | Ana, Jordi |
LIKE es combina amb NOT, AND i COUNT:
SELECT Nombre FROM Clientes WHERE Email NOT LIKE '%@gmail.com'; -- 5 clients
SELECT Nombre FROM Clientes WHERE Ciudad = 'Barcelona' AND Nombre LIKE 'P%'; -- Pablo Martín
SELECT COUNT(*) FROM Clientes WHERE Email LIKE '%@empresa.es'; -- 3| Consulta de classe | WHERE | Resultat |
|---|---|---|
| Nom que comença per «L» | Nombre LIKE 'L%' | Laura Gómez |
| Correu d'empresa.es | Email LIKE '%@empresa.es' | Carlos, Pablo, Marc |
| Ciutat amb la segona lletra «a» | Ciudad LIKE '_a%' | Barcelona, Madrid, Valencia, Sabadell, Sant Cugat |
| Nom complet acabat en «z» | Nombre LIKE '%z' | Ana, Carlos, Marta, Laura, Sara |
| Ciutat que no comença per «S» | Ciudad NOT LIKE 'S%' | Tots menys Jordi (Sabadell) i Sara (Sant Cugat) |
Majúscules i accents depenen de la col·lació de la columna. Amb MariaDB i utf8mb4_general_ci, '%martin%' troba Martín i també Martínez.
LIKE busca dins del text, però no entén què vol dir. Si el nom i el cognom van junts, '%a' mira el final del cognom: només surt Marc Serra.
El truc és buscar una «a» seguida d'un espai: LIKE '%a %' → Ana, Marta, Laura i Sara. Però la solució bona és de disseny: guardar Nombre i Apellidos en columnes separades (atomicitat).
Pregunta. Escriu una consulta que mostri el nom i la ciutat dels clients el nom dels quals comença per M, ordenats per nom de la Z a l'A.
Resposta model. SELECT Nombre, Ciudad FROM Clientes WHERE Nombre LIKE 'M%' ORDER BY Nombre DESC; El comodí % vol dir qualsevol nombre de caràcters. Cal LIKE i no =, perquè amb = el % no és comodí. El text va entre cometes simples i DESC inverteix l'ordre.
Modificar: INSERT, UPDATE i DELETE
INSERT INTO Clientes VALUES (1, 'Ana López', 'Barcelona');
UPDATE Clientes SET Ciudad = 'Sevilla' WHERE ClienteID = 2;
DELETE FROM Clientes WHERE ClienteID = 3;Compte: un UPDATE o un DELETE sense WHERE canvia o esborra totes les files. No dona cap error.
INSERT INTO Clientes VALUES (1, 'Ana López', 'Barcelona');
UPDATE Clientes SET Ciudad = 'Sevilla' WHERE ClienteID = 2;
DELETE FROM Clientes WHERE ClienteID = 3;Després de l'UPDATE
| ClienteID | Nombre | Ciudad |
|---|---|---|
| 1 | Ana López | Barcelona |
| 2 | Carlos Pérez | Sevilla |
| 3 | Marta Ruiz | Valencia |
Després del DELETE
| ClienteID | Nombre | Ciudad |
|---|---|---|
| 1 | Ana López | Barcelona |
| 2 | Carlos Pérez | Sevilla |
Combinar taules: JOIN
INNER JOIN … ON uneix dues taules: la FK d'una amb la PK de l'altra. Només surten les files que coincideixen.
SELECT c.Nombre, p.Importe
FROM Clientes c
INNER JOIN Pedidos p ON c.ClienteID = p.ClienteID;Un client sense comandes no surt. Un client amb dues comandes surt dues vegades.
c i p són àlies: noms curts per a cada taula.
Comptar bé després d'un JOIN
Després d'un JOIN, cada fila del resultat pot ser una línia, no una comanda. Pensa què representa cada fila.
| Funció | Què compta |
|---|---|
| COUNT amb asterisc | Files del resultat |
COUNT(columna) | Valors que no són NULL |
COUNT(DISTINCT columna) | Valors diferents |
DISTINCT | Treu files repetides del resultat |
NULL vol dir «no hi ha valor». No és un zero ni un text buit. Es comprova amb IS NULL.
La comanda 1001 té dos productes. La 1002 en té un. Uneixes PEDIDOS amb DETALLE_PEDIDO. Quantes files hi ha? Quantes comandes?
Solució
3 files (una per línia de comanda) però 2 comandes.
SELECT COUNT(*) AS Lineas, -- 3
COUNT(DISTINCT p.PedidoID) AS Pedidos -- 2
FROM PEDIDOS AS p
INNER JOIN DETALLE_PEDIDO AS d ON d.PedidoID = p.PedidoID;Pregunta. Escriu una consulta que mostri el nom de cada client i l'import de les seves comandes. Què passa amb un client sense comandes?
Resposta model. SELECT c.Nombre, p.Importe FROM Clientes c INNER JOIN Pedidos p ON c.ClienteID = p.ClienteID; El JOIN uneix la clau forana de Pedidos amb la clau primària de Clientes. Un client sense comandes no surt, perquè INNER JOIN només mostra les files que coincideixen. Un client amb dues comandes surt dues vegades.
Laboratori SQL
Practica les ordres en cadena: crear, inserir, consultar, canviar i esborrar. Mira com canvia la base de dades a cada pas.
Executa cada ordre i mira com canvia la base de dades. Les ordres s'apliquen una darrere l'altra, com en una base de dades real.
Cas complet
CREATE TABLE Clientes (
ClienteID INT PRIMARY KEY,
Nombre VARCHAR(100),
Ciudad VARCHAR(50)
);
CREATE TABLE Pedidos (
PedidoID INT PRIMARY KEY,
Fecha DATE,
Importe DECIMAL(10,2),
ClienteID INT,
FOREIGN KEY (ClienteID) REFERENCES Clientes(ClienteID)
);Primer Clientes: Pedidos hi fa referència.
INSERT INTO Clientes VALUES (1, 'Ana López', 'Barcelona');
INSERT INTO Pedidos VALUES (1001, '2026-09-15', 250.00, 1);La comanda 1001 es pot inserir perquè el client 1 ja existeix.
SELECT c.Nombre, p.Importe
FROM Clientes c
INNER JOIN Pedidos p ON c.ClienteID = p.ClienteID;Resultat: una fila, Ana López · 250.00.
UPDATE Clientes SET Ciudad = 'Girona' WHERE ClienteID = 1;
DELETE FROM Pedidos WHERE PedidoID = 1001;L'Ana passa a viure a Girona i la comanda 1001 desapareix. Si repeteixes el JOIN, no torna cap fila.
Taules: Clientes (ClienteID, Nombre, Ciudad) i Pedidos (PedidoID, Fecha, Importe, ClienteID).
- Noms dels clients de Madrid, en ordre alfabètic.
- Comandes de més de 100 €.
- Canvia la ciutat del client 3 a Lleida.
- Esborra la comanda 1005.
- Nom de cada client amb l'import de les seves comandes.
- Clients amb un nom que comença per «C».
Solució
-- 1
SELECT Nombre FROM Clientes WHERE Ciudad = 'Madrid' ORDER BY Nombre;
-- 2
SELECT * FROM Pedidos WHERE Importe > 100;
-- 3
UPDATE Clientes SET Ciudad = 'Lleida' WHERE ClienteID = 3;
-- 4
DELETE FROM Pedidos WHERE PedidoID = 1005;
-- 5
SELECT c.Nombre, p.Importe
FROM Clientes c
INNER JOIN Pedidos p ON c.ClienteID = p.ClienteID;
-- 6
SELECT * FROM Clientes WHERE Nombre LIKE 'C%';Pràctica 1 resolta
Part 1: una clínica dental. Necessita pacients, cites, tractaments i professionals. Un pacient té moltes cites → 1:N → la FK PacienteID va a Citas.
Part 2: Estudiantes i Matriculas. Un estudiant té moltes matrícules → 1:N. Cal crear les taules, inserir dades, consultar amb WHERE i ORDER BY, modificar i fer un INNER JOIN.
La primera part és oberta. Aquí tens un exemple complet amb la clínica dental de l'enunciat. La segona part té una sola solució.
Part 1 · Una clínica dental
- Pacients: nom, DNI, telèfon, correu, data de naixement, historial clínic.
- Cites: data, hora, motiu, dentista, estat (programada, feta, anul·lada).
- Tractaments i factures: tractament fet, preu, pagaments.
- Professionals: dentistes i horaris.
Amb fitxers separats, el telèfon d'un pacient es repeteix a cada cita: redundància. Si canvia, cal corregir-lo a tot arreu i apareixen inconsistències. Una base de dades guarda cada dada un sol cop, controla la integritat (no hi pot haver una cita d'un pacient que no existeix), deixa treballar diverses persones alhora i protegeix les dades de salut amb permisos.
- Es generen: quan el pacient demana cita o fa un tractament.
- S'emmagatzemen: a les taules Pacientes i Citas.
- S'utilitzen: per a l'agenda, els recordatoris i la facturació.
- S'arxiven: les cites antigues i l'historial, que s'han de conservar per llei.
- S'eliminen: les dades que ja no cal guardar, d'acord amb el RGPD.
3 · Dues entitats relacionades. Un pacient pot tenir moltes cites. Cada cita és d'un sol pacient.
La clau forana PacienteID va a la taula del costat N (Citas).
Part 2 · SQL amb Estudiantes i Matriculas
CREATE TABLE Estudiantes (
EstudianteID INT PRIMARY KEY,
Nombre VARCHAR(100),
Ciudad VARCHAR(50)
);
CREATE TABLE Matriculas (
MatriculaID INT PRIMARY KEY,
Fecha DATE,
Importe DECIMAL(10,2),
EstudianteID INT,
FOREIGN KEY (EstudianteID) REFERENCES Estudiantes(EstudianteID)
);
INSERT INTO Estudiantes VALUES
(1, 'Lucía Martín', 'Barcelona'),
(2, 'Daniel Ruiz', 'Terrassa'),
(3, 'Paula Gómez', 'Sabadell');
INSERT INTO Matriculas VALUES
(2001, '2026-09-10', 450.00, 1),
(2002, '2026-09-12', 300.00, 2),
(2003, '2026-09-15', 525.00, 1);-- 1. Tots els estudiants
SELECT * FROM Estudiantes;
-- 2. Nom i ciutat
SELECT Nombre, Ciudad FROM Estudiantes;
-- 3. Estudiants de Barcelona → Lucía Martín
SELECT * FROM Estudiantes WHERE Ciudad = 'Barcelona';
-- 4. Matrícules de més de 400 € → 2001 i 2003
SELECT * FROM Matriculas WHERE Importe > 400;
-- 5. Ordenar per nom
SELECT * FROM Estudiantes ORDER BY Nombre ASC;
SELECT * FROM Estudiantes ORDER BY Nombre DESC;-- 6. Inserir un estudiant nou
INSERT INTO Estudiantes VALUES (4, 'Marc Puig', 'Girona');
-- 7. Canviar-li la ciutat
UPDATE Estudiantes SET Ciudad = 'Manresa' WHERE EstudianteID = 4;
-- 8. Eliminar-lo
DELETE FROM Estudiantes WHERE EstudianteID = 4;Sense WHERE, l'UPDATE i el DELETE afectarien totes les files.
9. PK d'Estudiantes: EstudianteID. PK de Matriculas: MatriculaID. FK: Matriculas.EstudianteID. Relació 1:N: un estudiant pot tenir moltes matrícules i cada matrícula és d'un estudiant.
-- 10. Nom, matrícula i import
SELECT e.Nombre, m.MatriculaID, m.Importe
FROM Estudiantes e
INNER JOIN Matriculas m ON e.EstudianteID = m.EstudianteID;| Nombre | MatriculaID | Importe |
|---|---|---|
| Lucía Martín | 2001 | 450.00 |
| Daniel Ruiz | 2002 | 300.00 |
| Lucía Martín | 2003 | 525.00 |
La Paula no surt: no té cap matrícula. L'INNER JOIN només mostra les files que coincideixen.
La base de dades tienda de classe
El fitxer tienda.sql té quatre taules. detalle_pedido és una taula pont entre comandes i productes (N:M).
- Clients de Barcelona.
- Comandes de més de 150 €, de la més cara a la més barata.
- Comandes del client 1 (Arnau).
- Quin producte hi ha a cada comanda.
Solució
-- 1 → Ciro i Hector
SELECT Nombre, Apellidos FROM Clientes WHERE Ciudad = 'Barcelona';
-- 2 → 1003, 1004, 1005
SELECT PedidoID, Importe FROM pedidos WHERE Importe > 150 ORDER BY Importe DESC;
-- 3 → 1001, 1002 i 1003
SELECT c.Nombre, p.PedidoID, p.Importe
FROM Clientes c
INNER JOIN pedidos p ON c.ClienteID = p.ClienteID
WHERE c.ClienteID = 1;
-- 4 → 1001 Ordenador, 1002 Teclado, 1003 Mobil
SELECT p.PedidoID, pr.nombre_producto
FROM pedidos p
INNER JOIN detalle_pedido d ON p.PedidoID = d.pedidoId
INNER JOIN Productos pr ON d.productoID = pr.productoID;La consulta 4 necessita dos JOIN: de la comanda a la taula pont i de la taula pont al producte. Les comandes 1004 i 1005 no surten perquè no tenen cap línia a detalle_pedido.
Connexions amb els altres temes
| Tema | Connexió |
|---|---|
| T1 | SQL és el llenguatge del SGBD relacional que vas veure a l'arquitectura. |
| T3 | Les regles 1:N i N:M són les mateixes que fas servir per transformar un diagrama ER en taules. |
| T4 | Les claus i les dependències decideixen si una taula està ben normalitzada. |
Errors típics d'examen
DELETE = DROP
DELETE esborra files. DROP esborra la taula.
La FK no es pot repetir
Sí que es pot: un client, moltes comandes. La PK no es repeteix.
La PK pot ser nul·la
Mai. Per a una altra columna sense repetits, UNIQUE.
FK al costat 1
En una 1:N, la FK va al costat N.
N:M amb una columna
Necessita una taula intermèdia amb dues FK.
= en lloc de LIKE
Amb = el % no és comodí. I el comodí és %, no *.
UPDATE o DELETE sense WHERE
Afecten totes les files.
INNER JOIN mostra tothom
Només mostra les files que coincideixen.
Xuleta
| Et demanen… | Fes servir… |
|---|---|
| Taula / fila / columna | Relació / tupla o registre / atribut |
| Identificar cada fila | PRIMARY KEY |
| Relacionar dues taules | FOREIGN KEY … REFERENCES |
| Relació 1:N | FK al costat N |
| Relació N:M | Taula intermèdia amb dues FK |
| Que el correu no es repeteixi | UNIQUE |
| Limitar valors (edat 0–120) | CHECK (Edad BETWEEN 0 AND 120) |
| Crear, canviar o eliminar taules | DDL: CREATE, ALTER, DROP |
| Consultar, afegir, canviar o esborrar files | DML: SELECT, INSERT, UPDATE, DELETE |
| Ordre de les clàusules | SELECT → FROM → WHERE → ORDER BY |
| Diferent | <> |
| Text que comença per M | LIKE 'M%' |
| Exactament un caràcter | _ |
| Ordenar de la Z a l'A | ORDER BY … DESC |
| Combinar clients i comandes | INNER JOIN … ON |
| Imports amb cèntims | DECIMAL(10,2) |
02. Test
13 fàcils, 13 mitjanes i 14 difícils. L'ordre canvia cada vegada.
03. Targetes
Toca la targeta per girar-la i marca si te la saps. El progrés queda desat.