SQRT en SQL: raiz cuadrada, distancia euclidea y desviacion estandar

SQRT devuelve la raiz cuadrada de un numero: un bloque clasico para geometria, estadistica y cualquier formula con una "raiz de una suma de cuadrados". En PostgreSQL es una funcion corriente, pero tiene un par de aristas — la entrada negativa y la eleccion de tipo — con las que es facil tropezar en produccion.

Sintaxis basica y tipos

El caso mas simple es la raiz de una constante:

SELECT SQRT(144);   -- 12
SELECT SQRT(2);     -- 1.4142135623730951

SQRT recibe double precision y devuelve double precision. Si pasas un numeric, PostgreSQL elige la sobrecarga numeric y devuelve numeric — exacto, pero mas lento:

SELECT SQRT(2::numeric);  -- 1.4142135623730950488...
SELECT pg_typeof(SQRT(2::numeric));  -- numeric
SELECT pg_typeof(SQRT(2::double precision));  -- double precision

• Para dinero en orders.amount (normalmente numeric), la raiz queda en numeric por si sola.
• Para analitica pesada sobre millones de filas, convertir a double precision es bastante mas rapido.

El error con entrada negativa

La raiz de un numero negativo no esta definida en los reales, asi que PostgreSQL no devuelve NULL: lanza un error:

SELECT SQRT(-1);
-- ERROR: cannot take square root of a negative number

Esto implica que una sola fila "mala" puede tumbar toda la consulta. Si tu entrada puede ser negativa (por ejemplo, una diferencia de magnitudes), toma el valor absoluto de forma explicita:

SELECT SQRT(ABS(balance))    AS magnitude,
       SIGN(balance)         AS direction
FROM (SELECT amount - 100 AS balance FROM orders) t;

• Garantiza el signo de antemano: ABS(x) o power(x, 2) antes de la raiz.
• Una entrada NULL produce una salida NULL — eso no es un error, a diferencia de un numero negativo.

Trampa: en MySQL, SQRT(-1) devuelve NULL en lugar de fallar, y ClickHouse devuelve nan. La misma consulta se comporta distinto segun el motor, y un NULL/nan silencioso puede corromper agregados posteriores antes de que lo notes.

Distancia euclidea

El uso clasico es la distancia entre dos puntos via el teorema de Pitagoras: SQRT(dx^2 + dy^2). Supongamos que los usuarios llevan coordenadas lat/lon y queremos los cercanos a una oficina:

SELECT id,
       name,
       SQRT(power(lat - 40.0, 2) + power(lon - (-3.7), 2)) AS dist
FROM users
ORDER BY dist
LIMIT 10;

Para solo ordenar por cercania no necesitas la raiz — la distancia al cuadrado es monotona:

SELECT id, name
FROM users
ORDER BY power(lat - 40.0, 2) + power(lon - (-3.7), 2)
LIMIT 10;

• Omite SQRT cuando quieras el orden y no el numero real: menos trabajo de CPU.
• PostgreSQL tambien tiene ^ para potenciar (x ^ 2), pero power(x, 2) se lee con menos ambiguedad.

Desviacion estandar a mano

PostgreSQL trae stddev_pop y stddev_samp, pero conviene saber montar la varianza tu mismo: es SQRT(AVG(x^2) - AVG(x)^2). Midamos la dispersion salarial por departamento:

SELECT dept,
       SQRT(AVG(power(salary, 2)) - power(AVG(salary), 2)) AS std_pop,
       stddev_pop(salary)                                  AS std_check
FROM employees
GROUP BY dept;

Las columnas std_pop y std_check coincidiran. La formula manual muestra exactamente de donde sale la raiz, y se traslada a una ventana:

SELECT id,
       salary,
       SQRT(
         AVG(power(salary, 2)) OVER w
         - power(AVG(salary) OVER w, 2)
       ) AS dept_std
FROM employees
WINDOW w AS (PARTITION BY dept);

• En double precision, la formula AVG(x^2) - AVG(x)^2 puede dar un valor negativo diminuto por error de redondeo — y entonces SQRT falla. Envuelvelo como SQRT(GREATEST(variance, 0)).
• Para informes financieros, calcula en numeric: mas lento, pero sin sorpresas de redondeo.

Cierre

SQRT es simple pero exige disciplina: protege la entrada negativa con ABS/GREATEST, elige numeric frente a double precision con criterio, y omite la raiz cuando solo importa el orden. Asi la geometria y la estadistica en SQL siguen siendo rapidas y predecibles.