ORDER BY y HAVING

Hago este aporte a la comunidad, es un mapa mental con el resumen de las 35 clases anteriores y esta incluida

Se me ocurrió que se puede evitar el uso de having con una subconsulta:

En SQL SERVER no funciona el LIMIT, en su lugar use el TOP

Note:
ORDER BY : va a ordenar la consulta en el orden que ti lo determines , puedes utilizar como herramientas

• <>** para determinar que los datos serán discriminados de mayor o menor a que
• ASC para indicar si el orden según la discriminación sera ascendente
• DESC para indicar si el orden según la discriminación sera descendente
• LIMIT esta herramienta apoyada con ASC o DESC nos indicara segun el valor que le asignemos, que datos nos datos nos arrojara dentro de esas especificaciones
• HAVING en este caso lo utilizamos para seleccionar las tuplas asignadas

Encadenar consultas con HAVING

SELECT MONTHNAME(fecha_publicacion) AS mes, estatus, COUNT(*) AS cantidad
FROM posts
GROUP BY estatus, mes
HAVING cantidad > 1 AND mes IN ('December', 'May') ;

En la universidad siempre tenía problemas para ordenar de manera adecuada mis vistas y mis select, porque no tenia idea de que primero se hacen las agrupaciones y los conteos, después el filtrado por HAVING y al final el ordenamiento. Me frustraba muchísimo que mi profesora nunca pudo resolverme esa duda y tenia que encontrar otros métodos para solucionar algo tan fácil como usar HAVING. Dios, es hermoso.

• El orden inicial en una tabla es acorde a como fueron creados los datos.
• El default de la sentencia ORDER BY es ascendente.
• LIMIT es un complemento al ORDER BY y funciona similar a un filtro.
• Cuando se desea hacer una selección de rows, se hace con WHERE, pero cuando se desea hacer una selección de rows agrupados debe hacerse con HAVING.
• El orden de ejecución de los comandos es importante. Ejemplo: HAVING va después de GROUP BY, no puede ir después de ORDER BY porque lanza error de syntaxis.

Buenas, les dejo un link con una hoja de Excel con todos los queries que hemos visto hasta ahora en el curso con la descripcion de cada uno, espero que sea de utilidad a la comunidad.
Saludos!

https://docs.google.com/spreadsheets/d/1_LIvLPnMTLNqfgarnR1XbXUjs4RTiV9tHARLpvAp8C0/edit?usp=sharing

ORDER BY

Tiene que ver con el ordenamiento de los datos dependiendo de los criterios que quieras usar.

ASC: sirve para ordenar de forma ascendente.
DESC: sirve para ordenar de forma descendente.
LIMIT: se usa para limitar la cantidad de resultados que arroja el query.

Ejemplos:
SQL interpreta el orden de manera ascendente aunque no se lo mencionemos; para poder ASC. O DESC. Solo basta con colocarlo al final del query.
Limit solo basta con colocar el número (Cantidad) después de la sentencia.
.
SELECT *
FROM posts
ORDER BY fecha_publicacion DESC
LIMIT 5;
.

HAVING

Tiene una similitud muy grande con WHERE, sin embargo el uso de ellos depende del orden. El filtro como WHERE lo utilizaremos cuando queremos hacer una selección de tuplas; pero si lo que queremos es selecicionar una selección de tuplas agrupados, el mismo no puede ir antes de la agrupación. Cuando se quiere seleccionar tuplas agrupadas únicamente se puede hacer con HAVING.
.
Ejemplos:
SELECT MONTHNAME(fecha_publicacion) AS post_month, estatus, COUNT(*) AS post_quantity
FROM posts
GROUP BY estatus, post_month
HAVING post_quantity > 1
ORDER BY post_month;

Ya que llegaron al uso de ORDER BY y HAVING puedo compartirles mi conocimiento acerca del uso de Álgebra Relacional y SQL.

Algebra Relacional
Relación matemática de conjunto de tuplas, opera sobre las relaciones, conjuntos, el resultado de cualquier operación es otra relación. Existen dos tipos de operaciones.
a) Operaciones tradicionales sobre conjuntos. (U,Ո,-,x)
Dadas dos relaciones R y S:
R U S: Retorna una relación con las tuplas que están en R o S o en ambas.
R Ո S: Devuelve una relacion con las tuplas que estan en R y S.
R - S: Es una relación con las tuplas que están en R pero no en S y viceversa.
R x S: Este operador devuelve una relación con las tuplas de Rn x Sn. r(a1,a2,…,an) s(b1,b2,…,bn) entonces r x s (a1,a2,…,an,b1,b2,…,bn)

