Use DISTINCT para eliminar redundâncias no MySQL

O DISTINCT pode ser usado para determinar quantos valores redundantes há numa lista ou, pelo contrário, quantos valores distintos há presentes.
Use a cláusula DISTINCT para selecionar os valores únicos ou agregue funções com COUNT(DISTINCT) para contá-los.
O DISTINCROW, caso você já tenha ouvido falar, é sinônimo do DISTINCT — use o que te deixa mais confortável, portanto.
Um relatório que não use funções agregadas é usado para determinar quais valores ou quais registros estão contidos no banco de dados, pela eliminação das redundâncias.
O DISTINCT é útil para reduzir o resultado de uma declaração à sua essência. Pode ser combinado com ORDER BY para ordenar a lista.
Por exemplo, se quiser saber os nomes dos clientes listados na tabela de cli_tabela, use a seguinte consulta:

SELECT DISTINCT cli_nome FROM cli_tabela ORDER BY cli_nome;
_
+----------+
| cli_nome |
+----------+
| Ian      |
| Henry    |
| Justin   |
+----------+

Uma declaração sem o uso da cláusula DISTINCT e ORDER BY produz uma relação com os mesmos nomes, só que não é tão fácil de entender.
Veja como ficaria:

SELECT cli_nome FROM cli_tabela;
_

O resultado contém informação demais e fora de ordem:

+----------+
| cli_nome |
+----------+
| Ian      |
| Justin   |
| Henry    |
| Henry    |
| Ian      |
| Henry    |
| Justin   |
| Henry    |
| Ian      |
| Henry    |
+----------+

Mesmo a relação contendo 10 registros de nomes de clientes, temos na verdade apenas 3 nomes de clientes nesta relação.
Se você quiser obter apenas uma contagem dos nomes de clientes registrados na tabela, use COUNT(DISTINCT). Veja um exemplo:

SELECT COUNT(DISTINCT cli_nome) FROM cli_tabela;

como já sabemos, o resultado é…

+--------------------------+
| COUNT(DISTINCT cli_nome) |
+--------------------------+
|                        3 |
+--------------------------+

A cláusula COUNT(DISTINCT) ignora valores NULL.
Se, por acaso, você tiver interesse em incluir na conta estes tipos de valores, experimente o seguinte artifício:

Substitua, na query acima, a variável valor pelo campo desejado.
As consultas com DISTINCT, comumente são úteis quando combinadas com funções agregadas — podendo produzir uma caracterização mais completa de seus resultados.
Por exemplo, o uso da função COUNT(*) em uma tabela de clientes indica a quantidade de clientes presente.
Ao aplicar DISTINCT aos campos ‘estado’, por exemplo, revela-se em quais estados você tem clientes.
Se usar a combinação COUNT(DISTINCT), então, é possível saber por quantos estados se estende sua clientela.
Ao ser usado com múltiplas colunas, o DISTINCT mostra as diferentes combinações de valores e COUNT(DISTINCT) conta o número de combinações.

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 contar ocorrências e encontrar informações redundantes no MySQL

A função COUNT() pode ser usada para encontrar dados redundantes ou determinar a quantidade de vezes que uma informação se encontra inserida em uma tabela.
Pode vir acompanhada da cláusula GROUP BY para agrupar as ocorrências, na lista — o que torna o relatório mais fácil de compreender.
Se esta situação for um problema para você, leia o artigo Como eliminar registros duplicados no MySQL, para entender como resolvê-la.
Neste texto, vou usar exemplos com a seguinte tabela (vista parcialmente):

SELECT * FROM clientesEstaduais LIMIT 10;
+----+------------------+---------------+--------------+---------------+
| id | NomeCliente      | RegiaoCliente | DataCadastro | CreditCliente |
+----+------------------+---------------+--------------+---------------+
|  1 | Kiara Meadows    | SP            | 2010-11-30   |          2614 |
|  2 | Iris Moreno      | SP            | 2013-03-05   |         13818 |
|  3 | Camilla Klein    | GO            | 2011-04-08   |          4954 |
|  4 | Stephanie Thomas | BA            | 2014-10-06   |          1678 |
|  5 | Emerald Alston   | PE            | 2013-12-02   |         12574 |
|  6 | Nevada Phelps    | PR            | 2014-07-26   |          5080 |
|  7 | Nita Solomon     | MG            | 2013-04-15   |          2267 |
|  8 | Suki Ayers       | MG            | 2014-10-08   |         12884 |
|  9 | Camille Ray      | RS            | 2013-07-11   |         13807 |
| 10 | Chloe Gibbs      | CE            | 2012-11-06   |          8165 |
+----+------------------+---------------+--------------+---------------+
10 rows in set (0.00 sec)

A tabela clientesEstaduais, pode ser encontrada aqui.

A função COUNT() do MySQL

A sintaxe da função é simples: COUNT(expressão).
Veja como contar a quantidade de registros da tabela clientesEstaduais:

SELECT COUNT(*) AS "Qtd. de registros" FROM clientesEstaduais;
+-------------------+
| Qtd. de registros |
+-------------------+
|               100 |
+-------------------+

Veja outras perguntas que podem ser respondidas com o uso da função COUNT() aliada à cláusula WHERE
Quantos clientes são do estado do Paraná (PR)?

SELECT COUNT(*) AS "Clientes do PR" FROM clientesEstaduais WHERE RegiaoCliente = 'PR';
+----------------+
| Clientes do PR |
+----------------+
|              6 |
+----------------+

