Comandos de terminal para Android

Na maioria dos sistemas operacionais, é comum o uso do terminal (ou console), permitir rodar comandos com mais flexibilidade e opções de execução, além de poder determinar uma sequencia de tarefas a ser executada, mandar a estória toda para os bastidores e ir fazer outra coisa.
O Android não é diferente. Com acesso root (privilégios administrativos) ao seu dispositivo, dá pra “fazer chover” no seu terminal.
Logo Android sobre um terminal
Se você não tiver um dispositivo rooteado, não há problema. A maioria dos procedimentos descritos neste texto irão funcionar — outros são voltados para aparelhos rooteados de desenvolvimento.
O que não funcionar, você pode pular. No caso de aplicar o rooting, futuramente no seu aparelho, você pode voltar aqui e tentar os outros comandos.
Leve em conta que foram testados em aparelhos rodando versões do Android entre a 2.3 e 4.2.
Certifique-se de ter instalado um emulador de terminal para Android, em seu sistema para poder executar todos os comandos.
Outro software que pode ser valioso, se usado junto com o terminal, é o Hacker’s Keyboard. Recomendo a sua instalação.
É preciso ter cuidados ao executar comandos no seu terminal Android, principalmente se seu aparelho for rooteado — ou você pode causar danos aos seus dados.
Os comandos proibidos para Linux, valem aqui também. Além disto, o uso de fork bombs pode ter consequências desastrosas no terminal.
Siga por sua própria conta e risco (como sempre) e se não souber o que está fazendo, não faça.


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

O comando ls no terminal do Android

Este é provavelmente o comando mais usado para quem deseja navegar pelo sistema de arquivos e explorar os vários diretórios (pastas) do dispositivo.
Ao tentar executar o comando ls no diretório /sbin (e em outros, que sejam protegidos) de um telefone não rooteado, você vai obter uma mensagem de erro, informando que você não tem permissão para ler o conteúdo daquele diretório:

ls /sbin
opendir failed. Permission denied

O comando ls sozinho, irá revelar o conteúdo do diretório atual. Experimente.
O comando pwd (print working directory), mostra o caminho completo do diretório em que você se encontra.
É um comando útil para evitar fazer o que não deve no lugar errado: 😉

cd
pwd
/data/data/jackpal.androidterm/app_HOME
...

Para ver conteúdo de diretórios protegidos, como o /sbin, você precisa “invocar os poderes do root”, ou seja, adquirir privilégios administrativos em relação ao seu sistema.
Para se tornar superusuário, use o comando su.
Só para lembrar, o comando su só pode ser invocado em aparelhos rooteados.
Note que, ao se tornar superusuário, o shell prompt muda de ‘$’ para ‘#’, para indicar que você está acessando o aparelho como root (e pode causar danos ao sistema, se não for cuidadoso).
Para sair do modo de superusuário ou do terminal, use o comando exit:

exit

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

O Android Activity Manager

No terminal, este aplicativo responde pelo comando am (Android Activity Manager) — Gestor de Atividades do Android.
Se ele for dado, sem opção alguma, irá mostrar o texto de ajuda do programa.
Você pode usar aplicativo para terminar os programas que estão rodando em background:

am kill-all
java.lang.SecurityException: Permission Denial: killAllBackgroundProcesses() from pid=13511, uid=10152 requires android.permission.KILL_BACKGROUND_PROCESSES
        at android.os.Parcel.readException(Parcel.java:1425)
        at android.os.Parcel.readException(Parcel.java:1379)
        at android.app.ActivityManagerProxy.killAllBackgroundProcesses(ActivityManagerNative.java:3280)
        at com.android.commands.am.Am.runKillAll(Am.java:556)
        at com.android.commands.am.Am.run(Am.java:116)
        at com.android.commands.am.Am.main(Am.java:81)
        at com.android.internal.os.RuntimeInit.nativeFinishInit(Native Method)
        at u0_a152@android:/data/data/jackpal.androidterm/app_HOME $com.android.internal.os.RuntimeInit.main(RuntimeInit.java:237)
        at dalvik.system.NativeStart.main(Native Method)

