# 4. PHP & databases
El treball de **PHP amb bases de dades (BBDD)** és un pilar fonamental en el desenvolupament web dinàmic. PHP va néixer estretament lligat a MySQL, però avui dia interactua de manera eficient amb pràcticament qualsevol sistema de gestió de bases de dades (DBMS), com PostgreSQL, SQLite, o SQL Server.
**Extensions i Connexió**
PHP proporciona diverses extensions per connectar-se a BDD, sent les més importants i utilitzades:
1. **MySQLi (MySQL Improved)**: Una extensió orientada a objectes i funcional que és l'evolució de l'antic driver MySQL.
2. **PDO (PHP Data Objects)**: Aquesta és l'opció més recomanada i versàtil. PDO no és un driver per a una base de dades específica, sinó una capa d'abstracció de dades que permet utilitzar el mateix codi per connectar-se a múltiples tipus de bases de dades.
**PHP** treballa amb bases de dades principalment mitjançant **PDO** (capa d'abstracció de dades) o **MySQLi**. La seguretat en la interacció amb la BDD es garanteix mitjançant l'ús de **sentències preparades** (Prepared Statements), que separen les dades de l'usuari de la lògica de la consulta SQL per prevenir atacs d'**injecció SQL**.
# Introducció
## Extensions i Connexió
PHP proporciona diverses extensions per connectar-se a BDD, sent les més importants i utilitzades:
1. **MySQLi (MySQL Improved):** Una extensió orientada a objectes i funcional que és l'evolució de l'antic *driver* MySQL. És la preferida per treballar amb MySQL/MariaDB per la seva velocitat i suport a característiques modernes.
2. **PDO (PHP Data Objects):** Aquesta és l'opció **més recomanada** i versàtil. PDO no és un *driver* per a una base de dades específica, sinó una **capa d'abstracció de dades** que permet utilitzar el mateix codi per connectar-se a múltiples tipus de bases de dades (MySQL, PostgreSQL, Oracle, etc.), simplement canviant la cadena de connexió.
## Seguretat: Prepared Statements
El xifratge de contrasenyes no serveix de res si la interacció amb la BBDD és insegura. L'aspecte més crític de la seguretat en BBDD és prevenir els atacs d'**injecció SQL**. Tant MySQLi com PDO permeten l'ús de **sentències preparades** (*Prepared Statements*). Aquest mètode garanteix que les dades de l'usuari (variables) s'enviïn al servidor de BDD separadament de la consulta SQL. El servidor de BDD mai interpreta les dades de l'usuari com a part de la lògica de la consulta, tractant-les exclusivament com a valors de camp.
PHP
```php
// Exemple de sentència preparada amb PDO
$stmt = $pdo->prepare("INSERT INTO usuaris (nom, email) VALUES (?, ?)");
$stmt->execute(['David', 'david@exemple.cat']);
// Les dades s'envien separadament de la consulta, evitant la injecció SQL.
```
## Flux de treball
El flux per interactuar amb una BBDD des de PHP és coherent:
1. **Connexió:** Establir una connexió al servidor de BBDD (passant el nom de l'usuari, la contrasenya, i la BBDD).
2. **Preparació:** Preparar la sentència SQL.
3. **Execució:** Executar la sentència, passant les dades (vinculades).
4. **Processament:** Processar el resultat (si és una consulta `SELECT`), generalment extreient les files en formats d'array o objectes.
5. **Tancament:** Tancar la connexió (encara que PHP sovint ho fa automàticament en finalitzar l'script).
PHP actua com un pont eficient i segur que transforma les peticions web en operacions de BBDD i retorna les dades per generar la pàgina web final.
# Connexió BBDD
# Connectar base de dades
La connexió a bases de dades MySQL a PHP s'estableix principalment mitjançant l'extensió **MySQLi** (MySQL Improved), que ofereix mètodes orientats a objectes i procedurals. **PDO** (PHP Data Objects) és l'altra alternativa crucial.
## Connexió a MySQL amb MySQLi
L'extensió **MySQLi** és la manera recomanada de treballar amb bases de dades MySQL a PHP, ja que és una versió millorada i més ràpida que l'antiga (i obsoleta) extensió `mysql`.
### 1. Orientat a Objectes (OO)
Aquest és l'estil més modern i preferit.
## Errors Més Comuns
Els errors en la connexió solen ser d'aquests tipus:
Error Comú
Causa
Solució Típica
**"Access denied for user..."**
Credencials incorrectes (usuari o contrasenya).
Verificar la configuració a l'allotjament o al servidor local.
**"Unknown database..."**
La base de dades especificada no existeix.
Assegurar-se que `$dbname` (si s'ha afegit al constructor) sigui correcte.
**"Connection refused"**
El servidor MySQL no s'està executant o el *firewall* el bloqueja.
Iniciar el servidor MySQL (p. ex., XAMPP/WAMP/MAMP) o comprovar ports.
**"Undefined property..."**
Si s'intenta accedir a l'objecte `$conn` després que hagi fallat.
La verificació de l'error hauria d'aturar l'script (`die()`).
## Paràmetres Essencials
Els paràmetres bàsics per a la connexió són:
- `$servername`: Normalment **`"localhost"`** per a entorns de desenvolupament o el nom de l'amfitrió del servidor de BBDD a l'allotjament.
- `$username`: El nom d'usuari de MySQL (p. ex., `"root"` en desenvolupament).
- `$password`: La contrasenya de l'usuari de MySQL.
- **Recomanat:** Afegir el nom de la base de dades (`$dbname`) com a quart paràmetre, que permet seleccionar la BBDD alhora de connectar.
## I com funciona amb PDO?
És una excel·lent pràctica! **PDO** (**P**HP **D**ata **O**bjects) és la manera més recomanada d'establir connexions a bases de dades amb PHP per la seva seguretat i versatilitat. A diferència de MySQLi, PDO és purament **Orientat a Objectes** i s'utilitza una capa d'abstracció (el DSN) per especificar el tipus de base de dades, fent-lo molt més flexible.
Amb PDO, la connexió s'estableix creant una nova instància de l'objecte `PDO`. El procés es realitza dins d'un bloc **`try...catch`** per gestionar els errors mitjançant **excepcions**, una pràctica de gestió d'errors superior a la funció `die()`.
### Codi Base (Orientat a Objectes)
PHP
```php
PDO::ERRMODE_EXCEPTION,
// Desactiva l'emulació de sentències preparades (més seguretat contra Injecció SQL)
PDO::ATTR_EMULATE_PREPARES => false,
// Mode per defecte de retorn de resultats (objectes)
PDO::ATTR_DEFAULT_FETCH_MODE => PDO::FETCH_ASSOC,
];
try {
// Crear la connexió
$pdo = new PDO($dsn, $username, $password, $opcions);
echo "Connected successfully (via PDO)";
// Aquí s'executarien les consultes utilitzant $pdo
} catch (PDOException $e) {
// Captura els errors de connexió
// Es mostra el missatge d'error i el codi (codi d'error més baix de la BDD).
die("Connection failed: " . $e->getMessage() . " (Code: " . $e->getCode() . ")");
}
// La connexió es tanca automàticament quan l'script finalitza o si es fa $pdo = null;
?>
```
## Components de PDO
Component/Funció
Paràmetres/Valor
Propòsit
**`$dsn` (Data Source Name)**
`"mysql:host=...;dbname=...;charset=..."`
**Defineix l'estructura** de la connexió (tipus de BDD, servidor, nom de la BDD i codificació). El `charset=utf8mb4` és crucial per al suport complet d'emojis.
**`new PDO(...)`**
`$dsn`, `$username`, `$password`, `$opcions`
Crea l'objecte de connexió i inicia l'intent de connexió.
**`try...catch`**
`PDOException $e`
Mecanisme de gestió d'errors estàndard i superior. Si la connexió falla, el `catch` intercepta l'error.
**`$e->getMessage()`**
(Mètode)
Obté el missatge d'error de la base de dades (p. ex., "Access denied").
**`PDO::ATTR_ERRMODE`**
`PDO::ERRMODE_EXCEPTION`
**Mecanisme Clau:** Força PDO a llançar objectes d'excepció en cas d'errors de SQL. Això és molt més net i segur que comprovar errors manuals.
**`PDO::ATTR_EMULATE_PREPARES`**
`false`
**Mecanisme Clau de Seguretat:** Desactiva l'emulació de sentències preparades de PHP i força el *driver* a enviar les sentències preparades de manera nativa al servidor de BDD, oferint la màxima protecció contra la **Injecció SQL**.
### Errors en PDO
1. **DSN Incorrecte:** Un error de sintaxi al `$dsn` (p. ex., oblidar el punt i coma o escriure malament `mysql:host`).
2. **Credencials:** Usuari/contrasenya incorrectes, com en MySQLi.
3. **Encoding:** No especificar `charset=utf8mb4` pot provocar problemes amb caràcters especials.
### Avantatges PDO
- **Seguretat Superior:** Fàcilment configurable per deshabilitar l'emulació de preparació i forçar les sentències preparades segures.
- **Uniformitat:** Utilitza el mateix codi per a qualsevol base de dades (MySQL, SQLite, etc.).
- **Gestió d'Errors Moderna:** Utilitza excepcions, que permeten al codi *continuar* o *gestionar* l'error de manera més elegant que amb un `die()`.
El format utilitzat en les cadenes de connexió **DSN** (**D**ata **S**ource **N**ame) serveix per proporcionar a l'extensió **PDO** de PHP tota la informació necessària per connectar-se a una base de dades (BDD) específica, independentment del seu tipus (MySQL, PostgreSQL, SQLite, etc.).
## Estructura del DSN
El format DSN és una cadena de text amb una sintaxi molt específica. La cadena es divideix en dues parts principals separades pel signe de dos punts (`:`):
### Driver (Tipus BBDD)
La primera part especifica el controlador de la base de dades que PDO ha d'utilitzar. Aquesta és la clau de la flexibilitat de PDO.
### Paràmetres específics
La segona part (després dels dos punts) conté els detalls de la connexió. Aquests paràmetres s'especifiquen com a parelles **`nom=valor`** separades per un punt i coma (`;`). Els paràmetres més comuns per a una connexió **MySQL** són:
- **`host`:** El nom o adreça IP del servidor de la BBDD (p. ex., `localhost`).
- **`dbname`:** El nom de la base de dades a la qual es vol connectar.
- **`charset`:** La codificació de caràcters a utilitzar (p. ex., `utf8mb4` per al suport complet d'emojis i caràcters especials).
### Exemple MySQL
La cadena DSN que has vist als exemples de PDO es construeix així:
PHP
```php
$servername = "localhost";
$dbname = "base_de_dades_prova";
$dsn = "mysql:host=$servername;dbname=$dbname;charset=utf8mb4";
// ^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^^^^^ ^^^^^^^^^^^^^
// Driver Host + Valor BDD + Valor Charset + Valor
```
Aquesta cadena `$dsn` és un dels tres paràmetres essencials que es passen al constructor de l'objecte PDO, juntament amb el nom d'usuari i la contrasenya:
PHP
```php
$pdo = new PDO($dsn, $username, $password);
```
# Tancar connexió BBDD
Tancar la connexió amb la base de dades és una bona pràctica per alliberar recursos al servidor, tot i que PHP la tanca automàticament quan l'script finalitza. Aquí teniu com es tanca explícitament la connexió amb els tres mecanismes principals: **MySQLi OO**, **MySQLi Procedural** i **PDO**.
## MySQLi Orientat a Objectes (OO)
En l'estil orientat a objectes, s'utilitza el mètode **`close()`** de l'objecte de connexió.
PHP
```php
close();
?>
```
## MySQLi Procedural (Funció)
En l'estil procedural, s'utilitza la funció **`mysqli_close()`**, passant l'enllaç de connexió com a paràmetre.
PHP
```php
```
## PDO (PHP Data Objects)
Amb PDO, no hi ha cap mètode de tancament explícit com `close()`. La connexió es tanca eliminant la referència a l'objecte de connexió, és a dir, posant la variable a **`null`**.
PHP
```php
```
# Seguretat
La seguretat en la interacció entre PHP i Bases de Dades (BDD) és crucial per protegir les aplicacions web de l'explotació de vulnerabilitats, sent l'atac més crític la Injecció SQL. La clau de la seguretat resideix en tractar sempre les dades d'entrada com a simples valors, mai com a codi executable.
1\. **Mecanisme Fonamental**: ***Sentències Preparades***
El pilar de la defensa són les Sentències Preparades (Prepared Statements). Aquest mètode, suportat per PDO (recomanat) i MySQLi, separa el codi SQL de les dades de l'usuari. De forma que si un atacant introdueix codi SQL (p. ex., 1 OR 1=1), el servidor de BBDD l'interpreta literalment com una cadena de text, no com una part de la consulta, neutralitzant l'atac.
**2. Capa d'Abstracció: PDO**
PDO (PHP Data Objects) és l'opció preferida perquè força l'ús de sentències preparades, ofereix una gestió d'errors més robusta mitjançant excepcions dins de blocs try...catch.
**3. Integritat i Control: Transaccions**
Per a operacions de múltiples passos (insercions/actualitzacions), l'ús de Transaccions (amb beginTransaction(), commit(), i rollBack()) garanteix l'integritat de dades. Si una de les consultes falla, cap no s'executa, evitant estats inconsistents a la BDD.
**4. Protecció de Credencials**
Finalment, la seguretat exigeix mai emmagatzemar credencials de BDD en repositoris públics (Git) i mantenir-les en fitxers de configuració fora de l'accés web (.env o similars). Així, la seguretat entre PHP i BDD es basa en una regla: mai concatenar dades d'usuari directament a la consulta SQL.
# SQL Injection
És important veure com un atac d'Injecció SQL pot ser més destructiu que només retornar dades. Aquí teniu un exemple que permetria a l'atacant executar una ordre per **eliminar una taula** (`DROP TABLE`).
## Atac drop table
En aquest cas, l'atacant utilitzarà el caràcter de **punt i coma (`;`)** per finalitzar la consulta original i encadenar una nova ordre SQL.
### PHP Vulnerable
El codi PHP, vulnerable a la concatenació:
PHP
```php
// Codi PHP VULNERABLE
$product_id = $_GET['id']; // Valor obtingut de ?id=...
// Consulta original:
$sql = "SELECT nom, preu, descripcio FROM productes WHERE id = " . $product_id;
// Execució de la consulta...
// $db->query($sql);
```
### Vector d'atac
L'atacant aprofita que el motor SQL interpreta el punt i coma com el final d'una instrucció i l'inici d'una nova.
Acció
URL Sol·licitada
Valor `$product_id`
**Atac**
`?id=3; DROP TABLE productes; --`
`3; DROP TABLE productes; --`
### La SQL resultant
Quan el codi PHP concatena la cadena d'atac, el servidor de bases de dades rep **dues** instruccions per executar:
Part de la Consulta
Explicació
**`SELECT nom, preu, descripcio FROM productes WHERE id = 3;`**
La primera consulta. El servidor l'executa i la processa (o la ignora, depenent de l'èxit o el context).
**`DROP TABLE productes;`**
**La segona consulta!** Aquesta ordre destrueix permanentment la taula de productes.
**`--`**
El doble guió (`--`) és un comentari a SQL. Aquest caràcter fa que el servidor ignori la resta de la consulta, incloent-hi qualsevol cometa o caràcter que PHP hagi afegit al final, assegurant que l'ordre `DROP TABLE` s'executi correctament.
### Conseqüències
El servidor de BDD executa la segona ordre encadenada (`DROP TABLE productes;`), resultant en la **pèrdua irrecuperable de totes les dades** contingudes a la taula de productes.
## Solució
Com sempre, l'única defensa eficaç contra aquests atacs és l'ús de **Sentències Preparades** (amb **PDO** o **MySQLi**). Les sentències preparades no permeten que el caràcter punt i coma actuï com a separador d'ordres ni que l'apòstrof actuï com a tancament de camp, ja que tracten tota la cadena d'atac com una única dada literal.
PHP
```php
// SQL SEGUR: L'ID es tracta com un valor, no com a codi SQL
$stmt = $pdo->prepare("SELECT nom, preu, descripcio FROM productes WHERE id = ?");
$stmt->execute(['3; DROP TABLE productes; --']);
// El servidor cerca literalment un producte amb aquest ID inexistent i no executa l'ordre DROP TABLE.
```
# Sentències preparades
Les **Sentències Preparades** (*Prepared Statements*) són un mecanisme de seguretat i eficiència en bases de dades que garanteix que les dades proporcionades per l'usuari es tractin exclusivament com a **valors de camp**, i mai com a part del **codi SQL**. Funcionen en dos passos principals:
### Pas 1. Preparació (Separació de codi i dades)
El codi SQL amb marcadors de posició (generalment **`?`** o `:nom`) s'envia al servidor de la base de dades **abans** de rebre cap dada de l'usuari.
SQL
```sql
SELECT nom, email FROM Usuaris WHERE id = ? -- El servidor 'prepara' aquesta estructura.
```
El servidor compila l'estructura de la consulta i sap exactament on esperar les dades.
### Pas 2. Execució (Vinculació segura)
Posteriorment, les variables que contenen les dades de l'usuari s'envien al servidor de manera **separada** (o "vinculada") per omplir els marcadors de posició. Si un usuari malintencionat envia una cadena amb codi SQL (p. ex., `3 OR 1=1`), el servidor de BBDD l'interpreta literalment com una cadena de text dins del camp (`'3 OR 1=1'`) i no com una instrucció SQL per executar.
#### Avantatges
- **Seguretat:** Prevenció total de l'**Injecció SQL**, ja que cap dada d'entrada es pot executar com a codi.
- **Eficiència:** Si una sentència s'executa diverses vegades (p. ex., dins d'un bucle o transacció), el servidor només l'ha de compilar una vegada, estalviant temps de processament.
- **Claredat:** Millora la llegibilitat del codi.
## I en PHP?
Aquesta seria la base teòrica de les Sentències Preparades, ara veurem com s'implementen amb exemples pràctics en els tres mètodes: **MySQLi Procedural**, **MySQLi OO**, i **PDO**. Utilitzarem una consulta simple de selecció amb una clàusula `WHERE`.
### MySQLi Procedural
Aquest mètode utilitza funcions que comencen amb `mysqli_` per gestionar l'enllaç de connexió i l'objecte de la sentència.
PHP
```php
```
### MySQLi Orientat a Objectes (OO)
Aquest mètode utilitza mètodes dels objectes `$conn` i `$stmt`. És més net que el procedural.
PHP
```php
prepare($sql);
// 2. Vincular el paràmetre: 'i' = integer
$stmt->bind_param("i", $id_a_cercar);
// 3. Executar la sentència
$stmt->execute();
// 4. Obtenir el resultat
$result = $stmt->get_result();
// 5. Processar les dades
if ($row = $result->fetch_assoc()) {
echo "OO: Trobada l'ID " . $id_a_cercar . " per a " . $row['nom'] . "\n";
} else {
echo "OO: No s'ha trobat cap usuari amb aquesta ID.\n";
}
// 6. Tancar
$stmt->close();
?>
```
### PDO (PHP Data Objects)
PDO és el mètode més recomanat per la seva simplicitat en la vinculació de paràmetres i gestió d'errors.
#### Mètode amb marcador de posició (`?`)
PHP
```php
prepare($sql);
// 2. Executar la sentència: Es passen les dades directament com un array.
$stmt->execute([$id_a_cercar]);
// 3. Obtenir el resultat (només la primera fila)
$row = $stmt->fetch(PDO::FETCH_ASSOC);
// 4. Processar les dades
if ($row) {
echo "PDO: Trobada l'ID " . $id_a_cercar . " per a " . $row['nom'] . "\n";
} else {
echo "PDO: No s'ha trobat cap usuari amb aquesta ID.\n";
}
} catch (PDOException $e) {
die("Error de PDO: " . $e->getMessage());
}
// $pdo = null;
?>
```
#### Mètode alternatiu amb marcador nominal (`:nom`)
PDO també permet utilitzar noms en lloc de signes d'interrogació, cosa que és útil quan hi ha molts paràmetres.
PHP
```php
// PDO amb marcador nominal
$id_a_cercar = 30;
$sql = "SELECT nom, email FROM Usuaris WHERE id = :id_usuari";
$stmt = $pdo->prepare($sql);
// Executar: Es passa un array associatiu amb el nom del marcador (sense els ':')
$stmt->execute(['id_usuari' => $id_a_cercar]);
// ... resta del processament ...
```
Com veieu, en tots els mètodes s'evita la concatenació (p. ex., `WHERE id = '{$id_a_cercar}'`) i s'utilitza la **funció de preparació**. Aquest petit canvi és la diferència entre un codi **vulnerable a la Injecció SQL** i un codi **segur** i professional. **PDO** simplifica notablement el procés en l'etapa d'execució, ja que no requereix la definició explícita dels tipus de dades (`'i'`, `'s'`, etc., com fa MySQLi). En lloc d'això, **PDO infereix el tipus de dada** (com *string* o *integer*) **directament de la variable de PHP** subministrada en l'array d'execució, o bé es pot definir explícitament (p. ex., `PDO::PARAM_INT`) per a una major precisió.
##### El mètode `bindValue()` (Alternativa)
Tot i que l'execució amb l'array associatiu (`$stmt->execute([...])`) és la forma més ràpida i recomanada amb PDO, també podeu vincular els marcadors nominals un per un amb el mètode `bindValue()`:
PHP
```php
// 2. Mètode bindValue() (més verbós, però útil si cal definir tipus específics)
$stmt->bindValue(':id_usuari', $id_a_cercar, PDO::PARAM_INT); //PDO::PARAM_STR per a tipus string
$stmt->execute();
// ... resta del processament ...
```
# Transaccions
Les **Transaccions** amb PDO permeten agrupar múltiples consultes SQL (insercions, actualitzacions, eliminacions) en una única unitat de treball. Això assegura l'**Atomicitat** de les dades: o bé **totes** les consultes dins la transacció s'executen amb èxit i s'apliquen permanentment a la base de dades, o bé **cap** no s'aplica, i es desfà qualsevol canvi fet (`rollback`). Això és fonamental per a l'**integritat de dades**.
## Mecanismes PDO
PDO utilitza tres mètodes essencials en el seu objecte de connexió (`$pdo`) per gestionar transaccions. Aquest procés només funciona amb taules que suporten transaccions, com **InnoDB** a MySQL.
**Mètode**
**Propòsit**
**Acció SQL Equivalent**
**`beginTransaction()`**
Inicia la transacció. Totes les consultes següents s'executen en memòria i no afecten la BDD fins a la confirmació.
`START TRANSACTION;`
**`commit()`**
Fa els canvis permanents a la base de dades. Només s'executa si totes les consultes anteriors han tingut èxit.
`COMMIT;`
**`rollBack()`**
Desfà tots els canvis fets des de l'inici de la transacció si es produeix un error.
`ROLLBACK;`
## Procediment habitual (Try...Catch)
El patró de disseny més segur i recomanat per a les transaccions amb PDO és utilitzar un bloc **`try...catch`** per gestionar automàticament qualsevol error.
### Exemple: Transferència bancària
En una transferència, s'han de fer dues operacions (`UPDATE`): restar d'un compte i sumar a l'altre. Si la resta falla, la suma no s'ha de fer.
PHP
```php
beginTransaction();
// --- CONSULTA 1: Restar de l'origen ---
$sql1 = "UPDATE Comptes SET saldo = saldo - ? WHERE id = ?";
$stmt1 = $pdo->prepare($sql1);
$stmt1->execute([$quantitat, $compte_origen]);
// NOTA: Es podria afegir una comprovació (p. ex., si saldo < quantitat)
// if ($stmt1->rowCount() == 0) { throw new Exception("Compte origen no trobat."); }
// --- CONSULTA 2: Sumar al destí ---
$sql2 = "UPDATE Comptes SET saldo = saldo + ? WHERE id = ?";
$stmt2 = $pdo->prepare($sql2);
$stmt2->execute([$quantitat, $compte_desti]);
// 2. CONFIRMAR: Si tot ha anat bé, es fa permanent
$pdo->commit();
echo "Transferència completada amb èxit. Els canvis són permanents.";
} catch (PDOException $e) {
// 3. DESFER: Si hi ha un error SQL, desfem tots els canvis
if ($pdo->inTransaction()) {
$pdo->rollBack();
}
echo "ERROR: La transferència ha fallat. Canvis desfets. Detalls: " . $e->getMessage();
} catch (Exception $e) {
// Captura d'errors lògics (p. ex., la nostra excepció de saldo)
if ($pdo->inTransaction()) {
$pdo->rollBack();
}
echo "ERROR LÒGIC: " . $e->getMessage();
}
$pdo = null;
?>
```
## Avantatges
- **Integritat:** Garanteix que la base de dades es mantingui en un estat consistent. Sense transaccions, si la primera consulta té èxit i la segona falla (per un problema de connexió, per exemple), el compte d'origen perdria diners sense que el compte de destí els rebés.
- **Eficiència:** L'execució de múltiples consultes en una transacció sol ser **més ràpida** que l'execució individual, ja que el servidor de BDD optimitza les escriptures.
- **Aïllament:** Mentre es realitza una transacció, la resta d'usuaris no veuran els canvis parcials (escriptures), garantint l'aïllament del procés.
# Escapar caràcters maliciosos
Escapar caràcters maliciosos és una part essencial de la seguretat web, ja que neutralitza les dades d'entrada per assegurar-se que només es tractin com a text, i no com a codi executable. Aquesta protecció s'ha d'aplicar en dos contextos principals: **SQL** (per prevenir la Injecció SQL) i **HTML** (per prevenir l'Scripting entre Llocs o XSS).
## Escapar caràcters per a SQL (BBDD)
La funció d'escapament s'utilitza per afegir una barra invertida (`\`) davant de caràcters especials de SQL que podrien ser interpretats com a codi, com les cometes simples (`'`), les dobles cometes (`"`), i la barra invertida mateixa (`\`).
### Mètode antic i desaconsellat
Les funcions **`mysqli::real_escape_string()`** (OO) o **`mysqli_real_escape_string()`** (Procedural) són eines vàlides, però el seu ús directament a les consultes concatenades és **perillós** i **obsolet** com a mètode de seguretat primari.
**Estil**
**Funció**
**Ús**
**OO**
`$conn->real_escape_string($string)`
Escapa la cadena.
**Procedural**
`mysqli_real_escape_string($conn, $string)`
Escapa la cadena.
**Per què és obsolet?** Encara que aquesta funció escapa les dades, depèn que el desenvolupador utilitzi **sempre** la funció correctament en **totes** les consultes. Un oblit provoca una vulnerabilitat.
### Mètode recomanat: Sentències preparades
La manera correcta d'assegurar la integritat de SQL és utilitzar **Sentències Preparades (Prepared Statements)** amb **PDO** o **MySQLi**. Aquest mètode:
1. **Separa el Codi de les Dades:** El motor SQL rep la consulta i les dades per separat.
2. **L'escapament es Fa Automàticament:** El *driver* de la base de dades (i no el PHP) s'encarrega d'escapar o gestionar internament les dades de manera segura abans d'executar-les, eliminant la necessitat de cridar manualment `real_escape_string()`.
Si utilitzeu sentències preparades, **no necessiteu** cridar `real_escape_string()`.
## Escapar caràcters HTML (Output)
La funció **`htmlspecialchars()`** s'utilitza quan es mostra una dada d'usuari (que s'ha obtingut de la base de dades) a la pàgina HTML. Això és vital per prevenir atacs de **Scripting entre Llocs (XSS)**.
**ATENCIÓ!** Convertir caràcters que tenen un significat especial en HTML (com `<` i `>`) en les seves entitats HTML (`<` i `>`).
### Funció
**Funció**
**Propòsit**
**`htmlspecialchars($string)`**
Converteix caràcters especials en entitats HTML, neutralitzant el codi incrustat.
### Exemple
Si un atacant introdueix el nom `NomUsuari `, la funció ho converteix:
PHP
```php
$dada_bruta = "NomUsuari ";
// 1. Aplicar htmlspecialchars
$dada_neta = htmlspecialchars($dada_bruta, ENT_QUOTES, 'UTF-8');
// 2. El resultat és segur per a ser mostrat en HTML
echo $dada_neta;
// Sortida: NomUsuari <script>alert('XSS!')</script>
```
#### Paràmetres
1. **`$flags` (`ENT_QUOTES`):** Aquest és el paràmetre més important. Indica a PHP que també ha d'escapar les cometes simples (`'`) i les dobles cometes (`"`) com a entitats.
- **Sense `ENT_QUOTES`:** Un atacant podria tancar un atribut HTML (p. ex., ``) amb cometes, fent fallar la protecció.
- **Amb `ENT_QUOTES`:** Tanca aquesta vulnerabilitat.
2. **`$encoding` (`'UTF-8'`):** Defineix la codificació de caràcters, assegurant el tractament correcte de tots els símbols internacionals.
## Resum
**Context**
**Risc**
**Mètode Recomanat**
**Dades a SQL**
Injecció SQL
**Sentències Preparades (PDO/MySQLi).** Oblida't de `real_escape_string()`.
**Dades a HTML**
XSS (Cross-Site Scripting)
**`htmlspecialchars($dada, ENT_QUOTES, 'UTF-8')`** just abans de mostrar-la.
# Crear una BBDD i una taula
Utilitzant els tres mètodes —**MySQLi Orientat a Objectes (OO)**, **MySQLi Procedural**, i **PDO**—, el procés de creació d'una base de dades (BBDD) i una taula a dins segueix el mateix patró: primer s'estableix la connexió al servidor MySQL (sense especificar la BBDD), es crea la BBDD amb `CREATE DATABASE`, i finalment s'estableix una nova connexió o es selecciona la BBDD per crear la taula amb `CREATE TABLE`.
## MySQLi Procedural
Aquest mètode utilitza funcions amb el prefix `mysqli_`.
### Pas 1: Creació de la Base de Dades
Primer, connectem al servidor sense seleccionar cap BDD, i després utilitzem `mysqli_query()` per crear-la.
PHP
```php
```
### Pas 2: Creació de la Taula
Obrim una nova connexió, seleccionant directament la BBDD que acabem de crear, i llavors creem la taula.
PHP
```php
```
## MySQLi Orientat a Objectes (OO)
Aquest mètode utilitza l'objecte `$conn` i el mètode **`query()`**.
### Pas 1: Creació de la Base de Dades
PHP
```php
connect_error) {
die("Connexió fallida: " . $conn->connect_error);
}
// 2. Creació de la Base de Dades
$sql_db = "CREATE DATABASE IF NOT EXISTS $dbname";
if ($conn->query($sql_db) === TRUE) {
echo "BDD '$dbname' creada amb èxit.\n";
} else {
echo "Error creant BDD: " . $conn->error . "\n";
}
$conn->close();
?>
```
### Pas 2: Creació de la Taula
Obrim una nova connexió, especificant la BBDD al constructor.
PHP
```php
connect_error) {
die("Connexió fallida: " . $conn->connect_error);
}
// Creació de la Taula
$sql_table = "CREATE TABLE IF NOT EXISTS Usuaris (
id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(30) NOT NULL,
email VARCHAR(50),
data_registre TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
)";
if ($conn->query($sql_table) === TRUE) {
echo "Taula 'Usuaris' creada amb èxit (OO).\n";
} else {
echo "Error creant taula: " . $conn->error . "\n";
}
$conn->close();
?>
```
## PDO (PHP Data Objects)
PDO utilitza el mètode **`exec()`** per executar consultes SQL que no retornen un conjunt de resultats (com `CREATE` o `DROP`).
### Pas 1: Creació de la Base de Dades
Connectem al servidor amb un **DSN** (Data Source Name) sense la clau `dbname`.
PHP
```php
setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
// Creació de la Base de Dades
$sql_db = "CREATE DATABASE IF NOT EXISTS $dbname";
$pdo->exec($sql_db);
echo "BDD '$dbname' creada amb èxit.\n";
// Tancar la connexió
$pdo = null;
} catch (PDOException $e) {
die("Connexió fallida o error de BDD: " . $e->getMessage());
}
?>
```
### Pas 2: Creació de la Taula
Obrim una nova connexió al servidor, ara sí, especificant la BBDD.
PHP
```php
setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
// Creació de la Taula
$sql_table = "CREATE TABLE IF NOT EXISTS Usuaris (
id INT(6) UNSIGNED AUTO_INCREMENT PRIMARY KEY,
nom VARCHAR(30) NOT NULL,
email VARCHAR(50),
data_registre TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
)";
$pdo->exec($sql_table);
echo "Taula 'Usuaris' creada amb èxit (PDO).\n";
// Tancar la connexió
$pdo = null;
} catch (PDOException $e) {
die("Connexió fallida o error de BDD: " . $e->getMessage());
}
?>
```
# Manipulació dades
# Select data
La realització de consultes **`SELECT`** segures amb **clàusules `WHERE`** i la implementació de **paginació** són operacions fonamentals. Utilitzarem la tècnica de **Sentències preparades** per a la clàusula `WHERE` per garantir la seguretat contra la injecció SQL, i les clàusules **`LIMIT`** i **`OFFSET`** per a la paginació.
## MySQLi Procedural
Aquest mètode utilitza funcions prefixades amb `mysqli_` i punts d'interrogació (`?`) com a marcadors de posició.
### Consulta, filtre (`WHERE`) i paginació
## PDO (PHP Data Objects)
PDO és la forma més simple i segura per als selects, especialment en la vinculació de paràmetres.
### Consulta, filtre (`WHERE`) i paginació
PHP
```php
prepare($sql);
// 2. Vincular i executar (la manera més neta)
// IMPORTANT: PDO NO necessita definir els tipus (s, i, d), però sí que s'han de passar al mateix ordre.
// L'offset i el limit han de ser int, per la qual cosa cal assegurar-se que $offset i $limit són numèrics.
$stmt->execute([$filtre_nom, $limit, $offset]);
// 3. Obtenir totes les dades com un array associatiu
$resultats = $stmt->fetchAll(PDO::FETCH_ASSOC);
// 4. Processar i mostrar les dades
if (count($resultats) > 0) {
echo "
### Paginació
La **paginació** es realitza a nivell de SQL mitjançant les clàusules **`LIMIT`** i **`OFFSET`**:
- **`LIMIT N`**: Indica el nombre màxim de files que es volen retornar (els elements per pàgina).
- **`OFFSET M`**: Indica el nombre de files que s'han de saltar des del principi del conjunt de resultats.
La fórmula per calcular l'offset sempre és:
[](https://siensis.com/books/uploads/images/gallery/2025-10/N4FrLzFsrbXlRC3m-image.png)
# Paginació
La **paginació** és un mecanisme essencial en el desenvolupament web i de bases de dades per dividir grans conjunts de dades en pàgines més petites i manejables. Això millora dràsticament el rendiment i l'experiència de l'usuari. El mètode de paginació més comú, es coneix com a **paginació basada en desplaçament (Offset)**. Funciona utilitzant les clàusules **`LIMIT`** i **`OFFSET`** de SQL per dir al motor de la base de dades que retorni només un subconjunt de les dades.
El procés es divideix en tres parts:
1. **Càlcul de Paràmetres (PHP/Servidor):** El servidor (PHP) determina quina pàgina s'està sol·licitant i quants registres s'han de saltar (`OFFSET`).
2. **Consulta SQL:** El servidor envia la consulta amb els valors `LIMIT` i `OFFSET` inserits de manera segura.
3. **Presentació:** La base de dades retorna només les dades sol·licitades, que es mostren a l'usuari, juntament amb els enllaços de "Pàgina Anterior" i "Pàgina Següent".
### Fórmules
Assumim que `$elements_per_pagina` és el valor de `LIMIT` i `$pagina_actual` és el número de pàgina (començant per 1):
**Paràmetre**
**Propòsit**
**Fórmula de Càlcul**
**`LIMIT`**
Nombre màxim de registres a retornar (mida de la pàgina).
`$elements_per_pagina`
**`OFFSET`**
Nombre de registres a saltar des del principi.
`($pagina_actual - 1) * $elements_per_pagina`
### Exemple SQL
Per obtenir la **tercera pàgina** amb **15 registres** per pàgina:
[](https://siensis.com/books/uploads/images/gallery/2025-10/ViUFLWiUsKklGa1y-image.png)
SQL
```sql
SELECT * FROM Orders ORDER BY id LIMIT 15 OFFSET 30;
-- Retorna 15 registres, començant pel registre 31.
```
**ATENCIÓ** L'`ORDER BY` és crucial; sense ell, els registres retornats podrien canviar a cada consulta
### Avantatges
- **Simplicitat:** El concepte de `LIMIT` i `OFFSET` és molt fàcil d'entendre i d'implementar en la majoria de bases de dades (MySQL, PostgreSQL, etc.).
- **Accessibilitat:** Permet accedir directament a qualsevol número de pàgina, cosa que facilita la creació d'interfícies amb un menú de navegació numèric (p. ex., 1, 2, 3, 4...).
- **Control del Motor:** Tota la lògica de salt de dades es delega al motor SQL, que és el més eficient per gestionar-ho.
### Inconvenients (rendiment)
El principal desavantatge d'aquest mètode es manifesta en conjunts de dades molt grans i a pàgines molt avançades:
- **Escalat lent (Slow Scaling):** Quan l'usuari demana una pàgina amb un `OFFSET` molt gran (p. ex., `OFFSET 100000`), el motor de la base de dades *encara ha de recórrer i descartar* 100.000 registres.
- **Bloqueig implícit:** Si les dades estan canviant ràpidament (insercions/eliminacions), la pàgina 3 consultada un minut més tard podria mostrar registres duplicats o ometre'n alguns, ja que els índexs de desplaçament no són estables en el temps.
## Paginació basada en cursors (Keyset/Seek pagination)
Per superar les limitacions d'escalabilitat de l'`OFFSET`, s'utilitza la **Paginació basada en cursors** (o Keysets). En lloc de dir "salta 1000 registres", es pregunta: **"Dona'm els 20 registres següents a la ID 1000"**.
SQL
```php
SELECT * FROM Orders WHERE id > 1000 ORDER BY id ASC LIMIT 20;
```
Això evita que el motor hagi de comptar i descartar files. Simplement utilitza l'índex de la columna (`id` en aquest cas) per anar directament al registre desitjat. Aquesta tècnica és molt **més ràpida i eficient** en escales grans, encara que limita la navegació a "Següent" i "Anterior" (no permet anar directament a la pàgina 50).
### Que passa si no hi ha ID numèric?
Fer una paginació Keyset (o Seek Pagination) quan els IDs no són numèrics és totalment possible. La clau és utilitzar una columna que sigui **ordenada** i **indexada** com a punt de referència (el cursor), tot i que aquesta no sigui l'ID principal. Normalment, s'utilitza una columna de **data/hora** o una combinació de la columna no numèrica i l'ID (per a desempat).
#### Ordre consistent i únic
El principi de Keyset Pagination és trobar el "pròxim" registre basant-se en el valor de l'últim registre vist. Això requereix un camp o una combinació de camps que siguin:
1. **Ordenables** (`ORDER BY`).
2. **Únics** o gairebé únics (per evitar saltar-se o duplicar registres).
##### Paginació camps de Data/Hora (Timestamps)
Si el teu cursor no pot ser un ID numèric, el millor substitut és una columna **`TIMESTAMP`** o **`DATETIME`** ben indexada, ja que les dates són inherentment ordenables.
**Dades necessàries a cada petició:**
- `$limit`: Mida de la pàgina (p. ex., 20).
- `$ultima_data`: La data/hora de l'últim registre de la pàgina anterior.
**Consulta SQL:**
SQL
```sql
SELECT * FROM Productes
WHERE data_creacio < :ultima_data
ORDER BY data_creacio DESC
LIMIT :limit;
```
- **Com funciona:** Busca productes que siguin **anteriors** a la data de l'últim producte que vam veure.
- **Per a la primera pàgina:** Si `$ultima_data` és null, es pot utilitzar una data molt recent o un alias.
##### Paginació combinació columnes (Desempat)
Si hi ha la possibilitat que dos registres tinguin exactament la mateixa data/hora de creació, necessitem una segona columna per desempatar. S'utilitza la columna no numèrica i després el camp ID (o qualsevol camp únic).
Imaginem que tens un camp **`codi_sku`** (string) i el vols utilitzar per ordenar.
**Dades necessàries a cada petició:**
- `$limit`: Mida de la pàgina.
- `$ultim_sku`: El valor `codi_sku` de l'últim registre de la pàgina anterior.
- `$ultim_id_unic`: El valor ID (o data/hora) de l'últim registre de la pàgina anterior.
**Consulta SQL (Utilitzant `codi_sku` i `id` per desempat):**
SQL
```sql
SELECT codi_sku, nom, id
FROM Productes
WHERE codi_sku > :ultim_sku
OR (codi_sku = :ultim_sku AND id > :ultim_id_unic)
ORDER BY codi_sku ASC, id ASC
LIMIT :limit;
```
- **Com funciona:** Busca tots els productes on el `codi_sku` és lexicogràficament **més gran** que l'últim vist. Si hi ha SKUs idèntics, desempatarà amb l'`id` per evitar omissions.
Aquest mètode és robust i trasllada l'eficiència dels índexs de BBDD a la navegació, independentment de si el teu ID principal és numèric o no.
# Inserir dades
## MySQLi Procedural
Aquest mètode utilitza funcions prefixades amb `mysqli_` i les marques de posició (`?`).
### Inserció de dades i obtenció de l'ID
PHP
```php
```
## MySQLi Orientat a Objectes (OO)
Aquest mètode utilitza mètodes de l'objecte `$conn` i l'objecte `$stmt`.
### Inserció de dades i obtenció de l'ID
PHP
```php
prepare("INSERT INTO Usuaris (nom, email) VALUES (?, ?)");
// 2. Vincular les variables a la sentència
$stmt->bind_param("ss", $nom, $email);
// 3. Executar la sentència
if ($stmt->execute()) {
// 4. Obtenir l'últim ID Inserit
$last_id = $conn->insert_id;
echo "Nou registre creat amb èxit. ID: " . $last_id . ".\n";
} else {
throw new Exception("L'execució de la consulta va fallar.");
}
} catch (Exception $e) {
echo "Error: " . $e->getMessage() . " (" . $conn->error . ")\n";
}
// 5. Tancar el statement (i opcionalment la connexió)
$stmt->close();
// $conn->close();
?>
```
## PDO (PHP Data Objects)
PDO és la forma més neta i segura. Utilitza la funció **`lastInsertId()`** directament sobre l'objecte PDO.
### Inserció de dades i obtenció de l'ID
PHP
```php
prepare("INSERT INTO Usuaris (nom, email) VALUES (?, ?)");
// 2. Executar la sentència, passant les dades com un array
// PDO determina automàticament els tipus, simplificant la vinculació
$stmt->execute([$nom, $email]);
// 3. Obtenir l'últim ID Inserit
$last_id = $pdo->lastInsertId();
echo "Nou registre creat amb èxit. ID: " . $last_id . ".\n";
} catch (PDOException $e) {
echo "Error en la inserció: " . $e->getMessage() . ".\n";
}
// El statement es tanca automàticament en finalitzar
// $pdo = null; // Tancar connexió
?>
```
# Inserir dades multiples
Podem utilitzar la funció **`multi_query`** (o `mysqli_multi_query`) amb MySQLi per executar múltiples sentències SQL en una sola trucada. Aquesta és la tècnica habitual per a la inserció de *múltiples registres*. No obstant això, amb PDO i, en general, per raons de **seguretat** i **eficiència**, la manera més professional de fer múltiples insercions és utilitzar **Sentències Preparades** dins d'una **Transacció** (especialment amb PDO). A continuació, s'explica com fer-ho amb els tres mètodes.
## MySQLi Procedural: `mysqli_multi_query()`
Aquest mètode és el més directe per a consultes que **no** utilitzen dades de l'usuari (és a dir, sense risc d'injecció SQL, com en el vostre exemple).
Es concatenen totes les sentències `INSERT` separades per un punt i coma (`;`) i s'executa una sola funció.
PHP
```php
```
- **Mecanisme:** `mysqli_multi_query()`
- **Avantatge:** Molt ràpid per a sentències fixes.
- **Inconvenient:** **Insegur** si les dades provenen d'un usuari. No gestiona bé l'obtenció d'IDs de múltiples insercions.
## MySQLi Orientat a Objectes (OO): `$conn->multi_query()`
Igual que el mètode procedural, utilitza la funció nativa per executar múltiples sentències encadenades.
PHP
```php
multi_query($sql) === TRUE) {
echo "New records created successfully (OO multi_query).";
} else {
echo "Error: " . $conn->error;
}
$conn->close();
?>
```
- **Mecanisme:** `$conn->multi_query($sql)`
- **Avantatge/Inconvenient:** Igual que el procedural.
## PDO: Sentències preparades i transaccions (Recomanat)
Aquesta és la manera **més segura i controlada**. Es prepara una sola sentència `INSERT` i s'executa repetidament dins d'una **transacció**. Una transacció garanteix que, o bé **totes** les insercions es completen (`commit`), o bé **cap** no es fa (`rollback`) si alguna falla.
### Inserció múltiple i segura
PHP
```php
beginTransaction(); // 1. Iniciar la Transacció
$stmt = $pdo->prepare($sql); // 2. Preparar la Sentència (només una vegada)
$comptador = 0;
foreach ($dades as $registre) {
$stmt->execute($registre); // 3. Executar la Sentència per cada registre
$comptador++;
// NOTA: Per obtenir IDs individuals, s'hauria de cridar $pdo->lastInsertId() dins del bucle
}
$pdo->commit(); // 4. Confirmar els canvis
echo "New records created successfully ($comptador insercions via PDO Transaction).";
} catch (PDOException $e) {
$pdo->rollBack(); // 5. Desfer els canvis si alguna cosa ha fallat
echo "Error en la transacció: " . $e->getMessage();
}
$pdo = null; // Tancar connexió
?>
```
- **Mecanisme:** Transaccions (`beginTransaction`, `commit`, `rollBack`) amb Sentències Preparades (`prepare`, `execute`).
- **Avantatge:** **Màxima seguretat** (contra SQL Injection) i **Integritat de dades** (Atomicidad: totes o cap).
- **Eficiència:** Preparar la sentència només una vegada i executar-la múltiples vegades és molt ràpid.
# Delete data
Per eliminar un registre d'una taula, farem servir la sentència **`DELETE FROM`** de SQL. Igual que amb les altres operacions que involucren dades de l'usuari (en aquest cas, l'ID del registre a eliminar), utilitzarem **Sentències preparades** per evitar l'atac de la Injecció SQL.
Aquí teniu com implementar l'eliminació amb **MySQLi Procedural**, **MySQLi OO** i **PDO**.
## MySQLi Procedural
Aquest mètode utilitza la funció `mysqli_prepare()` i l'enllaç de connexió.
### Eliminació del registre
PHP
```php
0) {
echo "Registre amb ID " . $id_a_eliminar . " eliminat amb èxit (Procedural). \n";
} else {
echo "No s'ha trobat cap registre amb ID " . $id_a_eliminar . " per eliminar.\n";
}
} else {
echo "Error en l'execució: " . mysqli_error($conn) . "\n";
}
// 5. Tancar el statement
mysqli_stmt_close($stmt);
// mysqli_close($conn);
?>
```
## MySQLi Orientat a Objectes (OO)
Aquest mètode utilitza el mètode `prepare()` de l'objecte `$conn`.
### Eliminació del registre
PHP
```php
prepare("DELETE FROM Usuaris WHERE id = ?");
// 2. Vincular el paràmetre (la ID és un enter: 'i')
$stmt->bind_param("i", $id_a_eliminar);
// 3. Executar la sentència
if ($stmt->execute()) {
// 4. Comprovar si s'ha eliminat alguna fila
if ($stmt->affected_rows > 0) {
echo "Registre amb ID " . $id_a_eliminar . " eliminat amb èxit (OO). \n";
} else {
echo "No s'ha trobat cap registre amb ID " . $id_a_eliminar . " per eliminar.\n";
}
} else {
throw new Exception("L'execució de la consulta va fallar.");
}
} catch (Exception $e) {
echo "Error: " . $e->getMessage() . " (" . $conn->error . ")\n";
}
// 5. Tancar el statement
$stmt->close();
// $conn->close();
?>
```
## PDO (PHP Data Objects)
PDO és el mètode més net, utilitzant **`execute()`** amb un *array* de dades.
### Eliminació del registre
PHP
```php
prepare($sql);
// 2. Executar la sentència, passant la ID com a array
$stmt->execute([$id_a_eliminar]);
// 3. Comprovar si s'ha eliminat alguna fila
// s'utilitza rowCount() directament sobre el statement
if ($stmt->rowCount() > 0) {
echo "Registre amb ID " . $id_a_eliminar . " eliminat amb èxit (PDO). \n";
} else {
echo "No s'ha trobat cap registre amb ID " . $id_a_eliminar . " per eliminar.\n";
}
} catch (PDOException $e) {
die("Error en l'eliminació: " . $e->getMessage() . ".\n");
}
// 4. Tancar
// $pdo = null; // Tancar connexió
?>
```
### Com comprovar-ho?
Per confirmar que s'ha eliminat un registre, en lloc de comprovar l'èxit de l'execució (`true`), el que es comprova és el nombre de files afectades:
Si el valor retornat és **major que 0**, vol dir que s'ha eliminat un o més registres. Si és 0, la consulta ha funcionat, però el registre amb aquesta `ID` no existia.
# Update data
Per actualitzar un registre existent a una taula, s'utilitza la sentència **`UPDATE`** de SQL, especificant els camps i valors nous i utilitzant una clàusula **`WHERE`** per identificar el registre concret a modificar (normalment per la seva ID). Com en totes les operacions amb dades d'usuari, és crucial utilitzar **Sentències preparades** per prevenir la Injecció SQL.
## MySQLi Procedural
Aquest mètode utilitza la funció `mysqli_prepare()` i l'enllaç de connexió.
### Actualització registre
PHP
```php
0) {
echo "Registre amb ID " . $id_a_actualitzar . " actualitzat amb èxit (Procedural). \n";
} else {
echo "No s'ha fet cap canvi (el registre no existeix o les dades són les mateixes).\n";
}
} else {
echo "Error en l'execució: " . mysqli_error($conn) . "\n";
}
// 5. Tancar el statement
mysqli_stmt_close($stmt);
// mysqli_close($conn);
?>
```
## MySQLi Orientat a Objectes (OO)
Aquest mètode utilitza el mètode `prepare()` de l'objecte `$conn`.
### Actualització registre
PHP
```php
prepare("UPDATE Usuaris SET nom = ?, email = ? WHERE id = ?");
// 2. Vincular els paràmetres (ssi)
$stmt->bind_param("ssi", $nou_nom, $nou_email, $id_a_actualitzar);
// 3. Executar la sentència
if ($stmt->execute()) {
// 4. Comprovar si s'ha actualitzat alguna fila
if ($stmt->affected_rows > 0) {
echo "Registre amb ID " . $id_a_actualitzar . " actualitzat amb èxit (OO). \n";
} else {
echo "No s'ha fet cap canvi (el registre no existeix o les dades són les mateixes).\n";
}
} else {
throw new Exception("L'execució de la consulta va fallar.");
}
} catch (Exception $e) {
echo "Error: " . $e->getMessage() . " (" . $conn->error . ")\n";
}
// 5. Tancar el statement
$stmt->close();
// $conn->close();
?>
```
## PDO (PHP Data Objects)
PDO és el mètode més concís i prefereix l'execució amb un *array* de dades.
### Actualització registre
PHP
```php
prepare($sql);
// 2. Executar la sentència, passant totes les dades en un array
$stmt->execute([$nou_nom, $nou_email, $id_a_actualitzar]);
// 3. Comprovar si s'ha actualitzat alguna fila
if ($stmt->rowCount() > 0) {
echo "Registre amb ID " . $id_a_actualitzar . " actualitzat amb èxit (PDO). ✅\n";
} else {
echo "No s'ha fet cap canvi (el registre no existeix o les dades són les mateixes).\n";
}
} catch (PDOException $e) {
die("Error en l'actualització: " . $e->getMessage() . ".\n");
}
// 4. Tancar
// $pdo = null; // Tancar connexió
?>
```
### Com ho comprovem?
En els tres mètodes, la clau per saber si l'actualització ha tingut lloc és utilitzar la funció que retorna el **nombre de files afectades**:
Si el valor retornat és **major que 0**, s'ha fet l'actualització. Si és 0, potser la fila ja tenia els mateixos valors o la `WHERE` no va trobar cap registre.