Quantos clientes foram cadastros em Agosto (em qualquer dia/ano)?

SELECT COUNT(*) AS "Clientes de Agosto" FROM clientesEstaduais WHERE MONTH(DataCadastro)='08';
+--------------------+
| Clientes de Agosto |
+--------------------+
|                 12 |
+--------------------+

Quantos clientes têm mais de 15 mil em créditos?

SELECT COUNT(*) AS "> 15.000" FROM clientesEstaduais WHERE CreditCliente > 15000;
+----------+
| > 15.000 |
+----------+
|       19 |
+----------+

A função COUNT(), tem 2 formas.
A que temos usado, até agora, serve para contar as linhas da tabela: COUNT(*).
A outra forma usa uma expressão, como argumento e é usada para contar os valores não NULL ou non-NULL.
Em outras palavras, registros que contenham o campo NULL, não entram na conta, quando a expressão é dada como argumento.
Veja um exemplo:

SELECT COUNT(*) AS "Núm. de clientes",
    -> COUNT(DataCadastro) AS "Clientes cadastrados"
    -> FROM clientesEstaduais;

Uma vez que 2 clientes têm data de cadastro vazia (DataCadastro = NULL), a segunda coluna só irá contar 98:

+-------------------+----------------------+
| Núm. de clientes  | Clientes cadastrados |
+-------------------+----------------------+
|               100 |                   98 |
+-------------------+----------------------+

Como usar COUNT() com a cláusula GROUP BY

Além de ver os valores, você pode listar os registros, para ter um relatório mais rico.
No exemplo, abaixo, veja como obter a relação de estados presentes no cadastro de clientes, a quantidade de clientes por estado e em ordem descendente:

SELECT RegiaoCliente AS "Estados",
    -> COUNT(*) AS "Núm. de clientes"
    -> FROM clientesEstaduais
    -> GROUP BY RegiaoCliente
    -> ORDER BY COUNT(*) DESC;
+---------+-------------------+
| Estados | Núm. de clientes  |
+---------+-------------------+
| SP      |                30 |
| MG      |                18 |
| BA      |                10 |
| RJ      |                 9 |
| PR      |                 6 |
| RS      |                 6 |
| PE      |                 5 |
| CE      |                 5 |
| GO      |                 5 |
| MA      |                 3 |
| PA      |                 2 |
| PB      |                 1 |
+---------+-------------------+

No mês de Agosto, em quais datas houve maior número de cadastros?

SELECT DataCadastro,
    -> COUNT(*) FROM clientesEstaduais
    -> WHERE MONTH(DataCadastro)='08'
    -> GROUP BY DataCadastro
    -> ORDER BY COUNT(*) DESC;
+--------------+----------+
| DataCadastro | COUNT(*) |
+--------------+----------+
| 2016-08-21   |        2 |
| 2016-08-15   |        2 |
| 2016-08-11   |        2 |
| 2016-08-19   |        1 |
| 2016-08-16   |        1 |
| 2016-08-20   |        1 |
| 2016-08-13   |        1 |
| 2016-08-17   |        1 |
| 2016-08-09   |        1 |
+--------------+----------+

É possível fazer análise de big data com MySQL?

Sim. Na realidade, o MySQL já é usado na análise de big data (ou megadados) — tanto quanto o PostgreSQL.
No caso do MySQL, as estruturas InnoDB organizadas em índices oferecem vantagens para as atividades de análise de megadados — boa estrutura name-value-pair (ou par-valor-nome), que é mais útil para análise do que os índices secundários.
Para fazer análises de big data, você passa por processo semelhante ao que passaria usando o Hadoop, por exemplo:

  • organizar preliminarmente os dados
  • criar estruturas otimizadas especificametne para a sua análise
  • criar a estrutura de busca

Com um grande “parque de máquinas”, é desejável paralelizar o processo e usar scripts de análise que o façam localmente, em cada instância — com um subprocesso de agregação dos resultados ao final.
Se for usar o Hadoop de forma mais tradicional sobre dados desestruturados, use o MySQL para armazenar os resultados agregados pelo Hadoop.

Soluções de análise de big data com o MySQL

De maneira geral, há 2 maneiras de realizar a análise de megadados no MySQL:

  • O MySQL pode ser usado em conjunto com um sistema mais tradicional para lidar com big data — como o Hadoop.
    Grandes quantidades de dados podem ser armazenados em HDFS e processados com o Hadoop — com o resultado armazenado no MySQL, para a análise.

    O HDFS (Hadoop Distributed File System) é um sistema de arquivos distribuído, que armazena dados em commodity machines oferecendo grande largura de banda para fluxo de dados em um cluster.

    Por exemplo, a métrica crua pode ser armazenada em HDFS, mas os dados agregados e sumarizados são enviados ao MySQL, onde são analisados.

  • O MySQL pode ser usado como um grande armazém de dados.
    Tipicamente, ele ficará fragmentado para suportar tal volume de dados.
    Neste caso, os mecanismos de armazenamento mais adequados são o InnoDB ou o TokuDB. Alternativamente, os mecanismos InfoBright ou InfiniDB também podem ser empregados.

Sendo o banco de dados de código aberto líder na web em aplicações baseadas na nuvem (cloud based applications), o MySQL se integra às plataformas de big data.
O uso de soluções MySQL com Hadoop é o que ajuda a resolver problemas envolvendo big data.
Referências sobre o Hadoop: http://hadoop.apache.org/docs/r1.2.1/hdfs_design.html.