Obviamente, o comando só terá efeito naqueles processos sobre os quais você tiver privilégios de execução.

Os comandos Linux e UNIX no Android

Em princípio, os comandos UNIX e GNU/Linux básicos vão todos funcionar aqui (dentro daquelas limitações de que já falamos):

  • chmod
  • chown
  • date
  • rm, mv etc.

Há novos comandos, com funções específicas pro Android.
O comando dalvikvm é a máquina virtual dalvik, usada para rodar aplicações Android.
O comando df (disk free) pode ser usado para ver o espaço disponível dentro de um dispositivo de armazenamento.
Se for executado sozinho, vai mostrar todos:

df

Veja o meu resultado:

Filesystem             Size   Used   Free   Blksize
/dev                   402M   112K   401M   4096
/mnt/asec              402M  0.00K   402M   4096
/mnt/obb               402M  0.00K   402M   4096
/dev/shm               402M  0.00K   402M   4096
/system               1.15G  1011M   169M   4096
/modemfs              15.7M  4.34M  11.4M   4096
/cache                 826M  14.0M   812M   4096
/efs                  15.7M  4.53M  11.2M   4096
/preload               314M   106M   208M   4096
/data                 4.65G  2.44G  2.21G   4096
/mnt/.lfs: Function not implemented
/storage/sdcard0      4.55G  2.44G  2.11G   4096
/storage/extSdCard    14.8G   115M  14.7G   32768

Para obter informações específicas sobre o cartão de memória externo, basta citá-lo na linha de comando:

df /storage/extSdCard

segue o meu resultado…

Filesystem             Size   Used   Free   Blksize
/storage/extSdCard    14.8G   115M  14.7G   32768

O comando bootanimation pode trazer um resultado interessante (mas você possivelmente irá ter que dar um reset no aparelho, para sair deste aplicativo).
Para obter informações sobre processos em execução, use o comando ps.
Se achar que a lista é muito grande (provavelmente é), pode restringir a exibição aos processos em execução (running processes):

ps r

Este foi o meu resultado:

USER     PID   PPID  VSIZE  RSS     WCHAN    PC         NAME
radio     1670  1     12132  1964  ffffffff 00000000 S /system/bin/rild
system    2277  1678  474788 23892 ffffffff 00000000 S com.sec.android.app.twdvfs
u0_a139   3730  1678  503912 42364 ffffffff 00000000 S com.fitnesskeeper.runkeeper.pro
u0_a3     4225  1678  474564 27300 ffffffff 00000000 S com.sec.android.nearby.mediaserver

O vmstat exibe estatísticas da memória virtual do sistema. A linha, a seguir, exibe as estatísticas 5 vezes, num intervalo de um 1 segundo:

vmstat -n 5 -d 1

Se você não especificar qualquer parâmetro, o vmstat irá exibir (por padrão) as estatísticas da memória virtual a cada 1 segundo — até ser interrompido.
Se você estiver usando o Hacker’s Keyboard, será fácil parar o vmstat com o Ctrl+C.

Happy hacking! 😉

Como clonar uma tabela no MySQL

Clonar uma tabela, no MySQL, é a solução mais adequada quando você precisa de uma cópia exata da estrutura e o CREATE TABLE… SELECT não atende aos seus propósitos — por que você precisa que a cópia venha com os mesmos índices, os mesmos valores padrão etc.
Capa do tutorial MySQL - clonar tabelas
A solução para obter uma declaração CREATE TABLE adequada é usar SHOW CREATE TABLE nome_da_tabela.
Com esta declaração, o sistema irá mostrar como proceder para criar a sua tabela clone.
Deixe o exemplo falar por si:

SHOW CREATE TABLE ClientesCidades\G

O comando, acima, pede ao servidor MySQL mostrar qual declaração deve ser usada para criar uma tabela idêntica à ClientesCidades.
Veja o meu resultado:

*************************** 1. row ***************************
       Table: ClientesCidades
Create Table: CREATE TABLE `ClientesCidades` (
  `id` mediumint(8) unsigned NOT NULL AUTO_INCREMENT,
  `NomeCliente` varchar(255) DEFAULT NULL,
  `IdadeCliente` mediumint(9) DEFAULT NULL,
  `CidadeCliente` varchar(255) DEFAULT NULL,
  `CredCliente` mediumint(9) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=201 DEFAULT CHARSET=latin1
1 row in set (0.00 sec)

De tudo isto, você precisa apenas desta parte:

CREATE TABLE `ClientesCidades_clone` (   `id` mediumint(8) unsigned NOT NULL AUTO_INCREMENT,   `NomeCliente` varchar(255) DEFAULT NULL,   `IdadeCliente` mediumint(9) DEFAULT NULL,   `CidadeCliente` varchar(255) DEFAULT NULL,   `CredCliente` mediumint(9) DEFAULT NULL,   PRIMARY KEY (`id`) ) ENGINE=InnoDB AUTO_INCREMENT=201 DEFAULT CHARSET=latin1;

Note que troquei o nome da tabela de ClientesCidades para ClientesCidades_clone.
Use o SHOW TABLES para conferir a criação da tabela:

SHOW TABLES;
+-----------------------+
| Tables_in_tutorial    |
+-----------------------+
| CadCli                |
| CliCred               |
| ClientesCidades       |
| ClientesCidades_clone |
+-----------------------+
4 rows in set (0.00 sec)

Use o comando EXPLAIN para comparar as estruturas

Você pode usar o comando EXPLAIN para comparar as estruturas das 2 tabelas.

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)

Segue a estrutura da tabela clone:

EXPLAIN ClientesCidades_clone;
+---------------+-----------------------+------+-----+---------+----------------+
| 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)

Note que a segunda tabela foi clonada apenas na estrutura. Ela foi criada vazia, portanto — e como povoar uma tabela é assunto para outro tutorial. 😉

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!

Como usar LIMIT para selecionar registros do começo ou do fim de uma tabela no MySQL

A cláusula LIMIT, usada em conjunto com a cláusula ORDER BY, permite limitar a exibição dos registros de uma tabela a um determinado número.
O recurso é muito útil para mim, que estou sempre mostrando exemplos de uso de vários outros recursos do MySQL — mas não posso encher esta página com informações inúteis para os leitores.
Capa do tutorial MySQL LIMIT
O leitor quer ver apenas como um determinado recurso funciona… não a tabela toda!
Além disto, o recurso é útil quando se deseja mostrar apenas as últimas alterações ocorridas em uma tabela de um banco de dados, como seria o caso de um sistema de logging.
Uma outra situação em que este recurso é usado: quando o desenvolvedor deseja paginar os resultados — ou seja, distribuir uma relação por várias páginas. Uma de cada vez. Um exemplo disto, são as páginas do resultado de busca do Google.

Como funciona a cláusula LIMIT no MySQL

O MySQL suporta o uso desta cláusula, que serve para informar ao servidor que ele só deve retornar uma parte do resultado pedido em uma consulta.
Os exemplos, que seguem, fazem uso da tabela CadCli, que pode ser encontrada aqui — mas você pode usar qualquer outra. Basta adequar os comandos à sua situação.
Para limitar a exibição dos resultados de uma query a 1 registro, use a cláusula LIMIT 1:

SELECT * FROM CadCli LIMIT 1;
+-------+-----------------+------------------------------+-----------+------------+----------+----------+
| idCli | nomeCli         | emailCli                     | cidadeCli | creditoCli | dtCadCli | dtNscCli |
+-------+-----------------+------------------------------+-----------+------------+----------+----------+
|     1 | Tana Mclaughlin | eget.tincidunt@magnisdis.net | Stekene   |      27768 | 07-06-14 | 11-02-09 |
+-------+-----------------+------------------------------+-----------+------------+----------+----------+
1 row in set (0.00 sec)

