Tutorial SQL: Funciones numéricas y matemáticas

Funciones aritméticas

Las funciones aritméticas en SQL permiten realizar operaciones matemáticas básicas sobre valores numéricos directamente en las consultas. Estas funciones son fundamentales para realizar cálculos en tiempo real sin necesidad de procesar los datos en aplicaciones externas, lo que optimiza el rendimiento y simplifica el código.

Operadores aritméticos básicos

SQL proporciona los operadores aritméticos estándar que funcionan de manera similar en MySQL y PostgreSQL:

• Suma (+): Añade valores numéricos
• Resta (-): Sustrae valores numéricos
• Multiplicación (*): Multiplica valores numéricos
• División (/): Divide valores numéricos
• Módulo (%): Devuelve el resto de una división

Estos operadores pueden utilizarse directamente en las consultas SELECT:

SELECT 
    precio,
    cantidad,
    precio + cantidad AS suma,
    precio - cantidad AS resta,
    precio * cantidad AS multiplicacion,
    precio / cantidad AS division,
    precio % cantidad AS modulo
FROM productos;

Operador de división y diferencias entre MySQL y PostgreSQL

La división merece especial atención debido a las diferencias entre MySQL y PostgreSQL:

• En MySQL, cuando se dividen dos enteros, el resultado se trunca a un entero si ambos operandos son enteros.
• En PostgreSQL, la división de enteros también devuelve un entero truncado.

Para obtener un resultado con decimales, debemos convertir al menos uno de los operandos a un tipo decimal:

-- MySQL: División de enteros (resultado truncado)
SELECT 5 / 2;  -- Devuelve 2

-- MySQL: División con decimales
SELECT 5 / 2.0;  -- Devuelve 2.5000

-- PostgreSQL: División de enteros (resultado truncado)
SELECT 5 / 2;  -- Devuelve 2

-- PostgreSQL: División con decimales
SELECT 5 / 2.0;  -- Devuelve 2.5000

Funciones aritméticas avanzadas

Además de los operadores básicos, SQL ofrece funciones aritméticas más complejas:

Función ABS()

La función ABS() devuelve el valor absoluto de un número, eliminando el signo negativo si existe:

-- Sintaxis idéntica en MySQL y PostgreSQL
SELECT ABS(-15.7);  -- Devuelve 15.7
SELECT ABS(15.7);   -- Devuelve 15.7

-- Ejemplo práctico
SELECT 
    producto_id,
    stock_actual - stock_minimo AS diferencia_stock,
    ABS(stock_actual - stock_minimo) AS diferencia_absoluta
FROM inventario;

Función MOD()

La función MOD() calcula el resto de una división, similar al operador %:

-- MySQL y PostgreSQL
SELECT MOD(15, 4);  -- Devuelve 3 (15 ÷ 4 = 3 con resto 3)

-- Ejemplo práctico: identificar números pares e impares
SELECT 
    producto_id,
    precio,
    CASE 
        WHEN MOD(precio, 2) = 0 THEN 'Par'
        ELSE 'Impar'
    END AS tipo_precio
FROM productos;

Función POWER() o POW()

Eleva un número a una potencia específica:

-- MySQL: ambas formas son válidas
SELECT POWER(2, 3);  -- Devuelve 8 (2³)
SELECT POW(2, 3);    -- Devuelve 8 (2³)

-- PostgreSQL
SELECT POWER(2, 3);  -- Devuelve 8 (2³)

-- Ejemplo práctico: calcular área de un cuadrado
SELECT 
    id_figura,
    lado,
    POWER(lado, 2) AS area
FROM cuadrados;

Función SQRT()

Calcula la raíz cuadrada de un número:

-- Sintaxis idéntica en MySQL y PostgreSQL
SELECT SQRT(16);  -- Devuelve 4
SELECT SQRT(2);   -- Devuelve 1.4142...

-- Ejemplo práctico: calcular la distancia euclidiana
SELECT 
    SQRT(POWER(x2 - x1, 2) + POWER(y2 - y1, 2)) AS distancia
