Como inserir o resultado de uma query SELECT em uma tabela MySQL

Neste post vou mostrar como pegar o resultado de uma consulta MySQL e gravá-lo em uma tabela preexistente, em vez de exibi-lo.
Se você deseja criar uma nova tabela a partir de uma query SELECT, sugiro ler o artigo Como criar uma tabela a partir de uma declaração SELECT no MySQL.
Mountain high and mysql logo
O servidor MySQL normalmente retorna o resultado de um SELECT ao cliente que o requisitou.
Se você faz uma requisição a partir do terminal cliente MySQL, é para onde os resultados serão enviados e exibidos.
Neste texto vou mostrar como enviar os resultados de um SELECT para dentro de uma outra tabela.
Copiar resultados de uma tabela para outra pode ser útil em vários casos:

  1. Se você estiver desenvolvendo um algoritmo que modifica uma tabela, certamente seria mais seguro trabalhar em uma cópia — o que evita ter que lidar com as consequências de um desastre em cima de informações importantes para você ou para a empresa em que você trabalha.
  2. Em algumas operações, pode ser interessante trabalhar em uma tabela temporária e, mais tarde, copiar os dados conferidos para a tabela definitiva.
  3. Você pode usar o recurso em um script, que toma dados de uma tabela maior e cria uma pequena tabela de serviços e vai atualizando a tabela principal aos poucos (ou em horários de menor fluxo na rede).
  4. Se você está aprendendo MySQL, pode ser interessante transferir dados para tabelas “de aprendizado” e deixar as tabelas de produção em paz.

Vou mostrar como usar o INSERT ... SELECT para obter informações de uma tabela e inseri-las em outra.
Para isto, vou fazer uso das tabelas ClientesCidades e CliCred. Sugiro adequar os exemplos às suas próprias tabelas. Contudo, se quiser, você pode pegar as minhas mal acabadas tabelas aqui.

Como inserir os resultados da query em uma tabela

A tabela CliCred tem 3 campos coincidentes com a tabela ClientesCidades. Veja o que o comando EXPLAIN mostra (em destaque):

EXPLAIN CliCred;
+-----------+-----------------------+------+-----+---------+----------------+
| Field     | Type                  | Null | Key | Default | Extra          |
+-----------+-----------------------+------+-----+---------+----------------+
| id        | mediumint(8) unsigned | NO   | PRI | NULL    | auto_increment |
| cc_nome   | varchar(255)          | YES  |     | NULL    |                |
| cc_cidade | varchar(255)          | YES  |     | NULL    |                |
| cc_cred   | mediumint(9)          | YES  |     | NULL    |                |
| cc_limite | mediumint(9)          | YES  |     | NULL    |                |
+-----------+-----------------------+------+-----+---------+----------------+
5 rows in set (0.00 sec)

Embaixo, após o comando EXPLAIN, destaquei os campos que correspondem aos que foram destacados em cima:

EXPLAIN ClientesCidades;
+---------------+-----------------------+------+-----+---------+----------------+
| Field         | Type                  | Null | Key | Default | Extra          |
+---------------+-----------------------+------+-----+---------+----------------+
| id            | mediumint(8) unsigned | NO   | PRI | NULL    | auto_increment |
| NomeCliente   | varchar(255)          | YES  |     | NULL    |                |
| IdadeCliente  | mediumint(9)          | YES  |     | NULL    |                |
| CidadeCliente | varchar(255)          | YES  |     | NULL    |                |
| CredCliente   | mediumint(9)          | YES  |     | NULL    |                |
+---------------+-----------------------+------+-----+---------+----------------+
5 rows in set (0.00 sec)

Cada uma destas 2 tabelas tem 100 registros.
Ao final da operação, a tabela ClientesCidades terá recebido os 100 registros da tabela CliCred — e passará a ter 200 registros.
Veja:

INSERT INTO ClientesCidades (NomeCliente, CidadeCliente, CredCliente) SELECT cc_nome, cc_cidade, cc_cred FROM CliCred; 

Vamos analisar o comando dado:

  • INSERT INTO ClientesCidades — Determina em que tabela ocorrerá a alteração (inserção de novos dados).
  • (NomeCliente, CidadeCliente, CredCliente) — Estes são os campos (as colunas) que serão alterados na tabela ClientesCidades.
  • SELECT cc_nome, cc_cidade, cc_cred FROM CliCred — Seleciona os valores contidos nos campos cc_nome, cc_cidade, cc_cred na tabela CliCred, para inserir na primeira tabela.

