SELECT no SQLite: consultando colunas e expressões

SELECT no SQLite: lendo linhas de uma tabela

Toda pergunta que você faz a um banco SQLite começa com SELECT. A ideia é direta: me devolva essas colunas, dessa tabela, das linhas que batem com essas condições. Por enquanto, o foco é nas duas primeiras partes — quais colunas e qual tabela. O filtro fica para o próximo documento.

A consulta mais simples possível:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL,
    stock INTEGER
);

INSERT INTO products (name, price, stock) VALUES
    ('Caderno', 4.50, 120),
    ('Caneta', 1.20, 500),
    ('Mochila', 39.99, 25),
    ('Borracha', 0.80, 300);

SELECT * FROM products;

SELECT * significa "todas as colunas". O FROM products indica de qual tabela vêm os dados. O resultado é uma linha por registro, com as quatro colunas. O ponto e vírgula encerra o comando.

No fim das contas, a estrutura é essa: SELECT <colunas> FROM <tabela>;.

Selecionando colunas específicas no SQLite

O * quebra um galho quando você está só explorando os dados. Mas, em código de verdade, na maioria das vezes você vai querer listar exatamente as colunas que importam:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL,
    stock INTEGER
);

INSERT INTO products (name, price, stock) VALUES
    ('Caderno', 4.50, 120),
    ('Caneta', 1.20, 500),
    ('Mochila', 39.99, 25);

SELECT name, price FROM products;

Você recebe duas colunas, na ordem em que pediu. A ordem da lista do SELECT define a ordem do resultado — ela não precisa bater com a ordem das colunas na tabela.

Por que isso é melhor do que SELECT *? Dois motivos. Primeiro, trafega menos dado (ou menos coisa é lida do arquivo), o que faz diferença quando a tabela tem muitas colunas. Segundo, sua consulta continua estável quando alguém adicionar uma coluna nova mês que vem. O SELECT * passa a devolver mais campos sem avisar, e isso pode quebrar código de aplicação que desempacota as linhas por posição.

SELECT também calcula, não só busca

As colunas da lista do SELECT não precisam ser apenas nomes de colunas. Podem ser qualquer expressão — operações aritméticas, chamadas de função, concatenação de strings, constantes. O SQLite avalia a expressão para cada linha.

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL,
    stock INTEGER
);

INSERT INTO products (name, price, stock) VALUES
    ('Caderno', 4.50, 120),
    ('Caneta', 1.20, 500),
    ('Mochila', 39.99, 25);

SELECT name, price, stock, price * stock FROM products;

A quarta coluna nem existe na tabela — o SQLite calculou ela linha por linha. Dá pra fazer o mesmo com funções de string, datas, expressões condicionais, o que você quiser. A lista do SELECT é o lugar onde você molda os dados, não só onde você os busca.

Inclusive, você pode usar SELECT sem cláusula FROM, tratando o SQLite como uma calculadora:

SELECT 2 + 2, upper('olá'), length('SQLite');

Uma linha, três colunas. Bom para testar o que uma expressão faz antes de jogar ela numa consulta de verdade.

Apelidos de coluna com AS

Quando você calcula uma coluna, o SQLite escolhe um nome padrão para ela — geralmente a própria expressão, tipo price * stock. Isso fica feio e instável. Dê um nome decente para a coluna usando AS:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL,
    stock INTEGER
);

INSERT INTO products (name, price, stock) VALUES
    ('Caderno', 4.50, 120),
    ('Mochila', 39.99, 25);

SELECT
    name AS product,
    price * stock AS inventory_value
FROM products;

O apelido é o nome que a coluna recebe no resultado da consulta. Isso faz diferença na hora de ler a saída e faz muita diferença no código da aplicação, que costuma acessar valores pelo nome da coluna (row["inventory_value"] em vez de row[1]).

A palavra-chave AS é opcional — price * stock inventory_value funciona do mesmo jeito —, mas vale a pena escrevê-la. A intenção fica mais clara e você evita que alguém confunda uma vírgula esquecida com um alias.

Criando alias para a tabela

Você também pode dar um apelido curto para a própria tabela. Com uma tabela só, isso parece pouco útil, mas o hábito compensa demais quando você começa a fazer joins:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL
);

INSERT INTO products (name, price) VALUES ('Caderno', 4.50);

SELECT p.name, p.price FROM products AS p;

p agora funciona como apelido de products. A forma com ponto, p.name, deixa explícito de qual tabela vem cada coluna. Com uma única tabela isso é só ruído; com três tabelas em um JOIN, é o que mantém a consulta legível.

Literais e constantes no resultado

Dá pra misturar colunas reais com valores constantes. Isso é útil quando você quer rotular linhas ou preencher um valor fixo:

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL
);

INSERT INTO products (name, price) VALUES
    ('Caderno', 4.50),
    ('Caneta', 1.20);

SELECT
    name,
    price,
    'USD' AS currency,
    1 AS active
FROM products;

Toda linha recebe o mesmo 'USD' e 1. Esse padrão aparece bastante quando você está juntando resultados de várias consultas com UNION e precisa de uma coluna marcadora para identificar de onde veio cada registro.

Uma palavrinha sobre NULL

Algumas colunas vêm vazias — ou porque nenhum valor foi inserido, ou porque a coluna não tem valor padrão. No SQLite, essa "ausência de valor" é representada por NULL, que aparece nos resultados do SELECT como um espaço em branco ou como a palavra NULL, dependendo da ferramenta que você estiver usando.

CREATE TABLE products (
    id INTEGER PRIMARY KEY,
    name TEXT,
    price REAL
);

INSERT INTO products (name, price) VALUES
    ('Caderno', 4.50),
    ('Item Misterioso', NULL);

SELECT name, price, price * 2 AS doubled FROM products;

Olhe a segunda linha. price é NULL, e price * 2 também é NULL — qualquer operação aritmética envolvendo NULL resulta em NULL. Essa é uma das maiores fontes de confusão em resultados de SQL, e tem uma página inteira dedicada a isso mais adiante. Por enquanto, basta notar que NULL é contagioso quando aparece em expressões.

O que fica de aprendizado

• SELECT <colunas> FROM <tabela>; é o formato de toda consulta SQL no SQLite.
• Em código de verdade, liste as colunas explicitamente; deixe SELECT * para quando estiver explorando os dados.
• A lista do SELECT aceita qualquer expressão, não só nomes de coluna.
• Use AS para dar nomes decentes a colunas calculadas e a tabelas com alias.
• NULL se propaga pela aritmética — lembre disso quando o resultado parecer estranho.

A seguir: filtrando com WHERE

Até aqui, toda consulta devolve todas as linhas da tabela. A cláusula WHERE é o que serve para afunilar esse resultado — escolher linhas por preço, por nome, por data ou por qualquer expressão que retorne verdadeiro ou falso. É o assunto do próximo documento.