sql >> Base de Datos >  >> RDS >> Database

SQL SUM() para principiantes

En SQL, SUM() función es una función agregada que devuelve la suma de todos los valores en una expresión dada.

También se puede usar para devolver la suma de todos los valores distintos (únicos) en una expresión.

La expresión debe ser numérica (no puede ser una cadena de caracteres, una cadena de bits o una fecha y hora).

A continuación se muestran algunos ejemplos básicos para demostrar cómo funciona.

Tabla de muestra

Supongamos que tenemos la siguiente tabla:

SELECT * FROM Products;

Resultado:

+-------------+------------+---------------------------------+----------------+-----------------------------------------+
| ProductId   | VendorId   | ProductName                     | ProductPrice   | ProductDescription                      |
|-------------+------------+---------------------------------+----------------+-----------------------------------------|
| 1           | 1001       | Left handed screwdriver         | 25.99          | Purple. Includes left handed carry box. |
| 2           | 1001       | Long Weight (blue)              | 14.75          | Includes a long wait.                   |
| 3           | 1001       | Long Weight (green)             | 11.99          | Approximate 30 minute waiting period.   |
| 4           | 1002       | Sledge Hammer                   | 33.49          | Wooden handle. Free wine glasses.       |
| 5           | 1003       | Chainsaw                        | 245.00         | Orange. Includes spare fingers.         |
| 6           | 1003       | Straw Dog Box                   | NULL           | Tied with vines. Very chewable.         |
| 7           | 1004       | Bottomless Coffee Mugs (4 Pack) | 9.99           | Brown ceramic with solid handle.        |
| 8           | 1001       | Right handed screwdriver        | 25.99          | Blue. Includes right handed carry box.  |
+-------------+------------+---------------------------------+----------------+-----------------------------------------+

Ejemplo

Podemos usar la siguiente consulta para obtener la suma de todos los precios.

SELECT SUM(ProductPrice)
FROM Products;

Resultado:

+--------------------+
| (No column name)   |
|--------------------|
| 367.20             |
+--------------------+

En este caso, la información de precios se almacena en el ProductPrice columna, y así lo pasamos como argumento a SUM() función, que luego calcula la suma y devuelve el resultado.

Uso de alias de columna

Notará que los resultados anteriores no incluyen un nombre de columna. Esto es de esperar, porque SUM() La función no devuelve ninguna columna. Puede proporcionar fácilmente un nombre de columna asignando un alias.

SELECT SUM(ProductPrice) AS Sum
FROM Products;

Resultado:

+--------+
| Sum    |
|--------|
| 367.20 |
+--------+

Resultados filtrados

El SUM() opera en las filas devueltas por la consulta. Entonces, si filtra los resultados, el resultado de SUM() reflejará eso.

SELECT SUM(ProductPrice) AS Sum
FROM Products
WHERE VendorId = 1001;

Resultado:

+-------+
| Sum   |
|-------|
| 78.72 |
+-------+

En este caso, 78,72 es la suma de todos los productos ofrecidos por el proveedor especificado.

NULL Valores

El SUM() la función ignora cualquier NULL valores. En nuestra tabla de ejemplo anterior, número de producto 6 tiene NULL en su ProductPrice columna, pero eso fue ignorado en nuestro SUM() ejemplo.

Dependiendo de su DBMS y su configuración, es posible que vea o no una advertencia de que NULL los valores fueron eliminados en el conjunto de resultados.

Este es un ejemplo de lo que podrías ver:

SELECT SUM(ProductPrice) AS Sum
FROM Products;

Resultado:

+--------+
| Sum    |
|--------|
| 367.20 |
+--------+
Warning: Null value is eliminated by an aggregate or other SET operation.

Todo esto nos dice que la columna contenía al menos un NULL valor, y que se ignoró al calcular los resultados.

Datos de fecha/hora

El SUM() la función no acepta expresiones de fecha/hora.

Supongamos que tenemos la siguiente tabla:

SELECT PetName, DOB 
FROM Pets;

Resultado:

+-----------+------------+
| PetName   | DOB        |
|-----------+------------|
| Fluffy    | 2020-11-20 |
| Fetch     | 2019-08-16 |
| Scratch   | 2018-10-01 |
| Wag       | 2020-03-15 |
| Tweet     | 2020-11-28 |
| Fluffy    | 2020-09-17 |
| Bark      | NULL       |
| Meow      | NULL       |
+-----------+------------+

Si intentamos usar SUM() en el DOB columna, obtendremos un error.

SELECT SUM(DOB) AS Sum
FROM Pets;

Resultado:

Msg 8117, Level 16, State 1, Line 1
Operand data type date is invalid for sum operator.

Datos del personaje

El SUM() La función tampoco acepta expresiones de cadenas de caracteres.

Esto es lo que sucede si tratamos de usar SUM() en el ProductName columna de nuestros Products tabla (que usa un tipo de datos de varchar):