FROM puntos;

Operaciones con valores NULL

Es importante entender cómo se comportan las operaciones aritméticas con valores NULL:

• Cualquier operación aritmética que involucre un valor NULL dará como resultado NULL
• Esto aplica tanto a operadores básicos como a funciones aritméticas

-- Tanto en MySQL como en PostgreSQL
SELECT 5 + NULL;      -- Devuelve NULL
SELECT ABS(NULL);     -- Devuelve NULL
SELECT POWER(NULL, 2); -- Devuelve NULL

Para manejar valores NULL en cálculos, podemos usar la función COALESCE() o IFNULL():

-- MySQL
SELECT 
    producto_id,
    precio,
    descuento,
    precio - IFNULL(descuento, 0) AS precio_final
FROM productos;

-- PostgreSQL
SELECT 
    producto_id,
    precio,
    descuento,
    precio - COALESCE(descuento, 0) AS precio_final
FROM productos;

Funciones de signo

SQL también proporciona funciones para trabajar con el signo de los valores numéricos:

Función SIGN()

Devuelve el signo de un número: 1 (positivo), -1 (negativo) o 0:

-- Sintaxis idéntica en MySQL y PostgreSQL
SELECT SIGN(15);    -- Devuelve 1
SELECT SIGN(-15);   -- Devuelve -1
SELECT SIGN(0);     -- Devuelve 0

-- Ejemplo práctico: clasificar el balance de cuentas
SELECT 
    cuenta_id,
    balance,
    CASE SIGN(balance)
        WHEN 1 THEN 'Positivo'
        WHEN -1 THEN 'Negativo'
        ELSE 'Cero'
    END AS estado_cuenta
FROM cuentas;

Operaciones con diferentes tipos de datos

Al realizar operaciones aritméticas con diferentes tipos de datos numéricos, SQL sigue reglas de conversión implícita:

-- MySQL y PostgreSQL
SELECT 5 + 3.5;  -- Devuelve 8.5 (entero + decimal = decimal)

-- Ejemplo práctico
SELECT 
    producto_id,
    cantidad_entera,
    factor_decimal,
    cantidad_entera * factor_decimal AS resultado
FROM calculos;

Uso de expresiones aritméticas en cláusulas WHERE

Las funciones aritméticas también pueden utilizarse en condiciones de filtrado:

-- Encontrar productos con margen de beneficio superior al 50%
SELECT 
    producto_id,
    nombre,
    precio_venta,
    costo,
    (precio_venta - costo) / costo * 100 AS margen_porcentaje
FROM productos
WHERE (precio_venta - costo) / costo > 0.5;

-- Encontrar puntos dentro de un círculo
SELECT 
    punto_id, x, y
FROM puntos
WHERE POWER(x - centro_x, 2) + POWER(y - centro_y, 2) <= POWER(radio, 2);

Funciones específicas de cada sistema

Algunas funciones aritméticas son específicas de cada sistema de gestión de bases de datos:

MySQL: DIV (división entera)

-- División entera en MySQL
SELECT 17 DIV 5;  -- Devuelve 3 (cociente entero de 17÷5)

-- Ejemplo práctico
SELECT 
    total_minutos,
    total_minutos DIV 60 AS horas,
    total_minutos MOD 60 AS minutos
FROM tiempos;

PostgreSQL: División entera con //

-- División entera en PostgreSQL
SELECT 17 // 5;  -- Devuelve 3 (cociente entero de 17÷5)

-- Ejemplo práctico
SELECT 
    total_minutos,
    total_minutos // 60 AS horas,
    total_minutos % 60 AS minutos
FROM tiempos;

Precisión en cálculos aritméticos

Al realizar cálculos que requieren alta precisión, especialmente con valores monetarios, es importante considerar el tipo de datos adecuado:

-- MySQL: Usar DECIMAL para cálculos financieros precisos
CREATE TABLE transacciones (
    id INT PRIMARY KEY,
    monto DECIMAL(10,2),
    tasa_impuesto DECIMAL(5,4),
    impuesto DECIMAL(10,2) GENERATED ALWAYS AS (monto * tasa_impuesto) STORED
);

