Anatomia do SELECT: o que buscar e como nomear

Capítulo 2 — «Primeiro acesso»

O inventário foi lido — e a QUERY cumpre a promessa.

No centro do salão, um holopainel âmbar se abre com um clique suave: o terminal de leitura é liberado para a sua conta. O cursor pisca numa linha vazia. O arquivo está pronto para responder — mas só responde a perguntas bem formuladas.

Uma consulta é um protocolo de acesso.
Cada palavra nela ocupa o lugar certo.
Uma palavra diz o que mostrar. Outra, de onde tirar. E a terceira, como chamar o resultado, para que uma pessoa o entenda sem precisar decifrar nada.

QUERY: O terminal é seu. Fale com o arquivo de forma curta e precisa: ele não é surdo, só não responde a pedidos confusos.

O que o SELECT faz de verdade

Em SQL, costuma-se dizer que
o SELECT “escolhe colunas”.

Isso funciona bem como primeira explicação, mas não é a história completa.

Na verdade, o SELECT monta o resultado da consulta.

Esse resultado se parece com uma tabela: tem colunas e linhas. Mas essas colunas não precisam ser cópias exatas das colunas da tabela de origem.

O SELECT pode mostrar:

• colunas de uma tabela;
• números fixos;
• valores de texto;
• resultados de cálculos;
• expressões construídas a partir de colunas;
• resultados de funções;
• nomes temporários de colunas, criados com apelidos.

Ou seja, o SELECT responde à pergunta:

O que deve aparecer na saída final?

O caso mais comum é buscar dados de uma tabela:

SELECT name, price
FROM products;

Essa consulta diz:

Mostre os valores das colunas name e price da tabela products.

Mas o SELECT faz mais do que isso. No PostgreSQL, por exemplo, dá para executar uma consulta sem tabela nenhuma:

SELECT 1;

O resultado é uma tabelinha com uma linha e uma coluna.

Dá para exibir um texto:

SELECT 'Kotomarket';

Dá para exibir um cálculo:

SELECT 2 + 2;

E dá para já batizar o resultado com um nome claro:

SELECT 2 + 2 AS result;

Uma consulta dessas não “tira uma coluna pronta da tabela”. Ela pede ao banco que calcule uma expressão e mostre o resultado.

Essa é uma ideia importante:

O SELECT nem sempre pega colunas prontas. Às vezes ele cria as colunas do resultado bem no momento em que a consulta roda.

A consulta mínima a uma tabela

Quando você precisa dos dados de uma tabela, a consulta costuma ter esta forma:

SELECT colunas
FROM tabela;

Por exemplo:

SELECT name, price
FROM products;

Vamos destrinchar:

• SELECT name, price — quais valores mostrar no resultado;
• FROM products — de qual tabela vêm as linhas;
• ; — o fim do comando SQL.

Depois do SELECT, liste as colunas necessárias separadas por vírgula:

SELECT name, price, stock
FROM products;

Essa consulta vai mostrar três colunas no resultado:

• name;
• price;
• stock.

E, se você quiser ver todas as colunas da tabela, pode usar *:

SELECT *
FROM products;

O asterisco significa:

Mostre todas as colunas que existem na tabela.

Isso é prático no primeiro contato com uma tabela, mas nas consultas do dia a dia é melhor não abusar do *.

Por quê?

Porque o SELECT * pode devolver dados demais: campos técnicos, descrições de texto enormes, datas de controle, identificadores internos. Além disso, se a estrutura da tabela mudar, o resultado do SELECT * muda junto.

Para explorar e aprender, o * está de bom tamanho.
Numa consulta caprichada do dia a dia, é melhor listar explicitamente as colunas necessárias.

Apelidos: como nomear uma coluna do resultado

Às vezes os nomes das colunas no banco são convenientes para quem desenvolve, mas nem tanto para quem lê.

Por exemplo, a tabela pode ter esta coluna:

name

Mas, no relatório, você gostaria de ver:

produto

É para isso que serve o apelido — um nome temporário para a coluna no resultado da consulta.

SELECT name AS produto, price AS preço
FROM products;

O AS pode ser lido como “chame de”:

