Recuperando Informações de uma Tabela - Criação e Utilização de um Banco de Dados

3. Tutorial de Introdução Do MySQL

3.3. Criação e Utilização de um Banco de Dados

3.3.4. Recuperando Informações de uma Tabela

A instruçãoSELECTé usada para recuperar informações de uma tabela. A forma geral da instrução é:

SELECT o_que_mostrar FROM de_qual_tabela

WHERE condições_para_satisfazer;

o_que_mostrarindica o que você deseja ver. Isto pode ser uma lista de colunas ou*para indicar ``todas colunas.''

de_qual_tabelaindica a tabela de onde você deseja recuperar os dados. A cláusulaWHEREé opcional. Se estiver presente,

condições_para_satisfazerespecificam as condições que os registros devem satisfazer para fazer parte do resultado.

3.3.4.1. Selecionando Todos os Dados

A forma mais simples doSELECTrecuperar tudo de uma tabela:

mysql> SELECT * FROM pet;

+---+---+---+---+---+---+ | name | owner | species | sex | birth | death | +---+---+---+---+---+---+ | Fluffy | Harold | cat | f | 1993-02-04 | NULL | | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | | Fang | Benny | dog | m | 1990-08-27 | NULL | | Bowser | Diane | dog | m | 1979-08-31 | 1995-07-29 | | Chirpy | Gwen | bird | f | 1998-09-11 | NULL | | Whistler | Gwen | bird | NULL | 1997-12-09 | NULL | | Slim | Benny | snake | m | 1996-04-29 | NULL | | Puffball | Diane | hamster | f | 1999-03-30 | NULL | +---+---+---+---+---+---+

Esta forma doSELECTé útil se você deseja ver sua tabela inteira como agora, depois de você acabar de carregá-la com os dados iniciais. Por exempo, você pode pensar que a data de nascimento do Bowser não está correta. Consultando seus papéis originais de pedigree, descobriu que o ano correto do nascimento deve ser 1989, não 1979.

Existem pelo menos duas formas de corrigir isto:

• Edite o arquivopet.txtpara corrigir o erro, depois limpe a tabela e recarregue-o usandoDELETEeLOAD DATA:

mysql> DELETE FROM pet;

mysql> LOAD DATA LOCAL INFILE "pet.txt" INTO TABLE pet;

Entretanto, se você fizer isto, você também deve refazer a entrada para Puffball. • Corrigir somente o registro errado com uma instruçãoUPDATE:

OUPDATEaltera apenas o registro em questão e não exige que você recarregue a tabela.

3.3.4.2. Selecionando Registros Específicos

Como foi mostrado na seção anterior, é fácil recuperar uma tabela inteira. Apenas omita a cláusulaWHEREda instruçãoSELECT. Mas normalmente você não quer ver toda a tabela, particularmente quando a tabela ficar grande. Em vez disso, você estará mais interessado em ter a resposta de uma questão em particular, no qual você especifica detalhes da informação que deseja. Vamos ver algumas consultas de seleção nos termos das questões sobre seus animais.

Você pode selecionar apenas registros específicos da sua tabela. Por exemplo, se você deseja verificar a alteração que fez na data de nascimento do Bowser, selecione o registro desta forma:

mysql> SELECT * FROM pet WHERE name = "Bowser";

+---+---+---+---+---+---+ | name | owner | species | sex | birth | death | +---+---+---+---+---+---+ | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | +---+---+---+---+---+---+

A saída confirma que o ano foi gravado corretamente agora como 1989 e não 1979.

Comparações de strings normalmente são caso insensitivo, então você pode especificar o nome como"bowser","BOWSER", etc. O resultado da pesquisa será o mesmo.

Você pode especificar condições em qualquer coluna, não apenas noname. Por exemplo, se você deseja saber quais foram os animais que nasceram depois de 1998, teste o campobirth:

mysql> SELECT * FROM pet WHERE birth >= "1998-1-1";

Você pode combinar condições, por exemplo, para encontrar cadelas (dog/f):

mysql> SELECT * FROM pet WHERE species = "dog" AND sex = "f";