b) Operaciones especiales del Algebra Relacional.
*PROYECCIÓN: Permite proyectar atributos de una relación.
PROJECT, π(phi)
Sintaxis --> π<Lista de atributos de R> ®
*SELECCIÓN: Es un operador que permite seleccionar tuplas de una relación R, si cumple una condición.
SELECTION, SELECT, σ (sigma)
Sintaxis --> σ<condición> ®
<atributo>
<operacion>
<constante>
*Join: Permite hacer la concatenación de tuplas o vinculo atravez de las claves externas entre dos o mas relaciones.
Permite la concatenación de tuplas de diferentes relaciones de acuerdo a una condición.
Sintaxis --> JOIN, R ►◄ <condición> S

También existe el Join natural: Los atributos que participan en la condición tienen el mismo nombre. Eficiente para eliminar las columnas duplicadas.
R * S

FUNCIONES AGREGADAS Y DE AGRUPACIÓN.
CUENTA: Retorna el número de tuplas.
SUMA: Retorna la suma de los valores de la lista.
PROMEDIO(PROM): Devuelve el promedio de una lista de valores.
MIN: Devuelve el valor mínimo de una lista de valores.
MAX: Retorna el valor máximo de una lista de valores.

Para aplicar una funcion se utiliza la letra:
Û (f gotica) Sintaxis --> <atri,agr> Û f1a1. f2a2 ®

Ahora un ejercicio de examen resuelto con Álgebra relacional y SQL. (Imagenes)

SI QUIEREN GANAR UN MES GRATIS —> https://platzi.com/c/Skillparty
Me ayudarian bastante al compartir el link, gracias y a seguir aprendiendo.

#NuncaParesDeAprender

ORDER BY y HAVING
’

• ORDER BY sino se coloca criterio de ordenación, por defecto se ordenará de forma ascendente.

• HAVING nos ayuda a filtrar los campos dinámicos que se hallan creado, como por ejemplo para contar o sumar.

-- Ordenar los posts por el campo fecha_publicacion de forma ascendente.
Select * From posts 
Order By fecha_publicacion Asc;

-- Ordenar los posts por el campo fecha_publicacion de forma descendente.
Select * From posts 
Order By fecha_publicacion Desc;


-- Ordenar los posts por el campo fecha_publicacion de forma ascendente.
Select * From posts 
Order By fecha_publicacion;

-- Mostrar los primeros cinco posts que resulten de la consulta.
Select * From posts 
Order By fecha_publicacion Asc
Limit 5;

-- Ordenar los posts por el campo Usuario_Id de forma ascendente, exceptuando los valores nulos.
Select * From posts 
Where Usuario_Id Is Not Null 
Order By Usuario_Id Asc;

-- Ordenar los posts por el campo Usuario_Id de forma ascendente, exceptuando los valores nulos y que su Id esten entre 60 y 70.
Select * From posts Where 
Usuario_Id Is Not Null 
and Id Between 60 and 70
Order By Usuario_Id Asc;

-- Agrupar por estatus y mes. Contar los posts y mostrar los que se han mayores a uno. Finalmente se debe ornear por mes.
Select MonthName(fecha_publicacion) As Mes, status, Count(*) As Cant
From posts Group By status, Mes
Having Cant > 1
Order By Mes;

-- Agrupar por Año y mes. Contar los posts y mostrar los que sean mayores a uno. Finalmente se debe ornear por Año.
Select Year(fecha_publicacion) As Año, MonthName(fecha_publicacion) As Mes, status, Count(*) As Cant
From posts Group By Año, Mes
Having Cant > 1
Order By Año;

Faltó el operador OFFSET

SELECT * FROM artists LIMIT 5 OFFSET [Number of rows to skip];

Por ejemplo, digamos que quieres obtener 5 artistas de una tabla, pero no los primeros 5. Quieres obtener de las filas 5 a 8. Por lo tanto debes añadir un OFFSET de 2 para saltar las primeras dos filas.

SELECT * FROM artists LIMIT 5 OFFSET 2;

Puede llegar a ser muy útil para hacer paginación.

Limit and Offset

El HAVING es muy importante, recuerdo cuando lo conocí porque mi sentencia SQL no funcionaba xD Algo curioso es que dentro del HAVING tambien puedes poner subqueries con SELECT, de hecho, puedes poner subqueries en una query y también funcionará!

Puedes ver todas las tablas de tu DB:

SHOW FULL TABLES FROM platziblog;

Aquí dejo una consulta, realmente interesante, ya que me lista un resumen de actores por categoría, lo interesante que pude filtrarlo por numero de actores.

Espero sus comentarios.

La sentencia HAVING se usa para condicionar resultados, después de haberlos agrupado y totalizado.

A este punto no sé si se hayan dado cuenta de que las consultas tienen un orden. Una consultas generica contiene:
SELECT
FROM
WHERE
GROUP BY
HAVING
ORDER BY
LIMIT
OFFSET.
Si la consulta que queremos realizar no tiene alguna de esas palabras simplemente la quitamos pero respetando el orden establecido.

Especifica una condición de selección para un grupo. HAVING se usa normalmente con el GROUP BY. Cuando no está con el GROUP BY, HAVING se comporta como la cláusula WHERE, aunque esto es erróneo utilizarlo, puesto que ralentiza el sistema.

