SQL CREATE TABLE

Até aqui você só usou tabelas que já existiam: clientes, produtos, pedidos… Agora a Ana quer guardar uma coisa nova: as avaliações que os clientes deixam nos produtos da Loja Aurora ("chegou rápido, nota 5"). Não existe tabela para isso, então ela vai criar uma. O comando é o CREATE TABLE ("crie a tabela"). Nesta aula você vai criar tabelas, conferir o que foi criado e conhecer os erros mais comuns, inclusive um que não dá erro nenhum e estraga a tabela em silêncio.

Lembre-se: no editor do guia, cada Rodar parte do banco limpo da Loja Aurora. A tabela que você criar existe só durante aquela execução; ao rodar de novo, ela some e o banco volta ao original. Por isso os exemplos desta aula sempre trazem o CREATE TABLE junto com o que vem depois (o INSERT, o SELECT), na mesma caixa.

A ideia: o cabeçalho da planilha

Pense numa planilha nova, em branco. Antes de anotar a primeira avaliação, a Ana escreve na primeira linha os títulos das colunas: "número", "produto", "nota", "comentário". Ela ainda não tem nenhuma avaliação, mas já decidiu o que vai anotar de cada uma.

| id | produto_id | nota | comentario |
|----|------------|------|------------|
|    |            |      |            |   ← ainda vazia

Num banco de dados é igual, com uma diferença importante: o banco é mais exigente que a planilha. Cada coluna ganha um nome e um tipo (número inteiro, texto, número com casas decimais…), e pode ganhar regras ("esta coluna não pode ficar vazia"). Tudo isso se escreve uma vez só, no CREATE TABLE. Depois, cada INSERT só preenche as linhas.

1. A primeira tabela

Aqui está a tabela de avaliações. O SELECT logo depois serve para você ver a tabela que acabou de nascer:

CREATE TABLE avaliacoes (
    id         INTEGER,
    produto_id INTEGER,
    nota       INTEGER,
    comentario TEXT
);

SELECT * FROM avaliacoes;

O resultado mostra o "CREATE TABLE: ok" e uma tabela com as quatro colunas e nenhuma linha. É a planilha com o cabeçalho escrito e nada embaixo.

CREATE TABLE

"Crie a tabela." As duas palavras-chave que abrem o comando.

avaliacoes

O nome da tabela nova. Sem acento, sem espaço, em minúsculas (as regras estão na seção 5).

( … )

Os parênteses guardam a lista de colunas. Abre depois do nome, fecha depois da última coluna.

id INTEGER

Uma coluna: primeiro o nome (id), depois o tipo (INTEGER, "inteiro": números sem vírgula, como 1, 2, 3).

,

A vírgula separa uma coluna da outra. Vai entre as colunas: depois da última não tem vírgula.

comentario TEXT

A última coluna, do tipo TEXT ("texto"): qualquer frase.

;

O ponto e vírgula termina o comando, como em qualquer SQL.

As colunas desta tabela seguem o mesmo jeito das tabelas da Loja Aurora: id é o número da avaliação, produto_id diz qual produto foi avaliado (o mesmo número do id em produtos), nota vai de 1 a 5 e comentario é o texto do cliente.

2. Os tipos mais usados

Cada coluna tem um tipo. Os tipos têm duas aulas só para eles (Tipos de Dados e Os Tipos no SQLite); por enquanto, quatro bastam para quase tudo:

Uma tabela para os cupons de desconto da loja usa três deles: o código do cupom é texto, o desconto tem casas decimais e a validade é uma data.

CREATE TABLE cupons (
    codigo   TEXT,
    desconto REAL,
    validade TEXT
);

INSERT INTO cupons (codigo, desconto, validade)
VALUES ('AURORA10', 10, '2026-12-31');

SELECT * FROM cupons;

Repare no resultado: a Ana escreveu 10, mas o SELECT mostra 10.0. A coluna é REAL, então o SQLite guardou o número como número com casas decimais. É o tipo da coluna trabalhando. Datas são guardadas como texto no SQLite ('2026-12-31', entre aspas simples); a aula Datas e Horas explica por quê.

CREATE TABLE cupons (
    codigo   TEXT,
    desconto REAL,
    validade TEXT,
);

CREATE TABLE cupons (
    codigo   TEXT,
    desconto REAL,
    validade TEXT
);

3. As primeiras linhas

Tabela criada, agora é só usar o INSERT INTO que você já conhece (aula INSERT INTO). Duas avaliações do produto 3, o Lápis Grafite HB:

CREATE TABLE avaliacoes (
    id         INTEGER,
    produto_id INTEGER,
    nota       INTEGER,
    comentario TEXT
);

INSERT INTO avaliacoes (id, produto_id, nota, comentario)
VALUES (1, 3, 5, 'Chegou rápido');

INSERT INTO avaliacoes (id, produto_id, nota, comentario)
VALUES (2, 3, 4, 'Bom, mas a caixa veio amassada');

SELECT * FROM avaliacoes;

O quadro mostra os três passos, na ordem: "CREATE TABLE: ok", depois "1 linha afetada" duas vezes (um para cada INSERT) e, por fim, a tabela com as duas avaliações.

E se o cliente não escreveu comentário? Basta deixar a coluna de fora do INSERT. Como a tabela não tem nenhuma regra dizendo o contrário, a coluna esquecida fica vazia, com NULL (aula O Valor NULL):

CREATE TABLE avaliacoes (
    id         INTEGER,
    produto_id INTEGER,
    nota       INTEGER,
    comentario TEXT
);

INSERT INTO avaliacoes (id, produto_id, nota)
VALUES (3, 1, 2);

SELECT * FROM avaliacoes;

Às vezes é isso que você quer; às vezes não (uma avaliação sem nota não serve para nada). Para proibir o vazio, ou para pôr um valor automático no lugar dele, existem as restrições que você vai ver nas próximas aulas: NOT NULL e DEFAULT.

4. Conferir o que foi criado

Criou a tabela e quer ver como ela ficou? Há três jeitos, e cada um serve num lugar.

No editor: a tabela sqlite_schema

Todo banco SQLite tem uma tabela especial, a sqlite_schema ("o esquema do SQLite"), com uma linha para cada tabela do banco e o CREATE TABLE que a criou. Ela se consulta com um SELECT comum:

CREATE TABLE avaliacoes (id INTEGER, produto_id INTEGER, nota INTEGER, comentario TEXT);

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

sqlite_schema

A tabela onde o SQLite anota o próprio banco: o que existe nele.

name

O nome de cada tabela. A sua avaliacoes aparece por último, ao lado das sete da Loja Aurora.

sql

O CREATE TABLE que criou aquela tabela, guardado do jeito que foi escrito. É a melhor forma de descobrir quais colunas e regras uma tabela tem.

WHERE type = 'table'

Só as tabelas. A sqlite_schema também guarda índices e views (aulas Índices e Views).

No editor: PRAGMA table_info

O PRAGMA table_info(tabela) mostra as colunas uma por linha, já separadas em partes. Os PRAGMAs são comandos próprios do SQLite (aula PRAGMAs Úteis):

CREATE TABLE avaliacoes (id INTEGER, produto_id INTEGER, nota INTEGER, comentario TEXT);

PRAGMA table_info(avaliacoes);

Rode o mesmo PRAGMA numa tabela da loja e você já vê as regras que ela tem: em clientes, o nome tem notnull 1 e o vip tem valor padrão 0.

PRAGMA table_info(clientes);

No terminal: .tables e .schema

No programa sqlite3 (aula O Terminal do SQLite), os comandos de ponto .tables e .schema fazem o mesmo trabalho com menos digitação. Eles não existem no editor, só no terminal (aula Comandos de Ponto). A Ana abriu o banco da loja, criou a tabela e conferiu:

$ sqlite3 loja.db
SQLite version 3.50.4 2025-07-30 19:33:53
Enter ".help" for usage hints.
sqlite> CREATE TABLE avaliacoes (id INTEGER, produto_id INTEGER, nota INTEGER, comentario TEXT);
sqlite> .tables
avaliacoes    clientes      funcionarios  pedidos
categorias    fornecedores  itens_pedido  produtos
sqlite> .schema avaliacoes
CREATE TABLE avaliacoes (id INTEGER, produto_id INTEGER, nota INTEGER, comentario TEXT);
sqlite> .quit

Repare que o CREATE TABLE que deu certo não imprime nada: no terminal, silêncio quer dizer "deu certo". A tabela nova já aparece no .tables, em ordem alfabética, e o .schema devolve o comando que a criou. Diferente do editor, aqui a tabela fica gravada no arquivo loja.db: na próxima vez que a Ana abrir o banco, ela continua lá.

5. Como dar nome a tabelas e colunas

O SQLite aceita muita coisa como nome, mas nem tudo que ele aceita é uma boa ideia. As regras que o guia (e a maioria dos projetos) segue:

E maiúscula ou minúscula faz diferença? Para o SQLite, não: Avaliacoes e avaliacoes são o mesmo nome. Tanto que, se a Ana criar a Avaliacoes e depois tentar criar a avaliacoes, a segunda dá erro:

CREATE TABLE Avaliacoes (id INTEGER);
CREATE TABLE avaliacoes (id INTEGER);

Palavras reservadas

Algumas palavras são do próprio SQL: SELECT, FROM, WHERE, ORDER, TABLE, GROUP… São as palavras reservadas. Uma tabela de "ordens de serviço" chamada order parece uma boa ideia, mas o SQLite lê order como o começo de um ORDER BY e se perde:

CREATE TABLE order (id INTEGER);

Dá para forçar com aspas duplas (CREATE TABLE "order" (…)): no SQL padrão, aspas duplas marcam um nome, e então qualquer palavra vale. Só que aí você vai ter de escrever "order" com aspas em todas as consultas, para sempre. Escolha outro nome (ordens, ordens_servico) e economize a dor de cabeça. A lista completa está em Palavras-chave SQL.

6. IF NOT EXISTS: criar só se não existir

A Loja Aurora já tem uma tabela fornecedores. O que acontece se alguém tentar criá-la de novo?

CREATE TABLE fornecedores (id INTEGER, nome TEXT);

"A tabela fornecedores já existe." O SQLite não deixa duas tabelas com o mesmo nome no mesmo banco, e para tudo ali. Isso incomoda quando você tem um roteiro (um arquivo .sql com vários comandos, como o que monta a Loja Aurora) que precisa rodar mais de uma vez: na segunda vez, o primeiro CREATE TABLE já derruba o roteiro inteiro.

Para isso existe o IF NOT EXISTS ("se não existir"):

CREATE TABLE IF NOT EXISTS fornecedores (id INTEGER, nome TEXT);

SELECT count(*) FROM fornecedores;

CREATE TABLE

O comando de sempre.

IF NOT EXISTS

"Se não existir." Vem entre TABLE e o nome. Se a tabela ainda não existe, ela é criada normalmente. Se já existe, o comando não faz nada e não dá erro.

fornecedores (…)

O nome e as colunas, como sempre.

O editor mostrou "CREATE TABLE: ok" e o count(*) continua 6: os seis fornecedores estão lá, intactos. O comando simplesmente não fez nada.

CREATE TABLE IF NOT EXISTS clientes (codigo INTEGER, apelido TEXT);

PRAGMA table_info(clientes);

No terminal é igual: sem IF NOT EXISTS, o erro; com ele, silêncio. Aqui a mensagem vem com o prefixo Parse error: e uma setinha embaixo do ponto do problema:

$ sqlite3 loja.db
SQLite version 3.50.4 2025-07-30 19:33:53
Enter ".help" for usage hints.
sqlite> CREATE TABLE avaliacoes (id INTEGER, produto_id INTEGER, nota INTEGER, comentario TEXT);
sqlite> CREATE TABLE avaliacoes (id INTEGER);
Parse error: table avaliacoes already exists
  CREATE TABLE avaliacoes (id INTEGER);
               ^--- error here
sqlite> CREATE TABLE IF NOT EXISTS avaliacoes (id INTEGER);
sqlite> .quit

CREATE TABLE avaliacoes IF NOT EXISTS (
    id         INTEGER,
    produto_id INTEGER,
    nota       INTEGER,
    comentario TEXT
);

INSERT INTO avaliacoes (id, produto_id, nota, comentario)
VALUES (1, 10, 5, 'Carrega o celular bem rápido');

CREATE TABLE IF NOT EXISTS avaliacoes (
    id         INTEGER,
    produto_id INTEGER,
    nota       INTEGER,
    comentario TEXT
);

INSERT INTO avaliacoes (id, produto_id, nota, comentario)
VALUES (1, 10, 5, 'Carrega o celular bem rápido');

7. Uma tabela de verdade: tipos e regras

As tabelas que você criou até aqui só têm nome e tipo em cada coluna. As tabelas da Loja Aurora têm mais coisa. Veja como foi criada a tabela produtos:

SELECT sql FROM sqlite_schema WHERE name = 'produtos';

Depois do tipo, várias colunas têm restrições (em inglês, constraints): regras que o banco confere a cada INSERT e UPDATE, e que recusam o dado errado com uma mensagem de erro. Cada uma tem a sua aula, logo a seguir:

Uma versão mais caprichada da tabela de avaliações, com essas regras, ficaria assim. Você vai entender cada pedaço nas próximas aulas; por enquanto, repare que a estrutura é a mesma: nome da coluna, tipo, e as regras no fim da linha.

