# 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ó
```php
0) {
echo "Resultats (MySQLi Procedural)
";
while ($row = mysqli_fetch_assoc($result)) {
echo "Nom: " . $row['nom'] . " - Email: " . $row['email'] . "
";
}
} else {
echo "No s'han trobat resultats.";
}
// 6. Tancar
mysqli_stmt_close($stmt);
mysqli_close($conn);
?>
```
## MySQLi Orientat a Objectes (OO)
Aquest mètode utilitza mètodes de l'objecte `$conn` i l'objecte `$stmt`.
### Consulta, filtre (`WHERE`) i paginació
```php
prepare($sql);
// 2. Vincular les variables
$stmt->bind_param("sii", $filtre_nom, $offset, $limit);
// 3. Executar la sentència
$stmt->execute();
// 4. Obtenir el resultat
$result = $stmt->get_result();
// 5. Processar i mostrar les dades
if ($result->num_rows > 0) {
echo "Resultats (MySQLi OO)
";
while ($row = $result->fetch_assoc()) {
echo "Nom: " . $row['nom'] . " - Email: " . $row['email'] . "
";
}
} else {
echo "No s'han trobat resultats.";
}
// 6. Tancar
$stmt->close();
$conn->close();
?>
```
## 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
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 "Resultats (PDO)
";
foreach ($resultats as $row) {
echo "Nom: " . $row['nom'] . " - Email: " . $row['email'] . "
";
}
} else {
echo "No s'han trobat resultats.";
}
} catch (PDOException $e) {
die("Error en la consulta: " . $e->getMessage());
}
// 5. Tancar
$pdo = null;
?>
```
### 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` |
**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"**.
```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
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
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
```
## 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
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
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
```
- **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
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
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
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
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
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:
- **MySQLi (OO):** `$stmt->affected_rows`
- **MySQLi (Procedural):** `mysqli_stmt_affected_rows($stmt)`
- **PDO:** `$stmt->rowCount()`
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
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
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
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**:
- **MySQLi (OO):** `$stmt->affected_rows`
- **MySQLi (Procedural):** `mysqli_stmt_affected_rows($stmt)`
- **PDO:** `$stmt->rowCount()`
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.