-- PostgreSQL: Usar NUMERIC para cálculos financieros precisos
CREATE TABLE transacciones (
    id SERIAL PRIMARY KEY,
    monto NUMERIC(10,2),
    tasa_impuesto NUMERIC(5,4),
    impuesto NUMERIC(10,2) GENERATED ALWAYS AS (monto * tasa_impuesto) STORED
);

Las funciones aritméticas en SQL son herramientas fundamentales para realizar cálculos directamente en la base de datos, lo que mejora el rendimiento y reduce la necesidad de procesamiento en la capa de aplicación.

Redondeo y precisión

El manejo adecuado de la precisión numérica y las operaciones de redondeo son aspectos fundamentales en SQL, especialmente cuando trabajamos con valores decimales en cálculos financieros, científicos o estadísticos. Las bases de datos ofrecen diversas funciones para controlar cómo se presentan y almacenan los valores numéricos con decimales.

Funciones de redondeo básicas

SQL proporciona varias funciones para ajustar la precisión de los valores numéricos según las necesidades específicas de cada aplicación:

ROUND()

La función ROUND() permite redondear un número a una cantidad específica de decimales. Si el dígito siguiente al último que se conserva es mayor o igual a 5, se redondea hacia arriba; en caso contrario, hacia abajo:

-- Sintaxis básica (idéntica en MySQL y PostgreSQL)
SELECT ROUND(valor, decimales);

-- Ejemplos
SELECT ROUND(123.456, 2);  -- Devuelve 123.46
SELECT ROUND(123.454, 2);  -- Devuelve 123.45
SELECT ROUND(123.456, 0);  -- Devuelve 123

También podemos redondear a posiciones enteras negativas, lo que afecta a las cifras a la izquierda del punto decimal:

SELECT ROUND(123.456, -1);  -- Devuelve 120
SELECT ROUND(123.456, -2);  -- Devuelve 100
SELECT ROUND(1750, -2);     -- Devuelve 1800

En un contexto práctico, podríamos usar ROUND() para calcular precios redondeados:

-- Redondear precios a dos decimales
SELECT 
    producto_id,
    nombre,
    precio_original,
    ROUND(precio_original * 1.21, 2) AS precio_con_iva
FROM productos;

FLOOR()

La función FLOOR() redondea un número hacia abajo al entero más cercano, independientemente de la parte decimal:

-- Sintaxis idéntica en MySQL y PostgreSQL
SELECT FLOOR(valor);

-- Ejemplos
SELECT FLOOR(123.99);  -- Devuelve 123
SELECT FLOOR(123.01);  -- Devuelve 123
SELECT FLOOR(-123.99); -- Devuelve -124 (redondea hacia abajo)

Esta función es útil, por ejemplo, para calcular cuántas unidades completas se pueden obtener:

-- Calcular cuántas cajas completas se pueden llenar
SELECT 
    producto_id,
    stock_total,
    unidades_por_caja,
    FLOOR(stock_total / unidades_por_caja) AS cajas_completas
FROM inventario;

CEILING() o CEIL()

La función CEILING() (o CEIL() en algunas implementaciones) redondea un número hacia arriba al entero más cercano:

-- MySQL acepta ambas formas
SELECT CEILING(123.01);  -- Devuelve 124
SELECT CEIL(123.01);     -- Devuelve 124

-- PostgreSQL prefiere CEIL()
SELECT CEIL(123.01);     -- Devuelve 124
SELECT CEILING(123.01);  -- También funciona en PostgreSQL

-- Comportamiento con negativos
SELECT CEIL(-123.99);    -- Devuelve -123 (redondea hacia arriba)

Esta función es particularmente útil para cálculos donde necesitamos asegurar una cantidad mínima:

-- Calcular páginas necesarias para mostrar resultados
SELECT 
    CEIL(total_registros / registros_por_pagina) AS total_paginas
FROM configuracion_paginacion;

Funciones de truncamiento