CREATE TABLE avaliacoes (
    id         INTEGER PRIMARY KEY,
    produto_id INTEGER NOT NULL REFERENCES produtos(id),
    nota       INTEGER NOT NULL,
    comentario TEXT,
    criada_em  TEXT NOT NULL DEFAULT CURRENT_DATE
);

PRAGMA table_info(avaliacoes);

Formas diferentes de criar uma tabela

Quando dá errado

Num CREATE TABLE, quase todo erro é de digitação: uma vírgula, um parêntese, uma palavra trocada. Os quadros abaixo rodam o SQL errado de verdade e mostram a mensagem do SQLite.

CREATE TABLE avaliacoes (
    id         INTEGER,
    nota       INTEGER,
    comentario TEXT,
);

$ sqlite3 loja.db
SQLite version 3.50.4 2025-07-30 19:33:53
Enter ".help" for usage hints.
sqlite> CREATE TABLE teste (id INTEGER,);
Parse error: near ")": syntax error
  CREATE TABLE teste (id INTEGER,);
                   error here ---^
sqlite> .quit

CREATE TABLE avaliacoes (
    id         INTEGER,
    produto_id INTEGER
    nota       INTEGER
);

PRAGMA table_info(avaliacoes);

CREATE TABLE avaliacoes (
    id         INTEGER,
    produto_id INTEGER
    nota       INTEGER
);

INSERT INTO avaliacoes (id, produto_id, nota) VALUES (1, 3, 5);

CREATE TABLE clientes (id INTEGER, nome TEXT);

CREATE TABLE avaliacoes (
    id         INTEGER,
    nota       INTEGER,
    comentario TEXT,
    nota       TEXT
);

CREATE TABLE minhas avaliacoes (id INTEGER);

CREATE TABLE 2026_vendas (id INTEGER);

CREATE TABLE avaliacoes (
    id   INTEGER,
    nota INTEGER

$ sqlite3 loja.db
SQLite version 3.50.4 2025-07-30 19:33:53
Enter ".help" for usage hints.
sqlite> CREATE TABLE teste (id INTEGER
(x1...> );                         « fechou o parêntese: agora o comando roda
sqlite> .quit

CREATE TABLE avaliacoes (id INTEGER, nota INTEGER);

INSERT INTO avaliacoes VALUES (1, 5, 'Chegou rápido');

IF OBJECT_ID(N'avaliacoes', N'U') IS NULL
    CREATE TABLE avaliacoes (id INT, nota INT);

Referência rápida

Exercícios

Missão final: a tabela de avaliações

-- escreva aqui o CREATE TABLE avaliacoes

INSERT INTO avaliacoes (id, produto_id, nota, comentario)
VALUES (1, 1, 5, 'Folhas grossas, a caneta não atravessa');

INSERT INTO avaliacoes (id, produto_id, nota, comentario)
VALUES (2, 5, 3, 'Bonita, mas a alça é fina');

SELECT * FROM avaliacoes;

CREATE TABLE avaliacoes (
    id         INTEGER,
    produto_id INTEGER,
    nota       INTEGER,
    comentario TEXT
);

INSERT INTO avaliacoes (id, produto_id, nota, comentario)
VALUES (1, 1, 5, 'Folhas grossas, a caneta não atravessa');

INSERT INTO avaliacoes (id, produto_id, nota, comentario)
VALUES (2, 5, 3, 'Bonita, mas a alça é fina');

SELECT * FROM avaliacoes;

Se a sua tabela funcionou, experimente juntar as avaliações com os nomes dos produtos (produto 1 é o Caderno Pautado 96 folhas, o 5 é a Mochila Escolar Azul): isso é um JOIN, e você já sabe fazer (aula INNER JOIN).

Resumo

• CREATE TABLE nome (coluna TIPO, …); cria uma tabela nova, vazia. As colunas vão entre parênteses, separadas por vírgula, cada uma com nome e tipo.
• Os tipos do dia a dia: INTEGER (inteiro), REAL (com decimais) e TEXT (texto, e também datas no formato AAAA-MM-DD).
• Confira o que criou: sqlite_schema e PRAGMA table_info no editor; .tables e .schema no terminal.
• Nomes em minúsculas, sem espaço nem acento, começando por letra, e nada de palavra reservada como order.
• IF NOT EXISTS evita o erro table X already exists, mas não compara as colunas: se a tabela existe, ele simplesmente não faz nada.
• Vírgula sobrando dá near ")": syntax error; vírgula faltando não dá erro e junta duas colunas numa. Depois de criar, confira sempre.