SELECT SUM(ProductName) AS Sum
FROM Products;

Resultado:

Msg 8117, Level 16, State 1, Line 1
Operand data type varchar is invalid for sum operator.

El DISTINCT Palabra clave

Puedes usar el DISTINCT palabra clave con SUM() para calcular sólo valores distintos. Es decir, si hay valores duplicados, se tratan como un solo valor.

Ejemplo:

SELECT SUM(DISTINCT ProductPrice) AS DistinctSum
FROM Products;

Resultado:

+---------------+
| DistinctSum   |
|---------------|
| 341.21        |
+---------------+

Podemos ver que este resultado es más bajo que el resultado que obtuvimos sin DISTINCT palabra clave.

En resumen, obtuvimos 367.20 sin DISTINCT palabra clave y 341.21 con DISTINCT palabra clave.

Esto se debe a que hay dos artículos que comparten el mismo precio (el destornillador para zurdos y el destornillador para diestros tienen un precio de 25,99). Por lo tanto, SUM() función, cuando se usa con DISTINCT palabra clave, trata ambos valores como uno solo y calcula su resultado en consecuencia.

Funciones de ventana

Dependiendo de su DBMS, es posible que pueda usar un OVER cláusula con su SUM() para crear una función de ventana.

Una función de ventana realiza una operación similar a un agregado en un conjunto de filas de consulta. Produce un resultado para cada fila de consulta. Esto contrasta con una operación agregada, que agrupa las filas de consulta en una sola fila de resultados.

Aquí hay un ejemplo para demostrar el concepto.

Ya hemos visto los Products mesa. Nuestra base de datos también tiene un Customers tabla, y contiene los siguientes datos:

+--------------+----------------------+-------------------+------------+-----------------+------------+-----------+----------------+
| CustomerId   | CustomerName         | PostalAddress     | City       | StateProvince   | ZipCode    | Country   | Phone          |
|--------------+----------------------+-------------------+------------+-----------------+------------+-----------+----------------+
| 1001         | Palm Pantry          | 20 Esplanade      | Townsville | QLD             | 2040       | AUS       | (308) 555-0100 |
| 1002         | Tall Poppy           | 12 Main Road      | Columbus   | OH              | 43333      | USA       | (310) 657-0134 |
| 1003         | Crazy Critters       | 10 Infinite Loops | Cairns     | QLD             | 4870       | AUS       | (418) 555-0143 |
| 1004         | Oops Media           | 4 Beachside Drive | Perth      | WA              | 1234       | AUS       | (405) 443-5987 |
| 1005         | Strange Names Inc.   | 789 George Street | Sydney     | NSW             | 2000       | AUD       | (318) 777-0177 |
| 1006         | Hi-Five Solutionists | 5 High Street     | Highlands  | HI              | 1254       | AUS       | (415) 413-5182 |
+--------------+----------------------+-------------------+------------+-----------------+------------+-----------+----------------+

Podemos recuperar datos de estas tablas y presentarlos como un conjunto de resultados usando una combinación.

También podemos usar el SUM() función con OVER cláusula para aplicar una función de ventana a los datos.

SELECT 
    v.VendorName,
    p.ProductName,
    p.ProductPrice,
    SUM(ProductPrice) OVER (PARTITION BY v.VendorName) AS "Sum For This Vendor"
FROM Products p 
INNER JOIN Vendors v 
ON v.VendorId = p.VendorId
ORDER BY VendorName, ProductPrice, "Sum For This Vendor";

Resultado:

+---------------+---------------------------------+----------------+-----------------------+
| VendorName    | ProductName                     | ProductPrice   | Sum For This Vendor   |
|---------------+---------------------------------+----------------+-----------------------|
| Katty Kittens | Bottomless Coffee Mugs (4 Pack) | 9.99           | 9.99                  |
| Mars Supplies | Long Weight (green)             | 11.99          | 78.72                 |
| Mars Supplies | Long Weight (blue)              | 14.75          | 78.72                 |
| Mars Supplies | Right handed screwdriver        | 25.99          | 78.72                 |
| Mars Supplies | Left handed screwdriver         | 25.99          | 78.72                 |
| Pedal Medals  | Straw Dog Box                   | NULL           | 245.00                |
| Pedal Medals  | Chainsaw                        | 245.00         | 245.00                |
| Randy Roofers | Sledge Hammer                   | 33.49          | 33.49                 |
+---------------+---------------------------------+----------------+-----------------------+

En este caso usamos el OVER cláusula con nuestro SUM() función para particionar el resultado por nombre de proveedor.

Al hacer esto, pudimos devolver la información de precios de cada producto, así como la suma de todos los productos de ese proveedor determinado. La suma cambia a medida que cambia el proveedor (a menos que varios proveedores tengan la misma suma), pero sigue siendo la misma para todos los productos del mismo proveedor.

Este concepto también se puede aplicar a otras funciones agregadas en SQL, como AVG() , MIN() , MAX() y COUNT() .