SQL Views

Toda manhã a Ana abre o banco da Loja Aurora e digita a mesma consulta comprida: junta pedidos, clientes e itens, soma os itens, soma o frete e arredonda, para ver quanto deu cada pedido. São oito linhas de SQL, e um erro de digitação estraga tudo. Não seria bom salvar essa consulta com um nome e depois só escrever SELECT * FROM v_pedidos_total? É isso que uma view faz. Nesta aula você vai criar views com CREATE VIEW, usá-las como se fossem tabelas, apagá-las com DROP VIEW e entender o que uma view não é.

Os exemplos rodam de verdade no seu navegador, num SQLite com o banco da Loja Aurora. Cada exemplo parte do banco limpo, então a view que um exemplo cria não existe no seguinte: por isso quase todo exemplo começa com o seu CREATE VIEW. As sessões de terminal saíram do sqlite3 3.50.4 no computador fictício da Ana.

A ideia: um filtro salvo na planilha

Imagine a planilha de clientes da loja, com 30 linhas. A Ana vive filtrando "só os do Piauí". Em vez de refazer o filtro toda vez, ela cria uma aba nova chamada "Clientes PI", que não tem dados próprios: ela só mostra as linhas da aba principal que passam no filtro. Quando um cliente novo do Piauí entra na aba principal, ele aparece sozinho na aba "Clientes PI".

Uma view (em português, "visão" ou "vista") é essa aba. Ela é uma consulta SELECT guardada no banco com um nome. Toda vez que alguém consulta a view, o banco roda o SELECT guardado, naquele momento, nos dados de agora. Por isso as views também são chamadas de tabelas virtuais: parecem tabelas, mas não guardam nenhuma linha.

1. A primeira view: CREATE VIEW

A aba "Clientes PI" da planilha, em SQL:

CREATE VIEW v_clientes_pi AS
SELECT id, nome, cidade
FROM clientes
WHERE estado = 'PI';

CREATE VIEW

"Crie uma view". Guarda a consulta no banco.

v_clientes_pi

O nome da view. Ele não pode repetir o nome de uma tabela, índice ou outra view. O prefixo v_ é um costume (não uma regra) que avisa, a quem lê, que aquilo é uma view e não uma tabela.

AS

"Como". Separa o nome da consulta que a view vai guardar.

SELECT … WHERE estado = 'PI'

Uma consulta comum, como as que você já escreve. É ela que roda toda vez que a view for usada.

O resultado foi só um "ok". Criar a view não rodou a consulta nem copiou cliente nenhum: só guardou o texto. A consulta roda quando você usa a view, no FROM, como se ela fosse uma tabela:

CREATE VIEW v_clientes_pi AS
SELECT id, nome, cidade
FROM clientes
WHERE estado = 'PI';

SELECT * FROM v_clientes_pi;

Os 14 clientes do Piauí, só com as três colunas que a view escolheu. E dá para usar a view com tudo que você já sabe: WHERE, ORDER BY, LIMIT, COUNT…

CREATE VIEW v_clientes_pi AS
SELECT id, nome, cidade
FROM clientes
WHERE estado = 'PI';

SELECT nome, cidade
FROM v_clientes_pi
WHERE cidade <> 'Teresina'
ORDER BY cidade;

O banco junta as duas coisas: o WHERE estado = 'PI' da view e o WHERE cidade <> 'Teresina' da consulta. Vieram os 4 clientes do interior do Piauí.

-- crie a view aqui:


SELECT * FROM v_papelaria;

-- crie a view aqui:
CREATE VIEW v_papelaria AS
SELECT nome, preco FROM produtos WHERE categoria_id = 1;

SELECT * FROM v_papelaria;

2. A view está sempre atualizada

Como a view não guarda linhas, ela nunca fica velha. Veja: a Ana cria a view, cadastra uma cliente nova de Teresina e conta os clientes da view antes e depois:

CREATE VIEW v_clientes_pi AS
SELECT id, nome, cidade
FROM clientes
WHERE estado = 'PI';

SELECT COUNT(*) AS antes FROM v_clientes_pi;

INSERT INTO clientes (nome, cidade, estado)
VALUES ('Ana Lúcia Reis', 'Teresina', 'PI');

SELECT COUNT(*) AS depois FROM v_clientes_pi;

Eram 14, viraram 15, e ninguém mexeu na view. O INSERT foi na tabela clientes; a view só olhou de novo. O mesmo vale para UPDATE e DELETE: qualquer mudança nas tabelas aparece na view na próxima consulta.

No terminal, a view fica gravada