Veja uma listagem parcial (apenas os 10 últimos registros) da nova tabela ClientesCidades:

SELECT * FROM ClientesCidades where id > 190;
+-----+-------------------+--------------+----------------+-------------+
| id  | NomeCliente       | IdadeCliente | CidadeCliente  | CredCliente |
+-----+-------------------+--------------+----------------+-------------+
| 191 | Paula Wiley       |         NULL | St. Catharines |         187 |
| 192 | Cathleen Thornton |         NULL | Rouvroy        |         289 |
| 193 | Laurel Espinoza   |         NULL | Boneffe        |         131 |
| 194 | Amber Sparks      |         NULL | Kailua         |         256 |
| 195 | Elizabeth Bean    |         NULL | Beaconsfield   |         147 |
| 196 | Eleanor Cleveland |         NULL | Rosciano       |         295 |
| 197 | Virginia Dillon   |         NULL | Metairie       |         209 |
| 198 | Jana Dyer         |         NULL | Birori         |         135 |
| 199 | Kendall Reid      |         NULL | Westkapelle    |         274 |
| 200 | Katell Robinson   |         NULL | Colonnella     |         149 |
+-----+-------------------+--------------+----------------+-------------+
10 rows in set (0.03 sec)

Em uma análise do resultado, note que:

  1. o último valor do campo id, em ClientesCidades, reflete o acréscimo de mais 100 registros. Agora são 200 registros;
  2. 100 nomes de clientes, de cidades e valores de Crédito foram adicionados nos campos NomeCliente, CidadeCliente e CredCliente;
  3. A tabela CliCred não tem o campo IdadeCliente, por isto o valor NULL (nulo) foi gravado nos campos correspondentes.

Como copiar todos os valores de uma tabela para outra

Isto é bem mais fácil e pode realizado com um comando mais enxuto e menor preocupação com a sintaxe.
Vamos supor a existência das tabelas tabela_Origem e tabela_Destino, ambas com estruturas idênticas.
Para copíar os valores da primeira para dentro da segunda, use o seguinte comando:

INSERT INTO tabela_Destino SELECT * FROM tabela_Origem;

E se eu quisesse copiar apenas as informações sobre clientes com créditos superiores a 300?
Vamos retomar (e alterar) o exemplo acima:

INSERT INTO ClientesCidades (NomeCliente, CidadeCliente, CredCliente) SELECT cc_nome, cc_cidade, cc_cred FROM CliCred WHERE cc_cred > 300; 

Como, no caso da minha tabela, nenhum cliente tem valor de crédito superior a 300, o resultado foi este:

Query OK, 0 rows affected (0.00 sec)
Records: 0  Duplicates: 0  Warnings: 0

Uma última dica: Você pode usar a mesma tabela como origem e destino.

Divirta-se e tenha um bom aprendizado!

Qual a importância da linha de comando ou console para web designers?

A linha de comando, ou console, é onde se pode fornecer uma sequência de comandos, para executar um aplicativo ou vários, realizar uma tarefa ou uma sequência de tarefas etc.
Amparados por parâmetros, opções e cláusulas os comandos, dados no console ou no terminal, têm uma enorme (quase infinita) flexibilidade.
Command line tools for web design cover picture

Administradores de sistemas, desenvolvedores, hackers, autores etc. já descobriram o “poder divinal” que um terminal oferece a quem se dispõe a aprender a dominá-lo.

Mas, enfim… qual a utilidade ou a importância desta ferramenta a um web designer?
Se por um lado, a interface gráfica tem um grande apelo visual e facilidade de uso, ela também prejudica a flexibilidade e a agilidade — nenhum designer de interface “enche a tela” de botões para realizar uma determinada tarefa de n maneiras diferentes.
Além disto, a interface gráfica é comumente lenta em computadores mais antigos — o que implica na demora para iniciar a execução de alguma atividade.
O terminal permite determinar exatamente como se deseja que uma tarefa (ou uma sequência de tarefas) seja executada e ela começa a partir do momento em que você dá Enter.

Não abro mão da flexibilidade e da agilidade que só o terminal proporciona. É uma ferramenta que eleva exponencialmente o meu nível de controle sobre o sistema.

Terminal do Linux, do Windows ou do MacOS?

