PPLfunções matemáticas - OpenSearch Serviço Amazon
ABSACOSASINATANATAN2CBRTCEILCONVCOSCOTCRC32DEGREESEEXPFLOORLNLOGLOG2LOG10MODPIPOWPOWERRADIANSRANDROUNDSIGNSINSQRT

As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

PPLfunções matemáticas

nota

Para ver quais integrações AWS de fontes de dados oferecem suporte a essa PPL função, consulteFunções.

ABS

Uso: ABS(x) calcula o valor absoluto de x.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: INTEGER/LONG/FLOAT/DOUBLE

Exemplo:

os> source=people | eval `ABS(-1)` = ABS(-1) | fields `ABS(-1)`
fetched rows / total rows = 1/1
+-----------+
| ABS(-1)   |
|-----------|
| 1         |
+-----------+

ACOS

Uso: ACOS(x) calcula o arco cosseno de x. Ele retorna NULL se x não estiver no intervalo de -1 a 1.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `ACOS(0)` = ACOS(0) | fields `ACOS(0)`
fetched rows / total rows = 1/1
+--------------------+
| ACOS(0)            |
|--------------------|
| 1.5707963267948966 |
+--------------------+

ASIN

Uso: asin(x) calcula o arco seno de x. Ele retorna NULL se x não estiver no intervalo de -1 a 1.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `ASIN(0)` = ASIN(0) | fields `ASIN(0)`
fetched rows / total rows = 1/1
+-----------+
| ASIN(0)   |
|-----------|
| 0.0       |
+-----------+

ATAN

Uso: ATAN(x) calcula o arco tangente de x. atan(y, x) calcula o arco tangente de y/x, exceto que os sinais de ambos os argumentos determinam o quadrante do resultado.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `ATAN(2)` = ATAN(2), `ATAN(2, 3)` = ATAN(2, 3) | fields `ATAN(2)`, `ATAN(2, 3)`
fetched rows / total rows = 1/1
+--------------------+--------------------+
| ATAN(2)            | ATAN(2, 3)         |
|--------------------+--------------------|
| 1.1071487177940904 | 0.5880026035475675 |
+--------------------+--------------------+

ATAN2

Uso: ATAN2(y, x) calcula o arco tangente de y/x, exceto que os sinais de ambos os argumentos determinam o quadrante do resultado.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `ATAN2(2, 3)` = ATAN2(2, 3) | fields `ATAN2(2, 3)`
fetched rows / total rows = 1/1
+--------------------+
| ATAN2(2, 3)        |
|--------------------|
| 0.5880026035475675 |
+--------------------+

CBRT

Uso: CBRT calcula a raiz cúbica de um número.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução:DOUBLE:

INTEGER/LONG/FLOAT/DOUBLE -> DOUBLE

Exemplo:

opensearchsql> source=location | eval `CBRT(8)` = CBRT(8), `CBRT(9.261)` = CBRT(9.261), `CBRT(-27)` = CBRT(-27) | fields `CBRT(8)`, `CBRT(9.261)`, `CBRT(-27)`;
fetched rows / total rows = 2/2
+-----------+---------------+-------------+
| CBRT(8)   | CBRT(9.261)   | CBRT(-27)   |
|-----------+---------------+-------------|
| 2.0       | 2.1           | -3.0        |
| 2.0       | 2.1           | -3.0        |
+-----------+---------------+-------------+

CEIL

Uso: Um alias para a CEILING função. CEILING(T)assume o teto do valor T.

Limitação: CEILING só funciona conforme o esperado quando o tipo duplo IEEE 754 exibe um decimal quando armazenado.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: LONG

Exemplo:

os> source=people | eval `CEILING(0)` = CEILING(0), `CEILING(50.00005)` = CEILING(50.00005), `CEILING(-50.00005)` = CEILING(-50.00005) | fields `CEILING(0)`, `CEILING(50.00005)`, `CEILING(-50.00005)`
fetched rows / total rows = 1/1
+--------------+---------------------+----------------------+
| CEILING(0)   | CEILING(50.00005)   | CEILING(-50.00005)   |
|--------------+---------------------+----------------------|
| 0            | 51                  | -50                  |
+--------------+---------------------+----------------------+