Para practicar

Yo les recomiendo https://www.sololearn.com/Leaderboard/SQL
e encontrado muy pocas plataforma que me ayuden a practicar lo visto. Si alguien sabe de alguna mucho mejor me encantaria leerlos 😃

Recomiendo a 1000 este artículo. Si no tienes realmente en claro la diferencia entre el WHERE y el HAVING esto te la va a aclarar.

Entonces, para valores agregados usamos HAVING.
Para valores de una tabla ya existente, WHERE.

¿Por qué? Por el órden de ejecución de las instrucciones.

Apuntes:
A través de ORDER BY podemos ordenar nuestras consultas mediante criterios que podemos asignar mediante esta sentencia. Con la palabra reservada ASC, podemos ordenar nuestra consulta de manera ascendente, y a través de la palabra reservada DESC, podemos ordenar la misma de forma descendente. Ambas sentencias funcionan de manera similar tanto para letras como para números, en el caso de las letras, si es de forma ascendente, las letras iran por orden alfabetico de la A a la Z.

HAVING nos permite hacer lo similar a un WHERE, a diferencia de que WHERE no es posible usarlo cuando estamos haciendo consultas con agrupaciones, cosa que si se puede hacer con HAVING.

Nota:
HAVING: Sirve para filtrar columnas después de hacer agrupaciones o cuando hay datos agrupados, pero debe de declararse antes de Order By

Ejemplo:

SELECT monthname(posts.fecha_publicacion) AS post_month, estatus, COUNT(*) AS post_quantity FROM posts GROUP BY estatus, post_month having post_quantity > 2 ORDER BY post_month

ASC. Se utiliza para ordenar de forma ascendente.

DESC. Se utiliza para ordenar de forma descendente.

LIMIT. Sirve para limitar las rows que agrupamos.

HAVING. Es muy similar a WHERE. Sirve para filtrar campos dinámicos que agrupamos previamente.

Les recomiendo este sitio para que practiquen lo visto hasta ahora en SQL. Aunque también se encontrarán con otras funciones interesantes y útiles.

https://www.sql-practice.com/

Comparto una cheat sheet de MySQL 8.0 que me ha servido mucho para orientarme de forma ágil cuando tengo una duda, la tengo impresa en un banner a la vista en mi espacio de trabajo para familiarizarme con los comandos.
Descargar imagen

Click en la imagen para mas info!

SELECT usuarios.nickname , count(*) AS posts_per_user 
FROM posts INNER JOIN usuarios ON posts.usuario_id=usuarios.id 
GROUP BY usuarios.nickname;

COMANDOS USADOS EN LA CLASE
SELECT *
FROM posts
ORDER BY fecha_publicacion ASC
;

SELECT *
FROM posts
ORDER BY fecha_publicacion DESC
;

SELECT *
FROM posts
ORDER BY titulo ASC
;

SELECT *
FROM posts
ORDER BY titulo DESC
;

SELECT *
FROM posts
ORDER BY usuario_id ASC
;

SELECT *
FROM posts
ORDER BY fecha_publicacion ASC
LIMIT 5
;

SELECT MONTHNAME(fecha_publicacion) AS post_month, estatus, COUNT(*) AS post_quantity
FROM posts
GROUP BY estatus, post_month
HAVING post_quantity > 4
ORDER BY post_month
;

select usuario_id, count(*) as total_users
from posts
where usuario_id is not null
group by usuario_id
having total_users > 4
order by total_users desc;```

Logré algo básico:

SELECT 
    *
FROM
    usuarios
        INNER JOIN
    posts ON usuarios.id = posts.usuario_id;```

😄 xD

El “ORDER BY ____” SIEMPRE tiene que ir al final de una consulta !

Excelente clase!
Tengo una duda no se si sea de Query o Php.
En mi proyecto tengo una base de datos de por ejemplo libros. Primero necesito extraer los libros que sean de un aturo que el cliente elija. Luego de estos libros extraídos, aplicarle una formula condicional a cada dato y si da positivo, mostrarlos en pantalla.
Alguien conoce un script que me pueda ayudar en ello?

Muestro el nombre del genero relacionado por el id a libros agrupando por estatus y género donde el total sea mayor a 1

Máximos 5 puntajes totales por videojuego para cada equipo

SELECT equipos.nombre AS equipo, SUM(puntajes.puntaje) AS puntaje, enfrentamientos.enfrentamiento_id AS "enfrentamiento_no.", videojuegos.nombre AS videojuego
FROM equipos
INNER JOIN puntajes ON equipos.equipo_id = puntajes.equipo_id
INNER JOIN enfrentamientos ON enfrentamientos.enfrentamiento_id = puntajes.enfrentamiento_id
INNER JOIN videojuegos ON enfrentamientos.videojuego_id = videojuegos.videojuego_id
GROUP BY equipo, videojuegos.nombre
ORDER BY puntaje DESC
LIMIT 5;