Aumente o valor de LIMIT, para obter mais resultados:

SELECT * FROM CadCli LIMIT 5;
+-------+-----------------+------------------------------------------+---------------+------------+----------+----------+
| idCli | nomeCli         | emailCli                                 | cidadeCli     | creditoCli | dtCadCli | dtNscCli |
+-------+-----------------+------------------------------------------+---------------+------------+----------+----------+
|     1 | Tana Mclaughlin | eget.tincidunt@magnisdis.net             | Stekene       |      27768 | 07-06-14 | 11-02-09 |
|     2 | Jakeem Klein    | mauris.eu@Nuncmaurissapien.com           | Lagos         |      17465 | 02-07-14 | 29-04-71 |
|     3 | Wylie Carroll   | convallis.in.cursus@libero.ca            | Lelystad      |      81512 | 19-09-14 | 13-08-98 |
|     4 | Colton Franklin | dui.lectus.rutrum@eusem.org              | Sesto Campano |      68180 | 13-04-15 | 27-07-77 |
|     5 | Amity Whitfield | risus.Quisque.libero@Praesenteudui.co.uk | Fauvillers    |      21975 | 10-07-14 | 01-02-82 |
+-------+-----------------+------------------------------------------+---------------+------------+----------+----------+
5 rows in set (0.00 sec)

Melhore o resultado filtrando
O valor de LIMIT não pode ser negativo.
Se você quiser, de alguma forma, inverter a ordem de exibição dos registros, use as cláusulas WHERE e ORDER BY para filtrar os seus registros:

SELECT idCli AS "Ordem",nomeCli AS "Cliente", creditoCli AS "Credito Disponível" FROM CadCli ORDER BY CreditoCli DESC LIMIT 5;

O comando, acima, pede a relação dos clientes ordenada pelo crédito disponível (creditoCli), em ordem descendente e limitado a 5 registros. O meu resultado foi o seguinte:

+-------+----------------+---------------------+
| Ordem | Cliente        | Credito Disponível  |
+-------+----------------+---------------------+
|    78 | Steven Stokes  |               84831 |
|    54 | Yvonne Wise    |               84531 |
|     8 | Ocean Greene   |               84520 |
|   100 | Kendall Morton |               83838 |
|    19 | Lydia Patton   |               83368 |
+-------+----------------+---------------------+
5 rows in set (0.00 sec)

Você deve usar sempre as cláusulas WHERE e ORDER BY, combinadas ao LIMIT, para obter resultados mais significativos para as suas necessidades.
É possível obter os mesmos resultados, acima, sem usar a cláusula LIMIT.
A vantagem de fazer uso do LIMIT é que o servidor vai retornar a informação pedida — o que estiver fora dos limites definidos em LIMIT não será enviado. Desta forma, o uso da rede e da sua largura de banda é muito mais eficiente com o uso do LIMIT.
Em um universo de um milhão de registros, se eu quisesse ver apenas quem tem o maior valor em créditos disponíveis, nesta tabela, eu posso usar o LIMIT, sem sobrecarregar a rede com tráfego desnecessário de dados:

SELECT * FROM CadCli ORDER BY CreditoCli DESC LIMIT 1;
+-------+---------------+-----------------------------+------------+------------+----------+----------+
| idCli | nomeCli       | emailCli                    | cidadeCli  | creditoCli | dtCadCli | dtNscCli |
+-------+---------------+-----------------------------+------------+------------+----------+----------+
|    78 | Steven Stokes | est.Nunc.laoreet@cursus.edu | Llandovery |      84831 | 17-12-14 | 18-07-75 |
+-------+---------------+-----------------------------+------------+------------+----------+----------+
1 row in set (0.00 sec)

Use o quadro de pesquisa, no canto superior da página para encontrar mais artigos, neste site, sobre o uso do LIMIT e/ou outras cláusulas 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!