+---+---+---+---+---+---+ | name | owner | species | sex | birth | death | +---+---+---+---+---+---+ | Buffy | Harold | dog | f | 1989-05-13 | NULL | +---+---+---+---+---+---+

A consulta anterior utiliza o operador lógicoAND(e). Existe também um operadorOR(ou):

mysql> SELECT * FROM pet WHERE species = "snake" OR species = "bird";

ANDeORpodem ser misturados, emboraANDtem maior precedência queOR. Se você usar ambos os operadores, é uma ótima idéia usar parênteses para indicar explicitamente quais condições devem ser agrupadas:

mysql> SELECT * FROM pet WHERE (species = "cat" AND sex = "m")

-> OR (species = "dog" AND sex = "f");

+---+---+---+---+---+---+ | name | owner | species | sex | birth | death | +---+---+---+---+---+---+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +---+---+---+---+---+---+

3.3.4.3. Selecionando Colunas Específicas

Se você não desejar ver todo o registro de sua tabela, especifique as colunas em que você estiver interessado, separado por vírgulas. Por exemplo, se você deseja saber quando seus animais nasceram, selecione as colunasnameebirth:

mysql> SELECT name, birth FROM pet;

+---+---+ | name | birth |

+---+---+ | Fluffy | 1993-02-04 | | Claws | 1994-03-17 | | Buffy | 1989-05-13 | | Fang | 1990-08-27 | | Bowser | 1989-08-31 | | Chirpy | 1998-09-11 | | Whistler | 1997-12-09 | | Slim | 1996-04-29 | | Puffball | 1999-03-30 | +---+---+

Para saber quem são os donos dos animais, use esta consulta:

mysql> SELECT owner FROM pet;

Entretanto, perceba que a query simplesmente retornou o campoownerde cada registro, e alguns deles apareceram mais de uma vez. Para minimizar a saída, recupere cada registro apenas uma vez, adicionando a palavra chaveDISTINCT:

mysql> SELECT DISTINCT owner FROM pet;

Você pode usar uma cláusulaWHEREpara combinar seleção de registros com seleção de colunas. Por exemplo, para obter a data de nascimento somente dos gatos e cachorros, utilize esta query:

mysql> SELECT name, species, birth FROM pet

-> WHERE species = "dog" OR species = "cat";

+---+---+---+ | name | species | birth | +---+---+---+ | Fluffy | cat | 1993-02-04 | | Claws | cat | 1994-03-17 | | Buffy | dog | 1989-05-13 | | Fang | dog | 1990-08-27 | | Bowser | dog | 1989-08-31 | +---+---+---+

3.3.4.4. Ordenando Registros

Você deve ter percebido nos exemplos anteriores que os registros retornados não são mostrados de forma ordenada. Normalmente é mais fácil examinar a saída da consulta quando os registros são ordenados com algum sentido. Para ordenar o resultado, utilize uma cláusulaORDER BY.

Aqui está o dia de nascimento dos animais, ordenado por data:

mysql> SELECT name, birth FROM pet ORDER BY birth;

+---+---+ | name | birth | +---+---+ | Buffy | 1989-05-13 | | Bowser | 1989-08-31 | | Fang | 1990-08-27 | | Fluffy | 1993-02-04 | | Claws | 1994-03-17 | | Slim | 1996-04-29 | | Whistler | 1997-12-09 | | Chirpy | 1998-09-11 | | Puffball | 1999-03-30 | +---+---+

Em colunas de tipo de caracter, ordenaição ¯ como qualquer outra operação de comparação ¯ é normalmente realizada no modo caso insensitivo. Isto significa que a ordem será indefinida para colunas que são idênticas exceto quanto ao caso da letra. Você pode forçar uma ordenação em caso senitivo para uma coluna usando a coerção BINARY:ORDER BY BINARY(campo).

A ordenação padrão é crescente, com os valores menores em primeiro. Para ordenação na ordem reversa, adicione a palavra chave

DESC(descendente) ao nome da coluna que deve ser ordenada:

