SQL Tipos de Dados

Todo valor guardado num banco tem um tipo: é um número inteiro, um número com casas decimais, um texto, um arquivo… Esta página reúne, num lugar só, tudo o que você precisa consultar sobre tipos: como o SQLite guarda cada valor, o que ele faz com o nome de tipo que você escreve no CREATE TABLE, as tabelas rígidas (STRICT) e o nome de cada tipo no PostgreSQL, no MySQL e no SQL Server. As explicações passo a passo estão nas aulas Tipos de Dados e Os Tipos no SQLite.

As cinco classes de armazenamento do SQLite

No SQLite, o tipo pertence ao valor, e não à coluna. Cada valor guardado é de uma destas cinco classes (em inglês, storage classes):

SELECT typeof(NULL), typeof(42), typeof(4.9), typeof('Teresina'), typeof(x'CAFE');

Na Loja Aurora, cada coluna guarda sempre a mesma classe, porque os dados foram gravados com cuidado. A exceção são as colunas com campos vazios: a coluna email de clientes tem valores text e três null.

SELECT DISTINCT typeof(email) FROM clientes;

A afinidade: o tipo que você escreve no CREATE TABLE

O nome de tipo de uma coluna (INTEGER, VARCHAR(100), DATE…) não obriga nada no SQLite comum: ele vira uma afinidade, a classe que a coluna "prefere" e para a qual ela tenta converter os valores que chegam. A documentação do SQLite define a afinidade por estas regras, nesta ordem:

• Os números entre parênteses são ignorados: a documentação diz que o SQLite não impõe limite de tamanho por causa deles. VARCHAR(2) aceita 'Piauí'.
• DATE, DATETIME e BOOLEAN não criam nada especial: caem na regra 5, afinidade NUMERIC.
• A ordem das regras importa: FLOATING POINT tem INT no meio ("poINT") e vira INTEGER pela regra 1.

O que cada afinidade faz com o valor que chega

Uma tabela com os nomes de tipo dos outros bancos, para ver a afinidade agindo. O '19.90' virou o número 19.9; o 'sim' continuou texto na coluna BOOLEAN; a data continuou texto; e o VARCHAR(2) guardou as cinco letras de 'Piauí':

CREATE TABLE t (uf VARCHAR(2), preco DECIMAL(10,2), ativo BOOLEAN, dia DATE);
INSERT INTO t VALUES ('Piauí', '19.90', 'sim', '2026-10-14');
SELECT uf, typeof(uf), preco, typeof(preco), ativo, typeof(ativo), dia, typeof(dia)
FROM t;

Tabelas STRICT: os seis tipos aceitos

Com a palavra STRICT no fim do CREATE TABLE, o SQLite passa a recusar valores do tipo errado. Toda coluna precisa de tipo, e só valem estes nomes:

CREATE TABLE s (n INTEGER, t TEXT, r REAL, b BLOB, a ANY) STRICT;
INSERT INTO s VALUES ('5', 42, 42, x'CAFE', '5');
SELECT n, typeof(n), t, typeof(t), r, typeof(r), typeof(b), a, typeof(a)
FROM s;

O '5' virou o inteiro 5 na coluna INTEGER, mas continuou o texto '5' na coluna ANY. O 42 virou texto em t e real em r. As mensagens de quando o valor não serve estão em Erros comuns; a aula completa é Os Tipos no SQLite.

Datas, horas e booleanos no SQLite

O SQLite não tem classe própria para datas nem para verdadeiro/falso. A documentação dele recomenda estas formas:

A Loja Aurora usa a primeira forma: datas em texto ISO, que ordenam e comparam certo. As funções de data convertem entre as três formas:

SELECT julianday('2026-10-14'), unixepoch('2026-10-14'),
       date(2461327.5), date(1791936000, 'unixepoch');

SELECT TRUE, FALSE, typeof(TRUE);

Mais sobre datas em Datas e Horas e Funções de Data.

Funções para ver e trocar o tipo

SELECT CAST('42' AS INTEGER), CAST('4.9' AS REAL), CAST(42 AS TEXT),
       typeof(CAST(42 AS TEXT)), CAST('12abc' AS INTEGER),
       CAST('abc' AS INTEGER), CAST(3.99 AS INTEGER);