Se você ainda não usa o GNU/Linux, no seu trabalho, insisto: você deveria começar a considerar seriamente esta opção profissional — que te pode possibilitar trabalhar com softwares 100% legalizados a custos muito baixos ou gratuitos.
O terminal do Windows também oferece uma razoável dose de flexibilidade. O sistema, contudo, foi desenhado para que se usassem apenas as opções da interface gráfica. O processo de “castração” do terminal DOS, começou a partir do Windows 3.0 (Maio/1990) e tem se fortalecido até os dias de hoje.
A Microsoft tem se esforçados para esconder o terminal do usuário, como se fosse um parente indesejável.
O MacOS foi construído sobre a plataforma Unix FreeBSD e tem um terminal poderoso. A cultura dos usuários, incentivados pelo departamento de marketing da Apple constitui uma forte barreira para seu uso. Mas ele está lá. 😉
Usuários do MacOS X podem usar o Homebrew para instalar as ferramentas que não são parte do pacote de aplicativos padrão.
O Linux, como estes outros sistemas operacionais, também veio do ambiente em caracteres e evoluiu para o uso predominante da interface gráfica.
O Linux, contudo, convive muito bem com o uso do terminal. Todas as grandes distribuições oferecem facilidades de acesso ao console.
Embora haja ferramentas visuais sofisticadas para instalar softwares, muitos usuários Linux se sentem muito à vontade para instalar seus aplicativos com as ferramentas de linha de comando, como o apt-get — sendo que, na maioria das vezes, lhes basta copiar e colar a instrução de um site no seu terminal, podendo fazer as mudanças que achar pertinentes, se for o caso.
Encontre mais artigos sobre o uso do apt-get, na caixa de busca deste site.

O que há na linha de comando para profissionais do web design?

Há muito que um webdesigner já faz, usando a interface gráfica, que pode ser feito na linha de comando.
Eu sou um evangelista do uso do software livre e do uso de comandos no terminal — mas eu entendo, veja bem, que você deva usar sempre o que lhe oferecer os melhores resultados.
Tudo o que este artigo pede é que você abra os olhos para o terminal do seu sistema e veja (com generosidade e sem preconceitos) se há lá alguma coisa que lhe possa ser útil. Só isso.
Veja alguns pontos que Cadmin’s blog elenca como favoráveis ao uso do terminal:

  • O uso de pacotes de softwares de terceiros se torna invisível — Webdesigners usam vários pacotes de terceiros, tais como o Bootstrap, jQuery, Normalize.css etc.
    A gestão de pacotes, contudo, é muito morosa, quando feita manualmente.
    Com o uso do terminal, é possível inserir os pacotes requeridos pelo seu projeto com alguns comandos: bower install jquery, bower update jquery
  • Para quem não sabe, o Bower é um gestor de pacotes, semelhante ao apt-get ou o PIP.

  • No terminal, compilar é muito mais rápido — HTML, CSS e JavaScript são 3 linguagens sempre presentes em projetos de design web, entre outras. As ferramentas da linha de comando tornam a produção e entrega de código mais eficiente nestas linguagens.
    Eventualmente, compilar pré-processadores, é muito mais rápido na linha de comando.
  • Ferramentas de teste de sites — Há várias ferramentas de teste da rede e da eficiência de seu website ou do provedor em que ele se encontra hospedado, que podem ser invocadas do terminal — não somente as opções de execução, mas também as informações fornecidas, são extremamente flexíveis e maleáveis.

Uma vez iniciado o uso da linha de comando, você adquire o costume e um mundo novo de possibilidades surge, ao alcance de seus dedos.

Referências

Site oficial do Bower: bower.io
How important is command line for web designers — http://auckland.fortuneinnovations.com/how-important-command-line-web-designers
Command line tools for frontend developers — http://seesparkbox.com/foundry/command_line_tools_for_frontend_developers

Como solucionar alguns erros ao instalar ou atualizar aplicativos no Android.

O erro ao tentar instalar ou atualizar algum aplicativo no seu aparelho, pode ocorrer por diversos motivos.
Um dos mais comuns é identificado como erro 923. Mas há outros e estão associados ao contexto em que o usuário pretende fazer um download de um novo aplicativo ou de uma atualização, no seu smartphone ou tablet.
Pode ocorrer em outras situações também.
Os procedimentos relatados, também podem resolver o erro 905, conforme o vídeo ao final do texto.
Captura de tela do gerenciador de aplicativos no Android