mysql> SELECT name, birth FROM pet ORDER BY birth DESC;

+---+---+ | name | birth | +---+---+ | Puffball | 1999-03-30 | | Chirpy | 1998-09-11 | | Whistler | 1997-12-09 | | Slim | 1996-04-29 | | Claws | 1994-03-17 | | Fluffy | 1993-02-04 | | Fang | 1990-08-27 | | Bowser | 1989-08-31 | | Buffy | 1989-05-13 | +---+---+

Você pode ordenar por múltiplas colunas e você pode classificar colunas em direções diferentes. Por exemplo, para ordenar o tipo de animal em ordem crescente, depois por dia de nascimento dentro do tipo de animal em ordem decrescente (com os mais novos primeiro), utilize a seguinte consulta:

mysql> SELECT name, species, birth FROM pet ORDER BY species, birth DESC;

+---+---+---+ | name | species | birth | +---+---+---+ | Chirpy | bird | 1998-09-11 | | Whistler | bird | 1997-12-09 | | Claws | cat | 1994-03-17 | | Fluffy | cat | 1993-02-04 | | Fang | dog | 1990-08-27 | | Bowser | dog | 1989-08-31 | | Buffy | dog | 1989-05-13 | | Puffball | hamster | 1999-03-30 | | Slim | snake | 1996-04-29 | +---+---+---+

Perceba que a palavra chaveDESCaplica somente para o nome da coluna precedente (birth); ela não afeta a ordenação da coluna

species.

3.3.4.5. Cálculo de Datas

O MySQL fornece várias funções que você pode usar para realizar cálculos em datas, por exemplo, para calcular idades ou extrair partes de datas.

Para determinar quantos anos cada um do seus animais tem, compute a diferença do ano da data atual e a data de nascimento (birth), depois subtraia se a o dia/mês da data atual for anterior ao dia/mês da data de nascimento. A consulta seguinte, mostra, para cada animal, a data de nascimento, a data atual e a idade em anos.

mysql> SELECT name, birth, CURDATE(),

-> (YEAR(CURDATE())-YEAR(birth))

-> - (RIGHT(CURDATE(),5)<RIGHT(birth,5))

-> AS age

-> FROM pet;

+---+---+---+---+ | name | birth | CURDATE() | age | +---+---+---+---+ | Fluffy | 1993-02-04 | 2003-08-19 | 10 | | Claws | 1994-03-17 | 2003-08-19 | 9 | | Buffy | 1989-05-13 | 2003-08-19 | 14 | | Fang | 1990-08-27 | 2003-08-19 | 12 | | Bowser | 1989-08-31 | 2003-08-19 | 13 | | Chirpy | 1998-09-11 | 2003-08-19 | 4 | | Whistler | 1997-12-09 | 2003-08-19 | 5 | | Slim | 1996-04-29 | 2003-08-19 | 7 | | Puffball | 1999-03-30 | 2003-08-19 | 4 | +---+---+---+---+

Aqui,YEAR()separa a parte do ano de uma data eRIGHT()separa os cinco caracteres mais a direita que representam a parte da dataMM-DD. A parte da expressão que compara os valoresMM-DDresulta em 1 ou 0, o qual ajusta a diferença do ano um ano abaixo seCURDATEocorrer mais cedo, no ano, quebirth. A expressão completa é um tanto deselegante, então um apelido (age) é usado para obter uma saída mais significativa.

A consulta funciona, mas o resultado pode ser mais compreensível se os registros forem apresentados em alguma ordem. Isto pode ser feito adicionando uma cláusulaORDER BY namepara ordenar a saída pelo nome:

mysql> SELECT name, birth, CURDATE(),

-> (YEAR(CURDATE())-YEAR(birth))

-> - (RIGHT(CURDATE(),5)<RIGHT(birth,5))

-> AS age

-> FROM pet ORDER BY name;

