🇯🇵 日本語 | 🇺🇸 English | 🇪🇸 Español | 🇵🇹 Português | 🇹🇭 ไทย | 🇨🇳 中文

【Introducción a las Funciones de SQL】¡Domina la Agregación de Datos con SUM, AVG, MAX y MIN!

Al crear informes de ventas para un sitio web, información como "¿Cuáles son las ventas totales de este mes?", "¿Cuál es el precio promedio de nuestros productos?" y "¿Cuál fue el artículo más caro vendido?" es esencial. Cuando quieres tomar datos individuales almacenados en una base de datos y agregarlos en un único número significativo, las funciones de agregación de SQL desatan su inmenso poder.

Una función de agregación es una función que toma datos que abarcan múltiples filas como entrada y devuelve un único valor como resultado. Puedes pensar en ello como si introdujeras una pila de papeles con números en una calculadora para obtener una única respuesta, como un "total" o un "promedio".

Este artículo explicará a fondo cómo usar los "cuatro grandes" de las funciones de agregación, que se encuentran entre las más utilizadas y son fundamentales para el análisis de datos: SUM(), AVG(), MAX(), y MIN(), todo ello con código que puedes copiar y pegar. ¡Al dominar estas funciones y combinarlas con GROUP BY, tus capacidades de análisis de datos mejorarán drásticamente!

Preparación: Preparemos Nuestros Datos de Ventas para la Agregación

Para probar las funciones de agregación, primero necesitamos algunos datos numéricos con los que trabajar. Esta vez, crearemos una tabla de sales que imita el historial de ventas de un sitio de comercio electrónico. Al incluir datos de múltiples categorías y con diferentes precios y cantidades, la función de cada función de agregación será más clara.

-- Si la tabla sales existe, eliminarla (para pruebas repetibles)
DROP TABLE IF EXISTS sales;

-- Crear una nueva tabla sales
CREATE TABLE sales (
  id INTEGER PRIMARY KEY,
  product_name TEXT NOT NULL,
  category TEXT NOT NULL,
  price INTEGER NOT NULL,
  quantity INTEGER NOT NULL,
  sale_date DATE NOT NULL
);

-- Insertar datos iniciales
INSERT INTO sales (id, product_name, category, price, quantity, sale_date) VALUES
(1, 'Bolígrafo Asombroso', 'Papelería', 150, 10, '2025-07-01'),
(2, 'Cuaderno Mágico', 'Papelería', 300, 5, '2025-07-01'),
(3, 'Arrocera Definitiva', 'Electrodomésticos', 25000, 2, '2025-07-02'),
(4, 'Manzana Milagrosa', 'Alimentos', 500, 20, '2025-07-03'),
(5, 'Hub USB-C', 'Periféricos de PC', 4000, 3, '2025-07-03'),
(6, 'Pincel Tradicional', 'Papelería', 1200, 8, '2025-07-04'),
(7, 'Chocolate Premium', 'Alimentos', 3500, 5, '2025-07-05'),
(8, 'Bolígrafo Asombroso', 'Papelería', 150, 15, '2025-07-05');

Ahora estamos listos para agregar datos desde varios ángulos.

【Suma】Encontrando el Total con la Función `SUM()`

La función SUM() calcula el valor total de una columna numérica especificada. Es una de las funciones de agregación más básicas, utilizada en innumerables escenarios de negocio donde necesitas saber un "total", como "ventas totales", "inventario total" o "puntos totales".

Especificas la columna que quieres sumar dentro de los paréntesis de SUM(). También es posible sumar el resultado de un cálculo entre columnas.

Escenario: "¿Cuál es el monto total de todas las ventas (ingresos totales)?"

En este caso, calculamos "precio (price) * cantidad (quantity)" para cada registro y luego sumamos todos esos resultados.

SELECT SUM(price * quantity) AS ingresos_totales FROM sales;

Resultado:

ingresos_totales
----------------
102850

Usar AS ingresos_totales para dar a la columna de resultados un nombre claro y significativo también es un punto clave.

【Promedio】Encontrando el Valor Promedio con la Función `AVG()`

La función AVG() (abreviatura de Average) calcula el valor promedio de una columna numérica especificada. Es útil para comprender las tendencias generales en tus datos, como "edad promedio", "puntuación promedio" o "precio unitario promedio".

Escenario: "¿Cuál es el precio unitario promedio de los productos vendidos?"

SELECT AVG(price) AS precio_promedio FROM sales;

Resultado:

precio_promedio
---------------
5562.5

Como advertencia, recuerda que si la columna que se está calculando contiene valores `NULL`, SUM() y AVG() ignorarán esas filas en su agregación. Esto a veces puede llevar a resultados no deseados.

【Máximo y Mínimo】Encontrando los Valores Máximo y Mínimo con `MAX()` y `MIN()`