O que pode causar o erro ao tentar instalar ou atualizar aplicativos da Play Store?

Sabendo que ele, usualmente, está associado a downloads, instalações e atualizações de aplicativos interrompidos, você deve investigar por que a interrupção ocorreu.
3 causas comuns para que downloads e atualizações fracassem:

  • Falhas na conexão à Internet — rede instável ou muito lenta.
  • Espaço insuficiente no seu aparelho.
  • Dados do usuário corrompidos no tráfego ou dentro do aparelho.

Há outras possibilidades, mas estas são as mais usuais.
A primeira pode ser facilmente resolvida — principalmente se ela não acabar causando a corrupção dos dados que o usuário precisa para se conectar à Play Store.
Procure conexões mais estáveis, de preferência o WIFI na sua casa, para baixar ou atualizar aplicativos.
Se você tem espaço insuficiente no seu aparelho, pode tentar desinstalar ou desativar os aplicativos que não usa mais (ou não usa tanto).
Em seguida, tente novamente fazer o procedimento de atualizar ou baixar o aplicativo na Google Play Store.
Se isto não resolver, tente outras abordagens, conforme descrito no restante deste artigo.

Algumas pessoas dizem que o Android é um ambiente com muitos erros. Eu prefiro abordar a situação pelo mesmo ângulo que alguns técnicos Windows se acostumaram: pelo fato de ser mais difundido, há mais debate sobre os problemas da plataforma. Além disto, a enorme variedade de hardware que faz uso deste sistema operacional acaba por ser um entrave para a sua homogeneidade.
Por outro lado, é patente que, justamente por ser tão difundido, há também farta documentação sobre problemas e soluções, envolvendo o Android.


Use nossa página de busca para encontrar mais artigos sobre o Android

Entre e saia do modo avião (de voo) para resolver o erro 923

A solução parece estranha… mas há relatos em fóruns técnicos e de usuários de que funciona.
A explicação é que ao entrar no modo de voo, o aparelho se desliga totalmente das redes. Ao voltar ao modo online, ele pode conseguir uma conexão melhor, de uma torre mais próxima, por exemplo.
Este procedimento é usado na solução de outros problemas e erros na plataforma Android.
Mas, se isto não resolver o problema, tente o próximo passo.

Reinicie o aparelho

Reiniciar dispositivos para “resolver problemas” é sempre uma péssima opção — esta é uma opinião pessoal minha.
Não gosto desta solução por que ela, de certa forma, impede que se descubra a verdadeira causa do problema.
Se isto resolver, no entanto, quem sou eu para lhe dizer “não faça”?
Se for para reiniciar o aparelho, prefiro fazer isto para limpar o cache.


Você tem um aparelho Samsung? Leia outros textos que abordam smartphones e tablets desta marca.

Limpe o cache do sistema

O Android 4.2 Jelly Bean adicionou um recurso que permite limpar facilmente o cache do seu aparelho.

Como limpar o Cache no Android.
Clique para ampliar.

Para acessar esta seção, abra o menu de configurações e selecione a aba Mais…, no canto superior direito.
A seguir, toque no item Armazenamento.
Na próxima tela, toque em Dados memorizados e confirme.
Este procedimento, pode apagar algumas senhas de aplicativos e dados de usuário do navegador.

Remova completamente o aplicativo

Uma solução possível é remover completamente o aplicativo envolvido no erro e que está tentando ser atualizado.
Em seguida, tente instalá-lo novamente.

Remova o cache e outros dados do aplicativo Google Play Store

Se o problema estiver sendo causado por corrupção nos dados do aplicativo da loja Google, pode ser indicado a remoção de seus dados ou a remoção parcial do aplicativo de loja do Google.
Para isto, vá até o menu de configurações do aparelho e selecione o Gerenciador de aplicações.
Uma vez lá, localize a aba Todos, no canto superior direito e procure por Google Play Store.
Selecione-o e use a opção Limpar cache.
Se isto não resolver, escale para a opção Limpar Dados, nesta mesma tela.

Android Gerenciador de aplicações - Google Play Store
Clique para ampliar.

Se o problema ainda permanecer sem solução, use as opções Forçar parada e Desinstalar atualizações.
Em seguida, inicie a Play Store e faça a sua atualização.
O vídeo, abaixo, explica como resolver o problema apagando o cache e os dados do aplicativo.