| name | birth | CURDATE() | age | +---+---+---+---+ | Bowser | 1989-08-31 | 2003-08-19 | 13 | | Buffy | 1989-05-13 | 2003-08-19 | 14 | | Chirpy | 1998-09-11 | 2003-08-19 | 4 | | Claws | 1994-03-17 | 2003-08-19 | 9 | | Fang | 1990-08-27 | 2003-08-19 | 12 | | Fluffy | 1993-02-04 | 2003-08-19 | 10 | | Puffball | 1999-03-30 | 2003-08-19 | 4 | | Slim | 1996-04-29 | 2003-08-19 | 7 | | Whistler | 1997-12-09 | 2003-08-19 | 5 | +---+---+---+---+

Para ordenar a saída porageem vez dename, é só utilizar uma cláusuaORDER BYdiferente:

mysql> SELECT name, birth, CURDATE(),

-> (YEAR(CURDATE())-YEAR(birth))

-> - (RIGHT(CURDATE(),5)<RIGHT(birth,5))

-> AS age

-> FROM pet ORDER BY age;

+---+---+---+---+ | name | birth | CURDATE() | age | +---+---+---+---+ | Chirpy | 1998-09-11 | 2003-08-19 | 4 | | Puffball | 1999-03-30 | 2003-08-19 | 4 | | Whistler | 1997-12-09 | 2003-08-19 | 5 | | Slim | 1996-04-29 | 2003-08-19 | 7 | | Claws | 1994-03-17 | 2003-08-19 | 9 | | Fluffy | 1993-02-04 | 2003-08-19 | 10 | | Fang | 1990-08-27 | 2003-08-19 | 12 | | Bowser | 1989-08-31 | 2003-08-19 | 13 | | Buffy | 1989-05-13 | 2003-08-19 | 14 | +---+---+---+---+

Uma consulta similar pode ser usada para determinar a idade na morte para animais que morreram. Para determinar quais são os animais, confira se o valor dedeathnão éNULL. Depois para estes com valores não-NULL, compute a diferença entre os valores dos camposdeathebirth:

mysql> SELECT name, birth, death,

-> (YEAR(death)-YEAR(birth)) - (RIGHT(death,5)<RIGHT(birth,5))

-> AS age

-> FROM pet WHERE death IS NOT NULL ORDER BY age;

+---+---+---+---+ | name | birth | death | age | +---+---+---+---+ | Bowser | 1989-08-31 | 1995-07-29 | 5 | +---+---+---+---+

A consulta usadeath IS NOT NULLem vez dedeath != NULLporqueNULLé um valor especial que não pode ser compa- rada usando operadores comuns de comparação. Isto será explicado depois. SeeSecção 3.3.4.6, “Trabalhando com Valores Nulos (NULL)”.

E se você desejar saber quais animais fazem aniversário no próximo mês? Para este tipo de cálculo, ano e dia são irrelevantes; você simplesmente deseja extrair a parte do mês da colunabirth. O MySQL fornece diversas funções para extrair partes da data, como emYEAR(),MONTH()eDAYOFMONTH().MONTHé a função apropriada aqui. Para ver como ela funciona, execute uma consulta simples que mostre o valor debirtheMONTH(birth):

mysql> SELECT name, birth, MONTH(birth) FROM pet;

+---+---+---+ | name | birth | MONTH(birth) | +---+---+---+ | Fluffy | 1993-02-04 | 2 | | Claws | 1994-03-17 | 3 | | Buffy | 1989-05-13 | 5 | | Fang | 1990-08-27 | 8 | | Bowser | 1989-08-31 | 8 | | Chirpy | 1998-09-11 | 9 | | Whistler | 1997-12-09 | 12 | | Slim | 1996-04-29 | 4 | | Puffball | 1999-03-30 | 3 | +---+---+---+

Encontrar animais com aníversário no próximo mês também é fácil. Suponha que o mês atual é abril. Então o valor do mês é4e você procura por animais nascidos em Maio (mês5) assim:

mysql> SELECT name, birth FROM pet WHERE MONTH(birth) = 5;

+---+---+ | name | birth | +---+---+ | Buffy | 1989-05-13 | +---+---+