No editor do guia, cada Rodar começa do banco limpo. No terminal, a view fica no arquivo, como as tabelas. Repare que o .tables lista a view junto com as tabelas, e que o .schema mostra o comando que a criou, com um comentário que o próprio sqlite3 acrescenta com as colunas da view:

$ sqlite3 loja.db
SQLite version 3.50.4 2025-07-30 19:33:53
Enter ".help" for usage hints.
sqlite> CREATE VIEW v_clientes_pi AS SELECT id, nome, cidade FROM clientes WHERE estado = 'PI';
sqlite> .tables
categorias     fornecedores   itens_pedido   produtos
clientes       funcionarios   pedidos        v_clientes_pi
sqlite> .schema v_clientes_pi
CREATE VIEW v_clientes_pi AS SELECT id, nome, cidade FROM clientes WHERE estado = 'PI'
/* v_clientes_pi(id,nome,cidade) */;
sqlite> .quit
$ sqlite3 loja.db "SELECT nome, cidade FROM v_clientes_pi LIMIT 3;"     « no dia seguinte, a view continua lá
José Ribamar Silva|Teresina
Maria Clara Mendes|Teresina
Conceição Prado|Teresina

3. Uma view que poupa trabalho de verdade

A view de clientes do Piauí é curta, e talvez nem valesse a pena. O ganho aparece com consultas grandes, como a da Ana todas as manhãs: o total de cada pedido. Ela precisa de três tabelas (INNER JOIN), de GROUP BY para somar os itens de cada pedido e de ROUND para arredondar (aula Funções Numéricas). Escrita uma vez, dentro de uma view:

CREATE VIEW v_pedidos_total AS
SELECT p.id,
       p.data,
       c.nome AS cliente,
       ROUND(SUM(i.quantidade * i.preco_unitario), 2) AS subtotal,
       p.frete,
       ROUND(SUM(i.quantidade * i.preco_unitario) + p.frete, 2) AS total
FROM pedidos AS p
JOIN clientes AS c ON c.id = p.cliente_id
JOIN itens_pedido AS i ON i.pedido_id = p.id
GROUP BY p.id, p.data, c.nome, p.frete;

SELECT * FROM v_pedidos_total LIMIT 4;

c.nome AS cliente

O apelido vira o nome da coluna da view. Quem usar a view vai escrever cliente, e não c.nome.

… AS subtotal

A soma dos itens do pedido (quantidade × preço de cada item). Sem o AS, a coluna da view se chamaria ROUND(SUM(i.quantidade * i.preco_unitario), 2): um nome horrível de usar.

… AS total

Os itens mais o frete: o que o cliente pagou. O pedido 1 deu 30.94 de itens + 9.9 de frete = 40.84.

GROUP BY p.id, …

Uma linha por pedido.

Agora as perguntas do dia viram consultas curtinhas, sem nenhum JOIN à vista:

CREATE VIEW v_pedidos_total AS
SELECT p.id, p.data, c.nome AS cliente,
       ROUND(SUM(i.quantidade * i.preco_unitario), 2) AS subtotal,
       p.frete,
       ROUND(SUM(i.quantidade * i.preco_unitario) + p.frete, 2) AS total
FROM pedidos AS p
JOIN clientes AS c ON c.id = p.cliente_id
JOIN itens_pedido AS i ON i.pedido_id = p.id
GROUP BY p.id, p.data, c.nome, p.frete;

-- os 3 maiores pedidos
SELECT id, cliente, total FROM v_pedidos_total ORDER BY total DESC LIMIT 3;

-- quem mais gastou na loja
SELECT cliente, COUNT(*) AS pedidos, ROUND(SUM(total), 2) AS gasto
FROM v_pedidos_total
GROUP BY cliente
ORDER BY gasto DESC
LIMIT 3;

A Conceição Prado é a cliente que mais gastou: 4 pedidos, 1398.03 no total. O maior pedido da loja é o 3, da Ana Beatriz Sousa: 660.0.

View dentro de view

Uma view pode usar outra. A tela "pedidos grandes" da gerente é só um filtro em cima da v_pedidos_total:

CREATE VIEW v_pedidos_total AS
SELECT p.id, p.data, c.nome AS cliente,
       ROUND(SUM(i.quantidade * i.preco_unitario), 2) AS subtotal,
       p.frete,
       ROUND(SUM(i.quantidade * i.preco_unitario) + p.frete, 2) AS total
FROM pedidos AS p
JOIN clientes AS c ON c.id = p.cliente_id
JOIN itens_pedido AS i ON i.pedido_id = p.id
GROUP BY p.id, p.data, c.nome, p.frete;

CREATE VIEW v_pedidos_grandes AS
SELECT * FROM v_pedidos_total WHERE total >= 500;