Se nada deu certo, até aqui… faça o reset

Eu espero que, a esta altura, o seu problema já tenha se resolvido.
Se este não for o caso, faça o reset de fábrica.
Antes, contudo, faça um backup de todos os seus arquivos.
O que resta fazer, depois disto, é levar o aparelho à assistência técnica. Com o aparelho em mãos, uma pessoa mais experiente do que você pode encontrar outras soluções para o seu problema.
Boa sorte! 😉


Leia outros artigos relacionados à bateria em dispositivos Android

Como seccionar uma lista, usando a cláusula LIMIT do MySQL

A cláusula LIMIT pode ser usada para obter informações contidas no meio de uma lista, e não apenas nas extremidades (início ou fim) da consulta.
Capa do tutorial MySQL - a cláusula LIMIT
O uso básico da cláusula LIMIT, já foi discutido no artigo Como usar LIMIT para selecionar registros do começo ou do fim de uma tabela no MySQL — sugiro-o como leitura complementar.
Neste texto, vou mostrar como obter determinadas linhas, no “miolo” de uma relação e como é possível fazer paginação, com LIMIT — ou seja, dividir uma relação em múltiplas páginas.
Para que o LIMIT possa realizar a tarefa é necessário que você diga em que posição, na lista, ele deve começar, além da quantidade de linhas que você deseja que sejam exibidas.
A cláusula LIMIT aceita 2 argumentos:

  • O primeiro determina quantas linhas devem ser “puladas” ou ignoradas.
  • O segundo determina quantas linhas da lista devem ser exibidas.

Isto significa que você pode usar a cláusula LIMIT para pular 2 linhas e mostram a próxima, por exemplo. Isto permite responder perguntas um pouco mais complexas, como “Qual o quinto maior valor num determinado campo?” ou “Qual o terceiro menor valor?” — que seria mais difíceis de responder com as funções MIN() ou MAX().
Vamos aos exemplos.

Como paginar resultados com a cláusula LIMIT, no MySQL

Distribuir em várias páginas os resultados de uma query MySQL com o LIMIT é muito fácil — ele é feito pra isso.
Veja um exemplo básico de paginação de 2 em 2 (para não ficar muito extenso):

SELECT idCli,nomeCli,emailCli FROM CadCli LIMIT 2;

Na primeira parte, peço a lista limitada aos 2 primeiros registros:

+-------+-----------------+--------------------------------+
| idCli | nomeCli         | emailCli                       |
+-------+-----------------+--------------------------------+
|     1 | Tana Mclaughlin | eget.tincidunt@magnisdis.net   |
|     2 | Jakeem Klein    | mauris.eu@Nuncmaurissapien.com |
+-------+-----------------+--------------------------------+
2 rows in set (0.00 sec)

A lista segue, pulando 2 resultados, limitada a 2 linhas:

SELECT idCli,nomeCli,emailCli FROM CadCli LIMIT 2,2;
+-------+-----------------+-------------------------------+
| idCli | nomeCli         | emailCli                      |
+-------+-----------------+-------------------------------+
|     3 | Wylie Carroll   | convallis.in.cursus@libero.ca |
|     4 | Colton Franklin | dui.lectus.rutrum@eusem.org   |
+-------+-----------------+-------------------------------+
2 rows in set (0.00 sec)

Concluo o exemplo, exibindo a próxima página, depois do quarto registro, limitado a 2 linhas:

 SELECT idCli,nomeCli,emailCli FROM CadCli LIMIT 4,2;
+-------+-----------------+------------------------------------------+
| idCli | nomeCli         | emailCli                                 |
+-------+-----------------+------------------------------------------+
|     5 | Amity Whitfield | risus.Quisque.libero@Praesenteudui.co.uk |
|     6 | Sade Carver     | Donec@Innec.com                          |
+-------+-----------------+------------------------------------------+
2 rows in set (0.00 sec)

Dentro de um script, podemos usar um loop para fazer este trabalho.


Nota: Você pode usar qualquer tabela disponível para você para praticar. Se você fizer questão de usar a mesma tabela deste artigo, é possível obtê-la aqui.

Como obter o maior ou menor valor de um campo, usando o LIMIT

Para realizar este trabalho, vou acrescentar a cláusula DESC em uma das queries.
Veja como obter o maior valor em uma coluna da tabela:

SELECT nomeCli, creditoCli FROM CadCli ORDER BY creditoCli DESC LIMIT 1;
+---------------+------------+
| nomeCli       | creditoCli |
+---------------+------------+
| Steven Stokes |      84831 |
+---------------+------------+
1 row in set (0.00 sec)

Se a pergunta fosse “Qual o email do cliente com o menor valor de crédito?”, a resposta poderia ser obtida assim:

SELECT nomeCli AS Cliente, emailCli AS "Email p/contato", creditoCli FROM CadCli ORDER BY creditoCli LIMIT 1;
+-----------------+----------------------------------+------------+
| Cliente         | Email p/contato                  | creditoCli |
+-----------------+----------------------------------+------------+
| Hanna Mccormick | molestie.tortor.nibh@indolor.org |        600 |
+-----------------+----------------------------------+------------+
1 row in set (0.00 sec)

E, se a pergunta for “Qual o nome do cliente com o segundo maior crédito?”

SELECT nomeCli AS Cliente, emailCli AS "Email p/contato", creditoCli FROM CadCli ORDER BY creditoCli DESC LIMIT 1,1;
+-------------+-----------------------+------------+
| Cliente     | Email p/contato       | creditoCli |
+-------------+-----------------------+------------+
| Yvonne Wise | habitant@odioEtiam.ca |      84531 |
+-------------+-----------------------+------------+
1 row in set (0.00 sec)

Espero que este post resolva as suas dúvidas sobre como seccionar relatórios no MySQL, como a cláusula LIMIT. Você pode usar a caixa de buscas, no topo do site, para encontrar tutoriais e receitas MySQL.

Como filtrar resultados com a cláusula WHERE no MySQL

A cláusula WHERE serve para informar ao servidor de banco de dados MySQL exatamente quais resultados lhe interessa obter.
A consulta feita, através do SELECT, pode acabar trazendo uma quantidade de dados muito extensa.
Capa do artigo A Cláusula WHERE no MySQL
Adicionar uma cláusula WHERE a uma consulta MySQL, permite especificar que condições precisam ser satisfeitas para que um resultado seja exibido na tela.
Se você quiser ver outros exemplos de funcionamento da cláusula WHERE, use a caixa de busca, no topo deste site, para encontrar outros artigos sobre o assunto.

Como funciona a cláusula WHERE para limitar a exibição dos primeiros registros da tabela no MySQL

Neste tutorial, vou usar como exemplo uma tabela com 100 registros.
Esta quantidade de registros pode se tornar muito maçante para ser usada em um mero tutorial e acaba por tirar a atenção do que realmente interessa.
Portanto, para ver apenas os primeiros 10 registros, uso a cláusula WHERE desta forma:

SELECT * FROM ClientesCidades WHERE id < 10;
+----+-----------------+--------------+------------------+-------------+
| id | NomeCliente     | IdadeCliente | CidadeCliente    | CredCliente |
+----+-----------------+--------------+------------------+-------------+
|  1 | Dara Chase      |           40 | Buti             |          21 |
|  2 | Hanae Kane      |           26 | Whitehorse       |          28 |
|  3 | Jaden Moon      |           29 | Bertiolo         |          17 |
|  4 | Cathleen Harvey |           39 | Exeter           |          12 |
|  5 | Marcia Cole     |           49 | Fortune          |          13 |
|  6 | Winter Fischer  |           47 | Girifalco        |          53 |
|  7 | Irene Mann      |           48 | Rocca San Felice |          78 |
|  8 | Yetta Wood      |           46 | Doues            |          89 |
|  9 | Alfreda Church  |           38 | Tarnów           |          96 |
+----+-----------------+--------------+------------------+-------------+
9 rows in set (0.00 sec)

Veja como exibir apenas os clientes, cuja coluna IdadeCliente = 42:

SELECT * FROM ClientesCidades WHERE IdadeCliente = 42;
+----+------------------+--------------+----------------+-------------+
| id | NomeCliente      | IdadeCliente | CidadeCliente  | CredCliente |
+----+------------------+--------------+----------------+-------------+
| 18 | Zelenia Brady    |           42 | Modena         |          35 |
| 27 | Sandra Gay       |           42 | Oklahoma City  |          93 |
| 53 | Chastity Charles |           42 | Calgary        |          76 |
| 92 | Martena Flowers  |           42 | Fontenoille    |          97 |
| 93 | Piper Fuentes    |           42 | Qualicum Beach |          76 |
| 94 | Althea Knight    |           42 | My             |          18 |
+----+------------------+--------------+----------------+-------------+
6 rows in set (0.00 sec)