Existe uma pequena complicação se o mês atual é Dezembro, é claro. Você não pode apenas adicionar um para o número do mês (12) e procurar por animais nascidos no mês13, porque não existe tal mês. O certo seria procurar por animais nascidos em Janeiro

(mês1).

Você pode também escrever uma consulta para que funcione sem importar qual é o mês atual. Assim você não têm quee usar um número de mês em particular na consulta.DATE_ADD()permite adicionar um intervalo de tempo para uma data fornecida. Se vo- cê adicionar um mês para o valor deCURDATE, então extrair a parte do mês comMONTH(), o resultado é o mês no qual você deseja procurar por aniversários:

mysql> SELECT name, birth FROM pet

-> WHERE MONTH(birth) = MONTH(DATE_ADD(CURDATE(), INTERVAL 1 MONTH));

Uma maneira diferente para realizar a mesma tarefa é adicionar1para obter o mês seguinte ao atual (depois de usar a função mó- dulo (MOD) para o valor do mês retornar0se ele for12):

mysql> SELECT name, birth FROM pet

-> WHERE MONTH(birth) = MOD(MONTH(CURDATE()), 12) + 1;

Perceba queMONTHretorna um número entre1e12. EMOD(alguma_coisa,12)retorna um número entre0e11. Então a adição tem que ser feita depois doMOD(), senão iríamos de Novembro (11) para Janeiro (1).

3.3.4.6. Trabalhando com Valores Nulos (NULL)

O valorNULLpode ser supreendente até você usá-lo. Conceitualmente,NULLsignifica valor em falta ou valor desconhecido e é tratado de uma forma diferente de outros valores. Para testar o valorNULL, você não pode usar os operadores de comparações arit- méticas como em=,<, ou!=. Para demonstrar para você mesmo, tente executar a seguinte consulta:

mysql> SELECT 1 = NULL, 1 != NULL, 1 < NULL, 1 > NULL;

Claramente você não obterá resultados significativos destas comparações. Utilize os operadoresIS NULLeIS NOT NULLno lugar:

mysql> SELECT 1 IS NULL, 1 IS NOT NULL;

+---+---+ | 1 IS NULL | 1 IS NOT NULL | +---+---+

| 0 | 1 |

+---+---+

No MySQL,0ouNULLsignifica falso e o resto é verdadeiro. O valor verdadeiro por o padrão em uma operação booleana é1. Este tratamento especial deNULLé porque, na seção anterior, foi necessário determinar quais animais não estavam mais vivos usandodeath IS NOT NULLno lugar dedeath <> NULL.

Dois valoresNULLsão considerados como iguais em umGROUP BY.

Ao fazer umORDER BY, valoresNULLsão apresentados primeiro se você fizerORDER BY ... ASCe por último se você fizer

ORDER BY ... DESC.

Note que o MySQL 4.0.2 a 4.0.10 sempre ordenam, incorretamente, valoresNULLem primeiro independente da ordem escolhida.

3.3.4.7. Combinação de padrões

O MySQL fornece combinação de padrões do SQL bem como na forma de combinação de padrões baseado nas expressões regulares extendidas similares àquelas usadas pelos utilitários Unix como ovi,grepesed.

A combinação de padrões SQL lhe permite você usar_para coincidir qualquer caractere simples e%para coincidir um número ar- bitrário de caracteres (incluindo zero caracter). No MySQL, padrões SQL são caso insensitivo por padrão. Alguns exemplos são vistos abaixo. Perceba que você não usa=ou!=quando usar padrões SQL; use os operadores de comparaçãoLIKEouNOT LI- KEneste caso.

Para encontrar nomes começando com ‘b’:

mysql> SELECT * FROM pet WHERE name LIKE "b%";

+---+---+---+---+---+---+ | name | owner | species | sex | birth | death | +---+---+---+---+---+---+ | Buffy | Harold | dog | f | 1989-05-13 | NULL | | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | +---+---+---+---+---+---+

Para encontrar nomes com o final 'fy':

mysql> SELECT * FROM pet WHERE name LIKE "%fy";

