Skip navigation links
6.3.4 Funções de Data e Hora »
Section Navigation      [Toggle]

6.3.3.2. 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 MySQL 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 MySQL 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 MySQL. É sinônimo de LOG(X) no MySQL.

  • 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 MySQL. 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 MySQL. 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 MySQL 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 MySQL 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 MySQL.

  • 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 MySQL 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 MySQL 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 MySQL 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.

This is a translation of the MySQL Reference Manual that can be found at dev.mysql.com. The original Reference Manual is in English, and this translation is not necessarily as up to date as the English version.