os> source=people | eval `CEILING(3147483647.12345)` = CEILING(3147483647.12345), `CEILING(113147483647.12345)` = CEILING(113147483647.12345), `CEILING(3147483647.00001)` = CEILING(3147483647.00001) | fields `CEILING(3147483647.12345)`, `CEILING(113147483647.12345)`, `CEILING(3147483647.00001)`
fetched rows / total rows = 1/1
+-----------------------------+-------------------------------+-----------------------------+
| CEILING(3147483647.12345)   | CEILING(113147483647.12345)   | CEILING(3147483647.00001)   |
|-----------------------------+-------------------------------+-----------------------------|
| 3147483648                  | 113147483648                  | 3147483648                  |
+-----------------------------+-------------------------------+-----------------------------+

CONV

Uso: CONV(x, a, b) converte o número x de uma base para a base b.

Tipo de argumento: x:STRING, a:INTEGER, b: INTEGER

Tipo de devolução: STRING

Exemplo:

os> source=people | eval `CONV('12', 10, 16)` = CONV('12', 10, 16), `CONV('2C', 16, 10)` = CONV('2C', 16, 10), `CONV(12, 10, 2)` = CONV(12, 10, 2), `CONV(1111, 2, 10)` = CONV(1111, 2, 10) | fields `CONV('12', 10, 16)`, `CONV('2C', 16, 10)`, `CONV(12, 10, 2)`, `CONV(1111, 2, 10)`
fetched rows / total rows = 1/1
+----------------------+----------------------+-------------------+---------------------+
| CONV('12', 10, 16)   | CONV('2C', 16, 10)   | CONV(12, 10, 2)   | CONV(1111, 2, 10)   |
|----------------------+----------------------+-------------------+---------------------|
| c                    | 44                   | 1100              | 15                  |
+----------------------+----------------------+-------------------+---------------------+

COS

Uso: COS(x) calcula o cosseno de x, onde x é dado em radianos.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `COS(0)` = COS(0) | fields `COS(0)`
fetched rows / total rows = 1/1
+----------+
| COS(0)   |
|----------|
| 1.0      |
+----------+

COT

Uso: COT(x) calcula a cotangente de x. Ele retornará out-of-range um erro se x for igual a 0.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `COT(1)` = COT(1) | fields `COT(1)`
fetched rows / total rows = 1/1
+--------------------+
| COT(1)             |
|--------------------|
| 0.6420926159343306 |
+--------------------+

CRC32

Uso: CRC32 calcula um valor de verificação de redundância cíclica e retorna um valor não assinado de 32 bits.

Tipo de argumento: STRING

Tipo de devolução: LONG

Exemplo:

os> source=people | eval `CRC32('MySQL')` = CRC32('MySQL') | fields `CRC32('MySQL')`
fetched rows / total rows = 1/1
+------------------+
| CRC32('MySQL')   |
|------------------|
| 3259397556       |
+------------------+

DEGREES

Uso: DEGREES(x) converte x de radianos em graus.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `DEGREES(1.57)` = DEGREES(1.57) | fields `DEGREES(1.57)`
fetched rows / total rows  = 1/1
+-------------------+
| DEGREES(1.57)     |
|-------------------|
| 89.95437383553924 |
+-------------------+

E

Uso: E() retorna o número de Euler.

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `E()` = E() | fields `E()`
fetched rows / total rows = 1/1
+-------------------+
| E()               |
|-------------------|
| 2.718281828459045 |
+-------------------+

EXP

Uso: EXP(x) retorna e elevado à potência de x.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `EXP(2)` = EXP(2) | fields `EXP(2)`
fetched rows / total rows = 1/1
+------------------+
| EXP(2)           |
|------------------|
| 7.38905609893065 |
+------------------+

FLOOR

Uso: FLOOR(T) ocupa o piso do valor T.

Limitação: FLOOR só funciona conforme o esperado quando o tipo duplo IEEE 754 exibe um decimal quando armazenado.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: LONG

Exemplo:

os> source=people | eval `FLOOR(0)` = FLOOR(0), `FLOOR(50.00005)` = FLOOR(50.00005), `FLOOR(-50.00005)` = FLOOR(-50.00005) | fields `FLOOR(0)`, `FLOOR(50.00005)`, `FLOOR(-50.00005)`
fetched rows / total rows = 1/1
+------------+-------------------+--------------------+
| FLOOR(0)   | FLOOR(50.00005)   | FLOOR(-50.00005)   |
|------------+-------------------+--------------------|
| 0          | 50                | -51                |
+------------+-------------------+--------------------+

