SELECT básico: colunas, todas as linhas e aliases

1. Introdução ao comando SELECT

O comando SELECT é a instrução fundamental da linguagem SQL para consultar dados armazenados em bancos de dados relacionais. Diferentemente de comandos como INSERT, UPDATE ou DELETE, que modificam os dados, o SELECT apenas os recupera, sem alterar o estado original da tabela.

A estrutura sintática mínima do SELECT é:

SELECT coluna1, coluna2 FROM nome_da_tabela;

Essa instrução diz ao banco de dados: "quero ver os valores das colunas coluna1 e coluna2 que estão na tabela nome_da_tabela". O FROM é obrigatório quando consultamos uma tabela real (exceção: SELECT sem FROM existe em alguns SGBDs para cálculos simples).

2. Selecionando colunas específicas

Para selecionar colunas específicas, basta listá-las separadas por vírgula após o SELECT. A ordem em que você escreve as colunas determina a ordem em que elas aparecem no resultado.

Exemplo prático — considere uma tabela funcionarios com as colunas: id, nome, cargo, salario, data_admissao.

SELECT nome, cargo, salario FROM funcionarios;

Resultado (exemplo):

nome        | cargo        | salario
------------+--------------+--------
Maria Silva | Analista     | 4500.00
João Santos | Desenvolvedor| 5200.00
Ana Costa   | Gerente      | 7800.00

Você pode selecionar colunas de tipos diferentes — texto (nome), número (salario), data (data_admissao) — sem qualquer restrição:

SELECT nome, salario, data_admissao FROM funcionarios;

3. Selecionando todas as colunas de uma tabela

O asterisco (*) é um curinga que representa todas as colunas da tabela:

SELECT * FROM funcionarios;

Isso retorna todas as linhas com todas as colunas disponíveis.

Vantagens do SELECT *:
- Praticidade durante a exploração inicial dos dados
- Útil em scripts temporários ou análises rápidas
- Não exige conhecimento prévio de todos os nomes de colunas

Desvantagens do SELECT *:
- Desempenho: em tabelas com muitas colunas, você transfere dados desnecessários
- Quebra de código: se a estrutura da tabela mudar (adição/remoção de colunas), o resultado da consulta pode quebrar aplicações que esperam uma ordem fixa
- Clareza: dificulta o entendimento de quais dados estão sendo recuperados

Em produção, evite SELECT * e prefira listar explicitamente as colunas necessárias.

4. Aliases (apelidos) para colunas

Aliases permitem renomear temporariamente uma coluna no resultado da consulta. Isso melhora a legibilidade, especialmente quando:
- O nome original é muito longo ou pouco descritivo
- Você usa expressões ou funções na coluna
- Precisa de nomes mais amigáveis para o relatório final

A sintaxe usa a palavra-chave AS (opcional em alguns SGBDs):

SELECT coluna AS apelido FROM tabela;

Exemplo:

SELECT nome AS funcionario, salario AS salario_atual FROM funcionarios;

Resultado:

funcionario   | salario_atual
--------------+--------------
Maria Silva   | 4500.00
João Santos   | 5200.00
Ana Costa     | 7800.00

Se o alias contiver espaços ou caracteres especiais, use aspas duplas (no PostgreSQL e SQL Server) ou aspas simples (no MySQL):

SELECT nome AS "Nome do Funcionário", salario AS "Salário Atual" FROM funcionarios;

5. Aliases para tabelas

Assim como colunas, as tabelas também podem receber aliases. A sintaxe é:

SELECT alias.coluna FROM tabela AS alias;

Exemplo:

SELECT f.nome, f.cargo FROM funcionarios AS f;

Aqui, f é um alias para a tabela funcionarios. Isso é particularmente útil quando:
- O nome da tabela é longo (ex: relatorio_vendas_mensais → rv)
- Você precisa referenciar a mesma tabela várias vezes na consulta
- Prepara o terreno para JOINs entre múltiplas tabelas

Exemplo com tabela de nome longo:

SELECT rv.id, rv.valor_total 
FROM relatorio_vendas_mensais AS rv;

6. Combinando colunas, aliases e expressões simples

O verdadeiro poder do SELECT aparece quando combinamos colunas com expressões e damos a elas aliases descritivos.

Expressões aritméticas:

SELECT nome, salario, salario * 1.1 AS salario_com_aumento 
FROM funcionarios;

Resultado:

nome        | salario | salario_com_aumento
------------+---------+--------------------
Maria Silva | 4500.00 | 4950.00
João Santos | 5200.00 | 5720.00
Ana Costa   | 7800.00 | 8580.00

Concatenação de colunas (no PostgreSQL usa-se ||; no MySQL, CONCAT()):

-- PostgreSQL
SELECT nome || ' - ' || cargo AS descricao_completa 
FROM funcionarios;

-- MySQL
SELECT CONCAT(nome, ' - ', cargo) AS descricao_completa 
FROM funcionarios;

Exemplo prático completo — montando uma consulta com nome completo e valor calculado:

SELECT 
    nome AS funcionario,
    cargo AS cargo_atual,
    salario AS salario_base,
    salario * 1.15 AS salario_com_bonus,
    salario * 12 AS salario_anual
FROM funcionarios
WHERE cargo = 'Analista';

Resultado:

funcionario   | cargo_atual | salario_base | salario_com_bonus | salario_anual
--------------+-------------+--------------+-------------------+--------------
Maria Silva   | Analista    | 4500.00      | 5175.00           | 54000.00

7. Boas práticas e dicas finais

  1. Prefira colunas explícitas em produção — evite SELECT * em código que será executado regularmente.

  2. Use aliases descritivos — salario_com_bonus é mais informativo que apenas s. Evite aliases muito curtos como a, b, c a menos que seja para tabelas em JOINs complexos.

  3. Consistência nos aliases — se você usa AS para colunas, use também para tabelas (ou omita em ambos). Seja consistente.

  4. Cuidado com aliases em ORDER BY e WHERE — no PostgreSQL, você pode usar aliases de coluna no ORDER BY, mas não no WHERE (a ordem de execução do SQL não permite). Exemplo:

SELECT nome, salario * 1.1 AS novo_salario 
FROM funcionarios 
ORDER BY novo_salario;  -- Funciona no PostgreSQL
  1. Diferenças entre SGBDs:
  2. PostgreSQL: suporta AS e "" para aliases com espaços
  3. MySQL: aceita AS e também ` (crase) para aliases com espaços

  4. SQL Server: similar ao PostgreSQL, usa [] ou "" para aliases especiais

  5. Documente consultas complexas — quando usar expressões, considere adicionar comentários SQL (-- comentário) explicando o cálculo.

Dominar o SELECT básico — com colunas explícitas, aliases e expressões — é o primeiro passo para consultas SQL eficientes e legíveis. Pratique esses conceitos com dados reais e, em breve, estará pronto para explorar filtros (WHERE), ordenação (ORDER BY) e junções (JOIN).

Referências