12.4. Funciones numéricas

MySQL 5.0

previous page next page

12.4. Funciones numéricas

12.4.1. Operadores aritméticos

Los operadores aritméticos usuales están disponibles. Tenga en cuenta que en el caso de -, +, y *, el resultado se calcula con precisión BIGINT (64-bit) si ambos argumentos son enteros. Si uno de los argumentos es un entero sin signo, y los otros argumentos son también enteros, el resultado es un entero sin signo. Consulte Sección 12.8, “Funciones y operadores de cast”.

+

Suma:
```
mysql> SELECT 3+5;
        -> 8
```
-

Resta:
```
mysql> SELECT 3-5;
        -> -2
```
-

Menos unario. Cambia el signo del argumento.
```
mysql> SELECT - 2;
        -> -2
```
Nota: Si este operador se usa con BIGINT, el valor de retorno es también BIGINT. Esto significa que debe eliminar usar - con enteros que pueden ser iguales o menores a -2^63.
*

Multiplicación:
```
mysql> SELECT 3*5;
        -> 15
mysql> SELECT 18014398509481984*18014398509481984.0;
        -> 324518553658426726783156020576256.0
mysql> SELECT 18014398509481984*18014398509481984;
        -> 0
```
El resultado de la última expresión es incorrecto ya que el resultado de la multiplicación entera excede el rango de 64-bit de cálculos BIGINT. (Consulte Sección 11.2, “Tipos numéricos”.)
/

División:
```
mysql> SELECT 3/5;
        -> 0.60
```
División por cero produce un resultado NULL:
```
mysql> SELECT 102/(1-1);
        -> NULL
```
Una división se calcula con aritmética BIGINT sólo en un contexto donde el resultado se convierte a entero.
DIV

División entera. Similar aFLOOR() pero funciona con valores BIGINT.
```
mysql> SELECT 5 DIV 2;
        -> 2
```

12.4.2. Funciones matemáticas

Todas las funciones matemáticas retornan NULL en caso de error.

ABS(X)

Retorna el valor absoluto de X.

mysql> SELECT ABS(2); -> 2 mysql> SELECT ABS(-32); -> 32

Esta función puede usar valores BIGINT.

ACOS(X)

Retorna el arcocoseno de X, esto es, el valor cuyo coseno es X. Retorna NULL si X no está en el rango -1 a 1.

mysql> SELECT ACOS(1); -> 0 mysql> SELECT ACOS(1.0001); -> NULL mysql> SELECT ACOS(0); -> 1.5707963267949

ASIN(X)

Retorna el arcoseno de X, esto es, el valor cuyo seno es X. Retorna NULL si X no está en el rango de -1 a 1.

mysql> SELECT ASIN(0.2); -> 0.20135792079033 mysql> SELECT ASIN('foo'); -> 0

ATAN(X)

Retorna la arcotangente de X, esto es, el valor cuya tangente es X.

mysql> SELECT ATAN(2); -> 1.1071487177941 mysql> SELECT ATAN(-2); -> -1.1071487177941

ATAN(Y,X) , ATAN2(Y,X)

Retorna la arcotangente de las variables X y Y. Es similar a calcular la arcotangente de Y / X, excepto que los signos de ambos argumentos se usan para determinar el cuadrante del resultado.

mysql> SELECT ATAN(-2,2); -> -0.78539816339745 mysql> SELECT ATAN2(PI(),0); -> 1.5707963267949

CEILING(X), CEIL(X)

Retorna el entero más pequeño no menor a X.

mysql> SELECT CEILING(1.23); -> 2 mysql> SELECT CEIL(-1.23); -> -1

Estas dos funciones son sinónimos. Tenga en cuenta que el valor retornado se convierte a BIGINT.

COS(X)

Retorna el coseno de X, donde X se da en radianes.

mysql> SELECT COS(PI()); -> -1

COT(X)

Retorna la cotangente de X.

mysql> SELECT COT(12); -> -1.5726734063977 mysql> SELECT COT(0); -> NULL

CRC32(expr)

Computa un valor de redundancia cíclica y retorna el valor sin signo de 32 bits. El resultado es NULL si el argumento es NULL. Se espera que el argumento sea una cadena y (si es posible) se trata como una si no lo es.