os> source=people | eval `FLOOR(3147483647.12345)` = FLOOR(3147483647.12345), `FLOOR(113147483647.12345)` = FLOOR(113147483647.12345), `FLOOR(3147483647.00001)` = FLOOR(3147483647.00001) | fields `FLOOR(3147483647.12345)`, `FLOOR(113147483647.12345)`, `FLOOR(3147483647.00001)`
fetched rows / total rows = 1/1
+---------------------------+-----------------------------+---------------------------+
| FLOOR(3147483647.12345)   | FLOOR(113147483647.12345)   | FLOOR(3147483647.00001)   |
|---------------------------+-----------------------------+---------------------------|
| 3147483647                | 113147483647                | 3147483647                |
+---------------------------+-----------------------------+---------------------------+

os> source=people | eval `FLOOR(282474973688888.022)` = FLOOR(282474973688888.022), `FLOOR(9223372036854775807.022)` = FLOOR(9223372036854775807.022), `FLOOR(9223372036854775807.0000001)` = FLOOR(9223372036854775807.0000001) | fields `FLOOR(282474973688888.022)`, `FLOOR(9223372036854775807.022)`, `FLOOR(9223372036854775807.0000001)`
fetched rows / total rows = 1/1
+------------------------------+----------------------------------+--------------------------------------+
| FLOOR(282474973688888.022)   | FLOOR(9223372036854775807.022)   | FLOOR(9223372036854775807.0000001)   |
|------------------------------+----------------------------------+--------------------------------------|
| 282474973688888              | 9223372036854775807              | 9223372036854775807                  |
+------------------------------+----------------------------------+--------------------------------------+

LN

Uso: LN(x) retorna o logaritmo natural de x.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `LN(2)` = LN(2) | fields `LN(2)`
fetched rows / total rows = 1/1
+--------------------+
| LN(2)              |
|--------------------|
| 0.6931471805599453 |
+--------------------+

LOG

Uso: LOG(x) retorna o logaritmo natural de x que é o logaritmo base e do x. log (B, x) é equivalente a log (x) /log (B).

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `LOG(2)` = LOG(2), `LOG(2, 8)` = LOG(2, 8) | fields `LOG(2)`, `LOG(2, 8)`
fetched rows / total rows = 1/1
+--------------------+-------------+
| LOG(2)             | LOG(2, 8)   |
|--------------------+-------------|
| 0.6931471805599453 | 3.0         |
+--------------------+-------------+

LOG2

Uso: LOG2(x) é equivalente alog(x)/log(2).

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `LOG2(8)` = LOG2(8) | fields `LOG2(8)`
fetched rows / total rows = 1/1
+-----------+
| LOG2(8)   |
|-----------|
| 3.0       |
+-----------+

LOG10

Uso: LOG10(x) é equivalente alog(x)/log(10).

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `LOG10(100)` = LOG10(100) | fields `LOG10(100)`
fetched rows / total rows = 1/1
+--------------+
| LOG10(100)   |
|--------------|
| 2.0          |
+--------------+

MOD

Uso: MOD(n, m) calcula o restante do número n dividido por m.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de retorno: Tipo mais amplo entre os tipos de n e m se m for um valor diferente de zero. Se m for igual a 0, então retorna. NULL

Exemplo:

os> source=people | eval `MOD(3, 2)` = MOD(3, 2), `MOD(3.1, 2)` = MOD(3.1, 2) | fields `MOD(3, 2)`, `MOD(3.1, 2)`
fetched rows / total rows = 1/1
+-------------+---------------+
| MOD(3, 2)   | MOD(3.1, 2)   |
|-------------+---------------|
| 1           | 1.1           |
+-------------+---------------+

PI

Uso: PI() retorna a constante pi.

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `PI()` = PI() | fields `PI()`
fetched rows / total rows = 1/1
+-------------------+
| PI()              |
|-------------------|
| 3.141592653589793 |
+-------------------+

POW

Uso: POW(x, y) calcula o valor de x elevado à potência de y. Entradas incorretas retornam um NULL resultado.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Sinônimos: POWER(_, _)

Exemplo:

os> source=people | eval `POW(3, 2)` = POW(3, 2), `POW(-3, 2)` = POW(-3, 2), `POW(3, -2)` = POW(3, -2) | fields `POW(3, 2)`, `POW(-3, 2)`, `POW(3, -2)`
fetched rows / total rows = 1/1
+-------------+--------------+--------------------+
| POW(3, 2)   | POW(-3, 2)   | POW(3, -2)         |
|-------------+--------------+--------------------|
| 9.0         | 9.0          | 0.1111111111111111 |
+-------------+--------------+--------------------+

POWER

Uso: POWER(x, y) calcula o valor de x elevado à potência de y. Entradas incorretas retornam um NULL resultado.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Sinônimos: POW(_, _)

Exemplo:

