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

SQL AVG() para principiantes

En SQL, el AVG() La función es una función agregada que devuelve el promedio de todos los valores en una expresión dada.

También se puede usar para devolver el promedio 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 el promedio de todos los precios.

SELECT AVG(ProductPrice)
FROM Products;

Resultado:

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

En este caso, la información de precios se almacena en el ProductPrice columna, por lo que lo pasamos como argumento a AVG() función, que luego calcula el promedio 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 AVG() La función no devuelve ninguna columna. Puede proporcionar fácilmente un nombre de columna asignando un alias.

SELECT AVG(ProductPrice) AS Average
FROM Products;

Resultado:

+-----------+
| Average   |
|-----------|
| 52.457142 |
+-----------+

Resultados filtrados

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

SELECT AVG(ProductPrice) AS Average
FROM Products
WHERE VendorId = 1001;

Resultado:

+-----------+
| Average   |
|-----------|
| 19.680000 |
+-----------+

En este caso, 19,680000 es el precio medio de todos los productos ofrecidos por el proveedor especificado.

NULL Valores

El AVG() 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 AVG() 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 AVG(ProductPrice) AS Average
FROM Products;

Resultado:

+-----------+
| Average   |
|-----------|
| 52.457142 |
+-----------+
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 AVG() 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 AVG() en el DOB columna, obtendremos un error.

SELECT AVG(DOB) AS Average
FROM Pets;

Resultado:

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

Datos del personaje

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

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

SELECT AVG(ProductName) AS Average
FROM Products;

Resultado:

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

El DISTINCT Palabra clave

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

Ejemplo:

SELECT AVG(DISTINCT ProductPrice) AS DistinctAverage
FROM Products;

Resultado:

+-------------------+
| DistinctAverage   |
|-------------------|
| 56.868333         |
+-------------------+

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

En resumen, obtuvimos 52.457142 sin DISTINCT palabra clave y 56.868333 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, el AVG() 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 AVG() 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 AVG() función con OVER cláusula para aplicar una función de ventana a los datos.

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

Resultado:

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

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

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

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