Al igual que en el GROUP BY, en el ORDER BY puedes ordenar por varios campos, bien sea indicando el nombre de su columna, el alias o el numero segun el orden en el SELECT

En el HAVING se puede usar tanto la funcion como el alias colocado a la funcion.

## ORDER BY
ORDER BY nos permite establecer criterios para ordenar los datos consultados. Implementemos esto en el ejemplo del blog ordenando los elementos por fecha de publicación de manera ascendente:

SELECT *
FROM schemaname.posts
ORDER BY post_date ASC;

Para ordenar de manera descendente, usaríamos la palabra DESC

Si queremos ordenar mediante criterios aplicados a cadenas de texto, podemos emplear la siguiente forma, que por default ordenará alfabéticamente (o numéricamente si es el caso):

SELECT *
FROM schemaname.posts
ORDER BY title ASC;

Podemos agregar un límite a nuestro ordenamiento mediante la sentencia LIMIT:

SELECT *
FROM schemaname.posts
ORDER BY post_date ASC
LIMIT 5;

HAVING tiene una similitud con WHERE, pero su diferencia radica en que los elementos que se agrupan, no se pueden filtrar mediante la sentencia WHERE, para eso se utiliza HAVING, ejemplo:

SELECT MONTHNAME(post_date) AS post_month, status, COUNT(*) AS post_quantity
FROM schemaname.posts
GROUP BY status, post_month
HAVING post_quantity > 1
ORDER BY post_month;

29. Mis apuntes sobre: "ORDER BY y HAVING"
El comando ORDER BY lo ordena de manera ascendete por default.
Ordena en base a valores numéricos o alfabéticos (dependiendo del tipo de dato).
WHERE selecciona los rows antes de hacer los AS, entonces, si quiere seleccionar tuplas
o rows agrupados, debo usar HAVING al final, antes del ORDER BY.

-1. Ejemplo de Código SQL Usando ORDER BY con ASC:

SELECT *
FROM posts
ORDER BY fecha_publicacion ASC;

Explicación 1: SELECT * <<mostrar todos los resultados>>
FROM posts <<de la tabla posts>>
ORDER BY fecha_publicacion ASC; <<ordenando los valores de manera ASCENDENTE en base al campo ‘fecha_publicacion’>>

-2. Ejemplo de Código SQL Usando ORDER BY con DESC:

SELECT *
FROM posts
ORDER BY fecha_publicacion DESC;

Explicación 2: SELECT * <<mostrar todos los resultados>>
FROM posts <<de la tabla posts>>
ORDER BY fecha_publicacion DESC; <<ordenando los valores de manera DESCENDENTE en base al campo ‘fecha_publicacion’>>

-3. Ejemplo de Código SQL Usando ORDER BY con ASC y LIMIT:

SELECT *
FROM posts
ORDER BY fecha_publicacion ASC
LIMIT 5;

Explicación 3: SELECT * <<mostrar todos los resultados>>
FROM posts <<de la tabla posts>>
ORDER BY fecha_publicacion DESC <<ordenando los valores de manera DESCENDENTE en base al campo ‘fecha_publicacion’>>
LIMIT 5; <<solo mostrar los 5 primeros resultados de la consulta>>

-4. Ejemplo de Código SQL

SELECT MONTHNAME(fecha_publicacion) AS post_month, estatus,
COUNT(*) AS post_quantity
FROM posts
GROUP BY estatus, post_month
HAVING post_quantity>1
ORDER BY post_month;

Explicación 4: SELECT MONTHNAME(fecha_publicacion) AS post_month, estatus, <<Extraer el nombre del mes del campo fecha_publicacion con el nombre post_month, y todos los datos de status>>
COUNT(*) AS post_quantity <<contar la cantidad de registros y poner el valor en un campo llamado post_quantity>>
FROM posts <<de la tabla posts>>
GROUP BY estatus, post_month; <<mostrarlos de manera agrupada en base al valor de los campos, estatus y post_month extraído del SELECT>>
HAVING post_quantity>1 <<mostrar solo las rows donde post_quantity sea mayor a 1>>
ORDER BY post_month; <<ordenar los datos en base al valor que tenga post_month>>

HAVING es super cool!!!

tengo un proyecto para una sala de cine estoy realizando el diagrama de entidad relacion para realizar consultas modificaciones y normalizacion de bases de datos

Notas de clase:

WHERE: filtra los datos antes de la agrupación,
HAVING: filtra una vez los datos están agrupados.

Limit depende del manejador de base de datos, mysql y posgrest, Rowcount en sql server.

Básicamente, HAVING es un WHERE que se utiliza en columnas agrupadas.

El uso de having sería como un where aplicado al grupo

HAVING: para selección de rows agrupados después de un GROUP BY

Estos son algunos de los querys que se me han ocurrido para mi proyecto:

Este query lo que hace es traerme todos los pedidos que tuve, con sus datos de costos. y me los filtra por por meses.