name AS produto

Ou seja:

Pegue o valor da coluna name, mas, no resultado, rotule essa coluna como produto.

Importante: o apelido não renomeia a coluna na própria tabela.
Ele muda apenas o rótulo da coluna no resultado daquela consulta.

A tabela products não muda depois de uma consulta dessas.
A coluna name estava lá antes e continua lá.

Um apelido não é uma reforma no arquivo.
É um rótulo na tela do terminal.

Os dados não mudam: você só rotula a coluna para que a saída se pareça com a vitrine de uma loja, e não com uma nota de armazém de 2024.

O arquivo lê a consulta numa ordem diferente da que você escreve

Você escreve a consulta de cima para baixo:

SELECT name AS produto, price AS preço
FROM products
LIMIT 5;

Mas, logicamente, o banco não começa pelo SELECT.

Primeiro ele precisa entender de onde tirar as linhas.
Só depois vem a questão de quais colunas e expressões mostrar no resultado.

Por isso a ordem lógica de execução da consulta é esta:

FROM → WHERE → GROUP BY → HAVING → SELECT → ORDER BY → LIMIT

Nem todas as partes dessa esteira importam para você agora. GROUP BY e HAVING aparecem mais adiante, no módulo 3. Mas já vale conhecer a ordem completa desde já.

Vamos ao sentido de cada passo:

1. FROM
   O banco entende de qual tabela buscar os dados.

2. WHERE
   O banco separa apenas as linhas que servem. Esse passo aparece na próxima aula.

3. GROUP BY
   O banco junta as linhas em grupos. Esse é o tema de um módulo futuro.

4. HAVING
   O banco filtra não mais as linhas isoladas, e sim os grupos.

5. SELECT
   O banco monta as colunas finais do resultado: pega os campos, calcula as expressões, atribui os apelidos.

6. ORDER BY
   O banco ordena o resultado.

7. LIMIT
   O banco deixa só a quantidade de linhas pedida.

Dessa ordem sai uma regra importante:

O apelido só nasce no passo SELECT.

Ou seja, antes do passo SELECT o apelido ainda não existe.

É exatamente por isso que um apelido do SELECT não pode ser usado no WHERE.

-- Assim não dá: no passo WHERE o apelido sale_price ainda não existe
SELECT name, price * 0.9 AS sale_price
FROM products
WHERE sale_price < 3000;

O banco vai tentar executar o WHERE antes de criar a coluna de resultado sale_price.

Por isso ele vai ver:

WHERE sale_price < 3000

e não vai entender o que é sale_price.

No PostgreSQL, esse erro costuma aparecer assim:

ERROR: column "sale_price" does not exist

A forma correta é repetir a expressão:

SELECT name, price * 0.9 AS sale_price
FROM products
WHERE price * 0.9 < 3000;

Aqui o banco consegue filtrar, porque price é uma coluna de verdade da tabela products. Ela já está disponível na etapa do WHERE.

Já no ORDER BY o apelido pode ser usado:

SELECT name, price * 0.9 AS sale_price
FROM products
ORDER BY sale_price;

Por que isso funciona?

Porque o ORDER BY é executado, logicamente, depois do SELECT.
Nesse momento o apelido sale_price já foi criado.

Importante: essa ordem é chamada de lógica. Ela explica o sentido da consulta e as regras de visibilidade dos nomes. Fisicamente, o otimizador do banco de dados pode reorganizar as operações em nome da velocidade, mas o resultado final é obrigado a corresponder à ordem lógica.

O resultado da consulta também é uma tabela

Quando você executa uma consulta, o banco devolve o resultado em forma de tabela.

Por exemplo:

SELECT name AS produto, price AS preço
FROM products
LIMIT 5;

pode devolver:

Essa tabela de resultado não precisa repetir a tabela products por inteiro.

A tabela products pode ter dezenas de colunas:

• id;
• name;
• category;
• price;
• stock;
• created_at;
• updated_at;
• e outras.

Mas, no resultado, você pediu só duas colunas:

SELECT name AS produto, price AS preço

Por isso o terminal mostra apenas elas.