os> source=people | eval `POWER(3, 2)` = POWER(3, 2), `POWER(-3, 2)` = POWER(-3, 2), `POWER(3, -2)` = POWER(3, -2) | fields `POWER(3, 2)`, `POWER(-3, 2)`, `POWER(3, -2)`
fetched rows / total rows = 1/1
+---------------+----------------+--------------------+
| POWER(3, 2)   | POWER(-3, 2)   | POWER(3, -2)       |
|---------------+----------------+--------------------|
| 9.0           | 9.0            | 0.1111111111111111 |
+---------------+----------------+--------------------+

RADIANS

Uso: RADIANS(x) converte x de graus em radianos.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `RADIANS(90)` = RADIANS(90) | fields `RADIANS(90)`
fetched rows / total rows  = 1/1
+--------------------+
| RADIANS(90)        |
|--------------------|
| 1.5707963267948966 |
+--------------------+

RAND

Uso:RAND()/RAND(N)retorna um valor de ponto flutuante aleatório no intervalo 0 <= valor < 1,0. Se você especificar o inteiro N, a função inicializará a semente antes da execução. Uma implicação desse comportamento é que, com um argumento N idêntico, rand(N) retorna o mesmo valor a cada vez, produzindo uma sequência repetível de valores de coluna.

Tipo de argumento: INTEGER

Tipo de devolução: FLOAT

Exemplo:

os> source=people | eval `RAND(3)` = RAND(3) | fields `RAND(3)`
fetched rows / total rows = 1/1
+------------+
| RAND(3)    |
|------------|
| 0.73105735 |
+------------+

ROUND

Uso: ROUND(x, d) arredonda o argumento x para d casas decimais. Se você não especificar d, o padrão será 0.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Mapa do tipo de retorno:

  • (INTEGER/LONG [,INTEGER]) -> LONG

  • (FLOAT/DOUBLE [,INTEGER]) -> LONG

Exemplo:

os> source=people | eval `ROUND(12.34)` = ROUND(12.34), `ROUND(12.34, 1)` = ROUND(12.34, 1), `ROUND(12.34, -1)` = ROUND(12.34, -1), `ROUND(12, 1)` = ROUND(12, 1) | fields `ROUND(12.34)`, `ROUND(12.34, 1)`, `ROUND(12.34, -1)`, `ROUND(12, 1)`
fetched rows / total rows = 1/1
+----------------+-------------------+--------------------+----------------+
| ROUND(12.34)   | ROUND(12.34, 1)   | ROUND(12.34, -1)   | ROUND(12, 1)   |
|----------------+-------------------+--------------------+----------------|
| 12.0           | 12.3              | 10.0               | 12             |
+----------------+-------------------+--------------------+----------------+

SIGN

Uso: SIGN retorna o sinal do argumento como -1, 0 ou 1, dependendo se o número é negativo, zero ou positivo.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: INTEGER

Exemplo:

os> source=people | eval `SIGN(1)` = SIGN(1), `SIGN(0)` = SIGN(0), `SIGN(-1.1)` = SIGN(-1.1) | fields `SIGN(1)`, `SIGN(0)`, `SIGN(-1.1)`
fetched rows / total rows = 1/1
+-----------+-----------+--------------+
| SIGN(1)   | SIGN(0)   | SIGN(-1.1)   |
|-----------+-----------+--------------|
| 1         | 0         | -1           |
+-----------+-----------+--------------+

SIN

Uso: sin(x) calcula o seno de x, onde x é dado em radianos.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Tipo de devolução: DOUBLE

Exemplo:

os> source=people | eval `SIN(0)` = SIN(0) | fields `SIN(0)`
fetched rows / total rows = 1/1
+----------+
| SIN(0)   |
|----------|
| 0.0      |
+----------+

SQRT

Uso: SQRT calcula a raiz quadrada de um número não negativo.

Tipo de argumento: INTEGER/LONG/FLOAT/DOUBLE

Mapa do tipo de retorno:

  • (Não negativo) -> INTEGER/LONG/FLOAT/DOUBLE DOUBLE

  • (Negativo) INTEGER/LONG/FLOAT/DOUBLE -> NULL

Exemplo:

os> source=people | eval `SQRT(4)` = SQRT(4), `SQRT(4.41)` = SQRT(4.41) | fields `SQRT(4)`, `SQRT(4.41)`
fetched rows / total rows = 1/1
+-----------+--------------+
| SQRT(4)   | SQRT(4.41)   |
|-----------+--------------|
| 2.0       | 2.1          |
+-----------+--------------+