Funciones numéricas en SQLite: ROUND, ABS, CEIL, FLOOR

SQLite tiene más matemáticas de las que crees

SQLite es famoso por ser minimalista, pero trae de fábrica un repertorio completo de funciones numéricas: redondeo, valor absoluto, techo y suelo, potencias, raíces, logaritmos, trigonometría y números aleatorios. La mayoría de estas funciones matemáticas se incorporaron en SQLite 3.35 (2021), así que cualquier instalación medianamente actual —la que viene con Python, con Node, la heredera de WebSQL en tu navegador o la CLI oficial— las tiene listas para usar.

Antes de entrar en materia, aquí va un adelanto rápido:

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 funciones, una sola fila de resultados. En el resto de la página repasamos para qué sirve cada familia y los detalles que conviene tener en cuenta.

ROUND: la que más vas a usar

ROUND(valor, decimales) redondea a una cantidad concreta de posiciones decimales. El segundo argumento es opcional: si lo omites, se redondea al entero más cercano (aunque el resultado sigue siendo un valor en coma flotante):

SELECT
    ROUND(3.14159)       AS sin_decimales,
    ROUND(3.14159, 2)    AS dos_decimales,
    ROUND(3.14159, 4)    AS cuatro_decimales,
    ROUND(2.5)           AS mitad_arriba,
    ROUND(-2.5)          AS mitad_abajo;

Algunas cosas a tener en cuenta:

• ROUND(3.14159) devuelve 3.0, no 3. Si quieres un entero, usa CAST(ROUND(x) AS INTEGER) o directamente CAST(x AS INTEGER) para truncar.
• SQLite usa el redondeo "half away from zero" (la mitad se aleja del cero): 2.5 se redondea a 3 y -2.5 a -3. Algunas bases de datos aplican el redondeo bancario (half to even); SQLite no.
• El argumento digits admite valores negativos: ROUND(1234.5, -2) redondea a la centena más cercana, devolviendo 1200.

En la práctica, lo que más vas a escribir es ROUND(price, 2) para mostrar importes monetarios.

ROUND vs CAST: no son lo mismo

Mucha gente recurre a CAST(x AS INTEGER) pensando que está redondeando, y se lleva una sorpresa:

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 hacia cero: simplemente descarta la parte decimal. ROUND, en cambio, redondea al entero más cercano. Para 2.9 la diferencia es de una unidad entera, así que elige el que realmente haga lo que necesitas.

ABS, SIGN y el signo de un número

ABS(x) devuelve el valor absoluto. SIGN(x) devuelve -1, 0 o 1 según el signo del 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 es el caballo de batalla: te saca de apuros cuando necesitas saber «qué tan lejos están estos dos valores». SIGN se usa menos, pero viene de perlas cuando quieres agrupar filas por dirección (débito vs crédito, ganancia vs pérdida) sin tener que escribir un CASE explícito.

CEIL, FLOOR y TRUNC en SQLite

Estas funciones devuelven valores «enteros» sin redondear al más cercano. CEIL siempre redondea hacia arriba, FLOOR siempre hacia abajo, y TRUNC siempre hacia el cero:

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 con los casos negativos. FLOOR(-2.9) da -3 (se aleja del cero), mientras que TRUNC(-2.9) da -2 (se acerca al cero). Cuando hay números negativos, FLOOR y TRUNC no coinciden, y elegir el equivocado es el típico bug off-by-one.

CEILING es un alias de CEIL. Usa la forma que te resulte más legible.

La división entera en SQLite: el verdadero tropiezo

Esto no es una función, sino el operador /, pero confunde a los principiantes más que cualquier otra función matemática de SQLite:

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;

Cuando ambos lados son enteros, SQLite hace división entera y trunca el resultado. En el momento en que uno de los lados es REAL, toda la expresión pasa a ser real. La solución es asegurarte de que al menos uno de los operandos sea un número con decimales: o bien escribes 2.0 en lugar de 2, o usas un cast.

Esto te muerde sobre todo con referencias a columnas: total_cents / 100 devuelve un entero. total_cents / 100.0 devuelve el importe en dólares que realmente querías.

MOD y el operador %

MOD(x, y) devuelve el resto de x / y. El operador % hace exactamente lo mismo:

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) y 17 % 5 devuelven ambos 2. El módulo por cero retorna NULL en SQLite — no lanza un error, lo cual resulta poco habitual comparado con la mayoría de los lenguajes. Si esto te importa, valida antes el divisor o envuelve la llamada en un CASE WHEN y = 0 THEN ... END.

La función y el operador son intercambiables. La mayoría tira de % porque es más corto.

POWER, SQRT, EXP y LOG en SQLite

Para potencias y raíces:

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;

Algunos detalles que suelen pillar a la gente:

• POW es un alias de POWER.
• LOG(x) en SQLite usa base 10. LN(x) es el logaritmo natural. LOG(b, x) con dos argumentos es logaritmo en base b. (Esto se diferencia de muchos lenguajes donde log es el logaritmo natural; aquí ganó la convención de SQL.)
• SQRT de un número negativo devuelve NULL, no lanza un error.
• POWER(0, 0) devuelve 1 por convención.

Vienen muy bien para calcular intereses compuestos, normalizar a decibelios, medir distancias... cualquier cosa que involucre matemáticas geométricas o exponenciales.

RANDOM y RANDOMBLOB en SQLite

RANDOM() devuelve un entero con signo de 64 bits, dentro de todo su rango:

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 obtener un número dentro de un rango, envuélvelo con ABS (ya que RANDOM() devuelve valores con signo) y usa %. Si lo que quieres es un número real entre 0 y 1, divide entre el entero máximo de 64 bits. SQLite no trae un RAND() integrado que devuelva valores entre 0 y 1: te toca armarlo a mano.

RANDOMBLOB(n) devuelve n bytes aleatorios, algo muy útil para generar tokens de sesión o datos de prueba. Combínalo con HEX() y obtienes una cadena imprimible:

SELECT HEX(RANDOMBLOB(8)) AS token;

Cada llamada genera un valor nuevo. No esperes que RANDOM() devuelva el mismo número dos veces en la misma fila: incluso dentro de una sola expresión, cada invocación es independiente.

Juntándolo todo

Un pequeño ejemplo práctico: calcular distancias y redondear precios en una tabla de productos.

CREATE TABLE products (id INTEGER, name TEXT, price_cents INTEGER, weight_g REAL);
INSERT INTO products VALUES
    (1, 'Taza',      1299, 350.5),
    (2, 'Cuaderno',   850, 180.2),
    (3, 'Bolígrafo',  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;

La clave está en price_cents / 100.0 — ese .0 convierte la división en real, y luego ROUND la deja con dos decimales. Sin él, 1299 / 100 te daría 12, no 12.99.

Lo que viene: fechas y horas

Las funciones numéricas se encargan de la parte matemática. Pero las fechas y horas merecen su propio set de herramientas: SQLite las guarda como texto, real o entero, y ofrece un puñado de funciones —pequeño pero potente— para parsearlas, darles formato y hacer aritmética con ellas. De eso hablamos a continuación.