SQL - Funções Numéricas
As funções numéricas SQL são usadas principalmente para manipulação numérica e / ou cálculos matemáticos. A tabela a seguir detalha as funções numéricas -
| Sr. Não. | Descrição da função |
|---|---|
| 1 | ABDÔMEN() Retorna o valor absoluto da expressão numérica. |
| 2 | ACOS () Retorna o arco-cosseno da expressão numérica. Retorna NULL se o valor não estiver no intervalo de -1 a 1. |
| 3 | COMO EM() Retorna o arco seno da expressão numérica. Retorna NULL se o valor não estiver no intervalo de -1 a 1 |
| 4 | NUMA() Retorna o arco tangente da expressão numérica. |
| 5 | ATAN2 () Retorna o arco tangente das duas variáveis passadas a ele. |
| 6 | BIT_AND () Retorna o bit a bit AND todos os bits da expressão. |
| 7 | BIT_COUNT () Retorna a representação de string do valor binário passado a ele. |
| 8 | BIT_OR () Retorna o OR bit a bit de todos os bits na expressão passada. |
| 9 | CEIL () Retorna o menor valor inteiro que não é menor que a expressão numérica passada |
| 10 | TETO() Retorna o menor valor inteiro que não é menor que a expressão numérica passada |
| 11 | CONV () Converta a expressão numérica de uma base para outra. |
| 12 | COS () Retorna o cosseno da expressão numérica passada. A expressão numérica deve ser expressa em radianos. |
| 13 | BERÇO() Retorna a cotangente da expressão numérica passada. |
| 14 | GRAUS () Retorna a expressão numérica convertida de radianos para graus. |
| 15 | EXP () Retorna a base do logaritmo natural (e) elevado à potência da expressão numérica passada. |
| 16 | CHÃO() Retorna o maior valor inteiro que não é maior que a expressão numérica passada. |
| 17 | FORMATO() Retorna uma expressão numérica arredondada para um número de casas decimais. |
| 18 | GRANDE () Retorna o maior valor das expressões de entrada. |
| 19 | INTERVALO() Obtém várias expressões exp1, exp2 e exp3 assim por diante .. e retorna 0 se exp1 for menor que exp2, retorna 1 se exp1 for menor que exp3 e assim por diante. |
| 20 | MENOS () Retorna a entrada de valor mínimo quando fornecidos dois ou mais. |
| 21 | REGISTRO() Retorna o logaritmo natural da expressão numérica passada. |
| 22 | LOG10 () Retorna o logaritmo de base 10 da expressão numérica passada. |
| 23 | MOD () Retorna o resto de uma expressão mergulhando em outra expressão. |
| 24 | OCT () Retorna a representação de string do valor octal da expressão numérica passada. Retorna NULL se o valor passado for NULL. |
| 25 | PI () Retorna o valor de pi |
| 26 | PANCADA() Devolve o valor de uma expressão elevada à potência de outra expressão |
| 27 | PODER() Devolve o valor de uma expressão elevada à potência de outra expressão |
| 28 | RADIANOS () Retorna o valor da expressão passada convertida de graus para radianos. |
| 29 | VOLTA() Retorna a expressão numérica arredondada para um número inteiro. Pode ser usado para arredondar uma expressão para um número de casas decimais |
| 30 | PECADO() Retorna o seno da expressão numérica fornecida em radianos. |
| 31 | SQRT () Retorna a raiz quadrada não negativa da expressão numérica. |
| 32 | STD () Retorna o desvio padrão da expressão numérica. |
| 33 | STDDEV () Retorna o desvio padrão da expressão numérica. |
| 34 | BRONZEADO() Retorna a tangente da expressão numérica expressa em radianos. |
| 35 | TRUNCAR() Retorna exp1 numérico truncado em casas decimais de exp2. Se exp2 for 0, o resultado não terá casa decimal. |
ABS (X)
A função ABS () retorna o valor absoluto de X. Considere o seguinte exemplo -
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 função retorna o arco-cosseno de X. O valor de X deve variar entre -1 e 1 ou NULL será retornado. Considere o seguinte exemplo -
SQL> SELECT ACOS(1);
+---------------------------------------------------------+
| ACOS(1) |
+---------------------------------------------------------+
| 0.000000 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ASIN (X)
A função ASIN () retorna o arco seno de X. O valor de X deve estar no intervalo de -1 a 1 ou NULL é retornado.
SQL> SELECT ASIN(1);
+---------------------------------------------------------+
| ASIN(1) |
+---------------------------------------------------------+
| 1.5707963267949 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ATAN (X)
Esta função retorna o arco tangente de X.
SQL> SELECT ATAN(1);
+---------------------------------------------------------+
| ATAN(1) |
+---------------------------------------------------------+
| 0.78539816339745 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ATAN2 (Y, X)
Essa função retorna o arco-tangente dos dois argumentos: X e Y. É semelhante ao arco-tangente de Y / X, exceto que os sinais de ambos são usados para encontrar o quadrante do resultado.
SQL> SELECT ATAN2(3,6);
+---------------------------------------------------------+
| ATAN2(3,6) |
+---------------------------------------------------------+
| 0.46364760900081 |
+---------------------------------------------------------+
1 row in set (0.00 sec)BIT_AND (expressão)
A função BIT_AND retorna o AND bit a bit de todos os bits na expressão. A premissa básica é que se dois bits correspondentes são iguais, uma operação AND bit a bit retornará 1, enquanto se eles forem diferentes, uma operação AND bit a bit retornará 0. A própria função retorna um valor inteiro de 64 bits. Se não houver correspondências, ele retornará 18446744073709551615. O exemplo a seguir executa a função BIT_AND na coluna PRICE agrupada pelo FABRICANTE do carro -
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 (numeric_value)
A função BIT_COUNT () retorna o número de bits que estão ativos em numeric_value. O exemplo a seguir demonstra o uso da função BIT_COUNT () para retornar o número de bits ativos para um intervalo 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 (expressão)
A função BIT_OR () retorna o bit a bit OR de todos os bits na expressão. A premissa básica da função OR bit a bit é que ela retorna 0 se os bits correspondentes corresponderem e 1 se não corresponderem. A função retorna um inteiro de 64 bits e, se não houver linhas correspondentes, ela retorna 0. O exemplo a seguir executa a função BIT_OR () na coluna PRICE da tabela CARS, agrupada pelo MAKER -
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)CEIL (X)
TETO (X)
Essas funções retornam o menor valor inteiro que não é menor que X. Considere o seguinte exemplo -
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)
O objetivo da função CONV () é converter números entre diferentes bases numéricas. A função retorna uma string do valor N convertido de from_base para to_base. O valor mínimo de base é 2 e o máximo é 36. Se algum dos argumentos for NULL, a função retornará NULL. Considere o exemplo a seguir, que converte o número 5 da base 16 para a base 2 -
SQL> SELECT CONV(5,16,2);
+---------------------------------------------------------+
| CONV(5,16,2) |
+---------------------------------------------------------+
| 101 |
+---------------------------------------------------------+
1 row in set (0.00 sec)COS (X)
Esta função retorna o cosseno de X. O valor de X é dado em radianos.
SQL>SELECT COS(90);
+---------------------------------------------------------+
| COS(90) |
+---------------------------------------------------------+
| -0.44807361612917 |
+---------------------------------------------------------+
1 row in set (0.00 sec)COT (X)
Esta função retorna a cotangente de X. Considere o seguinte exemplo -
SQL>SELECT COT(1);
+---------------------------------------------------------+
| COT(1) |
+---------------------------------------------------------+
| 0.64209261593433 |
+---------------------------------------------------------+
1 row in set (0.00 sec)GRAUS (X)
Esta função retorna o valor de X convertido de radianos para graus.
SQL>SELECT DEGREES(PI());
+---------------------------------------------------------+
| DEGREES(PI()) |
+---------------------------------------------------------+
| 180.000000 |
+---------------------------------------------------------+
1 row in set (0.00 sec)EXP (X)
Esta função retorna o valor de e (a base do logaritmo natural) elevado à potência de X.
SQL>SELECT EXP(3);
+---------------------------------------------------------+
| EXP(3) |
+---------------------------------------------------------+
| 20.085537 |
+---------------------------------------------------------+
1 row in set (0.00 sec)PISO (X)
Esta função retorna o maior valor inteiro que não é maior que X.
SQL>SELECT FLOOR(7.55);
+---------------------------------------------------------+
| FLOOR(7.55) |
+---------------------------------------------------------+
| 7 |
+---------------------------------------------------------+
1 row in set (0.00 sec)FORMATO (X, D)
A função FORMAT () é usada para formatar o número X no seguinte formato: ###, ###, ###. ## truncated to D casas decimais. O exemplo a seguir demonstra o uso e a saída da função FORMAT () -
SQL>SELECT FORMAT(423423234.65434453,2);
+---------------------------------------------------------+
| FORMAT(423423234.65434453,2) |
+---------------------------------------------------------+
| 423,423,234.65 |
+---------------------------------------------------------+
1 row in set (0.00 sec)MAIOR (n1, n2, n3, ..........)
A função GREATEST () retorna o maior valor no conjunto de parâmetros de entrada (n1, n2, n3, e assim por diante). O exemplo a seguir usa a função GREATEST () para retornar o maior número de um 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, ..........)
A função INTERVAL () compara o valor de N com a lista de valores (N1, N2, N3 e assim por diante). A função retorna 0 se N <N1, 1 se N <N2, 2 se N <N3 e assim por diante. Ele retornará .1 se N for NULL. A lista de valores deve estar no formato N1 <N2 <N3 para funcionar corretamente. O código a seguir é um exemplo simples de como a função INTERVAL () funciona -
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, ..........)
A função INTERVAL () compara o valor de N com a lista de valores (N1, N2, N3 e assim por diante). A função retorna 0 se N <N1, 1 se N <N2, 2 se N <N3 e assim por diante. Ele retornará .1 se N for NULL. A lista de valores deve estar no formato N1 <N2 <N3 para funcionar corretamente. O código a seguir é um exemplo simples de como a função INTERVAL () funciona -
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)Lembre-se de que 6 é o índice baseado em zero na lista de valores do primeiro valor que era maior do que N. Em nosso caso, 7 era o valor incorreto e está localizado no sexto slot de índice.
MENOS (N1, N2, N3, N4, ......)
A função LEAST () é o oposto da função GREATEST (). Seu objetivo é retornar o item de menor valor da lista de valores (N1, N2, N3 e assim por diante). O exemplo a seguir mostra o uso e a saída adequados para a função LEAST () -
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)LOG (X)
LOG (B, X)
A versão de argumento único da função retornará o logaritmo natural de X. Se for chamada com dois argumentos, ela retornará o logaritmo de X para uma base arbitrária B. Considere o seguinte exemplo -
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 função retorna o logaritmo de base 10 de X.
SQL>SELECT LOG10(100);
+---------------------------------------------------------+
| LOG10(100) |
+---------------------------------------------------------+
| 2.000000 |
+---------------------------------------------------------+
1 row in set (0.00 sec)MOD (N, M)
Esta função retorna o resto de N dividido por M. Considere o seguinte exemplo -
SQL>SELECT MOD(29,3);
+---------------------------------------------------------+
| MOD(29,3) |
+---------------------------------------------------------+
| 2 |
+---------------------------------------------------------+
1 row in set (0.00 sec)OCT (N)
A função OCT () retorna a representação de string do número octal N. Isso é equivalente a usar CONV (N, 10,8).
SQL>SELECT OCT(12);
+---------------------------------------------------------+
| OCT(12) |
+---------------------------------------------------------+
| 14 |
+---------------------------------------------------------+
1 row in set (0.00 sec)PI ()
Esta função simplesmente retorna o valor de pi. O SQL armazena internamente o valor total de precisão dupla de pi.
SQL>SELECT PI();
+---------------------------------------------------------+
| PI() |
+---------------------------------------------------------+
| 3.141593 |
+---------------------------------------------------------+
1 row in set (0.00 sec)POW (X, Y)
POWER (X, Y)
Essas duas funções retornam o valor de X elevado à potência de Y.
SQL> SELECT POWER(3,3);
+---------------------------------------------------------+
| POWER(3,3) |
+---------------------------------------------------------+
| 27 |
+---------------------------------------------------------+
1 row in set (0.00 sec)RADIANOS (X)
Esta função retorna o valor de X, convertido de graus para radianos.
SQL>SELECT RADIANS(90);
+---------------------------------------------------------+
| RADIANS(90) |
+---------------------------------------------------------+
|1.570796 |
+---------------------------------------------------------+
1 row in set (0.00 sec)ROUND (X)
ROUND (X, D)
Esta função retorna X arredondado para o inteiro mais próximo. Se um segundo argumento, D, for fornecido, a função retornará X arredondado para D casas decimais. D deve ser positivo ou todos os dígitos à direita do ponto decimal serão removidos. Considere o seguinte exemplo -
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)SINAL (X)
Esta função retorna o sinal de X (negativo, zero ou positivo) como -1, 0 ou 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)SIN (X)
Esta função retorna o seno de X. Considere o seguinte exemplo -
SQL>SELECT SIN(90);
+---------------------------------------------------------+
| SIN(90) |
+---------------------------------------------------------+
| 0.893997 |
+---------------------------------------------------------+
1 row in set (0.00 sec)SQRT (X)
Esta função retorna a raiz quadrada não negativa de X. Considere o seguinte exemplo -
SQL>SELECT SQRT(49);
+---------------------------------------------------------+
| SQRT(49) |
+---------------------------------------------------------+
| 7 |
+---------------------------------------------------------+
1 row in set (0.00 sec)STD (expressão)
STDDEV (expressão)
A função STD () é usada para retornar o desvio padrão da expressão. Isso é equivalente a obter a raiz quadrada de VARIANCE () da expressão. O exemplo a seguir calcula o desvio padrão da coluna PRICE em nossa tabela CARS -
SQL>SELECT STD(PRICE) STD_DEVIATION FROM CARS;
+---------------------------------------------------------+
| STD_DEVIATION |
+---------------------------------------------------------+
| 7650.2146 |
+---------------------------------------------------------+
1 row in set (0.00 sec)TAN (X)
Esta função retorna a tangente do argumento X, que é expressa em radianos.
SQL>SELECT TAN(45);
+---------------------------------------------------------+
| TAN(45) |
+---------------------------------------------------------+
| 1.619775 |
+---------------------------------------------------------+
1 row in set (0.00 sec)TRUNCAR (X, D)
Esta função é usada para retornar o valor de X truncado em D número de casas decimais. Se D for 0, o ponto decimal é removido. Se D for negativo, o número D de valores na parte inteira do valor será truncado. Considere o seguinte exemplo -
SQL>SELECT TRUNCATE(7.536432,2);
+---------------------------------------------------------+
| TRUNCATE(7.536432,2) |
+---------------------------------------------------------+
| 7.53 |
+---------------------------------------------------------+
1 row in set (0.00 sec)