A consulta não é a tabela em si.
A consulta é a instrução que o banco segue para montar uma saída temporária.

SELECT sem tabela

Na maioria dos exemplos de estudo, o SELECT aparece junto com o FROM:

SELECT name
FROM products;

Mas, no PostgreSQL, o SELECT também funciona sem tabela.

Por exemplo:

SELECT 1;

O banco devolve uma linha com o número 1.

Dá para exibir um texto:

SELECT 'Arquivo ativo';

Dá para fazer um cálculo:

SELECT 10 * 3;

E dá para batizar o resultado com um nome claro:

SELECT 10 * 3 AS total;

O resultado fica mais ou menos assim:

Para que isso serve?

Em primeiro lugar, é um jeito prático de testar expressões simples.
Em segundo, ajuda a entender uma ideia importante: o SELECT não apenas copia colunas de uma tabela. Ele monta as colunas do resultado.

Às vezes essas colunas vêm de uma tabela.
Às vezes elas são calculadas na própria consulta.

QUERY: O arquivo não precisa abrir uma gaveta para responder a uma pergunta. Às vezes a resposta já está dentro da própria pergunta.

Observação: neste curso trabalhamos com o PostgreSQL. Em alguns outros SGBDs, a sintaxe de uma consulta que não usa nenhuma tabela pode ser diferente.

Expressões no SELECT

No SELECT você pode escrever não só nomes de colunas, mas também expressões.

Por exemplo, a tabela products tem o preço do item:

price

Se você precisa mostrar o preço com 10% de desconto, pode escrever:

SELECT name, price, price * 0.9 AS sale_price
FROM products;

Aqui:

• name — uma coluna comum;
• price — uma coluna comum;
• price * 0.9 — um cálculo;
• AS sale_price — o nome da coluna calculada no resultado.

O banco pega o valor de price em cada linha, multiplica por 0.9 e mostra o resultado numa coluna nova, sale_price.

Se a tabela tiver estes dados:

então a consulta:

SELECT name, price, price * 0.9 AS sale_price
FROM products;

vai devolver mais ou menos isto:

Um ponto importante: a coluna sale_price não passou a existir na tabela products.

Ela existe apenas no resultado da consulta.

Ou seja, o SELECT pode criar colunas calculadas no resultado.

AS: um rótulo temporário, não uma mudança na tabela

Um apelido com AS pode ser dado a:

• uma coluna comum;
• uma expressão calculada;
• um valor de texto;
• o resultado de uma função.

Exemplos:

SELECT name AS product_name
FROM products;

SELECT price * 0.9 AS sale_price
FROM products;

SELECT 'Kotomarket' AS archive_name;

O AS deixa o resultado mais claro.

Compare:

SELECT price * 0.9
FROM products;

Aí o nome da coluna no resultado pode sair técnico e pouco claro.

Melhor assim:

SELECT price * 0.9 AS sale_price
FROM products;

Agora fica claro de cara que é o preço com desconto.

Às vezes o AS pode ser omitido:

SELECT name product_name
FROM products;

Mas, para quem está começando e para um código de estudo legível, é melhor escrever o AS explicitamente:

SELECT name AS product_name
FROM products;

Assim a consulta fica mais fácil de ler.

Apelidos com mais de uma palavra

Se você quiser dar à coluna um nome com várias palavras, precisa de aspas duplas:

SELECT price * 0.9 AS "preço com desconto"
FROM products;

Mas, tanto nos estudos quanto no dia a dia, costuma ser mais prático usar nomes curtos e sem espaços:

SELECT price * 0.9 AS sale_price
FROM products;

Um apelido assim é mais simples de reaproveitar depois no ORDER BY e mais fácil de ler no código.

É importante não confundir:

• aspas simples '...' — para texto;
• aspas duplas "..." — para nomes de colunas, apelidos e outros identificadores, quando eles têm espaços ou precisam manter a grafia exata.

Exemplo de texto:

SELECT 'preço com desconto' AS label;

Exemplo de nome de coluna do resultado:

SELECT price * 0.9 AS "preço com desconto"
FROM products;

SELECT *: uma olhada rápida em tudo

O asterisco * significa “todas as colunas”.