MAX() (Maximum) y MIN() (Minimum) son, como sus nombres indican, funciones para obtener los valores máximo y mínimo en una columna. Es eficiente aprender estas dos como un par.

La Función `MAX()`: Encontrando el Valor Más Grande

Escenario: "¿Cuál fue la venta de mayor valor en una sola transacción?"

SELECT MAX(price * quantity) AS venta_mas_alta FROM sales;

Resultado:

venta_mas_alta
--------------
50000

Esa es la venta de la 'Arrocera Definitiva' con ID 3 (25,000 * 2).

La Función `MIN()`: Encontrando el Valor Más Pequeño

Escenario: "Entre los productos vendidos, ¿cuál es el precio unitario más barato?"

SELECT MIN(price) AS precio_mas_bajo FROM sales;

Resultado:

precio_mas_bajo
---------------
150

MAX() y MIN() no son solo para números; también se pueden usar en fechas (para encontrar la fecha más reciente/antigua) y cadenas de texto (para encontrar la última/primera en orden alfabético), lo que las convierte en funciones muy versátiles.

【La Combinación Suprema】La Cláusula `GROUP BY` y las Funciones de Agregación

El verdadero poder de estas cuatro funciones de agregación se evidencia más cuando se combinan con la cláusula GROUP BY. Usando GROUP BY, puedes agrupar datos por los valores de una columna específica y luego aplicar funciones de agregación a **cada uno** de esos grupos.

Esto permite un análisis más práctico y detallado, como "ventas totales por categoría" o "número promedio de unidades vendidas por producto".

Escenario: "Para cada categoría de producto, quiero agregar los ingresos totales, el precio unitario promedio y la cantidad total vendida."

SELECT
  category,
  SUM(price * quantity) AS ingresos_totales,
  AVG(price) AS precio_promedio,
  SUM(quantity) AS cantidad_total_vendida
FROM
  sales
GROUP BY
  category;

Resultado:

category           | ingresos_totales | precio_promedio | cantidad_total_vendida
-------------------|------------------|-----------------|------------------------
Periféricos de PC  | 12000            | 4000            | 3
Electrodomésticos  | 50000            | 25000           | 2
Papelería          | 13350            | 550             | 33
Alimentos          | 27500            | 2000            | 25

Con esta única consulta, el rendimiento de ventas detallado para cada categoría ahora es claro de un vistazo. Al combinar funciones de agregación con GROUP BY de esta manera, puedes extraer "perspectivas" críticas para el negocio a partir de datos brutos que antes eran solo una lista de números.

【Patio de Recreo Interactivo】¡Experimenta la Agregación de Datos Ejecutando SQL en tu Navegador!

¡Ahora es el momento de convertir el conocimiento en una habilidad! Copia todo el código HTML a continuación, guárdalo como un archivo llamado sql_aggregate_test.html y ábrelo en tu navegador. Se iniciará tu propio entorno SQL personal, precargado con la tabla sales que hemos estado usando en este artículo.

¡Intenta cambiar `SUM` por `AVG`, o agregar diferentes columnas a la cláusula `GROUP BY`. Experimenta libremente y ve por ti mismo cómo los datos se agregan y se transforman en información significativa!