mysql> SELECT CRC32('MySQL'); -> 3259397556 mysql> SELECT CRC32('mysql'); -> 2501908538

DEGREES(X)

Retorna el argumento X, convertido de radianes a grados.

mysql> SELECT DEGREES(PI()); -> 180 mysql> SELECT DEGREES(PI() / 2); -> 90

EXP(X)

Retorna el valor de e (la base del logaritmo natural) a la potencia de X.

mysql> SELECT EXP(2); -> 7.3890560989307 mysql> SELECT EXP(-2); -> 0.13533528323661

FLOOR(X)

Retorna el valor entero más grande pero no mayor a X.

mysql> SELECT FLOOR(1.23); -> 1 mysql> SELECT FLOOR(-1.23); -> -2

Tenga en cuenta que el valor devuelto se convierte a BIGINT.

LN(X)

Retorna el logaritmo natural de X, esto es, el logaritmo de X base e.

mysql> SELECT LN(2); -> 0.69314718055995 mysql> SELECT LN(-2); -> NULL

Esta función es sinónimo a LOG(X).

LOG(X), LOG(B,X)

Si se llama con un parámetro, esta función retorna el logaritmo natural de X.

mysql> SELECT LOG(2); -> 0.69314718055995 mysql> SELECT LOG(-2); -> NULL

Si se llama con dos parámetros, esta función retorna el logaritmo de X para una base arbitrária B.

mysql> SELECT LOG(2,65536); -> 16 mysql> SELECT LOG(10,100); -> 2

LOG(B,X) es equivalente a LOG(X) / LOG(B).

LOG2(X)

Retorna el logaritmo en base 2 de X.

mysql> SELECT LOG2(65536); -> 16 mysql> SELECT LOG2(-100); -> NULL

LOG2() es útil para encontrar cuántos bits necesita un número para almacenamiento. Esta función es equivalente a la expresión LOG(X) / LOG(2).

LOG10(X)

Retorna el logaritmo en base 10 de X.

mysql> SELECT LOG10(2); -> 0.30102999566398 mysql> SELECT LOG10(100); -> 2 mysql> SELECT LOG10(-100); -> NULL

LOG10(X) es equivalente a LOG(10,X).

MOD(N,M) , N % M, N MOD M

Operación de módulo. Retorna el resto de N dividido por M.

mysql> SELECT MOD(234, 10); -> 4 mysql> SELECT 253 % 7; -> 1 mysql> SELECT MOD(29,9); -> 2 mysql> SELECT 29 MOD 9; -> 2

Esta función puede usar valores BIGINT.

MOD() también funciona con valores con una parte fraccional y retorna el resto exacto tras la división:

mysql> SELECT MOD(34.5,3); -> 1.5

PI()

Retorna el valor de π (pi). El número de decimales que se muestra por defecto es siete, pero MySQL usa internamente el valor de doble precisión entero.

mysql> SELECT PI(); -> 3.141593 mysql> SELECT PI()+0.000000000000000000; -> 3.141592653589793116

POW(X,Y) , POWER(X,Y)

Retorna el valor de X a la potencia de Y.

mysql> SELECT POW(2,2); -> 4 mysql> SELECT POW(2,-2); -> 0.25

RADIANS(X)

Retorna el argumento X, convertido de grados a radianes. (Tenga en cuenta que π radianes son 180 grados.)

mysql> SELECT RADIANS(90); -> 1.5707963267949

RAND(), RAND(N)

Retorna un valor aleatorio en coma flotante del rango de 0 a 1.0. Si se especifica un argumento entero N, es usa como semilla, que produce una secuencia repetible.

mysql> SELECT RAND(); -> 0.9233482386203 mysql> SELECT RAND(20); -> 0.15888261251047 mysql> SELECT RAND(); -> 0.63553050033332 mysql> SELECT RAND(); -> 0.70100469486881 mysql> SELECT RAND(20); -> 0.15888261251047

Puede usar esta función para recibir registros de forma aleatoria como se muestra aquí:

mysql> SELECT * FROM tbl_name ORDER BY RAND();

ORDER BY RAND() combinado con LIMIT es útil para seleccionar una muestra aleatoria de una conjunto de registros:

mysql> SELECT * FROM table1, table2 WHERE a=b AND c<d -> ORDER BY RAND() LIMIT 1000;