SELECT pedidos.id, titulo, costo,url_img,cantidad_productos_vendidos,precio_venta,costos_envio,costos_comisiones,utilidad,fecha,id_compania,comisiones.porcentaje,utilidad_comision, clientes.nombre, clientes.telefono,clientes.email
FROM pedidos
INNER JOIN productos ON productos.id = pedidos.id_producto
	JOIN comisiones ON comisiones.id= pedidos.id_comision
	JOIN clientes ON clientes.id = pedidos.id_cliente
HAVING fecha BETWEEN '2019-01-01' AND '2019-06-01'
ORDER BY fecha
;

Este es un poco más específico al otro, este me trae el nombre del articulo y la cantidad que se vendieron entre tal fecha.

SELECT productos.titulo, productos.costo, SUM(pedidos.cantidad_productos_vendidos) AS vendidos,fecha
FROM pedidos
INNER JOIN productos ON productos.id = pedidos.id_producto
GROUP BY titulo
HAVING  fecha BETWEEN '2019-01-01' AND '2019-06-01'
;

Tengo algunas dudas pero estan algo extensas para explicar por texto, si llego a encontrar la solución la pondré en la respuesta a este comentario.

Muy buen curso, anteriormente usaba querys muy básicos desde PHP, pero ahora puedo agregarle nuevas características a mi aplicación web.

NO PARAMOS. ME ENCANTA

Estos son las sentencias que hemos usado desde la primera clase hasta ahora, aquí les dejo mores.

/Traer datos de tabla posts/

SELECT * FROM posts;

/Traer ciertos datos y dar alias a las tablas/

SELECT titulo AS Encabezado, fecha_publicacion AS Publicado_en FROM posts;

/Contar cuantos posts existen/

SELECT COUNT(*) AS numero_posts FROM posts;

/LEFT JOIN QUE NOS TRAERA TODOS LOS USUARIOS ASI TENGAN O NO TENGAN POSTS/

SELECT * FROM usuarios LEFT JOIN posts ON usuarios.id = posts.usuario_id;

/LEFT JOIN QUE NOS TRAERA TODOS LOS USUARIOS QUE NO TENGAN POSTS/

SELECT * FROM usuarios LEFT JOIN posts ON usuarios.id = posts.usuario_id WHERE posts.usuario_id IS NULL;

/RIGHT JOIN QUE NOS TRAERA TODOS LOS POSTS ASI TENGAN O NO TENGAN USUARIOS ASOCIADOS/

SELECT * FROM usuarios RIGHT JOIN posts ON usuarios.id = posts.usuario_id;

/RIGHT JOIN QUE NOS TRAERA TODOS LOS POSTS QUE NO TENGAN USUARIOS ASOCIADOS/

SELECT * FROM usuarios RIGHT JOIN posts ON usuarios.id = posts.usuario_id WHERE posts.usuario_id IS NULL;

/INNER JOIN Ó JOIN QUE NOS TRAERA TODOS LOS USUARIOS QUE TENGAN POSTS ASOCIADOS/

SELECT * FROM usuarios JOIN posts ON usuarios.id = posts.usuario_id;

/FORMA DE SIMULAR UN FULL JOIN EL CUAL TRAERA TODA LA INFORMACION DE AMBAS TABLAS/

SELECT * FROM usuarios LEFT JOIN posts ON usuarios.id = posts.usuario_id UNION SELECT * FROM usuarios RIGHT JOIN posts ON usuarios.id = posts.usuario_id;

/FORMA DE SIMULAR UN FULL JOIN EL CUAL TRAERA TODA LA INFORMACION QUE TENGA LA PRIMERA TABLA Y LA OTRA NO Y VICEVERSA/

SELECT * FROM usuarios LEFT JOIN posts ON usuarios.id = posts.usuario_id WHERE posts.usuario_id IS NULL UNION SELECT * FROM usuarios RIGHT JOIN posts ON usuarios.id = posts.usuario_id WHERE posts.usuario_id IS NULL;

/** TRAER DATOS CON EL MENOR **/

SELECT * FROM posts WHERE id <= 50;

/** TRAER EL STATUS ACTIVO O INACTIVO **/

SELECT * FROM posts WHERE estatus = 'activo';

/** TRAER DATOS CON EL DIFERENTE **/

SELECT * FROM posts WHERE estatus != 'activo';

/** TRAER DATOS CON LA SENTENCIA LIKE LA CUAL NOS PERMITE USAR UNA ESPECIE DE FILTRO **/

SELECT * FROM posts WHERE titulo LIKE '%escandalo%';

/** TRAER DATOS USANDO OPERADOR MAYOR O MENOR QUE CON LAS FECHAS **/

SELECT * FROM posts WHERE fecha_publicacion < '2025-01-01';

/** TRAER DATOS USANDO LA SENTENCIA BETWEEN CON FECHAS **/

SELECT * FROM posts WHERE fecha_publicacion BETWEEN '2023-01-01' AND '2025-12-31';

