【Introdução ao SQL】Explicação completa da cláusula WHERE! Aprenda a extrair dados com exemplos prontos para copiar
Você, criador de sites e aplicativos, já ouviu falar em “banco de dados” ou “SQL” e pensou que era algo técnico demais, sem relação com o seu trabalho? Na verdade, no desenvolvimento web moderno, o conhecimento de SQL é uma poderosa ferramenta que pode levar sua criatividade a um novo nível.
Por exemplo, em sistemas como WordPress, os dados de postagens e informações de usuários são armazenados em bancos de dados. Com conhecimento em SQL, você poderá personalizar o site de forma avançada, como exibir apenas os artigos que atendem a determinadas condições. Também é essencial ao analisar o comportamento dos usuários e melhorar seu site com base nos dados. Em outras palavras, SQL não é mais exclusividade dos engenheiros de backend.
Este artigo foca na importante cláusula WHERE do SQL. A cláusula WHERE é como uma “rede mágica” que permite pescar exatamente as informações necessárias em um mar de dados. Mesmo iniciantes podem aprender com tranquilidade, pois vamos explicar desde o básico até o avançado com muitos exemplos de código prontos para copiar e usar. Sinta na prática como é divertido manipular dados com liberdade!
Preparação! Criando a tabela de exemplo que será nosso palco
Para embarcar nesta aventura no mundo do SQL, primeiro precisamos preparar a tabela de exemplo users. Imagine que essa tabela armazena informações fictícias de usuários de um serviço web. Entender bem o que cada coluna representa ajudará bastante no aprendizado futuro.
Definição da tabela: users
id: Número único que identifica cada usuário (ID).name: Nome do usuário (texto).age: Idade do usuário (número).pref: Província onde o usuário reside (texto).points: Pontos acumulados pelo usuário (número). Pode serNULL(valor vazio).
Na seção prática, os dados desta tabela serão automaticamente carregados. Por agora, observe atentamente quais dados serão usados.
-- Definir a estrutura da tabela
CREATE TABLE users (
id INT PRIMARY KEY,
name VARCHAR(50),
age INT,
pref VARCHAR(50),
points INT
);
-- Inserir dados de exemplo na tabela
INSERT INTO users (id, name, age, pref, points) VALUES
(1, 'Tanaka Taro', 25, 'Tóquio', 120),
(2, 'Suzuki Ichiro', 32, 'Osaka', 85),
(3, 'Sato Hanako', 28, 'Tóquio', 300),
(4, 'Takahashi Jiro', 45, 'Fukuoka', 50),
(5, 'Ito Sakura', 25, 'Hokkaido', NULL),
(6, 'Watanabe Saburo', 32, 'Tóquio', 150),
(7, 'Yamamoto Shiro', 51, 'Osaka', 210);Básico da cláusula WHERE – Filtrando dados com condições simples
A cláusula WHERE é usada logo após instruções como SELECT * FROM users. O formato básico é WHERE coluna operador valor. Vamos ver isso na prática com operadores de comparação básicos.
= : Buscar dados que correspondem exatamente
O operador de igualdade = é o mais básico. Por exemplo, para buscar apenas os usuários com 25 anos, usamos esse operador. Números são passados diretamente, e strings devem estar entre aspas simples '.
SELECT * FROM users WHERE age = 25;<> ou != : Buscar dados que não correspondem
Para especificar “diferente de”, usamos <> ou !=. Por exemplo, para listar usuários que não moram em Tóquio, essa cláusula é muito útil.
SELECT * FROM users WHERE pref <> 'Tóquio';> e >= : Buscar valores maiores ou iguais
Comparar números é fácil. Por exemplo, para encontrar “bons clientes” com mais de 100 pontos, usamos >.
SELECT * FROM users WHERE points > 100;Se quiser incluir o limite, como em “usuários com 32 anos ou mais”, use >=. A presença ou ausência do = muda o resultado.
SELECT * FROM users WHERE age >= 32;Aplicações da cláusula WHERE – Manipulando dados com condições avançadas
Após dominar o básico, vamos para o nível avançado. Combinando múltiplas condições ou usando operadores especiais, a cláusula WHERE se torna ainda mais poderosa.
AND e OR : Combinação de múltiplas condições
AND extrai dados que satisfazem todas as condições. Vamos buscar usuários que moram em Tóquio e têm menos de 30 anos.
SELECT * FROM users WHERE pref = 'Tóquio' AND age < 30;OR, por outro lado, retorna dados que atendem a qualquer uma das condições. É útil para listar, por exemplo, usuários de Osaka ou com 50 anos ou mais.
SELECT * FROM users WHERE pref = 'Osaka' OR age >= 50;IN : Especificar múltiplos valores de uma vez
Se quiser encontrar usuários de Tóquio, Osaka ou Fukuoka, você poderia usar várias cláusulas OR. Mas isso se torna difícil com muitos valores. A cláusula IN resolve isso de forma elegante. Além de melhorar a legibilidade, também pode ser mais eficiente em alguns bancos de dados.
SELECT * FROM users WHERE pref IN ('Tóquio', 'Osaka', 'Fukuoka');`BETWEEN` : Especificando um intervalo
Quando você quer filtrar valores dentro de um intervalo — como "usuários com idade entre 30 e 50 anos" — o `BETWEEN` é uma forma intuitiva. Ele equivale a `age >= 30 AND age <= 50`, mas é mais direto. Atenção: o `BETWEEN` inclui os valores das extremidades (ou seja, é >= e <=).
SELECT * FROM users WHERE age BETWEEN 30 AND 50;`LIKE` : Pesquisa com correspondência parcial
O operador `LIKE` é muito útil para buscar por trechos específicos em textos. Ele utiliza caracteres curinga para ampliar as possibilidades de busca.
- `%` : Corresponde a qualquer sequência de caracteres (inclusive vazia)
- `_` : Corresponde a qualquer caractere único
Por exemplo, para encontrar usuários cujos nomes contenham "ro" (correspondência no meio), envolva a string de destino com `%`.
SELECT * FROM users WHERE name LIKE '%ro%';Para encontrar usuários cujo sobrenome comece com "Sato" (correspondência de prefixo), escreva assim:
SELECT * FROM users WHERE name LIKE 'Sato%';`IS NULL`: Buscando "nada"
`NULL` em um banco de dados representa um estado especial que significa "nenhum dado existe". É completamente diferente de `0` ou de uma string vazia (`''`). Para buscar por `NULL`, utilize a sintaxe especial `IS NULL` em vez de `=`. Vamos encontrar usuários que não possuem dados de pontos registrados.
SELECT * FROM users WHERE points IS NULL;Por outro lado, para buscar dados que não sejam `NULL` (ou seja, que tenham algum valor), use `IS NOT NULL`.
SELECT * FROM users WHERE points IS NOT NULL;3 armadilhas comuns para iniciantes
Embora o WHERE seja muito útil, há algumas armadilhas que podem te pegar desprevenido se você não estiver atento. Vamos revisar três pontos importantes.
- Precedência e parênteses `()` com `AND` e `OR`
Em SQL, `AND` tem precedência maior que `OR`. Sem parênteses, condições complexas podem se comportar de maneira inesperada. Por exemplo, para extrair "usuários que moram em Tokyo ou Osaka e têm 30 anos ou mais", é necessário agrupar a condição `OR` com parênteses para que o banco de dados interprete corretamente. - Considere os tipos de dados
Os valores devem corresponder ao tipo de dado da coluna: strings entre aspas (`'texto'`), números sem aspas. Alguns bancos fazem conversões automáticas, mas isso pode causar lentidão ou resultados incorretos. É boa prática sempre usar os tipos corretos. - `NULL` significa ausência total
Como vimos, `NULL` é especial. `points = 0` e `points IS NULL` são bem diferentes. Por exemplo, `COUNT(points)` não conta valores `NULL`, mas `COUNT(*)` conta tudo. Compreender isso ajuda a evitar erros em relatórios e estatísticas.
-- Condição no formato (A OR B) AND C
SELECT * FROM users WHERE (pref = 'Tokyo' OR pref = 'Osaka') AND age >= 30;O poder do WHERE vai além do SELECT
O `WHERE` também é vital nas instruções `UPDATE` e `DELETE`. Sem ele, você pode alterar ou excluir **todos os dados** da tabela por engano.
Exemplo assustador: se você rodar `DELETE FROM users` sem `WHERE`, todos os usuários serão apagados. Por isso, sempre faça um `SELECT` antes para conferir os registros que serão afetados.
-- Sempre verifique com SELECT primeiro!
SELECT * FROM users WHERE id = 3;
-- Após verificar, faça o UPDATE com segurança
-- UPDATE users SET points = points + 50 WHERE id = 3;【Prática】Execute SQL no seu navegador!
Agora é sua vez! Copie o código abaixo, salve como `sql-practice.html` e abra no navegador.
Utilizando a biblioteca JavaScript `sql.js`, o código cria um banco de dados temporário no seu navegador. Cole as instruções SQL que você aprendeu neste artigo e clique em "Executar SQL" para ver os resultados ao vivo. Experimente diferentes filtros e explore os efeitos do `WHERE`!
<!DOCTYPE html>
<html lang="pt">
<head>
<meta charset="UTF-8">
<title>Ambiente de Execução SQL (Cláusula WHERE)</title>
<style>
body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; display: flex; flex-direction: column; height: 100vh; margin: 0; background-color: #f9f9f9; }
.header { padding: 15px 20px; background-color: #fff; border-bottom: 1px solid #ddd; }
.main-content { display: flex; flex: 1; overflow: hidden; }
.container { flex: 1; display: flex; flex-direction: column; padding: 20px; overflow-y: auto; }
.container:first-child { border-right: 1px solid #ddd; }
h3 { margin-top: 0; color: #333; }
textarea { height: 200px; border: 1px solid #ccc; border-radius: 4px; padding: 10px; font-family: "SF Mono", "Fira Code", "Source Code Pro", monospace; font-size: 14px; margin-top: 10px; resize: vertical; }
button { background-color: #007bff; color: white; border: none; padding: 12px 18px; border-radius: 4px; cursor: pointer; margin-top: 10px; font-size: 16px; transition: background-color 0.2s; }
button:hover { background-color: #0056b3; }
table { border-collapse: collapse; width: 100%; margin-top: 10px; background-color: #fff; }
th, td { border: 1px solid #ddd; padding: 10px; text-align: left; }
th { background-color: #f2f2f2; font-weight: 600; }
#error { color: #d9534f; font-weight: bold; margin-top: 10px; white-space: pre-wrap; }
</style>
<script src="https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.10.3/sql-wasm.js"></script>
</head>
<body>
<div class="header">
<h2 style="margin: 0;">Área de Prática da Cláusula SQL WHERE</h2>
</div>
<div class="main-content">
<div class="container">
<h3>Entrada SQL</h3>
<textarea id="sql-input">-- Edite esta SQL para testar!
SELECT * FROM users WHERE pref = 'Tóquio';</textarea>
<button onclick="executeSql()">Executar SQL</button>
<div id="error"></div>
</div>
<div class="container">
<h3>Resultado</h3>
<div id="result-table"></div>
</div>
</div>
<script>
let db;
async function initDb() {
try {
const config = { locateFile: filename => `https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.10.3/${filename}` };
const SQL = await initSqlJs(config);
db = new SQL.Database();
const initialSql = `
CREATE TABLE users (id INT PRIMARY KEY, name VARCHAR(50), age INT, pref VARCHAR(50), points INT);
INSERT INTO users (id, name, age, pref, points) VALUES
(1, 'Tarō Tanaka', 25, 'Tóquio', 120),
(2, 'Ichirō Suzuki', 32, 'Osaka', 85),
(3, 'Hanako Satō', 28, 'Tóquio', 300),
(4, 'Jirō Takahashi', 45, 'Fukuoka', 50),
(5, 'Sakura Itō', 25, 'Hokkaido', null),
(6, 'Saburō Watanabe', 32, 'Tóquio', 150),
(7, 'Shirō Yamamoto', 51, 'Osaka', 210);
`;
db.run(initialSql);
executeSql(); // Exibição inicial
} catch (e) {
document.getElementById('error').textContent = "Falha ao inicializar o banco de dados: " + e.message;
}
}
function executeSql() {
const sqlInput = document.getElementById('sql-input').value;
const errorEl = document.getElementById('error');
const resultEl = document.getElementById('result-table');
errorEl.textContent = '';
resultEl.innerHTML = '';
try {
const results = db.exec(sqlInput);
if (results.length > 0) {
resultEl.appendChild(createTable(results[0]));
} else {
resultEl.innerHTML = '<p>A consulta foi bem-sucedida, mas não retornou resultados (ex: instruções UPDATE).</p>';
}
} catch (e) {
errorEl.textContent = "Erro SQL: " + e.message;
}
}
function createTable(result) {
const table = document.createElement('table');
const thead = document.createElement('thead');
const tbody = document.createElement('tbody');
const headerRow = document.createElement('tr');
result.columns.forEach(col => {
const th = document.createElement('th');
th.textContent = col;
headerRow.appendChild(th);
});
thead.appendChild(headerRow);
result.values.forEach(row => {
const tr = document.createElement('tr');
row.forEach(cell => {
const td = document.createElement('td');
td.textContent = cell === null ? 'NULL' : cell;
tr.appendChild(td);
});
tbody.appendChild(tr);
});
table.appendChild(thead);
table.appendChild(tbody);
return table;
}
initDb();
</script>
</body>
</html>
Resumo e próximos passos
Neste artigo, exploramos a cláusula WHERE do SQL desde o básico até aplicações práticas. Esperamos que você tenha percebido o quanto essa cláusula é poderosa e flexível na filtragem de dados.
Dominar a cláusula WHERE é apenas o começo. Se deseja aprofundar seus conhecimentos em SQL, recomendamos estudar os seguintes tópicos:
- Funções de agregação (`COUNT`, `SUM`, `AVG`, etc.) e `GROUP BY`: Agrupar dados e calcular totais ou médias.
- Cláusula `JOIN`: Relacionar múltiplas tabelas para extrair dados mais complexos.
- Subqueries: Técnicas avançadas com consultas dentro de outras consultas.
Ao dominar esses conceitos, sua capacidade de manipular dados aumentará significativamente, ampliando suas possibilidades como desenvolvedor web. Esperamos que este artigo seja o primeiro passo de uma grande jornada!