<div class="page">
<div class="cover text-center">
<img class="mx-auto" src=/itb/images/logo_mislata.png alt="logo">
# Consultes bàsiques
<div class="text-end fit-content ms-auto my-3 mt-auto pt-3">
<p><strong>Autor:</strong> Joan Puigcerver Ibáñez</p>
<p><strong>Correu electrònic:</strong> j.puigcerveribanez@edu.gva.es</p>
<p><strong>Curs:</strong> 2023/2024</p>
</div>
<div>
<p class="fw-bold mb-0">Llicència: BY-NC-SA</p>
<p class="d-none d-md-block">(Reconeixement - No Comercial - Compartir Igual)</p>
<a href="https://creativecommons.org/licenses/by-nc-sa/4.0/deed.ca" target="_blank">
<img class="mx-auto" src="/itb/images/license.png" alt="Licence"/>
</a>
</div><!--license-->
</div><!--cover-->
</div><!--page-->
{:toc}
## Introducció
Una vegada s'ha definit un model de dades en una base de dades és possible
realitzar consultes per manipular les dades emmagatzemades, com consultar
dades, insertar-ne de noves, modificar-les o eliminar-les.
Totes aquestes operacions es realitzen mitjançant el __Llenguatge de Manipulació de Dades (DML)__,
un subllenguatge de __SQL__.
Aquest material es centrarà a estudiar com realitzar consultes sobre una base de dades.
## DML
El __Llenguatge de Manipulació de Dades (DML o _Data Definition Language_)__ és un
subllenguatge de SQL que permet manipular les dades de una base de dades.
Les accions que es permeten són:
- `SELECT`: Permet consultar les dades de la base de dades.
- `INSERT`: Permet inserir noves dades a la base de dades.
- `UPDATE`: Permet modificar dades existents.
- `DELETE`: Permet elmininar dades.
::: docs
Documentació oficial sobre DML:
- MariaDB: https://mariadb.com/kb/en/data-manipulation/
- MySQL 8.0: https://dev.mysql.com/doc/refman/8.0/en/sql-data-manipulation-statements.html
:::
## SELECT
La sentència `SELECT` permet consultar dades existents en una base de dades.
Té el següent format:
```sql
SELECT
[ALL | DISTINCT | DISTINCTROW]
column_expr [[AS] alias] [, column2_expr [[AS] alias2] ...]
FROM table
[WHERE condition]
[ORDER BY {col_name} [ASC | DESC], ...]
[GROUP BY {col_name} [ASC | DESC], ... [WITH ROLLUP]]
[HAVING aggregate_condition]
```
- `SELECT`: Indica que volem consultar les dades de una base de dades.
- `[ALL | DISTINCT | DISTINCTROW]`: Paràmetre opcional.
- `ALL`: Valor per defecte si no s'especifica. Retorna totes les files, incloses aquelles que siguen iguals.
- `DISTINCT`: Retorna les files sense duplicats.
- `DISTINCTROW`: Sinònim de `DISTINCT`.
- `column_expr [, column2_expr ...]`: S'indiquen les columnes que es volen recuperar en la consulta.
Si es volen recuperar totes les columnes d'una taula es pot utilitzar un asterisc `*`.
- `[[AS] alias]`: Opcionalment, es pot indicar un àlies a una columna o expresió, que es mostrarà en el resultat.
La paraula clau `AS` és opcional.
- `FROM database.table`: Indica la taula sobre la qual volem fer la consulta.
El paràmetre `database` és opcional si la base de dades s'ha especificat prèviament amb `USE`.
- `WHERE condition`: S'utilitza per filtrar els resultats en base a una condició.
- `ORDER BY`: S'utilitza per ordenar els registres obtinguts en la consulta.
- `ASC`: Indica que s'ordenaran els valors de manera ascendent. Valor per defecte.
- `DESC`: Indica que s'ordenaran els valors de manera descendent.
- `GROUP BY`: S'utilitza per agrupar els registres obtinguts en la consulta.
- `HAVING aggregate_condition`: S'utilitza per filtrar els resultats obtinguts a partir d'una condució que utilitza
una funció d'agregació.
::: docs
Documentació oficial sobre consultes:
- MariaDB: https://mariadb.com/kb/en/select/
- MySQL 8.0: https://dev.mysql.com/doc/refman/8.0/en/select.html
:::
L'ordre en el qual el SGBD realitza les consultes és:
- Es consulten les taules sobre les quals es realitza la consulta.
- S'itera registre per registre per evaluar les condicions especificades, quedant-se amb
els registres que compleixen la condició i descartant la resta.
- Ordena el resultat.
- Selecciona les columnes o funcions d'agregació especificades.
## FROM
La paraula clau `FROM` especifica la taula o taules sobre les quals es recuperen
les dades. De moment, sols s'utilitzarà una única taula.
::: example
En aquest material s'utilitzarà la [Base de Dades Institut]() en els exemples.
```sql
USE institut;
```
Consultem les dades dels cicles formatius:
```sql
SELECT nom, sigles, nivell
FROM cicle_formatiu;
+------------------------------------------------+--------+----------+
| nom | sigles | nivell |
+------------------------------------------------+--------+----------+
| Sistemes Microinformàtics en Xarxa | SMX | mitja |
| Administració de Sistemes Informàtics en Xarxa | ASIX | superior |
| Desenvolupament d'Aplicacions Multiplataforma | DAM | superior |
| Desenvolupament d'Aplicacions Web | DAW | superior |
+------------------------------------------------+--------+----------+
```
Consultem tots els registres i columnes de les famílies professionals:
```sql
SELECT * FROM familia_professional;
+------------+-----------------------------+
| id_familia | nom |
+------------+-----------------------------+
| 1 | Informàtica i comunicacions |
+------------+-----------------------------+
```
:::
## WHERE
La paraula clau `WHERE` s'utilitza especificar una condició a les dades que
es recuperen.
Les condicions poden incloure operacions numèriques i alfabètiques, on es poden utilitzar constants o expressions aritmètiques, valors nuls, ...
::: docs Documentació oficial sobre funcions:
- MariaDB: https://mariadb.com/kb/en/built-in-functions/
- MySQL 8.0: https://dev.mysql.com/doc/refman/8.0/en/built-in-function-reference.html
:::
### Comparadors
Dins de la clàusula `WHERE` es poden definir condicions, les quals utilitzen operadors de comparació.
Algunes dels operadors més comuns són:
- `A = B`: Comprova si dos valors són iguals.
- `A != B` o `A <> B`: Comprova si dos valors són diferents.
- `A < B`: Comprova si un element és més xicotet que l'altre.
- `A <= B`: Comprova si un element és més xicotet o igual que l'altre.
- `A > B`: Comprova si un element és més gran que l'altre.
- `A >= B`: Comprova si un element és més gran o igual que l'altre.
- `A IN (B, C, ...)`: Comprova si un element forma part d'un conjunt de valors.
- `A NOT IN (B, C, ...)`: Comprova si un element no forma part d'un conjunt de valors.
- `A BETWEEN B AND C`: Comprova si un element està entre dos valors.
- `A NOT BETWEEN B AND C`: Comprova si un element no està entre dos valors.
::: docs
Documentació oficial sobre comparadors:
- MariaDB: https://mariadb.com/kb/en/comparison-operators/
- MySQL 8.0: https://dev.mysql.com/doc/refman/8.0/en/comparison-operators.html
:::
::: example
- Consultem els mòduls professionals amb més de 200 hores:
```sql
SELECT *
FROM modul_professional
WHERE hores > 200;
+----------+--------------------------------------------+--------+-------+------+
| id_modul | nom | sigles | hores | ects |
+----------+--------------------------------------------+--------+-------+------+
| 0221 | Muntatge i Manteniment d'Equips | MME | 224 | 5 |
| 0223 | Aplicacions Ofimàtiques | AOF | 224 | 5 |
| 0225 | Xarxes Locals | XAR | 224 | 5 |
| 0231 | Formació en Centres de Treball | FCT | 380 | 22 |
| 0369 | Implantació de Sistemes Operatius en Xarxa | ISO | 224 | 15 |
| 0382 | Formació en Centres de Treball | FCT | 400 | 22 |
| 0485 | Programació | PRG | 256 | 14 |
| 0495 | Formació en Centres de Treball | FCT | 400 | 22 |
| 0619 | Formació en Centres de Treball | FCT | 400 | 22 |
+----------+--------------------------------------------+--------+-------+------+
```
- Consultem els mòduls professionals amb exactament 9 crèdits.
```sql
SELECT *
FROM modul_professional
WHERE ects = 9;
+----------+--------------------------------------+--------+-------+------+
| id_modul | nom | sigles | hores | ects |
+----------+--------------------------------------+--------+-------+------+
| 0486 | Accés a Dades | ADB | 120 | 9 |
| 0488 | Desenvolupament d'Interfícies | DIU | 120 | 9 |
| 0612 | Desenvolupament Web en Entorn Client | DFT | 140 | 9 |
| 0615 | Disseny d'Interfícies Web | DIW | 120 | 9 |
+----------+--------------------------------------+--------+-------+------+
```
- Consultem els mòduls professionals amb crèdits entre 10 i 20.
```sql
SELECT *
FROM modul_professional
WHERE ects BETWEEN 10 and 20;
+----------+--------------------------------------------+--------+-------+------+
| id_modul | nom | sigles | hores | ects |
+----------+--------------------------------------------+--------+-------+------+
| 0369 | Implantació de Sistemes Operatius en Xarxa | ISO | 224 | 15 |
| 0370 | Planificació i administració de xarxes | PAX | 192 | 12 |
| 0372 | Gestió de Base de Dades | GBD | 160 | 11 |
| 0483 | Sistemes Informàtics | SI | 160 | 10 |
| 0484 | Bases de Dades | DBA | 160 | 12 |
| 0485 | Programació | PRG | 256 | 14 |
| 0613 | Desenvolupament Web en Entorn Servidor | DBK | 160 | 12 |
+----------+--------------------------------------------+--------+-------+------+
```
- Consultem les persones el qual el seu nom és Marta o Pau.
```sql
SELECT dni, nom, cognoms
FROM persona
WHERE nom IN ("Marta", "Pau");
+-----------+-------+---------+
| dni | nom | cognoms |
+-----------+-------+---------+
| 32409818N | Marta | Sanchis |
| 55739745G | Marta | Català |
| 56294859J | Marta | Ferrer |
| 71299956W | Pau | Martí |
| 92384756F | Pau | Peris |
| 92743788Z | Pau | Ivars |
+-----------+-------+---------+
```
:::
### Operacions i funcions aritmètiques
Les operacions aritmètiques es poden utilitzar en qualsevol lloc dins de la sentència `SELECT`.
Normalment s'utilitzen en la clàusula `SELECT` o `WHERE`.
::: docs
Documentació oficial sobre operacions i funcions aritmètiques:
- MariaDB: https://mariadb.com/kb/en/arithmetic-operators/
- MySQL 8.0: https://dev.mysql.com/doc/refman/8.0/en/arithmetic-functions.html
:::
Les operacions aritmètiques més utilitzades són:
- `+`: Suma
- `-`: Resta
- `*`: Multiplicació
- `/`: Divisió
- `DIV`: Divisió entera
- `%` o `MOD`: Mòdul o residu
També es pot fer ús de funcions aritmètiques integrades en el SGBD.
Les més comunes són:
- `POW(A, B)`: Potència ($A^B$)
::: example
```sql
SELECT POW(10, 2); --> 100
```
:::
- `LOG([A, ]B)`: Logartime ($\log_A B$). Si `A` no s'especifica, s'utilitza el logaritme natural ($\ln{B}$).
::: example
```sql
SELECT LOG(10, 100); --> 2
```
:::
- `PI()`: Retorna el valor de el número pi ($\pi$: 3,141593..).
::: example
```sql
SELECT PI(); --> 3.141593
```
:::
- `ABS(A)`: Valor absolut (sempre positiu).
::: example
```sql
SELECT ABS(10); --> 10
SELECT ABS(-10); --> 10
```
:::
- `ROUND(A, D)`: Arredoneix el número `A` al nombre de decimals `D` especificat.
::: example
```sql
SELECT ROUND(10.25, 1); --> 10.3
SELECT ROUND(10.25, 0); --> 10
```
:::
- `CEIL(A)`: Arredoneix el número `A` a l'alça.
::: example
```sql
SELECT CEIL(10.25); --> 11
```
:::
- `FLOOR(A)`: Arredoneix el número `A` a la baixa.
::: example
```sql
SELECT FLOOR(10.25); --> 10
```
:::
:::: example
- Consultem la ràtio d'hores que necessites per aconseguir un crèdit en els mòduls professionals.
::: note
S'ha definit l'àlias `ratio` a la columna del resultat `hores / etcs`.
L'àlias sols pot ser utulitzar en les clàusules `ORDER BY`, `GROUP BY` i `HAVING`
(https://stackoverflow.com/questions/942571/using-column-alias-in-where-clause-of-mysql-query-produces-an-error).
:::
```sql
SELECT hores / ects AS ratio, sigles, nom
FROM modul_professional
WHERE (hores / ects) <= 12;
+---------+--------+-------------------------------------------------------------+
| ratio | sigles | nom |
+---------+--------+-------------------------------------------------------------+
| 12.0000 | SGBD | Administració de sistemes gestors de bases de dades |
| 8.0000 | PRJ | Projecte d'Administració de Sistemes Informàtics en Xarxa |
| 12.0000 | PSP | Programació de Serveis i Processos |
| 8.0000 | PRJ | Projecte de Desenvolupament d'Aplicacions Multiplataforma |
| 8.0000 | PRJ | Projecte de Desenvolupament d'Aplicacions Web |
+---------+--------+-------------------------------------------------------------+
```
::::
### Operacions i funcions amb cadenes de caràcters
De la mateixa manera que es poden realitzar operacions aritmètiques,
també es permeten operacions per processar i transformar les cadenes de caràcters.
::: docs
Documentació oficial sobre operacions amb cadenes de caràcters:
- MariaDB: https://mariadb.com/kb/en/string-functions/
- MySQL 8.0: https://dev.mysql.com/doc/refman/8.0/en/string-functions.html
:::
Algunes de les funcions més comuns són:
- `LEFT(string, N)`: Retorna el prefix (part esquerra) de longitud `N` de la cadena de caràcters.
- `RIGHT(string, N)`: Retorna el sufix (part dreta) de longitud `N` de la cadena de caràcters.
- `CONCAT(string, ...)`: Retorna la concatenació de les cadenes de caràcters especificades.
- `LOWER(string)`: Retorna la cadena de caràcters en minúscula.
- `UPPER(string)`: Retorna la cadena de caràcters en majúscula.
::: example
- Consultem les inicials, el nom, el cognom i la data de naixement de les persones nascudes abans del 1990.
```sql
SELECT CONCAT(LEFT(nom, 1), ".", LEFT(cognoms, 1), ".") AS inicials, nom, cognoms, data_naixement
FROM persona
WHERE data_naixement < "1990-01-01";
+----------+--------+----------+----------------+
| inicials | nom | cognoms | data_naixement |
+----------+--------+----------+----------------+
| M.S. | Mar | Sánchez | 1984-11-10 |
| Ò.P. | Òscar | Peris | 1975-01-15 |
| M.F. | Maria | Femenia | 1974-12-04 |
| P.P. | Pau | Peris | 1982-03-19 |
+----------+--------+----------+----------------+
```
:::
A més, existeix la comparació `LIKE`, que permet comprovar si una cadena de caràcters
segueix un patró definit:
- `%`: Representa qualsevol cadena de caràcters, de longitud variable. Pot ser la cadena buida.
- `_`: Representa un únic caràcter.
::: docs
Documentació oficial sobre `LIKE`:
- MariaDB: https://mariadb.com/kb/en/like/
- MySQL 8.0: https://dev.mysql.com/doc/refman/8.0/en/string-comparison-functions.html#operator_like
:::
::: example
- Consultem les persones les quals el seu nom té una "e" en segona posició.
```sql
SELECT *
FROM persona
WHERE nom LIKE "_e%";
+--------+------------+
| nom | cognoms |
+--------+------------+
| Sergi | Martínez |
| Gemma | Femenia |
| Teresa | Mas |
| Helena | Montserrat |
| Helena | Benlloch |
| Teresa | Ginestar |
+--------+------------+
```
:::
### Operacions i funcions amb dates i hores
També existeixen operacions i funcions per extraure informació o manipular les dates o el temps.
::: docs
Documentació oficial sobre operacions sobre dates i hores:
- MariaDB: https://mariadb.com/kb/en/date-time-functions/
- MySQL 8.0: https://dev.mysql.com/doc/refman/8.0/en/date-and-time-functions.html
:::
Les operacions més comunes són:
- `NOW()`: Retorna un object `DATETIME` amb el dia i l'hora actual.
- `YEAR()`, `MONTH()` i `DAY()`: Extrau l'any, mes i dia d'una data respectivament.
::: example
```sql
SELECT YEAR("1707-04-25"); --> 1707
SELECT MONTH("1707-04-25"); --> 4
SELECT DAY("1707-04-25"); --> 25
```
:::
- `HOUR()`, `MINUTE()` i `SECOND()`: Extrau l'hora, el minut i els segons d'una hora respectivament.
::: example
```sql
SELECT HOUR("23:59:00"); --> 23
SELECT MINUTE("23:59:00"); --> 59
SELECT SECOND("23:59:00"); --> 0
```
:::
- `DATE_FORMAT(D, format)`: Retorna la data en el format especificat.
:::: info
El tipus de dades `DATE` sempre té el format `YYYY-MM-DD`.
::: docs
- MYSQL 8.0: https://dev.mysql.com/doc/refman/8.0/en/datetime.html
:::
::::
::: example
```sql
SELECT DATE_FORMAT("1707-04-25", "%d/%m/%Y"); --> "25/04/1707"
```
:::
- `STR_TO_DATE(string, format)`: Retorna un objecte `DATE` a partir d'una cadena de caràcters en el format especificat.
::: example
```sql
SELECT STR_TO_DATE("25/04/1707", "%d/%m/%Y"); --> "1707-04-25"
```
:::
### Operadors lògics
Els operadors lògics s'utilitzen per modificar el resultat booleà d'una condició
o combinar-ne diverses.
Els principals operadors lògics són:
- `NOT expr` o `! expr`: Nega una expresió. `TRUE` passa a ser `FALSE` i viceversa.
::: note
- `TRUE` es representa com un 1.
- `FALSE` es representa com un 0.
:::
::: info "Taula NOT"
<table>
<thead>
<tr>
<th class="center">A</th>
<th class="center">NOT A</th>
</tr>
</thead>
<tbody>
<tr>
<td class="center">0</td>
<td class="center">1</td>
</tr>
<tr>
<td class="center">1</td>
<td class="center">0</td>
</tr>
</tbody>
</table>
:::
- `AND` o `&&`: S'evalua a `TRUE` si les dues condicions es compleixen.
::: info "Taula AND"
<table>
<thead>
<tr>
<th class="center">A</th>
<th class="center">B</th>
<th class="center">A AND B</th>
</tr>
</thead>
<tbody>
<tr>
<td class="center">0</td>
<td class="center">0</td>
<td class="center">0</td>
</tr>
<tr>
<td class="center">0</td>
<td class="center">1</td>
<td class="center">0</td>
</tr>
<tr>
<td class="center">1</td>
<td class="center">0</td>
<td class="center">0</td>
</tr>
<tr>
<td class="center">1</td>
<td class="center">1</td>
<td class="center">1</td>
</tr>
</tbody>
</table>
:::
- `OR` o `||`: S'evalua a `TRUE` si qualsevol de les dues condicions es compleix.
::: info "Taula OR"
<table>
<thead>
<tr>
<th class="center">A</th>
<th class="center">B</th>
<th class="center">A OR B</th>
</tr>
</thead>
<tbody>
<tr>
<td class="center">0</td>
<td class="center">0</td>
<td class="center">0</td>
</tr>
<tr>
<td class="center">0</td>
<td class="center">1</td>
<td class="center">1</td>
</tr>
<tr>
<td class="center">1</td>
<td class="center">0</td>
<td class="center">1</td>
</tr>
<tr>
<td class="center">1</td>
<td class="center">1</td>
<td class="center">1</td>
</tr>
</tbody>
</table>
:::
- `XOR`: S'evalua a `TRUE` si qualsevol de les dues condicions es compleix,
però no cap de les dues o les dues a la vegada.
::: info "Taula XOR"
<table>
<thead>
<tr>
<th class="center">A</th>
<th class="center">B</th>
<th class="center">A XOR B</th>
</tr>
</thead>
<tbody>
<tr>
<td class="center">0</td>
<td class="center">0</td>
<td class="center">0</td>
</tr>
<tr>
<td class="center">0</td>
<td class="center">1</td>
<td class="center">1</td>
</tr>
<tr>
<td class="center">1</td>
<td class="center">0</td>
<td class="center">1</td>
</tr>
<tr>
<td class="center">1</td>
<td class="center">1</td>
<td class="center">0</td>
</tr>
</tbody>
</table>
:::
::: example
- Consulta les persones que el seu dni acaba en J i han nascut en el 2000 o anys posteriors.
```sql
SELECT dni, nom, cognoms, data_naixement
FROM persona
WHERE RIGHT(dni, 1) = "J" AND YEAR(data_naixement) >= 2000;
+-----------+------+---------+----------------+
| dni | nom | cognoms | data_naixement |
+-----------+------+---------+----------------+
| 58224076J | Rosa | Peris | 2000-10-21 |
+-----------+------+---------+----------------+
```
:::
## Registres duplicats (ALL | DISTINCT)
Les consultes poden retornar registres duplicats i podem especificar el comportament de la consulta en les següents opcions:
- `ALL`: Comportament per defecte. La consulta pot retornar files duplicades.
- `DISTINCT`: La consulta elimina les files duplicades del resultat.
::: example
- Consultem el nombre d'hores dels mòduls amb menys de 100 hores:
```sql
SELECT hores
FROM modul_professional
WHERE hores < 100;
+-------+
| hores |
+-------+
| 88 |
| 96 |
| 60 |
| 96 |
| 96 |
| 60 |
| 40 |
| 96 |
| 60 |
| 96 |
| 60 |
| 40 |
| 96 |
| 60 |
| 80 |
| 40 |
| 96 |
| 60 |
| 96 |
| 96 |
+-------+
```
- Consultem el nombre d'hores dels mòduls amb menys de 100 hores sense registres duplicats.
```sql
SELECT DISTINCT hores
FROM modul_professional
WHERE hores < 100;
+-------+
| hores |
+-------+
| 88 |
| 96 |
| 60 |
| 40 |
| 80 |
+-------+
```
:::
## ORDER BY
La clàusula `ORDER BY` permet especificar l'ordre dels resultats obtinguts en una consulta.
Per defecte, no s'aplica cap ordre en concret a la consuta.
En aquesta clàusula s'especifica un o més criteris d'ordenació.
Primer, s'ordena per el primer atribut especificat. Si hi ha un "empat", s'ordena pel següent, i així succecivament.
Es pot especificar el "sentit" de la ordenació:
- `ASC`: Ordena les dades de manera ascendent.
- `DESC`: Ordena les dades de manera descendent.
::: example
- Es consulta la informació dels mòduls professionals amb menys de 100 hores.
Els resultats s'han ordenat per nombre d'hores primer. En cas d'empat, pel nombre de crèdits descendentment.
Per últim, s'han orrdenat per l'ID del mòdul.
```sql
SELECT *
FROM modul_professional
WHERE hores < 100
ORDER BY hores ASC, ects DESC, id_modul ASC;
+----------+-------------------------------------------------------------+--------+-------+------+
| id_modul | nom | sigles | hores | ects |
+----------+-------------------------------------------------------------+--------+-------+------+
| 0379 | Projecte d'Administració de Sistemes Informàtics en Xarxa | PRJ | 40 | 5 |
| 0492 | Projecte de Desenvolupament d'Aplicacions Multiplataforma | PRJ | 40 | 5 |
| 0616 | Projecte de Desenvolupament d'Aplicacions Web | PRJ | 40 | 5 |
| 0377 | Administració de sistemes gestors de bases de dades | SGBD | 60 | 5 |
| 0490 | Programació de Serveis i Processos | PSP | 60 | 5 |
| 0230 | Empresa i Iniciativa Emprenedora | EIE | 60 | 4 |
| 0381 | Empresa i Iniciativa Emprenedora | EIE | 60 | 4 |
| 0494 | Empresa i Iniciativa Emprenedora | EIE | 60 | 4 |
| 0618 | Empresa i Iniciativa Emprenedora | EIE | 60 | 4 |
| 0614 | Desplegament d’Aplicacions Web | DPL | 80 | 5 |
| 0228 | Aplicacions Web | AW | 88 | 5 |
| 0373 | Llenguatge de marques i sistemes de gestió d'informació | LLM | 96 | 7 |
| 0371 | Fonaments de maquinari | FHW | 96 | 6 |
| 0487 | Entorns de Desenvolupament | IDE | 96 | 6 |
| CV0003 | Anglés Tècnic I-S | ATI | 96 | 6 |
| CV0004 | Anglés Tècnic II-S | ATI | 96 | 6 |
| 0229 | Formació i Orientació Laboral | FOL | 96 | 5 |
| 0380 | Formació i Orientació Laboral | FOL | 96 | 5 |
| 0493 | Formació i Orientació Laboral | FOL | 96 | 5 |
| 0617 | Formació i Orientació Laboral | FOL | 96 | 5 |
+----------+-------------------------------------------------------------+--------+-------+------+
```
:::
## Funcions d'agregació
Les funcións d'agregació s'utilitzen per realitzar operacions i fer càlculs a partir de múltiples registres.
Aquestes funcions poden ser utilitzades amb la clàusula `GROUP BY`.
Les funcions d'agregació més comunes són:
- `COUNT(A)`: Compta el nombre de registres de la columna `A`.
::: example
```sql
SELECT COUNT(nia) nombre_estudiants
FROM estudiant;
+-------------------+
| nombre_estudiants |
+-------------------+
| 40 |
+-------------------+
```
:::
- `MIN(A)`: Retorna el valor mínim dels registres de la columna `A`.
::: example
```sql
SELECT MIN(YEAR(data_naixement))
FROM persona;
+---------------------------+
| MIN(YEAR(data_naixement)) |
+---------------------------+
| 1974 |
+---------------------------+
```
:::
- `MAX(A)`: Retorna el valor màxim dels registres de la columna `A`.
::: example
```sql
SELECT MAX(YEAR(data_naixement))
FROM persona;
+---------------------------+
| MAX(YEAR(data_naixement)) |
+---------------------------+
| 2002 |
+---------------------------+
```
:::
- `SUM(A)`: Retorna la suma dels valors dels registres de la columna `A`.
::: example
```sql
SELECT SUM(hores)
FROM modul_professional;
+------------+
| sum(hores) |
+------------+
| 6806 |
+------------+
```
:::
- `AVG(A)`: Retorna la mitjana aritmètica dels valors dels registres de la columna `A`.
::: example
```sql
SELECT ROUND(AVG(hores), 2)
FROM modul_professional;
+---------------------+
| ROUND(AVG(hores),2) |
+---------------------+
| 141.79 |
+---------------------+
```
:::
- `DISTINCT(A)`: Retorna els valors no repetits dels registres de la columna `A`.
::: example
```sql
SELECT DISTINCT(hores)
FROM modul_professional
ORDER BY hores;
+-------+
| hores |
+-------+
| 40 |
| 60 |
| 80 |
| 88 |
| 96 |
| 100 |
| 110 |
| 120 |
| 128 |
| 140 |
| 160 |
| 176 |
| 192 |
| 224 |
| 256 |
| 380 |
| 400 |
+-------+
```
:::