/** TRAER DATOS CON LA SENTENCIA YEAR() **/

SELECT * FROM posts WHERE YEAR(fecha_publicacion) BETWEEN '2023' AND '2024';

/** TRAER DATOS CON LA SENTENCIA MONTH() **/

SELECT * FROM posts WHERE MONTH(fecha_publicacion) = '04';

/** TRAER LOS DATOS NULOS **/

SELECT * FROM posts WHERE usuario_id IS NULL;

/** TRAER LOS DATOS QUE NO SEAN NULOS Y AGREGAR CONDICIONES A ESO **/

SELECT * FROM posts WHERE usuario_id IS NOT NULL AND estatus = 'activo' AND id < 50 AND categoria_id = 2 AND YEAR(fecha_publicacion) = '2025';

/** SENTENCIA GROUP BY **/

SELECT estatus, COUNT(*) AS post_quantity FROM posts GROUP BY estatus;

SELECT estatus, MONTHNAME(fecha_publicacion) AS post_month, COUNT(*) AS post_quantity FROM POSTS GROUP BY post_month, estatus;

/** SENTENCIA HAVING LA CUAL NOS AYUDA A AGRUPAR CUANDO USAMOS HAVING**/

SELECT * FROM posts ORDER BY fecha_publicacion DESC;

SELECT * FROM posts ORDER BY titulo DESC;

SELECT * FROM posts ORDER BY fecha_publicacion LIMIT 5;

SELECT MONTHNAME(fecha_publicacion) AS post_month, estatus, COUNT(*) AS post_quantity FROM posts GROUP BY estatus, post_month HAVING post_quantity > 1 ORDER BY post_month;

comando de MONTHNAME para postgresql:

SELECT TO_CHAR(fecha_publicacion, 'Month') AS post_month, status, COUNT(*) AS post_quantity
FROM platziblog."Posts"
GROUP BY status, post_month
ORDER BY post_month;

Esta consulta fue la más compleja en su momento que me costó días hacerla (porque aún no tenía el conocimiento suficiente en base de datos o SQL, actualmente parece un chiste):

SELECT 
	public.factura.cantidad AS stock, registro_producto.codigo AS codigo, registro_producto.producto AS producto, registro_producto.valor_unidad AS valor_unidad, factura.subtotal AS subtotal 

FROM 
	public.factura, public.registro_producto, public.registro_usuario 

WHERE 
	factura.id_registro_producto = registro_producto.id 
AND factura.fecha_venta = '"+txf_fechaVenta.getText()+"' 
AND registro_usuario.cedula = '"+txf_cedula.getText()+"'
;

Saludos desde Ecuador ❤️ un Full Stack en proceso.

buenos dias, se me ocurrio hacer una busqueda de post filtrando por usuario y año

SELECT estatus, titulo, MONTHNAME(fecha_publicacion) as mes,YEAR(fecha_publicacion) as año, count(*) as cantidad_post
FROM usuarios
	LEFT JOIN post ON usuarios.id = post.usuario_id
where login = "monica"
group by mes, titulo, estatus, año
having año = 2023
order by titulo

SELECT monthname(fecha_publicacion) AS post_month, estatus, COUNT(*) AS post_quantity
FROM posts
GROUP BY estatus, post_month
HAVING post_quantity > 2
ORDER BY post_month;

Les comparto algunas consultas sobre la tabla de prueba sakila que está en el workbench de mySQL.

De la base de datos de sakila en MySQL consultar la siguiente información:

            - ¿ Los nombres de los actores que trabajaron en cada  película?

                SELECT title, actor.first_name, actor.last_name
                FROM film
                LEFT JOIN film_actor
                ON film.film_id = film_actor.film_id
                LEFT JOIN actor
                ON film_actor.actor_id = actor.actor_id

            - ¿ La cantidad de actores que tiene cada película?

                SELECT title, COUNT(*) cantidad_actores
                FROM film
                LEFT JOIN film_actor
                ON film.film_id = film_actor.film_id
                GROUP BY title
                ORDER BY cantidad_actores DESC

            - ¿ Los nombres de las películas en las que trabajo cada actor ?

                SELECT first_name, last_name, title
                FROM actor
                LEFT JOIN film_actor
                ON actor.actor_id = film_actor.actor_id
                LEFT JOIN film
                ON film.film_id = film_actor.film_id

            - ¿ la cantidad de películas en las que trabajó cada actor?

                SELECT  actor.first_name, actor.last_name, COUNT(*) cantidad_peliculas
                FROM actor
                LEFT JOIN film_actor
                ON actor.actor_id = film_actor.film_id
                GROUP BY actor. actor_id
                ORDER BY cantidad_peliculas DESC

            - ¿ Listar las películas dónde trabajó un actor en particular?

                SELECT first_name, last_name, title
                FROM actor
                LEFT JOIN film_actor
                ON actor.actor_id = film_actor.actor_id 
                LEFT JOIN film
                ON film.film_id = film_actor.film_id
                WHERE actor.actor_id = 1