E se eu quiser ver os registros em que IdadeCliente seja igual a 20, 21 e 22?
Veja como obter este resultado, em ordem ascendente de CredCliente:

SELECT * FROM ClientesCidades WHERE IdadeCliente = 20 OR IdadeCliente = 21 OR IdadeCliente = 22 ORDER BY CredCliente;
+----+----------------+--------------+---------------+-------------+
| id | NomeCliente    | IdadeCliente | CidadeCliente | CredCliente |
+----+----------------+--------------+---------------+-------------+
| 14 | Alea Beach     |           21 | Oromocto      |          15 |
| 64 | Illana Cannon  |           21 | Diksmuide     |          15 |
| 50 | Kelsie Whitney |           20 | Barranca      |          16 |
| 71 | Kylie Bradshaw |           20 | Fontanigorda  |          16 |
| 42 | Lynn Howe      |           21 | Basirhat      |          66 |
| 72 | Zenia Carr     |           22 | Wernigerode   |          78 |
| 76 | Leigh Barnett  |           22 | Stokrooie     |          87 |
| 31 | Cynthia Levy   |           21 | Pukekohe      |          99 |
+----+----------------+--------------+---------------+-------------+
8 rows in set (0.00 sec)

Como usar o operador IN() do MySQL

A query anterior pode ser simplificada com a adição do operador IN().
O operador IN() retorna verdadeiro (true) a cada vez que encontra uma coluna com valor correspondente ao seu.
Não entendeu? Vamos deixar o exemplo abaixo falar por si:

SELECT * FROM ClientesCidades WHERE IdadeCliente IN (20,21,22) ORDER BY CredCliente;

Note que a linha de comando é significativamente menor e o resultado, abaixo, é o mesmo obtido anteriormente:

+----+----------------+--------------+---------------+-------------+
| id | NomeCliente    | IdadeCliente | CidadeCliente | CredCliente |
+----+----------------+--------------+---------------+-------------+
| 14 | Alea Beach     |           21 | Oromocto      |          15 |
| 64 | Illana Cannon  |           21 | Diksmuide     |          15 |
| 50 | Kelsie Whitney |           20 | Barranca      |          16 |
| 71 | Kylie Bradshaw |           20 | Fontanigorda  |          16 |
| 42 | Lynn Howe      |           21 | Basirhat      |          66 |
| 72 | Zenia Carr     |           22 | Wernigerode   |          78 |
| 76 | Leigh Barnett  |           22 | Stokrooie     |          87 |
| 31 | Cynthia Levy   |           21 | Pukekohe      |          99 |
+----+----------------+--------------+---------------+-------------+
8 rows in set (0.00 sec)

Como usar o operador AND do MySQL

Se você quiser que duas condições sejam satisfeitas simultaneamente, use o operador AND:

SELECT * FROM ClientesCidades WHERE IdadeCliente < 30 AND CredCliente > 90;

No exemplo, acima, foi pedido uma lista dos clientes com idade inferior a 30 anos e com créditos superiores a 90. Veja o resultado:

+----+-----------------+--------------+---------------+-------------+
| id | NomeCliente     | IdadeCliente | CidadeCliente | CredCliente |
+----+-----------------+--------------+---------------+-------------+
| 31 | Cynthia Levy    |           21 | Pukekohe      |          99 |
| 37 | Tasha Walters   |           19 | Goutroux      |          98 |
| 62 | Zelenia Moss    |           18 | Elx           |          99 |
| 63 | Camilla Freeman |           19 | Falkensee     |          91 |
| 97 | Bo Simpson      |           24 | Omaha         |          91 |
+----+-----------------+--------------+---------------+-------------+
5 rows in set (0.00 sec)

No próximo exemplo vou usar uma query para testar se há algum cliente cuja idade seja igual ao seu crédito. Veja:

SELECT * FROM ClientesCidades WHERE IdadeCliente = CredCliente;

Por sorte, havia um:

+----+--------------+--------------+---------------+-------------+
| id | NomeCliente  | IdadeCliente | CidadeCliente | CredCliente |
+----+--------------+--------------+---------------+-------------+
| 46 | Signe Gamble |           39 | Charny        |          39 |
+----+--------------+--------------+---------------+-------------+
1 row in set (0.00 sec)

Divirta-se!