Como somar valores no MySQL

Em uma coluna ou em um conjunto de números, pode ser necessário determinar a soma. Use a função SUM() do MySQL para realizar esta operação.
Para começar o texto com um exemplo, veja um envolvendo todos os valores da coluna ‘CreditCliente’, que contem uma relação de créditos dos clientes na tabela ‘clientesEstaduais‘.

SELECT SUM(CreditCliente) FROM clientesEstaduais;
+--------------------+
| SUM(CreditCliente) |
+--------------------+
|             946227 |
+--------------------+

Veja a relação de clientes do Ceará (CE):

SELECT * FROM clientesEstaduais WHERE RegiaoCliente = 'CE';
+----+---------------+---------------+--------------+---------------+
| id | NomeCliente   | RegiaoCliente | DataCadastro | CreditCliente |
+----+---------------+---------------+--------------+---------------+
| 10 | Chloe Gibbs   | CE            | 2016-05-11   |          8165 |
| 14 | Winter Carson | CE            | 2016-12-10   |          2524 |
| 53 | Alea Byrd     | CE            | 2016-02-11   |          5592 |
| 76 | Taylor Ingram | CE            | 2016-06-19   |         15843 |
| 94 | Tanya Barr    | CE            | 2016-01-20   |          3252 |
+----+---------------+---------------+--------------+---------------+

Agora veja a soma de todos os seus créditos:

SELECT SUM(creditCliente) AS "Créditos CE" FROM clientesEstaduais WHERE RegiaoCliente = 'CE';
+--------------+
| Créditos CE  |
+--------------+
|        35376 |
+--------------+

Para ver todos os créditos referentes a um mês (de qualquer dia e qualquer ano):

SELECT SUM(creditCliente) AS "Créditos de Agosto" FROM clientesEstaduais WHERE MONTH(DataCadastro)='08';
+---------------------+
| Créditos de Agosto  |
+---------------------+
|              134245 |
+---------------------+

Como encontrar o maior ou o menor valor de uma lista no MySQL

As funções MIN() e MAX() podem ser usadas para encontrar o maior e o menor valor, respectivamente, dentro de uma lista de valores, no MySQL.
De certa forma, esta solução se equipara a organizar uma lista do menor valor para o maior (ou vice-versa) — e, destes itens, você escolhe apenas o primeiro valor, em vez de todos.
Este tipo de operação é feita para responder a perguntas como:

  • Qual o menor…
  • Qual o maior…
  • Qual o mais antigo…
  • Qual o mais recente…
  • Qual o mais caro…
  • Qual o mais barato…
  • etc.

Uma outra forma de resolver esta questão é com o uso da cláusula LIMIT.
As funções MIN() e MAX(), por determinarem os valores extremos de um conjunto são apropriadas para determinar limites numéricos.
Veja um exemplo, para determinar o primeiro e o último cadastro, o maior e o menor valor de crédito em uma tabela:

SELECT MIN(DataCadastro) AS "Primeiro cadastro",
    -> MAX(DataCadastro) AS "Cadastro mais recente",
    -> MIN(CreditCliente) AS "Menor valor de crédito",
    -> MAX(CreditCliente) AS "Maior valor de crédito"
    -> FROM clientesEstaduais;
+-------------------+-----------------------+-------------------------+-------------------------+
| Primeiro cadastro | Cadastro mais recente | Menor valor de crédito  | Maior valor de crédito  |
+-------------------+-----------------------+-------------------------+-------------------------+
| 2016-01-09        | 2016-12-21            |                     385 |                   19637 |
+-------------------+-----------------------+-------------------------+-------------------------+

Qual cliente tem o maior nome?

SELECT MIN(LENGTH(NomeCliente)) AS "Menor nome",
    -> MAX(LENGTH(NomeCliente)) AS "Maior nome"
    -> FROM clientesEstaduais;
+------------+------------+
| Menor nome | Maior nome |
+------------+------------+
|          8 |         19 |
+------------+------------+

Como determinar quando um ano é bissexto no MySQL

Veja alguns meios eficazes de determinar se um ano é bissexto ou não no MySQL.
Sabemos que alguns cálculos envolvendo anos ou dias dos anos pode se tornar complicados em função de alguns anos terem um dia a mais.
Neste texto, vou mostrar como determinar se um ano é bissexto ou não.
O fato de que um mês pode ter um dia a mais em alguns anos, já pode servir de complicador para realizar algumas contas.
Para determinar se uma determinada data cai ou não em um ano bissexto você deva obter o componente de ano, com a função YEAR() e testar este resultado.
Há um regra geral de que os anos bissextos são todos divisíveis por 4. Isto pode ser testado com o uso do operador de módulo, assim:

SELECT YEAR(DataNascimentoCliente) AS "Anos", YEAR(DataNascimentoCliente)% 4=0 AS "Anos normais/bissextos" FROM CadastroClientes LIMIT 10;
+------+------------------------+
| Anos | Anos normais/bissextos |
+------+------------------------+
| 1984 |                      1 |
| 1984 |                      1 |
| 1981 |                      0 |
| 1983 |                      0 |
| 1969 |                      0 |
| 1979 |                      0 |
| 1976 |                      1 |
| 1975 |                      0 |
| 1983 |                      0 |
| 1978 |                      0 |
+------+------------------------+

Os anos ‘1’ são bissextos.
Esta abordagem não é perfeita, contudo. O ano 1900 é também divisível por 4 e… não é bissexto.
Portanto, para que um ano seja qualificado como bissexto, precisa satisfazer a estas 2 condições:

  • o ano tem que ser divisível por 4
  • não pode ser divisível por 100, a menos que seja também divisível por 400

Vamos a uma query que faça estas filtragens:

SELECT YEAR(DataNascimentoCliente) AS ANO, (YEAR(DataNascimentoCliente) %4 = 0) AND (YEAR(DataNascimentoCliente) % 100 != 0) OR (YEAR(DataNascimentoCliente) % 400 = 0) AS "Teste completo" FROM CadastroClientes LIMIT 10;
+------+----------------+
| ANO  | Teste completo |
+------+----------------+
| 1984 |              1 |
| 1984 |              1 |
| 1981 |              0 |
| 1983 |              0 |
| 1969 |              0 |
| 1979 |              0 |
| 1976 |              1 |
| 1975 |              0 |
| 1983 |              0 |
| 1978 |              0 |
+------+----------------+

Pronto. Este método é mais seguro que o anterior — mas pode ser desnecessário se o seu banco de dados não inclui a possibilidade de lidar com o ano 1900…

Como determinar o primeiro e o último dia do mês no MySQL

Dada uma data, você deseja determinar qual o primeiro dia da semana naquele mês ou qual o último dia do mês (28, 29, 30 ou 31).
Veja algumas abordagens para este problema — e use a que melhor lhe convier.
Se você conhece outra solução, dentro do MySQL, sinta-se à vontade para expôr nos comentários.
Logo MySQL - The Dolphin.
Abaixo, veja como resolver o problema usando uma combinação das funções DATE_SUB() e DAYOFMONTH(). Neste caso

SELECT '2016-07-19', DATE_SUB('2016-07-19', INTERVAL DAYOFMONTH('2016-07-19')-1 DAY) AS 'Primeiro dia do mês';
+------------+----------------------+
| 2016-07-19 | Primeiro dia do mês  |
+------------+----------------------+
| 2016-07-19 | 2016-07-01           |
+------------+----------------------+

Obviamente, o primeiro dia de um mês é sempre o dia 01.
Faz mais sentido determinar em que dia da semana cai o primeiro dia do mês. isto pode ser feito com o acréscimo da função DAYOFWEEK():

SELECT '2016-07-19', DAYOFWEEK(DATE_SUB('2016-07-19', INTERVAL DAYOFMONTH('2016-07-19')-1 DAY)) AS 'Primeiro dia do mês';
+------------+----------------------+
| 2016-07-19 | Primeiro dia do mês  |
+------------+----------------------+
| 2016-07-19 |                    6 |
+------------+----------------------+

Sabendo que Domingo é o dia 1, chega-se à conclusão de que o dia 6 é Sexta-feira.
Com a função DAYNAME() fica mais fácil obter esta informação, veja:

SELECT '2016-07-19', DAYNAME(DATE_SUB('2016-07-19', INTERVAL DAYOFMONTH('2016-07-19')-1 DAY)) AS 'Primeiro dia do mês';
+------------+----------------------+
| 2016-07-19 | Primeiro dia do mês  |
+------------+----------------------+
| 2016-07-19 | sexta                |
+------------+----------------------+

A abordagem, que vimos é um tanto complexa e serve apenas para demonstrar algumas funções de manipulação das informações de data do MySQL.
Veja, a seguir, algumas maneiras mais rápidas de obter suas respostas.

Como estabelecer o último dia do mês no MySQL

