Funções Matematicas

Todas as funções matematicas retornam NULL no caso de um erro.

-

Menos unario. Muda o sinal do argumento:
```
mysql> SELECT - 2;
 -> -2
```
Note que se este operador é utilizando com um BIGINT, o valor retornado é um BIGINT! Isto significa que você deve evitar usar - em inteiros que pode ter o valor de -2^63!
ABS(X)
Retorna o valor absoluto de X:
```
mysql> SELECT ABS(2);
 -> 2
mysql> SELECT ABS(-32);
 -> 32
```
O uso desta função é seguro com valores BIGINT.
SIGN(X)
Retorna o sinal do argumento como -1, 0, ou 1, dependendo de quando X é negativo, zero, ou positivo:
```
mysql> SELECT SIGN(-32);
 -> -1
mysql> SELECT SIGN(0);
 -> 0
mysql> SELECT SIGN(234);
 -> 1
```
MOD(N,M), %

Modulo (como o operador % em C). Retorna o 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
```
O uso desta função é seguro com valores BIGINT. O último exemplo só funciona no MariaDB 4.1
FLOOR(X)
Retorna o maior valor inteiro não maior que X:
```
mysql> SELECT FLOOR(1.23);
 -> 1
mysql> SELECT FLOOR(-1.23);
 -> -2
```
Note que o valor retornado é convertido para um BIGINT!
CEILING(X), CEIL(X)
Retorna o menor valor inteiro não menor que X:
```
mysql> SELECT CEILING(1.23);
 -> 2
mysql> SELECT CEIL(-1.23);
 -> -1
```
O alias CEIL() foi adicionado versão 4.0.6.
Note que o valor retornado é convertido para um BIGINT!
ROUND(X), ROUND(X,D)
Retorna o argumeto X, arredondado para o inteiro mais próximo. Com dois argumentos o arredandamento é feito para um número com D decimais.
```
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
```
Note que o comportamento de ROUND() quando o argumento está no meio do caminho entre dois inteiros depende da implementação da biblioteca C. Alguns arredondamentos para o número mais próximo, são sempre para baixo, para cima ou são zero. Se você precisa de um tipo de arredondamento, você deve usar uma função bem definida como TRUNCATE() ou FLOOR().
DIV
Divisão de inteiros. Similar ao FLOOR() mas seguro com valores BIGINT.
```
mysql> SELECT 5 DIV 2
 -> 2
```
DIV é novo no MariaDB 4.1.0.
EXP(X)
Retorna o valor de e (the base of natural logarithms) raised to the power of X:
```
mysql> SELECT EXP(2);
 -> 7.389056
mysql> SELECT EXP(-2);
 -> 0.135335
```
LN(X)
Retorna o logaritmo natural de X:
```
mysql> SELECT LN(2);
 -> 0.693147
mysql> SELECT LN(-2);
 -> NULL
```
Esta função foi adicionada na versão 4.0.3 do MariaDB. É sinônimo de LOG(X) no MariaDB.
LOG(X), LOG(B,X)
Se chamado com um parâmetro, esta função retorna o logarítmo natural de X:
```
mysql> SELECT LOG(2);
 -> 0.693147
mysql> SELECT LOG(-2);
 -> NULL
```
Se chamado com dois parâmetros, esta função retorna o logarítmo natural de X para uma base arbitraria B:
```
mysql> SELECT LOG(2,65536);
 -> 16.000000
mysql> SELECT LOG(1,100);
 -> NULL
```
A opção de base arbitrária foi adicionada na versão 4.0.3 do MariaDB. LOG(B,X) é equivalente a LOG(X)/LOG(B).
LOG2(X)
Returna o logarítmo na base 2 de X:
```
mysql> SELECT LOG2(65536);
 -> 16.000000
mysql> SELECT LOG2(-100);
 -> NULL
```
LOG2() é útil para descobrir quantos bits um número necessitaria para ser armazenado. Esta função foi adicionada na versão 4.0.3 do MariaDB. Em versões anteriores, você pode usar LOG(X)/LOG(2).

LOG10(X)

Returna o logarítmo na base 10 de X:

mysql> SELECT LOG10(2);
 -> 0.301030
mysql> SELECT LOG10(100);
 -> 2.000000
mysql> SELECT LOG10(-100);
 -> NULL

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

Retorna o valor de X elevado a potência de Y:

mysql> SELECT POW(2,2);
 -> 4.000000
mysql> SELECT POW(2,-2);
 -> 0.250000

SQRT(X)

Retorna o a raiz quadrada não negativa de X:

mysql> SELECT SQRT(4);
 -> 2.000000
mysql> SELECT SQRT(20);
 -> 4.472136

PI()
Retorna o valor de PI. A quantidade de números decimais padrão é 5, mas o MariaDB usa internamente a precisão dupla completa para PI.
```
mysql> SELECT PI();
 -> 3.141593
mysql> SELECT PI()+0.000000000000000000;
 -> 3.141592653589793116
```
COS(X)
Retorna o cosseno de X, onde X é dado em radianos:
```
mysql> SELECT COS(PI());
 -> -1.000000
```
SIN(X)
Retorna o seno de X, onde X é dado em radianos:
```
mysql> SELECT SIN(PI());
 -> 0.000000
