SQL estándar de Google para BigQuery es compatible con las funciones matemáticas. Todas las funciones matemáticas tienen los siguientes comportamientos:
- Muestran
NULL
si alguno de los parámetros de entrada esNULL
. - Muestran
NaN
si alguno de los argumentos esNaN
.
ABS
ABS(X)
Descripción
Calcula el valor absoluto. Muestra un error si el argumento es un número entero y el valor de resultado no se puede representar como el mismo tipo; esto sucede solo para el valor de entrada negativo más grande, que no tiene una representación positiva.
X | ABS(X) |
---|---|
25 | 25 |
-25 | 25 |
+inf |
+inf |
-inf |
+inf |
Tipo de datos mostrados
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
OUTPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
SIGN
SIGN(X)
Descripción
Muestra -1
0
o +1
para los argumentos negativos, de cero y positivos, respectivamente. Para argumentos de punto flotante, esta función no distingue entre cero positivo y negativo.
X | SIGN(X) |
---|---|
25 | +1 |
0 | 0 |
-25 | -1 |
NaN | NaN |
Tipo de datos mostrados
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
OUTPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
IS_INF
IS_INF(X)
Descripción
Muestra TRUE
si el valor es infinito positivo o negativo.
X | IS_INF(X) |
---|---|
+inf |
TRUE |
-inf |
TRUE |
25 | FALSE |
IS_NAN
IS_NAN(X)
Descripción
Muestra TRUE
si el valor es NaN
.
X | IS_NAN(X) |
---|---|
NaN |
TRUE |
25 | FALSE |
IEEE_DIVIDE
IEEE_DIVIDE(X, Y)
Descripción
Divide X por Y; esta función nunca presenta errores. Muestra FLOAT64
. A diferencia del operador de división (/), esta función no genera errores de divisiones por cero ni se desborda.
X | S | IEEE_DIVIDE(X, Y) |
---|---|---|
20.0 | 4.0 | 5.0 |
0.0 | 25.0 | 0.0 |
25.0 | 0.0 | +inf |
-25.0 | 0.0 | -inf |
0.0 | 0.0 | NaN |
0.0 | NaN |
NaN |
NaN |
0.0 | NaN |
+inf |
+inf |
NaN |
-inf |
-inf |
NaN |
RAND
RAND()
Descripción
Genera un valor seudoaleatorio de tipo FLOAT64
en el rango de [0, 1), el cual incluye 0 pero no 1.
SQRT
SQRT(X)
Descripción
Calcula la raíz cuadrada de X. Genera un error si X es menor que 0.
X | SQRT(X) |
---|---|
25.0 |
5.0 |
+inf |
+inf |
X < 0 |
Error |
Tipo de datos mostrados
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
OUTPUT | FLOAT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
POW
POW(X, Y)
Descripción
Muestra el valor de X elevado a la potencia de Y. Si el resultado se subdesborda y no es representable, entonces la función muestra un valor de cero.
X | S | POW(X, Y) |
---|---|---|
2.0 | 3.0 | 8.0 |
1.0 | Cualquier valor, incluido NaN |
1.0 |
Cualquier valor, incluido NaN |
0 | 1.0 |
-1.0 | +inf |
1.0 |
-1.0 | -inf |
1.0 |
ABS(X) < 1 | -inf |
+inf |
ABS(X) > 1 | -inf |
0.0 |
ABS(X) < 1 | +inf |
0.0 |
ABS(X) > 1 | +inf |
+inf |
-inf |
Y < 0 | 0.0 |
-inf |
Y > 0 | -inf si Y es un número entero impar, +inf si es lo contrario |
+inf |
Y < 0 | 0 |
+inf |
Y > 0 | +inf |
Valor finito < 0 | Sin número entero | Error |
0 | Valor finito < 0 | Error |
Tipo de datos mostrados
El tipo de datos que se muestra se determina según los tipos de argumentos de la siguiente tabla.
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
INT64 | FLOAT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | BIGNUMERIC | FLOAT64 |
BIGNUMERIC | BIGNUMERIC | BIGNUMERIC | BIGNUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
POWER
POWER(X, Y)
Descripción
Sinónimo de POW(X, Y)
.
EXP
EXP(X)
Descripción
Calcula e elevado a X, también llamada función exponencial natural. Si el resultado se subdesborda, esta función muestra un cero. Genera un error si el resultado se desborda.
X | EXP(X) |
---|---|
0.0 | 1.0 |
+inf |
+inf |
-inf |
0.0 |
Tipo de datos mostrados
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
OUTPUT | FLOAT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
LN
LN(X)
Descripción
Calcula el logaritmo natural de X. Genera un error si X es menor o igual que cero.
X | LN(X) |
---|---|
1.0 | 0.0 |
+inf |
+inf |
X < 0 |
Error |
Tipo de datos mostrados
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
OUTPUT | FLOAT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
LOG
LOG(X [, Y])
Descripción
Si solo X está presente, LOG
es un sinónimo de LN
. Si Y también está presente, LOG
calcula el logaritmo de X en base Y.
X | Y | LOG(X, Y) |
---|---|---|
100.0 | 10.0 | 2.0 |
-inf |
Cualquier valor | NaN |
Cualquier valor | +inf |
NaN |
+inf |
0.0 Y < 1.0 | -inf |
+inf |
Y > 1.0 | +inf |
X <= 0 | Cualquier valor | Error |
Cualquier valor | Y <= 0 | Error |
Cualquier valor | 1.0 | Error |
Tipo de datos mostrados
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
INT64 | FLOAT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | BIGNUMERIC | FLOAT64 |
BIGNUMERIC | BIGNUMERIC | BIGNUMERIC | BIGNUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
LOG10
LOG10(X)
Descripción
Similar a LOG
, pero calcula el logaritmo en base 10.
X | LOG10(X) |
---|---|
100.0 | 2.0 |
-inf |
NaN |
+inf |
+inf |
X <= 0 | Error |
Tipo de datos mostrados
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
OUTPUT | FLOAT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
GREATEST
GREATEST(X1,...,XN)
Descripción
Muestra el valor más alto entre X1,...,XN
. Si algún argumento es NULL
, muestra NULL
. De lo contrario, en el caso de argumentos de punto flotante, si algún argumento es NaN
, muestra NaN
. En todos los demás casos, muestra el valor entre X1,...,XN
que tiene el valor más alto de acuerdo con el orden que usa la cláusula ORDER BY
. Los argumentos X1, ..., XN
deben ser coercibles a un supertipo común y el supertipo debe admitir el orden.
X1,...,XN | GREATEST(X1,...,XN) |
---|---|
3,5,1 | 5 |
Esta función admite la especificación de la intercalación.
Tipos de datos mostrados
Tipo de datos de los valores de entrada.
LEAST
LEAST(X1,...,XN)
Descripción
Muestra el valor mínimo entre X1,...,XN
. Si algún argumento es NULL
, muestra NULL
. De lo contrario, en el caso de argumentos de punto flotante, si algún argumento es NaN
, muestra NaN
. En todos los demás casos, muestra el valor entre X1,...,XN
que tiene el menor valor según el orden que usa la cláusula ORDER BY
. Los argumentos X1, ..., XN
deben ser coercibles a un supertipo común y el supertipo debe admitir el orden.
X1,...,XN | LEAST(X1,...,XN) |
---|---|
3,5,1 | 1 |
Esta función admite la especificación de la intercalación.
Tipos de datos mostrados
Tipo de datos de los valores de entrada.
DIV
DIV(X, Y)
Descripción
Muestra el resultado de la división del número entero de X por Y. La división por cero muestra un error. La división por -1 se puede desbordar.
X | S | DIV(X, Y) |
---|---|---|
20 | 4 | 5 |
12 | -7 | -1 |
20 | 3 | 6 |
0 | 20 | 0 |
20 | 0 | Error |
Tipo de datos mostrados
El tipo de datos que se muestra se determina según los tipos de argumentos de la siguiente tabla.
INPUT | INT64 | NUMERIC | BIGNUMERIC |
---|---|---|---|
INT64 | INT64 | NUMERIC | BIGNUMERIC |
NUMERIC | NUMERIC | NUMERIC | BIGNUMERIC |
BIGNUMERIC | BIGNUMERIC | BIGNUMERIC | BIGNUMERIC |
SAFE_DIVIDE
SAFE_DIVIDE(X, Y)
Descripción
Equivale al operador de división (X / Y
), pero muestra NULL
si se produce un error, como un error de división por cero.
X | S | SAFE_DIVIDE(X, Y) |
---|---|---|
20 | 4 | 5 |
0 | 20 | 0 |
20 | 0 | NULL |
Tipo de datos mostrados
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
INT64 | FLOAT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | BIGNUMERIC | FLOAT64 |
BIGNUMERIC | BIGNUMERIC | BIGNUMERIC | BIGNUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
SAFE_MULTIPLY
SAFE_MULTIPLY(X, Y)
Descripción
Equivalente al operador de multiplicación (*
), pero muestra NULL
si se produce un desbordamiento.
X | S | SAFE_MULTIPLY(X, Y) |
---|---|---|
20 | 4 | 80 |
Tipo de datos mostrados
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
INT64 | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | BIGNUMERIC | FLOAT64 |
BIGNUMERIC | BIGNUMERIC | BIGNUMERIC | BIGNUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
SAFE_NEGATE
SAFE_NEGATE(X)
Descripción
Equivalente al operador unario menos (-
), pero muestra NULL
si se produce un desbordamiento.
X | SAFE_NEGATE(X) |
---|---|
+1 | -1 |
-1 | +1 |
0 | 0 |
Tipo de datos mostrados
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
OUTPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
SAFE_ADD
SAFE_ADD(X, Y)
Descripción
Equivale al operador de suma (+
), pero muestra NULL
si se produce un desbordamiento.
X | S | SAFE_ADD(X, Y) |
---|---|---|
5 | 4 | 9 |
Tipo de datos mostrados
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
INT64 | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | BIGNUMERIC | FLOAT64 |
BIGNUMERIC | BIGNUMERIC | BIGNUMERIC | BIGNUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
SAFE_SUBTRACT
SAFE_SUBTRACT(X, Y)
Descripción
Muestra el resultado de Y que se restó de X.
Equivalente al operador de resta (-
), pero muestra NULL
si se produce un desbordamiento.
X | S | SAFE_SUBTRACT(X, Y) |
---|---|---|
5 | 4 | 1 |
Tipo de datos mostrados
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
INT64 | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
NUMERIC | NUMERIC | NUMERIC | BIGNUMERIC | FLOAT64 |
BIGNUMERIC | BIGNUMERIC | BIGNUMERIC | BIGNUMERIC | FLOAT64 |
FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 | FLOAT64 |
MOD
MOD(X, Y)
Descripción
Función de módulo: muestra el resto de la división de X por Y. El valor que se muestra tiene el mismo signo que X. Se generará un error si Y es 0.
X | S | MOD(X, Y) |
---|---|---|
25 | 12 | 1 |
25 | 0 | Error |
Tipo de datos mostrados
El tipo de datos que se muestra se determina según los tipos de argumentos de la siguiente tabla.
INPUT | INT64 | NUMERIC | BIGNUMERIC |
---|---|---|---|
INT64 | INT64 | NUMERIC | BIGNUMERIC |
NUMERIC | NUMERIC | NUMERIC | BIGNUMERIC |
BIGNUMERIC | BIGNUMERIC | BIGNUMERIC | BIGNUMERIC |
ROUND
ROUND(X [, N] [, rounding_mode])
Descripción
Si solo está presente X, redondea X al número entero más cercano. Si N está presente, redondea X a N decimales después del punto decimal. Si N es negativo, redondea los dígitos a la izquierda del punto decimal. Se redondean casos de punto medio en dirección opuesta al cero. Genera un error si se produce un desbordamiento.
Si X es un tipo NUMERIC
o BIGNUMERIC
, puedes configurar rounding_mode
([Preview][preview]) de forma explícita como una de las siguientes opciones:
- [
"ROUND_HALF_AWAY_FROM_ZERO"
][round-half-away-from-zero]: (Predeterminado) redondea los casos de punto medio en dirección opuesta al cero. - [
"ROUND_HALF_EVEN"
][round-half-even]: redondea casos del punto medio hacia el dígito par más cercano.
Si estableces rounding_mode
y X no es un tipo NUMERIC
o BIGNUMERIC
, la función genera un error.
Expresión | Valor de retorno |
---|---|
ROUND(2.0) |
2.0 |
ROUND(2.3) |
2.0 |
ROUND(2.8) |
3.0 |
ROUND(2.5) |
3.0 |
ROUND(-2.3) |
-2.0 |
ROUND(-2.8) |
-3.0 |
ROUND(-2.5) |
-3.0 |
ROUND(0) |
0 |
ROUND(+inf) |
+inf |
ROUND(-inf) |
-inf |
ROUND(NaN) |
NaN |
ROUND(123.7, -1) |
120.0 |
ROUND(1.235, 2) |
1.24 |
ROUND(NUMERIC "2.25", 1, "ROUND_HALF_EVEN") |
2.2 |
ROUND(NUMERIC "2.35", 1, "ROUND_HALF_EVEN") |
2.4 |
ROUND(NUMERIC "2.251", 1, "ROUND_HALF_EVEN") |
2.3 |
ROUND(NUMERIC "-2.5", 0, "ROUND_HALF_EVEN") |
-2 |
ROUND(NUMERIC "2.5", 0, "ROUND_HALF_AWAY_FROM_ZERO") |
3 |
ROUND(NUMERIC "-2.5", 0, "ROUND_HALF_AWAY_FROM_ZERO") |
-3 |
Tipo de datos mostrados
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
OUTPUT | FLOAT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
TRUNC
TRUNC(X [, N])
Descripción
Si solo está presente X, TRUNC
redondea X al número entero más cercano cuyo valor absoluto no es mayor que el valor absoluto de X. Si N también está presente, TRUNC
se comporta como ROUND(X, N)
, pero siempre se redondea hacia cero y nunca se desborda.
X | TRUNC(X) |
---|---|
2.0 | 2.0 |
2.3 | 2.0 |
2.8 | 2.0 |
2.5 | 2.0 |
-2.3 | -2.0 |
-2.8 | -2.0 |
-2.5 | -2.0 |
0 | 0 |
+inf |
+inf |
-inf |
-inf |
NaN |
NaN |
Tipo de datos mostrados
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
OUTPUT | FLOAT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
CEIL
CEIL(X)
Descripción
Muestra el valor integral más pequeño que no sea menor que X.
X | CEIL(X) |
---|---|
2.0 | 2.0 |
2.3 | 3.0 |
2.8 | 3.0 |
2.5 | 3.0 |
-2.3 | -2.0 |
-2.8 | -2.0 |
-2.5 | -2.0 |
0 | 0 |
+inf |
+inf |
-inf |
-inf |
NaN |
NaN |
Tipo de datos mostrados
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
OUTPUT | FLOAT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
CEILING
CEILING(X)
Descripción
Sinónimo de CEIL(X)
FLOOR
FLOOR(X)
Descripción
Muestra el valor integral más grande que no sea mayor que X.
X | FLOOR(X) |
---|---|
2.0 | 2.0 |
2.3 | 2.0 |
2.8 | 2.0 |
2.5 | 2.0 |
-2.3 | -3.0 |
-2.8 | -3.0 |
-2.5 | -3.0 |
0 | 0 |
+inf |
+inf |
-inf |
-inf |
NaN |
NaN |
Tipo de datos mostrados
INPUT | INT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
---|---|---|---|---|
OUTPUT | FLOAT64 | NUMERIC | BIGNUMERIC | FLOAT64 |
COS
COS(X)
Descripción
Calcula el coseno de X, en el que X se especifica en radianes. Nunca falla.
X | COS(X) |
---|---|
+inf |
NaN |
-inf |
NaN |
NaN |
NaN |
COSH
COSH(X)
Descripción
Calcula el coseno hiperbólico de X, en el que X se especifica en radianes. Genera un error si se produce un desbordamiento.
X | COSH(X) |
---|---|
+inf |
+inf |
-inf |
+inf |
NaN |
NaN |
ACOS
ACOS(X)
Descripción
Calcula el valor principal del coseno inverso de X. El valor de muestra está en el rango [0,π]. Genera un error si X es un valor fuera del rango [-1, 1].
X | ACOS(X) |
---|---|
+inf |
NaN |
-inf |
NaN |
NaN |
NaN |
X < -1 | Error |
X > 1 | Error |
ACOSH
ACOSH(X)
Descripción
Calcula el coseno hiperbólico inverso de X. Genera un error si X es un valor inferior a 1.
X | ACOSH(X) |
---|---|
+inf |
+inf |
-inf |
NaN |
NaN |
NaN |
X < 1 | Error |
COT
COT(X)
Descripción
Calcula la cotangente para el ángulo de X
, en el que X
se especifica en radianes.
X
puede ser cualquier tipo de datos que se convierta a FLOAT64
.
Admite el prefijo SAFE.
.
X | COT(X) |
---|---|
+inf |
NaN |
-inf |
NaN |
NaN |
NaN |
0 |
Error |
NULL |
NULL |
Tipo de datos mostrados
FLOAT64
Ejemplo
SELECT COT(1) AS a, SAFE.COT(0) AS b;
+---------------------+------+
| a | b |
+---------------------+------+
| 0.64209261593433065 | NULL |
+---------------------+------+
COTH
COTH(X)
Descripción
Calcula la cotangente hiperbólica para el ángulo de X
, en la que X
se especifica en radianes. X
puede ser cualquier tipo de datos que se convierta a FLOAT64
.
Admite el prefijo SAFE.
.
X | COTH(X) |
---|---|
+inf |
1 |
-inf |
-1 |
NaN |
NaN |
0 |
Error |
NULL |
NULL |
Tipo de datos mostrados
FLOAT64
Ejemplo
SELECT COTH(1) AS a, SAFE.COTH(0) AS b;
+----------------+------+
| a | b |
+----------------+------+
| 1.313035285499 | NULL |
+----------------+------+
CSC
CSC(X)
Descripción
Calcula la cosecante del ángulo de entrada, que está en radianes.
X
puede ser cualquier tipo de datos que se convierta a FLOAT64
.
Admite el prefijo SAFE.
.
X | CSC(X) |
---|---|
+inf |
NaN |
-inf |
NaN |
NaN |
NaN |
0 |
Error |
NULL |
NULL |
Tipo de datos mostrados
FLOAT64
Ejemplo
SELECT CSC(100) AS a, CSC(-1) AS b, SAFE.CSC(0) AS c;
+----------------+-----------------+------+
| a | b | c |
+----------------+-----------------+------+
| -1.97485753142 | -1.188395105778 | NULL |
+----------------+-----------------+------+
CSCH
CSCH(X)
Descripción
Calcula la cosecante hiperbólica del ángulo de entrada, que está en radianes.
X
puede ser cualquier tipo de datos que se convierta a FLOAT64
.
Admite el prefijo SAFE.
.
X | CSCH(X) |
---|---|
+inf |
0 |
-inf |
0 |
NaN |
NaN |
0 |
Error |
NULL |
NULL |
Tipo de datos mostrados
FLOAT64
Ejemplo
SELECT CSCH(0.5) AS a, CSCH(-2) AS b, SAFE.CSCH(0) AS c;
+----------------+----------------+------+
| a | b | c |
+----------------+----------------+------+
| 1.919034751334 | -0.27572056477 | NULL |
+----------------+----------------+------+
SEC
SEC(X)
Descripción
Calcula la secante para el ángulo de X
, en el que X
se especifica en radianes.
X
puede ser cualquier tipo de datos que se convierta a FLOAT64
.
X | SEC(X) |
---|---|
+inf |
NaN |
-inf |
NaN |
NaN |
NaN |
NULL |
NULL |
Tipo de datos mostrados
FLOAT64
Ejemplo
SELECT SEC(100) AS a, SEC(-1) AS b;
+----------------+---------------+
| a | b |
+----------------+---------------+
| 1.159663822905 | 1.85081571768 |
+----------------+---------------+
SECH
SECH(X)
Descripción
Calcula la secante hiperbólica para el ángulo de X
, en la que X
se especifica en radianes. X
puede ser cualquier tipo de datos que se convierta a FLOAT64
.
Nunca produce un error.
X | SECH(X) |
---|---|
+inf |
0 |
-inf |
0 |
NaN |
NaN |
NULL |
NULL |
Tipo de datos mostrados
FLOAT64
Ejemplo
SELECT SECH(0.5) AS a, SECH(-2) AS b, SECH(100) AS c;
+----------------+----------------+---------------------+
| a | b | c |
+----------------+----------------+---------------------+
| 0.88681888397 | 0.265802228834 | 7.4401519520417E-44 |
+----------------+----------------+---------------------+
SIN
SIN(X)
Descripción
Calcula el seno de X, en el que X se especifica en radianes. Nunca falla.
X | SIN(X) |
---|---|
+inf |
NaN |
-inf |
NaN |
NaN |
NaN |
SINH
SINH(X)
Descripción
Calcula el seno hiperbólico de X, en el que X se especifica en radianes. Genera un error si se produce un desbordamiento.
X | SINH(X) |
---|---|
+inf |
+inf |
-inf |
-inf |
NaN |
NaN |
ASIN
ASIN(X)
Descripción
Calcula el valor principal del seno inverso de X. El valor que se muestra está en el rango [-π/2,π/2]. Genera un error si X está fuera del rango [-1, 1].
X | ASIN(X) |
---|---|
+inf |
NaN |
-inf |
NaN |
NaN |
NaN |
X < -1 | Error |
X > 1 | Error |
ASINH
ASINH(X)
Descripción
Calcula el seno hiperbólico inverso de X. No falla.
X | ASINH(X) |
---|---|
+inf |
+inf |
-inf |
-inf |
NaN |
NaN |
TAN
TAN(X)
Descripción
Calcula la tangente de X, en la que X se especifica en radianes. Genera un error si se produce un desbordamiento.
X | TAN(X) |
---|---|
+inf |
NaN |
-inf |
NaN |
NaN |
NaN |
TANH
TANH(X)
Descripción
Calcula la tangente hiperbólica de X, en la que X se especifica en radianes. No falla.
X | TANH(X) |
---|---|
+inf |
1.0 |
-inf |
-1.0 |
NaN |
NaN |
ATAN
ATAN(X)
Descripción
Calcula el valor principal de la tangente inversa de X. El valor que se muestra está en el rango [-π/2,π/2]. No falla.
X | ATAN(X) |
---|---|
+inf |
π/2 |
-inf |
-π/2 |
NaN |
NaN |
ATANH
ATANH(X)
Descripción
Calcula la tangente hiperbólica inversa de X. Genera un error si X está fuera del rango (-1, 1).
X | ATANH(X) |
---|---|
+inf |
NaN |
-inf |
NaN |
NaN |
NaN |
X < -1 | Error |
X > 1 | Error |
ATAN2
ATAN2(X, Y)
Descripción
Calcula el valor principal de la tangente inversa de X/Y con los signos de los dos argumentos para determinar el cuadrante. El valor que se muestra está en el rango [-π,π].
X | S | ATAN2(X, Y) |
---|---|---|
NaN |
Cualquier valor | NaN |
Cualquier valor | NaN |
NaN |
0.0 | 0.0 | 0.0 |
Valor finito positivo | -inf |
π |
Valor finito negativo | -inf |
-π |
Valor finito | +inf |
0.0 |
+inf |
Valor finito | π/2 |
-inf |
Valor finito | -π/2 |
+inf |
-inf |
¾π |
-inf |
-inf |
-¾π |
+inf |
+inf |
π/4 |
-inf |
+inf |
-π/4 |
CBRT
CBRT(X)
Descripción
Calcula la raíz cúbica de X
. X
puede ser cualquier tipo de datos que se convierta a FLOAT64
.
Admite el prefijo SAFE.
.
X | CBRT(X) |
---|---|
+inf |
inf |
-inf |
-inf |
NaN |
NaN |
0 |
0 |
NULL |
NULL |
Tipo de datos mostrados
FLOAT64
Ejemplo
SELECT CBRT(27) AS cube_root;
+--------------------+
| cube_root |
+--------------------+
| 3.0000000000000004 |
+--------------------+
RANGE_BUCKET
RANGE_BUCKET(point, boundaries_array)
Descripción
RANGE_BUCKET
examina un arreglo ordenado y muestra la posición basada en 0 del límite superior del punto. Esto puede ser útil si necesitas agrupar tus datos para compilar particiones, histogramas, reglas definidas por el negocio y mucho más.
RANGE_BUCKET
sigue estas reglas:
Si el punto existe en el arreglo, muestra el índice del siguiente valor más grande.
RANGE_BUCKET(20, [0, 10, 20, 30, 40]) -- 3 is return value RANGE_BUCKET(20, [0, 10, 20, 20, 40, 40]) -- 4 is return value
Si el punto no existe en el arreglo, pero oscila entre dos valores, muestra el índice del valor más grande.
RANGE_BUCKET(25, [0, 10, 20, 30, 40]) -- 3 is return value
Si el punto es más pequeño que el primer valor del arreglo, muestra 0.
RANGE_BUCKET(-10, [5, 10, 20, 30, 40]) -- 0 is return value
Si el punto es mayor o igual que el último valor del arreglo, muestra la longitud de este.
RANGE_BUCKET(80, [0, 10, 20, 30, 40]) -- 5 is return value
Si el arreglo está vacío, muestra 0.
RANGE_BUCKET(80, []) -- 0 is return value
Si el punto es
NULL
oNaN
, muestraNULL
.RANGE_BUCKET(NULL, [0, 10, 20, 30, 40]) -- NULL is return value
El tipo de datos del punto y el arreglo debe ser compatible.
RANGE_BUCKET('a', ['a', 'b', 'c', 'd']) -- 1 is return value RANGE_BUCKET(1.2, [1, 1.2, 1.4, 1.6]) -- 2 is return value RANGE_BUCKET(1.2, [1, 2, 4, 6]) -- execution failure
La falla de ejecución se produce en los siguientes casos:
El arreglo tiene un valor
NaN
oNULL
.RANGE_BUCKET(80, [NULL, 10, 20, 30, 40]) -- execution failure
El arreglo no se ordenó de forma ascendente.
RANGE_BUCKET(30, [10, 30, 20, 40, 50]) -- execution failure
Parámetros
point
: Un valor genérico.boundaries_array
: Un arreglo genérico de valores.
Valor que se muestra
INT64
Ejemplos
En una tabla denominada students
, verifica cuántos registros existirían en cada depósito de age_group
, según la edad del alumno:
- age_group 0 (age < 10)
- age_group 1 (age >= 10, age < 20)
- age_group 2 (age >= 20, age < 30)
- age_group 3 (age >= 30)
WITH students AS
(
SELECT 9 AS age UNION ALL
SELECT 20 AS age UNION ALL
SELECT 25 AS age UNION ALL
SELECT 31 AS age UNION ALL
SELECT 32 AS age UNION ALL
SELECT 33 AS age
)
SELECT RANGE_BUCKET(age, [10, 20, 30]) AS age_group, COUNT(*) AS count
FROM students
GROUP BY 1
+--------------+-------+
| age_group | count |
+--------------+-------+
| 0 | 1 |
| 2 | 2 |
| 3 | 3 |
+--------------+-------+