La funcion POWER en SQL: potencias, raices y crecimiento compuesto

POWER(base, exponente) eleva un numero a una potencia: POWER(2, 10) es 1024. Es la herramienta basica para calculos de crecimiento, normalizacion de metricas y extraccion de raices mediante un exponente fraccionario.

Sintaxis basica

POWER recibe dos argumentos — la base y el exponente — y devuelve un numero de punto flotante (double precision en PostgreSQL). El alias POW funciona en MySQL y ClickHouse; PostgreSQL acepta ambos nombres.

SELECT POWER(2, 10) AS kib,      -- 1024
       POWER(10, 6) AS million,  -- 1000000
       POWER(2, -1) AS half;     -- 0.5

Un exponente negativo produce una fraccion, y un exponente cero siempre es uno. PostgreSQL ademas tiene un operador infijo ^ que se lee bien dentro de las formulas:

SELECT 2 ^ 10 AS via_operator;   -- 1024 in PostgreSQL

• En MySQL y ClickHouse, ^ es un XOR a nivel de bits, no una potencia. Alli usa POW.
• El resultado siempre es real; para una respuesta entera envuelvelo en ROUND(...)::bigint.

Exponentes fraccionarios y raices

Una raiz n-esima es simplemente elevar un valor a la potencia 1/n. La raiz cuadrada tiene su propia funcion, SQRT, pero POWER te da cualquier raiz.

SELECT POWER(27, 1.0 / 3) AS cube_root,    -- 3
       POWER(16, 0.25)     AS fourth_root,  -- 2
       SQRT(2)             AS sqrt2;        -- 1.4142...

Usalo para comprimir la dispersion de los importes de pedidos con una raiz cubica, un truco habitual para amortiguar valores atipicos en los tableros:

SELECT id,
       amount,
       ROUND(POWER(amount, 1.0 / 3), 2) AS dampened
FROM orders
WHERE status = 'paid'
ORDER BY amount DESC;

La media geometrica de salarios por departamento es otro caso donde brillan EXP y LN, pero una raiz tambien se puede expresar con POWER:

SELECT dept,
       ROUND(EXP(AVG(LN(salary))), 2) AS geo_mean_salary
FROM employees
GROUP BY dept;

• Escribe 1.0 / 3, no 1 / 3: en PostgreSQL y MySQL la division entera de 1 / 3 es 0, lo que colapsa todo el resultado a 1.

Interes compuesto y crecimiento

La formula clasica de capitalizacion es base * (1 + tasa) ^ periodos. Proyectemos donde queda el valor medio del pedido si crece un 3% mensual durante un ano completo.

SELECT ROUND(AVG(amount), 2)                          AS avg_now,
       ROUND(AVG(amount) * POWER(1 + 0.03, 12), 2)    AS avg_in_a_year
FROM orders
WHERE status = 'paid';

El problema inverso — hallar la tasa media de crecimiento mensual (CAGR) de los registros — tambien se apoya en POWER con un exponente fraccionario. La base debe ser la razon entre el ultimo valor y el primero (last_count / first_count), y el exponente es uno entre el numero de periodos: POWER(last_count / first_count, 1.0 / periodos) - 1. Un simple COUNT(*) sobre todo el rango no da esa razon: cuenta filas, no su crecimiento del primer mes al ultimo. Por eso tomamos los registros del primer y del ultimo mes por separado y dividimos uno entre otro. Fijate en el 1.0 del exponente y en la conversion a numeric, para que ninguna division colapse a cero:

WITH monthly AS (
    SELECT date_trunc('month', created_at) AS m,
           COUNT(*)                        AS signups
    FROM users
    GROUP BY 1
),
bounds AS (
    SELECT (SELECT signups FROM monthly ORDER BY m ASC  LIMIT 1) AS first_count,
           (SELECT signups FROM monthly ORDER BY m DESC LIMIT 1) AS last_count,
           (SELECT COUNT(*) - 1 FROM monthly)                    AS periods
)
SELECT ROUND(
         (POWER(last_count::numeric / first_count, 1.0 / periods) - 1) * 100, 2
       ) AS monthly_growth_pct
FROM bounds;

Overflow y trampas

Las potencias crecen de forma explosiva. Un exponente grande desborda el tipo rapidamente, y PostgreSQL lanza value out of range: overflow en lugar de un NULL silencioso.

SELECT POWER(10, 308);   -- ok, near the double precision limit
SELECT POWER(10, 309);   -- ERROR: value out of range: overflow

• Una base negativa con exponente fraccionario (POWER(-8, 0.5)) es un numero complejo; PostgreSQL lanza un error en vez de devolver NaN.
• En PostgreSQL, POWER(numeric, numeric) es mas preciso pero mas costoso que la version de double precision. Convierte a numeric de forma deliberada para el dinero.
• El pow de ClickHouse siempre devuelve Float64, asi que espera error de redondeo en magnitudes grandes.
• POWER(0, 0) es 1 en los tres motores — una convencion matematica, no un fallo.

Manten los exponentes dentro de limites razonables, convierte los tipos de forma explicita y usa 1.0 / n para las raices; asi POWER sigue siendo una herramienta predecible tanto para analitica como para formulas financieras.