Resumen: en este tutorial vas a aprender a redondear números en SQL.

Te mostraré a redondear hacia arriba, hacia abajo o redondear dependiendo de los decimales; usando la función round, floor y ceil / ceiling.

Nota: los ejemplos funcionan en MySQL, MariaDB y en SQL Server.

Redondear con función round

La función round en SQL permite indicar el número que se quiere redondear, y la cantidad de decimales que se desea tener en el resultado.

Su sintaxis es:

round(numero, cantidad_de_decimales);

Saltemos al ejemplo para explicarlo de mejor manera:

El segundo argumento es el número de decimales que queremos al final; si lo especificamos en 0 entonces dejará un número entero.

Redondeo con decimales negativos

También se puede redondear en SQL usando la función round, indicando el número de decimales como negativo.

Si el segundo argumento de round es negativo, esa cantidad de cifras a la izquierda del punto serán convertidas en ceros.

Veamos un ejemplo:

MariaDB [(none)]> select round(12.78, -1);
+------------------+
| round(12.78, -1) |
+------------------+
|               10 |
+------------------+
1 row in set (0.05 sec)

MariaDB [(none)]> select round(12.78, -2);
+------------------+
| round(12.78, -2) |
+------------------+
|                0 |
+------------------+
1 row in set (0.00 sec)

Criterio de redondeo de floor

Cuando redondeamos números en SQL usando floor, el resultado depende de un criterio.

Esta función se basa en la parte decimal; si es mayor o igual a la mitad entonces se redondea hacia arriba.

Si no, se redondea hacia abajo; lo que queda comprobado con los siguientes ejemplos:

MariaDB [(none)]> select round(12.5, 0);
+----------------+
| round(12.5, 0) |
+----------------+
|             13 |
+----------------+
1 row in set (0.00 sec)

MariaDB [(none)]> select round(12.4, 0);
+----------------+
| round(12.4, 0) |
+----------------+
|             12 |
+----------------+
1 row in set (0.00 sec)

Recuerda que por ejemplo 0.1, 0.4999, 0.4484818, 0.25815 van hacia abajo, y 0.5, 0.50001, 0.9 van hacia arriba.

Función floor

Otra función que sirve para redondear en SQL Server y MySQL es la función floor.

La función floor es como round, pero el resultado es un entero, y el redondeo lo hace hacia abajo. Es decir, no importa si la parte decimal es .99, .51, .70 van hacia abajo.

La sintaxis es:

floor(numero);

Es mejor con ejemplos:

MariaDB [(none)]> select floor(0.3);
+------------+
| floor(0.3) |
+------------+
|          0 |
+------------+
1 row in set (0.11 sec)

MariaDB [(none)]> select floor(1.3);
+------------+
| floor(1.3) |
+------------+
|          1 |
+------------+
1 row in set (0.00 sec)

MariaDB [(none)]> select floor(1.9);
+------------+
| floor(1.9) |
+------------+
|          1 |
+------------+
1 row in set (0.00 sec)

MariaDB [(none)]> select floor(165.55);
+---------------+
| floor(165.55) |
+---------------+
|           165 |
+---------------+
1 row in set (0.00 sec)

MariaDB [(none)]> select floor(200.5);
+--------------+
| floor(200.5) |
+--------------+
|          200 |
+--------------+
1 row in set (0.00 sec)

MariaDB [(none)]> select floor(200.4);
+--------------+
| floor(200.4) |
+--------------+
|          200 |
+--------------+
1 row in set (0.00 sec)

Función ceil y ceiling

La última función que redondea números en MariaDB y SQL Server es llamada ceiling, aunque tiene “alias” como ceil.

Finalmente veamos dos funciones para redondear hacia arriba. En MySQL y MariaDB esta función está disponible como ceil y ceiling.

En cambio, en SQL Server está como ceiling únicamente.

La función se comporta de manera contraria a floor, y es que redondea a un número hacia arriba, produciendo un entero.

Sintaxis:

ceiling(numero);

Veamos ejemplos:

MariaDB [(none)]> select ceiling(200.4);
+----------------+
| ceiling(200.4) |
+----------------+
|            201 |
+----------------+
1 row in set (0.04 sec)

MariaDB [(none)]> select ceiling(1.9);
+--------------+
| ceiling(1.9) |
+--------------+
|            2 |
+--------------+
1 row in set (0.00 sec)

MariaDB [(none)]> select ceiling(28.11);
+----------------+
| ceiling(28.11) |
+----------------+
|             29 |
+----------------+
1 row in set (0.00 sec)

MariaDB [(none)]> select ceiling(28.00001);
+-------------------+
| ceiling(28.00001) |
+-------------------+
|                29 |
+-------------------+
1 row in set (0.00 sec)

MariaDB [(none)]> select ceiling(0.0001);
+-----------------+
| ceiling(0.0001) |
+-----------------+
|               1 |
+-----------------+
1 row in set (0.00 sec)

MariaDB [(none)]> select ceiling(0);
+------------+
| ceiling(0) |
+------------+
|          0 |
+------------+
1 row in set (0.00 sec)

Conclusión

Así es como puedes redondear números en SQL, ya sea hacia arriba, hacia abajo o tomando en cuenta la parte decimal.