Emmagatzematge Dades · Tema 2

Bases de dades relacionals

Model relacional, claus primàries i foranes, relacions i SQL bàsic

33 min8 min 18 seccions 40 preguntes 23 targetes
4 fonts originals
T2.pdfpractica1_AMD_presencial22.pdftienda.sqlLIKE_busquedas_de_texto.pdf

01. Resum

18 seccions · 33 min8 min
Només l'essencial: sense explicacions llargues, exemples ni exercicis.Amb explicacions, exemples i exercicis resolts.

Comença per aquí

Si només recordes cinc coses d'aquest tema:

  1. Model relacional (Codd, 1970): les dades es guarden en taules. SQL és declaratiu: dius què vols, no com trobar-ho.
  2. 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.
  3. 1:N → la FK va al costat N. N:M → taula intermèdia amb dues FK.
  4. DDL canvia l'estructura (CREATE, ALTER, DROP). DML treballa amb les dades (SELECT, INSERT, UPDATE, DELETE).
  5. Ordre fix: SELECT → FROM → WHERE → ORDER BY. Un UPDATE o DELETE sense WHERE afecta 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. 1. El modelQui el va inventar i per què.
  2. 2. Les taulesFiles, columnes, dominis i propietats.
  3. 3. Les clausPrimàries, foranes i tipus de relació.
  4. 4. Les restriccionsEntitat, referencial, domini i UNIQUE.
  5. 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

  1. Abans dels 70Models jeràrquics o en xarxa. Per accedir a les dades calia conèixer com estaven guardades físicament.
  2. 1970Edgar F. Codd, investigador d'IBM, publica A Relational Model of Data for Large Shared Data Banks.
  3. La ideaGuardar les dades en relacions (taules) basades en la teoria de conjunts i l'àlgebra relacional.
  4. 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:

TermeTambé es diuExemple
TaulaRelacióClientes
FilaTupla, registreEl client 1, Ana López
ColumnaAtributCiudad
DominiValors permesosEdat 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).

TermeTambéQuè és
TaulaRelacióConjunt de files del mateix tipus
FilaTupla, registreUn element concret: el client 1, Ana López
ColumnaAtributUna 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
Cinc propietats d'una taula relacional

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.

Compta i anomena

La taula Productos (ProductoID, Nombre, Precio, CategoriaID) té 40 productes.

  1. Quantes files i columnes té?
  2. Com es diuen les files i les columnes en el model relacional?
  3. Quin domini té Precio?
Solució
  1. 40 files i 4 columnes.
  2. Files = tuples o registres. Columnes = atributs.
  3. Nombres decimals iguals o més grans que 0. Per exemple DECIMAL(10,2) amb Precio >= 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 · PKNombreCiudad
1Ana LópezBarcelona
2Carlos PérezMadrid
3Marta RuizValencia

Pedidos

PedidoID · PKClienteID · FKFecha
1001115/09/2026
1002216/09/2026
1003118/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 · FKProductoID · FK
10011 (Ordinador)
10012 (Teclat)
10022 (Teclat)
10023 (Mòbil)
Pregunta d'examen · Claus i relacions

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è miraError que evita
D'entitatLa PKDues comandes amb el mateix PedidoID
ReferencialLa FKUna comanda del client 999, que no existeix
De dominiEl valorUna edat de 150 anys
UNIQUERepetits en una columnaDos 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
Quina restricció es viola?
  1. Inserir un client amb ClienteID = 2 quan ja n'hi ha un.
  2. Inserir una comanda del client 57, que no existeix.
  3. Inserir un client sense ClienteID.
  4. Guardar una edat de −3.
  5. Esborrar l'Ana quan encara té comandes.
Solució
  1. Entitat: PK repetida.
  2. Referencial: la FK apunta a una PK que no existeix.
  3. Entitat: PK nul·la.
  4. Domini: valor fora del permès.
  5. Referencial: les seves comandes quedarien orfes.
Pregunta d'examen · Restriccions

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:

  1. Entitats: els substantius importants. Cada un serà una taula.
  2. Atributs: què cal saber de cada entitat.
  3. Claus primàries: un identificador per taula.
  4. 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.

Com es fa
  1. 1. EntitatsBusca els substantius importants: alumnes i cursos.
  2. 2. AtributsAlumne: nom i correu. Curs: nom i hores.
  3. 3. Claus primàriesAlumneID i CursID.
  4. 4. RelacionsUn alumne fa molts cursos i un curs té molts alumnes: N:M. Cal una taula intermèdia Matricules amb dues FK.
Resultat
ALUMNESAlumneIDPKNomEmail
MATRICULESAlumneIDPK, FK→ ALUMNESCursIDPK, FK→ CURSOSData
CURSOSCursIDPKNomHores

La data va a Matricules: depèn de l'alumne i del curs alhora.

Dissenya-ho: una biblioteca

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ó
SOCISSociIDPKNomEmail
PRESTECSPrestecIDPKSociIDFK→ SOCISLlibreIDFK→ LLIBRESDataSortidaDataRetorn
LLIBRESLlibreIDPKTitolAutor

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 d'examen · DDL i DML

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

