Datas e Horas no SQLite: strftime, date() e datetime()

O SQLite não tem um tipo de data de verdade

Isso pega de surpresa quem vem do Postgres ou do MySQL. O SQLite tem apenas cinco classes de armazenamento — NULL, INTEGER, REAL, TEXT e BLOB. Não existe DATE, nem DATETIME, nem TIMESTAMP. Você pode até escrever created_at DATETIME no seu CREATE TABLE, e o SQLite aceita numa boa, mas o valor vai ser guardado como texto puro ou número.

O que o SQLite oferece é um conjunto de funções de data e hora que entendem três formatos convencionais:

• Texto no formato ISO 8601 — '2026-04-23', '2026-04-23 10:15:00', '2026-04-23T10:15:00.123Z'.
• Timestamp Unix — segundos desde 1970-01-01 UTC, armazenado como inteiro.
• Dia juliano (Julian day) — dias fracionários desde 4714 a.C., armazenado como real.

Escolha um e mantenha o padrão. O texto ISO 8601 é o mais legível e ordena corretamente como string, e é justamente por isso que ele é o formato padrão.

SELECT date('now'),
       datetime('now'),
       strftime('%s', 'now'),
       julianday('now');

Quatro formas de pedir o "agora" — data em texto, data e hora em texto, segundos Unix e dia Juliano. Todas representam o mesmo instante.

As cinco funções de data e hora no SQLite

O SQLite traz cinco funções nativas que cobrem praticamente tudo o que você vai precisar no dia a dia:

• date(time, ...) — devolve YYYY-MM-DD.
• time(time, ...) — devolve HH:MM:SS.
• datetime(time, ...) — devolve YYYY-MM-DD HH:MM:SS.
• julianday(time, ...) — devolve um número real (ótimo para calcular diferenças entre datas).
• strftime(format, time, ...) — devolve uma string com o formato que você quiser.

Todas recebem um valor de tempo como primeiro argumento e, depois disso, quantos modificadores você quiser passar.

SELECT date('2026-04-23 10:15:00')          AS apenas_data,
       time('2026-04-23 10:15:00')          AS apenas_hora,
       datetime(1745402100, 'unixepoch')    AS de_unix,
       julianday('2026-04-23')              AS juliano;

Repare no 'unixepoch' — é assim que você avisa às funções de data que o número inteiro de entrada é um timestamp Unix, e não um dia juliano. Sem ele, o SQLite assume que o número é juliano.

strftime: formatos de data personalizados no SQLite

A função strftime é o coringa para formatar datas. Os mesmos códigos % que você já conhece do C ou do Python:

SELECT strftime('%Y-%m-%d',           'now') AS data_iso,
       strftime('%d/%m/%Y',           'now') AS europeu,
       strftime('%H:%M',              'now') AS horas_minutos,
       strftime('%Y-%m-%dT%H:%M:%fZ', 'now') AS iso_com_ms,
       strftime('%w',                 'now') AS dia_da_semana,
       strftime('%j',                 'now') AS dia_do_ano;

Os códigos que você vai usar com mais frequência:

• %Y — ano com quatro dígitos.
• %m — mês (01-12).
• %d — dia do mês (01-31).
• %H, %M, %S — horas, minutos, segundos.
• %w — dia da semana (0=domingo).
• %j — dia do ano (001-366).
• %s — timestamp Unix.
• %f — segundos fracionários (SS.SSS).

O strftime também é como você extrai partes de uma data — não existe uma função EXTRACT ou YEAR() separada no SQLite. Você simplesmente formata até a parte que quer e converte para número, se precisar:

SELECT strftime('%Y', '2026-04-23') AS year_text,
       CAST(strftime('%Y', '2026-04-23') AS INTEGER) AS year_num,
       CAST(strftime('%m', '2026-04-23') AS INTEGER) AS month_num;

strftime sempre devolve texto, então embrulhe a chamada em CAST(... AS INTEGER) quando precisar fazer contas ou comparações numéricas.