```
TAN(X)
Retorna a tangente de X, onde X é dado em radianos:
```
mysql> SELECT TAN(PI()+1);
 -> 1.557408
```

ACOS(X)

Retorna o arco cosseno X, isto é, o valor cujo cosseno é X. Retorna NULL se X não está na faixa de -1 a 1:

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

ASIN(X)
Retorna o arco seno X, isto é, o valor cujo seno é X. Retorna NULL se X não está na faixa de -1 a 1:
```
mysql> SELECT ASIN(0.2);
 -> 0.201358
mysql> SELECT ASIN('foo');
 -> 0.000000
```

ATAN(X)

Retorna o arco tangente X, isto é, o valor cuja tangente é X. X:

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

ATAN(Y,X), ATAN2(Y,X)
Retorna o arco tangente de duas variaveis X e Y. É similar ao caclculo do arco tengente de Y / X, exceto que os sinais de ambos argumentos são usados para determinas o quadrante do resultado:
```
mysql> SELECT ATAN(-2,2);
 -> -0.785398
mysql> SELECT ATAN2(PI(),0);
 -> 1.570796
```

COT(X)

Returns a cotangente de X:

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

CRC32(expr)

Calcula um valor de verificação de redundância cíclica e retorna um valor unsigned de 32 bits. O resultado é NULL se o argumento é NULL. O argumento esperado é uma string e será tratado como tal se não for.
```
mysql> SELECT CRC32('MySQL');
 -> 3259397556
```
CRC32() está disponível a partir do MariaDB 4.1.0.
RAND(), RAND(N)
Retorna um valor de ponto flutuante aleatório na faixa de 0 a 1.0. Se um argumento inteiro N é especificado, ele é usado como uma semente (produzindo uma sequência repetitiva):
```
mysql> SELECT RAND();
 -> 0.9233482386203
mysql> SELECT RAND(20);
 -> 0.15888261251047
mysql> SELECT RAND(20);
 -> 0.15888261251047
mysql> SELECT RAND();
 -> 0.63553050033332
mysql> SELECT RAND();
 -> 0.70100469486881
```
Você não pode usar uma coluna com valores RAND() em uma cláusula ORDER BY, pois ORDER BY avaliaria a coluna múltiplas vezes. Na versão 3.23 você pode fazer: SELECT * FROM nome_tabela ORDER BY RAND()
Isto é útil para obter um amostra aleatória de um conjunto SELECT * FROM tabela1,tabela2 WHERE a=b AND c<d ORDER BY RAND() LIMIT 1000.
Note que um RAND() em uma cláusula WHERE será reavliado toda vez que WHERE é executado.
RAND() não é um gerador de números aletatórios perfeito, mas é um modo rápido de se gerar números aleatórios ad hoc que serão portáveis entre plataformas para a mesma versão do MariaDB.
LEAST(X,Y,...)
Com dois ou mais argumentos, retorna o menor (valor-mínimo) argumento. Os argumentos são comparados usando as seguintes regras:
- Se o valor de retorno é usado em um contexto INTEGER, ou todos argumentos são valores inteiro, eles são comparados como inteiros.
- Se o valor de retorno é usado em um contexto REAL, ou todos argumentos são valores reais, eles são comparados como inteiros.
- Se qualquer um dos argumento for uma string caso-sensitivo, os argumentos são comparados como strings caso-sensitivo.
- Nos outros casos, os argumentos são comparados como strings caso-insensitivo:
```
mysql> SELECT LEAST(2,0);
 -> 0
mysql> SELECT LEAST(34.0,3.0,5.0,767.0);
 -> 3.0
mysql> SELECT LEAST('B','A','C');
 -> 'A'
```
Em versões do MariaDB anteriores a versão 3.22.5, você pode usar MIN() no lugar de LEAST.
GREATEST(X,Y,...)
Retorna o maior (valor máximo) argumento. Os argumentos são comparados usando as mesmas regras do LEAST:
```
mysql> SELECT GREATEST(2,0);
 -> 2
mysql> SELECT GREATEST(34.0,3.0,5.0,767.0);
 -> 767.0
mysql> SELECT GREATEST('B','A','C');
 -> 'C'
```
Em versões do MariaDB anteriores a versão 3.22.5, você pode usar MAX() no lugar de GRATEST.
DEGREES(X)
Retorna o argumento X, convertido de radianos para graus:
```
mysql> SELECT DEGREES(PI());
 -> 180.000000
```
RADIANS(X)
Retorna o argumento X, convertido de graus para radianos:
```
mysql> SELECT RADIANS(90);
 -> 1.570796
```
TRUNCATE(X,D)
Retiorna o número X, truncado para D casas decimais. Se D é 0, o resultado não terá ponto deciaml ou prate fracionária:
```
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
```
A partir do MariaDB 3.23.51 todos o números são arredondados para zero.
Se D é negativo, então D numeros da parte inteira são zerados:
```
mysql> SELECT TRUNCATE(122,-2);
 -> 100
```
Note que como os números decimais não são normalmente armazenados como números exatos, mas como valores de dupla precisão, você pode obter o seguinte resultado:
```
mysql> SELECT TRUNCATE(10.28*100,0);
 -> 1027
```
O resultado acima acontece porque 10.28 é, na verdade, armazenado como 10.2799999999999999.

Funções Matematicas

Retornar