A diferencia del redondeo, el truncamiento simplemente elimina los dígitos decimales sin ajustar el valor:

TRUNCATE() en MySQL / TRUNC() en PostgreSQL

-- MySQL
SELECT TRUNCATE(123.456, 2);  -- Devuelve 123.45
SELECT TRUNCATE(123.456, 0);  -- Devuelve 123
SELECT TRUNCATE(123.456, -1); -- Devuelve 120

-- PostgreSQL
SELECT TRUNC(123.456, 2);     -- Devuelve 123.45
SELECT TRUNC(123.456, 0);     -- Devuelve 123
SELECT TRUNC(123.456, -1);    -- Devuelve 120

El truncamiento es útil cuando necesitamos eliminar decimales sin alterar el valor base:

-- Truncar valores de mediciones científicas
SELECT 
    medicion_id,
    valor_original,
    TRUNC(valor_original, 3) AS valor_truncado  -- PostgreSQL
    -- TRUNCATE(valor_original, 3) AS valor_truncado  -- MySQL
FROM mediciones_cientificas;

Control de precisión en operaciones de división

Como vimos en la sección de funciones aritméticas, la división entre enteros puede producir resultados truncados. Para controlar la precisión en divisiones, podemos:

-- Asegurar precisión en divisiones (MySQL y PostgreSQL)
SELECT 
    ventas_totales,
    numero_dias,
    -- Convertir explícitamente a decimal antes de dividir
    ventas_totales / CAST(numero_dias AS DECIMAL(10,2)) AS promedio_diario
FROM estadisticas_ventas;

Redondeo para presentación vs. almacenamiento

Es importante distinguir entre redondear para presentación y para almacenamiento:

-- Redondeo para presentación (no altera los datos almacenados)
SELECT 
    producto_id,
    precio_exacto,
    ROUND(precio_exacto, 2) AS precio_mostrado
FROM productos;

-- Redondeo para almacenamiento (altera permanentemente los datos)
UPDATE productos
SET precio_exacto = ROUND(precio_exacto, 2);

Funciones específicas por sistema

Función ROUND() con modo de redondeo en MySQL

MySQL permite especificar el modo de redondeo en la función ROUND():

-- MySQL: Redondeo con diferentes modos
SELECT ROUND(123.456, 2);            -- Estándar: 123.46
SELECT ROUND(123.456, 2, 0);         -- Igual que el estándar: 123.46
SELECT ROUND(123.456, 2, 1);         -- Siempre hacia arriba: 123.46

Función ROUND() con precisión de tipo NUMERIC en PostgreSQL

PostgreSQL maneja con especial cuidado la precisión en tipos NUMERIC:

-- PostgreSQL: Precisión controlada con NUMERIC
SELECT ROUND(CAST(123.456 AS NUMERIC), 2);  -- Devuelve 123.46 como NUMERIC

Manejo de precisión en cálculos financieros

Para cálculos financieros, donde la precisión es crítica, debemos tener especial cuidado:

-- Cálculo de interés compuesto con precisión controlada
SELECT 
    inversion_inicial,
    tasa_interes,
    periodos,
    ROUND(
        inversion_inicial * POWER((1 + tasa_interes/100), periodos),
        2
    ) AS monto_final
FROM inversiones;

Redondeo monetario específico

Algunas aplicaciones requieren redondeo específico para monedas:

-- Redondeo a 5 céntimos más cercanos (útil en algunas monedas)
SELECT 
    precio_original,
    ROUND(precio_original * 20) / 20 AS precio_redondeado
FROM productos;

Diferencias de comportamiento con valores NULL

El manejo de NULL en funciones de redondeo es consistente entre sistemas:

-- Tanto en MySQL como en PostgreSQL
SELECT ROUND(NULL, 2);  -- Devuelve NULL
SELECT FLOOR(NULL);     -- Devuelve NULL
SELECT CEIL(NULL);      -- Devuelve NULL

Precisión en funciones de agregación

Las funciones de redondeo son especialmente útiles con funciones de agregación:

-- Calcular promedio redondeado de ventas por categoría
SELECT 
    categoria_id,
    COUNT(*) AS total_productos,
    ROUND(AVG(precio), 2) AS precio_promedio,
    ROUND(SUM(ventas_totales), 0) AS ventas_totales
FROM productos
GROUP BY categoria_id;

Uso de CAST y CONVERT para control de precisión

Además de las funciones de redondeo, podemos usar CAST o CONVERT para controlar la precisión:

-- MySQL
SELECT CAST(123.456 AS DECIMAL(10,2));  -- Devuelve 123.46
SELECT CONVERT(123.456, DECIMAL(10,2)); -- Devuelve 123.46

-- PostgreSQL
SELECT CAST(123.456 AS NUMERIC(10,2));  -- Devuelve 123.46

Esto es particularmente útil cuando necesitamos garantizar un formato específico para los datos:

-- Asegurar formato decimal específico para reportes
SELECT 
    producto_id,
    nombre,
    CAST(precio AS DECIMAL(10,2)) AS precio_formateado
FROM productos;

Consideraciones de rendimiento

Las operaciones de redondeo y precisión pueden afectar el rendimiento en conjuntos de datos grandes:

-- Más eficiente: redondear solo en el resultado final
SELECT 
    categoria_id,
    ROUND(SUM(precio * cantidad), 2) AS total_ventas
FROM ventas
GROUP BY categoria_id;

-- Menos eficiente: redondear cada valor individual
SELECT 
    categoria_id,
    SUM(ROUND(precio * cantidad, 2)) AS total_ventas
FROM ventas
GROUP BY categoria_id;

El control adecuado de la precisión y el redondeo es esencial para garantizar la integridad de los datos numéricos en aplicaciones de bases de datos, especialmente en contextos financieros o científicos donde pequeñas diferencias pueden tener impactos significativos.

Funciones matemáticas

Las funciones matemáticas en SQL proporcionan herramientas avanzadas para realizar cálculos científicos, estadísticos y de ingeniería directamente en la base de datos. Estas funciones van más allá de las operaciones aritméticas básicas y el redondeo, permitiendo implementar algoritmos complejos sin necesidad de extraer los datos a aplicaciones externas.

Funciones trigonométricas

Las funciones trigonométricas son fundamentales para cálculos geométricos, cartografía y análisis espacial. Tanto MySQL como PostgreSQL ofrecen un conjunto completo de estas funciones:

• SIN(): Calcula el seno de un ángulo en radianes
• COS(): Calcula el coseno de un ángulo en radianes
• TAN(): Calcula la tangente de un ángulo en radianes

-- Cálculo del seno, coseno y tangente de un ángulo
SELECT 
    angulo,
    SIN(angulo) AS seno,
    COS(angulo) AS coseno,
    TAN(angulo) AS tangente
FROM angulos_radianes;

Para trabajar con ángulos en grados, necesitamos convertirlos a radianes:

-- Conversión de grados a radianes
-- MySQL y PostgreSQL
SELECT 
    angulo_grados,
    angulo_grados * PI() / 180 AS angulo_radianes,
    SIN(angulo_grados * PI() / 180) AS seno
FROM angulos;

También disponemos de las funciones trigonométricas inversas:

-- Funciones trigonométricas inversas
SELECT 
    valor,
    ASIN(valor) AS arcoseno,   -- Devuelve el arcoseno en radianes
    ACOS(valor) AS arcocoseno, -- Devuelve el arcocoseno en radianes
    ATAN(valor) AS arcotangente -- Devuelve la arcotangente en radianes
FROM valores
WHERE valor BETWEEN -1 AND 1;  -- ASIN y ACOS requieren valores entre -1 y 1

La función ATAN2(y, x) es especialmente útil para calcular el ángulo en el plano cartesiano:

-- Calcular el ángulo entre dos puntos
SELECT 
    punto_id,
    x, y,
    ATAN2(y, x) AS angulo_radianes,
    ATAN2(y, x) * 180 / PI() AS angulo_grados
FROM puntos_cartesianos;

Funciones exponenciales y logarítmicas