+---+---+---+---+---+---+ | name | owner | species | sex | birth | death | +---+---+---+---+---+---+ | Fluffy | Harold | cat | f | 1993-02-04 | NULL | | Buffy | Harold | dog | f | 1989-05-13 | NULL | +---+---+---+---+---+---+

Para encontrar nomes contendo um ‘w’:

mysql> SELECT * FROM pet WHERE name LIKE "%w%";

+---+---+---+---+---+---+ | name | owner | species | sex | birth | death | +---+---+---+---+---+---+ | Claws | Gwen | cat | m | 1994-03-17 | NULL | | Bowser | Diane | dog | m | 1989-08-31 | 1995-07-29 | | Whistler | Gwen | bird | NULL | 1997-12-09 | NULL | +---+---+---+---+---+---+

Para encontrar nomes contendo exatamente cinco caracteres, use cinco instâncias do caracter ‘_’:

mysql> SELECT * FROM pet WHERE name LIKE "_____";

O outro tipo de combinação de padrões fornecido pelo MySQL usa expressões regulares extendidas. Quando você testa por uma combinação para este tipo de padrão, utilize os operadoresREGEXPeNOT REGEXP(ouRLIKEeNOT RLIKE, que são sinôni- mos).

Algumas características das expressões regulares extendidas são:

• ‘.’ combina qualquer caractere único

• Uma classe de caracteres '[...]' combina qualquer caractere que consta dentro dos colchetes. Por exemplo, '[abc]' combina com ‘a’, ‘b’, ou ‘c’. Para nomear uma sequência de caracteres utilize um traço. '[a-z]' combina com qualquer letra e '[0-9]' combina com qualquer dígito.

• ‘*’ combina com nenhuma ou mais instâncias de sua precedência. Por exemplo, 'x*' combina com qualquer número de caracteres ‘x’, '[0-9]*' combina com qualquer número de dígitos e '.*' combina com qualquer número de qualquer coisa.

• Um padrãoREGEXPcasa com sucesso se ele ocorre em algum lugar no valor sendo testado. (Ele difere do padrãoLIKE, que só obtem suceeso se eles combinarem com todo o valor.)

• Para fazer com que um padrão deva combinar com o começo ou o fim de um valor sendo testado, utilize ‘^’ no começo ou ‘$’ no final do padrão.

Para demonstrar como expressões regulares extendidas funcionam, as consultas comLIKEmostradas acima foram reescritas abaixo usandoREGEXP.

Para encontrar nomes começando com ‘b’, utilize ‘^’ para combinar com o começo do nome:

mysql> SELECT * FROM pet WHERE name REGEXP "^b";

Antes da versão 3.23.4 do MySQL,REGEXPera caso sensitivo, e a consulta anterior não iria retornar nenhum registro. Neste caso, para combinar letras ‘b’ maiúsculas e minúsculas, utilize esta consulta:

mysql> SELECT * FROM pet WHERE name REGEXP "^[bB]";

A partir do MySQL 3.23.4, se você realmente deseja forçar uma comparaçãoREGEXPcom caso sensitivo, utilize a palavra-chave

BINARYpara tornar uma das strings em uma string binárias. Esta consulta irá combinar somente com ‘b’s minúsculos no começo de um nome:

mysql> SELECT * FROM pet WHERE name REGEXP BINARY "^b";

Para encontrar nomes finalizados com 'fy', utilize ‘$’ para combinar com o final do nome:

mysql> SELECT * FROM pet WHERE name REGEXP "fy$";

Para encontrar nomes contendo um ‘w’, utilize esta consulta:

mysql> SELECT * FROM pet WHERE name REGEXP "w";

Como uma expressão regular extendida encontra padrões coincidentes se eles ocorrem em qualquer lugar no valor comparado, não é necessário utiliar, na consulta anterior, nenhum metacaracter em nenhum dos lados do padrão para fazê-lo coincidir com todo o valor, como seria feito se fosse utilizado o padrão SQL.

Para encontrar nomes contendo exatamente cinco caracteres, utilize ‘^’ e ‘$’ para combinar com o começo e fim do nome e cinco instâncias de ‘.’ entre eles.