TipusPer aExemple
INTEnters1, 225
DECIMAL(10,2)Imports amb cèntims25.50
VARCHAR(100)Text variableAna López
CHAR(2)Text fixES
DATEDates2026-09-15
BOOLEANCert o falsTRUE
CREATE TABLE Clientes (
  ClienteID INT PRIMARY KEY,
  Nombre    VARCHAR(100),
  Ciudad    VARCHAR(50)
);
TipusPer aExemple
INTEnters1, 225, 1000
DECIMAL(10,2)Nombres amb decimals: 10 xifres, 2 decimals25.50, 199.99
VARCHAR(100)Text de longitud variable, fins a 100 caràctersAna López
CHAR(2)Text de longitud fixaES, FR, IT
DATEDates (any-mes-dia)2026-09-15
BOOLEANLògicTRUE, 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
OperadorSignifica
=Igual
<>Diferent
> · <Més gran · més petit
>= · <=Més gran o igual · més petit o igual
AND · ORLes 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 dirTroba (Nombre)No troba
'M%'Comença per MMarta Ruiz, Marc SerraAna López
'%ez'Acaba en «ez»Ana López, Carlos Pérez, Laura Gómez, Sara MartínezMarta Ruiz
'%art%'Conté «art»Marta Ruiz, Pablo Martín, Sara MartínezMarc Serra
'_a%'Segona lletra «a»Carlos, Laura, Marta, Pablo, Sara, MarcAna, 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 classeWHEREResultat
Nom que comença per «L»Nombre LIKE 'L%'Laura Gómez
Correu d'empresa.esEmail 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.

Per pensar: el nom de pila acaba en «a»

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 d'examen · SELECT i LIKE

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

ClienteIDNombreCiudad
1Ana LópezBarcelona
2Carlos PérezSevilla
3Marta RuizValencia

Després del DELETE

ClienteIDNombreCiudad
1Ana LópezBarcelona
2Carlos PérezSevilla

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 asteriscFiles del resultat
COUNT(columna)Valors que no són NULL
COUNT(DISTINCT columna)Valors diferents
DISTINCTTreu files repetides del resultat

NULL vol dir «no hi ha valor». No és un zero ni un text buit. Es comprova amb IS NULL.

Files o comandes?

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 d'examen · INNER JOIN

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

1 · Crear les taules
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.

2 · Inserir dades
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.

3 · Consultar
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.

4 · Actualitzar i eliminar
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.

Escriu l'SQL

Taules: Clientes (ClienteID, Nombre, Ciudad) i Pedidos (PedidoID, Fecha, Importe, ClienteID).

  1. Noms dels clients de Madrid, en ordre alfabètic.
  2. Comandes de més de 100 €.
  3. Canvia la ciutat del client 3 a Lleida.
  4. Esborra la comanda 1005.
  5. Nom de cada client amb l'import de les seves comandes.
  6. 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

1 · Quines dades necessita
  • 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.
2 · Per què una base de dades

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.

4 · Cicle de vida de les dades
  • 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.

EntitatRelacióAtributSubratllat = identificador
PACIENTESPacienteIDPKNombreTelefono
CITASCitaIDPKFechaMotivoPacienteIDFK→ PACIENTES

La clau forana PacienteID va a la taula del costat N (Citas).

Part 2 · SQL amb Estudiantes i Matriculas

ESTUDIANTESEstudianteIDPKNombreCiudad
MATRICULASMatriculaIDPKFechaImporteEstudianteIDFK→ ESTUDIANTES
Crear i omplir
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–5 · Consultar
-- 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–8 · Modificar
-- 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–10 · Claus i JOIN

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;
NombreMatriculaIDImporte
Lucía Martín2001450.00
Daniel Ruiz2002300.00
Lucía Martín2003525.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).

CLIENTESClienteIDPKNombreApellidosCiudad
PEDIDOSPedidoIDPKFechaImporteClienteIDFK→ CLIENTES
DETALLE_PEDIDOdetalleIdPKpedidoIdFK→ PEDIDOSproductoIDFK→ PRODUCTOS
PRODUCTOSproductoIDPKnombre_producto
Quatre consultes amb tienda
  1. Clients de Barcelona.
  2. Comandes de més de 150 €, de la més cara a la més barata.
  3. Comandes del client 1 (Arnau).
  4. 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

TemaConnexió
T1SQL és el llenguatge del SGBD relacional que vas veure a l'arquitectura.
T3Les regles 1:N i N:M són les mateixes que fas servir per transformar un diagrama ER en taules.
T4Les 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 / columnaRelació / tupla o registre / atribut
Identificar cada filaPRIMARY KEY
Relacionar dues taulesFOREIGN KEY … REFERENCES
Relació 1:NFK al costat N
Relació N:MTaula intermèdia amb dues FK
Que el correu no es repeteixiUNIQUE
Limitar valors (edat 0–120)CHECK (Edad BETWEEN 0 AND 120)
Crear, canviar o eliminar taulesDDL: CREATE, ALTER, DROP
Consultar, afegir, canviar o esborrar filesDML: SELECT, INSERT, UPDATE, DELETE
Ordre de les clàusulesSELECT → FROM → WHERE → ORDER BY
Diferent<>
Text que comença per MLIKE 'M%'
Exactament un caràcter_
Ordenar de la Z a l'AORDER BY … DESC
Combinar clients i comandesINNER JOIN … ON
Imports amb cèntimsDECIMAL(10,2)

02. Test

40 preguntes

13 fàcils, 13 mitjanes i 14 difícils. L'ordre canvia cada vegada.

03. Targetes

23 targetes

Toca la targeta per girar-la i marca si te la saps. El progrés queda desat.