Estas funciones son esenciales para cálculos de crecimiento, decaimiento y escalas logarítmicas:

Función EXP()

Calcula el valor de e (base del logaritmo natural) elevado a una potencia:

-- Calcular e^x
SELECT 
    valor,
    EXP(valor) AS exponencial
FROM valores;

-- Ejemplo: Crecimiento exponencial
SELECT 
    año,
    poblacion_inicial,
    tasa_crecimiento,
    poblacion_inicial * EXP(tasa_crecimiento * (año - año_inicial)) AS poblacion_estimada
FROM proyecciones_demograficas;

Funciones logarítmicas

SQL ofrece diferentes tipos de logaritmos:

-- Logaritmo natural (base e)
SELECT LN(100);  -- Devuelve 4.60517...

-- Logaritmo base 10
SELECT LOG10(100);  -- Devuelve 2

-- Logaritmo en base arbitraria
-- En MySQL
SELECT LOG(2, 8);  -- Logaritmo de 8 en base 2, devuelve 3

-- En PostgreSQL (orden inverso de argumentos)
SELECT LOG(8, 2);  -- Logaritmo de 8 en base 2, devuelve 3

Estas funciones son útiles para análisis de datos en escala logarítmica:

-- Calcular magnitud en escala Richter (logarítmica)
SELECT 
    evento_id,
    amplitud,
    LOG10(amplitud / amplitud_minima) AS magnitud_richter
FROM mediciones_sismicas;

Funciones hiperbólicas

Tanto MySQL como PostgreSQL soportan funciones hiperbólicas, útiles en cálculos de ingeniería y física:

-- Funciones hiperbólicas
SELECT 
    valor,
    SINH(valor) AS seno_hiperbolico,
    COSH(valor) AS coseno_hiperbolico,
    TANH(valor) AS tangente_hiperbolica
FROM valores;

Funciones de valor aleatorio

La generación de valores aleatorios es útil para simulaciones, muestreos y pruebas:

-- Generar un número aleatorio entre 0 y 1
-- MySQL y PostgreSQL
SELECT RAND();  -- MySQL
SELECT RANDOM(); -- PostgreSQL

-- Generar un entero aleatorio en un rango específico
-- MySQL
SELECT FLOOR(RAND() * (max - min + 1) + min);

-- PostgreSQL
SELECT FLOOR(RANDOM() * (max - min + 1) + min);

Un ejemplo práctico sería seleccionar registros aleatorios:

-- Seleccionar 5 productos al azar (MySQL)
SELECT *
FROM productos
ORDER BY RAND()
LIMIT 5;

-- Seleccionar 5 productos al azar (PostgreSQL)
SELECT *
FROM productos
ORDER BY RANDOM()
LIMIT 5;

Funciones para cálculos estadísticos

Además de las funciones de agregación como AVG() y STDDEV(), SQL ofrece funciones matemáticas útiles para estadísticas:

-- Calcular la distribución normal acumulativa (solo en PostgreSQL)
SELECT 
    valor,
    (1 + ERF((valor - media) / (desviacion_estandar * SQRT(2)))) / 2 AS probabilidad_normal
FROM valores_estadisticos;

Constantes matemáticas

SQL proporciona acceso a constantes matemáticas importantes:

-- Valor de PI
SELECT PI();  -- Devuelve 3.14159...

-- Valor de e (base del logaritmo natural)
-- En MySQL
SELECT EXP(1);  -- Devuelve 2.71828...

-- En PostgreSQL
SELECT EXP(1);  -- Devuelve 2.71828...

Funciones para cálculos geométricos

Estas funciones son útiles para aplicaciones geoespaciales:

-- Calcular la distancia euclidiana entre dos puntos
SELECT 
    punto1_id, punto2_id,
    SQRT(POWER(x2 - x1, 2) + POWER(y2 - y1, 2)) AS distancia_euclidiana
FROM pares_puntos;

-- Calcular el área de un círculo
SELECT 
    circulo_id,
    radio,
    PI() * POWER(radio, 2) AS area
FROM circulos;

