En SQL, el COUNT() La función es una función agregada que devuelve el número de elementos encontrados en un grupo.
Puedes usar COUNT() en varias partes de una consulta. Por ejemplo, puede usarlo en el SELECT lista, o el HAVING cláusula al filtrar grupos.
Tabla de muestra
Supongamos que tenemos la siguiente tabla:
SELECT * FROM Pets;Resultado:
+---------+-------------+-----------+-----------+------------+ | PetId | PetTypeId | OwnerId | PetName | DOB | |---------+-------------+-----------+-----------+------------| | 1 | 2 | 3 | Fluffy | 2020-11-20 | | 2 | 3 | 3 | Fetch | 2019-08-16 | | 3 | 2 | 2 | Scratch | 2018-10-01 | | 4 | 3 | 3 | Wag | 2020-03-15 | | 5 | 1 | 1 | Tweet | 2020-11-28 | | 6 | 3 | 4 | Fluffy | 2020-09-17 | | 7 | 3 | 2 | Bark | NULL | | 8 | 2 | 4 | Meow | NULL | +---------+-------------+-----------+-----------+------------+
Los siguientes ejemplos usarán el COUNT() función al consultar esta tabla.
Ejemplo
Aquí hay un ejemplo simple para comenzar.
SELECT COUNT(*) AS Count
FROM Pets;Resultado:
+---------+ | Count | |---------| | 8 | +---------+
Esto nos dice que hay 8 filas en la tabla. Lo sabemos porque usamos el comodín asterisco (* ) para especificar todas las filas y todas las columnas.
Contar una columna específica
También puede especificar una columna en particular para contar. El COUNT() la función solo cuenta no NULL resultados, por lo que si especifica una columna que contiene NULL valores, esos valores no se contarán.
Aquí hay un ejemplo para demostrar lo que quiero decir.
SELECT COUNT(DOB) AS Count
FROM Pets;Resultado:
+---------+ | Count | |---------| | 6 | +---------+ Warning: Null value is eliminated by an aggregate or other SET operation.
En este caso, las Pets la tabla contiene dos NULL valores en el DOB columna (dos mascotas no han proporcionado su fecha de nacimiento), por lo que COUNT(DOB) devuelve 6, en lugar de 8 cuando usamos COUNT(*) .
El motivo COUNT(*) en el ejemplo anterior devolvió todas las filas, es porque esas dos filas lo hicieron tener datos en las otras columnas.
En mi ejemplo, mi DBMS también devolvió una advertencia sobre esto. Es posible que reciba o no una advertencia, según su DBMS y su configuración específica.
Resultados filtrados
El COUNT() La función cuenta las filas devueltas por la consulta. Entonces, si filtra los resultados, el resultado de COUNT() reflejará eso.
SELECT COUNT(*) AS Count
FROM Pets
WHERE PetName = 'Fluffy';Resultado:
+---------+ | Count | |---------| | 2 | +---------+
En este caso, hay dos mascotas con el nombre de Fluffy. Por lo tanto, la consulta habría devuelto dos filas y el resultado de COUNT() es 2 .
Contar columnas distintas
Por defecto, el COUNT() la función incluye un implícito ALL palabra clave. Esto significa que incluye duplicados en sus resultados.
Pero también tienes la opción de agregar el DISTINCT palabra clave para especificar que solo se devuelven valores distintos. Es decir, puede especificar que excluya los duplicados.
Elijamos el PetName columna. Si observa la tabla original anterior, puede ver que PetName columna incluye dos filas con el mismo valor (Fluffy ).
Primero ejecutaremos un COUNT(ALL PetName) consulta para incluir todos los valores duplicados en el conteo:
SELECT COUNT(ALL PetName) AS Count
FROM Pets;Resultado:
+---------+ | Count | |---------| | 8 | +---------+
Entonces, hay ocho filas. Recuerda que este es el mismo resultado que obtendríamos si no hubiéramos incluido ALL palabra clave, porque ALL es el predeterminado.
Ahora ejecutaremos un COUNT(DISTINCT PetName) para eliminar cualquier duplicado del conteo.
SELECT COUNT(DISTINCT PetName) AS Count
FROM Pets;Resultado:
+---------+ | Count | |---------| | 7 | +---------+
Esta vez el resultado es 7 . Esto se debe a que se eliminó nuestro valor duplicado. Es decir, el valor duplicado se trató como si solo hubiera un valor.
Usando COUNT() con el HAVING Cláusula
Puede incluir el COUNT() función en varias partes de una consulta. No se limita solo a SELECT lista.
Aquí hay un ejemplo que usa COUNT() tanto en HAVING cláusula y el SELECT lista.
SELECT
PetTypeId,
COUNT(PetTypeId) AS Count
FROM Pets
GROUP BY PetTypeId
HAVING COUNT(PetTypeId) > 2
ORDER BY Count DESC;Resultado:
+-------------+---------+ | PetTypeId | Count | |-------------+---------| | 3 | 4 | | 2 | 3 | +-------------+---------+
En este caso, usamos el HAVING cláusula junto con GROUP BY cláusula para devolver solo aquellas filas que tienen un COUNT(PetTypeId) mayor que 2 .
No está limitado solo al operador ) para principiantes”>operador mayor que (> ) cuando se usa HAVING cláusula. Puede usar los mismos operadores que puede usar con WHERE cláusula (como = , ) Operator for Beginners">< , =) Operator for Beginners">>= , IN , LIKE , etc.).
Consulte Operadores de SQL para obtener una lista de los operadores disponibles en SQL.
Funciones de ventana
Dependiendo de su DBMS, es posible que pueda usar un OVER cláusula con su COUNT() 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 las Pets mesa. Nuestra base de datos también tiene un Owners tabla, y contiene los siguientes datos:
+-----------+-------------+------------+----------------+-------------------+ | OwnerId | FirstName | LastName | Phone | Email | |-----------+-------------+------------+----------------+-------------------| | 1 | Homer | Connery | (308) 555-0100 | [email protected] | | 2 | Bart | Pitt | (231) 465-3497 | [email protected] | | 3 | Nancy | Simpson | (489) 591-0408 | NULL | | 4 | Boris | Trump | (349) 611-8908 | NULL | | 5 | Woody | Eastwood | (308) 555-0112 | [email protected] | | 6 | Burt | Tyson | (309) 565-0112 | [email protected] | +-----------+-------------+------------+----------------+-------------------+
Podemos recuperar datos de estas tablas y presentarlos como un conjunto de resultados usando una combinación.
También podemos usar el COUNT() función con OVER cláusula para aplicar una función de ventana a los datos.
SELECT
CONCAT(o.FirstName, ' ', o.LastName) AS Owner,
p.PetName,
COUNT(PetId) OVER (PARTITION BY CONCAT(o.FirstName, ' ', o.LastName)) AS "Number of pets from this owner"
FROM Owners o
INNER JOIN Pets p
ON p.OwnerId = o.OwnerId
ORDER BY "Number of pets from this owner" DESC;Resultado:
+---------------+-----------+----------------------------------+ | Owner | PetName | Number of pets from this owner | |---------------+-----------+----------------------------------| | Nancy Simpson | Wag | 3 | | Nancy Simpson | Fluffy | 3 | | Nancy Simpson | Fetch | 3 | | Bart Pitt | Scratch | 2 | | Bart Pitt | Bark | 2 | | Boris Trump | Meow | 2 | | Boris Trump | Fluffy | 2 | | Homer Connery | Tweet | 1 | +---------------+-----------+----------------------------------+
En este caso usamos el OVER cláusula con nuestro COUNT() cláusula para dividir el conteo solo en el nombre del propietario.
El resultado es que los propietarios con varias mascotas se muestran en varias filas (porque también se debe mostrar cada mascota), y cada fila contiene el recuento total de las mascotas de ese propietario.
Este concepto también se puede aplicar a otras funciones agregadas en SQL, como SUM() , MIN() , MAX() y AVG() .
COUNT_BIG()
Si está contando conjuntos de datos muy grandes en SQL Server, es posible que encuentre que COUNT() La función produce un error, debido a que el número es demasiado alto. Esto solo sucederá si su conteo es mayor a 2,147,483,647.
En tales casos, puede usar COUNT_BIG() , que puede atender números mucho más grandes.
Vea cómo COUNT_BIG() Funciona en SQL Server y COUNT() frente a COUNT_BIG() para una explicación más detallada.
Estándar ANSI SQL
El COUNT() La función se enumera en el estándar SQL y está disponible en la mayoría (si no en todos) de los principales DBMS, y funciona prácticamente igual en todos ellos.
Para ver ejemplos de código realizados en varios DBMS, consulte SQLite COUNT() , Servidor SQL COUNT() y MySQL COUNT() .