En el caso de SQL Server el orden del procesamiento lógico de una query es distinto al de MySQL.
La princilap diferencia es que en SQL Server primero se ejecutan GROUP BY seguida de HAVING (en caso de que se incluyan) y justo despues se procesa la instrucción SELECT, por lo tanto un RDBS como SQL Server no es posible utilizar los alias de las columnas en el GROUP BY ni en HAVING por que el procesamiento aun no conoce dichos alias.

Adjunto diagrama con el procesamiento lógico de una query en SQL Server

Información tomada del libro “Inside Microsoft SQL Server 2008: T-SQL Querying”

En el uso se las sentencias GROUP BY y ORDER BY, puede utilizarse también en lugar del nombre de la columna la posición que esta ocupa en el Query. Así que la consulta quedaría así.

SELECT MONTHNAME(fecha_publicacion) AS post_month, estatus, COUNT(*) AS post_quantity
FROM posts
GROUP BY 2, 1
ORDER BY 1;

TENGO mi cinturon de herramientas pero muchas de ellas todavia se me olvidan en el garaje, tengo que seguir practicando para que no se me olviden mis herramientas

de la clase pasada queria intentar si podia hacer uso de join , para ver agregar el usuario , y si pude la satisfaccion es inexpresable un pequeño paso para devs , un gran paso para mi

<select estatus,login as name,monthname(fecha_publicacion) as post_month , count(*) as post_cuantity
from blog . posts
left join blog . usuarios on usuarios.id = usuario_id
group by login,estatus, post_month;> 

ORDEN DE EJECUCIÓN DE COMANDOS SQL
.

Por fin entiendo la diferencia entre Where y Having

solo como comentario el count es mucho mas rapido usando un count(1) en lugar del count() , usar el count() en base de datos mas grandes presenta problemas de rendimiento .

select *
from
where
group by
having
order by

Just beautiful

Tambien puedes filtrar de manera descendente con el signo menos (-) antes del nombre de la columna: Ejemplo -usuario_id

No se si soy el único, pero me siento super poderoso con las bases de datos con SQL.

Hola team Platzi 😄

Comparto avances de mi proyecto.

Posiblemente lo vea en próximas clases pero… me gustaría que en vez de ver el número id que le corresponde a la marca de guitarra, aparezca el nombre de la marca 😕

Lo que me ha gustado de SQL es que me parece casi lenguaje natural, es muy fácil de entender lo que se lee y por ende, fácil de escribir

WHERE filtra antes de que se agrupen los datos
HAVING se filtra luego de que se agrupen los datos

LIMIT #n: para traer los #n primero registros de la consulta

Entendido, buena explicacion

Having es muy útil para conocer datos que se encuentran duplicados y que no deberían estarlo!

Validé cuantas vacas hay por raza y mes de nacimiento.

SELECT monthname(F_NACIMIENTO) AS MES, RAZA_ID, COUNT(*) AS CANTIDAD
FROM VACA
GROUP BY MES, RAZA_ID
HAVING CANTIDAD >1
ORDER BY MES ASC
;

Muy bueno el HAVING, no lo conocía mucho

Gracias instructor hasta el momento el curso ha sido excelente, la forma de explicar es lo suficientemente clara, estoy muy contento de haber ingresado a Platzi.

Buena clase ya me queda mas claro la diferencia where y having

No conocia la utilidad del Having. Gracias

select estatus, monthname(fecha_publicacion) as post_month,
count(*) as post_quantity
from usuarios
left join posts on usuarios.id = posts.usuario_id
left join categorias on categoria_id = categorias.id
group by estatus, post_month
having post_quantity > 1
order by post_quantity desc
;

Mostramos Post que sean igual 1 con estatus inactivos y ordenados por mes.

Esta consulta en el proyecto que hago para la universidad donde estudio.

lo interesante esta en la funcion FIND_IN_SET()

SELECT CONCAT('#', DatosGrupoAC.clavePeriodo, DatosGrupoAC.claveAC, DatosGrupoAC.claveGrupoAC) clavePrimaria,
(CASE WHEN (SELECT COUNT(numeroControl) FROM DatosListaACActual WHERE 
	clavePeriodo=(SELECT clavePeriodoActual FROM DatosGeneralesAC) 
	AND DatosListaACActual.claveAC=DatosGrupoAC.claveAC AND DatosListaACActual.claveGrupoAC=DatosGrupoAC.claveGrupoAC
	AND numeroControl='15371172')>0 THEN TRUE ELSE FALSE END) elegido,
(SELECT COUNT(numeroControl) FROM DatosListaACActual 
	WHERE DatosListaACActual.clavePeriodo=DatosGrupoAC.clavePeriodo
	AND DatosListaACActual.claveAC=DatosGrupoAC.claveAC
	AND DatosListaACActual.claveGrupoAC=DatosGrupoAC.claveGrupoAC) inscritos