Funciones específicas de PostgreSQL

PostgreSQL ofrece algunas funciones matemáticas adicionales:

-- Función factorial
SELECT FACTORIAL(5);  -- Devuelve 120 (5!)

-- Coeficiente binomial
SELECT 
    n, k,
    FACTORIAL(n) / (FACTORIAL(k) * FACTORIAL(n - k)) AS combinaciones
FROM parametros_combinatorios;

-- Función de error complementaria
SELECT ERFC(x);

-- Función gamma
SELECT GAMMA(x);

Funciones de manipulación de bits

Tanto MySQL como PostgreSQL ofrecen funciones para operaciones a nivel de bits:

-- Operaciones bit a bit
SELECT 
    a, b,
    a & b AS AND_bit,  -- AND bit a bit
    a | b AS OR_bit,   -- OR bit a bit
    a ^ b AS XOR_bit,  -- XOR bit a bit
    ~a AS NOT_bit      -- NOT bit a bit (complemento)
FROM valores_binarios;

-- Desplazamiento de bits
-- MySQL
SELECT 
    valor,
    valor << 2 AS desplazamiento_izquierda,  -- Multiplica por 4
    valor >> 1 AS desplazamiento_derecha     -- Divide por 2
FROM valores_enteros;

-- PostgreSQL
SELECT 
    valor,
    valor << 2 AS desplazamiento_izquierda,
    valor >> 1 AS desplazamiento_derecha
FROM valores_enteros;

Aplicación práctica: cálculos financieros

Las funciones matemáticas son especialmente útiles para implementar fórmulas financieras:

-- Cálculo del valor futuro de una inversión con interés compuesto
SELECT 
    inversion_id,
    principal,
    tasa_interes,
    periodos,
    principal * POWER(1 + tasa_interes, periodos) AS valor_futuro
FROM inversiones;

-- Cálculo de la cuota de un préstamo (fórmula de amortización)
SELECT 
    prestamo_id,
    principal,
    tasa_interes_mensual,
    plazo_meses,
    principal * (tasa_interes_mensual * POWER(1 + tasa_interes_mensual, plazo_meses)) 
    / (POWER(1 + tasa_interes_mensual, plazo_meses) - 1) AS cuota_mensual
FROM prestamos;

Aplicación práctica: análisis geoespacial

Las funciones matemáticas permiten realizar cálculos geoespaciales básicos:

-- Calcular distancia entre coordenadas geográficas (fórmula del haversine)
SELECT 
    ubicacion1_id, ubicacion2_id,
    2 * 6371 * ASIN(
        SQRT(
            POWER(SIN((lat2 - lat1) * PI() / 360), 2) +
            COS(lat1 * PI() / 180) * COS(lat2 * PI() / 180) *
            POWER(SIN((lon2 - lon1) * PI() / 360), 2)
        )
    ) AS distancia_km
FROM pares_coordenadas;

Optimización y consideraciones de rendimiento

Al utilizar funciones matemáticas complejas, debemos considerar el impacto en el rendimiento:

• Las funciones matemáticas pueden ser computacionalmente intensivas, especialmente en conjuntos de datos grandes
• Cuando sea posible, es preferible precalcular valores que se utilizan repetidamente
• Considerar la creación de columnas calculadas para valores que se consultan frecuentemente

-- Crear una columna calculada para mejorar el rendimiento
-- MySQL
ALTER TABLE productos
ADD COLUMN precio_con_impuesto DECIMAL(10,2) 
GENERATED ALWAYS AS (precio * (1 + tasa_impuesto)) STORED;

-- PostgreSQL
ALTER TABLE productos
ADD COLUMN precio_con_impuesto DECIMAL(10,2) 
GENERATED ALWAYS AS (precio * (1 + tasa_impuesto)) STORED;

Las funciones matemáticas en SQL proporcionan un conjunto poderoso de herramientas para implementar cálculos complejos directamente en la base de datos, mejorando el rendimiento y reduciendo la necesidad de transferir grandes volúmenes de datos a aplicaciones externas para su procesamiento.