DONDE vs TENER

Todas las respuestas no alcanzaron el punto clave.

Supongamos que tenemos una tabla:

CREATE TABLE `table` (
 `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
 `value` int(10) unsigned NOT NULL,
 PRIMARY KEY (`id`),
 KEY `value` (`value`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

Y tener 10 filas con id y valor de 1 a 10:

INSERT INTO `table`(`id`, `value`) VALUES (1, 1),(2, 2),(3, 3),(4, 4),(5, 5),(6, 6),(7, 7),(8, 8),(9, 9),(10, 10);

Pruebe las siguientes 2 consultas:

SELECT `value` v FROM `table` WHERE `value`>5; -- Get 5 rows
SELECT `value` v FROM `table` HAVING `value`>5; -- Get 5 rows

Obtendrá exactamente los mismos resultados, puede ver que la cláusula HAVING puede funcionar sin la cláusula GROUP BY.

Aquí está la diferencia:

SELECT `value` v FROM `table` WHERE `v`>5;

Error #1054-Columna desconocida 'v' en 'cláusula where'

SELECT `value` v FROM `table` HAVING `v`>5; -- Get 5 rows

DONDE la cláusula requiere que una condición sea una columna en una tabla, pero teniendo cláusula puede usar columna o alias.

Esto se debe a que la cláusula WHERE filtra los datos antes de seleccionar, pero la cláusula HAVING filtra los datos después de seleccionar.

Así que pon las condiciones en la cláusula WHERE será más eficiente si tienes muchas filas en una tabla.

Intenta EXPLICAR para ver la diferencia clave:

EXPLAIN SELECT `value` v FROM `table` WHERE `value`>5;
+----+-------------+-------+-------+---------------+-------+---------+------+------+--------------------------+
| id | select_type | table | type  | possible_keys | key   | key_len | ref  | rows | Extra                    |
+----+-------------+-------+-------+---------------+-------+---------+------+------+--------------------------+
|  1 | SIMPLE      | table | range | value         | value | 4       | NULL |    5 | Using where; Using index |
+----+-------------+-------+-------+---------------+-------+---------+------+------+--------------------------+

EXPLAIN SELECT `value` v FROM `table` having `value`>5;
+----+-------------+-------+-------+---------------+-------+---------+------+------+-------------+
| id | select_type | table | type  | possible_keys | key   | key_len | ref  | rows | Extra       |
+----+-------------+-------+-------+---------------+-------+---------+------+------+-------------+
|  1 | SIMPLE      | table | index | NULL          | value | 4       | NULL |   10 | Using index |
+----+-------------+-------+-------+---------------+-------+---------+------+------+-------------+

Puede ver DÓNDE o TENER índice de usos, pero las filas son diferentes.

La principal diferencia es que WHERE no se puede usar en elementos agrupados (como SUM(number)), mientras que HAVING sí.

La razón es que WHERE se hace antes de el agrupamiento y HAVING se hace después de se hace el agrupamiento.

HAVING se utiliza para filtrar las agregaciones en su GROUP BY.

Por ejemplo, para buscar nombres duplicados:

SELECT Name FROM Usernames
GROUP BY Name
HAVING COUNT(*) > 1

Estos 2 se sentirán igual que los primeros, ya que ambos se usan para decir sobre una condición para filtrar datos. Aunque podemos usar 'having' en lugar de' where 'en cualquier caso, hay casos en los que no podemos usar' where 'en lugar de'having'. Esto se debe a que en una consulta select,' where 'filtra los datos antes de 'select' mientras que' having 'filtra los datos después de'select'. Por lo tanto, cuando usamos nombres de alias que no están realmente en la base de datos, 'where' no puede identificarlos, pero 'having' sí.

Ex: deje que el estudiante de la tabla contiene student_id, nombre, fecha de nacimiento, dirección.Supongamos que birthday es de tipo date.

SELECT * FROM Student WHERE YEAR(birthday)>1993; /*this will work as birthday is in database.if we use having in place of where too this will work*/

SELECT student_id,(YEAR(CurDate())-YEAR(birthday)) AS Age FROM Student HAVING Age>20; 
/*this will not work if we use ‘where’ here, ‘where’ don’t know about age as age is defined in select part.*/

DONDE filtra antes de agrupar los datos, y TIENE filtra después de agrupar los datos. Esta es una distinción importante; filas que son eliminado por un DONDE la cláusula no se incluirá en el grupo. Este podría cambiar los valores calculados que a su vez podría afectar a que los grupos se filtran en función del uso de esos valores en el QUE TIENE clausula.

Extracto De: Forta, Ben. "Sams Teach Yourself SQL in 10 Minutes (4th Edición) (Sams Teach Yourself...).".

Having solo se usa con agregación pero donde con declaraciones sin agregación Si tiene donde word lo puso antes de la agregación (group by)

• Una DONDE se usa la cláusula es filtrar registros de un resultado. El el filtro se produce antes de realizar cualquier agrupación.

• Una cláusula QUE TIENE se usa para filtrar valores de un grupo. Antes de que vamos a revisar el formato de una sentencia SQL. Es

  SELECCIONE SalesOrderID, SUM (UnitPrice * OrderQty) AS totalPrice DE Ventas.SalesOrderDetail DONDE LineTotal > 100 GRUPO POR SalesOrderID TENIENDO SUMA (UnitPrice * OrderQty) > 10000

El punto clave, que también es la principal diferencia entre WHERE y HAVING clause en SQL es que, la condición especificada en WHERE clause se usa mientras se obtienen datos (filas) de la tabla, y los datos que no pasan la condición no se recuperarán en el conjunto de resultados, por otro lado HAVING clause se usa más tarde para filtrar datos resumidos o datos agrupados.

En resumen si ambos DONDE y QUE TIENEN la cláusula se usa en una consulta SELECT con función aggregate o AGRUPAR POR cláusula, se ejecutará antes de TENER cláusula.