Funções Numéricas no SQLite: ROUND, ABS, CEIL e FLOOR

O SQLite tem mais matemática do que você imagina

O SQLite tem fama de ser minimalista, mas vem com um conjunto completo de funções numéricas: arredondamento, valor absoluto, teto e piso, potências, raízes, logaritmos, trigonometria e números aleatórios. A maior parte dessas funções matemáticas foi adicionada no SQLite 3.35 (2021), então qualquer instalação razoavelmente atual — seja a que vem embutida no Python, no Node, na antiga WebSQL do navegador ou na CLI oficial — já tem tudo isso pronto pra usar.

Antes de mergulhar nos detalhes, dá uma olhada nesse aperitivo:

SELECT
    ROUND(3.14159, 2)   AS rounded,
    ABS(-42)            AS absolute,
    CEIL(2.1)           AS ceiling,
    FLOOR(2.9)          AS floor_val,
    POWER(2, 10)        AS two_to_ten,
    SQRT(144)           AS root;

Seis funções, uma linha de resultado. O restante desta página explica para que serve cada família e quais pegadinhas vale a pena conhecer.

ROUND: a função que você mais vai usar

ROUND(valor, casas) arredonda para um determinado número de casas decimais. O segundo argumento é opcional — se você omitir, o valor é arredondado para o inteiro mais próximo (mas ainda retornado como ponto flutuante):

SELECT
    ROUND(3.14159)       AS sem_casas,
    ROUND(3.14159, 2)    AS duas_casas,
    ROUND(3.14159, 4)    AS quatro_casas,
    ROUND(2.5)           AS meio_para_cima,
    ROUND(-2.5)          AS meio_para_baixo;

Alguns detalhes que vale notar:

• ROUND(3.14159) devolve 3.0, e não 3. Se você quer um inteiro de fato, use CAST(ROUND(x) AS INTEGER) — ou simplesmente CAST(x AS INTEGER) para truncar.
• O SQLite usa "round half away from zero" (arredondamento para longe do zero): 2.5 vira 3 e -2.5 vira -3. Alguns bancos usam o arredondamento bancário (round half to even); o SQLite não.
• O argumento digits aceita valores negativos: ROUND(1234.5, -2) arredonda para a centena mais próxima, retornando 1200.

Na prática, o uso mais comum no dia a dia é ROUND(price, 2) para exibir valores monetários.

ROUND vs CAST: não são a mesma coisa

É comum recorrer a CAST(x AS INTEGER) achando que está arredondando — e aí vem a pegadinha:

SELECT
    CAST(2.9 AS INTEGER)   AS cast_truncates,
    ROUND(2.9)             AS round_rounds,
    CAST(-2.9 AS INTEGER)  AS cast_negative,
    ROUND(-2.9)            AS round_negative;

CAST trunca em direção ao zero — simplesmente joga fora a parte fracionária. Já o ROUND arredonda para o inteiro mais próximo. No caso do 2.9, a diferença entre os dois é de uma unidade inteira. Escolha o que realmente faz o que você quer.

ABS, SIGN e o sinal de um número

A função ABS(x) devolve o valor absoluto. Já SIGN(x) retorna -1, 0 ou 1 conforme o sinal do número:

SELECT
    ABS(-17)    AS abs_neg,
    ABS(17)     AS abs_pos,
    ABS(0)      AS abs_zero,
    SIGN(-17)   AS sign_neg,
    SIGN(0)     AS sign_zero,
    SIGN(42.5)  AS sign_pos;

ABS é o burro de carga — ótima para responder "qual a distância entre esses dois valores". Já SIGN aparece menos, mas resolve bem quando você quer agrupar linhas por direção (débito vs crédito, ganho vs perda) sem precisar escrever um CASE explícito.

CEIL, FLOOR e TRUNC no SQLite

Essas funções devolvem valores inteiros (ou quase isso) sem arredondar para o mais próximo. CEIL sempre arredonda para cima, FLOOR sempre para baixo e TRUNC corta em direção ao zero:

SELECT
    CEIL(2.1)    AS ceil_pos,
    CEIL(-2.1)   AS ceil_neg,
    FLOOR(2.9)   AS floor_pos,
    FLOOR(-2.9)  AS floor_neg,
    TRUNC(2.9)   AS trunc_pos,
    TRUNC(-2.9)  AS trunc_neg;

Cuidado com os números negativos. FLOOR(-2.9) resulta em -3 (mais distante do zero), enquanto TRUNC(-2.9) dá -2 (em direção ao zero). Quando o assunto é negativo, FLOOR e TRUNC discordam — e escolher o errado é um clássico bug de off-by-one.

CEILING é um apelido para CEIL. Use a grafia que achar mais legível.

A divisão inteira no SQLite é a verdadeira pegadinha

Aqui não estamos falando de uma função, e sim do operador /. Mesmo assim, ele confunde mais os iniciantes do que qualquer função matemática de verdade:

SELECT
    5 / 2           AS int_div,
    5 / 2.0         AS real_div,
    5.0 / 2         AS also_real,
    CAST(5 AS REAL) / 2  AS explicit_cast;

Quando os dois lados da operação são inteiros, o SQLite faz divisão inteira e descarta a parte fracionária. Basta um dos lados ser REAL para que a expressão inteira passe a ser real. A solução é garantir que pelo menos um dos operandos seja float — ou escrevendo 2.0 no lugar de 2, ou usando CAST.

Esse problema aparece com força quando você referencia colunas: total_cents / 100 devolve um inteiro. Já total_cents / 100.0 devolve o valor em reais que você realmente queria.

MOD e o operador %

MOD(x, y) retorna o resto de x / y. O operador % faz exatamente a mesma coisa:

SELECT
    MOD(17, 5)   AS mod_func,
    17 % 5       AS mod_op,
    MOD(-17, 5)  AS mod_neg,
    MOD(17, 0)   AS mod_zero;

MOD(17, 5) e 17 % 5 retornam 2 nos dois casos. Já o módulo por zero devolve NULL no SQLite — ele não lança erro, o que destoa da maioria das linguagens. Se isso for relevante pra você, valide o divisor antes ou envolva a chamada num CASE WHEN y = 0 THEN ... END.

A função e o operador são intercambiáveis. Na prática, quase todo mundo usa % porque é mais curto.

POWER, SQRT, EXP e LOG no SQLite

Para potências e raízes:

SELECT
    POWER(2, 10)    AS two_to_the_ten,
    POW(2, 0.5)     AS sqrt_via_power,
    SQRT(2)         AS sqrt_two,
    EXP(1)          AS e,
    LOG(100)        AS log10_100,
    LN(EXP(1))      AS ln_of_e;

Algumas pegadinhas que costumam confundir:

• POW é apenas um apelido para POWER.
• No SQLite, LOG(x) é log na base 10. Já LN(x) é o logaritmo natural. Com dois argumentos, LOG(b, x) calcula o log na base b. (Isso é diferente de muitas linguagens, onde log significa logaritmo natural — aqui prevaleceu a convenção do SQL.)
• SQRT de um número negativo devolve NULL, não dispara erro.
• POWER(0, 0) retorna 1, por convenção.

Esses detalhes são úteis em juros compostos, normalização para decibéis, cálculo de distâncias — basicamente em qualquer cenário com matemática geométrica ou exponencial.

RANDOM e RANDOMBLOB

A função RANDOM() devolve um inteiro de 64 bits com sinal, podendo cair em qualquer ponto do intervalo:

SELECT
    RANDOM()                          AS raw_random,
    ABS(RANDOM()) % 100               AS zero_to_99,
    ABS(RANDOM()) % 100 + 1           AS one_to_100,
    ABS(RANDOM() / 9223372036854775807.0) AS unit_interval;

Para obter um número dentro de uma faixa específica, use ABS (já que RANDOM() retorna valores com sinal) junto com o operador %. Se quiser um número real entre 0 e 1, é só dividir pelo maior inteiro de 64 bits. O SQLite não tem uma função RAND() nativa que devolva valores entre 0 e 1 — você mesmo monta isso na mão.

Já o RANDOMBLOB(n) devolve n bytes de dados aleatórios, ótimo para gerar tokens de sessão ou massa de dados para testes. Combine com HEX() para ter uma string legível:

SELECT HEX(RANDOMBLOB(8)) AS token;

Cada chamada gera um valor novo. Não espere que RANDOM() devolva o mesmo número duas vezes na mesma linha — mesmo dentro de uma única expressão, cada invocação é independente.

Juntando tudo na prática

Um exemplo prático: calcular distâncias e arredondar preços em uma tabela de produtos.

CREATE TABLE products (id INTEGER, name TEXT, price_cents INTEGER, weight_g REAL);
INSERT INTO products VALUES
    (1, 'Caneca',     1299, 350.5),
    (2, 'Caderno',     850, 180.2),
    (3, 'Caneta',      199,  12.0);

SELECT
    name,
    ROUND(price_cents / 100.0, 2)  AS price_dollars,
    CEIL(weight_g / 100)           AS weight_buckets_100g,
    POWER(weight_g, 0.5)           AS sqrt_weight
FROM products;

O detalhe importante é o price_cents / 100.0 — aquele .0 força a divisão a virar real, e aí o ROUND formata com duas casas decimais. Sem ele, 1299 / 100 retornaria 12, não 12.99.

A seguir: data e hora

As funções numéricas resolvem a parte da matemática. Datas e horários pedem um conjunto próprio de ferramentas — o SQLite armazena esses valores como text, real ou integer, e oferece um conjunto enxuto, mas eficiente, de funções para fazer parsing, formatação e cálculos com eles. É justamente isso que vem na próxima parte.