Modificadores: aritmética de datas sem operadores

Esse é o recurso que torna o trabalho com datas no SQLite realmente agradável. Depois do argumento de tempo, você pode passar quantas strings de modificador quiser, e elas são aplicadas na ordem em que aparecem:

SELECT date('2026-04-23', '+7 days')              AS uma_semana_depois,
       date('2026-04-23', '-1 month')             AS um_mes_antes,
       datetime('now', '+2 hours', '+30 minutes') AS em_duas_e_meia,
       date('now', 'start of month')              AS primeiro_do_mes,
       date('now', 'start of month', '+1 month', '-1 day') AS ultimo_do_mes,
       date('now', 'weekday 0')                   AS proximo_domingo;

Os modificadores que você vai usar o tempo todo:

• '+N days', '-N days', e o mesmo para hours, minutes, seconds, months, years.
• 'start of day', 'start of month', 'start of year' — trunca a data até aquele ponto.
• 'weekday N' — avança até o próximo dia da semana indicado (0=domingo).
• 'localtime' e 'utc' — convertem entre fusos horários.

Aquele truque do "último dia do mês" — start of month, mais um mês, menos um dia — vale a pena decorar. O SQLite não tem função LAST_DAY, mas encadeando modificadores você chega no mesmo resultado.

UTC vs. horário local no SQLite

O 'now' sempre devolve em UTC. Se você quer o horário local (tipo converter UTC para horário de Brasília), precisa pedir explicitamente:

SELECT datetime('now')              AS utc_now,
       datetime('now', 'localtime') AS local_now,
       datetime('2026-04-23 10:00:00', 'utc') AS treated_as_local_then_utc;

O modificador 'localtime' pega um valor em UTC e converte para o fuso do sistema. Já o 'utc' faz o caminho inverso: assume que a entrada está no horário local e converte para UTC.

A regra de ouro: armazene tudo em UTC e só converta para o horário local na hora de exibir. Misturar fusos no banco gera bugs chatos, daqueles que só aparecem duas vezes por ano, quando o horário de verão entra ou sai.

Comparando datas e filtrando intervalos no SQLite

Se você guardar as datas como texto no formato ISO 8601, comparações e BETWEEN funcionam de cara — a ordem lexicográfica do ISO 8601 é a mesma da ordem cronológica. É justamente por isso que ele é o formato padrão.

CREATE TABLE orders (
    id         INTEGER PRIMARY KEY,
    customer   TEXT,
    placed_at  TEXT NOT NULL  -- ISO 8601
);

INSERT INTO orders (customer, placed_at) VALUES
    ('Ada',   '2026-04-01 09:30:00'),
    ('Boris', '2026-04-15 14:00:00'),
    ('Carla', '2026-04-23 11:45:00'),
    ('Dmitri','2026-05-02 08:15:00');

SELECT customer, placed_at
FROM orders
WHERE placed_at >= '2026-04-01'
  AND placed_at <  '2026-05-01'
ORDER BY placed_at;

O intervalo semiaberto (>= start, < end) é um hábito que vale a pena adotar — ele elimina de vez aquela dúvida do tipo "será que a meia-noite do dia 30 entrou ou não?".

Para pegar "os últimos 7 dias", deixe o próprio SQLite calcular o limite:

CREATE TABLE orders (
    id         INTEGER PRIMARY KEY,
    customer   TEXT,
    placed_at  TEXT NOT NULL
);

INSERT INTO orders (customer, placed_at) VALUES
    ('Ada',   datetime('now', '-2 days')),
    ('Boris', datetime('now', '-10 days')),
    ('Carla', datetime('now', '-1 day')),
    ('Dmitri',datetime('now', '-30 days'));

SELECT customer, placed_at
FROM orders
WHERE placed_at >= datetime('now', '-7 days')
ORDER BY placed_at DESC;

Diferença entre datas no SQLite

O SQLite não tem uma função DATEDIFF como outros bancos. Mas não se preocupe: dois padrões resolvem praticamente todos os casos:

SELECT julianday('2026-04-23') - julianday('2026-04-01')           AS days_between,
       (julianday('2026-04-23 18:00') - julianday('2026-04-23 09:00')) * 24 AS hours_between,
       strftime('%s', '2026-04-23 18:00') - strftime('%s', '2026-04-23 09:00') AS seconds_between;

As diferenças retornadas por julianday() vêm em dias (com precisão fracionária). Então, se você multiplicar por 24, tem horas; por 1440, tem minutos. Já as diferenças com strftime('%s', ...) vêm em segundos — bem prático quando o que você quer é um inteiro.

Para contar apenas dias inteiros, use CAST(... AS INTEGER), que descarta a parte fracionária:

CREATE TABLE orders (
    id         INTEGER PRIMARY KEY,
    customer   TEXT,
    placed_at  TEXT NOT NULL
);

INSERT INTO orders (customer, placed_at) VALUES
    ('Ada',   datetime('now', '-2 days')),
    ('Boris', datetime('now', '-10 days')),
    ('Carla', datetime('now', '-1 day')),
    ('Dmitri',datetime('now', '-30 days'));

SELECT customer,
       CAST(julianday('now') - julianday(placed_at) AS INTEGER) AS days_ago
FROM orders
ORDER BY days_ago;

Como armazenar datas no SQLite: escolha um formato e mantenha

Você tem três opções razoáveis, na ordem em que deveria escolher:

1. Texto ISO 8601 (TEXT). É legível em dumps, ordena corretamente e funciona bem com todas as funções de data. É a escolha padrão.
2. Segundos Unix (INTEGER). Compacto, comparações rápidas, sem ambiguidade de fuso horário. Vale a pena quando você tem milhões de linhas. Para ler de volta, vai precisar de datetime(col, 'unixepoch').
3. Dia juliano (REAL). Raramente compensa, a não ser que você faça muita aritmética de datas e queira precisão de subsegundos numa única coluna.

O que você não deve fazer é misturar formatos na mesma coluna. As funções de data aceitam qualquer um sem reclamar, mas índices, ordenações e comparações vão devolver resultados sem sentido.

-- Valores padrão que são preenchidos automaticamente na inserção:
CREATE TABLE events (
    id          INTEGER PRIMARY KEY,
    name        TEXT NOT NULL,
    happened_at TEXT NOT NULL DEFAULT (datetime('now'))
);

INSERT INTO events (name) VALUES ('cadastro'), ('login');

SELECT name, happened_at FROM events;

DEFAULT (datetime('now')) é o equivalente no SQLite ao DEFAULT CURRENT_TIMESTAMP — ele carimba cada linha nova com o horário UTC atual, sem precisar de nenhuma linha de código na aplicação.

Agrupando por período de tempo

A função strftime brilha quando você quer agrupar registros por mês, semana ou hora:

CREATE TABLE orders (
    id         INTEGER PRIMARY KEY,
    customer   TEXT,
    placed_at  TEXT NOT NULL
);

INSERT INTO orders (customer, placed_at) VALUES
    ('Ada',   '2026-04-01 09:30:00'),
    ('Boris', '2026-04-15 14:00:00'),
    ('Carla', '2026-04-23 11:45:00'),
    ('Dmitri','2026-05-02 08:15:00'),
    ('Ezra',  '2026-05-20 17:00:00');

SELECT strftime('%Y-%m', placed_at) AS month,
       COUNT(*)                     AS order_count
FROM orders
GROUP BY month
ORDER BY month;

A mesma ideia vale para "pedidos por hora do dia", "cadastros por dia da semana" ou "eventos por minuto" — escolha uma string de formato que capture apenas a granularidade desejada, agrupe por ela e agregue.

A seguir: funções de agregação

Por falar em agrupar, esse COUNT(*) é a mais simples das funções de agregação do SQLite. No próximo tópico vamos ver o conjunto completo: SUM, AVG, MIN, MAX e como elas condensam várias linhas em um único valor de resumo.