A função LAST_DAY() pode dar este resultado num piscar de olhos. Sua sintaxe é simples e pede apenas uma data:

SELECT LAST_DAY('2016-02-15') AS 'Últ. dia do mês';
+-------------------+
| Últ. dia do mês   |
+-------------------+
| 2016-02-29        |
+-------------------+

Esta é uma maneira fácil de saber quantos dias o mẽs de Fevereiro terá em um determinado ano.
Você pode aninhar funções e descobrir um pouco mais — por exemplo, em qual dia da semana, cai esta data:

SELECT DAYNAME(LAST_DAY('2016-02-15')) AS 'Últ. dia do mês';
+-------------------+
| Últ. dia do mês   |
+-------------------+
| segunda           |
+-------------------+

A função LAST_DAY() também pode ser usada para determinar a extensão do mês ou o que falta para concluí-lo a partir de uma determinada data.

Como usar a função LAST_DAY para determinar qual o primeiro dia do mês

Ainda não existe a função FIRST_DAY(), no MySQL. E, de certa forma, ela é desnecessária.
O que varia, de mês para mês, é o último dia — que pode ser 28, 29, 30 ou 31.
O primeiro dia de cada mês, é sempre o dia 01 — mas o dia da semana varia, conforme demonstramos no começo deste artigo.
Tecnicamente, o primeiro dia de cada mês é sempre o dia posterior à data retornada por LAST_DAY(), referente ao mês anterior. Por exemplo: LAST_DAY('uma data do mẽs de Março')+1 = primeiro dia do mẽs de Abril.
Veja esta outra solução para determinar o primeiro dia de um determinado mẽs:

SELECT CURDATE( ) AS 'Hoje', ADDDATE(LAST_DAY(SUBDATE(CURDATE(), INTERVAL 1 MONTH)), 1) AS 'Primeiro dia do mês';
+------------+----------------------+
| Hoje       | Primeiro dia do mês  |
+------------+----------------------+
| 2015-07-12 | 2015-07-01           |
+------------+----------------------+

Veja o que fizemos no exemplo acima:

  • subtraímos um mês ao resultados de CURDATE() Para obter o mesmo dia do mês anterior
  • A partir daí usamos a função LAST_DAY() para estabelecer o último dia daquele mês
  • Finalmente, a função ADDDATE() é usada para adicionar um dia ao resultado — o que nos dá o primeiro dia do mẽs subsequente (que é o mês atual)

Este método pode ser usado, sem perigo de obter resultados indesejados, quando datas entre Dezembro e Janeiro de outro ano, estiverem envolvidas na conta.
Para determinar a que dia da semana pertence a data obtida, aninhe a query dentro da função DAYNAME():

SELECT CURDATE( ) AS 'Hoje', DAYNAME(ADDDATE(LAST_DAY(SUBDATE(CURDATE(), INTERVAL 1 MONTH)), 1)) AS 'Primeiro dia do mês';
+------------+----------------------+
| Hoje       | Primeiro dia do mês  |
+------------+----------------------+
| 2015-07-12 | quarta               |
+------------+----------------------+

Como calcular a idade de uma pessoa no MySQL

Você tem uma ou várias datas de nascimento armazenadas em um banco de dados MySQL e gostaria de calcular as idades de cada pessoa, em relação à data de hoje.
O problema pode ser solucionado computando o intervalo entre as datas — sendo que a mesma abordagem pode ser usada para resolver inúmeras outras situações.
mysql logo over gray ubuntu wallpaper
Determinar a idade envolve calcular o intervalo, decorrido em anos, entre duas datas — mas você não pode fazer isto apenas dividindo a quantidade de dias decorridos por 365, sob pena de obter um resultado inexato — uma vez que este método não inclui os anos bissextos.
Algumas metodologias fazem a divisão por 365,25, o que ajuda a obter resultados menos inexatos.
Neste texto, vou abordar alguns métodos mais precisos para calcular a idade em anos e meses.

Como determinar uma idade em anos

Como já foi dito, não dá para efetuar a operação, contando o número de dias percorridos entre a data de nascimento e a data alvo, uma vez que anos diferentes podem ter uma quantidade diferente de dias.
Uma outra possibilidade é deduzir o ano de nascimento do ano atual. Veja:

SELECT YEAR('2015-06-22')-YEAR('1913-10-19')
    ->  AS "Idade de Vinícius de Moraes"\G
*************************** 1. row ***************************
Idade de Vinícius de Moraes: 102
1 row in set (0.00 sec)

