SQL - Funciones numéricas
Las funciones numéricas SQL se utilizan principalmente para la manipulación numérica y / o cálculos matemáticos. La siguiente tabla detalla las funciones numéricas:
| No Señor. | Función descriptiva |
|---|---|
| 1 | ABDOMINALES() Devuelve el valor absoluto de la expresión numérica. |
| 2 | ACOS () Devuelve el arcocoseno de una expresión numérica. Devuelve NULL si el valor no está en el rango de -1 a 1. |
| 3 | COMO EN() Devuelve el arcoseno de la expresión numérica. Devuelve NULL si el valor no está en el rango de -1 a 1 |
| 4 | UN BRONCEADO() Devuelve el arcotangente de la expresión numérica. |
| 5 | ATAN2 () Devuelve el arcotangente de las dos variables que se le pasan. |
| 6 | BIT_AND () Devuelve el bit a bit Y todos los bits en expresión. |
| 7 | BIT_COUNT () Devuelve la representación de cadena del valor binario que se le pasa. |
| 8 | BIT_OR () Devuelve el OR bit a bit de todos los bits en la expresión pasada. |
| 9 | HACER TECHO() Devuelve el valor entero más pequeño que no es menor que la expresión numérica pasada |
| 10 | TECHO() Devuelve el valor entero más pequeño que no es menor que la expresión numérica pasada |
| 11 | CONV () Convierte expresiones numéricas de una base a otra. |
| 12 | COS () Devuelve el coseno de la expresión numérica pasada. La expresión numérica debe expresarse en radianes. |
| 13 | CUNA() Devuelve la cotangente de la expresión numérica pasada. |
| 14 | GRADOS () Devuelve una expresión numérica convertida de radianes a grados. |
| 15 | EXP() Devuelve la base del logaritmo natural (e) elevado a la potencia de la expresión numérica pasada. |
| dieciséis | SUELO() Devuelve el valor entero más grande que no es mayor que la expresión numérica pasada. |
| 17 | FORMATO() Devuelve una expresión numérica redondeada a varios lugares decimales. |
| 18 | MEJOR () Devuelve el valor más grande de las expresiones de entrada. |
| 19 | INTERVALO() Toma múltiples expresiones exp1, exp2 y exp3, etc. y devuelve 0 si exp1 es menor que exp2, devuelve 1 si exp1 es menor que exp3 y así sucesivamente. |
| 20 | MENOS() Devuelve la entrada de valor mínimo cuando se le dan dos o más. |
| 21 | INICIAR SESIÓN() Devuelve el logaritmo natural de la expresión numérica pasada. |
| 22 | LOG10 () Devuelve el logaritmo en base 10 de la expresión numérica pasada. |
| 23 | MODIFICACIÓN() Devuelve el resto de una expresión buceando por otra expresión. |
| 24 | OCT() Devuelve la representación de cadena del valor octal de la expresión numérica pasada. Devuelve NULL si el valor pasado es NULL. |
| 25 | PI() Devuelve el valor de pi |
| 26 | POW () Devuelve el valor de una expresión elevado a la potencia de otra expresión |
| 27 | PODER() Devuelve el valor de una expresión elevado a la potencia de otra expresión |
| 28 | RADIANOS () Devuelve el valor de la expresión pasada convertida de grados a radianes. |
| 29 | REDONDO() Devuelve una expresión numérica redondeada a un número entero. Puede usarse para redondear una expresión a varios puntos decimales |
| 30 | PECADO() Devuelve el seno de una expresión numérica expresada en radianes. |
| 31 | SQRT () Devuelve la raíz cuadrada no negativa de una expresión numérica. |
| 32 | STD () Devuelve la desviación estándar de la expresión numérica. |
| 33 | STDDEV () Devuelve la desviación estándar de la expresión numérica. |
| 34 | BRONCEARSE() Devuelve la tangente de la expresión numérica expresada en radianes. |
| 35 | TRUNCAR() Devuelve exp1 numérico truncado a exp2 decimales. Si exp2 es 0, el resultado no tendrá punto decimal. |
ABS (X)
La función ABS () devuelve el valor absoluto de X. Considere el siguiente ejemplo:
SQL> SELECT ABS(2);
+---------------------------------------------------------+
| ABS(2) |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT ABS(-2);
+---------------------------------------------------------+
| ABS(2) |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ACOS (X)
Esta función devuelve el arcocoseno de X. El valor de X debe oscilar entre -1 y 1 o se devolverá NULL. Considere el siguiente ejemplo:
SQL> SELECT ACOS(1);
+---------------------------------------------------------+
| ACOS(1) |
+---------------------------------------------------------+
| 0.000000 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ASIN (X)
La función ASIN () devuelve el arcoseno de X. El valor de X debe estar en el rango de -1 a 1 o se devuelve NULL.
SQL> SELECT ASIN(1);
+---------------------------------------------------------+
| ASIN(1) |
+---------------------------------------------------------+
| 1.5707963267949 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ATAN (X)
Esta función devuelve el arcotangente de X.
SQL> SELECT ATAN(1);
+---------------------------------------------------------+
| ATAN(1) |
+---------------------------------------------------------+
| 0.78539816339745 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ATAN2 (Y, X)
Esta función devuelve el arcotangente de los dos argumentos: X e Y. Es similar al arcangente de Y / X, excepto que los signos de ambos se utilizan para encontrar el cuadrante del resultado.
SQL> SELECT ATAN2(3,6);
+---------------------------------------------------------+
| ATAN2(3,6) |
+---------------------------------------------------------+
| 0.46364760900081 |
+---------------------------------------------------------+
1 row in set (0.00 sec)BIT_AND (expresión)
La función BIT_AND devuelve el AND bit a bit de todos los bits de la expresión. La premisa básica es que si dos bits correspondientes son iguales, entonces una operación AND bit a bit devolverá 1, mientras que si son diferentes, una operación AND bit a bit devolverá 0. La función en sí misma devolverá un valor entero de 64 bits. Si no hay coincidencias, devolverá 18446744073709551615. El siguiente ejemplo realiza la función BIT_AND en la columna PRECIO agrupada por el FABRICANTE del automóvil:
SQL> SELECT
MAKER, BIT_AND(PRICE) BITS
FROM CARS GROUP BY MAKER
+---------------------------------------------------------+
|MAKER BITS |
+---------------------------------------------------------+
|CHRYSLER 512 |
|FORD 12488 |
|HONDA 2144 |
+---------------------------------------------------------+
1 row in set (0.00 sec)BIT_COUNT (valor_numérico)
La función BIT_COUNT () devuelve el número de bits que están activos en numeric_value. El siguiente ejemplo demuestra el uso de la función BIT_COUNT () para devolver el número de bits activos para un rango de números:
SQL> SELECT
BIT_COUNT(2) AS TWO,
BIT_COUNT(4) AS FOUR,
BIT_COUNT(7) AS SEVEN
+-----+------+-------+
| TWO | FOUR | SEVEN |
+-----+------+-------+
| 1 | 1 | 3 |
+-----+------+-------+
1 row in set (0.00 sec)BIT_OR (expresión)
La función BIT_OR () devuelve el OR bit a bit de todos los bits de la expresión. La premisa básica de la función OR bit a bit es que devuelve 0 si los bits correspondientes coinciden y 1 si no. La función devuelve un entero de 64 bits y, si no hay filas coincidentes, devuelve 0. El siguiente ejemplo realiza la función BIT_OR () en la columna PRECIO de la tabla CARS, agrupada por FABRICANTE:
SQL> SELECT
MAKER, BIT_OR(PRICE) BITS
FROM CARS GROUP BY MAKER
+---------------------------------------------------------+
|MAKER BITS |
+---------------------------------------------------------+
|CHRYSLER 62293 |
|FORD 16127 |
|HONDA 32766 |
+---------------------------------------------------------+
1 row in set (0.00 sec)TECHO (X)
TECHO (X)
Estas funciones devuelven el valor entero más pequeño que no es menor que X. Considere el siguiente ejemplo:
SQL> SELECT CEILING(3.46);
+---------------------------------------------------------+
| CEILING(3.46) |
+---------------------------------------------------------+
| 4 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL> SELECT CEIL(-6.43);
+---------------------------------------------------------+
| CEIL(-6.43) |
+---------------------------------------------------------+
| -6 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CONV (N, from_base, to_base)
El propósito de la función CONV () es convertir números entre diferentes bases numéricas. La función devuelve una cadena del valor N convertido de from_base a to_base. El valor base mínimo es 2 y el máximo es 36. Si alguno de los argumentos es NULL, la función devuelve NULL. Considere el siguiente ejemplo, que convierte el número 5 de base 16 a base 2 -
SQL> SELECT CONV(5,16,2);
+---------------------------------------------------------+
| CONV(5,16,2) |
+---------------------------------------------------------+
| 101 |
+---------------------------------------------------------+
1 row in set (0.00 sec)COS (X)
Esta función devuelve el coseno de X. El valor de X se da en radianes.
SQL>SELECT COS(90);
+---------------------------------------------------------+
| COS(90) |
+---------------------------------------------------------+
| -0.44807361612917 |
+---------------------------------------------------------+
1 row in set (0.00 sec)CUNA (X)
Esta función devuelve la cotangente de X. Considere el siguiente ejemplo:
SQL>SELECT COT(1);
+---------------------------------------------------------+
| COT(1) |
+---------------------------------------------------------+
| 0.64209261593433 |
+---------------------------------------------------------+
1 row in set (0.00 sec)GRADOS (X)
Esta función devuelve el valor de X convertido de radianes a grados.
SQL>SELECT DEGREES(PI());
+---------------------------------------------------------+
| DEGREES(PI()) |
+---------------------------------------------------------+
| 180.000000 |
+---------------------------------------------------------+
1 row in set (0.00 sec)EXP (X)
Esta función devuelve el valor de e (la base del logaritmo natural) elevado a la potencia de X.
SQL>SELECT EXP(3);
+---------------------------------------------------------+
| EXP(3) |
+---------------------------------------------------------+
| 20.085537 |
+---------------------------------------------------------+
1 row in set (0.00 sec)PISO (X)
Esta función devuelve el valor entero más grande que no es mayor que X.
SQL>SELECT FLOOR(7.55);
+---------------------------------------------------------+
| FLOOR(7.55) |
+---------------------------------------------------------+
| 7 |
+---------------------------------------------------------+
1 row in set (0.00 sec)FORMATO (X, D)
La función FORMAT () se utiliza para formatear el número X en el siguiente formato: ###, ###, ###. ## truncado a D lugares decimales. El siguiente ejemplo demuestra el uso y la salida de la función FORMAT ():
SQL>SELECT FORMAT(423423234.65434453,2);
+---------------------------------------------------------+
| FORMAT(423423234.65434453,2) |
+---------------------------------------------------------+
| 423,423,234.65 |
+---------------------------------------------------------+
1 row in set (0.00 sec)MÁS GRANDE (n1, n2, n3, ..........)
La función MAYOR () devuelve el mayor valor en el conjunto de parámetros de entrada (n1, n2, n3, y así sucesivamente). El siguiente ejemplo usa la función MÁS GRANDE () para devolver el número más grande de un conjunto de valores numéricos:
SQL>SELECT GREATEST(3,5,1,8,33,99,34,55,67,43);
+---------------------------------------------------------+
| GREATEST(3,5,1,8,33,99,34,55,67,43) |
+---------------------------------------------------------+
| 99 |
+---------------------------------------------------------+
1 row in set (0.00 sec)INTERVALO (N, N1, N2, N3, ..........)
La función INTERVAL () compara el valor de N con la lista de valores (N1, N2, N3, etc.). La función devuelve 0 si N <N1, 1 si N <N2, 2 si N <N3, y así sucesivamente. Devolverá .1 si N es NULL. La lista de valores debe tener el formato N1 <N2 <N3 para que funcione correctamente. El siguiente código es un ejemplo simple de cómo funciona la función INTERVAL ():
SQL>SELECT INTERVAL(6,1,2,3,4,5,6,7,8,9,10);
+---------------------------------------------------------+
| INTERVAL(6,1,2,3,4,5,6,7,8,9,10) |
+---------------------------------------------------------+
| 6 |
+---------------------------------------------------------+
1 row in set (0.00 sec)INTERVALO (N, N1, N2, N3, ..........)
La función INTERVAL () compara el valor de N con la lista de valores (N1, N2, N3, etc.). La función devuelve 0 si N <N1, 1 si N <N2, 2 si N <N3, y así sucesivamente. Devolverá .1 si N es NULL. La lista de valores debe tener el formato N1 <N2 <N3 para que funcione correctamente. El siguiente código es un ejemplo simple de cómo funciona la función INTERVAL ():
SQL>SELECT INTERVAL(6,1,2,3,4,5,6,7,8,9,10);
+---------------------------------------------------------+
| INTERVAL(6,1,2,3,4,5,6,7,8,9,10) |
+---------------------------------------------------------+
| 6 |
+---------------------------------------------------------+
1 row in set (0.00 sec)Recuerde que 6 es el índice de base cero en la lista de valores del primer valor que fue mayor que N. En nuestro caso, 7 fue el valor ofensivo y está ubicado en la sexta ranura del índice.
MENOS (N1, N2, N3, N4, ......)
La función MENOS () es lo opuesto a la función MÁS GRANDE (). Su propósito es devolver el elemento de menor valor de la lista de valores (N1, N2, N3, etc.). El siguiente ejemplo muestra el uso y la salida adecuados para la función MENOS ():
SQL>SELECT LEAST(3,5,1,8,33,99,34,55,67,43);
+---------------------------------------------------------+
| LEAST(3,5,1,8,33,99,34,55,67,43) |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)REGISTRO (X)
REGISTRO (B, X)
La versión de un solo argumento de la función devolverá el logaritmo natural de X. Si se llama con dos argumentos, devuelve el logaritmo de X para una base B arbitraria. Considere el siguiente ejemplo:
SQL>SELECT LOG(45);
+---------------------------------------------------------+
| LOG(45) |
+---------------------------------------------------------+
| 3.806662 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL>SELECT LOG(2,65536);
+---------------------------------------------------------+
| LOG(2,65536) |
+---------------------------------------------------------+
| 16.000000 |
+---------------------------------------------------------+
1 row in set (0.00 sec)LOG10 (X)
Esta función devuelve el logaritmo en base 10 de X.
SQL>SELECT LOG10(100);
+---------------------------------------------------------+
| LOG10(100) |
+---------------------------------------------------------+
| 2.000000 |
+---------------------------------------------------------+
1 row in set (0.00 sec)MOD (N, M)
Esta función devuelve el resto de N dividido por M. Considere el siguiente ejemplo:
SQL>SELECT MOD(29,3);
+---------------------------------------------------------+
| MOD(29,3) |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)OCT (N)
La función OCT () devuelve la representación de cadena del número octal N. Esto es equivalente a usar CONV (N, 10,8).
SQL>SELECT OCT(12);
+---------------------------------------------------------+
| OCT(12) |
+---------------------------------------------------------+
| 14 |
+---------------------------------------------------------+
1 row in set (0.00 sec)PI()
Esta función simplemente devuelve el valor de pi. SQL almacena internamente el valor completo de doble precisión de pi.
SQL>SELECT PI();
+---------------------------------------------------------+
| PI() |
+---------------------------------------------------------+
| 3.141593 |
+---------------------------------------------------------+
1 row in set (0.00 sec)POW (X, Y)
POTENCIA (X, Y)
Estas dos funciones devuelven el valor de X elevado a la potencia de Y.
SQL> SELECT POWER(3,3);
+---------------------------------------------------------+
| POWER(3,3) |
+---------------------------------------------------------+
| 27 |
+---------------------------------------------------------+
1 row in set (0.00 sec)RADIANOS (X)
Esta función devuelve el valor de X, convertido de grados a radianes.
SQL>SELECT RADIANS(90);
+---------------------------------------------------------+
| RADIANS(90) |
+---------------------------------------------------------+
|1.570796 |
+---------------------------------------------------------+
1 row in set (0.00 sec)REDONDO (X)
REDONDO (X, D)
Esta función devuelve X redondeado al número entero más cercano. Si se proporciona un segundo argumento, D, la función devuelve X redondeado a D lugares decimales. D debe ser positivo o se eliminarán todos los dígitos a la derecha del punto decimal. Considere el siguiente ejemplo:
SQL>SELECT ROUND(5.693893);
+---------------------------------------------------------+
| ROUND(5.693893) |
+---------------------------------------------------------+
| 6 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL>SELECT ROUND(5.693893,2);
+---------------------------------------------------------+
| ROUND(5.693893,2) |
+---------------------------------------------------------+
| 5.69 |
+---------------------------------------------------------+
1 row in set (0.00 sec)FIRMA (X)
Esta función devuelve el signo de X (negativo, cero o positivo) como -1, 0 o 1.
SQL>SELECT SIGN(-4.65);
+---------------------------------------------------------+
| SIGN(-4.65) |
+---------------------------------------------------------+
| -1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL>SELECT SIGN(0);
+---------------------------------------------------------+
| SIGN(0) |
+---------------------------------------------------------+
| 0 |
+---------------------------------------------------------+
1 row in set (0.00 sec)
SQL>SELECT SIGN(4.65);
+---------------------------------------------------------+
| SIGN(4.65) |
+---------------------------------------------------------+
| 1 |
+---------------------------------------------------------+
1 row in set (0.00 sec)PECADO (X)
Esta función devuelve el seno de X. Considere el siguiente ejemplo:
SQL>SELECT SIN(90);
+---------------------------------------------------------+
| SIN(90) |
+---------------------------------------------------------+
| 0.893997 |
+---------------------------------------------------------+
1 row in set (0.00 sec)SQRT (X)
Esta función devuelve la raíz cuadrada no negativa de X. Considere el siguiente ejemplo:
SQL>SELECT SQRT(49);
+---------------------------------------------------------+
| SQRT(49) |
+---------------------------------------------------------+
| 7 |
+---------------------------------------------------------+
1 row in set (0.00 sec)STD (expresión)
STDDEV (expresión)
La función STD () se usa para devolver la desviación estándar de expresión. Esto es equivalente a sacar la raíz cuadrada de VARIANCE () de expresión. El siguiente ejemplo calcula la desviación estándar de la columna PRECIO en nuestra tabla CARS:
SQL>SELECT STD(PRICE) STD_DEVIATION FROM CARS;
+---------------------------------------------------------+
| STD_DEVIATION |
+---------------------------------------------------------+
| 7650.2146 |
+---------------------------------------------------------+
1 row in set (0.00 sec)TAN (X)
Esta función devuelve la tangente del argumento X, que se expresa en radianes.
SQL>SELECT TAN(45);
+---------------------------------------------------------+
| TAN(45) |
+---------------------------------------------------------+
| 1.619775 |
+---------------------------------------------------------+
1 row in set (0.00 sec)TRUNCATE (X, D)
Esta función se utiliza para devolver el valor de X truncado al número D de decimales. Si D es 0, se elimina el punto decimal. Si D es negativo, entonces D número de valores en la parte entera del valor se trunca. Considere el siguiente ejemplo:
SQL>SELECT TRUNCATE(7.536432,2);
+---------------------------------------------------------+
| TRUNCATE(7.536432,2) |
+---------------------------------------------------------+
| 7.53 |
+---------------------------------------------------------+
1 row in set (0.00 sec)