FROM DatosGrupoAC, DatosAC 
WHERE 
DatosGrupoAC.claveAC=DatosAC.claveAC 
AND FIND_IN_SET(18, carrerasPermitidas) 
AND clavePeriodo=(SELECT clavePeriodoActual FROM DatosGeneralesAC)
AND claveFundamento=2

Exc Clase!

Ejemplo del HAVING

HAVING tiene una similitud muy grande con WHERE, sin embargo el uso de ellos depende del orden. Cuando se quiere seleccionar tuplas agrupadas únicamente se puede hacer con HAVING.

hola, en mi esperiencia personal me he demorado un poco mas de lo esperado en aprender por qur literalmente no tenia ningun conocimiento de base d datos y apesar de que estudio ing_sofware, al realizar los cursos de platzi me di cuenta que no sabia nada,el camino es largo pero voy dando un paso a la ves

Que bien, aprendimos a ordenar tanto de manera ascendente como descendente los registro, y ahora tengo más claro la diferencia que existen entre el WHERE y el HAVING, sería algo como ¿Qué condiciones quiere que cumpla los registros después de usar el GROUP BY? en el caso del HAVING.
Ahora, como una de las consultas locas de mi proyecto tengo esta, determine los artículos con un valor mayor a 2000 que tengan la etiqueta Enlatados y muéstrelos de forma descendente en base al Id del artículo, este es el código:

SELECT tbArti.Nombre_articulo, tbArti.Valor_articulo, tbEtiq.Nombre_etiqueta
FROM  articulos tbArti
INNER JOIN etiquetas tbEtiq ON tbArti.Id_etiqueta = tbEtiq.Id_etiqueta
WHERE tbArti.Valor_articulo >2000 AND tbEtiq.Nombre_etiqueta = 'Enlatados'
ORDER By tbArti.Id_articulo DESC

Aquí les dejo un script experimentando con ORDER BY y JOIN para ver los posts ordenados por mes y estado, mostrando también la categoría. Espero sugerencias:

La sentencia ORDER BY tiene que ver con el ordenamiento de los datos dependiendo de los criterios que quieras usar.

ASC sirve para ordenar de forma ascendente.
DESC sirve para ordenar de forma descendente.
LIMIT se usa para limitar la cantidad de resultados que arroja el query.

mostrando los usuarios y el mes que hicieron posts

select usuario_id as usuario, count(*) as posts, monthname(fecha_publicacion) as mes
from posts
group  by mes
having usuario is not null
order by usuario, posts DESC;```

Mi reto principal ha sido a la hora de ingresar datos con números, no me ha tomado decimales o un número me queda tipo 0000000001. Es un tema que tengo que investigar para que la base de datos quede estéticamente mejor.
El resto de cosas super claras la verdad 😄

frase celebre: “esas son las ventajas de un editor visual” XD

Pues no usé los order by ni having aún pero hasta el momento ha sido este:

SELECT nombre_banco, count(*) as card_emitted
FROM bancos
INNER JOIN (tipos_tarjetas inner join tarjetas on tipos_tarjetas.id_tipostarjetas = tarjetas.id_tipotarjeta)
on bancos.id_banco = tarjetas.id_banco
group by nombre_banco;

SELECT city.city, country.country, address.address, district, COUNT(address.address) AS direcciones_por_country FROM city
INNER JOIN country
ON city.country_id = country.country_id
RIGHT JOIN address
ON address.city_id = city.city_id
GROUP BY country.country
HAVING direcciones_por_country > 5

Agrupando las direcciones por barrios y filtrandolos cuales tengan mas de 5.

La selección de tuplas agrupadas no se puede hacer con WHERE, debe utilizarse el HAVING…

-- Es la Conulta mas Local que se me ocurrio
SELECT NICKNAME, YEAR(FECHA_PUBLICACION) AS AÑO, TITULO, COUNT(*) AS 'CANTIDAD POR AÑO' 
FROM USUARIOS
INNER JOIN posts ON USUARIOS.ID  = POSTS.USUARIO_ID
group by NICKNAME
having TITULO LIKE '%mejores%'
ORDER BY AÑO ASC;```

Muy interesante lo de having, nunca lo habia ocupado

buena clase

Muy interesante la diferencia entre WHERE y HAVING

SELECT posts.id, posts.titulo, posts.fecha_publicacion, posts.estatus, usuarios.nickname
FROM posts inner join usuarios on posts.usuario_id = usuarios.id
ORDER BY posts.fecha_publicacion
LIMIT 5
;

Que tal este querie? En anteriores clases viene esta cadena correspondiente a mi proyecto personal.:

SELECT nombre AS Nombre, deuda AS Deuda, telefono AS Telefono
FROM cliente
RIGHT JOIN trabajo ON cliente.id_cliente=trabajo.id_cliente
GROUP BY fecha_entre
ORDER BY fecha_entre DESC;