O problema desta abordagem, é que em Junho de 2015, o poeta Vinícius de Moraes ainda teria 101 anos — uma vez que seu mês de nascimento é Outubro.
Ao lidar com clientes, sabemos que algumas pessoas se incomodam quando lhes atribuímos uma idade acima da que realmente têm — por isto é que precisamos determinar suas idades de maneira mais precisa.
Veja outro exemplo (mais complexo) da aplicação deste método.

SELECT NomeCliente AS Cliente,
    ->  DATE_FORMAT(DataNascimentoCliente,'%d de %M de %Y') AS "Data nasc.",
    ->  YEAR(CURDATE()) - YEAR(DataNascimentoCliente) AS Idade
    ->  FROM CadastroClientes
    ->  WHERE YEAR(DataNascimentoCliente) > 1983;

Em destaque, as idades que estão “adiantadas” em relação 22 de Junho de 2015:

+-------------------+-------------------------+-------+
| Cliente           | Data nasc.              | Idade |
+-------------------+-------------------------+-------+
| Christen Wiggins  | 11 de abril de 1984     |    31 |
| Justine Howard    | 22 de dezembro de 1984  |    31 |
| Anika Hammond     | 01 de agosto de 1985    |    30 |
| Alea Vang         | 09 de julho de 1984     |    31 |
| Fredericka Jensen | 29 de fevereiro de 1984 |    31 |
| Alexa Duncan      | 09 de abril de 1985     |    30 |
| Lynn Mclean       | 11 de novembro de 1984  |    31 |
| Allegra Cantrell  | 19 de março de 1984     |    31 |
+-------------------+-------------------------+-------+
8 rows in set (0.00 sec)

Exemplos de uso da função TIMESTAMPDIFF, para calcular a idade exata

Para evitar qualquer desconforto, criado pela falta de exatidão, use a função TIMESTAMPDIFF() — com ela, é possível obter a idade exata de uma pessoa.
Veja um exemplo de uso:

SELECT TIMESTAMPDIFF (YEAR,'1913-10-19',CURDATE())
    ->  AS "Idade de Vinícius de Moraes";

Se a data atual for 22 de Junho de 2015, o resultado para a idade de Vinícius de Moraes é:

+------------------------------+
| Idade de Vinícius de Moraes  |
+------------------------------+
|                          101 |
+------------------------------+
1 row in set (0.00 sec)

A lista de aniversariantes, anterior, também muda (para melhor) com esta abordagem:

SELECT NomeCliente AS Nome,
    ->  DATE_FORMAT(DataNascimentoCliente, '%d de %M de %Y') AS Nascimento,
    ->  TIMESTAMPDIFF(YEAR,DataNascimentoCliente,CURDATE()) AS Idade
    ->  FROM CadastroClientes
    ->  WHERE YEAR(DataNascimentoCliente) > 1983;
+-------------------+-------------------------+-------+
| Nome              | Nascimento              | Idade |
+-------------------+-------------------------+-------+
| Christen Wiggins  | 11 de abril de 1984     |    31 |
| Justine Howard    | 22 de dezembro de 1984  |    30 |
| Anika Hammond     | 01 de agosto de 1985    |    29 |
| Alea Vang         | 09 de julho de 1984     |    30 |
| Fredericka Jensen | 29 de fevereiro de 1984 |    31 |
| Alexa Duncan      | 09 de abril de 1985     |    30 |
| Lynn Mclean       | 11 de novembro de 1984  |    30 |
| Allegra Cantrell  | 19 de março de 1984     |    31 |
+-------------------+-------------------------+-------+
8 rows in set (0.00 sec)

Como obter a idade em meses ou dias

A função TIMESTAMPDIFF() permite estabelecer o resultado em MESES ou DIAS, de maneira simples.
Vejamos quantos meses de idade a cantora Pitty tem:

SELECT TIMESTAMPDIFF (MONTH,'1977-10-07',CURDATE()) AS "Idade da Pitty"\G
*************************** 1. row ***************************
Idade da Pitty: 452
1 row in set (0.00 sec)

Ou em dias:

SELECT TIMESTAMPDIFF (DAY,'1977-10-07',CURDATE()) AS "Idade da Pitty"\G
*************************** 1. row ***************************
Idade da Pitty: 13772
1 row in set (0.00 sec)

Este método pode ser usado em várias outras situações, como estabelecer há quanto tempo um documento está vencido, calcular dívidas etc.
Referência: http://dev.mysql.com/doc/refman/5.7/en/date-calculations.html