<!DOCTYPE html>
<html lang="es">
<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Patio de Recreo en Línea de Funciones de Agregación de SQL</title>
  <style>
    body { font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif; line-height: 1.7; color: #333; max-width: 800px; margin: 2rem auto; padding: 0 1rem; }
    h1 { color: #2980b9; }
    textarea { width: 100%; height: 220px; font-family: "SF Mono", "Consolas", monospace; font-size: 16px; padding: 12px; border: 1px solid #ccc; border-radius: 6px; box-sizing: border-box; margin-bottom: 1rem; }
    button { background-color: #3498db; color: white; border: none; padding: 12px 22px; font-size: 16px; border-radius: 6px; cursor: pointer; transition: background-color 0.2s; }
    button:hover { background-color: #2980b9; }
    button:disabled { background-color: #bdc3c7; cursor: not-allowed; }
    #result-container { margin-top: 2rem; border: 1px solid #ddd; padding: 1rem; border-radius: 6px; background: #fdfdfd; min-height: 50px; }
    #error-message { color: #e74c3c; font-weight: bold; }
    table { border-collapse: collapse; width: 100%; margin-top: 1rem; }
    th, td { border: 1px solid #ddd; padding: 10px; text-align: left; }
    th { background-color: #f2f2f2; }
    tr:nth-child(even) { background-color: #f9f9f9; }
  </style>
  <script src="https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.10.3/sql-wasm.js"></script>
</head>
<body>

  <h1>¡Probemos SQL!</h1>
  <p>Introduce una sentencia SQL en el área de texto de abajo y haz clic en el botón "Ejecutar". ¡Vamos a probar varias agregaciones!</p>

  <textarea id="sql-input">-- Agrupemos por nombre de producto y calculemos los ingresos totales y la cantidad total para cada producto
SELECT
  product_name,
  SUM(price * quantity) AS ingresos_totales,
  SUM(quantity) AS cantidad_total
FROM
  sales
GROUP BY
  product_name
ORDER BY
  ingresos_totales DESC;
  </textarea>
  
  <button id="execute-btn">Ejecutar</button>
  
  <div id="result-container">
    <p id="error-message"></p>
    <div id="result-output"></div>
  </div>

  <script>
    const sqlInput = document.getElementById('sql-input');
    const executeBtn = document.getElementById('execute-btn');
    const errorMsg = document.getElementById('error-message');
    const resultOutput = document.getElementById('result-output');

    let db;

    async function initDb() {
      executeBtn.disabled = true;
      executeBtn.textContent = 'Inicializando BD...';
      try {
        const SQL = await initSqlJs({
          locateFile: file => `https://cdnjs.cloudflare.com/ajax/libs/sql.js/1.10.3/${file}`
        });
        db = new SQL.Database();
        
        const setupSql = `
          DROP TABLE IF EXISTS sales;
          CREATE TABLE sales (id INTEGER PRIMARY KEY, product_name TEXT NOT NULL, category TEXT NOT NULL, price INTEGER NOT NULL, quantity INTEGER NOT NULL, sale_date DATE NOT NULL);
          INSERT INTO sales (id, product_name, category, price, quantity, sale_date) VALUES
          (1, 'Bolígrafo Asombroso', 'Papelería', 150, 10, '2025-07-01'),
          (2, 'Cuaderno Mágico', 'Papelería', 300, 5, '2025-07-01'),
          (3, 'Arrocera Definitiva', 'Electrodomésticos', 25000, 2, '2025-07-02'),
          (4, 'Manzana Milagrosa', 'Alimentos', 500, 20, '2025-07-03'),
          (5, 'Hub USB-C', 'Periféricos de PC', 4000, 3, '2025-07-03'),
          (6, 'Pincel Tradicional', 'Papelería', 1200, 8, '2025-07-04'),
          (7, 'Chocolate Premium', 'Alimentos', 3500, 5, '2025-07-05'),
          (8, 'Bolígrafo Asombroso', 'Papelería', 150, 15, '2025-07-05');
        `;
        db.run(setupSql);
        
        executeBtn.disabled = false;
        executeBtn.textContent = 'Ejecutar';
        resultOutput.innerHTML = '<p>¡Todo listo! Siéntete libre de probar tus propias consultas SQL.</p>';

      } catch (err) {
        errorMsg.textContent = 'Error al inicializar la base de datos: ' + err.message;
        console.error(err);
      }
    }

    function executeSql() {
      if (!db) return;
      
      const sql = sqlInput.value;
      errorMsg.textContent = '';
      resultOutput.innerHTML = '';

      try {
        const results = db.exec(sql);
        if (results.length === 0) {
          resultOutput.innerHTML = '<p>Consulta ejecutada con éxito, pero no se devolvió ningún conjunto de resultados.</p>';
          return;
        }
        
        results.forEach(result => {
          const table = document.createElement('table');
          const thead = document.createElement('thead');
          const tbody = document.createElement('tbody');
          
          const headerRow = document.createElement('tr');
          result.columns.forEach(colName => {
            const th = document.createElement('th');
            th.textContent = colName;
            headerRow.appendChild(th);
          });
          thead.appendChild(headerRow);
          
          result.values.forEach(row => {
            const bodyRow = document.createElement('tr');
            row.forEach(cellValue => {
              const td = document.createElement('td');
              td.textContent = cellValue === null ? 'NULL' : (typeof cellValue === 'number' ? cellValue.toLocaleString('es-ES') : cellValue);
              bodyRow.appendChild(td);
            });
            tbody.appendChild(bodyRow);
          });
          
          table.appendChild(thead);
          table.appendChild(tbody);
          resultOutput.appendChild(table);
        });

      } catch (err) {
        errorMsg.textContent = 'Error de SQL: ' + err.message;
        console.error(err);
      }
    }

    executeBtn.addEventListener('click', executeSql);
    
    initDb();
  </script>
</body>
</html>

Conclusión

En este artículo, hemos aprendido sobre las cuatro funciones de agregación fundamentales para el análisis de datos: `SUM()`, `AVG()`, `MAX()`, y `MIN()`.

Estas funciones de agregación son el primer paso no solo para recuperar datos, sino para obtener perspectivas significativas de ellos. Son herramientas increíblemente poderosas para un creador web, útiles para todo, desde la toma de decisiones de negocio hasta la identificación de áreas de mejora del sitio. ¡Te animamos a dominar estas funciones y a experimentar la alegría de conversar con tus datos!

Plantillas Relacionadas