SELECT *
FROM products;

Uma consulta dessas é prática quando você está conhecendo a tabela pela primeira vez e quer saber que dados ela guarda.

Mas o SELECT * é um holofote grosseiro.
Ele ilumina tudo de uma vez: o que interessa, o que sobra, o que é interno, o que é temporário, o que é técnico.

Em consultas de estudo, ele ajuda a se situar rápido.
Nas consultas do dia a dia, é melhor ser explícito:

SELECT name, price, stock
FROM products;

Assim você controla o resultado com precisão.

Mau hábito de quem está começando:

SELECT *
FROM products;

mesmo quando só o nome e o preço são necessários.

Bom hábito:

SELECT name, price
FROM products;

Uma consulta assim é mais clara, mais caprichada e mais segura diante de mudanças futuras.

Análise da sua primeira consulta de verdade

Vamos olhar a consulta do terminal:

SELECT name AS produto, price AS preço
FROM products
LIMIT 5;

Ela se lê assim:

Da tabela products, mostre os valores das colunas name e price,
mas, no resultado, rotule-as como produto e preço,
e traga apenas as 5 primeiras linhas.

Linha por linha:

SELECT name AS produto, price AS preço

Monta as colunas do resultado.

FROM products

Indica de qual tabela os dados vêm.

LIMIT 5

Limita a saída a cinco linhas.

O LIMIT é útil quando a tabela é grande. Se o arquivo guarda milhares ou milhões de itens, nem sempre é preciso trazer tudo de uma vez. Às vezes as primeiras linhas já bastam para conferir a estrutura dos dados.

QUERY: Não abra a comporta inteira só para medir a pressão. Cinco linhas bastam para saber se o arquivo está respondendo direito.

Onde o apelido é visível e onde não é

A regra principal:

O apelido só fica visível depois de ser criado na etapa do SELECT.

Por isso:

Exemplo em que o apelido não funciona:

SELECT name, price * 0.9 AS sale_price
FROM products
WHERE sale_price < 3000;

Exemplo em que o apelido funciona:

SELECT name, price * 0.9 AS sale_price
FROM products
ORDER BY sale_price;

Se você guardar a ordem lógica, erros assim ficam muito mais fáceis de entender.

Erros frequentes nas primeiras consultas com SELECT

Erro 1. Esquecer a vírgula entre as colunas

Errado:

SELECT name price
FROM products;

O banco pode entender isso de um jeito diferente do que você espera: como se price fosse um apelido para name.

Certo:

SELECT name, price
FROM products;

Erro 2. Colocar o FROM antes do SELECT

Errado:

FROM products
SELECT name, price;

Certo:

SELECT name, price
FROM products;

O SQL é escrito na sua própria ordem sintática: primeiro o SELECT, depois o FROM.

Mas, logicamente, o banco começa o processamento pelo FROM.

Erro 3. Achar que o apelido muda a tabela

SELECT name AS produto
FROM products;

Depois dessa consulta, a tabela não ganha nenhuma coluna produto.

O apelido existe apenas no resultado dessa consulta.

Erro 4. Usar aspas simples no nome do apelido

Melhor não escrever assim:

SELECT price AS 'preço'
FROM products;

No PostgreSQL, as aspas simples servem para texto, não para nomes de colunas.

Certo:

SELECT price AS preço
FROM products;

Ou, se você precisar de um apelido com espaço:

SELECT price AS "preço do produto"
FROM products;

Erro 5. Usar o apelido no WHERE

Errado:

SELECT price * 0.9 AS sale_price
FROM products
WHERE sale_price < 3000;

Certo:

SELECT price * 0.9 AS sale_price
FROM products
WHERE price * 0.9 < 3000;

Erro 6. Escrever sempre SELECT *

Para o primeiro contato com a tabela, tudo bem:

SELECT *
FROM products;

Mas, para uma consulta clara, é melhor:

SELECT name, price
FROM products;

Assim fica logo claro de quais dados você precisa.

QUERY: Primeiro acesso liberado. Você já não olha para o arquivo como um paredão de dados. Agora você sabe dizer a ele que forma a resposta deve ter.