Tenga en cuenta que RAND() en una cláusula WHERE se re-evalúa cada vez que se ejecuta el WHERE.

RAND() no pretende ser un generador de números aleatorios perfecto, pero es una forma rápida de generar números aleatorios ad hoc portable entre plataformas para la misma versión de MySQL.

ROUND(X), ROUND(X,D)

Retorna el argumento X, redondeado al entero más cercano. Con dos argumentos, retorna X redondeado a D decimales. D puede ser negativo para redondear D dígitos a la izquierda del punto decimal del valor X.

mysql> SELECT ROUND(-1.23); -> -1 mysql> SELECT ROUND(-1.58); -> -2 mysql> SELECT ROUND(1.58); -> 2 mysql> SELECT ROUND(1.298, 1); -> 1.3 mysql> SELECT ROUND(1.298, 0); -> 1 mysql> SELECT ROUND(23.298, -1); -> 20

El tipo de retorno es el mismo tipo que el del primer argumento (asumiendo que sea un entero, doble o decimal). Esto significa que para un argumento entero, el resultado es un entero (sin decimales).

Antes de MySQL 5.0.3, el comportamiento de ROUND() cuando el argumento se encuentra a medias entre dos enteros depende de la implementación de la biblioteca C. Implementaciones distintas redondean al número par más próximo, siempre arriba, siempre abajo, o siempre hacia cero. Si necesita un tipo de redondeo, debe usar una función bien definida como TRUNCATE() o FLOOR() en su lugar.

Desde MySQL 5.0.3, ROUND() usa la biblioteca de matemática precisa para valores exactos cuando el primer argumento es un valor con decimales:

Para números exactos, ROUND() usa la regla de "redondea la mitad hacia arriba": Un valor con una parte fracional de .5 o mayor se redondea arriba al siguiente entero si es positivo o hacia abajo si el siguiente entero es negativo. (En otras palabras, se redondea en dirección contraria al cero.) Un valor con una parte fraccional menor a .5 se redondea hacia abajo al siguiente entero si es positivo o hacia arriba si el siguiente entero es negativo.

Para números aproximados, el resultado depende de la biblioteca C. En muchos sistemas, esto significa que ROUND() usa la regla de "redondeo al número par más cercano": Un valor con una parte fraccional se redondea al entero más cercano.

El siguiente ejemplo muestra cómo el redondeo difiere para valores exactos y aproximados:

mysql> SELECT ROUND(2.5), ROUND(25E-1); +------------+--------------+ | ROUND(2.5) | ROUND(25E-1) | +------------+--------------+ | 3 | 2 | +------------+--------------+

Para más información, consulte Capítulo 23, Matemáticas de precisión.

SIGN(X)

Retorna el signo del argumento como -1, 0, o 1, en función de si X es negativo, cero o positivo.

mysql> SELECT SIGN(-32); -> -1 mysql> SELECT SIGN(0); -> 0 mysql> SELECT SIGN(234); -> 1

SIN(X)

Retorna el seno de X, donde X se da en radianes.

mysql> SELECT SIN(PI()); -> 1.2246063538224e-16 mysql> SELECT ROUND(SIN(PI())); -> 0

SQRT(X)

Retorna la raíz cuadrada de un número no negativo. X.

mysql> SELECT SQRT(4); -> 2 mysql> SELECT SQRT(20); -> 4.4721359549996 mysql> SELECT SQRT(-16); -> NULL

TAN(X)

Retorna la tangente de X, donde X se da en radianes.

mysql> SELECT TAN(PI()); -> -1.2246063538224e-16 mysql> SELECT TAN(PI()+1); -> 1.5574077246549

TRUNCATE(X,D)

Retorna el número X, truncado a D decimales. Si D es 0, el resultado no tiene punto decimal o parte fraccional. D puede ser negativo para truncar (hacer cero) D dígitos a la izquierda del punto decimal del valor X.

mysql> SELECT TRUNCATE(1.223,1); -> 1.2 mysql> SELECT TRUNCATE(1.999,1); -> 1.9 mysql> SELECT TRUNCATE(1.999,0); -> 1 mysql> SELECT TRUNCATE(-1.999,1); -> -1.9 mysql> SELECT TRUNCATE(122,-2); -> 100

Todos los números se redondean hacia cero.

previous page start next page