SELECT id, data, cliente, total FROM v_pedidos_grandes;

Seis pedidos passaram de 500. Se um dia a regra do total mudar (por exemplo, descontar um cupom), basta corrigir a v_pedidos_total: a v_pedidos_grandes e todas as consultas que usam as duas passam a usar a regra nova.

4. Os nomes das colunas da view

As colunas da view herdam os nomes do SELECT: o nome da coluna original ou o apelido do AS. Também dá para escrever a lista de nomes logo depois do nome da view, entre parênteses:

CREATE VIEW v_contatos (cliente, uf, correio) AS
SELECT nome, estado, email
FROM clientes;

SELECT * FROM v_contatos LIMIT 3;

A primeira coluna do SELECT ganha o primeiro nome da lista, a segunda ganha o segundo, e assim por diante. As duas formas dão no mesmo; escolha uma e não misture.

5. Vendo, trocando e apagando views

Quais views o banco tem

As views ficam na mesma tabela especial dos índices e das tabelas, a sqlite_schema, com type = 'view':

CREATE VIEW v_clientes_pi AS
SELECT id, nome, cidade FROM clientes WHERE estado = 'PI';

SELECT type, name, sql
FROM sqlite_schema
WHERE type = 'view';

A coluna sql mostra que o banco guardou só o texto da consulta. No terminal, .tables e .schema fazem o mesmo serviço (seção 2).

DROP VIEW

Para apagar uma view, use DROP VIEW ("descarte a view"). Só a view some; as tabelas e os dados continuam lá, intocados:

CREATE VIEW v_clientes_pi AS
SELECT id, nome, cidade FROM clientes WHERE estado = 'PI';

DROP VIEW v_clientes_pi;

SELECT COUNT(*) AS clientes FROM clientes;

Trocar a consulta de uma view

O SQLite não tem um comando para alterar uma view. Para mudar a consulta, apague e crie de novo. Em scripts que rodam várias vezes, use as formas "se":

CREATE VIEW v_clientes_pi AS
SELECT id, nome, cidade FROM clientes WHERE estado = 'PI';

-- a Ana quer também o email: apaga e cria de novo
DROP VIEW IF EXISTS v_clientes_pi;
CREATE VIEW v_clientes_pi AS
SELECT id, nome, cidade, email FROM clientes WHERE estado = 'PI';

SELECT * FROM v_clientes_pi LIMIT 3;

View temporária

CREATE TEMP VIEW (de temporary, "temporária") cria uma view que só existe enquanto o banco estiver aberto. Ao fechar o sqlite3, ela some sozinha. Serve para uma análise rápida, sem deixar lixo no arquivo da loja.

6. Uma view não aceita INSERT (no SQLite)

A view parece uma tabela, e a Ana tentou cadastrar um cliente por ela:

CREATE VIEW v_clientes_pi AS
SELECT id, nome, cidade FROM clientes WHERE estado = 'PI';

INSERT INTO v_clientes_pi (nome, cidade)
VALUES ('Ana Lúcia Reis', 'Teresina');

cannot modify v_clientes_pi because it is a view: "não posso modificar v_clientes_pi porque é uma view". No SQLite, as views são só de leitura: INSERT, UPDATE e DELETE numa view dão esse mesmo erro. Faz sentido: a view não tem linhas próprias, e o banco teria de adivinhar em que tabela gravar (e que estado pôr no cliente novo). Grave sempre na tabela de verdade, clientes; a view mostra o resultado na hora.

No terminal, a mesma mensagem vem com o prefixo Parse error:, porque o SQLite recusa o comando antes de rodá-lo:

$ sqlite3 loja.db
SQLite version 3.50.4 2025-07-30 19:33:53
Enter ".help" for usage hints.
sqlite> INSERT INTO v_clientes_pi (nome) VALUES ('Ana Lúcia Reis');
Parse error: cannot modify v_clientes_pi because it is a view

CREATE VIEW v_clientes_pi AS
SELECT id, nome, cidade FROM clientes WHERE estado = 'PI';

INSERT INTO v_clientes_pi (nome, cidade)
VALUES ('Ana Lúcia Reis', 'Teresina');

SELECT * FROM v_clientes_pi WHERE nome LIKE 'Ana%';

CREATE VIEW v_clientes_pi AS
SELECT id, nome, cidade FROM clientes WHERE estado = 'PI';

INSERT INTO clientes (nome, cidade, estado)
VALUES ('Ana Lúcia Reis', 'Teresina', 'PI');

SELECT * FROM v_clientes_pi WHERE nome LIKE 'Ana%';

7. Para que servem as views

CREATE VIEW v_equipe AS
SELECT id, nome, cargo
FROM funcionarios;