SELECT typeof('42'), typeof(42), typeof(1.0), typeof(7 / 2), typeof(7 / 2.0);

Os tipos da Loja Aurora

Todas as colunas do banco das aulas, com o tipo declarado no CREATE TABLE. A Loja Aurora usa só três nomes: INTEGER, REAL e TEXT.

SELECT m.name AS tabela, p.name AS coluna, p.type AS tipo
FROM sqlite_schema AS m, pragma_table_info(m.name) AS p
WHERE m.type = 'table'
ORDER BY m.name, p.cid;

SELECT name, type FROM pragma_table_info('produtos');

SELECT name, type FROM pragma_table_info('clientes');

Limites e surpresas dos números no SQLite

SELECT 9223372036854775807 + 1, 7 / 2, 7 / 2.0, 0.1 + 0.2 = 0.3, round(0.1 + 0.2, 2);

Mais em Funções Numéricas.

Os equivalentes nos outros bancos

PostgreSQL, MySQL e SQL Server são rígidos: o tipo é da coluna, e um valor que não serve dá erro. Cada um tem os seus nomes. A tabela abaixo põe lado a lado o nome mais usado para cada dado. Nomes, tamanhos e limites conferidos na documentação oficial de cada banco.

As faixas dos inteiros

Pegadinhas entre bancos

• REAL não é igual em todo lugar. No SQLite, tem 8 bytes. No PostgreSQL e no SQL Server, real tem 4 bytes (menos precisão). No MySQL, REAL é sinônimo de DOUBLE (a não ser com o modo REAL_AS_FLOAT).
• O n do SQL Server conta bytes. A documentação da Microsoft avisa: em varchar(n), n é o tamanho em bytes, não em letras. Com acentos em UTF-8, cabem menos letras.
• TIMESTAMP do MySQL acaba em 2038. Para datas fora de 1970–2038, use DATETIME.
• Dinheiro: nos bancos rígidos, use o decimal exato (DECIMAL/numeric). No SQLite, guarde em REAL e arredonde, ou guarde os centavos num INTEGER.

A mesma tabela de clientes, em cada dialeto, só para comparar (ilustrativo: só a versão do SQLite roda aqui):

CREATE TABLE clientes (
    id         integer PRIMARY KEY,
    nome       varchar(100) NOT NULL,
    estado     char(2),
    nascimento date,
    vip        boolean NOT NULL DEFAULT false
);

CREATE TABLE clientes (
    id         INT PRIMARY KEY,
    nome       VARCHAR(100) NOT NULL,
    estado     CHAR(2),
    nascimento DATE,
    vip        BOOLEAN NOT NULL DEFAULT FALSE
);

CREATE TABLE clientes (
    id         int PRIMARY KEY,
    nome       nvarchar(100) NOT NULL,
    estado     char(2),
    nascimento date,
    vip        bit NOT NULL DEFAULT 0
);

CREATE TABLE clientes_novos (
    id         INTEGER PRIMARY KEY,
    nome       TEXT NOT NULL,
    estado     TEXT,
    nascimento TEXT,
    vip        INTEGER NOT NULL DEFAULT 0
) STRICT;

Erros comuns

CREATE TABLE s (n INTEGER, t TEXT) STRICT;
INSERT INTO s VALUES ('abc', 'x');

CREATE TABLE s (n INTEGER, d DATE) STRICT;

Resumo

• O SQLite guarda cada valor numa de cinco classes: NULL, INTEGER, REAL, TEXT e BLOB. typeof() mostra qual.
• O nome de tipo da coluna vira uma afinidade (INTEGER, TEXT, BLOB, REAL ou NUMERIC), pelas cinco regras da documentação. Os números entre parênteses são ignorados.
• Tabelas STRICT recusam o tipo errado e só aceitam INT, INTEGER, REAL, TEXT, BLOB e ANY.
• Datas vão em TEXT ISO (ou dia juliano em REAL, ou tempo Unix em INTEGER); booleanos vão em INTEGER 0/1.
• PostgreSQL, MySQL e SQL Server são rígidos e têm nomes e limites próprios; cuidado com REAL, com o n em bytes do SQL Server e com o TIMESTAMP do MySQL.