mysql> SELECT * FROM pet WHERE name REGEXP "^...$";

Você pode também escrever a consulta anterior utilizando o operador '{n}' ``repete-n-vezes'':

mysql> SELECT * FROM pet WHERE name REGEXP "^.{5}$";

3.3.4.8. Contando Registros

Bancos de dados normalmente são usados para responder a perguntas, ``Qual a frequência que certo tipo de dados ocorre em uma tabela?'' Por exemplo, você deve querer saber quantos animais tem, ou quantos animais cada dono tem, ou você pode querer fazer vários outros tipos de operações de censo com seus animais.

Contando o número total de animais que você tem é a mesma questão como em ``Quantos registros existem na tabelapet?'' porque existe um registro por animal.COUNT(*)conta o número de resultados não-NULL, portanto a pesquisa para contar seus animais parecerá com isto:

mysql> SELECT COUNT(*) FROM pet;

+---+ | COUNT(*) | +---+ | 9 | +---+

Logo, você recuperará os nomes das pessoas que possuam animais. Você pode usarCOUNT()se você desejar encontrar quantos animais cada dono possui:

mysql> SELECT owner, COUNT(*) FROM pet GROUP BY owner;

+---+---+ | owner | COUNT(*) | +---+---+ | Benny | 2 | | Diane | 2 | | Gwen | 3 | | Harold | 2 | +---+---+

Perceba o uso deGROUP BYpara agrupar todos os registros para cadaowner(dono). Sem ele, você teria uma mensagem de erro:

mysql> SELECT owner, COUNT(*) FROM pet;

ERROR 1140: Mixing of GROUP columns (MIN(),MAX(),COUNT()...) with no GROUP columns is illegal if there is no GROUP BY clause

COUNT()eGROUP BYsão úteis para personalizar seus dados de diversas maneiras. Os seguintes exemplos mostram diferentes maneiras para realizar operações de censo nos animais.

Número de animais por espécie:

mysql> SELECT species, COUNT(*) FROM pet GROUP BY species;

+---+---+ | species | COUNT(*) | +---+---+ | bird | 2 | | cat | 2 | | dog | 3 | | hamster | 1 | | snake | 1 | +---+---+

Número de animais por sexo:

mysql> SELECT sex, COUNT(*) FROM pet GROUP BY sex;

+---+---+ | sex | COUNT(*) | +---+---+ | NULL | 1 | | f | 4 | | m | 4 | +---+---+

(Nesta saída,NULLindica que o sexo é desconhecido.) Número de animais combinando espécie e sexo:

mysql> SELECT species, sex, COUNT(*) FROM pet GROUP BY species, sex;

+---+---+---+ | species | sex | COUNT(*) | +---+---+---+ | bird | NULL | 1 | | bird | f | 1 | | cat | f | 1 | | cat | m | 1 | | dog | f | 1 | | dog | m | 2 | | hamster | f | 1 | | snake | m | 1 | +---+---+---+

Não é necessário selecionar uma tabela inteira quando estiver usandoCOUNT(). Por exemplo, a consulta anterior, quando realizada apenas procurando por cachorros e gatos, se parece com isto:

mysql> SELECT species, sex, COUNT(*) FROM pet

-> WHERE species = "dog" OR species = "cat"

-> GROUP BY species, sex;

+---+---+---+ | species | sex | COUNT(*) | +---+---+---+ | cat | f | 1 | | cat | m | 1 | | dog | f | 1 | | dog | m | 2 | +---+---+---+

Ou se você desejar saber o número de animais por sexo somente de animais com sexo conhecido:

mysql> SELECT species, sex, COUNT(*) FROM pet

-> WHERE sex IS NOT NULL

-> GROUP BY species, sex;

+---+---+---+ | species | sex | COUNT(*) | +---+---+---+ | bird | f | 1 | | cat | f | 1 | | cat | m | 1 | | dog | f | 1 | | dog | m | 2 | | hamster | f | 1 |

No documento refman-4.1-pt.a4 (páginas 143-153)