SELECT * FROM v_equipe;

A lista da equipe para o mural da loja, sem o salário de ninguém. Quem usar a v_equipe simplesmente não enxerga a coluna salario: pedir por ela dá no such column: salario. Num banco com servidor (MySQL, PostgreSQL, SQL Server), dá para ir além: permitir que um usuário leia a view, mas não a tabela, e aí a view vira uma proteção de verdade (aula Usuários e Permissões). No SQLite, que não tem usuários, ela é uma organização: quem abre o arquivo continua podendo ler a tabela.

8. View × WITH × tabela copiada

Há três jeitos de dar um nome a uma consulta. Todos eles produzem o mesmo resultado aqui, mas vivem por tempos diferentes:

-- 1. view: guardada no banco, roda a consulta a cada uso
CREATE VIEW v_pi AS SELECT nome FROM clientes WHERE estado = 'PI';
SELECT COUNT(*) AS pela_view FROM v_pi;

-- 2. WITH (CTE): vale só para este SELECT
WITH pi AS (SELECT nome FROM clientes WHERE estado = 'PI')
SELECT COUNT(*) AS pelo_with FROM pi;

-- 3. tabela copiada: guarda uma FOTO das linhas de agora
CREATE TABLE copia_pi AS SELECT nome FROM clientes WHERE estado = 'PI';
SELECT COUNT(*) AS pela_copia FROM copia_pi;

Os três deram 14. A diferença aparece quando os dados mudam: um cliente novo do Piauí aparece na view (seção 2) e num WITH rodado de novo, mas não na copia_pi, que é uma tabela de verdade com as 14 linhas copiadas naquele instante.

Quando dá errado

CREATE VIEW v_clientes_pi AS
SELECT id, nome FROM clientes WHERE estado = 'PI';

CREATE VIEW v_clientes_pi AS
SELECT id, nome, email FROM clientes WHERE estado = 'PI';

CREATE VIEW clientes AS
SELECT nome FROM clientes WHERE estado = 'PI';

CREATE VIEW v_clientes_pi AS
SELECT id, nome FROM clientes WHERE estado = 'PI';

DROP TABLE v_clientes_pi;

DROP VIEW v_clientes_pi;

CREATE VIEW v_vendas AS
SELECT nome FROM vendas;

SELECT * FROM v_vendas;

CREATE VIEW v_contatos (cliente, uf, correio) AS
SELECT nome, email
FROM clientes;

SELECT * FROM v_contatos;

CREATE VIEW v_contatos AS
SELECT nome, email FROM clientes;

ALTER TABLE clientes DROP COLUMN email;

-- PostgreSQL e MySQL
CREATE OR REPLACE VIEW v_clientes_pi AS
SELECT id, nome, cidade, email FROM clientes WHERE estado = 'PI';

-- SQL Server
CREATE OR ALTER VIEW v_clientes_pi AS
SELECT id, nome, cidade, email FROM clientes WHERE estado = 'PI';

Referência rápida

Exercícios

Missão final: a view dos atendimentos

-- crie a view aqui:


SELECT * FROM v_atendimentos;

-- crie a view aqui:
CREATE VIEW v_atendimentos AS
SELECT f.nome AS vendedor, COUNT(*) AS pedidos
FROM funcionarios AS f
JOIN pedidos AS p ON p.funcionario_id = f.id
GROUP BY f.id, f.nome;

SELECT * FROM v_atendimentos;

Os seis vendedores atenderam 15 pedidos cada. A gerente Marta e o estoquista Davi não atendem pedidos, por isso ficaram de fora (com LEFT JOIN eles apareceriam com 0). Agora, quando entrar um pedido novo, a contagem da view sobe sozinha.

Resumo

• Uma view é uma consulta SELECT guardada no banco com um nome: CREATE VIEW nome AS SELECT …;.
• Ela se usa como uma tabela, no FROM, com WHERE, ORDER BY, GROUP BY, JOIN e até dentro de outra view.
• A view não guarda linhas: roda a consulta a cada uso, então está sempre atualizada. Uma cópia que não muda se faz com CREATE TABLE … AS SELECT.
• As colunas da view levam os nomes do SELECT (use AS) ou de uma lista: CREATE VIEW v (a, b) AS ….
• DROP VIEW nome; apaga só a view. Para trocar a consulta no SQLite: DROP VIEW IF EXISTS + CREATE VIEW.
• No SQLite, a view é só de leitura: INSERT/UPDATE/DELETE dão cannot modify … because it is a view. Grave na tabela.
• O SQLite só confere a consulta da view quando ela é usada: teste a view logo depois de criar.